Il modo più semplice per unire una versione in un file JAR

Il zipfileset di Ant fa il lavoro

<jar id="files" jarfile="all.jar">
    <zipfileset src="first.jar" includes="**/*.Java **/*.class"/>
    <zipfileset src="second.jar" includes="**/*.Java **/*.class"/>
</jar>

Avendo provato alcune soluzioni diverse, ho trovato One-JAR il più facile da usare e sono riuscito a fare esattamente questo: produrre un singolo JAR eseguibile che contenga tutto ciò di cui ho bisogno.

One-JAR utilizza un caricatore di classi personalizzato che può navigare tra le risorse annidate. Guarda il file .bat nel download, sembra che org.codelutin.jrst.JRST nel jrst-0.8.1.jar sia la classe principale, quindi il tuo manifest dovrebbe apparire così:

Main-Class: com.simontuffs.onejar.Boot
One-Jar-Main-Class: org.codelutin.jrst.JRST

La cosa veramente interessante è che One-JAR gestirà per te il passaggio degli argomenti da riga di comando. Il classpath è gestito dal programma di caricamento classi personalizzato, supponendo che tutte le risorse necessarie siano raggruppate nel singolo JAR.

Il modo più semplice per usare One-JAR è con la formica; c'è un'attivazione personalizzata "one jar" che funziona come segue (assumendo che il manifest sia chiamato "rst.mf"):

<target name="jar-rst">
    <one-jar destfile="rst.jar" manifest="rst.mf">
        <main jar="jrst-0.8.1.jar" />
        <lib>
            <fileset dir="${pathToJars}">
                <include name="batik-util-1.6-1.jar" />
                <include name="icu4j-2.6.1.jar" />
                <include name="commons-collections-3.1.jar" />
                <!-- Snip -->
            </fileset>
        </lib>
    </one-jar>
</target>

Se sei un Maven user, tipicamente il plugin Assembly fa quello che vuoi, o potenzialmente il plugin per lo schermo, e in alcuni casi una combinazione.

Con il plugin Assembly hai inserito un file manifest nel tuo progetto con tutte le impostazioni necessarie, anche se le impostazioni predefinite sono generalmente abbastanza buone. L'edificio è quindi fatto con

mvn Assembly:assembly

O se hai altre cose speciali da affrontare, uno degli altri obiettivi. Tutti i file JAR da includere vengono rilevati dal resolver delle dipendenze di Maven. Se si utilizza il plug-in della sfumatura, generalmente fa parte dell'obiettivo di installazione e in un particolare progetto che sto facendo ora lo faccio

mvn install
mvn Assembly:single

L'obiettivo Assembly:single è di aggirare i problemi di durata, in questo caso in un'applicazione Spring .

Puoi usare JarJar che userà il pacchetto shadowing per assicurarti che il tuo file JAR non sia in conflitto con gli altri.

C'è ProGuard che non solo impacchetta i file JAR in uno solo, ma può anche ottimizzare, ripulire o offuscare i file di classe, rendendo il file JAR risultante molto più piccolo della somma di tutti i file JAR precedenti.

Ho effettivamente provato ProGuard con lo strumento JRST, ed è come hai segnalato. Ho provato a rintracciare il problema e ho trovato che si riferisce a a bug nella libreria ICU4J a cui fa riferimento jrst. Il problema è che la versione ICU usata è ormai superata. Così ho sostituito il file icu.jar con ICU4J versione 3.2. Ora ProGuard trova un sacco di altri errori/avvertenze sulle incostanze con le librerie di JRST.

La mia ipotesi è che ProGuard funzioni come previsto, ma le librerie di jrst non sono coerenti. Non so se puoi fare molto di più che parlare con i suoi sviluppatori dato che dovrebbero controllare e aggiornare le dipendenze del progetto.

(basato su Andrian):

<jar id="files" jarfile="all.jar">
  <zipgroupfileset dir="${library.dir}" includes="*.jar" excludes="test-helper.jar"/>
  <zipfileset src="first.jar" includes="**/*.Java **/*.class"/>
  <zipfileset src="second.jar" includes="**/*.Java **/*.class"/>
  <fileset dir=".">
    <include name="LICENSE"/>
    <include name="NOTICE"/>
  </fileset>
</jar>

One-JAR 0.97 è stato appena rilasciato su http://one-jar.sourceforge.net , ed è stato esteso con supporto per framework come Spring e Guice , che potrebbero presentare problemi ad altri approcci. Gestisce anche l'inversione del classloader - dove alcuni file JAR sono esterni a One-JAR (ad esempio, JDBC driver che potrebbero non essere spediti in bundle).

One-JAR è una riga di comando, con Ant e Maven 2 plugin. È anche semplice costruire semplicemente usando lo strumento "jar".

Posso anche raccomandare Eclipse Jar Exporter (Runnable) su cui ha scritto Ference Hechler: ha fatto un ottimo lavoro nel proporre un approccio semplice per il wrapping di un set di file JAR. Lui e io abbiamo lavorato su One-JAR, ma Jar Exporter si basa su un codice diverso.

O usando il plugin Assembly Maven (mvn Assembly: assembly)

C'è uno strumento chiamato autojar che scansiona il tuo bytecode e compila un file .jar con le classi che trova, incluse le classi di riferimento (importate).

Tuttavia, non sempre funziona con qualcosa come Spring, dove si specificano i nomi di classe nella configurazione e questo viene caricato dal framework.

Penso che lo strumento di cui hai bisogno qui sia JarSplice: http://ninjacave.com/jarsplice

Fa not richiede Ant o Maven, ha la sua GUI, è semplice da usare e fa esattamente quello che hai chiesto -> Mescola il contenuto di diversi file jar in uno solo (notare che è ancora necessario aggiungere il proprio classloader).

Dovresti usare il plugin Maven shading per farlo. Uso spesso Maven per creare file jar standalone ed è così potente

Vedi altro:

http://maven.Apache.org/plugins/maven-shade-plugin/examples/includes-excludes.html