Maven2 macht mich während der Experimentier- / schnellen und schmutzigen Modellierungsphase der Entwicklung verrückt.

Ich habe eine pom.xmlDatei, die die Abhängigkeiten für das Web-App-Framework definiert, das ich verwenden möchte, und ich kann schnell Starterprojekte aus dieser Datei generieren. Manchmal möchte ich jedoch eine Verknüpfung zu einer Drittanbieter-Bibliothek herstellen, für die noch keine pom.xmlDatei definiert ist. Anstatt die pom.xmlDatei für die Drittanbieter-Bibliothek von Hand zu erstellen und zu installieren und die Abhängigkeit zu meiner hinzuzufügen pom.xml, möchte ich nur um Maven zu sagen: "Fügen Sie zusätzlich zu meinen definierten Abhängigkeiten alle Gläser hinzu, die sich ebenfalls befinden /lib."

Es scheint so, als ob dies einfach sein sollte, aber wenn es so ist, fehlt mir etwas.

Hinweise dazu sind sehr willkommen. Kurz gesagt, wenn es eine einfache Möglichkeit gibt, maven auf ein /libVerzeichnis zu verweisen und einfach ein pom.xmlmit allen beiliegenden Gläsern zu erstellen , die einer einzigen Abhängigkeit zugeordnet sind, die ich dann auf einen Schlag benennen / installieren und verknüpfen könnte, würde dies ebenfalls ausreichen.

Probleme populärer Ansätze

Die meisten Antworten, die Sie im Internet finden, empfehlen Ihnen, entweder die Abhängigkeit in Ihrem lokalen Repository zu installieren oder einen "System" -Bereich im anzugeben pomund die Abhängigkeit mit der Quelle Ihres Projekts zu verteilen. Beide Lösungen sind jedoch fehlerhaft.

Warum Sie den Ansatz "Auf lokalem Repo installieren" nicht anwenden sollten

Wenn Sie eine Abhängigkeit in Ihrem lokalen Repository installieren, bleibt diese dort. Ihr Distributionsartefakt funktioniert einwandfrei, solange es Zugriff auf dieses Repository hat. Das Problem ist, dass sich dieses Repository in den meisten Fällen auf Ihrem lokalen Computer befindet. Daher gibt es keine Möglichkeit, diese Abhängigkeit von einem anderen Computer aufzulösen. Es ist keine Möglichkeit, Ihr Artefakt von einer bestimmten Maschine abhängig zu machen. Andernfalls muss diese Abhängigkeit lokal auf jedem Computer installiert werden, der mit diesem Projekt arbeitet, was nicht besser ist.

Warum Sie den "System Scope" -Ansatz nicht anwenden sollten

Die Jars, auf die Sie beim "System Scope" -Ansatz angewiesen sind, werden weder in einem Repository installiert noch an Ihre Zielpakete angehängt. Aus diesem Grund kann Ihr Distributionspaket diese Abhängigkeit bei Verwendung nicht auflösen. Ich glaube, das war der Grund, warum die Nutzung des Systemumfangs sogar veraltet war. Auf jeden Fall möchten Sie sich nicht auf eine veraltete Funktion verlassen.

Die statische In-Project-Repository-Lösung

Nachdem Sie dies in Ihre pom:

<repository>
    <id>repo</id>
    <releases>
        <enabled>true</enabled>
        <checksumPolicy>ignore</checksumPolicy>
    </releases>
    <snapshots>
        <enabled>false</enabled>
    </snapshots>
    <url>file://${project.basedir}/repo</url>
</repository>

Für jedes Artefakt mit einer Gruppen-ID des Formulars nimmt x.y.zMaven bei der Suche nach Artefakten den folgenden Speicherort in Ihrem Projektverzeichnis auf:

repo/
| - x/
|   | - y/
|   |   | - z/
|   |   |   | - ${artifactId}/
|   |   |   |   | - ${version}/
|   |   |   |   |   | - ${artifactId}-${version}.jar

