Come risolvere java.lang.NoClassDefFoundError: javax / xml / bind / JAXBException in Java 9

Ho del codice che utilizza le classi API JAXB che sono state fornite come parte del JDK in Java 6/7/8. Quando eseguo lo stesso codice con Java 9, in fase di esecuzione visualizzo errori che indicano che non è possibile trovare le classi JAXB.

Le classi JAXB sono state fornite come parte del JDK da Java 6, quindi perché Java 9 non può più trovare queste classi?

Le API JAXB sono considerate API Java EE e pertanto non sono più contenute nel percorso di classe predefinito in Java SE 9. In Java 11, vengono completamente rimosse da JDK.

Java 9 introduce i concetti di moduli e, per impostazione predefinita, il java.semodulo aggregato è disponibile sul percorso di classe (o meglio, percorso del modulo). Come suggerisce il nome, il java.semodulo aggregato non include le API Java EE che sono state tradizionalmente raggruppate con Java 6/7/8.

Fortunatamente, queste API Java EE fornite in JDK 6/7/8 sono ancora nel JDK, ma per impostazione predefinita non sono sul percorso di classe. Le API Java EE extra sono fornite nei seguenti moduli:

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

Soluzione rapida e sporca: (solo JDK 9/10)

Per rendere disponibili le API JAXB in fase di runtime, specificare la seguente opzione della riga di comando:

--add-modules java.xml.bind

Ma ho ancora bisogno di questo per funzionare con Java 8 !!!

Se provi a specificare --add-modulesun JDK più vecchio, esploderà perché è un'opzione non riconosciuta. Suggerisco una delle due opzioni:

1. È possibile impostare qualsiasi opzione solo Java 9+ utilizzando la JDK_JAVA_OPTIONSvariabile di ambiente. Questa variabile di ambiente viene letta automaticamente dal programma di javaavvio per Java 9+.
2. È possibile aggiungere il -XX:+IgnoreUnrecognizedVMOptionsper fare in modo che JVM ignori silenziosamente le opzioni non riconosciute, invece di esplodere. Ma attenzione! Eventuali altri argomenti della riga di comando utilizzati non verranno più convalidati dalla JVM. Questa opzione funziona con Oracle / OpenJDK e IBM JDK (a partire da JDK 8sr4).

Soluzione rapida alternativa: (solo JDK 9/10)

Si noti che è possibile rendere disponibili tutti i moduli Java EE sopra indicati in fase di esecuzione specificando l' --add-modules java.se.eeopzione. Il java.se.eemodulo è un modulo aggregato che include java.se.eei suddetti moduli API Java EE. Nota, questo non funziona su Java 11 perché è java.se.eestato rimosso in Java 11.

Corretta soluzione a lungo termine: (JDK 9 e oltre)

I moduli API Java EE sopra elencati sono tutti contrassegnati @Deprecated(forRemoval=true)perché sono programmati per la rimozione in Java 11 . Quindi l' --add-moduleapproccio non funzionerà più in Java 11 immediatamente.

Quello che dovrete fare in Java 11 e successivi è includere la vostra copia delle API Java EE sul percorso di classe o sul modulo. Ad esempio, è possibile aggiungere le API JAX-B come dipendenza Maven in questo modo:

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

Vedere la pagina di implementazione di riferimento JAXB per maggiori dettagli su JAXB.

Per i dettagli completi sulla modularità di Java, consultare JEP 261: Module System

Per gli sviluppatori Gradle o Android Studio: (JDK 9 e successivi)

Aggiungi le seguenti dipendenze al tuo build.gradlefile:

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

Nel mio caso (barattolo grasso per stivali a molla) aggiungo solo quanto segue a pom.xml.

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

Nessuna di queste soluzioni ha funzionato bene per me nel recente JDK 9.0.1.

Ho scoperto che questo elenco di dipendenze è sufficiente per un corretto funzionamento, quindi non è necessario specificare esplicitamente --add-module(sebbene sia specificato nei pom di queste dipendenze). L'unica cosa che serve è specificare questo elenco di dipendenze:

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

Questo ha funzionato per me:

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

Aggiornare

Come suggerito da @Jasper, per evitare di dipendere dall'intera libreria EclipseLink, puoi anche dipendere da EclipseLink MOXy:

Esperto di

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

Come dipendenze per la mia app Java 8, che produce un * .jar che può essere eseguito da JRE 8 o JRE 9 senza argomenti aggiuntivi.

