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

845

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?

Andy Guibert
fonte
2
A parte adicional desta resposta está relacionada à migração dessas APIs.
Naman
7
a construção com Java 8 fará com que seu código seja compilado sim, mas quando você tenta executar esse código compilado no Java 9+, ele falhará porque o JAX-B não está presente.
Andy Guibert 24/10
1
Para Java 11, solução deste artigo é atualizado: crunchify.com/java-11-and-javax-xml-bind-jaxbcontext
Eric Wang

Respostas:

1225

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"
}
Andy Guibert
fonte
8
Portanto, se os módulos da API Java EE estiverem marcados como obsoletos, isso significa que é possível que no Java 10 o JAXB não esteja mais disponível em tempo de execução no Java 10? Isso parece um passo para trás. Teremos que voltar à prática pré-6 de incluir o JAXB como uma dependência.
Michael
4
O uso de --add-modules java.se.ee ou --add-modules ALL-SYSTEM como solução alternativa não é recomendado, de acordo com o guia de migração aqui docs.oracle.com/javase/9/migrate na seção Módulos compartilhados com Java EE não Resolvido por padrão -> ponto 1
justMe 20/17
6
Com o Java 10 lançado oficialmente, podemos confirmar que o método add-modules ainda funcionará. A javax.xml.binde outras classes JavaEE estão agendadas para remoção no Java 11, por JEP-320 .
Joep Weijers
10
E agora o Java 11 é lançado e o java.se.eemódulo foi removido, para que a --add-modulessolução não funcione mais. Use a solução recomendada: adicione JAXB como uma dependência separada.
Jesper
11
Eu adicionei essas dependências e ainda está me dando o mesmo erro. alguma idéia por que?
João Vieira
262

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>
jdev
fonte
10
Apenas para referência github.com/spring-projects/spring-boot/wiki/...
Tuno
9
Adicionar dependência gradle como essa testCompile('javax.xml.bind:jaxb-api')funcionou para mim.
Pamcevoy 17/05/19
5
Como o @pamcevoy mencionado, não há necessidade de especificar a versão do jaxb-api ao usar o Spring Boot. A inicialização gerencia a versão automaticamente.
Marcel Overdijk
2
Eu sugiro usar <scope>runtime</scope>para tal caso
VladS
5
@ Ligação de Tuno não funcionou para mim, ligação fixa é: github.com/spring-projects/spring-boot/wiki/...
Francisco Mateo
69

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>
Andremoniy
fonte
2
Para o JDK 8, remova o jaxb-core e o jaxb-impl de cima.
foo
3
@ Este é um pom.xmlarquivo da configuração do Maven. Se você não sabe o que é isso, então é melhor começar do beggining
Andremoniy
8
Ocorreu uma operação de acesso reflexivo ilegal AVISO: Acesso reflexivo ilegal por com.sun.xml.bind.v2.runtime.reflect.opt.Injector (arquivo: / C: /Users/eis/.m2/repository/com/sun/ xml / bind / jaxb-impl / 2.3.0 / jaxb-impl-2.3.0.jar) para o método java.lang.ClassLoader.defineClass (java.lang.String, byte [], int, int) AVISO: considere relatando isso aos mantenedores de com.sun.xml.bind.v2.runtime.reflect.opt.Injector AVISO: Use --illegal-access = warn para ativar avisos de outras operações de acesso reflexivo ilegal AVISO: Todas as operações de acesso ilegal serão negado em uma versão futura
Stefan
1
Isso funcionou para mim no JDK 9.0.4 (eu estava chamando código relacionado ao JAXB através de um plug-in Maven com o Maven 3.5.3). Embora eu usaria <dependency> <groupId>javax.activation</groupId> <artifactId>javax.activation-api</artifactId> <version>1.2.0</version> </dependency>como última dependência.
Scrutari
1
Impressionante. Eu tive uma situação em que - por algum motivo - um aplicativo de inicialização de primavera seria executado no intellij CE, mas não no eclipse no mac, e no eclipse, mas não no intellij CE no win10. Ser capaz de trabalhar em um IDE em duas plataformas é uma vantagem.
Kometen
42

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

Mikhail Kholodkov
fonte
5
adicionar org.eclipse.persistence:eclipselinkapenas para obter APIs JAXB é uma dependência muito pesada, a menos que você já esteja usando o eclipselink?
Andy Guibert 27/09
4
Sim, é pesado (~ 9mb) e sim, eu já estou usando isso. Mencionei que essa é simplesmente uma solução alternativa para aqueles que, talvez temporariamente, precisem usar os 8 e 9 JREs para o mesmo jar / war sem fornecer argumentos da linha de comando.
Mikhail Kholodkov
2
por uma questão de interoperabilidade entre JDK 8 e 9, eu recomendo usar a -XX:+IgnoreUnrecognizedVMOptionsopção de linha de comando (atualizei a minha resposta com detalhes)
Andy Guibert
System.setProperty ("javax.xml.bind.JAXBContextFactory", "org.eclipse.persistence.jaxb.JAXBContextFactory"); não funciona para mim
David Brossard
1
Para evitar depender de toda a biblioteca EclipseLink, também é possível depender apenas do EclipseLink MOXy: groupId org.eclipse.persistence, artifactId org.eclipse.persistence.moxy.
Jesper
36

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 )