Um mehr darüber zu erfahren, können Sie diesen Blog-Beitrag lesen .

Verwenden Sie Maven, um das Projekt-Repo zu installieren

Anstatt diese Struktur von Hand zu erstellen, empfehle ich, ein Maven-Plugin zu verwenden, um Ihre Gläser als Artefakte zu installieren. Um ein Artefakt in einem projektinternen Repository unter repoOrdner zu installieren, führen Sie Folgendes aus:

mvn install:install-file -DlocalRepositoryPath=repo -DcreateChecksum=true -Dpackaging=jar -Dfile=[your-jar] -DgroupId=[...] -DartifactId=[...] -Dversion=[...]

Wenn Sie diesen Ansatz wählen, können Sie die Repository-Deklaration vereinfachen in pom:

<repository>
    <id>repo</id>
    <url>file://${project.basedir}/repo</url>
</repository>

Ein Hilfsskript

Da das Ausführen des Installationsbefehls für jede Bibliothek etwas ärgerlich und definitiv fehleranfällig ist, habe ich ein Dienstprogramm-Skript erstellt, das automatisch alle Jars aus einem libOrdner in ein Projekt-Repository installiert und gleichzeitig alle Metadaten (groupId, artefaktId usw.) von automatisch auflöst Namen von Dateien. Das Skript druckt auch die XML-Abhängigkeiten aus, die Sie kopieren und in Ihre einfügen können pom.

Fügen Sie die Abhängigkeiten in Ihr Zielpaket ein

Wenn Sie Ihr projektinternes Repository erstellt haben, haben Sie ein Problem beim Verteilen der Abhängigkeiten des Projekts mit seiner Quelle gelöst. Seitdem hängt das Zielartefakt Ihres Projekts jedoch von nicht veröffentlichten Jars ab es zu einem Repository wird es unlösbare Abhängigkeiten haben.

Um dieses Problem zu lösen, schlage ich vor, diese Abhängigkeiten in Ihr Zielpaket aufzunehmen. Dies können Sie entweder mit dem Assembly Plugin oder besser mit dem OneJar Plugin tun . Die offizielle Dokumentation zu OneJar ist leicht zu verstehen.

Nur zum Wegwerfen von Code

Legen Sie scope == system fest und erstellen Sie einfach eine groupId, eine Artefakt-ID und eine Version

<dependency>
    <groupId>org.swinglabs</groupId>
    <artifactId>swingx</artifactId>
    <version>0.9.2</version>
    <scope>system</scope>
    <systemPath>${project.basedir}/lib/swingx-0.9.3.jar</systemPath>
</dependency>

Hinweis: Systemabhängigkeiten werden nicht in das resultierende jar / war kopiert
(siehe So schließen Sie Systemabhängigkeiten in War ein, die mit maven erstellt wurden ).

Sie können ein lokales Repository für Ihr Projekt erstellen

Zum Beispiel, wenn Sie einen libsOrdner in der Projektstruktur haben

• Im libsOrdner sollten Sie eine Verzeichnisstruktur erstellen wie:/groupId/artifactId/version/artifactId-version.jar

• In Ihrer pom.xml sollten Sie das Repository registrieren

  <repository>
      <id>ProjectRepo</id>
      <name>ProjectRepo</name>
      <url>file://${project.basedir}/libs</url>
  </repository>
  

• und fügen Sie die Abhängigkeit wie gewohnt hinzu

  <dependency>
      <groupId>groupId</groupId>
      <artifactId>artifactId</artifactId>
      <version>version</version>
  </dependency>
  

Das ist alles.

Ausführliche Informationen: Hinzufügen externer Bibliotheken in Maven

Hinweis: Bei Verwendung des Systembereichs ( wie auf dieser Seite erwähnt ) benötigt Maven absolute Pfade.

Wenn sich Ihre Jars im Stammverzeichnis Ihres Projekts befinden, sollten Sie Ihren systemPath-Werten $ {basedir} voranstellen.

