Come aggiungere file jar locali a un progetto Maven?

Come faccio ad aggiungere file jar locali (non ancora parte del repository Maven) direttamente nelle fonti della libreria del mio progetto?

Installare il JAR nel repository Maven locale come segue:

mvn install:install-file \
   -Dfile=<path-to-file> \
   -DgroupId=<group-id> \
   -DartifactId=<artifact-id> \
   -Dversion=<version> \
   -Dpackaging=<packaging> \
   -DgeneratePom=true

Dove ciascuno si riferisce a:

<path-to-file>: il percorso del file da caricare, ad es. → c:\kaptcha-2.3.jar

<group-id>: il gruppo in cui il file deve essere registrato, ad es. → com.google.code

<artifact-id>: il nome del manufatto per il file ad es. → kaptcha

<version>: la versione del file ad es. → 2.3

<packaging>: il pacchetto del file ad es. → jar

Riferimento

• FAQ di Maven: ho un barattolo che voglio mettere nel mio repository locale. Come posso copiarlo?
• Maven Install Plugin Usage: The install:install-filegoal

È possibile aggiungere direttamente dipendenze locali (come menzionato nel progetto build maven con librerie propriatery incluse ) in questo modo:

<dependency>
    <groupId>com.sample</groupId>
    <artifactId>sample</artifactId>
    <version>1.0</version>
    <scope>system</scope>
    <systemPath>${project.basedir}/src/main/resources/Name_Your_JAR.jar</systemPath>
</dependency>

Aggiornare

