如何从 package 生成 jar 文件？

Question

I have the following project, I am trying to generate jar file from it.

I tried a ton of methods and I cannot properly generate the jar file, I think the problem is the folders structure, I also have to include the.xlsx as it it part of my program. When I try to clean and build it generates the.jar file but when i try to run it I get an error I also tried to manually specify the main class in the Manifest.txt and compile it.

Error: Could not find or load main class NewJFrame
Caused by: java.lang.ClassNotFoundException: NewJFrame

What are the correct steps I should follow? I mention that the "NewJFrame" is the class that has the main inside

The pom structure is:

Pom Structure

Answer 1

Add this into your pom file. And you will have a single far jar which contains all the dependencies you need and everything.

<plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>3.1.1</version>

            <configuration>
                <archive>
                  <manifest>
                     <mainClass>fully.qualified.MainClass</mainClass>
                  </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>

            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>

        </plugin>

Answer 2

Unfortunately, it is not as easy as it sounds... To run a Jar, you need to have:

• The jar you want to run. In your case, this is the Jar generated from your IDE command
• A classpath, with all the dependencies. Usually, those dependencies are managed by your IDE, which is the reason why you can run your app with the IDE. But when you generate a JAR, with Maven for instance, then you no longer have your IDE managing the dependencies for you.

So let's say you have a basic application with Maven, with NO dependencies, you could do the following:

package com.stackoverflow.test;
public class Main {

    public static void main(String[] args) {
        System.out.println("Hello World !");
    }
}

Then, to generate the JAR, you run man package . To run it, do the following (no need for manifest file):

java -cp target/myApp.jar com.stackoverflow.test.Main

Here, you can see the "-cp" option, which instructs the JVM to load a JAR, in our case, located in target and named myApp.jar, and execute the main method inside the class com.stackoverflow.test.Main .

Easy right?

But then, things get more complicated when you start having dependencies. In my following example, I'll assume I have a dependency with a famous library. I'll update my POM accordingly:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>launchJar</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>
    </dependencies>


</project>

And then, I'll use this API in my code:

package com.stackoverflow.test;

import org.apache.commons.lang3.StringUtils;

public class Main {

    public static void main(String[] args) {
        System.out.println(StringUtils.upperCase("Hello World !"));
    }
}

Once I generated the Jar ( mvn package ) and execute the same command as before, I have your error:

java -cp target/myApp.jar com.stackoverflow.test.Main

Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/lang3/StringUtils at com.stackoverflow.test.Main.main(Main.java:8)
Caused by: java.lang.ClassNotFoundException: org.apache.commons.lang3.StringUtils
at java.net.URLClassLoader.findClass(URLClassLoader.java:382)
at java.lang.ClassLoader.loadClass(ClassLoader.java:418)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)
at java.lang.ClassLoader.loadClass(ClassLoader.java:351)
... 1 more

The only way to get it to work is by adding my new dependencies to the classpath, in order to run the application. With maven, in my example, the commons-lang3 dependencies is located in: ~/.m2/repository/org/apache/commons/commons-lang3/3.9/commons-lang3-3.9.jar .

In order for my application to run, I execute:

java -cp ~/.m2/repository/org/apache/commons/commons-lang3/3.9/commons-lang3-3.9.jar:target/myApp.jar com.stackoverflow.test.Main

Note:

• To run the application, the classpath order is important (commons-lang before my Jar)
• On Unix/Linux, to separate different JARs, the character is : . On windows, use ;

But then, what happens if I have lots of dependencies, will I need to provide them manually? Fortunately, no:D

With Maven, you can use a new plugin, which creates a so-called "fat jar", or "jar with dependencies". To do so, just update your POM to add a new plugin:

...
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.1.1</version>

                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>

                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>

            </plugin>
        </plugins>
    </build>
...

Then, with man package you have a new JAR created, called: myApp-with-dependencies.jar. To run it, execute:

java -cp target/myApp-jar-with-dependencies.jar com.stackoverflow.test.Main

You could also customize this plugin to automatically add a MainClass and have a "runnable Jar".

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.1.1</version>

                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>com.stackoverflow.test.Main</mainClass>
                        </manifest>
                    </archive>
                </configuration>

                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>

            </plugin>

And then, just run:

java -jar target/myApp-jar-with-dependencies.jar