Dies ist, was ich getan habe, es funktioniert auch um das Paketproblem und es funktioniert mit ausgechecktem Code.

Ich habe in meinem Fall einen neuen Ordner im Projekt erstellt repo, kann ihn aber gerne verwendensrc/repo

In meinem POM hatte ich eine Abhängigkeit, die sich in keinem öffentlichen Maven-Repository befindet

<dependency>
    <groupId>com.dovetail</groupId>
    <artifactId>zoslog4j</artifactId>
    <version>1.0.1</version>
    <scope>runtime</scope>
</dependency>

Ich habe dann die folgenden Verzeichnisse erstellt repo/com/dovetail/zoslog4j/1.0.1und die JAR-Datei in diesen Ordner kopiert.

Ich habe die folgende POM-Datei erstellt, um die heruntergeladene Datei darzustellen (dieser Schritt ist optional, entfernt jedoch eine WARNUNG) und hilft dem nächsten, herauszufinden, woher ich die Datei habe.

<?xml version="1.0" encoding="UTF-8" ?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.dovetail</groupId>
    <artifactId>zoslog4j</artifactId>
    <packaging>jar</packaging>
    <version>1.0.1</version>
    <name>z/OS Log4J Appenders</name>
    <url>http://dovetail.com/downloads/misc/index.html</url>
    <description>Apache Log4j Appender for z/OS Logstreams, files, etc.</description>
</project>

Zwei optionale Dateien, die ich erstelle, sind die SHA1-Prüfsummen für das POM und die JAR, um die fehlenden Prüfsummenwarnungen zu entfernen.

shasum -b < repo/com/dovetail/zoslog4j/1.0.1/zoslog4j-1.0.1.jar \
          > repo/com/dovetail/zoslog4j/1.0.1/zoslog4j-1.0.1.jar.sha1

shasum -b < repo/com/dovetail/zoslog4j/1.0.1/zoslog4j-1.0.1.pom \
          > repo/com/dovetail/zoslog4j/1.0.1/zoslog4j-1.0.1.pom.sha1

Schließlich füge ich meiner pom.xml das folgende Fragment hinzu, mit dem ich auf das lokale Repository verweisen kann

<repositories>
    <repository>
        <id>project</id>
        <url>file:///${basedir}/repo</url>
    </repository>
</repositories>

Sie sollten wirklich ein Framework über ein Repository einrichten und Ihre Abhängigkeiten im Voraus identifizieren. Die Verwendung des Systembereichs ist ein häufiger Fehler, den Benutzer verwenden, weil sie sich "nicht um das Abhängigkeitsmanagement kümmern". Das Problem ist, dass Sie dabei einen perversen Maven-Build erhalten, der Maven in einem normalen Zustand nicht anzeigt. Sie wäre besser dran , wie ein Ansatz folgt dies .

So fügen wir ein lokales Glas hinzu oder installieren es

    <dependency>
        <groupId>org.example</groupId>
        <artifactId>iamajar</artifactId>
        <version>1.0</version>
        <scope>system</scope>
        <systemPath>${project.basedir}/lib/iamajar.jar</systemPath>
    </dependency>

Ich gab einige Standard-GroupId und ArtefaktId, weil sie obligatorisch sind :)

Das Maven-Installations-Plugin verwendet die Befehlszeile, um ein JAR im lokalen Repository zu installieren. POM ist optional, Sie müssen jedoch die GroupId, ArtifactId, Version und Packaging (alle POM-Elemente) angeben.

Die Verwendung <scope>system</scope>ist aus Gründen, die von anderen erklärt wurden, eine schreckliche Idee. Die manuelle Installation der Datei in Ihrem lokalen Repository macht den Build nicht reproduzierbar, und die Verwendung <url>file://${project.basedir}/repo</url>ist auch keine gute Idee, da (1) dies möglicherweise keine wohlgeformte fileURL ist (z. B. wenn das Projekt wird in einem Verzeichnis mit ungewöhnlichen Zeichen ausgecheckt), (2) das Ergebnis ist unbrauchbar, wenn der POM dieses Projekts als Abhängigkeit vom Projekt eines anderen verwendet wird.

