Jak rozwiązać błąd java.lang.NoClassDefFoundError: javax / xml / bind / JAXBException w Javie 9

Mam kod, który używa klas API JAXB, które zostały dostarczone jako część JDK w Javie 6/7/8. Gdy uruchamiam ten sam kod z Javą 9, w czasie wykonywania pojawiają się błędy wskazujące, że nie można znaleźć klas JAXB.

Klasy JAXB są dostarczane jako część JDK od Java 6, więc dlaczego Java 9 nie może już znaleźć tych klas?

Interfejsy API JAXB są uważane za interfejsy API Java EE i dlatego nie są już zawarte w domyślnej ścieżce klas w Java SE 9. W Javie 11 są one całkowicie usuwane z JDK.

Java 9 wprowadza koncepcje modułów i domyślnie java.semoduł agregujący jest dostępny na ścieżce klasy (a raczej ścieżce modułu). Jak sama nazwa wskazuje, java.semoduł agregujący nie zawiera interfejsów API Java EE, które były tradycyjnie pakowane w Javę 6/7/8.

Na szczęście te interfejsy API Java EE, które zostały udostępnione w JDK 6/7/8, nadal znajdują się w JDK, ale domyślnie nie znajdują się w ścieżce klas. Dodatkowe interfejsy API Java EE znajdują się w następujących modułach:

java.activation
java.corba
java.transaction
java.xml.bind  << This one contains the JAXB APIs
java.xml.ws
java.xml.ws.annotation

Szybkie i brudne rozwiązanie: (tylko JDK 9/10)

Aby interfejsy API JAXB były dostępne w czasie wykonywania, określ następującą opcję wiersza polecenia:

--add-modules java.xml.bind

Ale nadal potrzebuję tego do pracy z Javą 8 !!!

Jeśli spróbujesz podać --add-modulesstarszy JDK, zostanie on wysadzony, ponieważ jest to nierozpoznana opcja. Proponuję jedną z dwóch opcji:

1. Możesz ustawić dowolne opcje tylko Java 9+, używając JDK_JAVA_OPTIONSzmiennej środowiskowej. Ta zmienna środowiskowa jest automatycznie odczytywana przez program javauruchamiający dla Java 9+.
2. Możesz dodać, -XX:+IgnoreUnrecognizedVMOptionsaby JVM dyskretnie ignorował nierozpoznane opcje, zamiast wysadzać w powietrze. Ale strzeż się! Wszelkie inne argumenty wiersza polecenia, których użyjesz, nie będą już dla ciebie sprawdzane przez JVM. Ta opcja działa z Oracle / OpenJDK oraz IBM JDK (od JDK 8sr4).

Alternatywne szybkie rozwiązanie: (tylko JDK 9/10)

Pamiętaj, że możesz udostępnić wszystkie powyższe moduły Java EE w czasie wykonywania, określając tę --add-modules java.se.eeopcję. java.se.eeModuł jest modułem, który zawiera kruszywa java.se.ee, jak również wyżej wymienionych modułów Java EE API. Uwaga: nie działa to w Javie 11, ponieważ java.se.eezostała usunięta w Javie 11.

Właściwe rozwiązanie długoterminowe: (JDK 9 i nowsze)

Wszystkie wymienione wyżej moduły API Java EE są oznaczone, @Deprecated(forRemoval=true)ponieważ ich usunięcie zaplanowano w Javie 11 . Dlatego --add-modulepodejście nie będzie już działać w Javie 11 od razu po wyjęciu z pudełka.

W języku Java 11 i nowszych wersjach należy umieścić własną kopię interfejsów API Java EE na ścieżce klasy lub ścieżce modułu. Na przykład możesz dodać interfejsy API JAX-B jako zależność Maven, taką jak ta:

<!-- API, java.xml.bind module -->
<dependency>
    <groupId>jakarta.xml.bind</groupId>
    <artifactId>jakarta.xml.bind-api</artifactId>
    <version>2.3.2</version>
</dependency>

<!-- Runtime, com.sun.xml.bind module -->
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>2.3.2</version>
</dependency>

Patrz strona Reference Implementation JAXB więcej szczegółów na JAXB.

Aby uzyskać szczegółowe informacje na temat modułowości Java, zobacz JEP 261: Moduł systemu

Dla programistów Gradle lub Android Studio: (JDK 9 i nowsze wersje)

