Comment résoudre java.lang.NoClassDefFoundError: javax / xml / bind / JAXBException dans Java 9

J'ai du code qui utilise des classes d'API JAXB qui ont été fournies dans le cadre du JDK en Java 6/7/8. Lorsque j'exécute le même code avec Java 9, lors de l'exécution, j'obtiens des erreurs indiquant que les classes JAXB sont introuvables.

Les classes JAXB sont fournies dans le cadre du JDK depuis Java 6, alors pourquoi Java 9 ne peut-il plus trouver ces classes?

Les API JAXB sont considérées comme des API Java EE et ne sont donc plus contenues dans le chemin de classe par défaut dans Java SE 9. Dans Java 11, elles sont complètement supprimées du JDK.

Java 9 introduit les concepts de modules, et par défaut, le java.semodule d'agrégation est disponible sur le chemin de classe (ou plutôt, chemin de module). Comme son nom l'indique, le java.semodule d'agrégation n'inclut pas les API Java EE qui étaient traditionnellement regroupées avec Java 6/7/8.

Heureusement, ces API Java EE fournies dans le JDK 6/7/8 sont toujours dans le JDK, mais elles ne sont tout simplement pas sur le chemin de classe par défaut. Les API Java EE supplémentaires sont fournies dans les modules suivants:

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

Solution rapide et sale: (JDK 9/10 uniquement)

Pour rendre les API JAXB disponibles au moment de l'exécution, spécifiez l'option de ligne de commande suivante:

--add-modules java.xml.bind

Mais j'en ai encore besoin pour travailler avec Java 8 !!!

Si vous essayez de spécifier --add-modulesavec un JDK plus ancien, il explosera car il s'agit d'une option non reconnue. Je suggère l'une des deux options:

1. Vous pouvez définir toutes les options Java 9+ uniquement à l'aide de la JDK_JAVA_OPTIONSvariable d'environnement. Cette variable d'environnement est automatiquement lue par le javalanceur pour Java 9+.
2. Vous pouvez ajouter le -XX:+IgnoreUnrecognizedVMOptionspour que la JVM ignore silencieusement les options non reconnues, au lieu de sauter. Mais méfiez-vous! Tout autre argument de ligne de commande que vous utilisez ne sera plus validé pour vous par la JVM. Cette option fonctionne avec Oracle / OpenJDK ainsi qu'avec IBM JDK (à partir de JDK 8sr4).

Solution rapide alternative: (JDK 9/10 uniquement)

Notez que vous pouvez rendre tous les modules Java EE ci-dessus disponibles au moment de l'exécution en spécifiant l' --add-modules java.se.eeoption. Le java.se.eemodule est un module agrégé qui inclut java.se.eeainsi que les modules API Java EE ci-dessus. Remarque, cela ne fonctionne pas sur Java 11 carjava.se.ee été supprimé dans Java 11.

Solution appropriée à long terme: (JDK 9 et au-delà)

Les modules API Java EE répertoriés ci-dessus sont tous marqués @Deprecated(forRemoval=true)car leur suppression est planifiée dans Java 11 . Alors le--add-module approche ne fonctionnera donc plus dans Java 11 prêt à l'emploi.

Ce que vous devrez faire dans Java 11 et plus tard, c'est inclure votre propre copie des API Java EE sur le chemin de classe ou le chemin du module. Par exemple, vous pouvez ajouter les API JAX-B en tant que dépendance Maven comme ceci:

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

Voir le page de mise en œuvre de référence JAXB pour plus de détails sur JAXB.

Pour plus de détails sur la modularité Java, voir JEP 261: Module System

Pour les développeurs Gradle ou Android Studio: (JDK 9 et au-delà)

Ajoutez les dépendances suivantes à votre build.gradlefichier:

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

Dans mon cas (pot de graisse de démarrage de printemps), j'ajoute simplement ce qui suit à pom.xml.

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

Aucune de ces solutions n'a bien fonctionné pour moi dans le récent JDK 9.0.1.