Nelle nuove versioni questa funzione è contrassegnata come obsoleta ma ancora funzionante e non ancora rimossa (viene visualizzato un avviso nel registro all'avvio). Un problema viene sollevato dal gruppo Maven su questo https://issues.apache.org/jira/browse/MNG-6523 (puoi partecipare e descrivere perché questa funzione è utile in alcuni casi). Spero che questa funzione rimanga lì!

Se mi stai chiedendo, fintanto che la funzione non viene rimossa, lo uso per fare la dipendenza da un solo file jar cattivo nel mio progetto che non si adatta al repository. Se questa funzione viene rimossa, beh, ci sono molte buone risposte qui che posso scegliere in seguito!

In primo luogo, vorrei dare credito per questa risposta a un utente anonimo di StackTranslate.it - ​​Sono abbastanza sicuro di aver già visto una risposta simile qui prima - ma ora non riesco a trovarla.

L'opzione migliore per avere file JAR locali come dipendenza è creare un repository Maven locale. Un repository di questo tipo non è altro che una struttura di directory corretta con file pom in esso.

Per il mio esempio: ho il mio progetto principale in ${master_project}posizione e il sottoprogetto1 è attivo ${master_project}/${subproject1}.

Poi creo un repository Maven in: ${master_project}/local-maven-repo.

Nel file pom in subproject1 situato in ${master_project}/${subproject1}/pom.xml, è necessario specificare il repository che prenderebbe il percorso del file come parametro URL:

<repositories>
    <repository>
        <id>local-maven-repo</id>
        <url>file:///${project.parent.basedir}/local-maven-repo</url>
    </repository>
</repositories>

La dipendenza può essere specificata come per qualsiasi altro repository. Questo rende il tuo repository pom indipendente. Ad esempio, una volta che il JAR desiderato è disponibile in Maven central, è sufficiente eliminarlo dal repository locale e verrà estratto dal repository predefinito.

    <dependency>
        <groupId>org.apache.felix</groupId>
        <artifactId>org.apache.felix.servicebinder</artifactId>
        <version>0.9.0-SNAPSHOT</version>
    </dependency>

L'ultima ma non meno importante cosa è aggiungere il file JAR al repository locale usando l'opzione -DlocalRepositoryPath in questo modo:

mvn org.apache.maven.plugins:maven-install-plugin:2.5.2:install-file  \
    -Dfile=/some/path/on/my/local/filesystem/felix/servicebinder/target/org.apache.felix.servicebinder-0.9.0-SNAPSHOT.jar \
    -DgroupId=org.apache.felix -DartifactId=org.apache.felix.servicebinder \
    -Dversion=0.9.0-SNAPSHOT -Dpackaging=jar \
    -DlocalRepositoryPath=${master_project}/local-maven-repo

Una volta installato il file JAR, il repository Maven può essere trasferito in un repository di codice e l'intero set-up è indipendente dal sistema. ( Esempio di lavoro in GitHub ).

Concordo sul fatto che avere JAR impegnati nel repository di codice sorgente non sia una buona pratica, ma nella vita reale, le soluzioni veloci e sporche a volte sono meglio di un repository Nexus completo per ospitare un JAR che non è possibile pubblicare.

Crea una nuova cartella, diciamo local-maven-repoalla radice del tuo progetto Maven.

Aggiungi un repository locale all'interno <project>del tuo pom.xml:

<repositories>
    <repository>
        <id>local-maven-repo</id>
        <url>file:///${project.basedir}/local-maven-repo</url>
    </repository>
</repositories>

Quindi per ogni vaso esterno che desideri installare, vai alla radice del tuo progetto ed esegui:

mvn deploy:deploy-file -DgroupId=[GROUP] -DartifactId=[ARTIFACT] -Dversion=[VERS] -Durl=file:./local-maven-repo/ -DrepositoryId=local-maven-repo -DupdateReleaseInfo=true -Dfile=[FILE_PATH]

Vorrei tale soluzione - utilizzare maven-install-pluginnel file pom:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <version>2.5.2</version>
    <executions>
        <execution>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <file>lib/yourJar.jar</file>
                <groupId>com.somegroup.id</groupId>
                <artifactId>artefact-id</artifactId>
                <version>x.y.z</version>
                <packaging>jar</packaging>
            </configuration>
        </execution>
    </executions>
</plugin>

In questo caso è possibile eseguire mvn initializee jar verrà installato nel repo locale di Maven. Ora questo vaso è disponibile durante qualsiasi passaggio di maven su questa macchina (non dimenticare di includere questa dipendenza come qualsiasi altra dipendenza di maven in pom con <dependency></dependency>tag). È anche possibile associare l'installazione del vaso non al initializepasso, ma a qualsiasi altro passo che ti piace.

<dependency>
    <groupId>group id name</groupId>
    <artifactId>artifact name</artifactId>
    <version>version number</version>
    <scope>system</scope>
    <systemPath>jar location</systemPath>
</dependency>

Sì, puoi avere ma non è una buona idea.

Installa invece tutti questi vasetti nei repository Maven

Vedi anche

• Come costruire un progetto maven con librerie propriatery incluse

Il modo più rapido e sporco è quello di puntare a un file locale:

<dependency>
      <groupId>sample</groupId>  
       <artifactId>com.sample</artifactId>  
       <version>1.0</version> 
      <scope>system</scope>
      <systemPath>C:\DEV\myfunnylib\yourJar.jar</systemPath>
</dependency>

Tuttavia, questo vivrà solo sulla tua macchina (ovviamente), per la condivisione di solito ha senso usare un archivio m2 appropriato (nexus / artificio) o se non ne hai uno o non vuoi crearne uno maven locale archivio strutturato e configurare un "repository" nel tuo pom: local:

<repositories>
    <repository>
        <id>my-local-repo</id>
        <url>file://C:/DEV//mymvnrepo</url>
    </repository>
</repositories>

a distanza:

<repositories>
    <repository>
        <id>my-remote-repo</id>
        <url>http://192.168.0.1/whatever/mavenserver/youwant/repo</url>
    </repository>
</repositories>

per questo è anche possibile un percorso relativo usando la variabile basedir:

<url>file:${basedir}</url>

Aggiungi il tuo JAR locale nel file POM e usalo nella build di Maven.

mvn install:install-file -Dfile=path-to-jar -DgroupId=owngroupid -DartifactId=ownartifactid -Dversion=ownversion -Dpackaging=jar

Per esempio:

mvn install:install-file -Dfile=path-to-jar -DgroupId=com.decompiler -DartifactId=jd-core-java -Dversion=1.2 -Dpackaging=jar

Quindi aggiungilo al POM in questo modo:

Un modo è quello di caricarlo sul tuo repository manager Maven (come Nexus). È buona norma avere comunque un proprio repository manager.

Un altro bel modo che ho visto di recente è quello di includere il plug-in di installazione Maven nel ciclo di vita della compilazione: dichiari nel POM di installare i file nel repository locale. È un piccolo ma piccolo sovraccarico e non richiede alcun passaggio manuale.

http://maven.apache.org/plugins/maven-install-plugin/install-file-mojo.html

Ovviamente puoi aggiungere barattoli a quella cartella. Ma forse non è quello che vuoi ottenere ...

Se hai bisogno di questi vasi per la compilazione, controlla questa domanda correlata: Posso aggiungere vasi a maven 2 build classpath senza installarli?

Inoltre, prima che qualcuno lo suggerisca, NON utilizzare l'ambito del sistema.

Un altro caso interessante è quando vuoi avere nel tuo progetto barattoli di maven privati. Potresti voler mantenere le capacità di Maven per risolvere le dipendenze transitive. La soluzione è abbastanza semplice.

1. Crea una cartella libs nel tuo progetto

2. Aggiungi le seguenti righe nel tuo file pom.xml

   <properties><local.repository.folder>${pom.basedir}/libs/</local.repository.folder>
   </properties>
   
   <repositories>
      <repository>
           <id>local-maven-repository</id>
           <url>file://${local.repository.folder}</url>
           <releases>
               <enabled>true</enabled>
           </releases>
           <snapshots>
               <enabled>true</enabled>
           </snapshots>
      </repository>
   </repositories>

3. Apri la cartella .m2 / repository e copia la struttura di directory del progetto che vuoi importare nella cartella libs .

Ad esempio, supponiamo di voler importare la dipendenza

<dependency>
    <groupId>com.mycompany.myproject</groupId>
    <artifactId>myproject</artifactId>
    <version>1.2.3</version>
</dependency>

Basta andare su .m2 / repository e vedrai la seguente cartella

com / mycompany / progetto / 1.2.3

Copia tutto nella cartella libs (di nuovo, comprese le cartelle in .m2 / repository ) e il gioco è fatto.

riga di comando :

mvn install:install-file -Dfile=c:\kaptcha-{version}.jar -DgroupId=com.google.code
-DartifactId=kaptcha -Dversion={version} -Dpackaging=jar

La parte importante nella dipendenza è: $ {pom.basedir} (anziché solo $ {basedir})

<dependency>
    <groupId>org.example</groupId>
    <artifactId>example</artifactId>
    <version>1.0</version>
    <scope>system</scope>
    <systemPath>${pom.basedir}/src/lib/example.jar</systemPath>
</dependency>

Penso che una soluzione migliore per questo problema sia usare maven-install-plugin per installare automaticamente i file al momento dell'installazione. È così che l'ho impostato per il mio progetto.

Innanzitutto, aggiungi il percorso (dove memorizzi i jar locali) come proprietà.

<properties>
    <local.sdk>/path/to/jar</local.sdk>
</properties>

Quindi, sotto pluginsaggiungi un plugin per installare i vasetti durante la compilazione.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <version>2.5.2</version>
    <executions>
        <execution>
            <id>1</id>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <groupId>com.local.jar</groupId> 
                <artifactId>appengine-api</artifactId>
                <version>1.0</version>
                <packaging>jar</packaging>
                <file>${local.sdk}/lib/impl/appengine-api.jar</file>
            </configuration>
        </execution>
        <execution>
            <id>appengine-api-stubs</id>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <groupId>com.local.jar</groupId>
                <artifactId>appengine-api-stubs</artifactId>
                <version>1.0</version>
                <packaging>jar</packaging>
                <file>${local.sdk}/lib/impl/appengine-api-stubs.jar</file>
            </configuration>
        </execution>
    </executions>
</plugin>

Infine, nelle dipendenze, è possibile aggiungere i vasetti

<dependency>
    <groupId>com.local.jar</groupId>
    <artifactId>appengine-api</artifactId>
    <version>1.0</version>
</dependency>

<dependency>
    <groupId>com.local.jar</groupId>
    <artifactId>appengine-api-stubs</artifactId>
    <version>1.0</version>
    <scope>test</scope>
</dependency>

Impostando il tuo progetto in questo modo, il progetto continuerà a essere compilato anche quando lo porti su un altro computer (dato che ha tutti i file jar nel percorso specificato dalla proprietà local.sdk ).

Per groupId utilizzare un nome univoco solo per assicurarsi che non vi siano conflitti.

Ora quando tu mvn installo mvn testi barattoli locali verranno aggiunti automaticamente.

Il modo preferito sarebbe quello di creare il proprio repository remoto.

Vedi qui per i dettagli su come farlo. Dai un'occhiata alla sezione " Caricamento in un archivio remoto ".

Voglio condividere un codice in cui è possibile caricare una cartella piena di barattoli. È utile quando un provider non ha un repository pubblico ed è necessario aggiungere manualmente molte librerie. Ho deciso di creare un .bat invece di chiamare direttamente a Maven perché potrebbero essere errori di memoria insufficiente. È stato preparato per un ambiente Windows ma è facile adattarlo al sistema operativo Linux:

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;

public class CreateMavenRepoApp {

    private static final String OCB_PLUGIN_FOLDER = "C://your_folder_with_jars";

    public static void main(String[] args) throws IOException {

    File directory = new File();
    //get all the files from a directory
    PrintWriter writer = new PrintWriter("update_repo_maven.bat", "UTF-8");
    writer.println("rem "+ new Date());  
    File[] fList = directory.listFiles();
    for (File file : fList){
        if (file.isFile()){               
        String absolutePath = file.getAbsolutePath() ;
        Manifest  m = new JarFile(absolutePath).getManifest();
        Attributes attributes = m.getMainAttributes();
        String symbolicName = attributes.getValue("Bundle-SymbolicName");

        if(symbolicName!=null &&symbolicName.contains("com.yourCompany.yourProject")) {
            String[] parts =symbolicName.split("\\.");
            String artifactId = parts[parts.length-1];
            String groupId = symbolicName.substring(0,symbolicName.length()-artifactId.length()-1);
            String version = attributes.getValue("Bundle-Version");
            String mavenLine= "call mvn org.apache.maven.plugins:maven-install-plugin:2.5.1:install-file -Dfile="+ absolutePath+" -DgroupId="+ groupId+" -DartifactId="+ artifactId+" -Dversion="+ version+" -Dpackaging=jar ";
            writer.println(mavenLine);          
        }

        }
    }
    writer.close();
    }

}

Dopo aver eseguito questo main da qualsiasi IDE, eseguire update_repo_maven.bat.

Questa è una breve sintassi per le versioni più recenti:

mvn install:install-file -Dfile=<path-to-file>

Funziona quando il JAR è stato creato da Apache Maven, il caso più comune. Quindi conterrà un pom.xml in una sottocartella della directory META-INF, che verrà letta per impostazione predefinita.

Fonte: http://maven.apache.org/guides/mini/guide-3rd-party-jars-local.html

Dai anche un'occhiata a ...

<scope>compile</scope>

Dipendenze Maven . Questo è il valore predefinito ma in alcuni casi ho trovato che imposta esplicitamente tale ambito anche a Maven per trovare le librerie locali nel repository locale.

Per qualche ragione, nell'applicazione web a cui sto dando la manutenzione, né la soluzione di Alireza Fattahi né quella di JJ Roman hanno funzionato correttamente. In entrambi i casi, la compilation va bene (vede il barattolo), ma la confezione non include il barattolo all'interno della guerra.

L'unico modo in cui sono riuscito a farlo funzionare è stato mettere il barattolo /src/main/webapp/WEB-INF/lib/e poi combinarlo con la soluzione di Fattahis o di Roman.

Si noti che NON è necessariamente una buona idea utilizzare un repository locale. Se questo progetto è condiviso con altri, tutti gli altri avranno problemi e domande quando non funziona e il vaso non sarà disponibile nemmeno nel tuo sistema di controllo del codice sorgente!

Sebbene il repository condiviso sia la risposta migliore, se non è possibile farlo per qualche motivo, incorporare il jar è meglio di un repository locale. I contenuti repo solo locali possono causare molti problemi, soprattutto nel tempo.

Sul tuo repository locale puoi installare il tuo jar inviando i comandi

 mvn install:install-file -Dfile=<path-to-file> -DgroupId=<group-id> \
-DartifactId=<artifact-id> -Dversion=<version> -Dpackaging=<packaging>

Segui questo utile link per fare lo stesso dal sito web di mkyoung. Puoi anche controllare la guida di Maven per lo stesso

Per installare jar di terze parti, si prega di chiamare il comando come di seguito

mvn install:install-file -DgroupId= -DartifactId= -Dversion= -Dpackaging=jar -Dfile=path

1. mvn install

Puoi scrivere il codice qui sotto nella riga di comando o se stai usando eclipse builtin maven fai clic destro sul progetto -> Esegui come -> esegui configurazioni ... -> nel pannello di sinistra fai clic destro su Maven Build -> nuova configurazione -> scrivi il codice in Obiettivi e nella directory di base: $ {project_loc: NameOfYourProject} -> Esegui

mvn install:install-file
   -Dfile=<path-to-file>
   -DgroupId=<group-id>
   -DartifactId=<artifact-id>
   -Dversion=<version>
   -Dpackaging=<packaging>
   -DgeneratePom=true

Dove ciascuno si riferisce a:

<percorso-file>: il percorso del file da caricare, ad es. -> c: \ kaptcha-2.3.jar

<group-id>: il gruppo in cui deve essere registrato il file, ad es. -> com.google.code

<artefatto-id>: il nome del manufatto per il file ad es. -> kaptcha

<versione>: la versione del file ad es. -> 2.3

<packaging>: il packaging del file ad es. -> jar

2.Dopo aver installato, dichiara semplicemente jar in pom.xml.

 <dependency>
      <groupId>com.google.code</groupId>
      <artifactId>kaptcha</artifactId>
      <version>2.3</version>
 </dependency>

Passaggio 1: configura il maven-install-plugincon l'obiettivo install-filenel tuopom.xml

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <executions>
        <execution>
            <id>install-external-non-maven-jar-MWS-Client-into-local-maven-repo</id>
            <phase>clean</phase>
            <configuration>
                <repositoryLayout>default</repositoryLayout>
                <groupId>com.amazonservices.mws</groupId>
                <artifactId>mws-client</artifactId>
                <version>1.0</version>
                <file>${project.basedir}/lib/MWSClientJavaRuntime-1.0.jar</file>
                <packaging>jar</packaging>
                <generatePom>true</generatePom>
            </configuration>
            <goals>
                <goal>install-file</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Assicurati di modificare il filepercorso in base al percorso del tuo file effettivo (si consiglia di posizionare questi vasi esterni non fatti in una cartella, diciamo lib, e posizionare questolib cartella all'interno del progetto in modo da utilizzare il percorso relativo specifico del progetto ed evitare l'aggiunta di sistema percorso assoluto specifico.

Se hai più vasetti esterni, ripeti semplicemente gli <execution>altri vasetti all'interno dello stesso maven-install-plugin.

Passo 2: Dopo aver configurato maven-install-plugincome mostrato sopra nel tuo pom.xmlfile, devi usare questi vasi pom.xmlcome al solito:

    <dependency>
        <groupId>com.amazonservices.mws</groupId>
        <artifactId>mws-client</artifactId>
        <version>1.0</version>
    </dependency>

Nota che l' maven-install-pluginunico copia i tuoi vasetti esterni sul tuo locale.m2 repository Maven . Questo è tutto. Non include automaticamente questi barattoli come dipendenze maven al tuo progetto.

È un punto secondario, ma a volte facile da perdere.

Ho avuto lo stesso errore per una serie di dipendenze nel mio pom.xml, risulta che le versioni delle dipendenze non sono state specificate nel pom.xml e sono state menzionate nel repository padre. Per qualche motivo i dettagli della versione non si sincronizzavano con questo repository. Quindi ho inserito manualmente le versioni usando il tag e ha funzionato come un fascino. È necessario un po 'di tempo per cercare le versioni nel genitore e specificare qui. Ma questo può essere fatto solo per i vasetti che mostrano l'errore artefatto e funziona. Spero che questo aiuti qualcuno.

In Apache Maven 3.5.4, ho dovuto aggiungere una doppia citazione. Senza doppia citazione non ha funzionato per me.

esempio: mvn install: file di installazione "-Dfile = posizione nel file jar" "-DgroupId = ID gruppo" "-DartifactId = ID artefatto" "-Dversion = versione" "-Dpackaging = tipo di pacchetto"

1. Crea una directory di repository Maven locale, la radice del tuo progetto dovrebbe assomigliare a questa per iniziare:

yourproject
+- pom.xml
+- src

2. Aggiungi una directory di repository Maven standard chiamata repo per il gruppo com.example e la versione 1.0:

yourproject
+- pom.xml
+- src
+- repo

3. Distribuisci l'artefatto nel Repo, Maven può distribuire l'artefatto per te usando l'obiettivo mvn deploy: deploy-file:

mvn deploy:deploy-file -Durl=file:///pathtoyour/repo -Dfile=your.jar -DgroupId=your.group.id -DartifactId=yourid -Dpackaging=jar -Dversion=1.0

4. installa il file pom corrispondente al tuo jar in modo che il tuo progetto possa trovare jar durante la compilazione di Maven dal repository locale:

mvn install:install-file -Dfile=/path-to-your-jar-1.0.jar -DpomFile=/path-to-your-pom-1.0.pom

5. aggiungi repository nel tuo file pom:

<repositories>
    <!--other repositories if any-->
    <repository>
        <id>project.local</id>
        <name>project</name>
        <url>file:${project.basedir}/repo</url>
    </repository>
</repositories>

6. aggiungi la dipendenza nel tuo pom:

<dependency>
    <groupId>com.groupid</groupId>
    <artifactId>myid</artifactId>
    <version>1.0</version>
</dependency>

QUESTA RISPOSTA È SOLO PER GLI UTENTI ECLIPSE:

Se si utilizza Eclipse, posizionare il vaso in lib /, fare clic con il tasto destro sul nome del vaso e fare clic su "Aggiungi al percorso di costruzione". Eclipse creerà una "libreria di riferimento" e posizionerà il vaso per te

Ha risolto l'importazione del vaso subito nel programma per me