Maven2 gelişimin hızlı / kirli mock-up aşamasında beni deli ediyor.

pom.xmlKullanmak istediğim web uygulaması çerçevesinin bağımlılıklarını tanımlayan bir dosyam var ve hızlı bir şekilde bu dosyadan başlangıç ​​projeleri oluşturabiliyorum. Ancak, bazen önceden pom.xmltanımlanmış bir dosyaya sahip olmayan bir 3. taraf kütüphanesine bağlantı vermek istiyorum , bu yüzden pom.xml3. taraf lib için dosyayı elle oluşturmak ve yüklemek ve bağımlılığımı eklemek yerine pom.xml, sadece istiyorum Maven'e: "Tanımlanmış bağımlılıklarıma ek olarak, içinde bulunan kavanozları da ekleyin /lib."

Bu basit olmalı gibi görünüyor, ama eğer öyleyse, bir şey eksik.

Bunun nasıl yapılacağına dair işaretçiler büyük beğeni topluyor. Bunun kısaltması, maven'i bir /libdizine işaret etmenin ve kolayca pom.xmlekleyebileceğim tek bir bağımlılığa eşlenen tüm kapalı kavanozlarla kolayca oluşturmanın basit bir yolu varsa, o zaman isimlendirebileceğim / yükleyebileceğim ve bir düşme bağlantısında bağlantı da yeterli olacaktır.

Popüler yaklaşımların sorunları

İnternette bulacağınız cevapların çoğu, yerel deponuza bağımlılığı yüklemenizi veya projenizde bir "sistem" kapsamı belirtmenizi pomve bağımlılığı projenizin kaynağına dağıtmanızı önerir . Ancak bu çözümlerin her ikisi de aslında kusurlu.

"Yerel Repo'ya Yükle" yaklaşımını neden uygulamamalısınız?

Yerel deponuza bir bağımlılık yüklediğinizde orada kalır. Dağıtım yapay nesneniz bu depoya erişimi olduğu sürece başarılı olacaktır. Sorun çoğu durumda bu havuzun yerel makinenizde bulunmasıdır, bu nedenle bu bağımlılığı başka bir makinede çözmenin bir yolu olmayacaktır. Eserinizi açıkça belirli bir makineye bağımlı hale getirmek, işleri halletmenin bir yolu değildir. Aksi takdirde, bu bağımlılığın daha iyi olmayan bu proje ile çalışan her makineye yerel olarak kurulması gerekecektir.

Neden "Sistem Kapsamı" yaklaşımını uygulamamalısınız?

"Sistem Kapsamı" yaklaşımına bağlı olduğunuz kavanozlar herhangi bir depoya kurulmaz veya hedef paketlerinize takılmaz. Bu nedenle dağıtım paketinizin kullanıldığında bu bağımlılığı çözmek için bir yolu yoktur. Sistem kapsamı kullanımının kullanımdan kaldırılmasının sebebi olduğuna inanıyorum. Neyse, kullanımdan kaldırılmış bir özelliğe güvenmek istemiyorsunuz.

Statik proje içi depo çözümü

Bunu içine koyduktan sonra 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>

x.y.zMaven form kimliğine sahip her bir eser için Maven, proje dizininizde, eser arayışında aşağıdaki konumu içerecektir:

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

Bununla ilgili daha ayrıntılı bilgi için bu blog gönderisini okuyabilirsiniz .

Proje deposuna yüklemek için Maven'i kullanın

Bu yapıyı el ile oluşturmak yerine kavanozlarınızı yapay olarak kurmak için bir Maven eklentisi kullanmanızı öneririm. Bu nedenle, repoklasör yürütme altındaki proje içi bir depoya bir yapı yüklemek için :

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

Bu yaklaşımı seçerseniz, depo bildirimini şu şekilde basitleştirebilirsiniz pom:

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

Yardımcı komut dosyası

Her lib için kurulum komutunu çalıştırarak eğilimli hata kesinlikle tür can sıkıcı ve olduğundan, bir oluşturduk yarar komut dosyası otomatik olarak tüm kavanozları yükler lib, bir proje deposuna klasörden otomatik dan (GroupID, artifactId vb) tüm meta çözümlenirken dosya adları. Komut dosyası ayrıca, kopyala yapıştırmanız için xml bağımlılıklarını yazdırır pom.

Hedef paketinize bağımlılıkları ekleyin

Proje içi deponuzu oluşturduğunuzda, projenin bağımlılıklarını kaynağına dağıtma sorununu çözmüş olursunuz, ancak o zamandan beri projenizin hedef yapısı yayınlanmamış kavanozlara bağlı olacaktır, bu nedenle bir depoya çözülemez bağımlılıkları olacaktır.

