Come: Eclipse Maven installare vaso accumulo con dipendenze

Question

Sto usando Eclipse Maven (M2E) all'interno di Eclipse e sto in esecuzione il mio progetto come questo:

mio pom.xml assomiglia a questo:

<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>ro.project</groupId> 
    <packaging>jar</packaging> 
    <version>1.0-SNAPSHOT</version> 
    <name>ro.project</name> 

    <properties> 
     <org.springframework.version>3.1.1.RELEASE</org.springframework.version> 
     <org.hibernate.version>4.1.0.Final</org.hibernate.version> 
    </properties> 
    <dependencies> 

     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-core</artifactId> 
      <version>${org.springframework.version}</version> 
     </dependency> 
    <build> 
     <plugins> 

      <plugin> 
       <groupId>org.apache.maven.plugins</groupId> 
       <artifactId>maven-jar-plugin</artifactId> 
       <configuration> 
        <archive> 
         <manifest> 
          <addClasspath>true</addClasspath> 
          <classpathPrefix>lib/</classpathPrefix> 
          <mainClass>ro.project.ProjectServer</mainClass> 
         </manifest> 
        </archive> 
       </configuration> 
      </plugin> 
      <plugin> 
       <artifactId>maven-antrun-plugin</artifactId> 
       <dependencies> 
        <dependency> 
         <groupId>com.sun</groupId> 
         <artifactId>tools</artifactId> 
         <version>1.7.0_02</version> 
         <scope>system</scope> 
         <systemPath>${java.home}/../lib/tools.jar</systemPath> 
        </dependency> 
       </dependencies> 
       <executions> 
        <execution> 
         <id>ant-magic</id> 
         <phase>prepare-package</phase> 
         <goals> 
          <goal>run</goal> 
         </goals> 
         <configuration> 
          <tasks> 
           <property name="compile_classpath" refid="maven.compile.classpath" /> 
           <property name="runtime_classpath" refid="maven.runtime.classpath" /> 
           <property name="test_classpath" refid="maven.test.classpath" /> 
           <property name="plugin_classpath" refid="maven.plugin.classpath" /> 

           <ant antfile="${basedir}/clientExport.xml" target="export-all" /> 
          </tasks> 
         </configuration> 
        </execution> 
       </executions> 
      </plugin> 
     </plugins> 
    </build> 

    <artifactId>project-core</artifactId> 
    <url>http://www.project.ro</url> 
</project> 

Dopo corro l'esperto di installarlo sta lavorando ...

Maven configurazioni run:

Il problema è che il mio generato .jar non ha le dipendenze inclusi .... Come posso configurare pom.xml per includere tutte le mie dipendenze in formato .jar e non spacchettato .. perché sembra che scompattato non funzionano correttamente ...

per essere sicuri che tutti i vasi tra cui è ok .. ho scaricato e aggiunto ogni libreria in jar s' /lib cartella e il vaso è in funzione ... così .. la mia unica domanda è: come posso configurare pom.xml per aggiungere tutte le mie dipendenze nel formato jar?

Ho provato tutti i metodi:

1. assembly:assembly
2. assembly:single
3. assembly:single con la mia descrittore (un file assemble.xml), ma non funzionava
4. maven copy dependencies plug-in, ma ancora non funziona con Eclipse Maven - m2e

Sono fuori di soluzioni ... qualcuno può dirmi un modo corretto per aggiungere le mie dipendenze in jar? Non posso credere che maven è così complessa e non riesco a trovare una risposta alla mia domanda ovunque ..

Grazie in anticipo

Answer 1

Ci sono un paio di modi per farlo.

1) Se si desidera un uber-vaso (riconfezionato con tutte le dipendenze), considerare di usare e la configurazione del maven-shade-plugin:

<build> 
    <plugins> 
     <plugin> 
     <groupId>org.apache.maven.plugins</groupId> 
     <artifactId>maven-shade-plugin</artifactId> 
     <version>1.6</version> 
     <executions> 
      <execution> 
      <phase>package</phase> 
      <goals> 
       <goal>shade</goal> 
      </goals> 
      <configuration> 
       <transformers> 
       <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> 
        <mainClass>com.group.id.Launcher1</mainClass> 
       </transformer> 
       </transformers> 
      </configuration> 
      </execution> 
     </executions> 
     </plugin> 
    </plugins> 
    </build> 

Ciò scompattare tutte le dipendenze e fonderli in un unico JAR file.

2) Se si vuole fornire un fascio (zip, tar.gz, ecc) con i file JAR decompressi nel pacchetto (forse sotto lib /) allora avete bisogno di esaminare la maven-assembly-plugin:

