How to resolve java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException

Question 1

I have some code that uses JAXB API classes which have been provided as a part of the JDK in Java 6/7/8. When I run the same code with Java 9, at runtime I get errors indicating that JAXB classes can not be found.

The JAXB classes have been provided as a part of the JDK since Java 6, so why can Java 9 no longer find these classes?

Question 2

The additional part in this answer relates to the migration of these API's.

Question 3

building with Java 8 will get your code to compile yes, but when you try to run that compiled code on Java 9+ it will fail because JAX-B is not present.

Question 4

For Java 11, this article's solution is up to date: crunchify.com/java-11-and-javax-xml-bind-jaxbcontext

Question 5

see wiki.bitplan.com/index.php/Java8

Question 6

See the way I fixed it her :- Answer

Question 7

The JAXB APIs are considered to be Java EE APIs and therefore are no longer contained on the default classpath in Java SE 9. In Java 11, they are completely removed from the JDK.

Java 9 introduces the concepts of modules, and by default, the java.se aggregate module is available on the classpath (or rather, module-path). As the name implies, the java.se aggregate module does not include the Java EE APIs that have been traditionally bundled with Java 6/7/8.

Fortunately, these Java EE APIs that were provided in JDK 6/7/8 are still in the JDK, but they just aren't on the classpath by default. The extra Java EE APIs are provided in the following modules:

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

Quick and dirty solution: (JDK 9/10 only)

To make the JAXB APIs available at runtime, specify the following command-line option:

--add-modules java.xml.bind

But I still need this to work with Java 8!!!

If you try specifying --add-modules with an older JDK, it will blow up because it's an unrecognized option. I suggest one of two options:

You can set any Java 9+ only options using the JDK_JAVA_OPTIONS environment variable. This environment variable is automatically read by the java launcher for Java 9+.
You can add the -XX:+IgnoreUnrecognizedVMOptions to make the JVM silently ignore unrecognized options, instead of blowing up. But beware! Any other command-line arguments you use will no longer be validated for you by the JVM. This option works with Oracle/OpenJDK as well as IBM JDK (as of JDK 8sr4).

Alternate quick solution: (JDK 9/10 only)

Note that you can make all of the above Java EE modules available at run time by specifying the --add-modules java.se.ee option. The java.se.ee module is an aggregate module that includes java.se.ee as well as the above Java EE API modules. Note, this doesn't work on Java 11 because java.se.ee was removed in Java 11.

Proper long-term solution: (JDK 9 and beyond)

The Java EE API modules listed above are all marked @Deprecated(forRemoval=true) because they are scheduled for removal in Java 11. So the --add-module approach will no longer work in Java 11 out-of-the-box.

What you will need to do in Java 11 and forward is include your own copy of the Java EE APIs on the classpath or module path. For example, you can add the JAX-B APIs as a Maven dependency like this:

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

See Eclipse Implementation of JAXBTM and the GitHub site for more details on that implementation. Another implementation is EclipseLink MOXy.

For full details on Java modularity, see JEP 261: Module System

As of July 2022, the latest version of the bind-api and jaxb-runtime is 4.0.0. So you can also use

 <version>4.0.0</version>

...within those dependency clauses. But if you do so, the package names have changed from javax.xml.bind... to jakarta.xml.bind.... You will need to modify your source code to use these later versions of the JARs.

For Gradle or Android Studio developer: (JDK 9 and beyond)

Add the following dependencies to your build.gradle file:

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

Question 8

So if the Java EE API modules are marked deprecated does that mean it is a possibility that in Java 10 JAXB will no longer be available at runtime in Java 10? That seems like a step backwards. We will have to go back to the pre-6 practice of including JAXB as a dependency.

Question 9

Using --add-modules java.se.ee or --add-modules ALL-SYSTEM as a workaround is not recommended according to migration guide here docs.oracle.com/javase/9/migrate under section Modules Shared with Java EE Not Resolved by Default --> point 1

Question 10

With Java 10 officially released, we can confirm that the add-modules method will still work. The javax.xml.bind and other JavaEE classes are scheduled for removal in Java 11, per JEP-320.

Question 11

And now Java 11 is released and the java.se.ee module has been removed, so the --add-modules solution does not work anymore. Use the recommended solution instead: add JAXB as a separate dependency.

Question 12

i've added these dependencies and it is still giving me the same error. any ideas why?

Question 13

In my case (spring boot fat jar) I just add the following to pom.xml.

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

Question 14

Just for reference github.com/spring-projects/spring-boot/wiki/…

Question 15

Adding gradle dependency like this testCompile('javax.xml.bind:jaxb-api') worked for me.

Question 16

Like @pamcevoy mentioned, no need to specify the version of jaxb-api when using Spring Boot. Boot manages the version automatically.

