Maven: il modo migliore per collegare il JAR esterno personalizzato al mio progetto?

Sono i miei primi due giorni a imparare Maven e sto ancora lottando con le basi. Ho un file .jar esterno (non disponibile nei repository pubblici) che devo fare riferimento nel mio progetto e sto cercando di capire quale sia la mia migliore opzione.

È un progetto su piccola scala senza un repository centrale per le librerie, quindi deve essere un repository locale (in qualche modo aggiunto al controllo del codice sorgente, non sai se dovrebbe funzionare in quel modo?) O il file .jar deve essere archiviato su disco esterno a qualsiasi repository formale.

1) Qual è la mia migliore opzione per aggiungere il file .jar ai riferimenti del mio progetto con Maven dato che voglio che sia il progetto che la libreria siano nel controllo del codice sorgente?

2) Non riesco ancora a vedere Eclipse vedere la dipendenza. L'ho aggiunto manualmente alla sezione del pom e si presenta bene nell'elenco Dipendenze in m2eclipse. mvn compile e pacchetto mvn hanno esito positivo, ma l'esecuzione del programma comporta:

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
        LibraryStuff cannot be resolved to a type

Questo è dopo aver modificato il POM come:

<dependency>
  <groupId>stuff</groupId>
  <artifactId>library</artifactId>
  <version>1.0</version>
  <systemPath>${lib.location}/MyLibrary.jar</systemPath>
  <scope>system</scope>
</dependency>

Dovrei eseguire mvn install: install-file anche se ho già modificato il pom.xml come sopra?

Grazie!

Penso che dovresti usare mvn install:install-fileper popolare il tuo repository locale con i vasetti della libreria, quindi dovresti cambiare l'ambito dal sistema alla compilazione.

Se stai iniziando con maven ti suggerisco di usare maven direttamente non plugin IDE in quanto aggiunge un ulteriore livello di complessità.

Per quanto riguarda l'errore, metti i barattoli richiesti sul tuo percorso di classe? Se si utilizzano tipi dalla libreria, è necessario averne accesso anche in fase di esecuzione. Questo non ha nulla a che fare con la stessa maven.

Non capisco perché vuoi mettere la libreria al controllo del codice sorgente - è per codice sorgente non barattoli binari.

È possibile creare un repository In Project, quindi non è necessario run mvn install:install-fileogni volta che si lavora su un nuovo computer

<repository>
    <id>in-project</id>
    <name>In Project Repo</name>
    <url>file://${project.basedir}/libs</url>
</repository>

<dependency>
    <groupId>dropbox</groupId>
    <artifactId>dropbox-sdk</artifactId>
    <version>1.3.1</version>
</dependency>

/groupId/artifactId/version/artifactId-verion.jar

dettaglio leggi questo post sul blog

https://web.archive.org/web/20121026021311/charlie.cu.cc/2012/06/how-add-external-libraries-maven

Ciò può essere facilmente ottenuto utilizzando l'elemento <scope> nidificato all'interno dell'elemento <dipendenza>.

Per esempio:

 <dependencies>
   <dependency>
     <groupId>ldapjdk</groupId>
     <artifactId>ldapjdk</artifactId>
     <scope>system</scope>
     <version>1.0</version>
     <systemPath>${basedir}\src\lib\ldapjdk.jar</systemPath>
   </dependency>
 </dependencies>

Riferimento: http://www.tutorialspoint.com/maven/maven_external_dependencies.htm

Il manuale Maven dice di fare questo:

mvn install:install-file -Dfile=non-maven-proj.jar -DgroupId=some.group -DartifactId=non-maven-proj -Dversion=1 -Dpackaging=jar

aggiornare Da allora abbiamo appena installato il nostro server Nexus, molto più semplice e pulito.

Nella nostra azienda avevamo alcuni barattoli che alcuni barattoli erano comuni ma non erano ospitati in nessun deposito maven, né volevamo averli in deposito locale. Abbiamo creato un repository mvn (pubblico) molto semplice su Github (ma puoi ospitarlo su qualsiasi server o localmente):
nota che questo è l'ideale solo per gestire alcuni file jar che cambiano raramente

