forcer Maven à copier les dépendances dans target / lib

Comment obtenir les dépendances d'exécution de mon projet copiées dans le target/libdossier?

Comme c'est le cas actuellement, après que mvn clean installle targetdossier ne contienne que le pot de mon projet, mais aucune des dépendances d'exécution.

Cela fonctionne pour moi:

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

La meilleure approche dépend de ce que vous voulez faire:

• Si vous souhaitez regrouper vos dépendances dans un fichier WAR ou EAR, définissez simplement le type de package de votre projet sur EAR ou WAR. Maven regroupera les dépendances au bon endroit.
• Si vous souhaitez créer un fichier JAR qui inclut votre code avec toutes vos dépendances, utilisez le plugin d' assembly avec le descripteur jar-with-dependencies . Maven générera un fichier JAR complet avec toutes vos classes ainsi que les classes de toutes les dépendances.
• Si vous souhaitez simplement extraire vos dépendances dans le répertoire cible de manière interactive, utilisez le plug-in de dépendance pour copier vos fichiers.
• Si vous souhaitez extraire les dépendances pour un autre type de traitement, vous devrez probablement générer votre propre plugin. Il existe des API pour obtenir la liste des dépendances et leur emplacement sur le disque. Vous devrez le prendre à partir de là ...

mvn install dependency:copy-dependencies 

Fonctionne pour moi avec le répertoire des dépendances créé dans le dossier cible. J'aime ça!

Jetez un œil au plug - in de dépendance Maven , en particulier à l' objectif dependency: copy-dependencies . Jetez un œil à l'exemple sous le titre The dependency: copy-dependencies mojo . Définissez la propriété de configuration outputDirectory sur $ {basedir} / target / lib (je crois que vous devrez tester).

J'espère que cela t'aides.

Une solution simple et élégante pour le cas où l'on a besoin de copier les dépendances dans un répertoire cible sans utiliser d'autres phases de maven (j'ai trouvé cela très utile lorsque l'on travaille avec Vaadin).

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

Exécutez ensuite mvn process-sources

Les dépendances du fichier jar se trouvent dans /target/dependency

Si vous voulez le faire de façon occasionnelle (et donc ne voulez pas changer votre POM), essayez cette ligne de commande:

dépendance mvn: copie-dépendances -DoutputDirectory = $ {project.build.directory} / lib

Si vous omettez le dernier argument , les dépendances sont placées dans target/dependencies.

Essayez quelque chose comme ceci:

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

Tout ce dont vous avez besoin est l'extrait de code suivant dans 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>

Ce qui précède s'exécutera dans la packagephase lorsque vous exécutez

mvn clean package

Et les dépendances seront copiées dans le répertoire de sortie spécifié dans l'extrait de code, c'est- libà- dire dans ce cas.

Si vous ne souhaitez le faire qu'occasionnellement, aucune modification de pom.xml n'est requise. Exécutez simplement ce qui suit:

mvn clean package dependency:copy-dependencies

Pour remplacer l'emplacement par défaut, qui est ${project.build.directory}/dependencies, ajoutez une propriété système nommée outputDirectory, c.-à-d.

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

supposant

• vous ne voulez pas modifier le pom.xml
• vous ne voulez pas de portée de test (par exemple junit.jar) ou de dépendances fournies (par exemple wlfullclient.jar)

voici ce qui a fonctionné pour moi:

dépendance d'installation mvn: dépendances de copie -DincludeScope = runtime -DoutputDirectory = target / lib

Si vous souhaitez fournir un ensemble de votre jar d'application, ainsi que toutes ses dépendances et certains scripts pour appeler la MainClass, regardez le plugin appassembler-maven .

La configuration suivante générera des scripts pour Windows et Linux pour lancer l'application (avec un chemin généré faisant référence à tous les pots de dépendance, téléchargez toutes les dépendances (dans un dossier lib sous target / appassembler). Le plugin d'assemblage peut ensuite être utilisé pour empaqueter l'ensemble répertoire appassembler vers un zip qui est installé / déployé avec le pot dans le référentiel.

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

Le descripteur d'assembly (dans src / main / assembly) pour empaqueter le direcotry sous forme de zip serait:

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

Si vous faites de votre projet un maven de type guerre ou oreille copiera les dépendances.

Vous pouvez utiliser le plugin Shade pour créer un pot uber dans lequel vous pouvez regrouper toutes vos dépendances tierces.

Juste pour expliquer brièvement ce qui a déjà été dit. Je voulais créer un fichier JAR exécutable qui comprenait mes dépendances avec mon code. Cela a fonctionné pour moi:

(1) Dans le pom, sous <build> <plugins>, j'ai inclus:

<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) Exécution de l'assembly de compilation mvn: l'assembly a produit le fichier my-project-0.1-SNAPSHOT-jar-with-dependencies.jar souhaité dans le répertoire cible du projet.

(3) J'ai exécuté le JAR avec java -jar my-project-0.1-SNAPSHOT-jar-with-dependencies.jar

C'est une solution lourde pour intégrer de fortes dépendances, mais le plugin d'assemblage de Maven fait l'affaire pour moi.

La réponse de @ Rich Seller devrait fonctionner, mais pour les cas plus simples, vous ne devriez avoir besoin que de cet extrait du guide d'utilisation :

<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 vous rencontrez des problèmes liés à des dépendances n'apparaissant pas dans le fichier WEB-INF / lib lors de l'exécution sur un serveur Tomcat dans Eclipse, jetez un œil à ceci:

ClassNotFoundException DispatcherServlet lors du lancement de Tomcat (les dépendances Maven ne sont pas copiées dans wtpwebapps)

Vous deviez simplement ajouter les dépendances Maven dans Propriétés du projet> Assemblage de déploiement.