java - pom - maven repository server




Wie füge ich lokale JAR-Dateien zu einem Maven-Projekt hinzu? (16)

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


Aus irgendeinem Grund, in der Web-Anwendung, die ich Wartung gebe, funktionierte weder Alireza Fattahis Lösung noch JJ Romans Lösung richtig. In beiden Fällen ist die Kompilierung in Ordnung (sie sieht das Glas), aber die Verpackung schließt das Glas nicht in den Krieg ein.

Die einzige Möglichkeit, es zum /src/main/webapp/WEB-INF/lib/ zu bringen, bestand darin, das Jar auf /src/main/webapp/WEB-INF/lib/ und es 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, werden alle anderen Probleme und Fragen haben, wenn es nicht funktioniert, und das Jar wird auch in Ihrem Quellcode-Kontrollsystem nicht verfügbar sein!

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


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

Sehen Sie here für Details, wie es geht. Sehen Sie sich den Abschnitt " Hochladen in ein Remote-Repository " an.


Dies ist eine kurze Syntax für neuere Versionen:

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

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

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


Ein weiterer interessanter Fall ist, wenn Sie in Ihrem Projekt private Maven Gläser haben wollen. Vielleicht möchten Sie die Fähigkeiten von Maven behalten, um transitive Abhängigkeiten aufzulösen. Die Lösung ist ziemlich einfach.

  1. Erstellen Sie eine Ordner- Bibliothek 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 werden den folgenden Ordner sehen

com / mycompany / meinprojekt / 1.2.3

Kopiere alles in deinen libs-Ordner (wieder inklusive der Ordner unter .m2 / repository ) und du bist fertig.


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

Eine weitere nette Möglichkeit, die ich kürzlich gesehen habe, ist die Einbindung des Maven Install Plugins in Ihren Build-Lebenszyklus: Sie deklarieren im POM, um die Dateien im lokalen Repository zu installieren. Es ist ein kleiner aber kleiner Overhead und kein manueller Schritt involviert.

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


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

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

Beispielsweise:

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

Dann füge es dem POM wie folgt hinzu:


Ich hätte gerne eine solche Lösung - benutze maven-install-plugin in der pom-Datei:

        <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 mvn initialize ausführen und jar wird im lokalen maven repo installiert. Jetzt ist dieses Jar während irgendeines Mavenschritts auf diesem Rechner verfügbar (vergiss nicht, diese Abhängigkeit wie jede andere maven-Abhängigkeit in pom mit dem <dependency></dependency> -Tag zu berücksichtigen). Es ist auch möglich, jar install nicht mit initialize , sondern mit jedem anderen Schritt zu verknüpfen.


Ich hatte den gleichen Fehler für eine Reihe von Abhängigkeiten in meiner pom.xml stellt sich heraus, dass die Versionen der Abhängigkeiten nicht in der pom.xml angegeben wurde und im übergeordneten Repository erwähnt wurde. Aus irgendeinem Grund wurden die Versionsdetails nicht mit diesem Repo synchronisiert. Daher habe ich die Versionen mit dem Tag manuell eingegeben und es funktionierte wie ein Zauber. Wenig Zeit benötigt, um die Versionen im Elternteil nachzuschlagen und hier anzugeben. Aber das kann nur für die Gläser gemacht werden, die den Artefatzfehler zeigen und es funktioniert. Hoffe, das hilft jemandem.


Ich möchte einen Code teilen, wo Sie einen Ordner voller Gläser hochladen können. Es ist nützlich, wenn ein Anbieter kein öffentliches Repository hat und Sie viele Bibliotheken manuell hinzufügen müssen. Ich habe beschlossen, eine .bat statt Anruf direkt zu maven zu bauen, weil es möglicherweise zu wenig Speicherfehler gibt. Es wurde für eine Windows-Umgebung vorbereitet, ist aber leicht an Linux anzupassen:

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 diese main aus jeder IDE aus und führen Sie die Datei update_repo_maven.bat aus.


Installieren Sie das 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

Where: <path-to-file>  the path to the file to load
   <group-id>      the group that the file should be registered under
   <artifact-id>   the artifact name for the file
   <version>       the version of the file
   <packaging>     the packaging of the file e.g. jar

Reference



Sehen Sie sich auch an ...

<scope>compile</scope>

Maven-Abhängigkeiten . Dies ist die Standardeinstellung, aber ich habe in einigen Fällen explizit festgestellt, dass auch Maven lokale Bibliotheken im lokalen Repository findet.


Sie können lokale Abhängigkeiten direkt hinzufügen (wie in build maven project mit proprietary Bibliotheken enthalten ):

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

Zunächst möchte ich diese Antwort dem anonymen -Benutzer anerkennen - ich bin mir ziemlich sicher, dass ich schon ähnliche Antworten hier gesehen habe - aber jetzt kann ich sie nicht finden.

Die beste Option für lokale JAR-Dateien als Abhängigkeit ist das Erstellen eines lokalen Maven-Repositorys. Ein solches Repo ist nichts anderes als eine richtige Verzeichnisstruktur mit Pom-Dateien.

In meinem Beispiel: Ich habe Masterprojekt auf ${master_project} location und Subprojekt1 ist auf ${master_project}/${subproject1}

dann erstelle ich mvn repository in: ${master_project}/local-maven-repo

In der Pom-Datei im Subprojekt ${master_project}/${subproject1}/pom.xml Repository ${master_project}/${subproject1}/pom.xml angegeben werden, das den Dateipfad als URL-Parameter annehmen würde:

<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. Zum Beispiel, sobald das gewünschte Glas in maven central verfügbar ist, müssen Sie es nur aus Ihrem lokalen Repo löschen und es wird aus dem Standard-Repo gezogen.

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

Die letzte Sache ist es, 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

Onece-JAR-Datei wird installiert, so dass MVN-Repo an Code-Repository übergeben werden kann und die gesamte Einrichtung systemunabhängig ist. ( Arbeitsbeispiel in GitHub )

Ich stimme zu, dass die Einbindung von JARs in Quellcode-Repos keine gute Praxis ist, aber im echten Leben ist eine schnelle und schmutzige Lösung manchmal besser als eine vollständige Nexus-Repo, um ein Jar zu hosten, das Sie nicht veröffentlichen können.


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




mvn-repo