Wie füge ich einem Maven-Projekt lokale JAR-Dateien hinzu?

Wie füge ich lokale JAR-Dateien (die noch nicht Teil des Maven-Repositorys sind) direkt in die Bibliotheksquellen meines Projekts ein?

Installieren Sie die JAR wie folgt in Ihrem lokalen Maven-Repository:

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

Wo sich jeder bezieht auf:

<path-to-file>: der Pfad zur zu ladenden Datei zB → c:\kaptcha-2.3.jar

<group-id>: die Gruppe, unter der die Datei registriert werden soll, zB → com.google.code

<artifact-id>: der Artefaktname für die Datei zB → kaptcha

<version>: die Version der Datei zB → 2.3

<packaging>: die Verpackung der Datei zB → jar

Referenz

• Maven FAQ: Ich habe ein Glas, das ich in mein lokales Repository stellen möchte. Wie kann ich es kopieren?
• Maven Install Plugin Verwendung: Das install:install-fileZiel

Sie können lokale Abhängigkeiten wie folgt direkt hinzufügen (wie im Build-Maven-Projekt mit Propriaterie-Bibliotheken erwähnt ):

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

Aktualisieren

In neuen Versionen ist diese Funktion als veraltet markiert, funktioniert aber noch und wurde noch nicht entfernt (Sie sehen nur eine Warnung im Protokoll während des Starts des Maven). In der Maven-Gruppe wird ein Problem mit https://issues.apache.org/jira/browse/MNG-6523 angesprochen (Sie können teilnehmen und beschreiben, warum diese Funktion in einigen Fällen hilfreich ist). Ich hoffe, dass diese Funktion dort bleibt!

Wenn Sie mich fragen, solange das Feature nicht entfernt wird, verwende ich dies, um die Abhängigkeit von nur einer ungezogenen JAR-Datei in meinem Projekt herzustellen, die nicht in das Repository passt. Wenn diese Funktion entfernt wird, gibt es hier viele gute Antworten, aus denen ich später auswählen kann!

Erstens möchte ich diese Antwort einem anonymen Stack Overflow-Benutzer gutschreiben - ich bin mir ziemlich sicher, dass ich hier schon einmal eine ähnliche Antwort gesehen habe - aber jetzt kann ich sie nicht finden.

Die beste Option, um lokale JAR-Dateien als Abhängigkeit zu haben, besteht darin, ein lokales Maven-Repository zu erstellen. Ein solches Repository ist nichts anderes als eine richtige Verzeichnisstruktur mit POM-Dateien.

Für mein Beispiel: Ich habe mein Masterprojekt vor ${master_project}Ort und Unterprojekt1 ist eingeschaltet ${master_project}/${subproject1}.

Dann erstelle ich ein Maven-Repository in : ${master_project}/local-maven-repo.

In der pom-Datei in subproject1 unter ${master_project}/${subproject1}/pom.xmlmuss das Repository angegeben werden, das den Dateipfad als URL-Parameter verwendet:

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

Die Abhängigkeit kann wie für jedes andere Repository angegeben werden. Dies macht Ihr POM-Repository unabhängig. Sobald die gewünschte JAR beispielsweise in Maven Central verfügbar ist, müssen Sie sie nur noch aus Ihrem lokalen Repo löschen, und sie wird aus dem Standard-Repo abgerufen.

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

Das Letzte, was Sie tun müssen, ist, die JAR-Datei mit dem Schalter -DlocalRepositoryPath wie folgt zum lokalen Repository hinzuzufügen:

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

Sobald die JAR-Datei installiert ist, kann Ihr Maven-Repo in ein Code-Repository übertragen werden, und die gesamte Einrichtung ist systemunabhängig. ( Arbeitsbeispiel in GitHub ).

Ich bin damit einverstanden, dass es keine gute Praxis ist, JARs für das Quellcode-Repo zu verwenden, aber im wirklichen Leben sind schnelle und schmutzige Lösungen manchmal besser als ein vollwertiges Nexus-Repo, um eine JAR zu hosten, die Sie nicht veröffentlichen können.

Erstellen Sie einen neuen Ordner, beispielsweise local-maven-repoim Stammverzeichnis Ihres Maven-Projekts.

Fügen Sie einfach ein lokales Repo in <project>Ihr pom.xml:

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

