java - single - maven jar file with dependencies




Como posso criar um JAR executável com dependências usando o Maven? (20)

Algo que funcionou para mim foi:

  <plugin>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
      <execution>
        <id>unpack-dependencies</id>
        <phase>prepare-package</phase>
        <goals>
          <goal>unpack-dependencies</goal>
        </goals>
        <configuration>
          <outputDirectory>${project.build.directory}/classes</outputDirectory>
        </configuration>
      </execution>

    </executions>
  </plugin>


  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <executions>
      <execution>
        <id>unpack-dependencies</id>
        <phase>package</phase>
      </execution>
    </executions>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
          <classpathPrefix>lib/</classpathPrefix>
          <mainClass>SimpleKeyLogger</mainClass>
        </manifest>
      </archive>
    </configuration>
  </plugin>

Eu tive um caso extraordinário porque minha dependência era um sistema:

<dependency>
  ..
  <scope>system</scope>
  <systemPath>${project.basedir}/lib/myjar.jar</systemPath>
</dependency>

Eu alterei o código fornecido por @ user189057 com as alterações: 1) maven-dependency-plugin é executado em "prepare-package" fase 2) Estou extraindo as classes descompactadas diretamente para "target / classes"

Eu quero empacotar meu projeto em um único JAR executável para distribuição.

Como posso fazer um pacote de projeto Maven todos os JARs de dependência em meu JAR de saída?


Aqui está um plugin jar executável para o Maven que usamos no Credit Karma. Cria um jar de frascos com um classloader capaz de carregar classes de jars aninhados. Isso permite que você tenha o mesmo caminho de classe em dev e prod e ainda mantenha todas as classes em um único arquivo jar assinado.

https://github.com/creditkarma/maven-exec-jar-plugin

E aqui está uma postagem no blog com detalhes sobre o plugin e por que nós fizemos isso: https://engineering.creditkarma.com/general-engineering/new-executable-jar-plugin-available-apache-maven/


Essa é a melhor maneira que encontrei:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.4</version>
    <configuration>
      <archive>
        <manifest>
        <addClasspath>true</addClasspath>
        <mainClass>com.myDomain.etc.MainClassName</mainClass>
        <classpathPrefix>dependency-jars/</classpathPrefix>
        </manifest>
      </archive>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.5.1</version>
    <executions>
      <execution>
        <id>copy-dependencies</id>
        <phase>package</phase>
        <goals>
            <goal>copy-dependencies</goal>
        </goals>
        <configuration>
            <outputDirectory>
               ${project.build.directory}/dependency-jars/
            </outputDirectory>
        </configuration>
      </execution>
    </executions>
  </plugin>

Com esta configuração, todas as dependências estarão localizadas em /dependency-jars. Meu aplicativo não tem Mainclasse, apenas contextos, mas uma das minhas dependências possui uma Mainclasse ( com.myDomain.etc.MainClassName) que inicia o servidor JMX e recebe um startou um stopparâmetro. Então, com isso, eu pude iniciar meu aplicativo assim:

java -jar ./lib/TestApp-1.0-SNAPSHOT.jar start

Eu espero que seja útil para todos vocês.


Eu escrevi sobre algumas maneiras diferentes de fazer isso.

Veja Jar Executável com o Apache Maven (WordPress)

ou executable-jar-with-maven-example (GitHub)

Notas

Esses prós e contras são fornecidos por Stephan .

Para implantação manual

  • Prós
  • Contras
    • Dependências estão fora do jarro final.

Copiar dependências para um diretório específico

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-dependency-plugin</artifactId>
  <executions>
    <execution>
      <id>copy-dependencies</id>
      <phase>prepare-package</phase>
      <goals>
        <goal>copy-dependencies</goal>
      </goals>
      <configuration>
        <outputDirectory>${project.build.directory}/${project.build.finalName}.lib</outputDirectory>
      </configuration>
    </execution>
  </executions>
</plugin>

Tornar o Jar executável e o Classpath Aware

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <addClasspath>true</addClasspath>
        <classpathPrefix>${project.build.finalName}.lib/</classpathPrefix>
        <mainClass>${fully.qualified.main.class}</mainClass>
      </manifest>
    </archive>
  </configuration>
