Incluyendo dependencias en un frasco con Maven

¿Hay alguna manera de obligar a maven (2.0.9) a incluir todas las dependencias en un solo archivo jar?

Tengo un proyecto que se construye en un solo archivo jar. Quiero que las clases de las dependencias también se copien en el jar.

Actualización: Sé que no puedo incluir un archivo jar en un archivo jar. Estoy buscando una forma de descomprimir los frascos que se especifican como dependencias y empaquetar los archivos de clase en mi jar.

Puede hacerlo utilizando el complemento maven-assembly con el descriptor "jar-with-dependencies". Aquí está el fragmento relevante de uno de nuestros pom.xml que hace esto:

  <build>
    <plugins>
      <!-- any other plugins -->
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
      </plugin>
    </plugins>
  </build>

Con Maven 2, la forma correcta de hacerlo es usar el complemento de ensamblaje Maven2 que tiene un archivo descriptor predefinido para este propósito y que puede usar en la línea de comandos:

mvn assembly:assembly -DdescriptorId=jar-with-dependencies

Si desea hacer que este jar sea ejecutable, simplemente agregue la clase principal que se ejecutará a la configuración del complemento:

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>my.package.to.my.MainClass</mainClass>
      </manifest>
    </archive>
  </configuration>
</plugin>

Si desea crear ese ensamblaje como parte del proceso de compilación normal, debe vincular el objetivo único o el directorio único (el assemblyobjetivo SOLO debe ejecutarse desde la línea de comandos) a una fase del ciclo de vida ( packagetiene sentido), algo como esto:

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <executions>
    <execution>
      <id>create-my-bundle</id>
      <phase>package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        ...
      </configuration>
    </execution>
  </executions>
</plugin>

Adapte el configurationelemento para adaptarlo a sus necesidades (por ejemplo, con el material manifiesto como se dice)

Si desea hacer un archivo jar ejecutable, también deben establecer la clase principal. Entonces la configuración completa debería ser.

    <plugins>
            <plugin>
                 <artifactId>maven-assembly-plugin</artifactId>
                 <executions>
                     <execution>
                          <phase>package</phase>
                          <goals>
                              <goal>single</goal>
                          </goals>
                      </execution>
                  </executions>
                  <configuration>
                       <!-- ... -->
                       <archive>
                           <manifest>
                                 <mainClass>fully.qualified.MainClass</mainClass>
                           </manifest>
                       </archive>
                       <descriptorRefs>
                           <descriptorRef>jar-with-dependencies</descriptorRef>
                      </descriptorRefs>
                 </configuration>
         </plugin>
   </plugins>

Ahí está el plugin de sombra maven . Se puede usar para empaquetar y renombrar dependencias (para omitir problemas de dependencia en el classpath).

Puede usar el jar recién creado con una <classifier>etiqueta.

<dependencies>
    <dependency>
        <groupId>your.group.id</groupId>
        <artifactId>your.artifact.id</artifactId>
        <version>1.0</version>
        <type>jar</type>
        <classifier>jar-with-dependencies</classifier>
    </dependency>
</dependencies>

Si a usted (como a mí) no le gusta especialmente el enfoque de jar con dependencias descrito anteriormente, la solución de Maven que prefiero es simplemente construir un proyecto WAR, incluso si solo está creando una aplicación Java independiente:

1. Haga un proyecto jar maven normal, que construirá su archivo jar (sin las dependencias).

2. Además, configure un proyecto de guerra maven (con solo un archivo src / main / webapp / WEB-INF / web.xml vacío , que evitará una advertencia / error en la compilación maven), que solo tiene su proyecto jar como una dependencia, y haga que su proyecto jar esté <module>debajo de su proyecto war. (Este proyecto de guerra es solo un simple truco para envolver todas sus dependencias de archivos jar en un archivo zip).

3. Construye el proyecto de guerra para producir el archivo de guerra.

4. En el paso de implementación, simplemente cambie el nombre de su archivo .war a * .zip y descomprímalo.

Ahora debería tener un directorio lib (que puede mover donde lo desee) con su jar y todas las dependencias que necesita para ejecutar su aplicación:

java -cp 'path/lib/*' MainClass

(El comodín en classpath funciona en Java-6 o superior)

Creo que esto es más simple de configurar en Maven (no es necesario jugar con el complemento de ensamblaje) y también le da una visión más clara de la estructura de la aplicación (verá los números de versión de todos los archivos jar dependientes en vista simple, y evite obstruir todo en un solo archivo jar).

http://fiji.sc/Uber-JAR proporciona una excelente explicación de las alternativas:

Hay tres métodos comunes para construir un uber-JAR:

1. Sin sombrear Descomprima todos los archivos JAR, luego vuelva a empaquetarlos en un solo JAR.
   • Pro: funciona con el cargador de clases predeterminado de Java.
   • Con: los archivos presentes en varios archivos JAR con la misma ruta (por ejemplo, META-INF / services / javax.script.ScriptEngineFactory) se sobrescribirán entre sí, lo que provocará un comportamiento defectuoso.
   • Herramientas: Maven Assembly Plugin, Classworlds Uberjar
2. Sombreado Igual que sin sombrear, pero cambie el nombre (es decir, "sombrear") todos los paquetes de todas las dependencias.
   • Pro: funciona con el cargador de clases predeterminado de Java. Evita algunos (no todos) conflictos de versiones de dependencia.
   • Con: los archivos presentes en varios archivos JAR con la misma ruta (por ejemplo, META-INF / services / javax.script.ScriptEngineFactory) se sobrescribirán entre sí, lo que provocará un comportamiento defectuoso.
   • Herramientas: Maven Shade Plugin
