obligar a Maven a copiar dependencias en target / lib

¿Cómo copio las dependencias de tiempo de ejecución de mi proyecto en la target/libcarpeta?

Como es ahora, después de que mvn clean installla targetcarpeta contenga solo el jar de mi proyecto, pero ninguna de las dependencias de tiempo de ejecución.

Esto funciona para mi:

<project>
  ...
  <profiles>
    <profile>
      <id>qa</id>
      <build>
        <plugins>
          <plugin>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
              <execution>
                <phase>install</phase>
                <goals>
                  <goal>copy-dependencies</goal>
                </goals>
                <configuration>
                  <outputDirectory>${project.build.directory}/lib</outputDirectory>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
</project>

El mejor enfoque depende de lo que quieras hacer:

• Si desea agrupar sus dependencias en un archivo WAR o EAR, simplemente configure el tipo de paquete de su proyecto en EAR o WAR. Maven agrupará las dependencias en la ubicación correcta.
• Si desea crear un archivo JAR que incluya su código junto con todas sus dependencias, use el complemento de ensamblaje con el descriptor jar-with-dependencies . Maven generará un archivo JAR completo con todas sus clases más las clases de cualquier dependencia.
• Si desea simplemente extraer sus dependencias en el directorio de destino de forma interactiva, utilice el complemento de dependencia para copiar sus archivos.
• Si desea obtener las dependencias para algún otro tipo de procesamiento, probablemente necesitará generar su propio complemento. Hay API para obtener la lista de dependencias y su ubicación en el disco. Tendrás que llevarlo desde allí ...

mvn install dependency:copy-dependencies 

Funciona para mí con el directorio de dependencias creado en la carpeta de destino. ¡Gusta!

Eche un vistazo al complemento de dependencia de Maven , específicamente, el objetivo de dependencia: dependencias de copia . Eche un vistazo al ejemplo bajo el título La dependencia: copia-dependencias mojo . Establezca la propiedad de configuración outputDirectory en $ {basedir} / target / lib (creo que tendrá que probar).

Espero que esto ayude.

Una solución simple y elegante para el caso en que uno necesita copiar las dependencias en un directorio de destino sin usar ninguna otra fase de Maven (esto me pareció muy útil cuando trabajé con Vaadin).

Ejemplo completo de pom:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <groupId>groupId</groupId>
    <artifactId>artifactId</artifactId>
    <version>1.0</version>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.1.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-dependency-plugin</artifactId>
                    <executions>
                        <execution>
                            <phase>process-sources</phase>

                            <goals>
                                <goal>copy-dependencies</goal>
                            </goals>

                            <configuration>
                                <outputDirectory>${targetdirectory}</outputDirectory>
                            </configuration>
                        </execution>
                    </executions>
            </plugin>
        </plugins>
    </build>
</project>

Entonces corre mvn process-sources

Las dependencias del archivo jar se pueden encontrar en /target/dependency

Si desea hacer esto ocasionalmente (y por lo tanto no quiere cambiar su POM), intente esta línea de comando:

dependencia mvn: copy-dependencies -DoutputDirectory = $ {project.build.directory} / lib

Si omite el último argumento , se colocan las dependencias target/dependencies.

Intenta algo como esto:

<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>
            <mainClass>MainClass</mainClass>
        </manifest>
    </archive>
    </configuration>
</plugin>
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.4</version>
    <executions>
        <execution>
            <id>copy</id>
            <phase>install</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>
                    ${project.build.directory}/lib
                </outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>

Todo lo que necesitas es el siguiente fragmento dentro de pom.xml build/plugins:

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

Lo anterior se ejecutará en la packagefase cuando ejecutes

mvn clean package

Y las dependencias se copiarán al directorio de salida especificado en el fragmento, es decir, liben este caso.

Si solo desea hacerlo ocasionalmente, no se requieren cambios en pom.xml. Simplemente ejecute lo siguiente:

mvn clean package dependency:copy-dependencies

Para anular la ubicación predeterminada, que es ${project.build.directory}/dependencies, agregue una propiedad del Sistema llamada outputDirectory, es decir

    -DoutputDirectory=${project.build.directory}/lib

suponiendo que

• no quieres alterar el pom.xml
• no desea un alcance de prueba (por ejemplo, junit.jar) o dependencias proporcionadas (por ejemplo, wlfullclient.jar)

Esto es lo que funcionó para mí:

