cómo generar jar y war tanto en el proyecto

Question

tenemos dos proyectos diferentes. Y el controlador es casi lo mismo en dos proyectos.

proyecto A tiene un controlador dentro. Generar la guerra no es un problema.

Pero el proyecto B requiere el controlador del controlador A del proyecto.

¿Puede alguien decirme cómo puedo generar el archivo jar desde el controlador del proyecto A que puedo usar en el proyecto B?

Answer 1

La solución predeterminada para tal cosa es tener dos módulos separados, uno para la guerra y el otro para el módulo del controlador. No empieces a pelear con Maven.

Answer 2

Puede generar tanto en un mismo proyecto e instalar también, 1. Generar frasco, el uso experto-Jar-plugin 2. Para instalar el tarro, el uso experto de instalar, plug-in 3. Para implementar Jar, uso experto -deploy-plugin

Nota: utilice el tipo como war, de manera predeterminada genera el archivo war de su proyecto.

de verificación a continuación para la configuración más detallada: Los envases de http://communitygrids.blogspot.in/2007/11/maven-making-war-and-jar-at-same-time.html

Answer 3

proyecto Keep A como de guerra. Agregue el plugin maven jar al pom.xml del proyecto A. Cree el proyecto con "mvn clean package jar: jar". Creará tanto una jarra como una guerra.

Answer 4

Como señaló @Shashank, puede hacer que maven también ejecute maven-jar-plugin. Pero esto solo creará un JAR, que contiene solo las clases compiladas, pero no las fuentes de webapp.

hay manera fácil como hacerlo en un proyecto de varios módulos con un simple comando mvn clean install sin invocar explícitamente mvn clean install jar:jar:

Basta con añadir el maven-jar-plugin a la >build>plugins y lo llaman en la fase de "paquete":

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

Esto creará un gran .war y un objeto de clase -classes.jar más pequeño.

actualización 06/15/2017: Si por el contrario, necesita una copia exacta del archivo de la guerra (no sólo las clases de Java envasados), que es una especie de enmascarado como un archivo JAR , puede usar una combinación de maven-dependency-plugin y maven-install-plugin para crear una copia JAR de WAR. (Me pasó a estar en necesidad de tal solución - no pregunte por qué;))

crear un nuevo módulo que se dependend en el módulo de la 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> 

Esto creará una copia de la guerra, llámalo "--copy-of-war.jar", mientras que "copy-of-war" es el clasificador de este módulo.