web-dev-qa-db-fra.com

Créer uniquement des jar avec dépendances exécutables dans Maven

Dans mon pom.xml, j'utilise le plug-in maven-Assembly pour créer un jar avec dépendances exécutable lors de l'exécution de "mvn clean install". Il crée d'abord le fichier non-exécutable "name-version.jar", puis que le "nom-version-jar-with-dependencies.jar".

Puis-je configurer le pom.xml de façon à ce qu'il ne crée pas le fichier JAR non exécutable?

Pour le moment, j'utilise <appendAssemblyId> false </ appendAssemblyId> afin de simplement écraser le premier fichier ...

De plus, je reçois plusieurs messages "... déjà ajoutés, en sautant". Puis-je en quelque sorte les empêcher?

Voici la définition de maven-Assembly-plugin dans mon pom.xml:

<plugin>
    <artifactId>maven-Assembly-plugin</artifactId>
    <version>2.2-beta-5</version>
    <configuration>
        <appendAssemblyId>false</appendAssemblyId>
        <archive>
            <manifest>
                <mainClass>my.main.class</mainClass>
            </manifest>
        </archive>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration>
    <executions>
        <execution>
            <id>make-Assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>
mavenjar
26
phil

Je l'ai fait fonctionner en utilisant le maven-jar-plugin et le single goal de maven-Assembly-plugin comme ceci

<plugin>
    <groupId>org.Apache.maven.plugins</groupId>
    <artifactId>maven-Assembly-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
            <configuration>
                <finalName>finalName</finalName>
                <archive>
                    <manifest>
                        <mainClass>
                            mainClass
                        </mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
        </execution>
    </executions>
</plugin>

Quoi qu'il en soit, le plus important est de dire à maven de ne pas générer le fichier jar par défaut en utilisant cette configuration du maven-jar-plugin

<plugin>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.0.2</version>
    <executions>
        <execution>
            <id>default-jar</id>
            <phase>none</phase>
        </execution>
    </executions>
</plugin>
4
Matteo Casaro

Je pense avoir compris comment faire cela. Vous devez quitter le pot, sinon vous perdrez le compilateur et la copie des ressources, ainsi que tout ce qui va avec la construction du pot dont vous avez besoin.

Ma solution implique essentiellement de tromper maven, alors je suppose que la chose dont il faut se méfier, c'est qu'il est très possible que dans les prochaines versions, cela ne fonctionne pas ...

<build>
    <defaultGoal>install</defaultGoal>
    <plugins>
        <plugin>
            <groupId>org.Apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>1.6</source>
                <target>1.6</target>
            </configuration>
        </plugin>
        <plugin>
            <artifactId>maven-Assembly-plugin</artifactId>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <finalName>dumpster-diver</finalName>
                <appendAssemblyId>false</appendAssemblyId>
                <archive>
                    <manifest>
                        <mainClass>DumpsterDiver</mainClass>
                    </manifest>
                </archive>
            </configuration>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
    <finalName>${project.artifactId}</finalName>
</build>

Notez que dans la configuration de construction répertoriée, le nom final de maven-Assembly-plugin ET la construction elle-même correspondent. Notez également le <appendAssemblyId>false</appendAssemblyId>. Si vous faites cela, le nom du fichier de sortie de la construction et du jar Assembly sera identique. Maven vous avertira certainement à ce sujet, mais mettra le pot que vous voulez dans votre répertoire cible ET dans votre référentiel local.

Voici la sortie de 'mvn clean install' sur ce projet, ainsi que jar -tvf sur le jar du répertoire cible et du référentiel local:

