如何在Maven中用单个Jar包同时执行多子项目的main方法？

我来帮你搞定这个需求——要把两个子项目的main函数打包进同一个Jar并执行，咱们可以通过自定义统一启动类配合Maven的maven-shade-plugin（处理依赖合并更灵活）来实现，下面是一步步的具体操作：

1. 新增统一启动类 #

首先，在其中一个子项目（比如Project-1）里创建一个统一的启动类，用来调用两个子项目的main方法。比如新建com.name.example.UnifiedMain.java：

package com.name.example;

public class UnifiedMain {
    public static void main(String[] args) {
        // 顺序执行两个main方法
        Main1.main(args);
        Main2.main(args);
        
        // 如果需要并行执行，改用线程启动（避免阻塞）
        // new Thread(() -> Main1.main(args)).start();
        // new Thread(() -> Main2.main(args)).start();
    }
}

然后，确保Project-1能访问到Project-2的类，在Project-1的pom.xml中添加对Project-2的依赖：

<dependencies>
    <dependency>
        <groupId>com.name.example</groupId>
        <artifactId>Project-2</artifactId>
        <version>${project.version}</version> <!-- 和父项目版本保持一致 -->
    </dependency>
</dependencies>

2. 配置Maven Shade插件 #

在Project-1的pom.xml中配置maven-shade-plugin，它会把当前项目和所有依赖的类打包成一个可执行Jar，并指定我们的统一启动类作为入口：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.5.1</version> <!-- 使用最新稳定版即可 -->
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <transformers>
                            <!-- 指定统一启动类为Jar的入口 -->
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <mainClass>com.name.example.UnifiedMain</mainClass>
                            </transformer>
                            <!-- 处理资源文件冲突（比如Spring相关的配置文件，按需添加） -->
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>META-INF/spring.handlers</resource>
                            </transformer>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>META-INF/spring.schemas</resource>
                            </transformer>
                        </transformers>
                        <!-- 过滤签名文件，避免打包时出现冲突 -->
                        <filters>
                            <filter>
                                <artifact>*:*</artifact>
                                <excludes>
                                    <exclude>META-INF/*.SF</exclude>
                                    <exclude>META-INF/*.DSA</exclude>
                                    <exclude>META-INF/*.RSA</exclude>
                                </excludes>
                            </filter>
                        </filters>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

3. 打包并运行Jar #

执行打包命令 #

在父项目的根目录下运行Maven打包命令：

mvn clean package

打包完成后，你会在Project-1/target目录下看到一个带-shaded后缀的Jar包（比如Project-1-1.0-SNAPSHOT-shaded.jar），这个就是包含两个子项目所有类的可执行Jar。

运行Jar包 #

用Java命令启动这个Jar：

java -jar Project-1-1.0-SNAPSHOT-shaded.jar

这样就会按照你在UnifiedMain里写的逻辑，执行两个子项目的main方法了。

额外注意事项 #

• 如果两个子项目的main方法需要接收不同的参数，可以在UnifiedMain里拆分参数后分别传递。
• 确保父项目的pom.xml已经正确声明了两个子模块，否则Maven无法识别子项目：

  <modules>
      <module>Project-1</module>
      <module>Project-2</module>
  </modules>
  

• 如果遇到类冲突，可以在maven-shade-plugin的配置中添加过滤规则，排除重复的类文件。

内容的提问来源于stack exchange，提问作者Rishabh Deep Singh