Create multiple runnable Jars (with dependencies included) from a single Maven project

Question

I have a single maven project that has multiple main classes. I want to generate runnable Jars (that include all dependencies) out of these project. I currently have the following build configuration (using maven.assembly):

<build>
<plugins>
    <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
            <archive>
                <manifest>
                    <mainClass>classpath.to.my.mainClass</mainClass>
                </manifest>
            </archive>
            <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
            </descriptorRefs>
        </configuration>
    </plugin>
</plugins>
</build>

Is their a way to achive this with maven-assembly? If not, what is the simplest way to achive my goal?

Have you tried to create several `` entries for `maven-assembly-plugin` with different configurations? This will trigger this plugin twice and create two JAR files hopefully... — dma_k, Jan 04 '12 at 14:51
@dma_k Following your suggestion, trying to generate three JARs, the first two get overwritten by the last `` configuration. — anon, Jan 14 '13 at 18:19
Try to play with `` configuration option (check [here](http://maven.apache.org/plugins/maven-assembly-plugin/howto.html)). — dma_k, Jan 15 '13 at 15:08

score 32 · Answer 1 · answered Jan 04 '12 at 12:36

You can do it. You'll need a separate execution for each artifact that you're building (i.e., give each its own id but you can leave the phase as default), and you'll need to specify the finalName and archive/manifest/mainClass for each.

<build>
<plugins>
    <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <executions>
          <execution>
            <id>build-a</id>
            <configuration>
              <archive>
                <manifest>
                  <mainClass>foobar.Aclass</mainClass>
                </manifest>
              </archive>
              <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
              </descriptorRefs>
              <finalName>foobar_a.jar</finalName>
            </configuration>
          </execution>
          <execution>
            <id>build-b</id>
            <configuration>
              <archive>
                <manifest>
                  <mainClass>foobar.Bclass</mainClass>
                </manifest>
              </archive>
              <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
              </descriptorRefs>
              <finalName>foobar_b.jar</finalName>
            </configuration>
          </execution>
        </executions>
    </plugin>
</plugins>
</build>

It probably also ought to explicitly declare that the `single` goal is to be used. — Donal Fellows, Jan 04 '12 at 12:45
from trying this solution and the one [posted here](http://stackoverflow.com/a/15799254/288875), it looks like one also needs to add the `` and `` tags ? — Andre Holzner, Jun 25 '13 at 12:24
I edited the post (waiting for peer review) to include goals and phase tags. — Gabriel, Apr 09 '15 at 07:44
Would it also be possible to install them both? by adding a suffix to the artifact? — Phate, Apr 07 '20 at 19:21
Can these two jars also be size minimised with the shade plugin? — ifly6, Dec 21 '20 at 18:26

score 24 · Accepted Answer · edited Feb 23 '16 at 09:15

24

I wasn't able to solve this problem with the maven-assembly-plugin in a satisfying way, so I went for a different solution. I used the onejar-maven-plugin:

<build>
  <plugins>
  <plugin>
    <groupId>org.dstovall</groupId>
    <artifactId>onejar-maven-plugin</artifactId>
    <version>1.4.4</version>
    <executions>
      <execution>
        <id>build-first</id>
          <configuration>
            <mainClass>classpath.to.first.Main</mainClass>
            <attachToBuild>true</attachToBuild>
            <classifier>onejar</classifier>
            <filename>first-runnable.jar</filename>
          </configuration>
          <goals>
            <goal>one-jar</goal>
          </goals>
        </execution>
      <execution>
        <id>build-second</id>
          <configuration>
            <mainClass>classpath.to.second.Main</mainClass>
            <attachToBuild>true</attachToBuild>
            <classifier>onejar</classifier>
            <filename>second-runnable.jar</filename>
          </configuration>
          <goals>
            <goal>one-jar</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

<pluginRepositories>
  <pluginRepository>
     <id>onejar-maven-plugin.googlecode.com</id>
     <url>http://onejar-maven-plugin.googlecode.com/svn/mavenrepo</url>
  </pluginRepository>
</pluginRepositories>

edited Feb 23 '16 at 09:15

Tombart

30,520
16
123
136

answered Feb 03 '12 at 09:22

Martin Thurau

7,564
7
43
80

1

shouldn't the two `id`s in the two `execution`s be different ? My maven complains if I have the same id more than once. – Andre Holzner Feb 21 '12 at 12:11
@AndreHolzner: Yes, this was an error – Martin Thurau Feb 22 '12 at 09:59
1

IMHO, same thing is possible with maven-assembly-plugin. See @donal-fellows answer – Gabriel Apr 09 '15 at 07:46
different id's are required to uniquely identify separate jars, – Ankur Srivastava Apr 13 '17 at 19:21
You should replace the plugin repository with this: redhat-earlyaccess-repository https://maven.repository.redhat.com/earlyaccess/all/ – Babajide M. Moibi Sep 18 '18 at 13:20
the url http://onejar-maven-plugin.googlecode.com/svn/mavenrepo seems to be no longer working – Fred_Weitendorf Feb 19 '19 at 22:18

score 19 · Answer 3 · edited May 23 '17 at 10:30

The top answer works if you are not using any configuration (or any resource, for that matter) that gets bundled into your jar file (e.g., configuration for Spring Framework auto-bindings).

Fortunately, this solution also works with maven-shade-plugin and you don't have that aforementioned issue with onejar-maven-plugin.

Also, maven-shade-plugin is actively being maintained as opposed to onejar-maven-plugin which is in the purgatory that is googlecode.

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-shade-plugin</artifactId>
  <version>2.4.1</version>
  <executions>
    <execution>
      <id>build-first</id>
      <phase>package</phase>
      <goals>
         <goal>shade</goal>
      </goals>   
      <configuration>
        <transformers>
          <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">                        
            <mainClass>classpath.to.first.Main</mainClass>
          </transformer>
        </transformers>
        <finalName>first-runnable</finalName>
      </configuration>        
    </execution>
    <execution>
      <id>build-second</id>
      <phase>package</phase>
      <goals>
         <goal>shade</goal>
      </goals>   
      <configuration>
        <transformers>
          <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">                        
            <mainClass>classpath.to.second.Main</mainClass>
          </transformer>
        </transformers>
        <finalName>second-runnable</finalName>
      </configuration>  
    </execution>
  </executions>
</plugin>

This works but it also seems to backup the target JAR if it already exists, e.g. it creates original-first-runnable.jar and original-second-runnable.jar (using your example). — Mike Stoddart, Aug 18 '23 at 13:35

score 5 · Answer 4 · answered Mar 11 '15 at 18:21

To specify a little more previous answer that was very helpful to me, you need to add phase package and goal assembly and run mvn run clean package, pom is as follows :

<plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <executions>
                <execution>
                    <id>build-a</id>
                    <configuration>
                        <archive>
                            <manifest>
                                <mainClass>firstMainClass</mainClass>
                            </manifest>
                        </archive>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                        <finalName>a.jar</finalName>
                    </configuration>
                    <phase>package</phase>
                    <goals>
                        <goal>assembly</goal>
                    </goals>
                </execution>
                <execution>
                    <id>build-b</id>
                    <configuration>
                        <archive>
                            <manifest>
                                <mainClass>SecondMainClass</mainClass>
                            </manifest>
                        </archive>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                        <finalName>b.jar</finalName>
                    </configuration>
                    <phase>package</phase>
                    <goals>
                        <goal>assembly</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>

Goal `assembly` is deprecated. See [plugin information](https://maven.apache.org/plugins/maven-assembly-plugin/plugin-info.html). Better to use `single` instead. — Gabriel, Apr 09 '15 at 07:43

Create multiple runnable Jars (with dependencies included) from a single Maven project

4 Answers4

Linked