Como resolver java.lang.NoClassDefFoundError: javax / xml / bind / JAXBException no Java 9

Eu tenho algum código que usa classes de API JAXB que foram fornecidas como parte do JDK em Java 6/7/8. Quando executo o mesmo código com o Java 9, em tempo de execução, recebo erros indicando que não foi possível encontrar as classes JAXB.

As classes JAXB são fornecidas como parte do JDK desde o Java 6, então por que o Java 9 não pode mais encontrar essas classes?

As APIs JAXB são consideradas APIs Java EE e, portanto, não estão mais contidas no caminho de classe padrão no Java SE 9. No Java 11, elas são completamente removidas do JDK.

O Java 9 apresenta os conceitos de módulos e, por padrão, o java.semódulo agregado está disponível no caminho de classe (ou melhor, caminho do módulo). Como o nome indica, o java.semódulo agregado não inclui as APIs Java EE que foram tradicionalmente empacotadas com o Java 6/7/8.

Felizmente, essas APIs Java EE que foram fornecidas no JDK 6/7/8 ainda estão no JDK, mas elas simplesmente não estão no caminho de classe por padrão. As APIs Java EE extras são fornecidas nos seguintes módulos:

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

Solução rápida e suja: (apenas JDK 9/10)

Para disponibilizar as APIs JAXB em tempo de execução, especifique a seguinte opção da linha de comandos:

--add-modules java.xml.bind

Mas ainda preciso disso para trabalhar com o Java 8 !!!

Se você tentar especificar --add-modulescom um JDK mais antigo, ele explodirá porque é uma opção não reconhecida. Sugiro uma das duas opções:

1. Você pode definir qualquer opção apenas para Java 9+ usando a JDK_JAVA_OPTIONSvariável de ambiente Essa variável de ambiente é lida automaticamente pelo javainiciador para Java 9+.
2. Você pode adicionar o -XX:+IgnoreUnrecognizedVMOptionspara fazer a JVM ignorar silenciosamente as opções não reconhecidas, em vez de explodir. Mas cuidado! Quaisquer outros argumentos da linha de comando que você usar não serão mais validados para você pela JVM. Esta opção funciona com Oracle / OpenJDK e IBM JDK (a partir do JDK 8sr4).

Solução rápida alternativa: (apenas JDK 9/10)

Observe que você pode disponibilizar todos os módulos Java EE acima em tempo de execução, especificando a --add-modules java.se.eeopção O java.se.eemódulo é um módulo agregado que inclui java.se.ee, além dos módulos da API Java EE acima. Observe que isso não funciona no Java 11 porque java.se.eefoi removido no Java 11.

Solução adequada a longo prazo: (JDK 9 e além)

Os módulos da API Java EE listados acima estão todos marcados @Deprecated(forRemoval=true)porque estão agendados para remoção no Java 11 . Portanto, a --add-moduleabordagem não funcionará mais no Java 11 imediatamente.

O que você precisará fazer no Java 11 e encaminhar é incluir sua própria cópia das APIs Java EE no caminho de classe ou no caminho do módulo. Por exemplo, você pode adicionar as APIs JAX-B como uma dependência do Maven assim:

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

Consulte a página Implementação de Referência JAXB para obter mais detalhes sobre JAXB.

Para obter detalhes completos sobre a modularidade Java, consulte JEP 261: Módulo Sistema

Para desenvolvedores Gradle ou Android Studio: (JDK 9 e posterior)

Adicione as seguintes dependências ao seu build.gradlearquivo:

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

No meu caso (jarra de gordura para botas de primavera), basta adicionar o seguinte ao pom.xml.

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

Nenhuma dessas soluções funcionou bem para mim no recente JDK 9.0.1.

Eu descobri que essa lista de dependências é suficiente para um funcionamento adequado, portanto você não precisa especificar explicitamente --add-module(embora seja especificada nos poms dessas dependências). O único que você precisa é especificar esta lista de dependências:

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

Isso funcionou para mim:

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

Atualizar

Como o @Jasper sugeriu, para evitar a dependência de toda a biblioteca EclipseLink, você também pode depender apenas do 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'

