come generare jar e war sia nel progetto

Question

abbiamo due progetti diversi. E il controller è quasi lo stesso in due progetti.

Il progetto A contiene un controller. Quindi generare la guerra non è un problema.

Ma il progetto B richiede il barattolo del Controller del controller di progetto A.

Qualcuno può dirmi come posso generare il file jar dal controller del progetto A che posso utilizzare nel progetto B?

Answer 1

La soluzione predefinita per questo è di avere due moduli separati uno per la guerra e uno per il modulo controller. Non iniziare a combattere con Maven.

Answer 2

È possibile generare sia nel medesimo progetto e l'installazione anche, 1. Per generare vaso, utilizzare Maven-jar-plug 2. Per installare Jar, Usare Maven-install-plugin 3. Per distribuire Jar, Usa Maven -deploy-plugin

Nota: Usa type come war, per impostazione predefinita genera un file war del progetto.

controllo di seguito per la configurazione più dettagliate: imballaggio http://communitygrids.blogspot.in/2007/11/maven-making-war-and-jar-at-same-time.html

Answer 3

progetto Keep A come la guerra. Aggiungi il plugin maven jar al pom.xml del progetto A. Costruisci il progetto con "mvn clean package jar: jar". Creerà sia un vaso che una guerra.

Answer 4

Come sottolineato da @Shashank, è possibile fare in modo che Maven esegua anche il plug-in maven-jar. Ma questo creerà solo un JAR, che contiene solo le classi compilate, ma non le fonti webapp.

C'è modo semplice come farlo in un progetto multi-modulo con un semplice comando mvn clean install senza richiamare esplicitamente mvn clean install jar:jar:

basta aggiungere il maven-jar-plugin al >build>plugins e chiamano in fase di "pacchetto":

<project> 
    <packaging>war</packaging> 
    <!-- .. --> 
    <build> 
    <plugins> 
     <plugin> 
     <artifactId>maven-jar-plugin</artifactId> 
     <configuration> 
      <classifier>classes</classifier> 
     </configuration> 
     <executions> 
      <execution> 
      <id>package-jar</id> 
      <phase>package</phase> 
      <goals> 
       <goal>jar</goal> 
      </goals> 
      </execution> 
     </executions> 
     </plugin> 
     <plugin> 
     <artifactId>maven-war-plugin</artifactId> 
     </plugin> 
    </plugins> 
    </build> 
</project> 

Questo creerà un grande artefatto .war e un piccolo -classes.jar.

Aggiornamento 2017/06/15: Se d'altra parte, è necessario un copia esatta del file di guerra (non solo le classi Java confezionati), che è una specie di mascherato come un file JAR , è possibile utilizzare una combinazione di maven-dependency-plugin e maven-install-plugin per creare una copia JAR di una GUERRA. (Mi è capitato di avere bisogno di una tale soluzione - non chiedere perché;))

Creare un nuovo modulo che è dependend sul modulo di guerra:

<project> 
    <!-- ... --> 
    <dependencies> 
    <!-- ... --> 
    <dependency> 
     <groupId>your-group-id-here</groupId> 
     <artifactId>your-war-artifact-id-here</artifactId> 
     <version>${project.version}</version> 
     <type>war</type> 
    </dependency> 
    </dependencies> 

    <build> 
    <plugins> 
     <plugin> 
     <groupId>org.apache.maven.plugins</groupId> 
     <artifactId>maven-dependency-plugin</artifactId> 
     <executions> 
      <execution> 
      <id>copy</id> 
      <phase>package</phase> 
      <goals> 
       <goal>copy</goal> 
      </goals> 
      </execution> 
     </executions> 
     <configuration> 
      <artifactItems> 
      <artifactItem> 
       <groupId>your-group-id-here</groupId> 
       <artifactId>your-war-artifact-id-here</artifactId> 
       <version>${project.version}</version> 
       <type>war</type> 
       <overWrite>true</overWrite> 
       <destFileName>jar-copy-of-war.jar</destFileName> 
      </artifactItem> 
      </artifactItems> 
      <overWriteReleases>false</overWriteReleases> 
      <overWriteSnapshots>true</overWriteSnapshots> 
     </configuration> 
     </plugin> 
     <plugin> 
     <artifactId>maven-install-plugin</artifactId> 
     <executions> 
      <execution> 
      <id>install-copy-of-war</id> 
      <phase>install</phase> 
      <goals> 
       <goal>install-file</goal> 
      </goals> 
      <configuration> 
       <packaging>jar</packaging> 
       <classifier>copy-of-war</classifier> 
       <artifactId>${project.artifactId}</artifactId> 
       <groupId>your-group-id-here</groupId> 
       <version>${project.version}</version> 
       <file>${project.build.directory}/dependency/jar-copy-of-war.jar</file> 
       <generatePom>true</generatePom> 
      </configuration> 
      </execution> 
     </executions> 
     </plugin> 
    </plugins> 
    </build> 
</project> 

Questo creerà una copia del war, chiamalo "--copy-of-war.jar", mentre "copy-of-war" è il classificatore per questo modulo.