Java: jak rozwiązać Javę.lang.NoClassDefFoundError: javax / xml / bind / JAXBException

W moim przypadku (spring boot fat jar) dodaję tylko 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 dobrze dla mnie w ostatnim JDK 9.0.1.

Odkryłem, że ta lista zależności jest wystarczająca do prawidłowego funkcjonowania, więc nie musisz jawnie określać --add-module (choć jest ona określona w pom tych zależności). Wystarczy tylko określić 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>

Czysty roztwór dla wszystkich JDK > = 9

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

• jaxb-api
• implementacja jaxb

Jako implementację wybrałem implementację referencyjną firmy glassfish, aby pozbyć się starego com.sun classes / libraries. Więc w rezultacie dodałem w moim Maven build

<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 dodawać javax.aktywacja trwa dłużej. (patrz https://github.com/eclipse-ee4j/jaxb-ri/issues/1222 )

To mi pomogło:

<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>

Update

Jak zasugerował @Jasper, aby uniknąć zależności od całej biblioteki EclipseLink, możesz również 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 produkuje *.jar, który może być uruchamiany zarówno przez JRE 8, jak i JRE 9 bez dodatkowych argumentów.

Dodatkowo, to musi być wykonane gdzieś, zanim JAXB API będzie być użyte:

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

Its ponieważ 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 to rozwiązać, zaimportowałem kilka plików JAR do mojego powyższe pliki i skopiować je do folderu libs w projekcie

W czasie 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 do modułów JDK 9 można również znaleźć na : https://www.youtube.com/watch?v=KZfbRuvv5qc

To mi pomogło. 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>

Idź do swojej budowy.gradle i dodać poniżej zależności zarówno 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ć opcji --add-modules=java.xml.bind JVM, aby dodać moduł XML bind do środowiska JVM run-time.

Eg: java --add-modules=java.xml.bind XmlTestClass

Aktualizacja Kwiecień 2019

Zmiana 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 jest na https://github.com/eclipse-ee4j/jaxb-ri#maven-artifacts

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

Dżakarta.xml.bind: Dżakarta.xml.bind-api: klasy API dla JAXB. Wymagane do kompilacji przeciwko JAXB.

Org.glassfish.jaxb: JAXB-runtime: Implementacja JAXB, runtime używana do serializacji i deserializacji obiektów java do / z xml.

JAXB fat-jar bundles:

Com.słońce.xml.bind: jaxb-impl: JAXB runtime fat słoik.

W przeciwieństwie do org.glassfish.JAXB, te słoiki mają wszystkie zależności zajęcia zawarte w środku. Artefakty te nie zawierają modułu JPMS deskryptory. W Maven projects org.glassfish.artefakty jaxb są / align = "left" / zamiast tego.

Org.glassfish.jaxb: jaxb-runtime:jar: 2.3.2 ścią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 artefaktów powinienem użyć dla JAXB RI w moim projekcie Maven? W Maven możesz użyć profilu typu:

<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

Potykam się również o ClassNotFoundException: javax.xml.bind.DatatypeConverter using Java 11 and

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

Tak więc, sprawdź to odniesienie: https://github.com/jwtk/jjwt/issues/510

Po prostu, jeśli używasz

Java11 oraz jjwt 0.9.x i stawiasz czoła klasie: javax.xml.bind.Problem DatatypeConverter,

Idź do

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

Nie znajdziesz wyższej wersji zależności od jjwt, ponieważ dzielą Pakiety.

W 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 dodatkowy " = " w --add-modules. Zobacz ten bilet openjdk lub ostatnią uwagę w "Understanding runtime Access Warnings" Java Platform, Standard Edition Oracle JDK 9 Migration Guide.

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

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

To rozwiązało moje problemy z zależnościami z uruchomieniem 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>

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

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

Pierwszy wydany jaxb.wersja 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>

Skorzystałem z tego adresu URL i poniższe ustawienia naprawdę mi pomogły. Używam Javy 10 z STS IDE w MacBooku 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>

Napotkałem ten sam problem przy użyciu Spring Boot 2.0.5.RELEASE W Java 11.

Samo dodanie javax.xml.bind:jaxb-api:2.3.0 nie rozwiązało problemu. Musiałem również zaktualizować Spring Boot do najnowszego kamienia milowego 2.1.0.M2, więc zakładam, że zostanie to naprawione w następnym oficjalnym wydaniu.

Musisz dodać zależności JAX - B podczas używania JDK 9+. Dla użytkownika Android Studio, musisz dodać to do swojego 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"
}

Jak stwierdza oficjalna dokumentacja:

Podczas aktualizacji możesz napotkać:

java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException

Hibernate zazwyczaj wymaga JAXB, który nie jest już domyślnie dostarczany. Możesz dodaj Javę.xml.moduł bind przywracający tę funkcjonalność za pomocą Java9 lub Java10 (nawet jeśli moduł jest przestarzały).