Question 17

I suggest to use <scope>runtime</scope> for such case

Question 18

@Tuno's link didn't work for me, fixed link is: github.com/spring-projects/spring-boot/wiki/…

Question 19

Clean solution for all JDKs >= 9

You need to add two dependencies to your build

the jaxb-api
a jaxb implementation

As an implementation I chose to use the reference implementation by glassfish to get rid of old com.sun classes / libraries. So as a result I added in my 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>

Note that from version 2.3.1 you don't need to add the javax.activation any longer. (see https://github.com/eclipse-ee4j/jaxb-ri/issues/1222)

Question 20

Is the javax.xml.bind module really required? My code in JDK 11 works without it.

Question 21

@k.liakos I am not sure. The jaxb-runtime jar and the api-jar do not share the same classes/packages. I guess it depends on your code. If your code does not use the classes from the package 'javax.xml.bind' then you probably don't need it. The topic of this thread is that 'javax/xml/bind/JAXBException' cannot be found; this class is only in the jaxb-api.

Question 22

Works perfectly with multi-module project in java 12.

Question 23

Works in JDK 11.

Question 24

where is pom.xml file in project which is writable , in my project all pom.xml file only readbale, Is I need to create another one, if yes where i create this. @SebastianThees

Question 25

None of these solutions worked fine for me in the recent JDK 9.0.1.

I found that this list of dependencies is enough for a proper functioning, so you don't need to explicitly specify --add-module (though it is specified within these dependencies's pom's). The only you need is to specify this list of dependencies:

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

Question 26

For JDK 8, remove the jaxb-core and jaxb-impl from above.

Question 27

@Anil this is a pom.xml file of the Maven configuration. If you don't know what is that, then it is better to start from beggining

Question 28

An illegal reflective access operation has occurred WARNING: Illegal reflective access by com.sun.xml.bind.v2.runtime.reflect.opt.Injector (file:/C:/Users/eis/.m2/repository/com/sun/xml/bind/jaxb-impl/2.3.0/jaxb-impl-2.3.0.jar) to method java.lang.ClassLoader.defineClass(java.lang.String,byte[],int,int) WARNING: Please consider reporting this to the maintainers of com.sun.xml.bind.v2.runtime.reflect.opt.Injector WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations WARNING: All illegal access operations will be denied in a future release

Question 29

This worked for me on JDK 9.0.4 (I was calling JAXB related code through a Maven plugin with Maven 3.5.3). Although I would use

<dependency> <groupId>javax.activation</groupId> <artifactId>javax.activation-api</artifactId> <version>1.2.0</version> </dependency>

as last dependency.

Question 30

Awesome. I had a situation where - for some reason - a spring boot app would run in intellij CE but not eclipse on mac, and in eclipse but not intellij CE on win10. Being able to work in one IDE on two platforms is an advantage.

Question 31

This worked for 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>

Update

As @Jasper suggested, in order to avoid depending on the entire EclipseLink library, you can also just depend on 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'

As dependencies for my Java 8 app, which produces a *.jar which can be run by both JRE 8 or JRE 9 with no additional arguments.

In addition, this needs to be executed somewhere before JAXB API will be used:

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

Works great so far, as a workaround. Doesn't look like a perfect solution though...

Question 32

adding org.eclipse.persistence:eclipselink just to get JAXB APIs is a very heavy-weight dependency, unless you are already using eclipselink?

Question 33

Yes it is heavy (~9mb) and yes I've been using that already. I've mentioned that this is simply an alternative workaround for those who, maybe temporary, will have to use both 8 and 9 JREs for the same jar/war without providing command-line arguments.

Question 34

for the sake of interop between JDK 8 & 9, I would recommend using the -XX:+IgnoreUnrecognizedVMOptions command line option (updated my answer with details)

Question 35

System.setProperty("javax.xml.bind.JAXBContextFactory", "org.eclipse.persistence.jaxb.JAXBContextFactory"); does not work for me

Question 36

To avoid depending on the entire EclipseLink library, you can also just depend on EclipseLink MOXy: groupId org.eclipse.persistence, artifactId org.eclipse.persistence.moxy.

Question 37

it ́s because java version if you are using jdk 9 or a later version just add this to your pom

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

Question 38

I run into this all the time with the Spring Boot guides... Thanks a ton.

Question 39

@Cesar Rodriguez T, I tried this with a swagger example and compiling worked but running gave errors. I used the selected answer which included more dependencies and that worked.

Question 40

On pom.xml file of your project

Question 41

In my project two pom.xml i found but they not writable , its only in readable format what i need to do? @CesarRodriguez

Question 42

To solve this, I have imported some JAR files in my project:

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

Download above files and copy them into libs folder in the project
Add the imported JAR files in Java Build Path