Dodaj następujące zależności do build.gradlepliku:

dependencies {
    // JAX-B dependencies for JDK 9+
    implementation "jakarta.xml.bind:jakarta.xml.bind-api:2.3.2"
    implementation "org.glassfish.jaxb:jaxb-runtime:2.3.2"
}

W moim przypadku (słoik z grubym bootem) po prostu dodaję następujący tekst do pom.xml.

<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.1</version>
</dependency>

Żadne z tych rozwiązań nie działało dla mnie dobrze w ostatnim JDK 9.0.1.

Odkryłem, że ta lista zależności jest wystarczająca do prawidłowego funkcjonowania, więc nie trzeba jawnie określać --add-module(chociaż jest ona określona w pom pom tych zależności). Wystarczy tylko podać tę listę zależności:

<dependencies>
    <dependency>
        <groupId>javax.xml.bind</groupId>
        <artifactId>jaxb-api</artifactId>
        <version>2.3.0</version>
    </dependency>
    <dependency>
        <groupId>com.sun.xml.bind</groupId>
        <artifactId>jaxb-impl</artifactId>
        <version>2.3.0</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
        <version>2.3.0</version>
    </dependency>
    <dependency>
        <groupId>javax.activation</groupId>
        <artifactId>activation</artifactId>
        <version>1.1.1</version>
    </dependency>
</dependencies>

To działało dla mnie:

<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.0</version>
</dependency>
<dependency>
    <groupId>org.eclipse.persistence</groupId>
    <artifactId>eclipselink</artifactId>
    <version>2.7.0</version>
</dependency>

Aktualizacja

Jak sugerował @Jasper, aby uniknąć zależności od całej biblioteki EclipseLink, możesz także polegać na EclipseLink MOXy:

Maven

<dependency>
    <groupId>org.eclipse.persistence</groupId>
    <artifactId>org.eclipse.persistence.moxy</artifactId>
    <version>2.7.3</version>
</dependency>

Gradle

compile group: 'org.eclipse.persistence', name: 'org.eclipse.persistence.moxy', version: '2.7.3'

Jako zależności dla mojej aplikacji Java 8, która tworzy plik * .jar, który może być uruchamiany zarówno przez JRE 8, jak i JRE 9 bez dodatkowych argumentów.

Ponadto należy to gdzieś wykonać, zanim zostanie użyty interfejs API JAXB:

System.setProperty("javax.xml.bind.JAXBContextFactory", "org.eclipse.persistence.jaxb.JAXBContextFactory");

Jak dotąd działa świetnie jako obejście. Nie wygląda to jednak na idealne rozwiązanie ...

czyste rozwiązanie dla wszystkich JDK> = 9

Musisz dodać dwie zależności do swojej kompilacji

• jaxb-api
• implementacja jaxb

Jako implementację postanowiłem użyć implementacji referencyjnej przez glassfish, aby pozbyć się starych klas / bibliotek com.sun. W rezultacie dodałem w swojej wersji maven

<dependency>
  <groupId>javax.xml.bind</groupId>
  <artifactId>jaxb-api</artifactId>
  <version>2.3.1</version>
</dependency>

<dependency>
  <groupId>org.glassfish.jaxb</groupId>
  <artifactId>jaxb-runtime</artifactId>
  <version>2.3.1</version>
</dependency>

