web-dev-qa-db-fra.com

Comment créer un pot exécutable à base de printemps avec maven?

J'ai un projet client Spring-WS basé sur Maven que je souhaite empaqueter sous la forme d'un fichier jar. Dans Eclipse, tout fonctionne correctement. Lorsque j'essaie de le conditionner en tant que fichier jar exécutable, j'obtiens des exceptions ClassNotFound, car les fichiers jar Spring ne sont pas inclus dans mon fichier jar d'application.

J'ai donc ajouté le maven-shade-plugin pour inclure toutes mes dépendances dans mon fichier jar. Lorsque je regarde mon fichier jar app, je vois tous les fichiers de classe de toutes les dépendances incluses (tous les fichiers jar de la bibliothèque sont éclatés).

<build>
    <plugins>
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>1.6</source>
                <target>1.6</target>
            </configuration>
        </plugin>

        <plugin>
            <groupId>org.Apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.4</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>com.cws.cs.Client</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>

        <plugin>
            <groupId>org.Apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>1.7</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                </execution>
            </executions>

        </plugin>
    </plugins>
</build>

Mon problème est que dans le processus d’emballage, mes multiples dépendances de ressort ont des fichiers META-INF/spring.schemas différents qui se substituent les uns aux autres. Par conséquent, mon dernier pot contient un fichier spring.schemas incomplet.

Ainsi, lorsque j'essaie d'exécuter mon fichier jav exécutable, des messages d'erreur Spring m'indiquent que les fichiers sont introuvables, car le fichier spring.schemas est incomplet (le fichier jar de Spring-WS a remplacé le fichier spring.schemas du composant Spring-core). 

Les fichiers META-INF/spring.schemas de mon pot exécutable:

http\://www.springframework.org/schema/web-services/web-services-1.5.xsd=/org/springframework/ws/config/web-services-1.5.xsd
http\://www.springframework.org/schema/web-services/web-services-2.0.xsd=/org/springframework/ws/config/web-services-2.0.xsd
http\://www.springframework.org/schema/web-services/web-services.xsd=/org/springframework/ws/config/web-services-2.0.xsd

Au lieu de Spring-beans.jar META-INF/spring.schemas:

http\://www.springframework.org/schema/beans/spring-beans-2.0.xsd=org/springframework/beans/factory/xml/spring-beans-2.0.xsd
http\://www.springframework.org/schema/beans/spring-beans-2.5.xsd=org/springframework/beans/factory/xml/spring-beans-2.5.xsd
http\://www.springframework.org/schema/beans/spring-beans-3.0.xsd=org/springframework/beans/factory/xml/spring-beans-3.0.xsd
http\://www.springframework.org/schema/beans/spring-beans-3.1.xsd=org/springframework/beans/factory/xml/spring-beans-3.1.xsd
http\://www.springframework.org/schema/beans/spring-beans.xsd=org/springframework/beans/factory/xml/spring-beans-3.1.xsd
http\://www.springframework.org/schema/tool/spring-tool-2.0.xsd=org/springframework/beans/factory/xml/spring-tool-2.0.xsd
http\://www.springframework.org/schema/tool/spring-tool-2.5.xsd=org/springframework/beans/factory/xml/spring-tool-2.5.xsd
http\://www.springframework.org/schema/tool/spring-tool-3.0.xsd=org/springframework/beans/factory/xml/spring-tool-3.0.xsd
http\://www.springframework.org/schema/tool/spring-tool-3.1.xsd=org/springframework/beans/factory/xml/spring-tool-3.1.xsd
http\://www.springframework.org/schema/tool/spring-tool.xsd=org/springframework/beans/factory/xml/spring-tool-3.1.xsd
http\://www.springframework.org/schema/util/spring-util-2.0.xsd=org/springframework/beans/factory/xml/spring-util-2.0.xsd
http\://www.springframework.org/schema/util/spring-util-2.5.xsd=org/springframework/beans/factory/xml/spring-util-2.5.xsd
http\://www.springframework.org/schema/util/spring-util-3.0.xsd=org/springframework/beans/factory/xml/spring-util-3.0.xsd
http\://www.springframework.org/schema/util/spring-util-3.1.xsd=org/springframework/beans/factory/xml/spring-util-3.1.xsd
http\://www.springframework.org/schema/util/spring-util.xsd=org/springframework/beans/factory/xml/spring-util-3.1.xsd