Como dependências para meu aplicativo Java 8, que produz um * .jar que pode ser executado pelo JRE 8 ou JRE 9 sem argumentos adicionais.

Além disso, isso precisa ser executado em algum lugar antes que a API JAXB seja usada:

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

Funciona muito bem até agora, como uma solução alternativa. Não parece uma solução perfeita ...

solução limpa para todos os JDKs> = 9

Você precisa adicionar duas dependências à sua compilação

• o jaxb-api
• uma implementação jaxb

Como uma implementação, eu escolhi usar a implementação de referência do glassfish para se livrar das antigas classes / bibliotecas com.sun. Então, como resultado, adicionei no meu 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>

Observe que a partir da versão 2.3.1, você não precisa adicionar mais o javax.activation. (consulte https://github.com/eclipse-ee4j/jaxb-ri/issues/1222 )

é porque a versão java, se você estiver usando o jdk 9 ou uma versão posterior, basta adicionar isso ao seu pom

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

Para resolver isso, importei alguns arquivos JAR no meu projeto:

• 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. Faça o download dos arquivos acima e copie-os para a pasta libs no projeto
2. Inclua os arquivos JAR importados no Java Build Path

No momento da compilação, bem como no tempo de execução, adicione a opção --add-modules java.xml.bind

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

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

Uma boa introdução dos JDK 9módulos também pode ser encontrada em: https://www.youtube.com/watch?v=KZfbRuvv5qc

Isso funcionou para mim. Adicionar apenas jaxb-api não foi suficiente.

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

Acesse Your Build.gradle e inclua dependências abaixo para 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'

É possível usar a --add-modules=java.xml.bindopção JVM para incluir o módulo de ligação xml no ambiente de tempo de execução da JVM.

Por exemplo: java --add-modules=java.xml.bind XmlTestClass

Atualização em abril de 2019

O Changelong para lançamentos JAXB está em https://javaee.github.io/jaxb-v2/doc/user-guide/ch02.html

trechos:

    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

O link oficial está em https://github.com/eclipse-ee4j/jaxb-ri#maven-artifacts

Coordenadas do Maven para artefatos JAXB

jakarta.xml.bind: jakarta.xml.bind-api: classes de API para JAXB. Necessário para compilar no JAXB.

org.glassfish.jaxb: jaxb-runtime: Implementação do JAXB, tempo de execução usado para serialização e desserialização de objetos java para / do xml.

Pacotes de jar de gordura JAXB:

com.sun.xml.bind: jaxb-impl: frasco de gordura em tempo de execução JAXB.

Ao contrário dos artefatos org.glassfish.jaxb, esses jars possuem todas as classes de dependência incluídas. Esses artefatos não contêm descritores de módulo JPMS. Nos projetos Maven, os artefatos org.glassfish.jaxb devem ser usados.

O org.glassfish.jaxb: jaxb-runtime: jar: 2.3.2 puxa:

[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

Resposta original

A seguir Quais artefatos devo usar para o JAXB RI no meu projeto Maven? no Maven, você pode usar um perfil como:

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

A árvore de dependência 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

Para usar isso no Eclipse, diga Oxygen.3a Release (4.7.3a) ou posterior, Ctrl-Alt-P, ou clique com o botão direito do mouse no projeto Maven e selecione o perfil.

Para a execução do Java Web Start, podemos usar a sugestão de Andy Guibert assim:

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

Observe o "=" extra nos --add-modules. Consulte este tíquete OpenJDK ou a última nota em "Noções básicas sobre avisos de acesso em tempo de execução" do Guia de Migração do Oracle JDK 9 da Java Platform, Standard Edition .

adicione dependência javax.xml.bind no pom.xml

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

Como o JavaEE agora é governado por https://jakarta.ee/ , as novas coordenadas do Maven a partir do 2.3.2 são:

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

O primeiro jaxb.version lançado é o 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>

Eu segui este URL e as configurações abaixo realmente me ajudaram. Eu uso o Java 10 com STS IDE no Macbook Pro. Ele funciona como um encanto.

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

Isso resolveu meus problemas com dependências executando o Apache Camel 2.24.1 no 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>

Encontrei o mesmo problema usando o Spring Boot 2.0.5.RELEASEno Java 11.

Adicionar javax.xml.bind:jaxb-api:2.3.0sozinho não resolveu o problema. Também tive que atualizar o Spring Boot para o Milestone mais recente 2.1.0.M2, portanto, presumo que isso será corrigido no próximo lançamento oficial.

Você precisa adicionar dependências JAX-B ao usar o JDK 9+. Para o usuário Android Studio, você precisa adicionar este à sua build.gradle's dependencies {}bloco:

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

Também tropecei no ClassNotFoundException: javax.xml.bind.DatatypeConverter usando Java 11 e

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

Tentei todas essas coisas adicionando javax.xml.bind: jaxb-api ou boot de primavera jakarta.xml.bind-api .. Encontrei uma dica para correções no jjwt versão 0.10.0 .. mas o mais importante é que o pacote jjwt é agora divida!

Portanto, verifique esta referência: https://github.com/jwtk/jjwt/issues/510

Simplesmente, se você usar

Java11 e jjwt 0.9.xe você enfrenta o problema ClassNotFoundException: javax.xml.bind.DatatypeConverter,

ir para

jjwt versão 0.11.x, mas use os pacotes divididos: https://github.com/jwtk/jjwt#install

Você não encontrará uma versão superior para a dependência do jjwt, pois eles dividem os pacotes.

Felicidades.

Não é uma resposta, mas um adendo: recebi porque a execução groovysh(Groovy 2.4.13) se JAVA_HOME aponta para uma instalação do Java 9 ( java version "9.0.1"para ser mais preciso) falha abismalmente:

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

A solução foi:

• Vá para o projeto JAXB em github.io ( "JAXB é licenciado sob uma licença dupla - CDDL 1.1 e GPL 2.0 com exceção de caminho de classe" )

• Baixar jaxb-ri-2.3.0.zip

• Descompacte o arquivo onde quer que você coloque seus arquivos de infraestrutura Java (no meu caso /usr/local/java/jaxb-ri/). Pode haver outra solução (talvez via SDKMAN, não sei)

• Verifique se os jars no subdiretório lib estão no CLASSPATH. Eu faço isso através de um script iniciado na inicialização do bash, chamado /etc/profile.d/java.sh, onde adicionei (entre muitas outras linhas) o seguinte loop:

Embalado em uma função ...

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

Você só precisa de 1 dependência:

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

OK, estou tendo o mesmo tipo de problema, mas estava usando o Java 8 e continuava recebendo esse erro, tentei a maioria das soluções. mas acontece que meu maven ainda estava apontando para o java 9, apesar de eu ter definido a versão global do Java para 8, assim que resolvi que tudo funcionava.

Para qualquer pessoa que possa ter esse tipo de problema, consulte Como corrigir o Maven para usar o Java padrão

Resposta antiga "Problema resolvido com a mudança para o amazoncorretto" Resposta de notícias: Usei o corretto mais recente, mas é semelhante ao jdk 1.8. mesmo assim, precisamos adicionar dependências manualmente

As versões de dependência que eu precisava usar ao compilar para o destino Java 8. Aplicativo testado em Java 8, 11 e 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 -->

Para mim no Java 11 e gradle, foi o que funcionou:

plugins {
      id 'java'
}

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

Você precisa adicionar dependências jaxb ao maven. A versão 2.3.2 da implementação do glassfish é perfeitamente compatível com a nova versão 2.3.2 da jakarta EE jaxb api.

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

Eu tive problemas semelhantes depois de atualizar meu projeto para java 11, então o que o corrigiu foi atualizar para o spring boot 2.1.1 que aparentemente tem suporte para java 11, isso ajudou

Eu sei que estou atrasado para a festa, mas meu erro acabou precisando de uma solução diferente ... super simples também

Inicialmente, depoloyed para o Tomcat 9 e percebi que precisava de 7 ... esqueci de mapear meu caminho de classe de volta à versão 7 no build.xml

Espero que isso resolva o erro de alguém no futuro, que consegue ignorar esse problema simples como eu fiz!

Se você estiver chamando serviços da web SOAP (por exemplo, usando jaxws-maven-plugin) apenas adicionando essa dependência, todos os erros JAXB desaparecerão:

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

Testado com Java 13