Od Java11, moduł nie jest dostępny, więc jedyną opcją jest dodaj JAXB RI (możesz to zrobić od Java9 zamiast dodawania java.xml.bind Moduł:

Maven

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

Gradle (bułg.gradle.kts):

implementation("org.glassfish.jaxb:jaxb-runtime")

Gradle (bułg.gradle)

implementation 'org.glassfish.jaxb:jaxb-runtime'

Jeśli wolisz określić konkretną wersję, zajrzyj tutaj: https://mvnrepository.com/artifact/org.glassfish.jaxb/jaxb-runtime

Nie odpowiedź, ale dodatek: dostałem, ponieważ uruchomienie groovysh (Groovy 2.4.13) jeśli JAVA_HOME wskazuje na instalację Java 9 (java version "9.0.1" aby być precyzyjnym) nie powiodło się:

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 JAXB Project na github.io ("JAXB jest licencjonowany na podwójnej licencji-CDDL 1.1 i GPL 2.0 z wyjątkiem ścieżki klasowej")

• Pobierz jaxb-ri-2.3.0.zip

• Rozpakuj gdziekolwiek umieścisz swoje pliki java infrastructure (w moja sprawa, /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, o nazwie /etc/profile.d/java.sh, gdzie dodałem (wśród wielu innych linii) następującą pętlę:

Spakowane do funkcji...

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")

Napotkałem ten problem podczas pracy nad projektem Java W Debian 10 .

Przy każdym uruchomieniu aplikacji wyświetla błąd w pliku dziennika:

Java.lang.NoClassDefFoundError: javax / xml / bind / JAXBException

Oto Jak to rozwiązałem :

Problem jest często spowodowany brakiem JAXB biblioteki (Java Architecture for XML Binding) w classpath. JAXB jest zawarty w Javie SE 10 lub starszej, ale został usunięty z Java SE z Java 11 lub nowszej-przeniesiony do Java EE w ramach projektu Jakarta ee.

Więc sprawdziłem moją wersję Javy używając:

java --version

I dało mi to wyjście

openjdk 11.0.8 2020-07-14
OpenJDK Runtime Environment (build 11.0.8+10-post-Debian-1deb10u1)
OpenJDK 64-Bit Server VM (build 11.0.8+10-post-Debian-1deb10u1, mixed mode, sharing)

Więc natknąłem się na błąd JAXBException ponieważ używałem Java 11 , który nie ma biblioteki JAXB (Java Architecture for XML Binding) brakuje w classpath. JAXB wchodzi w jego skład.

Aby rozwiązać problem musiałem dodać JAXB API biblioteka lib (/opt/tomcat/lib) katalog mojej instalacji tomcat:

sudo wget https://repo1.maven.org/maven2/javax/xml/bind/jaxb-api/2.4.0-b180830.0359/jaxb-api-2.4.0-b180830.0359.jar

Potem zmieniłem nazwę z jaxb-api-2.4.0-b180830.0359.jar na jaxb-api.jar:

sudo mv jaxb-api-2.4.0-b180830.0359.jar jaxb-api.jar

Uwaga : upewnij się, że zmienisz uprawnienia zezwalaj tomcat na dostęp do pliku, a także zmień własność na tomcat:

sudo chown -R tomcat:tomcat /opt/tomcat
sudo chmod -R 777 /opt/tomcat/

A potem zrestartowałem serwer tomcat:

sudo systemctl restart tomcat

Zasoby: [Solved] java.lang.NoClassDefFoundError: javax / xml / bind / JAXBException

To wszystkie.

Mam nadzieję, że to pomoże

OK, miałem ten sam problem, ale korzystałem z Javy 8 i ciągle otrzymywałem ten błąd, próbowałem większości rozwiązań. ale okazuje się, że mój maven nadal wskazywał na Javę 9-chociaż ustawiłem globalną wersję Javy na 8, jak tylko naprawiłem, że wszystko działało.

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

Stara odpowiedź " Problem rozwiązany przez przejście na amazoncorretto" Odpowiedź na wiadomości: używałem corretto latest, ale jest podobny jdk 1.8. więc tak czy inaczej musimy dodać zależności ręcznie

Wersje zależności, których potrzebowałem podczas kompilacji dla Java 8 target. Testowana aplikacja w Javie 8, 11 i 12 JREs.

        <!-- 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 gradle tak wyszło:

plugins {
      id 'java'
}

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

Wiem, że jestem spóźniony na imprezę, ale mój błąd zakończył się potrzebą innego rozwiązania... super simple too

Początkowo depoloyed do Tomcat 9 i zdałem sobie sprawę, że potrzebuję 7... Zapomniałem mapować moją ścieżkę klasową z powrotem do wersji 7 W build.xml

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

Musisz dodać JAXB do Mavena. Implementacja glassfish w wersji 2.3.2 jest doskonale kompatybilna z nowym jakarta EE JAXB API w wersji 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>