forzare Maven a copiare le dipendenze in target / lib

Come posso copiare le dipendenze di runtime del mio progetto nella target/libcartella?

Come è adesso, dopo che mvn clean installla targetcartella contiene solo il vaso del mio progetto, ma nessuna delle dipendenze di runtime.

Questo funziona per me:

<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>

L'approccio migliore dipende da cosa vuoi fare:

• Se vuoi raggruppare le tue dipendenze in un file WAR o EAR, imposta semplicemente il tipo di packaging del tuo progetto su EAR o WAR. Maven raggrupperà le dipendenze nella giusta posizione.
• Se si desidera creare un file JAR che includa il codice insieme a tutte le dipendenze, utilizzare il plug-in di assembly con il descrittore jar-with-dependencies . Maven genererà un file JAR completo con tutte le tue classi più le classi da qualsiasi dipendenza.
• Se si desidera semplicemente trascinare le dipendenze nella directory di destinazione in modo interattivo, utilizzare il plug-in delle dipendenze per copiare i file.
• Se vuoi inserire le dipendenze per qualche altro tipo di elaborazione, probabilmente dovrai generare il tuo plugin. Esistono API per ottenere l'elenco delle dipendenze e la loro posizione sul disco. Dovrai prenderlo da lì ...

mvn install dependency:copy-dependencies 

Funziona per me con la directory delle dipendenze creata nella cartella di destinazione. Mi piace!

Dai un'occhiata al plug-in di dipendenza Maven , in particolare l' obiettivo dipendenza: copia-dipendenze . Dai un'occhiata all'esempio sotto l'intestazione La dipendenza: copia-dipendenze mojo . Imposta la proprietà di configurazione outputDirectory su $ {basedir} / target / lib (credo, dovrai testare).

Spero che questo ti aiuti.

Una soluzione semplice ed elegante per il caso in cui è necessario copiare le dipendenze in una directory di destinazione senza utilizzare altre fasi di Maven (l'ho trovato molto utile quando si lavora con Vaadin).

Esempio di pom completo:

<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>

Quindi corri mvn process-sources

Le dipendenze del file jar sono disponibili in /target/dependency

Se vuoi farlo occasionalmente (e quindi non vuoi cambiare il tuo POM), prova questa riga di comando:

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

Se si omette l' ultimo argomento , vengono inserite le dipendenze target/dependencies.

Prova qualcosa del genere:

<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>

Tutto ciò di cui hai bisogno è il seguente frammento all'interno di 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>

Quanto sopra verrà eseguito nella packagefase quando si esegue

mvn clean package

E le dipendenze verranno copiate nella directory di output specificata nello snippet, ovvero libin questo caso.

Se lo desideri solo occasionalmente, non sono necessarie modifiche a pom.xml. Esegui semplicemente quanto segue:

mvn clean package dependency:copy-dependencies

Per sovrascrivere il percorso predefinito, ovvero ${project.build.directory}/dependenciesaggiungere una proprietà di sistema denominata outputDirectory, ad es

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

Supponendo

• non vuoi modificare il pom.xml
• non si desidera eseguire l'ambito del test (ad es. junit.jar) o le dipendenze fornite (ad es. wlfullclient.jar)

ecco cosa ha funzionato per me:

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

Se vuoi consegnare un bundle del tuo jar dell'applicazione, insieme a tutte le sue dipendenze e alcuni script per invocare la MainClass, guarda appassembler-maven-plugin .

La seguente configurazione genererà script per Windows e Linux per avviare l'applicazione (con un percorso generato che fa riferimento a tutti i barattoli delle dipendenze, scarica tutte le dipendenze (in una cartella lib sotto target / appassembler). Il plugin di assemblaggio può quindi essere utilizzato per impacchettare l'intero directory appassembler in un file zip che viene installato / distribuito insieme al jar nel repository.

  <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> 

Il descrittore di assembly (in src / main / assembly) per impacchettare la directory come zip sarebbe:

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

Se rendi il tuo progetto una guerra o un tipo di orecchio, la copia copierà le dipendenze.

È possibile utilizzare il plug-in Ombra per creare un super vaso in cui è possibile raggruppare tutte le dipendenze di terze parti.

Giusto per precisare ciò che è già stato detto in breve. Volevo creare un file JAR eseguibile che includesse le mie dipendenze insieme al mio codice. Questo ha funzionato per me:

(1) Nel pom, sotto <build> <plugins>, ho incluso:

<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) Esecuzione dell'assieme di compilazione mvn: assembly ha prodotto il desiderato my-project-0.1-SNAPSHOT-jar-with-dependencies.jar nella directory di destinazione del progetto.

(3) Ho eseguito il JAR con java -jar my-project-0.1-SNAPSHOT-jar-with-dependencies.jar

È una soluzione pesante per incorporare dipendenze pesanti, ma il plugin di assemblaggio di Maven fa il trucco per me.

@ Risposta di Rich venditore dovrebbe funzionare, anche se per i casi più semplici si deve solo bisogno di questo estratto dalla guida utilizzo :

<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>

Se riscontri problemi relativi alle dipendenze che non compaiono nel file WEB-INF / lib durante l'esecuzione su un server Tomcat in Eclipse, dai un'occhiata a questo:

ClassNotFoundException DispatcherServlet all'avvio di Tomcat (dipendenze Maven non copiate in wtpwebapps)

È stato semplicemente necessario aggiungere le dipendenze Maven in Proprietà del progetto> Assembly di distribuzione.