Angenommen, Sie möchten das Artefakt nicht in ein öffentliches Repository hochladen, erledigt Simeons Vorschlag für ein Hilfsmodul die Aufgabe. Aber jetzt gibt es einen einfacheren Weg…

Die Empfehlung

Verwenden Sie das Non-Maven-Jar-Maven-Plugin . Tut genau das, wonach Sie gefragt haben, ohne die Nachteile der anderen Ansätze.

Ich habe einen anderen Weg gefunden, dies zu sehen, siehe hier aus einem Heroku-Beitrag

Zusammenfassend (Entschuldigung für das Kopieren und Einfügen)

• Erstellen Sie ein repoVerzeichnis unter Ihrem Stammordner:

dein Projekt
+ - pom.xml
+ - src
+ - Repo

• Führen Sie dies aus, um das JAR in Ihrem lokalen Repo-Verzeichnis zu installieren

mvn deploy: deploy-file -Durl = file: /// path / to / yourproject / repo / -Dfile = mylib-1.0.jar -DgroupId = com.example -DartifactId = mylib -Dpackaging = jar -Dversion = 1.0

• Fügen Sie dies hinzu pom.xml:

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


<dependency>
    <groupId>com.example</groupId>
    <artifactId>mylib</artifactId>
    <version>1.0</version>  
</dependency>

Nachdem sie wirklich lange mit CloudBees-Leuten über die ordnungsgemäße Verpackung solcher JARs gesprochen hatten, machten sie einen interessanten guten Vorschlag für eine Lösung:

Erstellung eines gefälschten Maven-Projekts, das eine bereits vorhandene JAR als primäres Artefakt anfügt und auf die zugehörige POM-Installation: Installation der Installationsdatei stößt. Hier ist ein Beispiel für eine solche Verwandtschaft von POM:

 <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-install-plugin</artifactId>
            <version>2.3.1</version>
            <executions>
                <execution>
                    <id>image-util-id</id>
                    <phase>install</phase>
                    <goals>
                        <goal>install-file</goal>
                    </goals>
                    <configuration>
                        <file>${basedir}/file-you-want-to-include.jar</file>
                        <groupId>${project.groupId}</groupId>
                        <artifactId>${project.artifactId}</artifactId>
                        <version>${project.version}</version>
                        <packaging>jar</packaging>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Um dies umzusetzen, sollte die bestehende Projektstruktur geändert werden. Zunächst sollten Sie bedenken, dass für jede solche Art von JAR ein anderes gefälschtes Maven-Projekt (Modul) erstellt werden sollte. Außerdem sollte ein übergeordnetes Maven-Projekt erstellt werden, das alle Untermodule enthält: alle JAR-Wrapper und das vorhandene Hauptprojekt. Die Struktur könnte sein:

Stammprojekt (dies enthält die übergeordnete POM-Datei enthält alle Untermodule mit Modul- XML-Element) (POM-Verpackung)

JAR 1 Wrapper Maven Child Project (POM-Verpackung)

JAR 2 Wrapper Maven Child Project (POM-Verpackung)

Haupt bestehendes Maven-Kinderprojekt (WAR, JAR, EAR .... Verpackung)

Wenn ein übergeordnetes Element ausgeführt wird, das über mvn: install oder mvn: package ausgeführt wird, werden Submodule ausgeführt. Dies könnte hier als Minus angesehen werden, da die Projektstruktur geändert werden sollte, aber am Ende eine nicht statische Lösung bietet

