我可以将 jars 添加到 Maven 2 构建类路径而不安装它们吗？

流行方法的问题

您可以在 Internet 上找到的大多数答案都建议您将依赖项安装到本地存储库或在 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>

对于具有 x.y.z 形式的组 id 的每个工件，Maven 将在您的项目目录中包含以下位置以搜索工件：

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

要详细说明这一点，您可以阅读 this blog post。

使用 Maven 安装到项目 repo

我建议不要手动创建此结构，而是使用 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>

辅助脚本

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

在目标包中包含依赖项

当您创建项目内存储库时，您将解决分发项目依赖项及其源的问题，但从那时起，您的项目的目标工件将依赖于未发布的 jar，所以当您安装它到一个存储库，它将具有无法解决的依赖关系。

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

---

仅用于丢弃代码

设置范围 == 系统，只需组成一个 groupId、artifactId 和 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>

注意：系统依赖项不会复制到生成的 jar/war
（请参阅 How to include system dependencies in war built using maven）

---

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

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

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

在你的 pom.xml 你应该注册存储库 ProjectRepo ProjectRepo file://${project.basedir}/libs

并像往常一样添加依赖项 groupId artifactId version

就这些。

有关详细信息：How to add external libraries in Maven（已归档）

---

注意：使用系统范围 (as mentioned on this page) 时，Maven 需要绝对路径。

如果您的 jars 位于项目的根目录下，您需要在 systemPath 值前面加上 ${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>

---

这就是我们添加或安装本地 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 构建，在正常情况下不会显示 Maven。您最好采用像 this 这样的方法。

---

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

---

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

假设您不愿意将工件上传到公共存储库，Simeon 建议使用辅助模块就可以了。但是现在有一个更简单的方法……

建议书

使用 non-maven-jar-maven-plugin。完全符合您的要求，没有其他方法的缺点。

---

我找到了另一种方法，请参见此处的 Heroku post

总结（抱歉有些复制和粘贴）

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

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

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

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

将此添加到您的 pom.xml：

project.local project file:${project.basedir}/repo com.example mylib 1.0

---

对我来说似乎最简单的就是配置您的 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>

---

在与 CloudBees 人员就此类 JAR 的正确 maven 打包进行了很长时间的讨论后，他们提出了一个有趣的好解决方案建议：

创建一个伪造的 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 运行父级时，将执行子模块。这可能是一个减号，因为项目结构应该改变，但最后提供了一个非静态的解决方案

---

systemPath 的问题是依赖项的 jar 不会作为传递依赖项随您的工件一起分发。试试我在此处发布的内容：Is it best to Mavenize your project jar files or put them in WEB-INF/lib?

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

请阅读页脚说明。

---

如果您想要一个快速而肮脏的解决方案，您可以执行以下操作（尽管我不建议将其用于除测试项目之外的任何东西，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>
";

---

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

使用 Eclipse

创建简单的（非 Maven）java 项目

添加一个主类

将所有 jar 添加到类路径

导出 Runnable JAR（这很重要，因为这里没有其他方法可以做到）

选择将所需库提取到生成的 JAR 中

决定许可证问题

tadammm ...将生成的 jar 安装到您的 m2repo

将此单一依赖项添加到您的其他项目中。

干杯，巴林特

---

一个快速而肮脏的批处理解决方案（基于亚历克斯的回答）：

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 并将其内容复制为依赖项。

就我而言，我只需要这些库来编译我的代码，而这个解决方案最适合这个目的。

---

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

在在线 maven 存储库中找不到的 jar 应该在 SVN 中。如果一个开发人员添加了另一个库，其他开发人员不应该为手动安装它们而烦恼。 IDE（在我的例子中是 NetBeans）应该能够找到源代码和 javadocs 以提供自动完成和帮助。

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

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

创建一个新的 maven 项目（将其命名为“shared-libs”或类似名称）。下载 metawidget 并将 zip 解压到 src/main/lib 中。文件夹 doc/api 包含 javadocs。创建内容的 zip (doc/api/api.zip)。像这样修改 pom 构建项目并安装库。将库作为依赖项添加到您的项目中，或者（如果您在 shared-libs 项目中添加了依赖项）添加 shared-libs 作为依赖项以一次获取所有库。

每次你有一个新的库时，只需添加一个新的执行并告诉每个人重新构建项目（你可以通过项目层次结构改进这个过程）。

---

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

以下是步骤：

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

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

下面是我用于 simonsite log4j 的示例

mvn install:install-file -Dfile=/Users/athanka/git/MyProject/repo/log4j-rolling-appender.jar -DgroupId=uk.org.simonsite -DartifactId=log4j-rolling-appender -Dversion=20150607-2059 - dpackaging=jar

在 pom.xml 中包含以下依赖项 uk.org.simonsite log4j-rolling-appender 20150607-2059 运行 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>

并且 * 应更改为中央。所以如果他的回答对你不起作用，你应该检查你的 settings.xml

---

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

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

如果您想使用它，请确保您了解脚本在做什么，您可能需要更改 lib 文件夹和 groupId 或 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();
    }
}

---