在试验/快速而肮脏的开发阶段，Maven2让我发疯。

我有一个pom.xml文件，该文件定义了要使用的Web应用程序框架的依赖关系，并且可以从该文件快速生成入门项目。但是，有时我想链接到尚未pom.xml定义文件的第三方库，因此，不是pom.xml手动为第三方库创建文件并安装它，然后将依赖项添加到我的pom.xml，告诉Maven：“除了我定义的依赖项，还包括其中的所有jar/lib。”

看起来这应该很简单，但是如果是这样，我就缺少了一些东西。

任何有关如何执行此操作的指示都将受到赞赏。简而言之，如果有一种简单的方法将maven指向/lib目录并轻松创建一个pom.xml将所有封闭的jar映射到单个依赖项的方法，那么我就可以命名/安装并链接到一个依赖项，这也足够了。

流行方法的问题

在互联网上找到的大多数答案都建议您将依赖项安装到本地存储库中，或在 pom然后将依赖项与项目源一起分发。但是，这两种解决方案实际上都是有缺陷的。

为什么不应该应用“安装到本地存储库”方法

当您将依赖项安装到本地存储库时，它将保留在那里。只要您可以访问此存储库，您的分发工件就可以正常工作。问题是在大多数情况下，该存储库将驻留在您的本地计算机上，因此将无法解决对任何其他计算机的依赖性。显然，使您的工件依赖于特定的机器不是处理事情的方法。否则，必须将此依赖项本地安装在与该项目一起工作的每台计算机上，这并没有更好的效果。

为什么不应该应用“系统范围”方法

您使用“系统范围”方法依赖的jar既不会安装到任何存储库，也不会附加到目标软件包。这就是为什么您的分发软件包在使用时将无法解决该依赖性的原因。我认为这是什至不赞成使用系统范围的原因。无论如何，您都不想依赖不推荐使用的功能。

静态项目内存储库解决方案

将其放入您的后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>

对于每个组ID形式为x.y.zMaven的工件，Maven在搜索工件时将在项目目录中包括以下位置：

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

要对此进行详细说明，可以阅读此博客文章。

使用Maven安装到项目仓库

我建议不要使用手动创建此结构，而是使用Maven插件将jar安装为工件。因此，要将工件安装到repo文件夹下的项目内存储库中，请执行：

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

如果您选择这种方法，则可以将存储库声明简化pom为：

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

辅助脚本

由于对每个库执行安装命令有点烦人并且绝对容易出错，因此我创建了一个实用程序脚本，该脚本会自动将lib文件夹中的所有jar都安装到项目存储库中，同时会自动从中解析所有元数据（groupId，artifactId等）。文件名。该脚本还会打印出依赖项xml，供您复制粘贴到pom。

在目标包中包含依赖项

创建项目内存储库后，将解决分配项目及其源代码的依赖关系的问题，但是从那时起，项目的目标工件将依赖于未发布的jar，因此在安装时它到存储库中，它将具有无法解决的依赖关系。

为了解决这个问题，我建议在目标软件包中包括这些依赖项。您可以使用Assembly插件，也可以使用OneJar插件更好地做到这一点。OneJar上的官方文档很容易掌握。

仅适用于丢弃代码

设置scope == system并仅组成一个groupId，artifactId和版本

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

注意：系统依赖项不会复制到生成的jar / war中
（请参阅如何在使用maven构建的war中包括系统依赖项）

您可以在项目上创建本地存储库

例如，如果libs项目结构中有文件夹

• 在libs文件夹中，您应该创建目录结构，例如：/groupId/artifactId/version/artifactId-version.jar

• 在pom.xml中，您应该注册存储库

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

• 并像往常一样添加依赖项

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

就这些。

有关详细信息：如何在Maven中添加外部库

注意：使用系统范围（如本页所述）时）时，Maven需要绝对路径。

如果jars在项目的根目录下，则需要在$ Systems值前面加上$ {basedir}。

这是我所做的，它也可以解决程序包问题，并且可以与签出的代码一起工作。

我使用的情况是在项目中创建了一个新文件夹repo，但是请随时使用src/repo