Bu sorunu aşmak için bu bağımlılıkları hedef paketinize eklemenizi öneririm. Bu, Montaj Eklentisi ile veya OneJar Eklentisi ile daha iyi yapabilirsiniz . OneJar'ın resmi belgeselini kavramak kolaydır.

Sadece atma kodu için

scope == sistemi ayarlayın ve bir groupId, artifactId ve sürüm oluşturun

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

Not: sistem bağımlılıkları sonuçta ortaya çıkan kavanoza / savaşa kopyalanmaz
( bkz.Maven kullanılarak oluşturulan savaşa sistem bağımlılıkları nasıl eklenir )

Projenizde yerel depo oluşturabilirsiniz

Örneğin libs, proje yapısında bir klasörünüz varsa

• Gelen libsklasörün dizin yapısı gibi oluşturmalıdır:/groupId/artifactId/version/artifactId-version.jar

• Pom.xml'nizde depoyu kaydetmelisiniz

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

• ve her zamanki gibi bağımlılık ekleyin

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

Hepsi bu.

Ayrıntılı bilgi için: Maven'e harici kitaplıklar nasıl eklenir

Not: Sistem kapsamını kullanırken ( bu sayfada belirtildiği gibi ), Maven mutlak yollara ihtiyaç duyar.

Kavanozlarınız projenizin kökünün altındaysa, systemPath değerlerinize $ {basedir} öneki eklemek istersiniz.

Ben yaptım bu, aynı zamanda paket sorunu etrafında çalışır ve kullanıma kodu ile çalışır.

Kullandığım durumda projede yeni bir klasör oluşturdum repo, ancak kullanmaktan çekinmeyinsrc/repo

POM'mda herhangi bir kamu maven deposunda olmayan bir bağımlılığım vardı

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

Daha sonra aşağıdaki dizinleri oluşturdum repo/com/dovetail/zoslog4j/1.0.1 ve JAR dosyasını bu klasöre kopyaladım.

İndirilen dosyayı temsil etmek için aşağıdaki POM dosyasını oluşturdum (bu adım isteğe bağlıdır, ancak bir UYARI kaldırır) ve bir sonraki adama dosyanın nereden başlayacağımı bulmasına yardımcı olur.

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

Oluşturduğum iki isteğe bağlı dosya, eksik sağlama toplamı uyarılarını kaldırmak için POM ve JAR için SHA1 sağlama toplamlarıdır.

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

Son olarak pom.xml dosyasına yerel depoya başvurmamı sağlayan aşağıdaki parçayı ekliyorum

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

Gerçekten bir havuz aracılığıyla bir çerçeve kurmanız ve bağımlılıklarınızı önceden tanımlamanız gerekir. Sistem kapsamını kullanmak insanların kullandığı yaygın bir hatadır, çünkü “bağımlılık yönetimini umursamıyorlar”. Sorun şu ki, normal bir durumda maven göstermeyecek sapkın bir maven yapısı ile sonuçlanır. Sen gibi bir yaklaşımdan aşağıdaki daha iyi olurdu bu .

Yerel bir kavanoz bu şekilde ekliyor veya takıyoruz

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

bazı varsayılan groupId ve artifactId verdi çünkü onlar zorunlu :)

Maven kurulum eklentisi , yerel depoya bir kavanoz yüklemek için komut satırı kullanımına sahiptir, POM isteğe bağlıdır, ancak GroupId, ArtifactId, Sürüm ve Paketleme (tüm POM şeylerini) belirtmeniz gerekecektir.

Kullanmak <scope>system</scope>, başkaları tarafından açıklanan nedenlerden dolayı korkunç bir fikirdir, dosyayı yerel deponuza manuel olarak yüklemek, yapıyı yeniden oluşturulamaz hale getirir ve <url>file://${project.basedir}/repo</url>(1) iyi biçimlendirilmemiş bir fileURL olmayabilir (örneğin, proje (2) bu projenin POM'u başka birinin projesine bağımlı olarak kullanılırsa, sonuç kullanılamaz.

Eseri halka açık bir depoya yüklemek istemediğinizi varsayarsak, Simeon'un bir yardımcı modül önerisi işi yapar. Ama şimdi daha kolay bir yol var…

Tavsiye

Kullanım dışı maven-kavanoz-maven-eklentisi . Tam olarak ne istediğini yapar, diğer yaklaşımların dezavantajları yoktur.

Bunu yapmanın başka bir yolunu buldum, buraya bir Heroku gönderisinden bakın

