Develop Reference

Running Java program/Jar from command line

I have a java program that I coded in intellij using maven. I exported it as a jar and tried running from the command line but it keeps on telling me
Error: Could not find or load main class com.company.Main
Caused by: java.lang.ClassNotFoundException: com.company.Main
I then attempted to run the program itself from the command line and that also tells me it cannot find the main class
command line:
for the jar: java -jar selenium_project.jar
for running the program :java com.company.Main
For the jar I am running it from the folder it is in. For the program I am running it from the root of the program.
Pom.xml
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.4</version>
<configuration>
<archive>
<index>true</index>
<manifest>
<mainClass>com.company.Main</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
</plugins></build>
Manifest:
Manifest-Version: 1.0
Main-Class: com.company.Main
It might be an issue with maven, I dont know. I created a simple hello world program and ran that from the command line and it worked. I ran it like this (c://etc)../src/> java com.company.HelloWorld. But again when i try for this one it cannot find the main class.
Thank you
These are my classes
EDIT:
I changed to use the maven-assembly-plugin and I rebuilt the jar and still does not work
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
<configuration>
<archive>
<manifest>
<mainClass>
com.company.Main
</mainClass>
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</execution>
</executions>
</plugin>
</plugins></build>
class structure to show where main class is
code in the Main class
public class Main {
public static void main(String[] args) throws IOException, SQLException {
System.out.println("hello");
Executor ex = new Executor();
}
}

Your error is probably that your Main class is in the wrong package.
Furthermore, please not that you need the Maven shade plugin or Maven assembly plugin to build executable jars if you have dependencies.

I dont know what the issue was. I tried creating a new program and i copied over the classes and remade the pom.xml file and my new program works except for one dependency (chrome options) but I dont think that is what was causing an issue. So now I just need to figure out why Chrome options wont work but the actual jar from the new program does run.

From： https://www.xspdf.com/resolution/54971948.html
To extract the files from a jar file, use x , as in: C:\Java> jar xf myFile.jar. To extract only certain files from a jar file, supply their Install an archive program. JAR files work just like ZIP files. You can use any archive program to extract them. 2. Find the JAR file you want to extract. Use File Explorer (press Win + E to open File Explorer) or Finder on Mac to 3. Right-click the JAR file. Doing so . How to extract manifest file from jar. Extracting the Contents of a JAR File.

Create executable jar file for Cucumber Selenium project

Problem: I want to create an executable jar of my BDD Cucumber Selenium framework, which I can run using command like "java -jar bddframework-0.0.1-SNAPSHOT.jar".
What I tried:
I tried to directly create a jar file by "mvn clean package". I did get an jar file but when I run it using java -jar ***, I get below message:
no main manifest attribute, in bddframework-0.0.1-SNAPSHOT.jar
Then I tried adding a main method as below by adding a new Main.java.
public static void main(String[] args) throws Throwable {
String[] arguments = {"--plugin", "html:build/reports/cucumber", "--glue", "com.demo.amazonbdddocker.teststeps", "src/test/resources/feature"};
cucumber.api.cli.Main.main(arguments);
}
Still I get the same error: no main manifest attribute

The root cause of that issue is you are just creating a jar file NOT EXECUTABLE JAR. In order to create the executable jar, you need to do the below configuration in the POM.xml and after that you will be able to create the executable jar file.
<build>
<plugins>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<archive>
<manifest>
<mainClass>fully.qualified.MainClass</mainClass>
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</plugin>
</plugins>
</build>
and then you can run the below maven goals
mvn clean compile assembly:single

Running maven project via apache-maven server

Dear all I have a maven project and I need to run it using apache-maven I'm using the command mvn install to compile and add it to .m2 repository but how can I run this maven project via apache-maven server without using IDE's
Thanks in advance

In order to run a simple Java project, you have to identify the Main class. If you are using Maven for the build, the packaging will have to specify which class contains the main method.
You can do the above in Maven POM by adding a manifest in the configuration for the maven-jar-plugin which is responsible for the packaging. In other words, you simply add the following to your POM.
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<classpathPrefix>libs/</classpathPrefix>
<mainClass>
org.baeldung.executable.ExecutableMavenJar
<!--Full classified name of the class that contains the main method -->
</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
Once the JAR is created, you can execute it by invoking the following:
java -jar jarName.jar
You can find more details on the topic at http://www.baeldung.com/executable-jar-with-maven

You can follow these steps to find the solution of the main question:
https://www.mkyong.com/maven/how-to-deploy-maven-based-war-file-to-tomcat/

Error: Could not find or load main class in Java Maven project

I am working in Java Maven project. There is a .bat file in the root of the project which invokes a Java class with some arguments something like this:
java my.package.MyClass abc hi 1
Now, my project jar is built in the target directory of that project when I do mvn clean install. When I run that .bat file it gives me the below error
Error: Could not find or load main class my.package.MyClass
Project's pom.xml only contains jars as dependency.
Do I need to do something in pom.xml to make it work?

please provide your pom.xml so we can look for it,
anyway,
do you use maven-jar-plugin?
something like this
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.4</version>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<classpathPrefix>lib/</classpathPrefix>
<mainClass>your.main.class.package.ClassName</mainClass> // your main class
</manifest>
</archive>
</configuration>
</plugin>
and try to run your *.jar with command java -jar yourjar.jar

"No Main Manifest Attribute" in ----.jar Netbeans

I recently just started toying around with Maven in java. Time comes to test my project, it works fine in the NetBeans window, running the main class found in App.java (com.MyCompany.App), but when I try to run it from a command line I get an error:
java -jar fileName.jar
"No Main Manifest Attribute" in fileName.jar
I have tried adding a manifest.mf file specifying what main is, I've also been into project properties and added it as the main file...
What's going on?

You need the maven-jar-plugin (see Maven's example). This plugin will create the required entries in the manifest file when the project is built.
<project>
...
<build>
<plugins>
...
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<mainClass>fully.qualified.MainClass</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
...
</plugins>
</build>
...
</project>
You need the version, otherwise, the project won't build. The fully.qualified.MainClass starts at the package hierarchy.

Hope there is a problem in your manifest file. Some basic checks might solve your problem.
it should under /META-INF/MANIFEST.MF
Content should have Main-Class:com.MyCompany.App
If you are using any IDE, there should be an option to export project as runnable jar, you can make use of that to let the IDE take care of correct manifest.
From command line jar cfm filename.jar Manifest.txt com/MyCompany/*.class which generates the Manifest file with following contents
Manifest-Version: 1.0
Created-By: 1.6.0 (Sun Microsystems Inc.)
Main-Class: com.MyCompany.App
And then you can run jar command java -jar fileName.jar.
These type of problems are trivial but kills lot of time, just ensure your contents and location of the file is correct.

You could just use this for command line:
java -cp jarFileName.jar full.package.className
You wouldn't have to go into specifics of the Manifest file in this case.

Setting an Entry Point with the JAR Tool:
The 'e' flag (for 'entrypoint') creates or overrides the manifest's Main-Class attribute. It can be used while creating or updating a JAR file. Use it to specify the application entry point without editing or creating the manifest file.
For example, this command creates app.jar where the Main-Class attribute value in the manifest is set to MyApp:
jar cfe app.jar MyApp MyApp.class
You can directly invoke this application by running the following command:
java -jar app.jar
If the entrypoint class name is in a package it may use a '.' (dot) character as the delimiter. For example, if Main.class is in a package called foo the entry point can be specified in the following ways:
jar cfe Main.jar foo.Main foo/Main.class

If you look at the properties dialog for the project (from project tab, right click on your project and select properties) you'll see that there is a "run" item in the "Categories" window. Click on it and you'll see a dialog where you can specify the Main Class for the jar. That information will end up in your manifest.

I have been having this problem with Netbeans 8.0 and the built-in Maven project for the "Java Application" project prototype. Also I have Maven 3 and I found some of the suggestions on the web don't match the maven code used with Netbeans as well.
Anyway here's a simple recipe for having JAR file to run the main-class and embed dependent libraries. I made this work by comparing other project POM files for projects I found that worked with sub-project JAR-s so if someone with better Maven knowledge spots a gottcha, please speak. Also, I left in some normal stuff to provide context. Example follows:
<properties>
<packageName>trials.example</packageName>
<mainClass>${packageName}.CmdApp</mainClass>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<slf4jVersion>1.7.7</slf4jVersion>
<log4jVersion>1.2.17</log4jVersion>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
This section tells Maven about the project.
packageName ... Is the Java package for the main-class
mainClass ..... The fully qualified name for class with main() method.
You will see these used in the maven-jar-plugin.
The other thing the built-in example prototype didn't do was to package my sub-projects into the JAR so I can run from the command line. This is done with the maven-dependency-plugin below. The interesting bit is in the where we don't need to package the system stuff, and we want the dependant classes wrapped into our JAR.
These are used as follows:
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.6</version>
<executions>
<execution>
<id>unpack-dependencies</id>
<phase>package</phase>
<goals>
<goal>unpack-dependencies</goal>
</goals>
<configuration>
<excludeScope>system</excludeScope>
<outputDirectory>${project.build.directory}/classes</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.5</version>
<configuration>
<useDefaultManifestFile>true</useDefaultManifestFile>
<archive>
<manifest>
<mainClass>${mainClass}</mainClass>
<packageName>${packageName}</packageName>
<addClasspath>true</addClasspath>
<classpathPrefix>classes/</classpathPrefix>
</manifest>
<manifestEntries>
<mode>development</mode>
<url>${pom.url}</url>
</manifestEntries>
</archive>
</configuration>
</plugin>
</plugins>
</build>
Hope that saves you the few hours of checking and testing to make it happen. Cheers, Will.