Maven deploy jar with dependencies to repo

Question

I can deploy a jar by using the following in my pom.xml and running mvn deploy :

    <distributionManagement>
    <repository>
        <id>releases</id>
        <url>http://${host}:8081/nexus/content/repositories/releases</url>
    </repository>
    <snapshotRepository>
        <id>snapshots</id>
        <name>Internal Snapshots</name>
        <url>http://${host}:8081/nexus/content/repositories/snapshots</url>
    </snapshotRepository>
</distributionManagement>

And I can build an executable jar-with-dependencies using the following:

        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <executions>
                <execution>
                    <id>create-executable-jar</id>
                    <phase>deploy</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                    <configuration>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                        <archive>
                            <manifest>
                                <mainClass>my.company.app.Main</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                </execution>
            </executions>
        </plugin>

Problem is I don't know how to stitch these together to deploy the executable jar to my Maven repo. I don't really know if this is accomplished by a new plugin or by adding a goal or other step to the existing assembly plugin.

Answer 1

If you bind the assembly to the packaging phase, it will install in your repository both the "regular" jar and the with-dependencies jar when you do a build:

    <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
            <archive>
                <manifest>
                    <mainClass>my.company.app.Main</mainClass>
                </manifest>
            </archive>
            <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
            </descriptorRefs>
        </configuration>
        <executions>
            <execution>
                <id>make-assembly</id> <!-- this is used for inheritance merges -->
                <phase>package</phase> <!--  bind to the packaging phase -->
                <goals>
                    <goal>single</goal>
                </goals>
            </execution>
        </executions>
    </plugin>

Then simply run mvn clean install deploy to upload both jars to your repository.

Answer 2

In order to build a (so-called) Über JAR and deploy it using maven, you could also use the shade plugin . The following code is taken from their website but I've made one or two projects using this feature.

 <project>
  ...
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>2.0</version>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>shade</goal>
            </goals>
            <configuration>
              <shadedArtifactAttached>true</shadedArtifactAttached>
              <shadedClassifierName>jackofall</shadedClassifierName> <!-- Any name that makes sense -->
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  ...
</project>

In this configuration you get the Über JAR as one deployment besides the normal JAR. The user of your JAR can then decide to pull the all-in-one package or the JAR with dependencies based on the classifier.

I'll usually use the shade plugin to build Über JARs (or modify the JAR in a way) and use the assembly plugin to build things like installation packages (containing the JAR and possibly other things). I am unsure what the intended goals of the single plugins are however.

Answer 3

The following worked. I'm going to leave this question open a bit because I'm not positive this is best practice, but working is something.

Problems I notice are that I made up the ID name and I don't know if this is usual practice and that I have to hard code the jar name; it isn't inferred from anything else.

<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.7</version>
<executions>
    <execution>
        <id>deploy-executable</id>
        <goals>
            <goal>deploy-file</goal>
        </goals>
        <configuration>
            <file>target/Monitoring-Client-1.0-SNAPSHOT-jar-with-dependencies.jar</file>
        </configuration>
    </execution>
</executions>
</plugin>

Answer 4

Essentially my difficulty doing this revealed the fact that my pom.xml was way off the rails already. Everything would have snapped into place on its own. I was formerly doing:

• Save all the dependencies into a lib folder
• Build a jar with a classpath slurping up that lib folder
• Use the assembly plugin to make another deployable jar

I think there were several reasons this sort of made sense along the way, especially when my libraries were not well-factored from my applications.

However by deleting 1 and 2 all that is needed is the distributionManagement section and the deploy phase works automagically. So all in all this is an amazing case of literally adding functionality by deleting large swathes of code.

Answer 5

First you shouldn't do the creation of the ueber jar in the deploy phase it's better to do this in the package phase. Furthermore the created jar file is usually automatically attached to your artifact and will be transfered to the remote repository (in your case Nexus). You can check this if you simply try to do a mvn install and take a look at the output if the created jar is installed into the local repository. To deploy the results into nexus you need to call mvn deploy.