Costruire un vaso eseguibile con Maven?

Question

Sto cercando di generare un jar eseguibile per un piccolo progetto home chiamato " logmanager " usando maven, proprio così:

Come posso creare un JAR eseguibile con dipendenze che utilizzano Maven?

Ho aggiunto lo snippet mostrato lì a pom.xml e ho eseguito mvn assembly: assembly. Genera due file jar in logmanager / target: logmanager-0.1.0.jar e logmanager-0.1.0-jar-with-dependencies.jar. Viene visualizzato un errore quando faccio doppio clic sul primo barattolo:

Could not find the main class: com.gorkwobble.logmanager.LogManager. Program will exit.

Un errore leggermente diverso quando faccio doppio clic su jar-with-dependencies.jar:

Failed to load Main-Class manifest attribute from: C:\EclipseProjects\logmanager\target\logmanager-0.1.0-jar-with-dependencies.jar

Ho copiato e incollato il percorso e il nome classe e ho verificato l'ortografia nel POM. La mia classe principale si avvia bene da una configurazione di avvio di eclissi. Qualcuno può aiutarmi a capire perché il mio file jar non verrà eseguito? Inoltre, perché ci sono due vasetti per cominciare? Fammi sapere se hai bisogno di maggiori informazioni.

Ecco il pom.xml completo, per riferimento:

<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>com.gorkwobble</groupId>
  <artifactId>logmanager</artifactId>
  <name>LogManager</name>
  <version>0.1.0</version>
  <description>Systematically renames specified log files on a scheduled basis. Designed to help manage MUSHClient logging and prevent long, continuous log files.</description>
  <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.2</version>
            <!-- nothing here -->
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.2-beta-4</version>
            <configuration>
              <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
              </descriptorRefs>
              <archive>
                <manifest>
                  <mainClass>com.gorkwobble.logmanager.LogManager</mainClass>
                </manifest>
              </archive>
            </configuration>
            <executions>
              <execution>
                <phase>package</phase>
                <goals>
                  <goal>single</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
              <source>1.6</source>
              <target>1.6</target>
            </configuration>
          </plugin>
    </plugins>
  </build>
  <dependencies>
    <!-- commons-lang -->
    <dependency>
        <groupId>commons-lang</groupId>
        <artifactId>commons-lang</artifactId>
        <version>2.4</version>
    </dependency> 

    <!-- Quartz scheduler -->
    <dependency>
        <groupId>opensymphony</groupId>
        <artifactId>quartz</artifactId>
        <version>1.6.3</version>
    </dependency>
    <!-- Quartz 1.6.0 depends on commons collections -->
    <dependency>
      <groupId>commons-collections</groupId>
      <artifactId>commons-collections</artifactId>
      <version>3.1</version>
    </dependency>
    <!-- Quartz 1.6.0 depends on commons logging -->
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.1</version>
    </dependency>
    <!-- Quartz 1.6.0 requires JTA in non J2EE environments -->
    <dependency>
      <groupId>javax.transaction</groupId>
      <artifactId>jta</artifactId>
      <version>1.1</version>
      <scope>runtime</scope>
    </dependency>

    <!-- junitx test assertions -->
    <dependency>
        <groupId>junit-addons</groupId>
        <artifactId>junit-addons</artifactId>
        <version>1.4</version>
        <scope>test</scope>
    </dependency>

    <!-- junit dependency; FIXME: make this a separate POM -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.1</version>
    </dependency>

  </dependencies>
  <dependencyManagement>
  </dependencyManagement>
</project>

Answer 1