</plugin>

Neste ponto, o jar é realmente executável com elementos de caminho de classe externos.

$ java -jar target/${project.build.finalName}.jar

Faça Arquivos Implantáveis

O arquivo jar é apenas executável com o diretório irmão ...lib/ . Precisamos fazer arquivos para implantar com o diretório e seu conteúdo.

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-antrun-plugin</artifactId>
  <executions>
    <execution>
      <id>antrun-archive</id>
      <phase>package</phase>
      <goals>
        <goal>run</goal>
      </goals>
      <configuration>
        <target>
          <property name="final.name" value="${project.build.directory}/${project.build.finalName}"/>
          <property name="archive.includes" value="${project.build.finalName}.${project.packaging} ${project.build.finalName}.lib/*"/>
          <property name="tar.destfile" value="${final.name}.tar"/>
          <zip basedir="${project.build.directory}" destfile="${final.name}.zip" includes="${archive.includes}" />
          <tar basedir="${project.build.directory}" destfile="${tar.destfile}" includes="${archive.includes}" />
          <gzip src="${tar.destfile}" destfile="${tar.destfile}.gz" />
          <bzip2 src="${tar.destfile}" destfile="${tar.destfile}.bz2" />
        </target>
      </configuration>
    </execution>
  </executions>
</plugin>