1. Crea repository su GitHub:
   https://github.com/<user_name>/mvn-repo/

2. Aggiungi repository in pom.xml
   (Nota che il file raw del percorso completo sarà leggermente diverso dal nome del repository)
   

   <repository>
       <id>project-common</id>
       <name>Project Common</name>
       <url>https://github.com/<user_name>/mvn-repo/raw/master/</url>
   </repository>

3. Aggiungi dipendenza all'host (Github o server privato)
   a. Tutto quello che devi sapere è che i file sono memorizzati nel modello menzionato da @glitch
   /groupId/artifactId/version/artifactId-version.jar
   b. Sul tuo host crea le cartelle per abbinare questo modello.
   cioè se hai un file jar chiamato service-sdk-0.0.1.jar, crea la cartella service-sdk/service-sdk/0.0.1/e inserisci il file jar service-sdk-0.0.1.jarin essa.
   c. Provalo provando a scaricare il jar da un browser (nel nostro caso:https://github.com/<user_name>/mvn-repo/raw/master/service-sdk/service-sdk/0.0.1/service-sdk-0.0.1.jar
   

4. Aggiungi dipendenza al tuo file pom.xml:
   

   <dependency>
       <groupId>service-sdk</groupId>
       <artifactId>service-sdk</artifactId>
       <version>0.0.1</version>
   </dependency>

5. Godere

Non usare systemPath. Contrariamente a ciò che la gente ha detto qui, puoi mettere un vaso esterno in una cartella sotto la directory del tuo progetto estratto e rifugio Maven lo trova come altre dipendenze. Ecco due passaggi cruciali:

1. Utilizzare "mvn install: install-file" con -DlocalRepositoryPath.
2. Configura un repository per puntare a quel percorso nel tuo POM.

È abbastanza semplice e puoi trovare un esempio passo-passo qui: http://randomizedsort.blogspot.com/2011/10/configuring-maven-to-use-local-library.html

Modo Maven per aggiungere vasetti non maven al progetto maven

Progetto Maven e barattoli non maven

Aggiungi i plug-in di installazione Maven nella sezione build

<plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-install-plugin</artifactId>
        <version>${version.maven-install-plugin}</version>
        <executions>

            <execution>
                <id>install-external-non-maven1-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar1.group</groupId>
                    <artifactId>non-maven1</artifactId>
                    <version>${version.non-maven1}</version>
                    <file>${project.basedir}/libs/non-maven1.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
            <execution>
                <id>install-external-non-maven2-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar2.group</groupId>
                    <artifactId>non-maven2</artifactId>
                    <version>${version.non-maven2}</version>
                    <file>${project.basedir}/libs/non-maven2.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
            <execution>
                <id>install-external-non-maven3-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar3.group</groupId>
                    <artifactId>non-maven3</artifactId>
                    <version>${version.non-maven3}</version>
                    <file>${project.basedir}/libs/non-maven3.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
        </executions>
    </plugin>

Aggiungi la dipendenza

<dependencies>
    <dependency>
        <groupId>jar1.group</groupId>
        <artifactId>non-maven1</artifactId>
        <version>${version.non-maven1}</version>
    </dependency>
    <dependency>
        <groupId>jar2.group</groupId>
        <artifactId>non-maven2</artifactId>
        <version>${version.non-maven2}</version>
    </dependency>
    <dependency>
        <groupId>jar3.group</groupId>
        <artifactId>non-maven3</artifactId>
        <version>${version.non-maven3}</version>
    </dependency>
</dependencies>

Riferimenti Nota Sono il proprietario del blog

Se si riscontra lo stesso problema e si utilizza spring-boot v1.4 + , è possibile farlo in questo modo.

C'è un includeSystemScope che è possibile utilizzare per aggiungere dipendenze dell'ambito del sistema al vaso.

per esempio

Sto usando Oracle Driver nel mio progetto.

<dependency>
        <groupId>com.oracle</groupId>
        <artifactId>ojdbc14</artifactId>
        <version>10.2.0.3.0</version>
        <scope>system</scope>
        <systemPath>${project.basedir}/src/main/resources/extra-jars/ojdbc14-10.2.0.3.0.jar</systemPath>
    </dependency>

quindi make includeSystemScope = true per includere il jar in path / BOOT-INF / lib / **

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <includeSystemScope>true</includeSystemScope>
    </configuration>
</plugin>

ed escludi dalla risorsa per evitare duplicati, il vaso è abbastanza grasso ~

<build>
    <testSourceDirectory>src/test/java</testSourceDirectory>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <excludes>
                <exclude>**/*.jar</exclude>
            </excludes>
        </resource>
    </resources>
</build>

In bocca al lupo!

Cambia il tuo systemPath .

<dependency>
  <groupId>stuff</groupId>
  <artifactId>library</artifactId>
  <version>1.0</version>
  <systemPath>${project.basedir}/MyLibrary.jar</systemPath>
  <scope>system</scope>
</dependency>

Pom.xml esaminerà il repository locale per cercare di trovare la dipendenza corrispondente al tuo artefatto. Inoltre, non dovresti davvero utilizzare l'ambito del sistema o gli attributi systemPath, questi sono normalmente riservati per le cose che si trovano nel JDK e non nel JRE

Vedi questa domanda per come installare artefatti di Maven.

Nota che tutti gli esempi che usano

<repository>...</respository> 

richiede esterno

<repositories>...</repositories> 

tag allegati. Non è chiaro da alcuni degli esempi.

La soluzione migliore qui è installare un repository: Nexus o Artifactory. Se ti dà un posto dove mettere le cose in questo modo, e inoltre accelera le cose memorizzando nella cache le tue cose dall'esterno.

Se la cosa con cui hai a che fare è open source, potresti anche prendere in considerazione l' idea di metterti al centro.

Vedere la guida .

Con Eclipse Oxygen puoi fare le seguenti cose:

1. Inserisci le tue librerie in WEB-INF / lib
2. Progetto -> Configura percorso build -> Aggiungi libreria -> Libreria app Web

Maven li prenderà durante l'installazione del progetto.

Se il jar esterno viene creato solo da un progetto Maven, è possibile copiare l'intero progetto sul sistema ed eseguire un

mvn install

nella directory del progetto. Questo aggiungerà il vaso nella directory .m2 che è il repository locale di Maven.

Ora puoi aggiungere il

<dependency>
     <groupId>copy-from-the=maven-pom-of-existing-project</groupId>
     <artifactId>copy-from-the=maven-pom-of-existing-project</artifactId>
     <version>copy-from-the=maven-pom-of-existing-project</version>
</dependency>

Questo ti garantirà

mvn exec:java 

lavori. Se usi suggerito qui

<scope>system</scope>

Quindi dovrai aggiungere le classi individualmente durante l'utilizzo tramite la riga di comando.

È possibile aggiungere i vasetti esterni con il seguente comando descritto qui

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

Il modo più efficiente e più pulito che ho trovato per affrontare questo problema è utilizzando i pacchetti Github

1. Crea un semplice repository pubblico / privato vuoto su GitHub in base alle tue esigenze, indipendentemente dal fatto che tu voglia ospitare o meno il tuo jar esterno.

2. Esegui sotto il comando maven per distribuire il tuo jar esterno nel repository github sopra creato

   mvn deploy:deploy-file \ -DgroupId= your-group-id \ -DartifactId= your-artifact-id \ -Dversion= 1.0.0 -Dpackaging= jar -Dfile= path-to-file \ -DrepositoryId= id-to-map-on-server-section-of-settings.xml \ -Durl=https://maven.pkg.github.com/github-username/github-reponame-created-in-above-step

   Il comando sopra ti distribuirà jar esterno nel repository GitHub menzionato in -Durl=. È possibile fare riferimento a questo collegamento su Come distribuire le dipendenze come Tutorial di distribuzione dei pacchetti GitHub

3. Dopo di che è possibile aggiungere la dipendenza utilizzando groupId, artifactIde versiondi cui al punto precedente in Maven pom.xmled eseguiremvn install

4. Maven recupererà la dipendenza del vaso esterno dal registro dei pacchetti GitHub e fornirà il tuo progetto maven.

5. Affinché funzioni, dovrai anche configurare la tua maven's settings.xmlper il recupero dal registro del pacchetto GitHub.