In realtà, penso che la risposta data nella domanda che hai menzionato è solo sbagliata ( AGGIORNAMENTO - 20101106: qualcuno l'ha riparata, questa risposta si riferisce alla versione che precede la modifica ) e questo spiega, almeno in parte, perché si verificano problemi.

---

  

Genera due file jar in logmanager / target: logmanager-0.1.0.jar e logmanager-0.1.0-jar-with-dependencies.jar.

Il primo è il JAR del modulo logmanager generato durante la fase package da jar:jar (poiché il modulo ha un pacchetto di tipo jar). Il secondo è l'assembly generato da assembly:assembly e dovrebbe contenere le classi del modulo corrente e le sue dipendenze (se hai usato il descrittore jar-with-dependencies).

  

Ricevo un errore quando faccio doppio clic sul primo barattolo:

Could not find the main class: com.gorkwobble.logmanager.LogManager. Program will exit.

Se hai applicato la configurazione suggerita del link pubblicato come riferimento, hai configurato il plugin jar per produrre un artefatto eseguibile, qualcosa del genere:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
          <mainClass>com.gorkwobble.logmanager.LogManager</mainClass>
        </manifest>
      </archive>
    </configuration>
  </plugin>

Quindi logmanager-0.1.0.jar è effettivamente eseguibile ma 1. questo non è quello che vuoi (perché non ha tutte le dipendenze) e 2. non contiene com.gorkwobble.logmanager.LogManager (questo è ciò che dice l'errore, controlla il contenuto del barattolo).

  

Un errore leggermente diverso quando faccio doppio clic su jar-with-dependencies.jar:

Failed to load Main-Class manifest attribute from: C:\EclipseProjects\logmanager\target\logmanager-0.1.0-jar-with-dependencies.jar

Ancora una volta, se hai configurato il plugin assembly come suggerito, hai qualcosa del genere:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
      <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
    </configuration>
  </plugin>

Con questa configurazione, logmanager-0.1.0-jar-with-dependencies.jar contiene le classi del modulo corrente e le sue dipendenze ma, in base all'errore, il suo META-INF/MANIFEST.MF non contiene un Main-Class voce (probabilmente non è lo stesso MANIFEST.MF di logmanager-0.1.0.jar). Il vaso non è in realtà non eseguibile, che di nuovo non è quello che vuoi.

---

Quindi, il mio suggerimento sarebbe di rimuovere l'elemento configuration dal plug-in maven-jar e configurare il plug-in maven-assembly in questo modo:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.2</version>
    <!-- nothing here -->
  </plugin>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.2-beta-4</version>
    <configuration>
      <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
      <archive>
        <manifest>
          <mainClass>org.sample.App</mainClass>
        </manifest>
      </archive>
    </configuration>
    <executions>
      <execution>
        <phase>package</phase>
        <goals>
          <goal>single</goal>
        </goals>
      </execution>
    </executions>
  </plugin>

Naturalmente, sostituisci org.sample.App con la classe che vuoi eseguire. Poco bonus, ho legato assembly:single alla fase mvn install, quindi non devi più eseguire mvn clean install. Basta eseguire target e l'assemblaggio verrà prodotto durante la build standard.

Quindi, aggiorna il tuo pom.xml con la configurazione sopra indicata ed esegui pom.xml. Quindi, cd nella directory <=> e riprovare:

java -jar logmanager-0.1.0-jar-with-dependencies.jar

Se ricevi un errore, aggiorna la tua domanda con esso e pubblica il contenuto del file <=> e la parte pertinente del tuo <=> (le parti di configurazione dei plugin). Pubblica inoltre il risultato di:

java -cp logmanager-0.1.0-jar-with-dependencies.jar com.gorkwobble.logmanager.LogManager

per dimostrare che sta funzionando bene sulla riga di comando (indipendentemente da cosa sta dicendo eclissi).

EDIT: per Java 6, è necessario configurare il plugin maven-compilatore. Aggiungi questo al tuo pom.xml:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
      <source>1.6</source>
      <target>1.6</target>
    </configuration>
  </plugin>

Answer 2

Anche la risposta di Pascal Thivent mi ha aiutato. Ma se gestisci i tuoi plugin all'interno dell'elemento <pluginManagement>, devi definire nuovamente l'assembly al di fuori della gestione dei plug-in, altrimenti le dipendenze non vengono impacchettate nel vaso se esegui mvn install.

<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>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>jar</packaging>


    <build>
        <pluginManagement>
            <plugins>

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.1</version>
                    <configuration>
                        <source>1.6</source>
                        <target>1.6</target>
                    </configuration>
                </plugin>

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>2.4</version>
                    <configuration>
                        <archive>
                            <manifest>
                                <mainClass>main.App</mainClass>
                            </manifest>
                        </archive>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                    </configuration>
                    <executions>
                        <execution>
                            <id>make-assembly</id>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>

            </plugins>

        </pluginManagement>

        <plugins> <!-- did NOT work without this  -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
            </plugin>
        </plugins>

    </build>


    <dependencies>
       <!--  dependencies commented out to shorten example -->
    </dependencies>

</project>

Answer 3

Se non si desidera eseguire l'obiettivo di assemblaggio sul pacchetto, è possibile utilizzare il comando successivo:

mvn package assembly:single

Qui pacchetto è una parola chiave.

Answer 4

Fai clic con il pulsante destro del mouse sul progetto e fornisci maven build, maven clean, maven genera risorse e installa maven. Il file jar verrà generato automaticamente.