Özetlemek gerekirse (kopyala ve yapıştır için üzgünüm)

• repoKök klasörünüzün altında bir dizin oluşturun :

senin projen
+ - pom.xml
+ - src
+ - repo

• Kavanozu yerel repo dizininize yüklemek için bunu çalıştırın

mvn deploy: deploy-file -Durl = dosya: /// yol / to / projeniz / repo / -Dfile = mylib-1.0.jar -DgroupId = com.example -DartifactId = mylib -Dpackaging = kavanoz -Dversion = 1.0

• Bunu ekleyin 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>

CloudBees'lerle bu tür JAR'ların düzgün bir şekilde paketlenmesi hakkında gerçekten uzun bir tartışma yaptıktan sonra, bir çözüm için ilginç iyi bir teklifte bulundular:

Önceden var olan bir JAR'ı ait olan POM kurulumuna bağlanan sahte bir Maven projesinin oluşturulması: yükleme dosyası yürütme. İşte böyle bir POM kinf örneği:

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

Ancak bunu uygulamak için mevcut proje yapısı değiştirilmelidir. İlk olarak, bu tür her JAR için farklı sahte Maven projesi (modül) oluşturulması gerektiğini unutmayın. Ve tüm alt modülleri içeren bir ana Maven projesi oluşturulmalıdır: tüm JAR paketleyicileri ve mevcut ana proje. Yapı şöyle olabilir:

kök proje (üst POM dosyası modül XML elemanlı tüm alt modülleri içerir ) (POM paketleme)

JAR 1 sarıcı Maven çocuk projesi (POM paketleme)

JAR 2 sarıcı Maven çocuk projesi (POM paketleme)

mevcut ana Maven çocuk projesi (WAR, JAR, EAR .... paketleme)

Ebn mvn: install veya mvn: üzerinden çalıştırıldığında paketleme zorlanır ve alt modüller yürütülür. Bu, eksi olarak düşünülebilir, çünkü proje yapısı değiştirilmelidir, ancak sonunda statik olmayan bir çözüm sunar

Bana en basit görünen şey, maven-derleyici-eklentinizi özel kavanozlarınızı içerecek şekilde yapılandırmanız. Bu örnek, herhangi bir jar dosyasını bir lib dizinine yükleyecektir.

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

Sorun systemPath, bağımlılık kavanozlarının, geçişli bağımlılıklar olarak eserler boyunca dağıtılmamasıdır. Burada gönderdiğim şeyi deneyin: Proje jar dosyalarınızı Mavenize etmek veya WEB-INF / lib'e koymak en iyisi mi?

Sonra bağımlılıkları her zamanki gibi ilan edin.

Ve lütfen altbilgi notunu okuyun.

Tuhaf bir çözüm buldum:

Eclipse kullanma

• basit (maven olmayan) java projesi oluştur
• Ana sınıf ekle
• tüm kavanozları sınıf yoluna ekle
• Runnable JAR'ı dışa aktar (önemli, çünkü burada bunu yapmanın başka yolu yok)
• Oluşturulan JAR'a gerekli kitaplıkları ayıkla'yı seçin
• lisans sorunlarına karar vermek
• tadammm ... oluşturulan kavanozu m2repo'nuza takın
• bu tek bağımlılığı diğer projelerinize ekleyin.

alkış, Balint

Hızlı ve kirli bir çözüm istiyorsanız, aşağıdakileri yapabilirsiniz (test projeleri dışında herhangi bir şey için bunu tavsiye etmememe rağmen, maven bunun uygun olmadığından şikayet edecektir).

İhtiyacınız olan her kavanoz dosyası için, tercihen bir perl betiği veya benzer bir şeyle bir bağımlılık girişi ekleyin ve bunu pom dosyanıza kopyalayın / yapıştırın.

#! /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>
";