3. JAR de JAR. El archivo JAR final contiene los otros archivos JAR integrados.
   • Pro: evita conflictos de versiones de dependencia. Todos los archivos de recursos se conservan.
   • Con: necesita agrupar un cargador de clases especial "bootstrap" para permitir que Java cargue clases desde los archivos JAR envueltos. La depuración de problemas del cargador de clases se vuelve más compleja.
   • Herramientas: Eclipse JAR File Exporter, One-JAR.

        <!-- Method 1 -->
        <!-- Copy dependency libraries jar files to a separated LIB folder -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
                <excludeTransitive>false</excludeTransitive> 
                <stripVersion>false</stripVersion>
            </configuration>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <!-- Add LIB folder to classPath -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.4</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <classpathPrefix>lib/</classpathPrefix>
                    </manifest>
                </archive>
            </configuration>
        </plugin>


        <!-- Method 2 -->
        <!-- Package all libraries classes into one runnable jar -->
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <executions>
              <execution>
                <phase>package</phase>
                <goals>
                  <goal>single</goal>
                </goals>
              </execution>
            </executions>
            <configuration>
              <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
              </descriptorRefs>
            </configuration>
        </plugin>            

Mi solución definitiva en Eclipse Luna y m2eclipse: Custom Classloader (descargue y agregue a su proyecto, solo 5 clases): http://git.eclipse.org/c/jdt/eclipse.jdt.ui.git/plain/org. eclipse.jdt.ui / jar% 20in% 20jar% 20loader / org / eclipse / jdt / internal / jarinjarloader / ; este cargador de clases es el mejor cargador de clases de un solo contenedor y muy rápido;

<project.mainClass>org.eclipse.jdt.internal.jarinjarloader.JarRsrcLoader</project.mainClass> <project.realMainClass>my.Class</project.realMainClass>

Editar en JIJConstants "Rsrc-Class-Path" a "Class-Path"
mvn clean dependency: el paquete copy-dependencies
se crea un jar con dependencias en la carpeta lib con un cargador de clases delgado

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.java</include>
                <include>**/*.properties</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/*</include>
            </includes>
            <targetPath>META-INF/</targetPath>
        </resource>
        <resource>
            <directory>${project.build.directory}/dependency/</directory>
            <includes>
                <include>*.jar</include>
            </includes>
            <targetPath>lib/</targetPath>
        </resource>
    </resources>
<pluginManagement>
        <plugins>

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

                        <manifestEntries>
                            <Rsrc-Main-Class>${project.realMainClass}  </Rsrc-Main-Class>
                            <Class-Path>./</Class-Path>
                        </manifestEntries>

                    </archive>
                </configuration>
            </plugin>
<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </pluginManagement>
</build>

Dejando a un lado a Maven, puedes poner bibliotecas JAR dentro del Main Jar pero necesitarás usar tu propio cargador de clases.

Verifique este proyecto: Texto de enlace de un JAR

Esta publicación puede ser un poco antigua, pero también tuve el mismo problema recientemente. La primera solución propuesta por John Stauffer es buena, pero tuve algunos problemas ya que estoy trabajando esta primavera. Los tarros de dependencia de Spring que uso tienen algunos archivos de propiedades y declaraciones de esquemas xml que comparten las mismas rutas y nombres. Aunque estos frascos provienen de las mismas versiones, las jarras con dependencias maven-goal estaba sobrescribiendo el archivo de tesis con el último archivo encontrado.

Al final, la aplicación no pudo iniciarse ya que los tarros de primavera no pudieron encontrar los archivos de propiedades correctos. En este caso, la solución propuesta por Rop ha resuelto mi problema.

También desde entonces, el proyecto de arranque de primavera ahora existe. Tiene una manera genial de manejar este problema al proporcionar un objetivo experto que sobrecarga el objetivo del paquete y proporciona su propio cargador de clases. Ver la guía de referencia de botas de resorte

Echa un vistazo a esta respuesta:

Estoy creando un instalador que se ejecuta como un archivo JAR de Java y necesita descomprimir los archivos WAR y JAR en los lugares apropiados en el directorio de instalación. El complemento de dependencia se puede usar en la fase de paquete con el objetivo de copia y descargará cualquier archivo en el repositorio de Maven (incluidos los archivos WAR) y los escribirá donde los necesite. Cambié el directorio de salida a $ {project.build.directory} / classes y luego el resultado final es que la tarea JAR normal incluye mis archivos perfectamente. Luego puedo extraerlos y escribirlos en el directorio de instalación.

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
    <execution>
        <id>getWar</id>
        <phase>package</phase>
        <goals>
            <goal>copy</goal>
        </goals>
        <configuration>
            <artifactItems>
                <artifactItem>
                    <groupId>the.group.I.use</groupId>
                    <artifactId>MyServerServer</artifactId>
                    <version>${env.JAVA_SERVER_REL_VER}</version>
                    <type>war</type>
                    <destFileName>myWar.war</destFileName>
                </artifactItem>
            </artifactItems>
            <outputDirectory>${project.build.directory}/classes</outputDirectory>
        </configuration>
    </execution>
</executions>

Gracias. He agregado el fragmento a continuación en el archivo POM.xml y el problema de Mp resuelto y creo un archivo jar gordo que incluye todos los frascos dependientes.

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
        <executions>
            <execution>
                <phase>package</phase>
                <goals>
                    <goal>single</goal>
                </goals>
            </execution>
        </executions>
        <configuration>
            <descriptorRefs>
                <descriptorRef>dependencies</descriptorRef>
            </descriptorRefs>
        </configuration>
    </plugin>
</plugins>