Gehen Sie dann für jedes externe JAR, das Sie installieren möchten, zum Stammverzeichnis Ihres Projekts und führen Sie Folgendes aus:

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

Ich möchte eine solche Lösung - maven-install-pluginin POM-Datei verwenden:

<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 diesem Fall können Sie durchführen mvn initializeund jar wird im lokalen Maven Repo installiert. Jetzt ist dieses JAR während eines beliebigen Maven-Schritts auf diesem Computer verfügbar (vergessen Sie nicht, diese Abhängigkeit wie jede andere Maven-Abhängigkeit in pom with <dependency></dependency>tag aufzunehmen). Es ist auch möglich, jar install nicht an initializestep, sondern an einen beliebigen anderen Schritt zu binden .

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

Ja, Sie können haben, aber es ist keine gute Idee.

Installieren Sie stattdessen alle diese Gläser, um Repos zu maven

Siehe auch

• So erstellen Sie ein Maven-Projekt mit enthaltenen Propriaterie-Bibliotheken

Der wirklich schnelle und schmutzige Weg besteht darin, auf eine lokale Datei zu verweisen:

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

Dies funktioniert jedoch (offensichtlich) nur auf Ihrem Computer. Für die Freigabe ist es normalerweise sinnvoll, ein geeignetes m2-Archiv (nexus / artifactory) zu verwenden, oder wenn Sie keines davon haben oder keinen lokalen Maven einrichten möchten strukturiertes Archiv und konfigurieren Sie ein "Repository" in Ihrem pom: local:

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

Fernbedienung:

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

Hierzu ist auch ein relativer Pfad mit der Variable basedir möglich:

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

Fügen Sie Ihre eigene lokale JAR in die POM-Datei ein und verwenden Sie diese in Maven Build.

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

Zum Beispiel:

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

Fügen Sie es dann wie folgt zum POM hinzu:

Eine Möglichkeit besteht darin, es in Ihren eigenen Maven-Repository-Manager (z. B. Nexus) hochzuladen. Es ist sowieso empfehlenswert, einen eigenen Repository-Manager zu haben.

Eine andere nette Möglichkeit, die ich kürzlich gesehen habe, besteht darin, das Maven-Installations-Plugin in Ihren Build-Lebenszyklus aufzunehmen: Sie deklarieren im POM, die Dateien im lokalen Repository zu installieren. Es ist ein kleiner, aber kleiner Aufwand und kein manueller Schritt erforderlich.

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

Natürlich können Sie diesem Ordner Gläser hinzufügen. Aber vielleicht macht es nicht das, was Sie erreichen wollen ...

Wenn Sie diese Jars zum Kompilieren benötigen, überprüfen Sie diese verwandte Frage: Kann ich dem Maven 2 Build-Klassenpfad Jars hinzufügen, ohne sie zu installieren?

Verwenden Sie den Systembereich NICHT, bevor jemand dies vorschlägt.

Ein weiterer interessanter Fall ist, wenn Sie in Ihrem Projekt private Maven-Gläser haben möchten. Möglicherweise möchten Sie die Funktionen von Maven beibehalten, um transitive Abhängigkeiten aufzulösen. Die Lösung ist ziemlich einfach.

1. Erstellen Sie eine Ordnerbibliothek in Ihrem Projekt

2. Fügen Sie die folgenden Zeilen in Ihre pom.xml-Datei ein

   <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. Öffnen Sie den Ordner .m2 / repository und kopieren Sie die Verzeichnisstruktur des Projekts, das Sie importieren möchten, in den Ordner libs .

Angenommen, Sie möchten die Abhängigkeit importieren

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

Gehen Sie einfach auf .m2 / repository und Sie sehen den folgenden Ordner

com / mycompany / myproject / 1.2.3

Kopieren Sie alles in Ihren libs-Ordner (wieder einschließlich der Ordner unter .m2 / repository ) und Sie sind fertig.

Befehlszeile :

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