Sebastian Thees
fonte
O módulo javax.xml.bind é realmente necessário? Meu código no JDK 11 funciona sem ele.
k.liakos
@ k.liakos Não tenho certeza. O jar do jaxb-runtime e o api-jar não compartilham as mesmas classes / pacotes. Eu acho que depende do seu código. Se o seu código não usa as classes do pacote 'javax.xml.bind', provavelmente você não precisa dele. O tópico deste encadeamento é que 'javax / xml / bind / JAXBException' não pode ser encontrado; essa classe é apenas no jaxb-api.
Sebastian Thees
1
Funciona perfeitamente com projecto multi-módulo em java 12.
Heril Muratovic
35

é 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>
Cesar Rodriguez T
fonte
1
Eu sempre encontro isso com os guias do Spring Boot ... Muito obrigado.
Masterxilo #
2
@ Cesar Rodriguez T, tentei isso com um exemplo arrogante e a compilação funcionou, mas a execução deu erros. Usei a resposta selecionada que incluía mais dependências e que funcionava.
Pats
No arquivo pom.xml de seu projeto
Cesar Rodriguez T
22

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
Fábio Nascimento
fonte
4
Observe que os com.sun.xml.bindartefatos são antigos e fornecidos apenas para compatibilidade com versões anteriores. Você deve usar os org.glassfish.jaxbartefatos equivalentes , como mencionado em algumas das outras respostas.
Jesper
Isso não funcionou para mim. Ele gerou um erro e disse que não conseguia encontrar uma classe específica.
RamenChef 15/10
Trabalhou para mim quando os coloquei na pasta tomcat9 / lib no Mint 19.2 (Ubuntu 18.04 base), ao implantar um aplicativo Grails 3.4.10.
Mohamad Fakih
18

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

Pallavi Sonal
fonte
11

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>
Mr Jedi
fonte
E como foi definido o jaxb-api.version?
MiguelMunoz
@MiguelMunoz eu usei 2.2.7
Mr Jedi
2
Observe que os com.sun.xml.bindartefatos são antigos e fornecidos apenas para compatibilidade com versões anteriores. Você deve usar os org.glassfish.jaxbartefatos equivalentes , como mencionado em algumas das outras respostas.
Jesper
11

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'
Kumar Abhishek
fonte
11

É 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

Jayesh Jayanthivasan
fonte
11

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.

JasonPlutext
fonte
Obrigado por mostrar que uma dependência para javax.xml.bind> jaxb-apique eu já vi em outros lugares é realmente redundante. A dependência do glassfish o puxa. Eu apenas tentei isso, e realmente funciona.
Basil Bourque
8

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>
Malith Vitha
fonte
8

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

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

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>
kachanov
fonte
No meu caso eu preciso adicionar tomcat dependência no arquivo pom
GvSharma
6

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.

Javide
fonte
Isso não parece relacionado a mim. Existem várias soluções nesse segmento que funcionam independentemente do uso da bota de mola 2. (Também uso a bota de mola 2.0.5.RELEASE btw). Talvez no Spring 2.1.0.M2 já exista um tempo de execução jaxb incluído.
Sebastian Thees 2/11
Parece que com a Primavera Bota 2.1.0.RELEASE, JAXB não é mais necessário - github.com/spring-projects/spring-boot/releases
Burrich
5

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"
}
Hieu Rocker
fonte
Embora não funcione para testes de unidade
Malachiasz 03/03
Modifiquei sua resposta para trabalhar também com testes de unidade.
Malachiasz 04/03
4

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.

rico_s
fonte
3

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!

David Tonhofer
fonte
1
Eu não entendo os votos negativos. Aparentemente, as pessoas querem brincar com as opções de linha de comando em vez de realmente obter os potes? Adapte-se.
David Tonhofer
7
Os desenvolvedores de Java normalmente usam ferramentas de construção como Gradle ou Maven para gerenciar dependências, em vez de baixar manualmente os frascos. Essa é provavelmente a razão dos votos negativos.
21418 Joshua Davis
3

Você só precisa de 1 dependência:

dependencies {
    implementation ("jakarta.xml.bind:jakarta.xml.bind-api:2.3.2")
Dmitry Kaltovich
fonte
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

Ipkiss
fonte
2

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

Armen Arzumanyan
fonte
2
A distribuição do Amazon Corretto para JDK 11 não fornece classes javax.xml.bind. Se o problema foi resolvido após a mudança para Correto, foi porque você rebaixado para JDK 8.
Andy Guibert
estranho, vou verificar, na janela de encaixe i usado Correto mais recente
Armen Arzumanyan
Sim, amazoncorretto:latestatualmente dá JDK 8, e não 11. Muitas imagens Docker ainda são baseadas em JDK 8, precisamente por causa dos problemas de compatibilidade causados pela remoção API entre JDK 8 -> 11
Andy Guibert
2

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 -->
Chris
fonte
2

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

plugins {
      id 'java'
}

dependencies {
      runtimeOnly 'javax.xml.bind:jaxb-api:2.3.1'
}
silver_mx
fonte
onde exatamente colocamos isso?
nyxee 8/01
No seu arquivo build.gradle, se você estiver usando gradle.
silver_mx 9/01
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>
Krishna Telgave
fonte
1

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

FreakAtNs
fonte
considere adicionar pelo menos a parte da solução em sua resposta, pois as respostas somente para links se tornarão inválidas se o URL mudar no futuro.
yukashima huksay
0

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!

Tyler Miles
fonte
2
Embora isso possa ajudar OP, é melhor adicionar mais detalhes, exemplos, etc.
Tiw
0

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

GabrielBB
fonte