Was mir am einfachsten erscheint, ist einfach Ihr Maven-Compiler-Plugin so zu konfigurieren, dass es Ihre benutzerdefinierten Jars enthält. In diesem Beispiel werden alle JAR-Dateien in ein lib-Verzeichnis geladen.

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <includes>
                    <include>lib/*.jar</include>
                </includes>
            </configuration>
        </plugin>

Das Problem dabei systemPathist, dass die Gläser der Abhängigkeiten nicht als transitive Abhängigkeiten entlang Ihrer Artefakte verteilt werden. Versuchen Sie, was ich hier gepostet habe: Ist es am besten, Ihre Projekt-JAR-Dateien zu mavenisieren oder in WEB-INF / lib abzulegen?

Deklarieren Sie dann wie gewohnt Abhängigkeiten.

Und bitte lesen Sie die Fußzeile.

Eine seltsame Lösung, die ich gefunden habe:

mit Eclipse

• Erstellen Sie ein einfaches (nicht-maven) Java-Projekt
• Fügen Sie eine Hauptklasse hinzu
• Fügen Sie alle Gläser zum Klassenpfad hinzu
• Export Runnable JAR (es ist wichtig, weil es hier keine andere Möglichkeit gibt)
• Wählen Sie Erforderliche Bibliotheken in generierte JAR extrahieren
• Entscheiden Sie die Lizenzprobleme
• tadammm ... installiere das generierte jar auf deinem m2repo
• Fügen Sie diese einzelne Abhängigkeit Ihren anderen Projekten hinzu.

Prost, Balint

Wenn Sie eine schnelle und schmutzige Lösung wünschen, können Sie Folgendes tun (obwohl ich dies nur für Testprojekte empfehle, wird sich maven ausführlich darüber beschweren, dass dies nicht richtig ist).

Fügen Sie für jede benötigte JAR-Datei einen Abhängigkeitseintrag hinzu, vorzugsweise mit einem Perl-Skript oder ähnlichem, und kopieren Sie diesen in Ihre POM-Datei.

#! /usr/bin/perl

foreach my $n (@ARGV) {

    $n=~s@.*/@@;

    print "<dependency>
    <groupId>local.dummy</groupId>
    <artifactId>$n</artifactId>
    <version>0.0.1</version>
    <scope>system</scope>
    <systemPath>\${project.basedir}/lib/$n</systemPath>
</dependency>
";