Ein wichtiger Teil der Abhängigkeit ist: $ {pom.basedir} (statt nur $ {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>

Ich denke, eine bessere Lösung für dieses Problem ist die Verwendung des Maven-Install-Plugins , um die Dateien bei der Installation automatisch zu installieren. So richte ich es für mein Projekt ein.

Fügen Sie zunächst den Pfad (in dem Sie die lokalen .jars speichern) als Eigenschaft hinzu.

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

Fügen Sie dann unter pluginsAdd ein Plugin hinzu, um die Jars beim Kompilieren zu installieren.

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

Schließlich können Sie in Abhängigkeiten die Gläser hinzufügen

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

Wenn Sie Ihr Projekt so einrichten, wird das Projekt auch dann weiter erstellt, wenn Sie es auf einen anderen Computer übertragen (vorausgesetzt, es enthält alle JAR-Dateien in dem von der Eigenschaft angegebenen Pfad local.sdk).

Für den groupIdEinsatz nur einen eindeutigen Namen , um sicherzustellen , dass es keine Konflikte.

Jetzt, wenn Sie mvn installoder mvn testlokale Gläser automatisch hinzugefügt werden.

Der bevorzugte Weg wäre, ein eigenes Remote-Repository zu erstellen.

Sehen Sie hier für Informationen, wie man es tun. Schauen Sie sich den Abschnitt " Hochladen in ein Remote-Repository " an.

Ich möchte einen Code freigeben, in den Sie einen Ordner voller Gläser hochladen können. Dies ist nützlich, wenn ein Anbieter kein öffentliches Repository hat und Sie viele Bibliotheken manuell hinzufügen müssen. Ich habe beschlossen, eine .bat-Datei zu erstellen, anstatt sie direkt an maven zu senden, da dies möglicherweise auf Speicherfehler zurückzuführen ist. Es wurde für eine Windows-Umgebung vorbereitet, lässt sich jedoch leicht an das Linux-Betriebssystem anpassen:

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();
    }

}

Führen Sie die Datei update_repo_maven.bat aus, nachdem Sie diese Hauptleitung von einer beliebigen IDE aus ausgeführt haben.

Dies ist eine kurze Syntax für neuere Versionen:

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

Es funktioniert, als die JAR von Apache Maven erstellt wurde - der häufigste Fall. Dann enthält es eine pom.xml in einem Unterordner des META-INF-Verzeichnisses, die standardmäßig gelesen wird.

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

Schauen Sie sich auch ...

<scope>compile</scope>

Maven-Abhängigkeiten . Dies ist die Standardeinstellung, aber ich habe in einigen Fällen festgestellt, dass dieser Bereich auch Maven explizit so einstellt, dass lokale Bibliotheken im lokalen Repository gefunden werden.

Aus irgendeinem Grund, in der Web - Anwendung Ich gebe Wartung, weder Alireza Fattahi Lösung noch Lösung JJ Roman arbeitete richtig. In beiden Fällen ist die Zusammenstellung in Ordnung (es sieht das Glas), aber die Verpackung enthält das Glas nicht im Krieg.

Die einzige Möglichkeit, es zum /src/main/webapp/WEB-INF/lib/Laufen zu bringen, bestand darin, das Glas aufzusetzen und es dann entweder mit der Lösung von Fattahis oder Roman zu kombinieren.

Beachten Sie, dass es NICHT unbedingt eine gute Idee ist, ein lokales Repo zu verwenden. Wenn dieses Projekt mit anderen geteilt wird, haben alle anderen Probleme und Fragen, wenn es nicht funktioniert, und das Glas ist nicht einmal in Ihrem Versionsverwaltungssystem verfügbar!

Obwohl das gemeinsame Repo die beste Antwort ist, ist das Einbetten des Glases besser als ein lokales Repo, wenn Sie dies aus irgendeinem Grund nicht tun können. Nur lokale Repo-Inhalte können viele Probleme verursachen, insbesondere im Laufe der Zeit.

In Ihrem lokalen Repository können Sie Ihr JAR installieren, indem Sie die Befehle eingeben

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

Folgen Sie diesem nützlichen Link , um dasselbe auf der Website von mkyoung zu tun. Sie können auch die Maven-Anleitung überprüfen

Rufen Sie den folgenden Befehl auf, um jar von Drittanbietern zu installieren

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

1. mvn installieren

Sie können den folgenden Code in die Befehlszeile schreiben oder wenn Sie Eclipse Builtin Maven verwenden, klicken Sie mit der rechten Maustaste auf Projekt -> Ausführen als -> Konfigurationen ausführen ... -> Klicken Sie im linken Bereich mit der rechten Maustaste auf Maven Build -> Neue Konfiguration -> Schreiben Sie die Code in Ziele & im Basisverzeichnis: $ {project_loc: NameOfYourProject} -> Ausführen

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