Question 43

Note that the com.sun.xml.bind artifacts are old and provided only for backward compatibility. You should use the equivalent org.glassfish.jaxb artifacts instead, as mentioned in some of the other answers.

Question 44

This didn't work for me. It threw an error, and said that it couldn't find a particular class.

Question 45

Worked for me when I put them in tomcat9/lib folder under Mint 19.2 (Ubuntu 18.04 base), when deploying a Grails 3.4.10 application.

Question 46

Didn't work, instead raised more errors requiring several other jar inclusions. Mine was for jdk8

Question 47

At the time of compilation as well as run time, add the switch --add-modules java.xml.bind

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

A good introduction of the JDK 9 modules can also be found at : https://www.youtube.com/watch?v=KZfbRuvv5qc

Question 48

I encountered this issue when working on a Java Project in Debian 10.

Each time I start the appliction it throws the error in the log file:

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

Here's how I solved it:

The issue is often caused when JAXB library (Java Architecture for XML Binding) is missing in the classpath. JAXB is included in Java SE 10 or older, but it is removed from Java SE from Java 11 or newer –moved to Java EE under Jakarta EE project.

So, I checked my Java version using:

java --version

And it gave me this output

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

So I was encountering the JAXBException error because I was using Java 11, which does not have the JAXB library (Java Architecture for XML Binding) is missing in the classpath. JAXB is included in it.

To fix the issue I had to add the JAXB API library to the lib (/opt/tomcat/lib) directory of my tomcat installation:

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

Then I renamed it from jaxb-api-2.4.0-b180830.0359.jar to jaxb-api.jar:

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

Note: Ensure that you change the permission allow tomcat access the file and also change the ownership to tomcat:

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

And then I restarted the tomcat server:

sudo systemctl restart tomcat

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

That's all.

Question 49

in case of a spring boot app ?

Question 50

I also stumpled accross the ClassNotFoundException:javax.xml.bind.DatatypeConverter using Java 11 and

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

I tried all this stuff around adding javax.xml.bind:jaxb-api or spring boot jakarta.xml.bind-api .. I found a hint for fixes in jjwt version 0.10.0 .. but most importantly, the jjwt package is now split !

Thus, check this reference: https://github.com/jwtk/jjwt/issues/510

Simply, if you use

Java11 and jjwt 0.9.x and you face the ClassNotFoundException:javax.xml.bind.DatatypeConverter issue,

go for

jjwt version 0.11.x, but use the splitted packages: https://github.com/jwtk/jjwt#install

You maven wont find a higher version for jjwt dependency, since they split the packages.

Cheers.

Question 51

Using jjwt from io.jsonwebtoken version 0.9.1 with java 16 also caused the same error. The root cause is the same of java 11. Using jjwt-api and jjwt-impl (from io.jsonwebtoken) with version 0.10.7 solved the issue here.

Question 52

Update April 2019

Changelong for JAXB releases is at https://javaee.github.io/jaxb-v2/doc/user-guide/ch02.html

excerpts:

 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

Authoritative link is at https://github.com/eclipse-ee4j/jaxb-ri#maven-artifacts

Maven coordinates for JAXB artifacts

jakarta.xml.bind:jakarta.xml.bind-api: API classes for JAXB. Required to compile against JAXB.

org.glassfish.jaxb:jaxb-runtime: Implementation of JAXB, runtime used for serialization and deserialization java objects to/from xml.

JAXB fat-jar bundles:

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

In contrast to org.glassfish.jaxb artifacts, these jars have all dependency classes included inside. These artifacts does not contain JPMS module descriptors. In Maven projects org.glassfish.jaxb artifacts are supposed to be used instead.

org.glassfish.jaxb:jaxb-runtime:jar:2.3.2 pulls 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

Original Answer

Following Which artifacts should I use for JAXB RI in my Maven project? in Maven, you can use a profile like:

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

Dependency tree shows:

[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

To use this in Eclipse, say Oxygen.3a Release (4.7.3a) or later, Ctrl-Alt-P, or right-click on the project, Maven, then select the profile.

Question 53

Thanks for showing that a dependency for javax.xml.bind > jaxb-api that I have seen elsewhere is actually redundant. The glassfish dependency pulls it is. I just tried that, and it does indeed work.

Question 54

You need to add JAX-B dependencies when using JDK 9+. For Android Studio user, you'll need to add this to your build.gradle's dependencies {} block:

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

Question 55

I have modified your answer to work with Unit tests as well.

Question 56

This is the only solution that worked for me!

Question 57

This is the best solution!!!

Question 58

This worked for me. Adding only jaxb-api wasn't enough.

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

Question 59

And what was jaxb-api.version set to?

Question 60

@MiguelMunoz I used 2.2.7

Question 61

Note that the com.sun.xml.bind artifacts are old and provided only for backward compatibility. You should use the equivalent org.glassfish.jaxb artifacts instead, as mentioned in some of the other answers.

Question 62

The root cause of this issue is that Gradle Daemon using JDK11, either you set your JAVA_HOME to JDK11 or your running your Gradle Task in the shared daemon which running with JDK11.

For Android:

Check your Project Structure settings, you can change the JDK to JDK8 from there.
You can also set a JAVA_HOME and points to java8 home.

Question 63

Go to Your Build.gradle and add below dependencies for both Java 9 or 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'

Question 64

You can use --add-modules=java.xml.bind JVM option to add xml bind module to JVM run-time environment.

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

Andy Guibert Andy Guibert 43.1k8 gold badges46 silver badges65 bronze badges · Accepted Answer · 2017-04-23 17:40:23Z

The JAXB APIs are considered to be Java EE APIs and therefore are no longer contained on the default classpath in Java SE 9. In Java 11, they are completely removed from the JDK.

Java 9 introduces the concepts of modules, and by default, the java.se aggregate module is available on the classpath (or rather, module-path). As the name implies, the java.se aggregate module does not include the Java EE APIs that have been traditionally bundled with Java 6/7/8.

Fortunately, these Java EE APIs that were provided in JDK 6/7/8 are still in the JDK, but they just aren't on the classpath by default. The extra Java EE APIs are provided in the following modules:

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

Quick and dirty solution: (JDK 9/10 only)

To make the JAXB APIs available at runtime, specify the following command-line option:

--add-modules java.xml.bind

But I still need this to work with Java 8!!!

If you try specifying --add-modules with an older JDK, it will blow up because it's an unrecognized option. I suggest one of two options:

You can set any Java 9+ only options using the JDK_JAVA_OPTIONS environment variable. This environment variable is automatically read by the java launcher for Java 9+.
You can add the -XX:+IgnoreUnrecognizedVMOptions to make the JVM silently ignore unrecognized options, instead of blowing up. But beware! Any other command-line arguments you use will no longer be validated for you by the JVM. This option works with Oracle/OpenJDK as well as IBM JDK (as of JDK 8sr4).

Alternate quick solution: (JDK 9/10 only)

Note that you can make all of the above Java EE modules available at run time by specifying the --add-modules java.se.ee option. The java.se.ee module is an aggregate module that includes java.se.ee as well as the above Java EE API modules. Note, this doesn't work on Java 11 because java.se.ee was removed in Java 11.

Proper long-term solution: (JDK 9 and beyond)

The Java EE API modules listed above are all marked @Deprecated(forRemoval=true) because they are scheduled for removal in Java 11. So the --add-module approach will no longer work in Java 11 out-of-the-box.

What you will need to do in Java 11 and forward is include your own copy of the Java EE APIs on the classpath or module path. For example, you can add the JAX-B APIs as a Maven dependency like this:

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

See Eclipse Implementation of JAXBTM and the GitHub site for more details on that implementation. Another implementation is EclipseLink MOXy.

For full details on Java modularity, see JEP 261: Module System

As of July 2022, the latest version of the bind-api and jaxb-runtime is 4.0.0. So you can also use

 <version>4.0.0</version>

...within those dependency clauses. But if you do so, the package names have changed from javax.xml.bind... to jakarta.xml.bind.... You will need to modify your source code to use these later versions of the JARs.

For Gradle or Android Studio developer: (JDK 9 and beyond)

Add the following dependencies to your build.gradle file:

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

So if the Java EE API modules are marked deprecated does that mean it is a possibility that in Java 10 JAXB will no longer be available at runtime in Java 10? That seems like a step backwards. We will have to go back to the pre-6 practice of including JAXB as a dependency.
Using --add-modules java.se.ee or --add-modules ALL-SYSTEM as a workaround is not recommended according to migration guide here docs.oracle.com/javase/9/migrate under section Modules Shared with Java EE Not Resolved by Default --> point 1
With Java 10 officially released, we can confirm that the add-modules method will still work. The javax.xml.bind and other JavaEE classes are scheduled for removal in Java 11, per JEP-320.
And now Java 11 is released and the java.se.ee module has been removed, so the --add-modules solution does not work anymore. Use the recommended solution instead: add JAXB as a separate dependency.
i've added these dependencies and it is still giving me the same error. any ideas why?

CollectivesTM on Stack Overflow

How to resolve java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException

46 Answers 46

Proper long-term solution: (JDK 9 and beyond)

Clean solution for all JDKs >= 9

Update

Linked

Hot Network Questions

CollectivesTM on Stack Overflow

46 Answers 46

Proper long-term solution: (JDK 9 and beyond)

Clean solution for all JDKs >= 9

Update

Linked

Related