maven build with war e jar che spingono dispari artefatti al repository interno

Question

Ho un progetto Maven dove sto costruendo un file war, ma sto anche usando il plugin maven-jar per costruire un jar nello stesso progetto.

--DISCLAIMER-- So che questo non è il modo 'corretto' per fare questo, ma ci sono alcuni altri problemi che si verificano quando si divide questo in un progetto vaso e un progetto di guerra separato con alcuni plugin 3rd party.

Sto vedendo un comportamento strano con questo. Di seguito è la mia struttura del progetto.

warproject 
-src 
--main 
---webapp 
----WEB-INF 
-----web.xml 
---java 
----com.test.myclass 
-----test.java 
-pom.xml 

Quando costruisco questo progetto, ottengo la guerra giusta e file jar nella mia directory di destinazione, tuttavia a mio locale qualcosa .m2 repo di strano accade. Il file di guerra che viene installato è chiamato correttamente war-jar-0.0.1-SNAPSHOT.war, tuttavia i contenuti di questo file sono i contenuti del mio file jar. Questo si verifica anche se faccio l'inverso. Ad esempio, se ho impostato il mio progetto per costruire un vaso e usare il plugin maven-war per costruire la guerra, gli archivi nella mia directory di destinazione sono corretti, ma il mio repository locale ha un file jar con il contenuto del mio file di guerra. Di seguito è riportato il file pom che sto usando.

<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"> 
    <modelVersion>4.0.0</modelVersion> 
    <groupId>com.test</groupId> 
    <artifactId>war-jar</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
    <packaging>war</packaging> 
<build> 
     <plugins> 
      <plugin> 
       <groupId>org.apache.maven.plugins</groupId> 
       <artifactId>maven-jar-plugin</artifactId> 
       <configuration> 
        <jarName>${project.artifactId}-${project.version}-client</jarName> 
       </configuration> 
       <executions> 
        <execution> 
         <id>make-a-jar</id> 
         <phase>package</phase> 
         <goals> 
          <goal>jar</goal> 
         </goals> 
        </execution> 
       </executions> 
      </plugin> 
     </plugins> 
     <resources> 
      <resource> 
       <directory>src/main/java</directory> 
      </resource> 
      <resource> 
       <directory>src/main/resources</directory> 
      </resource> 
     </resources> 
    </build> 

</project> 

L'output della console per questo è il seguente, mostra che il jar viene caricato come guerra.

Installing /home/me/work/src/war-jar/target/war-jar-0.0.1-SNAPSHOT.jar to /home/me/.m2/repository/com/test/war-jar/0.0.1-SNAPSHOT/war-jar-0.0.1-SNAPSHOT.war 

--update ho ottenuto questo lavoro, ma ho dovuto cambiare la fase della mia esecuzione 'make-a-jar' per installare dal pacchetto. Funziona bene e vengono caricati gli artefatti corretti, ma sono ancora confuso sul perché questo faccia la differenza. Ovviamente l'artefatto è generato in una diversa fase del ciclo di vita, e quindi non è intorno al momento dell'installazione originale per il progetto, quindi il file sbagliato non viene caricato. Questo mi sembra un 'trucco' e vorrei capire perché questo si sta comportando in questo modo.

Answer 1

sto rispondendo alle mie domande dal momento che non ho avuto alcuna informazione che mi ha aiutato a mia soluzione. Vedi il mio aggiornamento sulla mia domanda originale per la mia soluzione.

Answer 2

Per ottenere ciò è necessario specificare le configurazioni per il plugin di installazione di maven. Aggiungi la seguente configurazione di plugin sotto <build>.

 <plugin> 
      <groupId>org.apache.maven.plugins</groupId> 
      <artifactId>maven-install-plugin</artifactId> 
      <executions> 
       <execution> 
        <phase>install</phase> 
        <goals> 
         <goal>install-file</goal> 
        </goals> 
        <configuration> 
         <packaging>jar</packaging> 
         <artifactId>${project.artifactId}</artifactId> 
         <groupId>${project.groupId}</groupId> 
         <version>${project.version}</version> 
         <file> 
          ${project.build.directory}/${project.artifactId}-${project.version}.jar 
         </file> 
        </configuration> 
       </execution> 
      </executions> 
     </plugin> 

Answer 3

Questo funziona anche,

<plugin> 
    <groupId>org.apache.maven.plugins</groupId> 
    <artifactId>maven-war-plugin</artifactId> 
    <executions> 
    <execution> 
     <!-- 
     When also running maven-jar-plugin correct maven-war-plugin's ID 
     from "default-war" to "default-jar" 
     --> 
     <id>default-jar</id> 
     <phase>package</phase> 
     <goals><goal>war</goal></goals> 
     <configuration> 
     ... 
     </configuration> 
    </execution> 
    </executions> 
</plugin> 

Fare riferimento alla http://maven.apache.org/guides/mini/guide-default-execution-ids.html

Per capire il motivo per cui il progetto si comporta come è, analizzare l'effettiva POM.