Maven: Beste Möglichkeit, benutzerdefinierte externe JAR mit meinem Projekt zu verknüpfen?

Es sind meine ersten Tage, in denen ich Maven lerne, und ich habe immer noch Probleme mit den Grundlagen. Ich habe eine externe JAR-Datei (nicht in den öffentlichen Repos verfügbar), auf die ich in meinem Projekt verweisen muss, und ich versuche herauszufinden, was meine beste Option ist.

Es ist ein kleines Projekt ohne zentrales Repository für Bibliotheken, daher muss es entweder ein lokales Repository sein (irgendwie zur Quellcodeverwaltung hinzugefügt, weiß nicht, ob es so funktionieren soll?) Oder die .jar muss gespeichert werden Festplatte außerhalb eines formalen Repositorys.

1) Was ist meine beste Option, um die JAR-Datei mit maven zu den Referenzen meines Projekts hinzuzufügen, da ich möchte, dass sowohl das Projekt als auch die Bibliothek in der Quellcodeverwaltung sind?

2) Ich kann immer noch nicht scheinen, dass Eclipse die Abhängigkeit sieht. Ich habe es manuell zum Abschnitt des POM hinzugefügt und es wird in der Liste der Abhängigkeiten in m2eclipse gut angezeigt. mvn compile und mvn package sind beide erfolgreich, aber das Ausführen des Programms führt zu:

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

Dies erfolgt nach dem Bearbeiten des POM als:

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

Sollte ich mvn install: install-file ausführen, obwohl ich dachte, ich hätte die pom.xml bereits wie oben bearbeitet?

Vielen Dank!

Ich denke, Sie sollten verwenden mvn install:install-file, um Ihr lokales Repository mit den Bibliotheksgläsern zu füllen, dann sollten Sie den Bereich vom System zum Kompilieren ändern.

Wenn Sie mit maven beginnen, empfehle ich, maven direkt und nicht IDE-Plugins zu verwenden, da dies eine zusätzliche Komplexitätsebene hinzufügt.

Stellen Sie für den Fehler die erforderlichen Gläser in Ihren Klassenpfad? Wenn Sie Typen aus der Bibliothek verwenden, müssen Sie auch zur Laufzeit Zugriff darauf haben. Das hat nichts mit Maven selbst zu tun.

Ich verstehe nicht, warum Sie die Bibliothek der Quellcodeverwaltung unterziehen möchten - es handelt sich um Quellcode, nicht um Binärgläser.

Sie können ein In Project Repository erstellen, sodass Sie dies nicht run mvn install:install-filejedes Mal tun müssen, wenn Sie an einem neuen Computer arbeiten

<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

Detail lesen Sie diesen Blog-Beitrag

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

Dies kann leicht erreicht werden, indem das im <dependency> -Element verschachtelte <scope> -Element verwendet wird.

Beispielsweise:

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

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

Das Maven-Handbuch sagt dazu Folgendes :

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

Update Wir haben seitdem gerade unseren eigenen Nexus-Server installiert, viel einfacher und sauberer.

In unserer Firma hatten wir einige Gläser, von denen wir einige Gläser hatten, die üblich waren, aber nicht in Maven-Repositories gehostet wurden, und wir wollten sie auch nicht in einem lokalen Lager haben. Wir haben ein sehr einfaches mvn (öffentliches) Repo auf Github erstellt (Sie können es jedoch auf jedem Server oder lokal hosten):
Beachten Sie, dass dies nur ideal für die Verwaltung einiger selten wechselnder JAR-Dateien ist

1. Repo auf GitHub erstellen:
   https://github.com/<user_name>/mvn-repo/

2. Repository in pom.xml hinzufügen
   (Beachten Sie, dass sich die vollständige Pfad-Rohdatei etwas vom Repo-Namen unterscheidet.)
   

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