<build> 
    <plugins> 
     <plugin> 
     <groupId>org.apache.maven.plugins</groupId> 
     <artifactId>maven-assembly-plugin</artifactId> 
     <version>2.3</version> 
     <executions> 
      <execution> 
      <id>create-distro</id> 
      <phase>package</phase> 
      <goals> 
       <goal>single</goal> 
      </goals> 
      <configuration> 
       <descriptors> 
       <descriptor>src/main/assembly/dist.xml</descriptor> 
       </descriptors> 
      </configuration> 
      </execution> 
     </executions> 
     </plugin> 
    </plugins> 
    </build> 

Si noti che questo richiede un descrittore di assemblaggio src/main/assembly/dist.xml e l'esempio si presenta così:

<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"> 
    <id>distribution</id> 
    <formats> 
    <format>zip</format> 
    </formats> 

    <dependencySets> 
    <dependencySet> 
     <useProjectArtifact>false</useProjectArtifact> 
     <useTransitiveDependencies>false</useTransitiveDependencies> 
     <unpack>false</unpack> 
     <scope>runtime</scope> 
     <fileMode>0755</fileMode> 
     <directoryMode>0755</directoryMode> 
     <outputDirectory>bin</outputDirectory> 

     <includes> 
     <include>com.group.id:project-launch1</include> 
     <include>com.group.id:project-launch2</include> 
     </includes> 

    </dependencySet> 
    <dependencySet> 
     <useProjectArtifact>false</useProjectArtifact> 
     <useTransitiveDependencies>true</useTransitiveDependencies> 
     <unpack>false</unpack> 
     <scope>runtime</scope> 
     <fileMode>0644</fileMode> 
     <directoryMode>0755</directoryMode> 
     <outputDirectory>lib</outputDirectory> 

     <includes> 
     <include>com.group.id:project-lib1</include> 
     <include>com.group.id:project-lib2</include> 
     <include>com.group.id:project-lib3</include> 
     <include>com.group.id:project-lib4</include> 
     </includes> 

    </dependencySet> 
    </dependencySets> 
</assembly> 

E dal momento che si sta ora assemblando le dipendenze, si è meglio definire la dipendenza nel pom.xml, in questo modo:

<dependencies> 
    <dependency> 
     <groupId>com.group.id</groupId> 
     <artifactId>project-launch1</artifactId> 
     <version>0.0.1-SNAPSHOT</version> 
     <type>jar</type> 
    </dependency> 
    <dependency> 
     <groupId>com.group.id</groupId> 
     <artifactId>project-launch2</artifactId> 
     <version>0.0.1-SNAPSHOT</version> 
     <type>jar</type> 
    </dependency> 
    <dependency> 
     <groupId>com.group.id</groupId> 
     <artifactId>project-lib1</artifactId> 
     <version>0.0.1-SNAPSHOT</version> 
     <type>jar</type> 
    </dependency> 
    ... and so on ... 
    </dependencies> 

3) Se si consegnano un bundle con un lanciatore di file JAR eseguibile, è probabile che sia necessario aggiungere una configurazione maven-jar-plugin oltre al Maven-assemblaggio-plugin:

<dependencies> 
    <dependency> 
     <groupId>com.group.id</groupId> 
     <artifactId>project-lib1</artifactId> 
     <version>0.0.1-SNAPSHOT</version> 
     <type>jar</type> 
    </dependency> 
    <dependency> 
     <groupId>com.group.id</groupId> 
     <artifactId>project-lib2</artifactId> 
     <version>0.0.1-SNAPSHOT</version> 
     <type>jar</type> 
    </dependency> 
    <dependency> 
     <groupId>com.group.id</groupId> 
     <artifactId>project-lib3</artifactId> 
     <version>0.0.1-SNAPSHOT</version> 
     <type>jar</type> 
    </dependency> 
    ... and so on ... 
    </dependencies> 

    <build> 
    <plugins> 
     <plugin> 
     <artifactId>maven-jar-plugin</artifactId> 
     <configuration> 
      <archive> 
      <addMavenDescriptor>false</addMavenDescriptor> 
      <compress>true</compress> 
      <manifest> 
       <mainClass>com.group.id.Launcher1</mainClass> 
       <addClasspath>true</addClasspath> 
       <classpathPrefix>../lib/</classpathPrefix> 
      </manifest> 
      </archive> 
     </configuration> 
     </plugin> 
    </plugins> 
    </build> 

Si noti che la La direttiva "addClasspath" aggiunge le dipendenze del progetto al percorso della classe. Questo è necessario per i lanciatori JAR, poiché ignorano esplicitamente tutte le variabili ambientali di CLASSPATH.