Java: come posso creare distribuzioni standalone di progetti basati su Maven?

Question

Incontro spesso distribuzioni di applicazioni o librerie Java che usano Maven come strumento di costruzione.

Alcuni di loro, purtroppo, non forniscono giare standalone (o ridistribuibili).

E 'possibile creare applicazioni basate su Maven in modo tale, che il risultato build contiene tutte le dipendenze e può essere ridistribuito a lavorare out-of-the box?

Ho provato a creare il modulo OCM di Jackrabbit. Per alcuni motivi "intelligenti" non è disponibile la versione autonoma scaricabile .
Quindi ho creato Jackrabbit con Maven (il pacchetto sorgente di Jackrabbit include OCM) e ho ottenuto lo stesso contenitore trovato nello apache repository. Il barattolo non contiene le dipendenze necessarie ed è inutile per me.

Answer 1

Modificare il file pom.xml e utilizzare la direttiva <Embed-Dependency>. Un esempio simile può essere trovato here in modo che tu possa adattarlo al tuo scenario.

<Embed-Dependency>*;scope=!test;inline=true</Embed-Dependency> 

Penso che questo dovrebbe fare il trucco.

---

Ecco l'esempio all'indirizzo di cui sopra, che sembra dare timeout.

<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>br.gov.lexml</groupId> 
    <artifactId>toolkit</artifactId> 
    <packaging>bundle</packaging> 
    <version>3.0</version> 
    <parent> 
     <artifactId>lexml</artifactId> 
     <groupId>br.gov.lexml</groupId> 
     <version>1.0</version> 
    </parent> 
    <build> 
     <finalName>Lexml_Toolkit-2.0</finalName> 
     <plugins> 
      <plugin> 
       <groupId>org.apache.maven.plugins</groupId> 
       <artifactId>maven-compiler-plugin</artifactId> 
       <configuration> 
        <source>1.5</source> 
        <target>1.5</target> 
       </configuration> 
      </plugin> 
      <plugin> 
       <groupId>org.apache.felix</groupId> 
       <artifactId>maven-bundle-plugin</artifactId> 
       <extensions>true</extensions> 
       <configuration> 
        <instructions> 
         <!--_include>src/toolkit/resources/META-INF/MANIFEST.MF</_include--> 

         <Export-Package>*;-split-package:=merge-last</Export-Package> 
         <Bundle-Activator>br.gov.lexml.borda.Toolkit</Bundle-Activator> 
         <Bundle-Name>Toolkit</Bundle-Name> 
         <Private-Package /> 
         <Embed-Dependency>*;scope=!test;inline=true</Embed-Dependency> 
         <Bundle-ClassPath>.,{maven-dependencies}</Bundle-ClassPath> 
        </instructions> 
       </configuration> 
      </plugin> 
     </plugins> 
    </build> 
    <dependencies> 
     <dependency> 
      <groupId>org.apache.xmlbeans</groupId> 
      <artifactId>xmlbeans</artifactId> 
      <version>2.4.0</version> 
     </dependency> 
     <dependency> 
      <groupId>org.apache.xmlbeans</groupId> 
      <artifactId>xmlbeans-xmlpublic</artifactId> 
      <version>2.4.0</version> 
     </dependency> 
     <dependency> 
      <groupId>log4j</groupId> 
      <artifactId>log4j</artifactId> 
      <version>1.2.15</version> 
     </dependency> 
     <dependency> 
      <groupId>br.gov.lexmlbeans</groupId> 
      <artifactId>lexmlbeans</artifactId> 
      <version>3.0</version> 
     </dependency> 
    </dependencies> 
</project> 

Answer 2

Potresti avere un po 'di fortuna con lo . In caso contrario, dai uno sguardo allo assembly plugin. Questo è più flessibile, ma di livello inferiore. Se stai utilizzando il plug-in di assembly, potresti trovare utile il capitolo su di esso in maven: the definitive guide.

Answer 3

Credo che il Maven Shade Plugin soddisferà le vostre esigenze. Lo uso quando creo strumenti di interfaccia a riga di comando per creare un JAR Uber che includa le mie classi e insieme alle classi di tutte le mie dipendenze.

È molto facile da usare e penso che questo example è auto-esplicativo.

Answer 4

Come ha detto Dominic, l'uso del plug-in di assemblaggio farà il possibile. Si potrebbe configurare solito all'interno POM del proprio progetto per raccogliere e confezionare tutte le dipendenze richieste:

... 
    <plugin> 
    <artifactId>maven-assembly-plugin</artifactId> 
    <configuration> 
     <descriptorRefs> 
     <descriptorRef>jar-with-dependencies</descriptorRef> 
     </descriptorRefs> 
    </configuration> 
    </plugin> 
    ... 

jar-with-dependencies è predefinito dal plugin di montaggio e comprenderà tutte le dipendenze nel pacchetto finale (vedere la documentazione here).

Se non si desidera utilizzare Maven per il proprio progetto, sarà necessario modificare le POM delle librerie e riconfezionarle da soli (scaricare i sorgenti, aggiungere lo snippet sopra a pom.xml ed eseguire mvn package). Fai attenzione alle dipendenze transitive duplicate o incompatibili se usi più librerie. exclusions potrebbe essere di aiuto in questo caso (consultare la documentazione here).

Answer 5

Come un paio di poster hanno detto, il plugin assembly è un buon modo per creare un file jar completo, con tutte le dipendenze del progetto. Tuttavia, in realtà non è necessario modificare il file pom.xml. È sufficiente eseguire:

mvn assembly:single -DdescriptorId=jar-with-dependencies 

... per creare un file jar. Se vuoi fare qualcosa di più avanzato, probabilmente dovresti modificare pom.xml e creare un descrittore di assemblaggio personalizzato.

Answer 6

Utilizzare la tonalità plugin di Maven

... ma fate attenzione dei trucchi (simile a quello descritto più in basso la mia risposta), che ha ottenuto a workaround explained here.

Inoltre, sii estremamente attento con la configurazione del plug-in di Shade. Ho usato per errore i tag double <configuration> una volta, ei trasformatori non si applicavano del tutto e il plugin si è anche permesso di non avvertirmi.

Non usare l'Assemblea Maven plug

assembly:single sarà disfare i JAR di dipendenza così com'è, e questo non poteva essere quello che vuoi. Per esempio. roba come META-INF/spring.schemas saranno sostituiti con l'ultimo JAR di dipendenza Spring valutato, e come tale i tuoi XSD non saranno trovati (a parte quelli dell'ultimo JAR, ovviamente). Ecco perché sistemi come Alfresco hanno creato il loro plug-in AMP che raggruppa le dipendenze all'interno di lib/ all'interno dell'AMP che stai costruendo. Quest'ultimo solleva problemi di gestione delle dipendenze, però.