Agora você tem target/${project.build.finalName}.(zip|tar|tar.bz2|tar.gz) que contém o jar e lib/* .

Plugin de montagem do Apache Maven

  • Prós
  • Contras
    • Nenhum suporte de realocação de classe (use maven-shade-plugin se a realocação de classe for necessária).
<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>${fully.qualified.main.class}</mainClass>
          </manifest>
        </archive>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
      </configuration>
    </execution>
  </executions>
</plugin>

Você tem target/${project.bulid.finalName}-jar-with-dependencies.jar .

Plugin de máscara Apache Maven

  • Prós
  • Contras
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-shade-plugin</artifactId>
  <executions>
    <execution>
      <goals>
        <goal>shade</goal>
      </goals>
      <configuration>
        <shadedArtifactAttached>true</shadedArtifactAttached>
        <transformers>
          <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
            <mainClass>${fully.qualified.main.class}</mainClass>
          </transformer>
        </transformers>
      </configuration>
    </execution>
  </executions>
</plugin>

Você tem target/${project.build.finalName}-shaded.jar .

onejar-maven-plugin

  • Prós
  • Contras
    • Não é ativamente apoiado desde 2012.
<plugin>
  <!--groupId>org.dstovall</groupId--> <!-- not available on the central -->
  <groupId>com.jolira</groupId>
  <artifactId>onejar-maven-plugin</artifactId>
  <executions>
    <execution>
      <configuration>
        <mainClass>${fully.qualified.main.class}</mainClass>
        <attachToBuild>true</attachToBuild>
        <!-- https://code.google.com/p/onejar-maven-plugin/issues/detail?id=8 -->
        <!--classifier>onejar</classifier-->
        <filename>${project.build.finalName}-onejar.${project.packaging}</filename>
      </configuration>
      <goals>
        <goal>one-jar</goal>
      </goals>
    </execution>
  </executions>
</plugin>

Plugin Spring Maven

  • Prós
  • Contras
    • Adicione possíveis classes desnecessárias de Spring e Spring Boot relacionadas.
<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <executions>
    <execution>
      <goals>
        <goal>repackage</goal>
      </goals>
      <configuration>
        <classifier>spring-boot</classifier>
        <mainClass>${fully.qualified.main.class}</mainClass>
      </configuration>
    </execution>
  </executions>
</plugin>

Você tem target/${project.bulid.finalName}-spring-boot.jar .


Eu passei por cada uma dessas respostas procurando fazer um jar gordo executável contendo todas as dependências e nenhum deles funcionou direito. A resposta é o plugin de sombra, é muito fácil e simples.

    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-shade-plugin</artifactId>
      <version>2.3</version>
      <executions>
         <!-- Run shade goal on package phase -->
        <execution>
        <phase>package</phase>
        <goals>
            <goal>shade</goal>
        </goals>
        <configuration>
          <transformers>
             <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                <mainClass>path.to.MainClass</mainClass>
             </transformer>
          </transformers>
        </configuration>
          </execution>
      </executions>
    </plugin>

Esteja ciente de que suas dependências precisam ter um escopo de compilação ou tempo de execução para que isso funcione corretamente.

Este exemplo veio de mkyong.com


Eu tentei a resposta mais votada aqui, e pude fazer o jar executar. Mas o programa não funcionou corretamente. Eu não sei qual foi o motivo. Quando tento executar a partir do Eclipse , obtenho um resultado diferente, mas quando executo o jar da linha de comando, obtenho um resultado diferente (ele falha com um erro de tempo de execução específico do programa).

Eu tinha um requisito semelhante ao OP apenas que eu tinha muitas dependências (Maven) para o meu projeto. Felizmente, a única solução que funcionou para mim foi o uso do Eclipse . Muito simples e muito simples. Esta não é uma solução para o OP, mas é uma solução para alguém que tem um requisito semelhante, mas com muitas dependências do Maven,

1) Clique com o botão direito do mouse na pasta do projeto (no Eclipse) e selecione Export

2) Em seguida, selecione Java -> Runnable Jar

3) Você será solicitado a escolher o local do arquivo jar

4) Finalmente, selecione a classe que possui o método Main que você deseja executar e escolha Package dependencies with the Jar file e clique em Finish


Outra opção, se você realmente quiser reempacotar o conteúdo dos outros JARs dentro de seu único JAR resultante, é o plugin Maven Assembly . Ele descompacta e repõe tudo em um diretório via <unpack>true</unpack> . Então você teria uma segunda passagem que a construiu em um JAR massivo.

onejar-maven-plugin . Isso executa as ações de reempacotamento acima em uma única etapa.


Por muito tempo usei o plugin de assembly maven , mas não consegui encontrar uma solução para o problema com "already added, skipping" . Agora estou usando outro plugin - onejar-maven-plugin . Exemplo abaixo (jar de compilação do mvn package ):

<plugin>
    <groupId>org.dstovall</groupId>
    <artifactId>onejar-maven-plugin</artifactId>
    <version>1.3.0</version>
    <executions>
        <execution>
            <configuration>
                <mainClass>com.company.MainClass</mainClass>
            </configuration>
            <goals>
                <goal>one-jar</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Você precisa adicionar um repositório para esse plugin:

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

Se você quiser se do comando Line propriamente dito. Basta executar o comando abaixo do caminho do projeto

mvn assembly: assembly


Tomando a resposta do Unanswered e reformatando-o, nós temos:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>fully.qualified.MainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
        </plugin>
    </plugins>
</build>

Em seguida, recomendo tornar isso uma parte natural de sua compilação, em vez de algo a ser chamado explicitamente. Para tornar isso parte integrante de sua construção, inclua esse plug-in em seu pom.xml e vincule-o ao evento de ciclo de vida do package . No entanto, uma pegadinha é que você precisa chamar o assembly:single goal se colocar isso no seu pom.xml, enquanto você chamaria 'assembly: assembly' se executá-lo manualmente a partir da linha de comando.

<project>
  [...]
  <build>
      <plugins>
          <plugin>
              <artifactId>maven-assembly-plugin</artifactId>
              <configuration>
                  <archive>
                      <manifest>
                          <addClasspath>true</addClasspath>
                          <mainClass>fully.qualified.MainClass</mainClass>
                      </manifest>
                  </archive>
                  <descriptorRefs>
                      <descriptorRef>jar-with-dependencies</descriptorRef>
                  </descriptorRefs>
              </configuration>
              <executions>
                  <execution>
                      <id>make-my-jar-with-dependencies</id>
                      <phase>package</phase>
                      <goals>
                          <goal>single</goal>
                      </goals>
                  </execution>
              </executions>
          </plugin>
      [...]
      </plugins>
    [...]
  </build>
</project>

Use o maven-shade-plugin para empacotar todas as dependências em um uber-jar. Também pode ser usado para criar um jar executável especificando a classe principal. Depois de tentar usar maven-assembly e maven-jar, descobri que esse plugin é mais adequado às minhas necessidades.

Eu achei este plugin particularmente útil porque ele mescla o conteúdo de arquivos específicos em vez de sobrescrevê-los. Isso é necessário quando há arquivos de recursos que possuem o mesmo nome nos jars e o plug-in tenta empacotar todos os arquivos de recursos

Veja o exemplo abaixo

      <plugins>
    <!-- This plugin provides the capability to package the artifact in an uber-jar, including its dependencies and to shade - i.e. rename - the packages of some of the dependencies. -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>1.4</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <artifactSet>
                        <!-- signed jars-->
                            <excludes>
                                <exclude>bouncycastle:bcprov-jdk15</exclude>
                            </excludes>
                        </artifactSet>

                         <transformers>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <!-- Main class -->
                                <mainClass>com.main.MyMainClass</mainClass>
                            </transformer>
                            <!-- Use resource transformers to prevent file overwrites -->
                            <transformer 
                                 implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>properties.properties</resource>
                            </transformer>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.XmlAppendingTransformer">
                                <resource>applicationContext.xml</resource>
                            </transformer>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>META-INF/cxf/cxf.extension</resource>
                            </transformer>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.XmlAppendingTransformer">
                                <resource>META-INF/cxf/bus-extensions.xml</resource>
                            </transformer>
                     </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>

    </plugins>

Você pode adicionar o seguinte ao seu pom.xml :

<build>
<defaultGoal>install</defaultGoal>
<plugins>
  <plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.3.2</version>
    <configuration>
      <source>1.6</source>
      <target>1.6</target>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.3.1</version>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
          <mainClass>com.mycompany.package.MainClass</mainClass>
        </manifest>
      </archive>
    </configuration>
  </plugin>
  <plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
      <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
      <archive>
        <manifest>
          <mainClass>com.mycompany.package.MainClass</mainClass>
        </manifest>
      </archive>
    </configuration>
    <executions>
      <execution>
        <id>make-my-jar-with-dependencies</id>
        <phase>package</phase>
        <goals>
          <goal>single</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
</plugins>
</build>

Depois disso, você precisa alternar através do console para o diretório, onde o pom.xml está localizado. Então você tem que executar o assembly mvn: single e, em seguida, o seu arquivo JAR executável com dependências será construído esperançosamente. Você pode verificá-lo ao alternar para o diretório de saída (destino) com cd ./target e iniciar seu jar com um comando semelhante ao java -jar mavenproject1-1.0-SNAPSHOT-jar-with-dependencies.jar .

Eu testei isso com o Apache Maven 3.0.3 .


Você pode usar o maven-dependency-plugin, mas a questão era como criar um JAR executável. Para fazer isso requer a seguinte alteração na resposta de Matthew Franglen (btw, usando o plugin de dependência leva mais tempo para construir quando se inicia a partir de um alvo limpo):

<build>
    <plugins>
        <plugin>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>fully.qualified.MainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>unpack-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>unpack-dependencies</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
    <resources>
        <resource>
            <directory>${basedir}/target/dependency</directory>
        </resource>
    </resources>
</build>

Você pode usar o plugin de dependência para gerar todas as dependências em um diretório separado antes da fase do pacote e, em seguida, incluí-lo no caminho de classe do manifesto:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>prepare-package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
                <overWriteReleases>false</overWriteReleases>
                <overWriteSnapshots>false</overWriteSnapshots>
                <overWriteIfNewer>true</overWriteIfNewer>
            </configuration>
        </execution>
    </executions>
</plugin>
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <classpathPrefix>lib/</classpathPrefix>
                <mainClass>theMainClass</mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>

Como alternativa, use ${project.build.directory}/classes/lib como OutputDirectory para integrar todos os arquivos jar no jar principal, mas você precisará adicionar um código de carregamento de classe personalizado para carregar os jars.



Adicione ao pom.xml:

  <dependency>
            <groupId>com.jolira</groupId>
            <artifactId>onejar-maven-plugin</artifactId>
            <version>1.4.4</version>
  </dependency>

e

<plugin>
       <groupId>com.jolira</groupId>
       <artifactId>onejar-maven-plugin</artifactId>
       <version>1.4.4</version>
       <executions>
              <execution>
                     <goals>
                         <goal>one-jar</goal>
                     </goals>
              </execution>
       </executions>
</plugin>

É isso aí. O próximo pacote mvn também criará um frasco de gordura, incluindo todos os frascos de dependência.


Para quem procura opções para excluir dependências específicas do uber-jar, esta é uma solução que funcionou para mim:

<project...>
<dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>1.6.1</version>
            <scope>provided</scope> <=============
        </dependency>
</dependencies>
<build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>...</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Portanto, não é uma configuração do plugin mvn-assembly, mas uma propriedade da dependência.


Eu comparei os plugins da árvore mencionados neste post. Eu gerou dois frascos e um diretório com todos os frascos. Eu comparei os resultados e definitivamente o plugin maven-shade é o melhor. Meu desafio era ter vários recursos de Spring que precisavam ser mesclados, assim como os serviços jax-rs e JDBC. Eles foram todos mesclados corretamente pelo plugin de sombra em comparação com o maven-assembly-plugin. Nesse caso, a fonte falhará, a menos que você copie-a para sua pasta de recursos e mescle-a manualmente uma vez. Ambos os plugins geram a árvore de dependências correta. Eu tinha vários escopos como teste, fornecer, compilar, etc o teste e fornecidos foram ignorados por ambos os plugins. Ambos produziram o mesmo manifesto, mas consegui consolidar licenças com o plugin de sombra usando o transformador. Com o plugin maven-dependency, é claro que você don 'Não tenho esses problemas porque os frascos não são extraídos. Mas como alguns outros apontaram, você precisa carregar um (s) arquivo (s) extra (s) para funcionar corretamente. Aqui está um recorte do pom.xml

            <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>prepare-package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        <includeScope>compile</includeScope>
                        <excludeTransitive>true</excludeTransitive>
                        <overWriteReleases>false</overWriteReleases>
                        <overWriteSnapshots>false</overWriteSnapshots>
                        <overWriteIfNewer>true</overWriteIfNewer>
                    </configuration>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>com.rbccm.itf.cdd.poller.landingzone.LandingZonePoller</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-my-jar-with-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>2.4.3</version>
            <configuration>
                <shadedArtifactAttached>false</shadedArtifactAttached>
                <keepDependenciesWithProvidedScope>false</keepDependenciesWithProvidedScope>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/services/javax.ws.rs.ext.Providers</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.factories</resource>
                    </transformer>
                    <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>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.tooling</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"/>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ApacheLicenseResourceTransformer">
                    </transformer>
                </transformers>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>

O maven-assembly-plugin funcionou muito bem para mim. Passei horas com o plugin maven-dependency e não consegui fazer funcionar. A principal razão foi que eu tinha que definir explicitamente na seção de configuração os itens de artefatos que deveriam ser incluídos como estão descritos na documentation . Existe um exemplo para os casos em que você deseja usá-lo como:, mvn dependency:copyonde não estão incluídos quaisquer artefatos, mas isso não funciona.


Para resolver esse problema, usaremos o Plug-in de Montagem do Maven que criará o JAR junto com seus JARs de dependência em um único arquivo JAR executável. Basta adicionar abaixo a configuração do plugin no seu arquivo pom.xml.

<build>
   <pluginManagement>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
               <archive>
                  <manifest>
                     <addClasspath>true</addClasspath>
                     <mainClass>com.your.package.MainClass</mainClass>
                  </manifest>
               </archive>
               <descriptorRefs>
                  <descriptorRef>jar-with-dependencies</descriptorRef>
               </descriptorRefs>
            </configuration>
            <executions>
               <execution>
                  <id>make-my-jar-with-dependencies</id>
                  <phase>package</phase>
                  <goals>
                     <goal>single</goal>
                  </goals>
               </execution>
            </executions>
         </plugin>
      </plugins>
   </pluginManagement>
</build>

Depois de fazer isso, não se esqueça de executar a ferramenta MAVEN com este comando mvn clean compile assembly: single

http://jkoder.com/maven-creating-a-jar-together-with-its-dependency-jars-into-a-single-executable-jar-file/





executable-jar