在我的POM中，我有一个不在任何公共Maven存储库中的依赖项

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

然后，我创建了以下目录 repo/com/dovetail/zoslog4j/1.0.1，并将JAR文件复制到该文件夹​​中。

我创建了以下POM文件来表示下载的文件（此步骤是可选的，但它删除了警告），并帮助下一个家伙弄清楚我从何处获得该文件。

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

我创建的两个可选文件是POM的SHA1校验和和删除缺少的校验和警告的JAR。

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

最后，我将以下片段添加到pom.xml中，该片段允许我引用本地存储库

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

您确实应该通过存储库建立一个框架，并预先确定您的依赖项。使用系统范围是人们经常使用的错误，因为他们“不在乎依赖关系管理”。问题是这样做会导致变态的Maven构建最终无法正常显示Maven。你会断下像一个更好的办法这个。

这就是我们添加或安装本地jar的方式

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

我给了一些默认的groupId和artifactId，因为它们是强制性的:)

Maven安装插件具有命令行用法，可以将jar安装到本地存储库中，POM是可选的，但您必须指定GroupId，ArtifactId，Version和Packaging（所有POM内容）。

<scope>system</scope>出于其他原因解释，使用是一个糟糕的主意，将文件手动安装到本地存储库会使构建<url>file://${project.basedir}/repo</url>无法重现，并且使用也不是一个好主意，因为（1）可能不是格式正确的fileURL（例如，如果项目在包含不正常字符的目录中检出），（2）如果此项目的POM用作其他人项目的依赖项，则结果将不可用。

假设您不愿意将工件上传到公共存储库，Simeon建议使用帮助程序模块来完成这项工作。但是现在有一种更简单的方法…

建议

使用non-maven-jar-maven-plugin。确实满足您的要求，而没有其他方法的缺点。

我找到了另一种方法，请参见Heroku文章

总结（很抱歉复制和粘贴）

• repo在根文件夹下创建一个目录：

您的项目
+-pom.xml
+-src
+-回购

• 运行此命令将jar安装到本地repo目录

mvn deploy：部署文件-Durl = file：/// path / to / yourproject / repo / -Dfile = mylib-1.0.jar -DgroupId = com.example -DartifactId = mylib -Dpackaging = jar -Dversion = 1.0

• 将此添加到您的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的家伙进行了很长时间的讨论之后，他们讨论了如何正确地包装此类JAR，然后提出了一个有趣的好建议：

创建一个伪造的Maven项目，该项目将先前存在的JAR附加为主要工件，并运行到所属的POM install：install-file执行中。这是这种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>

但是为了实现它，应该改变现有的项目结构。首先，您应该记住，对于每种此类JAR，都应创建不同的假Maven项目（模块）。并且应该创建一个父Maven项目，其中包括所有子模块：所有JAR包装器和现有的主项目。结构可以是：

根项目（此文件包含父POM文件，其中包括带有模块 XML元素的所有子模块）（POM打包）

JAR 1包装Maven子项目（POM包装）

JAR 2包装Maven子项目（POM包装）

现有的主要Maven子项目（WAR，JAR，EAR ....包装）

当通过mvn：install或mvn：packaging运行父级时，将执行子模块。这可能是一个负号，因为项目结构应该更改，但是最后提供了一个非静态的解决方案

对我来说，最简单的方法就是将您的maven-compiler-plugin配置为包含您的自定义jar。本示例将在lib目录中加载所有jar文件。

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

问题systemPath在于依赖项的jars不会作为传递性依赖项随您的工件分布。试试我在这里发布的内容：最好将项目jar文件Mavenize或将其放在WEB-INF / lib中吗？

然后像往常一样声明依赖项。

并且请阅读页脚注释。

我发现一个奇怪的解决方案：

使用Eclipse

• 创建简单的（非Maven）java项目
• 添加一个主类
• 将所有罐子添加到类路径
• 导出Runnable JAR（这很重要，因为这里没有其他方法可以做到）
• 选择将所需的库提取到生成的JAR中
• 决定许可问题
• tadammm ...将生成的jar安装到m2repo
• 将此单一依赖项添加到您的其他项目中。

