错误：找不到或加载主类NewJFrame
原因：java.lang.ClassNotFoundException: NewJFrame

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

package com.stackoverflow.test;
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World !");
    }
}

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

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

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 !"));
    }
}

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

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

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

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

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

<details>
<summary>英文:</summary>
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&#39;s say you have a basic application with Maven, with NO dependencies, you could do the following:

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

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:

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

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

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:

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

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:

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

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

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

</details>