mvn install dependency: copy-dependencies -DincludeScope = runtime -DoutputDirectory = target / lib

Si desea entregar un paquete de su jar de aplicación, junto con todas sus dependencias y algunos scripts para invocar MainClass, consulte el appassembler-maven-plugin .

La siguiente configuración generará scripts para Windows y Linux para iniciar la aplicación (con una ruta generada que hace referencia a todos los archivos jar de dependencias, descargue todas las dependencias (en una carpeta lib debajo de target / appassembler). El complemento de ensamblaje se puede usar para empaquetar todo appassembler directorio a un zip que se instala / implementa junto con el jar en el repositorio.

  <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>appassembler-maven-plugin</artifactId>
    <version>1.0</version>
    <executions>
      <execution>
        <id>generate-jsw-scripts</id>
        <phase>package</phase>
        <goals>
          <goal>generate-daemons</goal>
        </goals>
        <configuration>
          <!--declare the JSW config -->
          <daemons>
            <daemon>
              <id>myApp</id>
              <mainClass>name.seller.rich.MyMainClass</mainClass>
              <commandLineArguments>
                <commandLineArgument>start</commandLineArgument>
              </commandLineArguments>
              <platforms>
                <platform>jsw</platform>
              </platforms>              
            </daemon>
          </daemons>
          <target>${project.build.directory}/appassembler</target>
        </configuration>
      </execution>
      <execution>
        <id>assemble-standalone</id>
        <phase>integration-test</phase>
        <goals>
          <goal>assemble</goal>
        </goals>
        <configuration>
          <programs>
            <program>
              <mainClass>name.seller.rich.MyMainClass</mainClass>
              <!-- the name of the bat/sh files to be generated -->
              <name>mymain</name>
            </program>
          </programs>
          <platforms>
            <platform>windows</platform>
            <platform>unix</platform>
          </platforms>
          <repositoryLayout>flat</repositoryLayout>
          <repositoryName>lib</repositoryName>
        </configuration>
      </execution>
    </executions>
  </plugin>
  <plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.2-beta-4</version>
    <executions>
      <execution>
        <phase>integration-test</phase>
        <goals>
          <goal>single</goal>
        </goals>
        <configuration>
          <descriptors>
            <descriptor>src/main/assembly/archive.xml</descriptor>
          </descriptors>
        </configuration>
      </execution>
    </executions>
  </plugin> 

El descriptor de ensamblaje (en src / main / assembly) para empaquetar el directorio como un zip sería:

<assembly>
  <id>archive</id>
  <formats>
    <format>zip</format>
  </formats>
  <fileSets>
    <fileSet>
     <directory>${project.build.directory}/appassembler</directory>
     <outputDirectory>/</outputDirectory>
    </fileSet>
  </fileSets>
</assembly>

Si hace que su proyecto sea un war o ear type maven copiará las dependencias.

Puede usar el Shade Plugin para crear un jar súper en el que puede agrupar todas sus dependencias de terceros.

Solo para explicar lo que ya se ha dicho brevemente. Quería crear un archivo JAR ejecutable que incluyera mis dependencias junto con mi código. Esto funcionó para mí:

(1) En el pom, en <build> <plugins>, incluí:

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.2-beta-5</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>dk.certifikat.oces2.some.package.MyMainClass</mainClass>
            </manifest>
        </archive>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration>
</plugin>

(2) Ejecución del ensamblaje de compilación mvn: el ensamblado produjo el my-project-0.1-SNAPSHOT-jar-with-dependencies.jar deseado en el directorio de destino del proyecto.

(3) Ejecuté el JAR con java -jar my-project-0.1-SNAPSHOT-jar-with-dependencies.jar

Es una solución pesada para incrustar dependencias pesadas, pero el complemento de ensamblaje de Maven hace el truco por mí.

La respuesta de @ Rich Seller debería funcionar, aunque para casos más simples solo debería necesitar este extracto de la guía de uso :

<project>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.2.2</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Si tiene problemas relacionados con dependencias que no aparecen en el archivo WEB-INF / lib cuando se ejecuta en un servidor Tomcat en Eclipse, eche un vistazo a esto:

ClassNotFoundException DispatcherServlet al iniciar Tomcat (dependencias de Maven no copiadas a wtpwebapps)

Simplemente tenía que agregar las dependencias de Maven en Propiedades del proyecto> Ensamblaje de implementación.