Maven: najlepszy sposób łączenia niestandardowego zewnętrznego JAR z moim projektem?

Możesz utworzyć repozytorium projektu In, więc nie musisz run mvn install:install-file za każdym razem, gdy pracujesz na nowym komputerze

<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

Szczegóły przeczytaj ten wpis na blogu

Http://charlie.cu.cc/2012/06/how-add-external-libraries-maven/

Instrukcja obsługi Mavena mówi, aby zrobić to:

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

Aktualizacja od tego czasu właśnie zainstalowaliśmy nasz własny serwer Nexus, znacznie łatwiejszy i czystszy.

W naszej firmie mieliśmy kilka słoików, które były wspólne, ale nie były hostowane w żadnych repozytoriach maven, ani nie chcieliśmy mieć ich w lokalnym magazynie. Stworzyliśmy bardzo prosty repo mvn (public) na Githubie (ale możesz go hostować na dowolnym serwerze lub lokalnie):
Uwaga że jest to idealne rozwiązanie tylko do zarządzania kilkoma pliki

1. Utwórz repo na GitHub:
   https://github.com/<user_name>/mvn-repo/

2. Dodaj repozytorium w pom.xml
   (Należy pamiętać, że pełna ścieżka pliku raw będzie nieco inna niż nazwa repo)
   

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

3. Dodaj zależność do hosta (Github lub private server)
   a. Wszystko, co musisz wiedzieć, to to, że pliki są przechowywane we wzorze wspomnianym przez @ glitch
   /groupId/artifactId/version/artifactId-version.jar
   B. na twoim komputerze Utwórz foldery pasujące do tego wzorca.
   jeśli Utwórz plik jar o nazwie service-sdk-0.0.1.jar, Utwórz folder service-sdk/service-sdk/0.0.1/ i umieść w nim plik jar service-sdk-0.0.1.jar.
   C. przetestuj go, próbując pobrać jar z przeglądarki (w naszym przypadku: https://github.com/<user_name>/mvn-repo/raw/master/service-sdk/service-sdk/0.0.1/service-sdk-0.0.1.jar
   

4. Dodaj zależność do pom.plik xml:
   

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

5. Enjoy

Można to łatwo osiągnąć za pomocą elementu zagnieżdżonego wewnątrz elementu .

Na przykład:

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

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

Nie używaj systemPath. W przeciwieństwie do tego, co ludzie tutaj powiedzieli, możesz umieścić zewnętrzny jar w folderze pod twoim sprawdzonym katalogiem projektu i nie ma problemu znaleźć go jak inne zależności. Oto dwa kluczowe kroki:

1. Użyj "mvn install: install-file" z -DlocalRepositoryPath.
2. Skonfiguruj repozytorium tak, aby wskazywało na tę ścieżkę w Twoim POM.

Jest to dość proste i można znaleźć przykład krok po kroku proszę.: http://randomizedsort.blogspot.com/2011/10/configuring-maven-to-use-local-library.html

Zmień swój systemPath .

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

Jeśli napotkasz ten sam problem i używasz spring-boot v1.4+, możesz to zrobić w ten sposób.

Istnieje includeSystemScope, którego można użyć do dodania zależności zakresu systemowego do jar.

Np.

Używam sterownika oracle do mojego projektu.

<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>

Następnie utwórz includeSystemScope = true, aby włączyć jar do ścieżki / BOOT-INF / lib/ * *

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

I wyklucz z zasobu, aby uniknąć powielania include, słoik jest gruby enought ~

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

Maven sposób na dodanie słoików non maven do projektu Maven

Maven Project i non Maven jars

Dodaj wtyczki instalacyjne maven w sekcji budowania

<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>

Dodaj zależność

<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>

Referencje Uwaga jestem właścicielem bloga

Pom.xml zajrzy do lokalnego repozytorium, aby spróbować znaleźć zależność, która pasuje do twojego artefaktu. Ponadto nie powinieneś używać atrybutów system scope lub systemPath, są one zwykle zarezerwowane dla rzeczy, które są w JDK, a nie JRE

Zobacz to pytanie Jak zainstalować artefakty Mavena.

Najlepszym rozwiązaniem jest zainstalowanie repozytorium: Nexus lub Artifactory. Jeśli daje Ci miejsce do umieszczenia takich rzeczy, a dodatkowo przyspiesza rzeczy, buforując twoje rzeczy z zewnątrz.

Jeśli rzecz, z którą masz do czynienia jest open source, możesz również rozważyć umieszczenie w centrum.

Zobacz poradnik .

Zauważ, że wszystkie przykłady, które używają

<repository>...</respository> 

Require outer

<repositories>...</repositories> 

Dołączanie znaczników. Nie jest to jasne z niektórych przykładów.

Jeśli zewnętrzny jar jest tworzony tylko przez projekt Maven, możesz skopiować cały projekt na swój system i uruchomić

mvn install

W katalogu projektu. To doda słoik .katalog m2 będący lokalnym repozytorium maven.

Teraz możesz dodać

<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>

To zapewni Ci

mvn exec:java 

<scope>system</scope>

Następnie będziesz musiał dodawać klasy indywidualnie podczas używania polecenia executing through Kolejka

Możesz dodać zewnętrzne słoiki za pomocą następującego polecenia opisanego tutaj

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

Z Eclipse Oxygen możesz zrobić następujące rzeczy:

1. Umieść swoje biblioteki w WEB-INF / lib
2. Project - > Configure Build Path -> Add Library - > Web App Library

Maven zajmie się nimi podczas instalacji projektu.