Zauważ, że od wersji 2.3.1 nie musisz już dodawać javax.activation. (patrz https://github.com/eclipse-ee4j/jaxb-ri/issues/1222 )

to dlatego, że wersja Java, jeśli używasz jdk 9 lub nowszej wersji, po prostu dodaj to do pom

<dependency>
  <groupId>javax.xml.bind</groupId>
  <artifactId>jaxb-api</artifactId>
  <version>2.3.0</version>
</dependency>

Aby rozwiązać ten problem, zaimportowałem niektóre pliki JAR w moim projekcie:

• javax.activation-1.2.0.jar

http://search.maven.org/remotecontent?filepath=com/sun/activation/javax.activation/1.2.0/javax.activation-1.2.0.jar

• jaxb-api-2.3.0.jar

http://search.maven.org/remotecontent?filepath=javax/xml/bind/jaxb-api/2.3.0/jaxb-api-2.3.0.jar

• jaxb-core-2.3.0.jar

http://search.maven.org/remotecontent?filepath=com/sun/xml/bind/jaxb-core/2.3.0/jaxb-core-2.3.0.jar

• jaxb-impl-2.3.0.jar

http://search.maven.org/remotecontent?filepath=com/sun/xml/bind/jaxb-impl/2.3.0/jaxb-impl-2.3.0.jar

1. Pobierz powyższe pliki i skopiuj je do folderu libs w projekcie
2. Dodaj importowane pliki JAR do Ścieżki kompilacji Java

W momencie kompilacji, a także w czasie wykonywania, dodaj przełącznik --add-modules java.xml.bind

javac --add-modules java.xml.bind <java file name>

java --add-modules java.xml.bind <class file>

Dobre wprowadzenie JDK 9modułów można również znaleźć na stronie : https://www.youtube.com/watch?v=KZfbRuvv5qc

To zadziałało dla mnie. Dodanie tylko jaxb-api nie wystarczyło.

        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>${jaxb-api.version}</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-impl</artifactId>
            <version>${jaxb-api.version}</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-core</artifactId>
            <version>${jaxb-api.version}</version>
        </dependency>

Przejdź do swojego Build.gradle i dodaj poniższe zależności dla Java 9 lub Java 10.

sourceCompatibility = 10 // You can also decrease your souce compatibility to 1.8 

//java 9+ does not have Jax B Dependents

    compile group: 'javax.xml.bind', name: 'jaxb-api', version: '2.3.0'
    compile group: 'com.sun.xml.bind', name: 'jaxb-core', version: '2.3.0'
    compile group: 'com.sun.xml.bind', name: 'jaxb-impl', version: '2.3.0'
    compile group: 'javax.activation', name: 'activation', version: '1.1.1'

Możesz użyć --add-modules=java.xml.bindOpcji JVM aby dodać moduł powiązania xml do środowiska wykonawczego JVM.

Na przykład: java --add-modules=java.xml.bind XmlTestClass

Aktualizacja kwietnia 2019 r

Changelong dla wydań JAXB jest na https://javaee.github.io/jaxb-v2/doc/user-guide/ch02.html

fragmenty:

    4.1. Changes between 2.3.0.1 and 2.4.0

         JAXB RI is now JPMS modularized:

            All modules have native module descriptor.

            Removed jaxb-core module, which caused split package issue on JPMS.

            RI binary bundle now has single jar per dependency instead of shaded fat jars.

            Removed runtime class weaving optimization.

    4.2. Changes between 2.3.0 and 2.3.0.1

          Removed legacy technology dependencies:

            com.sun.xml.bind:jaxb1-impl

            net.java.dev.msv:msv-core

            net.java.dev.msv:xsdlib

            com.sun.xml.bind.jaxb:isorelax

    4.3. Changes between 2.2.11 and 2.3.0

          Adopt Java SE 9:

            JAXB api can now be loaded as a module.

            JAXB RI is able to run on Java SE 9 from the classpath.

            Addes support for java.util.ServiceLoader mechanism.

            Security fixes

Autorytatywny link znajduje się na https://github.com/eclipse-ee4j/jaxb-ri#maven-artifacts

Współrzędne Maven dla artefaktów JAXB

jakarta.xml.bind: jakarta.xml.bind-api: klasy API dla JAXB. Wymagany do kompilacji z JAXB.

org.glassfish.jaxb: jaxb-runtime: Implementacja JAXB, środowisko wykonawcze używane do serializacji i deserializacji obiektów java do / z xml.

Pakiety słoików tłuszczu JAXB:

com.sun.xml.bind: jaxb-impl: JAXB runtime fat jar.

W przeciwieństwie do artefaktów org.glassfish.jaxb słoiki te zawierają wszystkie klasy zależności. Te artefakty nie zawierają deskryptorów modułów JPMS. W projektach Maven zamiast tego należy używać artefaktów org.glassfish.jaxb.

org.glassfish.jaxb: jaxb-runtime: jar: 2.3.2 wciąga:

[INFO] +- org.glassfish.jaxb:jaxb-runtime:jar:2.3.2:compile
[INFO] |  +- jakarta.xml.bind:jakarta.xml.bind-api:jar:2.3.2:compile
[INFO] |  +- org.glassfish.jaxb:txw2:jar:2.3.2:compile
[INFO] |  +- com.sun.istack:istack-commons-runtime:jar:3.0.8:compile
[INFO] |  +- org.jvnet.staxex:stax-ex:jar:1.8.1:compile
[INFO] |  +- com.sun.xml.fastinfoset:FastInfoset:jar:1.2.16:compile
[INFO] |  \- jakarta.activation:jakarta.activation-api:jar:1.2.1:compile

Oryginalna odpowiedź

Po jakich artefaktach powinienem użyć JAXB RI w moim projekcie Maven? w Maven możesz użyć profilu takiego jak:

<profile>
    <id>java-9</id>
    <activation>
        <jdk>9</jdk>
    </activation>
    <dependencies>
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
    </dependencies>
</profile> 

Drzewo zależności pokazuje:

[INFO] +- org.glassfish.jaxb:jaxb-runtime:jar:2.3.0:compile
[INFO] |  +- org.glassfish.jaxb:jaxb-core:jar:2.3.0:compile
[INFO] |  |  +- javax.xml.bind:jaxb-api:jar:2.3.0:compile
[INFO] |  |  +- org.glassfish.jaxb:txw2:jar:2.3.0:compile
[INFO] |  |  \- com.sun.istack:istack-commons-runtime:jar:3.0.5:compile
[INFO] |  +- org.jvnet.staxex:stax-ex:jar:1.7.8:compile
[INFO] |  \- com.sun.xml.fastinfoset:FastInfoset:jar:1.2.13:compile
[INFO] \- javax.activation:activation:jar:1.1.1:compile

Aby użyć tego w Eclipse, powiedz Oxygen.3a Release (4.7.3a) lub nowszy, Ctrl-Alt-P, lub kliknij prawym przyciskiem myszy projekt, Maven, a następnie wybierz profil.

W przypadku Java Web Start Execution możemy użyć sugestii Andy'ego Guiberta w następujący sposób:

<j2se version="1.6+" 
      java-vm-args="-XX:+IgnoreUnrecognizedVMOptions --add-modules=java.se.ee"/>

Zwróć uwagę na dodatkowe „=” w --add-module. Zobacz ten bilet OpenJDK lub ostatnią uwagę w „Zrozumieniu ostrzeżeń dotyczących dostępu do środowiska wykonawczego” platformy Java, Standard Edition Oracle JDK 9 Migration Guide .

dodaj zależność javax.xml.bind w pom.xml

    <dependency>
        <groupId>javax.xml.bind</groupId>
        <artifactId>jaxb-api</artifactId>
        <version>2.3.0</version>
    </dependency>

Ponieważ JavaEE jest teraz zarządzany przez https://jakarta.ee/ , nowe współrzędne Maven od 2.3.2 to:

https://eclipse-ee4j.github.io/jaxb-ri/#maven-artifacts

Pierwsza wydana wersja jaxb.version to 2.3.2.

<properties>
  <jaxb.version>2.3.2</jaxb.version>
</properties>

<dependency>
  <groupId>jakarta.xml.bind</groupId>
  <artifactId>jakarta.xml.bind-api</artifactId>
  <version>${jaxb.version}</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>${jaxb.version}</version>
</dependency>

Śledziłem ten adres URL i poniższe ustawienia naprawdę mi pomogły. Używam Java 10 z STS IDE w Macbook Pro. To działa jak urok.

   <dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.0</version>
</dependency>
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>2.3.0</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>javax.activation</groupId>
    <artifactId>javax.activation-api</artifactId>
    <version>1.2.0</version>
</dependency>

To rozwiązało moje problemy z zależnościami uruchomionymi Apache Camel 2.24.1 na Javie 12:

    <dependency>
        <groupId>javax.activation</groupId>
        <artifactId>activation</artifactId>
        <version>1.1.1</version>
    </dependency>

    <dependency>
        <groupId>javax.xml.bind</groupId>
        <artifactId>jaxb-api</artifactId>
        <version>2.3.1</version>
    </dependency>

    <dependency>
        <groupId>com.sun.xml.bind</groupId>
        <artifactId>jaxb-core</artifactId>
        <version>2.3.0.1</version>
    </dependency>

    <dependency>
        <groupId>com.sun.xml.bind</groupId>
        <artifactId>jaxb-impl</artifactId>
        <version>2.3.0.1</version>
    </dependency>

Ten sam problem napotkałem podczas korzystania z Spring Boot 2.0.5.RELEASEw Javie 11.

Samo dodanie javax.xml.bind:jaxb-api:2.3.0nie rozwiązało problemu. Musiałem także zaktualizować Spring Boot do najnowszego Milestone 2.1.0.M2, więc zakładam, że zostanie to naprawione w następnej oficjalnej wersji.

Musisz dodać zależności JAX-B podczas korzystania z JDK 9+. Dla Android Studio użytkownikiem, musisz dodać do swojej build.gradle„s dependencies {}bloku:

// Add missing dependencies for JDK 9+
if (JavaVersion.current().ordinal() >= JavaVersion.VERSION_1_9.ordinal()) {
    // If you're using @AutoValue or any libs that requires javax.annotation (like Dagger)
    compileOnly 'com.github.pengrad:jdk9-deps:1.0'
    compileOnly 'javax.annotation:javax.annotation-api:1.3.2'

    // If you're using Kotlin
    kapt "com.sun.xml.bind:jaxb-core:2.3.0.1"
    kapt "javax.xml.bind:jaxb-api:2.3.1"
    kapt "com.sun.xml.bind:jaxb-impl:2.3.2"

    // If you're using Java
    annotationProcessor "com.sun.xml.bind:jaxb-core:2.3.0.1"
    annotationProcessor "javax.xml.bind:jaxb-api:2.3.1"

    testAnnotationProcessor "com.sun.xml.bind:jaxb-core:2.3.0.1"
    testAnnotationProcessor "javax.xml.bind:jaxb-api:2.3.1"
}

Natknąłem się również na wyjątek ClassNotFoundException: javax.xml.bind.DatatypeConverter przy użyciu Java 11 i

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

Próbowałem wszystkich tych rzeczy, dodając javax.xml.bind: jaxb-api lub spring boot jakarta.xml.bind-api .. Znalazłem wskazówkę dotyczącą poprawek w wersji jjwt 0.10.0 .. ale co najważniejsze, pakiet jjwt to teraz podzielone!

Dlatego sprawdź to odniesienie: https://github.com/jwtk/jjwt/issues/510

Po prostu, jeśli używasz

Java11 i jjwt 0.9.x, a ty napotykasz wyjątek ClassNotFoundException: javax.xml.bind.DatatypeConverter,

idź po

jjwt wersja 0.11.x, ale użyj podzielonych pakietów: https://github.com/jwtk/jjwt#install

Nie można znaleźć wyższej wersji dla zależności jjwt, ponieważ dzielą pakiety.

Twoje zdrowie.

Nie odpowiedź, ale dodatek: Dostałem, ponieważ uruchamianie groovysh(Groovy 2.4.13), jeśli JAVA_HOME wskazuje na instalację Java 9 ( java version "9.0.1"a konkretnie) kończy się fatalnie:

java.lang.reflect.InvocationTargetException
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.base/java.lang.reflect.Method.invoke(Method.java:564)
        at org.codehaus.groovy.tools.GroovyStarter.rootLoader(GroovyStarter.java:107)
        at org.codehaus.groovy.tools.GroovyStarter.main(GroovyStarter.java:129)
Caused by: java.lang.NoClassDefFoundError: Unable to load class groovy.xml.jaxb.JaxbGroovyMethods due to missing dependency javax/xml/bind/JAXBContext
        at org.codehaus.groovy.vmplugin.v5.Java5.configureClassNode(Java5.java:400)
        at org.codehaus.groovy.ast.ClassNode.lazyClassInit(ClassNode.java:277)
        at org.codehaus.groovy.ast.ClassNode.getMethods(ClassNode.java:397)
        ...
        ..
        .
        ..
        ...
        at org.codehaus.groovy.tools.shell.Groovysh.<init>(Groovysh.groovy:135)
        at org.codehaus.groovy.vmplugin.v7.IndyInterface.selectMethod(IndyInterface.java:232)
        at org.codehaus.groovy.tools.shell.Main.<init>(Main.groovy:66)
        at org.codehaus.groovy.vmplugin.v7.IndyInterface.selectMethod(IndyInterface.java:232)
        at org.codehaus.groovy.tools.shell.Main.main(Main.groovy:163)
... 6 more

Rozwiązaniem było:

• Przejdź do projektu JAXB na github.io ( „JAXB jest licencjonowany na podstawie podwójnej licencji - CDDL 1.1 i GPL 2.0 z wyjątkiem ścieżki klasy” )

• Pobieranie jaxb-ri-2.3.0.zip

• Rozpakuj, gdziekolwiek umieścisz pliki infrastruktury Java (w moim przypadku, /usr/local/java/jaxb-ri/). Inne rozwiązanie może istnieć (może przez SDKMAN, nie wiem)

• Upewnij się, że słoiki w podkatalogu lib znajdują się w CLASSPATH. Robię to za pomocą skryptu uruchomionego przy starcie basha, zwanego /etc/profile.d/java.sh, w którym dodałem (między innymi wierszami) następującą pętlę:

Pakowane w funkcję ...

function extend_qzminynshg {
   local BASE="/usr/local/java"
   for LIB in jaxb-api.jar  jaxb-core.jar  jaxb-impl.jar  jaxb-jxc.jar  jaxb-xjc.jar; do
      local FQLIB="$BASE/jaxb-ri/lib/$LIB"
      if [[ -f $FQLIB ]]; then
         export CLASSPATH=$FQLIB:$CLASSPATH
      fi
    done
}

extend_qzminynshg; unset extend_qzminynshg

I to działa!

Potrzebujesz tylko 1 zależności:

dependencies {
    implementation ("jakarta.xml.bind:jakarta.xml.bind-api:2.3.2")

OK, miałem ten sam problem, ale używałem Java 8 i ciągle otrzymywałem ten błąd, wypróbowałem większość rozwiązań. ale okazuje się, że mój maven wciąż wskazuje Java 9, mimo że ustawiłem globalną wersję Java na 8, gdy tylko ustaliłem, że wszystko działa.

Dla każdego, kto może mieć tego rodzaju problem, sprawdź Jak naprawić Maven, aby używał domyślnej Java

Stara odpowiedź „Problem rozwiązany przez przejście na amazoncorretto” Odpowiedź na wiadomość: Użyłem najnowszej wersji corretto, ale jest podobny jdk 1.8. więc i tak potrzebujemy dodać zależności ręcznie

Wersje zależności, których musiałem użyć podczas kompilacji pod docelową wersję Java 8. Testowana aplikacja w środowiskach JRE Java 8, 11 i 12.

        <!-- replace dependencies that have been removed from JRE's starting with Java v11 -->
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.2.8</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-core</artifactId>
            <version>2.2.8-b01</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-impl</artifactId>
            <version>2.2.8-b01</version>
        </dependency>
        <!-- end replace dependencies that have been removed from JRE's starting with Java v11 -->

Dla mnie w Javie 11 i stopniach to się udało:

plugins {
      id 'java'
}

dependencies {
      runtimeOnly 'javax.xml.bind:jaxb-api:2.3.1'
}

Musisz dodać zależności mavb do maven. Wersja implementacyjna glassfish 2.3.2 jest doskonale kompatybilna z nową wersją interfejsu API jakarta EE jaxb api 2.3.2.

<!-- API -->
<dependency>
    <groupId>jakarta.xml.bind</groupId>
    <artifactId>jakarta.xml.bind-api</artifactId>
    <version>2.3.2</version>
</dependency>

<!-- Runtime -->
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>2.3.2</version>
</dependency>

miałem podobne problemy po uaktualnieniu mojego projektu do java 11, a następnie to, co naprawiłem, to uaktualnienie do wersji spring boot 2.1.1, która najwyraźniej obsługuje java 11, to pomogło

Wiem, że spóźniłem się na imprezę, ale mój błąd ostatecznie wymagał innego rozwiązania ... również bardzo prostego

Oryginalnie rozłożyłem się na Tomcat 9 i zdałem sobie sprawę, że potrzebuję 7 ... Zapomniałem zmapować ścieżkę swojej klasy z powrotem do wersji 7 w build.xml

Mam nadzieję, że naprawi to błąd w przyszłości, któremu uda się przeoczyć ten prosty problem, tak jak ja!

Jeśli wywołujesz usługi sieciowe SOAP (na przykład za pomocą jaxws-maven-plugin), dodając tę ​​zależność, wszystkie błędy JAXB znikają:

<dependency>
            <groupId>org.glassfish.metro</groupId>
            <artifactId>webservices-rt</artifactId>
            <version>2.4.3</version>
</dependency>

Testowane z Javą 13