$ mvn clean install
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Building dumpster-diver
[INFO]    task-segment: [clean, install]
[INFO] ------------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] Deleting directory <currentDirectory>/target
[INFO] [resources:resources {execution: default-resources}]
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 1 resource
[INFO] [compiler:compile {execution: default-compile}]
[INFO] Compiling 1 source file to <currentDirectory>/target/classes
[INFO] [resources:testResources {execution: default-testResources}]
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory <currentDirectory>/src/test/resources
[INFO] [compiler:testCompile {execution: default-testCompile}]
[INFO] No sources to compile
[INFO] [surefire:test {execution: default-test}]
[INFO] No tests to run.
[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: <currentDirectory>/target/dumpster-diver.jar
[INFO] [Assembly:single {execution: default}]
[INFO] Processing DependencySet (output=)
[WARNING] Artifact: <groupId>:dumpster-diver:jar:0.1.0-SNAPSHOT references the same file as the Assembly destination file. Moving it to a temporary location for inclusion.
[INFO] Building jar: <currentDirectory>/target/dumpster-diver.jar
[WARNING] Configuration options: 'appendAssemblyId' is set to false, and 'classifier' is missing.
Instead of attaching the Assembly file: <currentDirectory>/target/dumpster-diver.jar, it will become the file for main project artifact.
NOTE: If multiple descriptors or descriptor-formats are provided for this project, the value of this file will be non-deterministic!
[WARNING] Replacing pre-existing project main-artifact file: <currentDirectory>/target/archive-tmp/dumpster-diver.jar
with Assembly file: <currentDirectory>/target/dumpster-diver.jar
[INFO] [install:install {execution: default-install}]
[INFO] Installing <currentDirectory>/target/dumpster-diver.jar to /opt/m2repo/<groupId>/dumpster-diver/0.1.0-SNAPSHOT/dumpster-diver-0.1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4 seconds
[INFO] Finished at: Thu Aug 18 13:08:56 EDT 2011
[INFO] Final Memory: 22M/618M
[INFO] ------------------------------------------------------------------------
krohr@krohr-Latitude-E6500:<currentDirectory>
$ jar -tvf ./target/dumpster-diver.jar | grep -i "dump"
  6831 Thu Aug 18 13:08:54 EDT 2011 DumpsterDiver.class
  6831 Thu Aug 18 13:08:54 EDT 2011 DumpsterDiver.class
     0 Thu Aug 18 13:08:56 EDT 2011 META-INF/maven/<groupId>/dumpster-diver/
  2580 Thu Aug 18 13:01:46 EDT 2011 META-INF/maven/<groupId>/dumpster-diver/pom.xml
       126 Thu Aug 18 13:08:54 EDT 2011 META-INF/maven/<groupId>/dumpster-diver/pom.properties
krohr@krohr-Latitude-E6500:<currentDirectory>
$ jar -tvf /opt/m2repo/<groupId>/dumpster-diver/0.1.0-SNAPSHOT/dumpster-diver-0.1.0-SNAPSHOT.jar | grep -i "dump"
  6831 Thu Aug 18 13:08:54 EDT 2011 DumpsterDiver.class
  6831 Thu Aug 18 13:08:54 EDT 2011 DumpsterDiver.class
     0 Thu Aug 18 13:08:56 EDT 2011 META-INF/maven/<groupId>/dumpster-diver/
  2580 Thu Aug 18 13:01:46 EDT 2011 META-INF/maven/<groupId>/dumpster-diver/pom.xml
   126 Thu Aug 18 13:08:54 EDT 2011 META-INF/maven/<groupId>/dumpster-diver/pom.properties
4
kevinmrohr

Vous pouvez essayer de régler pour pomper. Cela empêchera la création du fichier jar default.

<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/xsd/maven-4.0.0.xsd">
  ...
  <packaging>pom</packaging>
  ...
</project>
1
Raghuram

Peut-être que je manque quelque chose à propos de votre question mais le code suivant me fait un seul jar exécutable: Est-ce ce que vous cherchez?

              <plugin>
              <groupId>org.Apache.maven.plugins</groupId>
              <artifactId>maven-jar-plugin</artifactId>
              <version>2.3.1</version>
              <configuration>
                    <archive>
                          <manifest>
                              <addClasspath>true</addClasspath>
                                <mainClass>some.main.class</mainClass>
                          </manifest>
                    </archive>
                    <finalName>Proj-${project.version}</finalName>
                    <outputDirectory>target</outputDirectory>
              </configuration>
        </plugin>
0
Rob McFeely

Vous pouvez utiliser cette construction ci-dessous et compiler avec cette commande: 

mvn clean compile Assembly: single 

<build>
    <plugins>
        <plugin>
            <artifactId>maven-Assembly-plugin</artifactId>
            <version>3.1.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>youMainClass</mainClass>
                        </manifest>
                    </archive>

                    <finalName>${artifactId}</finalName>
                    <appendAssemblyId>false</appendAssemblyId>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
        </plugin>
    </plugins>
</build>
0
dz00dz