3. Hinzufügen einer Abhängigkeit zum Host (Github oder privater Server)
   a. Alles, was Sie wissen müssen, ist, dass Dateien in dem von @glitch
   /groupId/artifactId/version/artifactId-version.jar
   b angegebenen Muster gespeichert werden . Erstellen Sie auf Ihrem Host die Ordner, die diesem Muster entsprechen.
   Wenn Sie also eine JAR-Datei mit dem Namen haben service-sdk-0.0.1.jar, erstellen Sie den Ordner service-sdk/service-sdk/0.0.1/und legen Sie die JAR-Datei service-sdk-0.0.1.jardarin ab.
   c. Testen Sie es, indem Sie versuchen, das Glas von einem Browser herunterzuladen (in unserem Fall:https://github.com/<user_name>/mvn-repo/raw/master/service-sdk/service-sdk/0.0.1/service-sdk-0.0.1.jar
   

4. Fügen Sie Ihrer pom.xml-Datei eine Abhängigkeit hinzu:
   

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

5. Genießen

Verwenden Sie nicht systemPath. Im Gegensatz zu dem, was die Leute hier gesagt haben, können Sie ein externes Glas in einen Ordner unter Ihrem ausgecheckten Projektverzeichnis legen und Maven findet es wie andere Abhängigkeiten. Hier sind zwei entscheidende Schritte:

1. Verwenden Sie "mvn install: install-file" mit -DlocalRepositoryPath.
2. Konfigurieren Sie ein Repository so, dass es auf diesen Pfad in Ihrem POM verweist.

Es ist ziemlich einfach und Sie finden hier ein schrittweises Beispiel: http://randomizedsort.blogspot.com/2011/10/configuring-maven-to-use-local-library.html

Maven-Methode zum Hinzufügen von Nicht-Maven-Gläsern zum Maven-Projekt

Maven Project und Nicht-Maven-Gläser

Fügen Sie die Maven-Installations-Plugins in Ihren Build-Bereich ein

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

Fügen Sie die Abhängigkeit hinzu

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

Referenzen Hinweis Ich bin der Eigentümer des Blogs

Wenn Sie auf dasselbe Problem stoßen und Spring-Boot v1.4 + verwenden , können Sie dies auf diese Weise tun.

Es gibt ein includeSystemScope , mit dem Sie dem JAR Abhängigkeiten vom Systembereich hinzufügen können.

z.B

Ich verwende Oracle-Treiber in meinem Projekt.

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

Machen Sie dann includeSystemScope = true, um das JAR in den Pfad / BOOT-INF / lib / ** aufzunehmen

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

und von der Ressource ausschließen, um doppelte Einschlüsse zu vermeiden, das Glas ist fett genug ~

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

Viel Glück!

Ändern Sie Ihren Systempfad .

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

In der Datei pom.xml wird in Ihrem lokalen Repository nach der Abhängigkeit gesucht, die Ihrem Artefakt entspricht. Außerdem sollten Sie den Systembereich oder die systemPath-Attribute nicht wirklich verwenden. Diese sind normalerweise für Dinge reserviert, die sich im JDK und nicht in der JRE befinden

In dieser Frage erfahren Sie, wie Sie Maven-Artefakte installieren.

Beachten Sie, dass alle Beispiele, die verwenden

<repository>...</respository> 

erfordern äußere

<repositories>...</repositories> 

Tags einschließen. Aus einigen Beispielen ist dies nicht ersichtlich.

Die beste Lösung besteht darin, ein Repository zu installieren: Nexus oder Artifactory. Wenn Sie einen Platz haben, an dem Sie solche Dinge platzieren können, beschleunigt dies die Dinge, indem Sie Ihre Sachen von außen zwischenspeichern.

Wenn es sich um Open Source handelt, können Sie auch in Betracht ziehen , es in die Zentrale zu integrieren.

Siehe die Anleitung .

Mit Eclipse Oxygen können Sie Folgendes tun:

1. Platzieren Sie Ihre Bibliotheken in WEB-INF / lib
2. Projekt -> Erstellungspfad konfigurieren -> Bibliothek hinzufügen -> Web-App-Bibliothek

Maven übernimmt sie bei der Installation des Projekts.

Wenn das externe JAR nur von einem Maven-Projekt erstellt wird, können Sie das gesamte Projekt auf Ihr System kopieren und a ausführen

mvn install

im Projektverzeichnis. Dadurch wird das JAR in das Verzeichnis .m2 eingefügt, das das lokale Maven-Repository ist.

Jetzt können Sie die hinzufügen

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

Dies wird sicherstellen, dass Sie

mvn exec:java 

funktioniert. Wenn Sie hier vorgeschlagen verwenden

<scope>system</scope>

Dann müssen Sie Klassen einzeln hinzufügen, während Sie die Ausführung über die Befehlszeile verwenden.

Sie können die externen Gläser mit dem folgenden hier beschriebenen Befehl hinzufügen

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

Der effizienteste und sauberste Weg, um dieses Problem zu lösen, ist die Verwendung von Github-Paketen

1. Erstellen Sie auf GitHub ein einfaches leeres öffentliches / privates Repository gemäß Ihren Anforderungen, unabhängig davon, ob Ihr externes JAR öffentlich gehostet werden soll oder nicht.

2. Führen Sie den folgenden Befehl aus, um Ihr externes JAR im oben erstellten Github-Repository bereitzustellen

   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

   Mit dem obigen Befehl wird Ihr externes JAR im GitHub-Repository bereitgestellt, das in erwähnt wird -Durl=. Sie können diesen Link unter Bereitstellen von Abhängigkeiten als GitHub-Pakete lesen. GitHub-Paketbereitstellungs-Lernprogramm

3. Danach können Sie die Abhängigkeit unter Verwendung hinzufügen groupId, artifactIdund versionerwähnt in obigen Schritt in Maven pom.xmlund Laufmvn install

4. Maven ruft die Abhängigkeit von externem JAR aus der Registrierung von GitHub Packages ab und stellt sie in Ihrem Maven-Projekt bereit.

5. Damit dies funktioniert, müssen Sie auch Ihre Maven so konfigurieren, dass settings.xmlsie aus der GitHub Package-Registrierung abgerufen werden.