J'ai trouvé que cette liste de dépendances est suffisante pour un bon fonctionnement, vous n'avez donc pas besoin de spécifier explicitement --add-module(bien qu'elle soit spécifiée dans les pom de ces dépendances). Il vous suffit de spécifier cette liste de dépendances:

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

Cela a fonctionné pour moi:

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

Mise à jour

Comme l'a suggéré @Jasper, afin d'éviter de dépendre de l'ensemble de la bibliothèque EclipseLink, vous pouvez également simplement dépendre d'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'

Comme dépendances pour mon application Java 8, qui produit un * .jar qui peut être exécuté par JRE 8 ou JRE 9 sans arguments supplémentaires.

De plus, cela doit être exécuté quelque part avant que l'API JAXB soit utilisée:

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

Fonctionne très bien jusqu'à présent, comme solution de contournement. Cela ne semble pas être une solution parfaite ...

solution propre pour tous les JDK> = 9

Vous devez ajouter deux dépendances à votre build

• le jaxb-api
• une implémentation jaxb

En tant qu'implémentation, j'ai choisi d'utiliser l'implémentation de référence par glassfish pour se débarrasser des anciennes classes / bibliothèques com.sun. Donc, par conséquent, j'ai ajouté dans ma version 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>

Notez qu'à partir de la version 2.3.1, vous n'avez plus besoin d'ajouter le javax.activation. (voir https://github.com/eclipse-ee4j/jaxb-ri/issues/1222 )

c'est parce que la version java si vous utilisez jdk 9 ou une version plus récente il suffit de l'ajouter à votre pom

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

Pour résoudre ce problème, j'ai importé des fichiers JAR dans mon projet:

• 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. Téléchargez les fichiers ci-dessus et copiez-les dans le dossier libs du projet
2. Ajouter les fichiers JAR importés dans Java Build Path

Au moment de la compilation et de l'exécution, ajoutez le commutateur --add-modules java.xml.bind

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

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

Une bonne introduction des JDK 9modules peut également être trouvée sur: https://www.youtube.com/watch?v=KZfbRuvv5qc

Cela a fonctionné pour moi. Ajouter seulement jaxb-api n'était pas suffisant.

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

Accédez à Your Build.gradle et ajoutez les dépendances ci-dessous pour Java 9 ou 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'

Vous pouvez utiliser l' --add-modules=java.xml.bindoption JVM pour ajouter un module de liaison xml à l'environnement d'exécution JVM.

Par exemple: java --add-modules=java.xml.bind XmlTestClass

Mise à jour avril 2019

Changelong pour les versions JAXB se trouve à https://javaee.github.io/jaxb-v2/doc/user-guide/ch02.html

extraits:

    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

Le lien faisant autorité est à https://github.com/eclipse-ee4j/jaxb-ri#maven-artifacts

Coordonnées Maven pour les artefacts JAXB

jakarta.xml.bind: jakarta.xml.bind-api: classes d'API pour JAXB. Requis pour compiler avec JAXB.

org.glassfish.jaxb: jaxb-runtime: implémentation de JAXB, runtime utilisé pour la sérialisation et la désérialisation des objets java vers / depuis xml.

Ensembles de pots de graisse JAXB:

com.sun.xml.bind: jaxb-impl: Pot de graisse d'exécution JAXB.

Contrairement aux artefacts org.glassfish.jaxb, ces pots ont toutes les classes de dépendance incluses à l'intérieur. Ces artefacts ne contiennent pas de descripteurs de module JPMS. Dans les projets Maven, les artefacts org.glassfish.jaxb sont censés être utilisés à la place.

org.glassfish.jaxb: jaxb-runtime: jar: 2.3.2 tire:

[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

Réponse originale

A la suite Quels artefacts dois - je utiliser pour JAXB RI dans mon projet Maven? dans Maven, vous pouvez utiliser un profil comme:

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

L'arbre de dépendance montre:

[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

Pour l'utiliser dans Eclipse, dites Oxygen.3a Release (4.7.3a) ou version ultérieure, Ctrl-Alt-P, ou cliquez avec le bouton droit sur le projet, Maven, puis sélectionnez le profil.

Pour l'exécution de Java Web Start, nous pouvons utiliser la suggestion d'Andy Guibert comme ceci:

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

Notez le "=" supplémentaire dans les modules --add. Consultez ce ticket OpenJDK ou la dernière note dans "Understanding Runtime Access Warnings" du Java Platform, Standard Edition Oracle JDK 9 Migration Guide .

ajouter la dépendance javax.xml.bind dans pom.xml

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

Comme JavaEE est désormais régi par https://jakarta.ee/ , les nouvelles coordonnées Maven à partir de 2.3.2 sont:

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

La première version jaxb.version publiée est la 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>

J'ai suivi cette URL et les paramètres ci-dessous m'ont vraiment aidé. J'utilise Java 10 avec STS IDE dans Macbook Pro. Il fonctionne comme un charme.

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

Cela a résolu mes problèmes avec les dépendances exécutant Apache Camel 2.24.1 sur Java 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>

J'ai rencontré le même problème en utilisant Spring Boot 2.0.5.RELEASEsur Java 11.

L'ajout javax.xml.bind:jaxb-api:2.3.0seul n'a pas résolu le problème. J'ai également dû mettre à jour Spring Boot vers la dernière Milestone 2.1.0.M2, donc je suppose que cela sera corrigé dans la prochaine version officielle.

Vous devez ajouter des dépendances JAX-B lors de l'utilisation de JDK 9+. Pour les utilisateurs Android Studio, vous devrez ajouter à votre build.gradlede » dependencies {}bloc:

// 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"
}

J'ai également trébuché sur l'exception ClassNotFoundException: javax.xml.bind.DatatypeConverter à l'aide de Java 11 et

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

J'ai essayé toutes ces choses autour de l'ajout de javax.xml.bind: jaxb-api ou spring boot jakarta.xml.bind-api .. J'ai trouvé un indice pour les correctifs dans la version jjwt 0.10.0 .. mais surtout, le package jjwt est maintenant divisé!

Vérifiez donc cette référence: https://github.com/jwtk/jjwt/issues/510

Simplement, si vous utilisez

Java11 et jjwt 0.9.x et vous rencontrez le problème ClassNotFoundException: javax.xml.bind.DatatypeConverter,

allez pour

jjwt version 0.11.x, mais utilisez les packages fractionnés: https://github.com/jwtk/jjwt#install

Vous ne trouverez pas de version supérieure pour la dépendance jjwt, car ils divisent les packages.

À votre santé.

Pas une réponse, mais un addendum: je l'ai parce que l'exécution groovysh(Groovy 2.4.13) si JAVA_HOME pointe vers une installation de Java 9 ( java version "9.0.1"pour être précis) échoue de façon catastrophique:

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

La solution était de:

• Accédez au projet JAXB sur github.io ( "JAXB est autorisé sous une double licence - CDDL 1.1 et GPL 2.0 avec exception de chemin de classe" )

• Télécharger jaxb-ri-2.3.0.zip

• Décompressez où vous placez vos fichiers d'infrastructure java (dans mon cas, /usr/local/java/jaxb-ri/). Une autre solution peut exister (peut-être via SDKMAN, je ne sais pas)

• Assurez-vous que les fichiers jar du sous-répertoire lib se trouvent sur le CLASSPATH. Je le fais via un script démarré au démarrage de bash, appelé /etc/profile.d/java.sh, où j'ai ajouté (parmi beaucoup d'autres lignes) la boucle suivante:

Emballé dans une fonction ...

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

Et il fonctionne!

Vous n'avez besoin que d'une seule dépendance:

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

OK, j'ai eu le même genre de problème, mais j'utilisais Java 8, et n'arrêtais pas d'obtenir cette erreur, j'ai essayé la plupart des solutions. mais il s'avère que mon maven pointait toujours vers java 9 même si j'ai défini la version globale de Java sur 8, dès que j'ai corrigé que tout fonctionnait.

Pour tous ceux qui pourraient avoir ce genre de problème, consultez Comment réparer Maven pour utiliser Java par défaut

Ancienne réponse "Problème résolu en passant à amazoncorretto" Nouvelle réponse: J'ai utilisé le corretto le plus récent, mais il est similaire au jdk 1.8. de toute façon, nous devons ajouter des dépendances manuellement

Les versions de dépendance que j'avais besoin d'utiliser lors de la compilation pour la cible Java 8. Application testée dans Java 8, 11 et 12 JRE.

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

Pour moi, en Java 11 et gradle, c'est ce qui a fonctionné:

plugins {
      id 'java'
}

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

Vous devez ajouter des dépendances jaxb à maven. La version 2.3.2 de l'implémentation de Glassfish est parfaitement compatible avec la nouvelle version 2.3.2 de l'API jaxarta EE jaxb.

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

J'ai eu des problèmes similaires après la mise à niveau de mon projet vers Java 11, puis ce qui l'a corrigé était la mise à niveau vers Spring Boot 2.1.1 qui a apparemment un support pour Java 11, cela a aidé

Je sais que je suis en retard à la fête, mais mon erreur a fini par nécessiter une solution différente ... super simple aussi

Au départ, j'ai dépoli Tomcat 9 et j'ai réalisé que j'avais besoin de 7 ... J'ai oublié de mapper mon chemin de classe vers la version 7 dans build.xml

J'espère que cela corrigera une erreur elses à l'avenir, qui réussit à ignorer ce problème simple comme je l'ai fait!

Si vous appelez des services Web SOAP (par exemple, en utilisant jaxws-maven-plugin ) simplement en ajoutant cette dépendance, toutes les erreurs JAXB disparaissent:

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

Testé avec Java 13