Eine schnelle und schmutzige Batch-Lösung (basierend auf Alex 'Antwort):

libs.bat

@ECHO OFF
FOR %%I IN (*.jar) DO (
echo ^<dependency^>
echo ^<groupId^>local.dummy^</groupId^>
echo ^<artifactId^>%%I^</artifactId^>
echo ^<version^>0.0.1^</version^>
echo ^<scope^>system^</scope^>
echo ^<systemPath^>${project.basedir}/lib/%%I^</systemPath^>
echo ^</dependency^>
)

Führen Sie es folgendermaßen aus : libs.bat > libs.txt. Öffnen Sie dann libs.txtden Inhalt und kopieren Sie ihn als Abhängigkeiten.

In meinem Fall brauchte ich nur die Bibliotheken, um meinen Code zu kompilieren, und diese Lösung war die beste für diesen Zweck.

Auch wenn es nicht genau zu Ihrem Problem passt, werde ich dies hier fallen lassen. Meine Anforderungen waren:

1. Jars, die nicht in einem Online-Maven-Repository gefunden werden können, sollten sich im SVN befinden.
2. Wenn ein Entwickler eine andere Bibliothek hinzufügt, sollten sich die anderen Entwickler nicht darum kümmern, sie manuell zu installieren.
3. Die IDE (in meinem Fall NetBeans) sollte in der Lage sein, die Quellen und Javadocs zu finden, um die automatische Vervollständigung und Hilfe bereitzustellen.

Lassen Sie uns zuerst über (3) sprechen: Nur die Gläser in einem Ordner zu haben und sie irgendwie in das endgültige Glas zu verschmelzen, funktioniert hier nicht, da die IDE dies nicht versteht. Dies bedeutet, dass alle Bibliotheken ordnungsgemäß installiert werden müssen. Ich möchte jedoch nicht, dass jeder es mit "mvn install-file" installiert.

In meinem Projekt brauchte ich Metawidget. Auf geht's:

1. Erstellen Sie ein neues Maven-Projekt (nennen Sie es "shared-libs" oder ähnliches).
2. Laden Sie metawidget herunter und extrahieren Sie die Zip-Datei in src / main / lib.
3. Der Ordner doc / api enthält die Javadocs. Erstellen Sie eine Zip-Datei des Inhalts (doc / api / api.zip).
4. Ändern Sie den Pom wie folgt
5. Erstellen Sie das Projekt und die Bibliothek wird installiert.
6. Fügen Sie die Bibliothek als Abhängigkeit zu Ihrem Projekt hinzu, oder fügen Sie (wenn Sie die Abhängigkeit im Shared-Libs-Projekt hinzugefügt haben) Shared-Libs als Abhängigkeit hinzu, um alle Bibliotheken gleichzeitig abzurufen.

Jedes Mal, wenn Sie eine neue Bibliothek haben, fügen Sie einfach eine neue Ausführung hinzu und fordern Sie alle auf, das Projekt erneut zu erstellen (Sie können diesen Prozess mit Projekthierarchien verbessern).

Verwenden Sie das maven-install-plugin, um das JAR eines Drittanbieters zu installieren, das sich nicht im Maven-Repository befindet.

Unten sind Schritte:

1. Laden Sie die JAR-Datei manuell von der Quelle (Website) herunter.
2. Erstellen Sie einen Ordner und legen Sie Ihre JAR-Datei darin ab
3. Führen Sie den folgenden Befehl aus, um das JAR eines Drittanbieters in Ihrem lokalen Maven-Repository zu installieren

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

Unten ist das Beispiel, das ich für simonsite log4j verwendet habe

mvn install: Installationsdatei -Dfile = / Users / athanka / git / MyProject / repo / log4j-rollender-appender.jar -DgroupId = uk.org.simonsite -DartifactId = log4j-rollender-appender -Dversion = 20150607-2059 - Verpackung = Glas

4. Fügen Sie in die pom.xml die Abhängigkeit wie folgt ein

     <dependency> 
           <groupId>uk.org.simonsite</groupId>
           <artifactId>log4j-rolling-appender</artifactId>
           <version>20150607-2059</version> 
     </dependency>

5. Führen Sie den Befehl mvn clean install aus, um Ihre Verpackung zu erstellen

Unten ist der Referenzlink:

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

Für diejenigen, die hier keine gute Antwort gefunden haben, ist dies das, was wir tun, um ein Glas mit allen notwendigen Abhängigkeiten zu erhalten. In dieser Antwort ( https://stackoverflow.com/a/7623805/1084306 ) wird die Verwendung des Maven Assembly-Plugins erwähnt, die Antwort enthält jedoch kein Beispiel. Und wenn Sie nicht bis zum Ende der Antwort lesen (es ist ziemlich lang), können Sie es verpassen. Wenn Sie das Folgende zu Ihrer pom.xml hinzufügen, wird dies generierttarget/${PROJECT_NAME}-${VERSION}-jar-with-dependencies.jar

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.4.1</version>
            <configuration>
                <!-- get all project dependencies -->
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <!-- MainClass in mainfest make a executable jar -->
                <archive>
                  <manifest>
                    <mainClass>my.package.mainclass</mainClass>
                  </manifest>
                </archive>

            </configuration>
            <executions>
              <execution>
                <id>make-assembly</id>
                <!-- bind to the packaging phase -->
                <phase>package</phase> 
                <goals>
                    <goal>single</goal>
                </goals>
              </execution>
            </executions>
        </plugin>

Ich habe in einem Kommentar zur Antwort von @alex lehmann auf einen Python-Code angespielt, also poste ich ihn hier.

def AddJars(jarList):
  s1 = ''
  for elem in jarList:
   s1+= """
     <dependency>
        <groupId>local.dummy</groupId>
        <artifactId>%s</artifactId>
        <version>0.0.1</version>
        <scope>system</scope>
        <systemPath>${project.basedir}/manual_jars/%s</systemPath>
     </dependency>\n"""%(elem, elem)
  return s1

Dies beantwortet nicht, wie Sie sie zu Ihrem POM hinzufügen können, und ist möglicherweise ein Kinderspiel, würde aber nur das lib-Verzeichnis zu Ihrer Klassenpfadarbeit hinzufügen? Ich weiß, dass ich das tue, wenn ich ein externes Glas brauche, das ich meinen Maven-Repos nicht hinzufügen möchte.

Hoffe das hilft.

Was in unserem Projekt funktioniert, ist das, was Archimedes Trajano geschrieben hat, aber wir hatten in unserer .m2 / settings.xml so etwas:

 <mirror>
  <id>nexus</id>
  <mirrorOf>*</mirrorOf>
  <url>http://url_to_our_repository</url>
 </mirror>

und das * sollte auf zentral geändert werden. Wenn seine Antwort für Sie nicht funktioniert, sollten Sie Ihre settings.xml überprüfen

Ich wollte nur eine schnelle und schmutzige Problemumgehung ... Ich konnte das Skript nicht von Nikita Volkov ausführen: Syntaxfehler + Es erfordert ein striktes Format für die JAR-Namen.

Ich habe dieses Perl-Skript erstellt, das mit jedem Format für die JAR-Dateinamen funktioniert und die Abhängigkeiten in einer XML-Datei generiert, damit es direkt in einen POM eingefügt werden kann.

Wenn Sie es verwenden möchten, stellen Sie sicher , dass Sie verstehen , was das Skript tut, müssen Sie die Änderungen libOrdner und den Wert für die groupIdoder artifactId...

#!/usr/bin/perl

use strict;
use warnings;

open(my $fh, '>', 'dependencies.xml') or die "Could not open file 'dependencies.xml' $!";
foreach my $file (glob("lib/*.jar")) {
    print "$file\n";
    my $groupId = "my.mess";
    my $artifactId = "";
    my $version = "0.1-SNAPSHOT";
    if ($file =~ /\/([^\/]*?)(-([0-9v\._]*))?\.jar$/) {
        $artifactId = $1;
        if (defined($3)) {
            $version = $3;
        }
        `mvn install:install-file -Dfile=$file -DgroupId=$groupId -DartifactId=$artifactId -Dversion=$version -Dpackaging=jar`;
        print $fh "<dependency>\n\t<groupId>$groupId</groupId>\n\t<artifactId>$artifactId</artifactId>\n\t<version>$version</version>\n</dependency>\n";
        print " => $groupId:$artifactId:$version\n";
    } else {
        print "##### BEUH...\n";
    }
}
close $fh;

Die Lösung für den Ansatz scope = 'system' in Java:

public static void main(String[] args) {
        String filepath = "/Users/Downloads/lib/";
        try (Stream<Path> walk = Files.walk(Paths.get(filepath))) {

        List<String> result = walk.filter(Files::isRegularFile)
                .map(x -> x.toString()).collect(Collectors.toList());

                String indentation = "    ";
                for (String s : result) {
                    System.out.println(indentation + indentation + "<dependency>");
                    System.out.println(indentation + indentation + indentation + "<groupId>"
                            + s.replace(filepath, "").replace(".jar", "")
                            + "</groupId>");
                    System.out.println(indentation + indentation + indentation + "<artifactId>"
                            + s.replace(filepath, "").replace(".jar", "")
                            + "</artifactId>");
                    System.out.println(indentation + indentation + indentation + "<version>"
                            + s.replace(filepath, "").replace(".jar", "")
                            + "</version>");
                    System.out.println(indentation + indentation + indentation + "<scope>system</scope>");
                    System.out.println(indentation + indentation + indentation + "<systemPath>" + s + "</systemPath>");
                    System.out.println(indentation + indentation + "</dependency>");
                }

    } catch (IOException e) {
        e.printStackTrace();
    }
}