Je suis perplexe. Je ne sais pas si/comment je peux tout mettre dans un fichier jar exécutable. Je ne sais pas s'il s'agit d'un problème de configuration de Shadow Plugin ou si j'essaie de faire quelque chose d'impossible. Il ne semble pas correct de devoir créer manuellement mon propre fichier spring.schemas (une concaténation des autres).

J'ai peut-être un peu sauté le flingue. En déterrant plus d'informations sur le plugin shade, j'ai remarqué le AppendingTransformer que j'avais précédemment manqué. Cependant, mon souci est de savoir quels autres fichiers ont les mêmes problèmes? J'ai découvert/attrapé ce numéro de printemps en particulier. Je n'ai aucune idée des autres bibliothèques qui pourraient faire quelque chose de similaire ...

Toute suggestion serait appréciée.

javaspringmavenspring-wsmaven-shade-plugin
28
Eric B.

Au lieu de maven-shade-plugin, utilisez onejar-maven-plugin . One-JAR vous permet de conditionner une application Java avec ses fichiers JAR de dépendance dans un seul fichier Jar exécutable.

6
amra

Vous pouvez ajouter la configuration suivante de sorte que le contenu des fichiers .schema de tous les fichiers JAR soit ajouté ensemble.

<configuration>
  <transformers>
    <transformer implementation="org.Apache.maven.plugins.shade.resource.AppendingTransformer">
      <resource>META-INF/spring.handlers</resource>
    </transformer>
    <transformer implementation="org.Apache.maven.plugins.shade.resource.AppendingTransformer">
      <resource>META-INF/spring.schemas</resource>
    </transformer>
  </transformers>
</configuration>
59
gkamal

Hier, j'ai aussi rencontré ce problème.

La solution consistait à préparer les fichiers requis par concaténation manuelle et à configurer le plugin Assembly de la manière suivante:

  <files>
    <file>
        <source>src/META-INF/spring.schemas</source>
        <outputDirectory>META-INF</outputDirectory>
    </file>
    <file>
        <source>src/META-INF/spring.handlers</source>
        <outputDirectory>META-INF</outputDirectory>
    </file>
  </files>
  <dependencySets>
    <dependencySet>
      <outputDirectory>/</outputDirectory>
      <useProjectArtifact>true</useProjectArtifact>
      <unpack>true</unpack>
      <scope>runtime</scope>
      <unpackOptions>
        <excludes>
            <exclude>META-INF/spring.handlers</exclude>
            <exclude>META-INF/spring.schemas</exclude>
        </excludes>
      </unpackOptions>  
    </dependencySet>
  </dependencySets>

REMARQUE: il n'est pas suffisant d'utiliser une approche de type jar - vous ne pouvez pas être sûr d'avoir des fichiers mélangés sous la main, essayez de conserver l'exportation de toutes les dépendances telle quelle ... 

4
Mikhail Tsaplin
Assembly plugin have issues, use below plugin

<plugin>
    <groupId>org.Apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer implementation="org.Apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>at.seresunit.lecturemanager_connector.App</mainClass>
                    </transformer>
                    <transformer implementation="org.Apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.handlers</resource>
                    </transformer>
                    <transformer implementation="org.Apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.schemas</resource>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

you may get security exception resolve it using below configuration

 <configuration>
    <filters>
        <filter>
            <artifact>*:*</artifact>
            <excludes>
                <exclude>META-INF/*.SF</exclude>
                <exclude>META-INF/*.DSA</exclude>
                <exclude>META-INF/*.RSA</exclude>
            </excludes>
        </filter>
    </filters>
</configuration>
1
aamir

Avez-vous essayé le maven-Assembly-plugin ?

Il créera un seul fichier jar avec des dépendances et pourra en outre rendre ce fichier jar exécutable:

Utilisez mainClass pour spécifier la classe que vous souhaitez exécuter.

<plugin>
    <artifactId>maven-Assembly-plugin</artifactId>
    <version>2.3</version>
    <configuration>
      <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
      <archive>
        <manifest>
          <mainClass>org.sample.App</mainClass>
        </manifest>
      </archive>
    </configuration>
    <executions>
      <execution>
        <id>make-Assembly</id> <!-- this is used for inheritance merges -->
        <phase>package</phase> <!-- bind to the packaging phase -->
        <goals>
          <goal>single</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
1
Jean-Philippe Briend