如何用Java编译器运行无内置Manifest的Jar文件，指定自定义主类与类路径

Great question—running a JAR without relying on its built-in manifest (and overriding old entries) is a common need, especially when dealing with pre-built JARs that don’t have the right settings. Let’s walk through the most reliable methods to do this:

Method 1: Explicitly specify Main-Class and Class-Path via the java command #

This is the most straightforward approach—it completely ignores any existing manifest in the JAR and lets you define everything on the fly.

Use this command structure (adjust paths and class names to match your setup):

# Windows
java -cp "your-target.jar;lib/dependency1.jar;lib/dependency2.jar" com.your.package.YourMainClass

# Linux/macOS
java -cp "your-target.jar:lib/dependency1.jar:lib/dependency2.jar" com.your.package.YourMainClass

• Breakdown:
  • -cp (short for -classpath) sets your custom Class-Path. List all required JARs and directories, separated by ; (Windows) or : (Linux/macOS). Don’t forget to include the target JAR itself here!
  • The final argument is your fully qualified Main-Class name (including its package structure, like com.example.MyApp).
  • This command bypasses the JAR’s manifest entirely—any old Main-Class or Class-Path entries inside the JAR are ignored automatically.

Method 2: Create a thin wrapper JAR with your custom manifest #

If you want a reusable way to run the original JAR with your settings (without modifying it), create a small wrapper JAR that references the original one.

1. Create a text file (e.g., custom-manifest.mf) with these lines:

Main-Class: com.your.package.YourMainClass
Class-Path: your-target.jar lib/dependency1.jar lib/dependency2.jar

• Critical note: Add a blank line at the end of the file—manifest files require this to be parsed correctly by the JVM.
• The Class-Path entries are space-separated, and paths are relative to the directory where you’ll run the command.

2. Create a minimal wrapper JAR that only contains this manifest:

jar cfm wrapper.jar custom-manifest.mf

• This creates a tiny JAR (wrapper.jar) with just your custom manifest.

3. Run the wrapper JAR—this will load the original JAR and dependencies using your settings:

java -jar wrapper.jar

• This approach ignores the original JAR’s manifest entirely, since the wrapper’s manifest takes precedence.

Method 3: Replace the original JAR’s manifest (permanent change) #

If you don’t mind modifying the original JAR, you can overwrite its existing manifest with your custom one.

1. Create your custom-manifest.mf as in Method 2.

2. Run this command to update the JAR’s manifest:

jar ufm your-target.jar custom-manifest.mf

• Breakdown:
  • u = update the existing JAR
  • f = specify the JAR file name
  • m = use the custom manifest file to replace the old one

Now, when you run java -jar your-target.jar, it will use your specified Main-Class and Class-Path, completely ignoring the original manifest entries.

Key Tips #

• Always include the target JAR in your Class-Path (either via -cp or the manifest’s Class-Path entry)—otherwise the JVM won’t find the classes inside it.
• On Linux/macOS, use colons (:) instead of semicolons (;) for classpath separators.
• If your paths contain spaces, wrap the entire classpath string in quotes (e.g., "my jar.jar:lib/my dep.jar").
• The manifest’s Class-Path uses relative paths, so ensure dependencies are in the correct location relative to where you run the command.

内容的提问来源于stack exchange，提问作者Fabillo