Wo sich jeder bezieht auf:

<Pfad zur Datei>: Der Pfad zur zu ladenden Datei, z. B. -> c: \ kaptcha-2.3.jar

<Gruppen-ID>: Die Gruppe, unter der die Datei registriert werden soll, z. B. -> com.google.code

<Artefakt-ID>: Der Artefaktname für die Datei, z. B. -> kaptcha

<Version>: Die Version der Datei, zB -> 2.3

<Packaging>: Das Packen der Datei, zB -> jar

2.Nach der Installation wird jar in pom.xml deklariert.

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

Schritt 1: Konfigurieren Sie das maven-install-pluginmit dem Ziel install-filein Ihrempom.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>

fileStellen Sie sicher, dass Sie den Pfad basierend auf Ihrem tatsächlichen Dateipfad bearbeiten (empfohlen wird, diese externen Nicht-Maven-Jars beispielsweise in einem Ordner zu platzieren libund diesen libOrdner in Ihrem Projekt zu platzieren, um den projektspezifischen relativen Pfad zu verwenden und das Hinzufügen eines Systems zu vermeiden spezifischer absoluter Pfad.

Wenn Sie mehrere externe Gläser haben, wiederholen Sie dies einfach <execution>für andere Gläser innerhalb desselben maven-install-plugin.

Schritt 2: Nachdem Sie das maven-install-pluginwie oben in Ihrer pom.xmlDatei gezeigt konfiguriert haben , müssen Sie diese Gläser pom.xmlwie gewohnt in Ihrem verwenden :

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

Beachten Sie, dass maven-install-pluginnur Ihre externen Jars in Ihr lokales .m2Maven-Repository kopiert werden. Das ist es. Diese Gläser werden nicht automatisch als Maven-Abhängigkeiten zu Ihrem Projekt hinzugefügt.

Es ist ein kleiner Punkt, aber manchmal leicht zu übersehen.

Ich hatte den gleichen Fehler für eine Reihe von Abhängigkeiten in meiner pom.xml. Es stellte sich heraus, dass die Versionen der Abhängigkeiten nicht in der pom.xml angegeben und im übergeordneten Repository erwähnt wurden. Aus irgendeinem Grund wurden die Versionsdetails nicht mit diesem Repo synchronisiert. Daher habe ich die Versionen manuell mit dem Tag eingegeben und es hat wie ein Zauber funktioniert. Es wird ein wenig Zeit benötigt, um die Versionen im übergeordneten Element nachzuschlagen und hier anzugeben. Dies kann jedoch nur für die Gläser durchgeführt werden, die den Artefaktfehler anzeigen, und es funktioniert. Hoffe das hilft jemandem.

In Apache Maven 3.5.4 musste ich ein doppeltes Anführungszeichen hinzufügen. Ohne doppeltes Zitat hat es bei mir nicht funktioniert.

Beispiel: mvn install: install-file "-Dfile = Speicherort der JAR-Datei" "-DgroupId = Gruppen-ID" "-DartifactId = Artefakt-ID" "-Dversion = Version" "-Dpackaging = Pakettyp"

1. Erstellen Sie ein lokales Maven-Repository-Verzeichnis. Ihr Projektstamm sollte zunächst ungefähr so ​​aussehen:

yourproject
+- pom.xml
+- src

2. Fügen Sie ein Standard-Maven-Repository-Verzeichnis namens repo für die Gruppe com.example und Version 1.0 hinzu:

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

3. Bereitstellen des Artefakts Im Repo kann Maven das Artefakt mithilfe des Ziels mvn deploy: deploy-file für Sie bereitstellen:

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

4. Installieren Sie die POM-Datei, die Ihrem JAR entspricht, damit Ihr Projekt das JAR während des Maven-Builds aus dem lokalen Repo finden kann:

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

5. füge repo in deine pom datei ein:

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

6. füge die Abhängigkeit in deinem Pom hinzu:

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

DIESE ANTWORT IST NUR FÜR ECLIPSE-BENUTZER:

Wenn Sie Eclipse verwenden, platzieren Sie das JAR in lib /, klicken Sie mit der rechten Maustaste auf den JAR-Namen und klicken Sie auf "Zum Erstellungspfad hinzufügen". Eclipse erstellt eine "referenzierte Bibliothek" und platziert das Glas für Sie

Es hat den Import des Glases sofort im Programm für mich gelöst