干杯，Balint

如果您想要一个快速而肮脏的解决方案，则可以执行以下操作（尽管除了测试项目以外，我不建议这样做，但maven会抱怨这是不合适的）。

为您需要的每个jar文件添加一个依赖项，最好使用perl脚本或类似的东西，然后将其复制/粘贴到pom文件中。

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

一个快速和肮脏的批量解决方案（基于Alex的答案）：

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

像这样执行：libs.bat > libs.txt。然后打开libs.txt并将其内容复制为依赖项。

就我而言，我只需要库来编译我的代码，而该解决方案是达到此目的的最佳解决方案。

即使它并不完全适合您的问题，我也将其放在这里。我的要求是：

1. 在在线Maven存储库中找不到的jar应该在SVN中。
2. 如果一个开发人员添加了另一个库，那么其他开发人员不应手动安装它们。
3. IDE（在我的情况下为NetBeans）应该能够找到源代码和javadocs来提供自动补全和帮助。

让我们先讨论（3）：在这里，仅将jar放在一个文件夹中，然后以某种方式将其合并到最终jar中，因为IDE无法理解这一点。这意味着必须正确安装所有库。但是，我不想让每个人都使用“ mvn install-file”安装它。

在我的项目中，我需要metawidget。开始了：

1. 创建一个新的Maven项目（将其命名为“ shared-libs”或类似名称）。
2. 下载metawidget并将zip解压缩到src / main / lib中。
3. 文件夹doc / api包含javadocs。创建内容的zip文件（doc / api / api.zip）。
4. 像这样修改pom
5. 生成项目，然后将安装库。
6. 将库添加为项目的依赖项，或者（如果在共享库项目中添加了此依赖项）将共享库添加为依赖项，以一次获取所有库。

每次拥有新库时，只需添加一个新执行，并告诉每个人再次构建项目（您可以使用项目层次结构来改进此过程）。

要安装不在maven存储库中的第3方jar，请使用maven-install-plugin。

以下是步骤：

1. 从源（网站）手动下载jar文件
2. 创建一个文件夹并将jar文件放入其中
3. 运行以下命令以将第3方jar安装在本地Maven存储库中

mvn install：安装文件-Dfile = -DgroupId = -DartifactId = -Dversion = -Dpackaging =

下面是例如我用于simonsite log4j的示例

mvn install：安装文件-Dfile = / Users / athanka / git / MyProject / repo / log4j-rolling-appender.jar -DgroupId = uk.org.simonsite -DartifactId = log4j-rolling-appender -Dversion = 20150607-2059- Dpackaging = jar

4. 在pom.xml中包括如下依赖项

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

5. 运行mvn clean install命令创建包装

以下是参考链接：

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

对于那些在这里找不到好的答案的人，这就是我们要获得一个包含所有必需依赖项的jar的方法。这个答案（https://stackoverflow.com/a/7623805/1084306）提到要使用Maven Assembly插件，但实际上并未给出示例。而且，如果您没有完全阅读答案的末尾（很长），您可能会错过它。将以下内容添加到您的pom.xml中将生成target/${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>

我在@alex lehmann's的答案注释中提到了一些python代码，因此请将其发布在此处。

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

这没有回答如何将它们添加到您的POM中，并且可能没有什么用，但是只是将lib目录添加到您的类路径中就可以了吗？我知道当我需要一个不想添加到我的Maven仓库中的外部jar时，该怎么办。

希望这可以帮助。

在我们的项目中起作用的是Archimedes Trajano编写的内容，但是我们在.m2 / settings.xml文件中有如下内容：

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

并将*更改为Central。因此，如果他的答案对您不起作用，则应检查您的settings.xml

我只是想要一种快速而肮脏的解决方法...我无法从Nikita Volkov运行脚本：语法错误+它要求jar名称使用严格的格式。

我制作了这个Perl脚本，该脚本可以使用任何格式的jar文件名，并且可以在xml中生成依赖项，因此可以直接将其复制粘贴到pom中。

如果要使用它，请确保您了解脚本的作用，您可能需要更改lib文件夹和groupIdor 的值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中scope ='system'方法的解决方案：

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