Bir hızlı & kirli (Alex'in Yanıta göre) toplu çözümü:

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

Bu şekilde yürütün: libs.bat > libs.txt. Sonra libs.txtiçeriğini bağımlı olarak açın ve kopyalayın.

Benim durumumda, sadece kodumu derlemek için kütüphanelere ihtiyacım vardı ve bu çözüm bu amaç için en iyisiydi.

Sorununuza tam olarak uymasa da, bunu buraya bırakacağım. Gereksinimlerim:

1. Çevrimiçi bir maven deposunda bulunamayan kavanozlar SVN'de olmalıdır.
2. Bir geliştirici başka bir kitaplık eklerse, diğer geliştiriciler bunları manuel olarak yüklemekle uğraşmamalıdır.
3. IDE (benim durumumda NetBeans), otomatik tamamlama ve yardım sağlamak için kaynakları ve javadocları bulabilmelidir.

İlk önce (3) hakkında konuşalım: Kavanozların bir klasörde olması ve bir şekilde son kavanoza birleştirilmesi burada işe yaramayacaktır, çünkü IDE bunu anlamayacaktır. Bu, tüm kütüphanelerin düzgün bir şekilde kurulması gerektiği anlamına gelir. Ancak, herkes "mvn install-file" kullanarak yüklemesini istemiyorum.

Projemde metawidget'a ihtiyacım vardı. İşte başlıyoruz:

1. Yeni bir maven projesi oluşturun ("paylaşılan kütüphaneler" veya buna benzer bir ad verin).
2. Metawidget'ı indirin ve zip dosyasını src / main / lib dizinine çıkarın.
3. Doc / api klasörü javadocları içerir. İçeriğin bir zip dosyasını oluşturun (doc / api / api.zip).
4. Pom'yı böyle değiştirin
5. Projeyi derlediğinizde kütüphane kurulacaktır.
6. Kütüphaneyi projenize bağımlılık olarak ekleyin veya (paylaşılan kütüphaneler projesine bağımlılık eklediyseniz), tüm kütüphaneleri aynı anda almak için paylaşılan kütüphaneleri bağımlılık olarak ekleyin.

Yeni bir kütüphaneniz olduğunda, yeni bir yürütme ekleyin ve herkese projeyi tekrar inşa etmesini söyleyin (bu süreci proje hiyerarşileriyle geliştirebilirsiniz).

Maven deposunda olmayan 3. taraf kavanozunu kurmak için maven-install-plugin kullanın.

Aşağıda adımlar verilmiştir:

1. Jar dosyasını kaynaktan manuel olarak indirin (web sitesi)
2. Bir klasör oluşturun ve jar dosyanızı buraya yerleştirin
3. 3. parti kavanozunu yerel maven deponuza kurmak için aşağıdaki komutu çalıştırın

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

Aşağıda simonsite log4j için kullandığım örnektir

mvn install: install-file -Dfile = / Kullanıcılar / athanka / git / MyProject / repo / log4j-rolling-appender.jar -DgroupId = uk.org.simonsite -DartifactId = log4j-rolling-appender -Dversion = 20150607-2059 - Dpackaging = kavanoz

4. Pom.xml dosyasında bağımlılığı aşağıdaki gibi ekleyin

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

5. Paketinizi oluşturmak için mvn clean install komutunu çalıştırın

Referans linki aşağıdadır:

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

Burada iyi bir cevap bulamayanlar için, içinde gerekli tüm bağımlılıkları olan bir kavanoz almak için yapıyoruz. Bu yanıt ( https://stackoverflow.com/a/7623805/1084306 ) Maven Assembly eklentisini kullandığından bahsediyor, ancak aslında cevapta bir örnek vermiyor. Ve cevabın sonuna kadar okumazsanız (oldukça uzun), onu özleyebilirsiniz. Pom.xml dosyanıza aşağıdakileri eklemektarget/${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>

Ben @alex lehmann'ın cevabına bir yorumda bazı python kodunu ima ettim, bu yüzden buraya gönderiyorum.

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

Bu, onları POM'nize nasıl ekleyeceğinize cevap vermez ve beyinsiz olabilir, ancak sadece sınıf yolunuza lib dir ekler misiniz? Maven depolarıma eklemek istemediğim harici bir kavanoza ihtiyacım olduğunda bunu yapıyorum.

Bu yardımcı olur umarım.

Projemizde işe yarayan, Archimedes Trajano'nun yazdığı şeydir, ancak .m2 / settings.xml dosyamızda şöyle bir şey vardı:

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

ve * merkezi olarak değiştirilmelidir. Cevabı sizin için işe yaramıyorsa, ayarlarınızı kontrol etmelisiniz .xml

Sadece hızlı ve kirli bir geçici çözüm istedim ... Nikita Volkov'dan senaryoyu çalıştıramadım: sözdizimi hatası + kavanoz adları için sıkı bir format gerektiriyor.

Jar dosya adları için herhangi bir format ile çalışan bu Perl betiğini yaptım ve bir pompayla doğrudan yapıştırılabilecek şekilde bir xml'de bağımlılıkları üretir.

Bunu kullanmak istiyorsanız, komut ne yaptığını mutlaka öğrenin değiştirmek gerekebilir libklasör ve değerini groupIdveya 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;

Java'da scope = 'system' yaklaşımının çözümü:

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