Inoltre, questo deve essere eseguito da qualche parte prima che venga utilizzata l'API JAXB:

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

Finora funziona alla grande, come soluzione alternativa. Non sembra una soluzione perfetta però ...

soluzione pulita per tutti i JDK> = 9

Devi aggiungere due dipendenze alla tua build

• il jaxb-api
• un'implementazione jaxb

Come implementazione ho scelto di usare l'implementazione di riferimento di glassfish per sbarazzarmi delle vecchie classi / librerie com.sun. Quindi come risultato ho aggiunto la mia build 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>

Si noti che dalla versione 2.3.1 non è più necessario aggiungere javax.activation. (vedi https://github.com/eclipse-ee4j/jaxb-ri/issues/1222 )

è perché la versione java se stai usando jdk 9 o una versione successiva basta aggiungere questo al tuo pom

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

Per risolvere questo problema, ho importato alcuni file JAR nel mio progetto:

• 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. Scarica i file sopra e copiali nella cartella libs nel progetto
2. Aggiungi i file JAR importati in Java Build Path

Al momento della compilazione e del tempo di esecuzione, aggiungere l'opzione --add-modules java.xml.bind

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

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

Una buona introduzione ai JDK 9moduli è disponibile anche su: https://www.youtube.com/watch?v=KZfbRuvv5qc

Questo ha funzionato per me. Aggiungere solo jaxb-api non era abbastanza.

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

Vai a Your Build.gradle e aggiungi le dipendenze di seguito per Java 9 o 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'

È possibile utilizzare l' --add-modules=java.xml.bindopzione JVM per aggiungere il modulo bind xml all'ambiente runtime JVM.

Per esempio: java --add-modules=java.xml.bind XmlTestClass

Aggiornamento aprile 2019

La modifica delle versioni di JAXB è disponibile su https://javaee.github.io/jaxb-v2/doc/user-guide/ch02.html

estratti:

    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

Il link autorevole è disponibile all'indirizzo https://github.com/eclipse-ee4j/jaxb-ri#maven-artifacts

Coordinate di Maven per i manufatti JAXB

jakarta.xml.bind: jakarta.xml.bind-api: classi API per JAXB. Richiesto per la compilazione su JAXB.

org.glassfish.jaxb: jaxb-runtime: implementazione di JAXB, runtime utilizzato per serializzare e deserializzare oggetti java da / a xml.

Fasci di grasso JAXB:

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

Contrariamente agli artefatti org.glassfish.jaxb, questi vasi contengono tutte le classi di dipendenza all'interno. Questi artefatti non contengono descrittori del modulo JPMS. Nei progetti Maven si suppone invece che vengano utilizzati artefatti org.glassfish.jaxb.

org.glassfish.jaxb: jaxb-runtime: jar: 2.3.2 pull in:

[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

Risposta originale

Seguendo Quali artefatti dovrei usare per JAXB RI nel mio progetto Maven? in Maven, puoi utilizzare un profilo come:

<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'albero delle dipendenze mostra:

[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

Per usarlo in Eclipse, dì Oxygen.3a Release (4.7.3a) o successivo, Ctrl-Alt-P, o fai clic con il tasto destro del mouse sul progetto, Maven, quindi seleziona il profilo.

Per Java Web Start Execution possiamo usare il suggerimento di Andy Guibert in questo modo:

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

Nota il "=" extra nei moduli --add. Vedi questo biglietto OpenJDK o l'ultima nota in "Informazioni sugli avvisi di accesso al runtime" della piattaforma Java, Guida alla migrazione di Oracle JDK 9 Standard Edition .

aggiungi la dipendenza javax.xml.bind in pom.xml

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

Poiché JavaEE è ora governato da https://jakarta.ee/ , le nuove coordinate Maven al 2.3.2 sono:

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

La prima versione jaxb.version rilasciata è 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>

Ho seguito questo URL e le seguenti impostazioni mi hanno davvero aiutato. Uso Java 10 con STS IDE in Macbook Pro. Esso funziona magicamente.

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

Ciò ha risolto i miei problemi con le dipendenze che eseguono Apache Camel 2.24.1 su 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>

Ho riscontrato lo stesso problema utilizzando Spring Boot 2.0.5.RELEASE su Java 11.

L'aggiunta da javax.xml.bind:jaxb-api:2.3.0sola non ha risolto il problema. Ho anche dovuto aggiornare Spring Boot all'ultimo Milestone 2.1.0.M2, quindi suppongo che questo sarà risolto nella prossima versione ufficiale.

È necessario aggiungere dipendenze JAX-B quando si utilizza JDK 9+. Per Studio Android utente, è necessario aggiungere questo alla vostra build.gradle's dependencies {}blocco:

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

Mi sono anche imbattuto in ClassNotFoundException: javax.xml.bind.DatatypeConverter utilizzando Java 11 e

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

Ho provato tutte queste cose in giro aggiungendo javax.xml.bind: jaxb-api o avvio a molla jakarta.xml.bind-api .. Ho trovato un suggerimento per le correzioni nella versione jjwt 0.10.0 .. ma, soprattutto, il pacchetto jjwt è ora diviso!

Quindi, controlla questo riferimento: https://github.com/jwtk/jjwt/issues/510

Semplicemente, se lo usi

Java11 e jjwt 0.9.x e devi affrontare il problema ClassNotFoundException: javax.xml.bind.DatatypeConverter,

andare per

jjwt versione 0.11.x, ma usa i pacchetti divisi: https://github.com/jwtk/jjwt#install

Non troverai una versione superiore per la dipendenza jjwt, dal momento che hanno diviso i pacchetti.

Saluti.

Non una risposta, ma un addendum: ho ottenuto perché l'esecuzione groovysh(Groovy 2.4.13) se JAVA_HOME punta a un'installazione Java 9 ( java version "9.0.1"per essere precisi) non riesce in modo abissale:

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 soluzione era:

• Vai al Progetto JAXB su github.io ( "JAXB è concesso in licenza con una doppia licenza - CDDL 1.1 e GPL 2.0 con eccezione del percorso di classe" )

• Scarica jaxb-ri-2.3.0.zip

• Decomprimi ovunque metti i tuoi file di infrastruttura Java (nel mio caso, /usr/local/java/jaxb-ri/). Potrebbe esistere un'altra soluzione (forse tramite SDKMAN, non so)

• Assicurati che i vasetti nella sottodirectory lib siano sul CLASSPATH. Lo faccio tramite uno script avviato all'avvio di bash, chiamato /etc/profile.d/java.sh, dove ho aggiunto (tra le altre righe) il seguente ciclo:

Impacchettato in una funzione ...

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

E funziona!

Hai solo bisogno di 1 dipendenza:

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

OK, ho avuto lo stesso tipo di problema, ma stavo usando Java 8 e continuavo a ricevere questo errore, ho provato la maggior parte delle soluzioni. ma si scopre che la mia maven puntava ancora a java 9 anche se ho impostato la versione globale di Java su 8, non appena ho risolto che tutto funzionava.

Per chiunque abbia questo tipo di problema, dai un'occhiata a Come risolvere Maven per usare Java predefinito

Vecchia risposta "Problema risolto passando all'amazoncorretto" Notizie: Ho usato correttamente l'ultimo, ma è simile jdk 1.8. quindi abbiamo bisogno di aggiungere dipendenze manualmente

Le versioni di dipendenza che avevo bisogno di usare durante la compilazione per destinazione Java 8. Applicazione testata in Java 8, 11 e 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 -->

Per me in Java 11 e gradi questo è quello che ha funzionato:

plugins {
      id 'java'
}

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

Devi aggiungere dipendenze jaxb a Maven. L'implementazione glassfish versione 2.3.2 è perfettamente compatibile con la nuova versione 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>

ho avuto problemi simili dopo aver aggiornato il mio progetto a Java 11, quindi ciò che è stato risolto è stato l'aggiornamento a Spring Boot 2.1.1 che apparentemente ha il supporto per Java 11, questo ha aiutato

So di essere in ritardo alla festa, ma il mio errore è finito per aver bisogno di una soluzione diversa ... anche super semplice

Inizialmente ho depolito su Tomcat 9 e mi sono reso conto che avevo bisogno di 7 ... Ho dimenticato di mappare il mio percorso di classe alla versione 7 in build.xml

Spero che questo risolverà l'errore di qualcun altro in futuro, che riesce a trascurare questo semplice problema come ho fatto io!

Se si chiamano i servizi Web SOAP (ad esempio, utilizzando jaxws-maven-plugin) semplicemente aggiungendo questa dipendenza scompaiono tutti gli errori JAXB:

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

Testato con Java 13