如何将本地jar文件添加到Maven项目？

Question

如何在项目的库源中直接添加本地jar文件(尚未成为Maven存储库的一部分)？

Answer 1

您可以直接添加本地依赖项(如包含propriatery库的build maven项目中所述),如下所示:

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

更新

在新版本中,此功能被标记为已弃用但仍在工作但尚未删除(您只需在maven启动期间在日志中看到警告).maven小组就此问题提出了一个问题:https://issues.apache.org/jira/browse/MNG-6523(您可以参与并说明为什么此功能在某些情况下有用).我希望这个功能仍然存在!

如果您问我,只要不删除该功能,我就会使用它来依赖于我的项目中只有一个不适合存储库的淘气jar文件.如果删除了这个功能,那么这里有很多好的答案我可以从以后选择!

Answer 2

将JAR安装到本地Maven存储库中,如下所示:

mvn install:install-file \
   -Dfile=<path-to-file> \
   -DgroupId=<group-id> \
   -DartifactId=<artifact-id> \
   -Dversion=<version> \
   -Dpackaging=<packaging> \
   -DgeneratePom=true

每个都指的是:

<path-to-file>:要加载的文件的路径,例如 - > c:\ kaptcha-2.3.jar

<group-id>:文件应在例如 - > com.google.code下注册的组

<artifact-id>:文件的工件名称,例如 - > kaptcha

<version>:文件的版本,例如 - > 2.3

<packaging>:文件的包装,例如 - > jar

参考

Answer 3

首先,我想对这个匿名Stack Overflow用户的答案给予赞扬 - 我很确定我之前已经看过类似的答案 - 但现在我找不到了.

将本地JAR文件作为依赖项的最佳选择是创建本地Maven存储库.这样的存储库只不过是一个包含pom文件的正确目录结构.

对于我的例子:我的${master_project}位置上的主项目和子项目1已打开${master_project}/${subproject1}.

然后我在:创建一个Maven存储库 ${master_project}/local-maven-repo.

在位于子项目1的pom文件中${master_project}/${subproject1}/pom.xml,需要指定存储库,将文件路径作为URL参数:

<repositories>
    <repository>
        <id>local-maven-repo</id>
        <url>file:///${project.parent.basedir}/local-maven-repo</url>
    </repository>
</repositories>

可以为任何其他存储库指定依赖项.这使您的pom存储库独立.例如,一旦所需的JAR在Maven central中可用,您只需要从本地仓库中删除它,它将从默认仓库中提取.

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

最后但并非最不重要的事情是使用-DlocalRepositoryPath开关将JAR文件添加到本地存储库,如下所示:

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

安装JAR文件后,可以将Maven存储库提交到代码存储库,整个设置与系统无关.(GitHub中的工作示例).

我同意让JAR承诺源代码回购不是一个好习惯,但在现实生活中,快速和肮脏的解决方案有时比完整的Nexus repo更好地托管一个你无法发布的JAR.

Answer 4

创建一个新文件夹,假设local-maven-repo您的Maven项目的根目录.

只需在您<project>的内部添加一个本地仓库pom.xml:

<repositories>
    <repository>
        <id>local-maven-repo</id>
        <url>file:///${project.basedir}/local-maven-repo</url>
    </repository>
</repositories>

然后,对于要安装的每个外部jar,请转到项目的根目录并执行:

mvn deploy:deploy-file -DgroupId=[GROUP] -DartifactId=[ARTIFACT] -Dversion=[VERS] -Durl=file:./local-maven-repo/ -DrepositoryId=local-maven-repo -DupdateReleaseInfo=true -Dfile=[FILE_PATH]

Answer 5

我想要这样的解决方案 - maven-install-plugin在pom文件中使用:

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

在这种情况下,您可以执行mvn initialize,jar将安装在本地maven仓库中.现在这个jar在这台机器上的任何maven步骤中都可用(不要忘记将这个依赖项包含在带有<dependency></dependency>标记的pom中的任何其他maven依赖项中).也可以将jar install绑定到initializestep,但是你喜欢的任何其他步骤.

Answer 6

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

Answer 7

依赖中的重要部分是： ${pom.basedir}（而不仅仅是 ${basedir}）

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

Answer 8

是的,你可以拥有但不是好主意.

而是将所有这些罐子安装到maven repos

另见

• 如何使用propriatery库构建maven项目

Answer 9

真正快速而肮脏的方式是指向本地文件:

<dependency>
      <groupId>sample</groupId>  
       <artifactId>com.sample</artifactId>  
       <version>1.0</version> 
      <scope>system</scope>
      <systemPath>C:\DEV\myfunnylib\yourJar.jar</systemPath>
</dependency>

然而,这只会存在于您的机器上(显然),为了共享它通常是有意义的使用正确的m2存档(nexus/artifactory)或者如果你没有任何这些或者不想设置一个本地maven结构化存档并在您的pom中配置"存储库":local:

<repositories>
    <repository>
        <id>my-local-repo</id>
        <url>file://C:/DEV//mymvnrepo</url>
    </repository>
</repositories>

远程:

<repositories>
    <repository>
        <id>my-remote-repo</id>
        <url>http://192.168.0.1/whatever/mavenserver/youwant/repo</url>
    </repository>
</repositories>

为此,使用basedir变量也可以使用相对路径:

<url>file:${basedir}</url>

Answer 10

一种方法是将其上传到您自己的Maven存储库管理器(例如Nexus).无论如何,拥有自己的存储库管理器是一种很好的做法.

我最近看到的另一个好方法是在构建生命周期中包含Maven Install Plugin:您在POM中声明将文件安装到本地存储库.这是一个小但很小的开销,没有涉及手动步骤.

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

Answer 11

在POM文件中添加您自己的本地JAR,并在maven构建中使用它.

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

例如:

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

然后将它添加到POM中,如下所示:

Answer 12

第 1 步：在您maven-install-plugin的目标install-file中配置pom.xml

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <executions>
        <execution>
            <id>install-external-non-maven-jar-MWS-Client-into-local-maven-repo</id>
            <phase>clean</phase>
            <configuration>
                <repositoryLayout>default</repositoryLayout>
                <groupId>com.amazonservices.mws</groupId>
                <artifactId>mws-client</artifactId>
                <version>1.0</version>
                <file>${project.basedir}/lib/MWSClientJavaRuntime-1.0.jar</file>
                <packaging>jar</packaging>
                <generatePom>true</generatePom>
            </configuration>
            <goals>
                <goal>install-file</goal>
            </goals>
        </execution>
    </executions>
</plugin>

确保file根据您的实际文件路径编辑路径（建议将这些外部非 Maven jar 放在某个文件夹中，比如说lib，将此lib文件夹放在您的项目中，以便使用项目特定的相对路径并避免添加系统具体的绝对路径。

如果您有多个外部 jar，只需<execution>对同一maven-install-plugin.

第 2 步：一旦您maven-install-plugin在pom.xml文件中配置了如上所示的内容，您必须pom.xml像往常一样在您的文件中使用这些 jar ：

    <dependency>
        <groupId>com.amazonservices.mws</groupId>
        <artifactId>mws-client</artifactId>
        <version>1.0</version>
    </dependency>

请注意，maven-install-plugin只会将您的外部 jar 复制到您的本地.m2Maven 存储库。就是这样。它不会自动将这些 jar 作为 Maven 依赖项包含到您的项目中。

这是一个小问题，但有时很容易错过。

Answer 13

当然,您可以将jar添加到该文件夹​​.但也许它不是你想要实现的......

如果您需要这些jar进行编译,请检查以下相关问题:我可以将jar添加到maven 2 build classpath而不安装它们吗？

此外,在任何人建议之前,请不要使用系统范围.

Answer 14

命令行 :

mvn install:install-file -Dfile=c:\kaptcha-{version}.jar -DgroupId=com.google.code
-DartifactId=kaptcha -Dversion={version} -Dpackaging=jar

Answer 15

我认为这个问题的一个更好的解决方案是使用maven-install-plugin在安装时自动安装文件。这就是我为我的项目设置的方式。

首先，添加路径（您存储本地 .jars 的位置）作为属性。

<properties>
    <local.sdk>/path/to/jar</local.sdk>
</properties>

然后，在plugins编译时添加一个插件来安装jar。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <version>2.5.2</version>
    <executions>
        <execution>
            <id>1</id>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <groupId>com.local.jar</groupId> 
                <artifactId>appengine-api</artifactId>
                <version>1.0</version>
                <packaging>jar</packaging>
                <file>${local.sdk}/lib/impl/appengine-api.jar</file>
            </configuration>
        </execution>
        <execution>
            <id>appengine-api-stubs</id>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <groupId>com.local.jar</groupId>
                <artifactId>appengine-api-stubs</artifactId>
                <version>1.0</version>
                <packaging>jar</packaging>
                <file>${local.sdk}/lib/impl/appengine-api-stubs.jar</file>
            </configuration>
        </execution>
    </executions>
</plugin>

最后，在依赖项中，您可以添加 jars

<dependency>
    <groupId>com.local.jar</groupId>
    <artifactId>appengine-api</artifactId>
    <version>1.0</version>
</dependency>

<dependency>
    <groupId>com.local.jar</groupId>
    <artifactId>appengine-api-stubs</artifactId>
    <version>1.0</version>
    <scope>test</scope>
</dependency>

通过像这样设置您的项目，即使您将其带到另一台计算机，该项目也将继续构建（假设它具有属性指定的路径中的所有 jar 文件local.sdk）。

对于groupId使用一个唯一的名称只是为了确保不存在冲突。

现在当你mvn install或mvn test本地 jars 将被自动添加。

Answer 16

将本地jar库、它们的sources和添加javadoc到 Maven 项目

如果您有jar带有库的预编译文件、它们的sources和javadoc，那么您可以install像这样将它们放到您的本地 Maven 存储库中：

mvn 安装：安装文件
    -Dfile=awesomeapp-1.0.1.jar \
    -DpomFile=awesomeapp-1.0.1.pom \
    -Dsources=awesomeapp-1.0.1-sources.jar \ 
    -Djavadoc=awesomeapp-1.0.1-javadoc.jar \
    -DgroupId=com.example \
    -DartifactId=awesomeapp \
    -Dversion=1.0.1 \
    -Dpackaging=jar

然后在你的项目中你可以使用这个库：

mvn install:install-file
    -Dfile=awesomeapp-1.0.1.jar \
    -DpomFile=awesomeapp-1.0.1.pom \
    -Dsources=awesomeapp-1.0.1-sources.jar \
    -Djavadoc=awesomeapp-1.0.1-javadoc.jar \
    -DgroupId=com.example \
    -DartifactId=awesomeapp \
    -Dversion=1.0.1 \
    -Dpackaging=jar

请参阅：maven-install-plugin用法。

或者您可以build自己使用这些库sources并javadoc使用maven-source-plugin和maven-javadoc-plugin，然后使用install它们。

示例项目：图书馆

<!-- com.example -->
<dependency>
    <groupId>com.example</groupId>
    <artifactId>awesomeapp</artifactId>
    <version>1.0.1</version>
</dependency>

执行 Maveninstall目标：

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

    <url>https://example.com/awesomeapp</url>

    <groupId>com.example</groupId>
    <artifactId>awesomeapp</artifactId>
    <name>awesomeapp</name>
    <version>1.0.1</version>
    <packaging>jar</packaging>

    <properties>
        <java.version>12</java.version>
    </properties>

    <build>
        <finalName>awesomeapp</finalName>
        <defaultGoal>install</defaultGoal>

        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <inherited>true</inherited>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>3.2.1</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <goals><goal>jar</goal></goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <inherited>true</inherited>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <version>3.2.0</version>
                <executions>
                    <execution>
                        <id>attach-javadocs</id>
                        <goals><goal>jar</goal></goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

检查您的本地 Maven 存储库：

mvn install

然后你可以使用这个库：

~/.m2/repository/com/example/awesomeapp/1.0.1/
 ?? _remote.repositories
 ?? awesomeapp-1.0.1.jar
 ?? awesomeapp-1.0.1.pom
 ?? awesomeapp-1.0.1-javadoc.jar
 ?? awesomeapp-1.0.1-sources.jar

Answer 17

这是较新版本的简短语法：

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

它在 JAR 由 Apache Maven 构建时起作用 - 最常见的情况。然后它将在 META-INF 目录的子文件夹中包含一个 pom.xml，默认情况下将读取该子文件夹。

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

Answer 18

另一个有趣的情况是，您想在项目中使用私有Maven罐子。您可能需要保留Maven的功能，以解决传递依赖项。解决方案相当简单。

1. 在您的项目中创建一个文件夹库

2. 在pom.xml文件中添加以下行

   <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. 打开.m2 / repository文件夹，然后将要导入的项目的目录结构复制到libs文件夹中。

例如，假设您要导入依赖项

<dependency>
    <groupId>com.mycompany.myproject</groupId>
    <artifactId>myproject</artifactId>
    <version>1.2.3</version>
</dependency>

只需进入.m2 / repository，您将看到以下文件夹

com / mycompany / myproject / 1.2.3

复制您libs文件夹中的所有内容（同样，包括.m2 / repository下的文件夹），您就完成了。

Answer 19

不是原始问题的答案，但可能对某人有用

没有正确的方法可以使用 Maven 从文件夹中添加多个 jar 库。如果只有很少的依赖项，则maven-install-plugin按照上面的答案中所述进行配置可能会更容易。

然而，对于我的特殊情况，我有一个lib包含 100 多个专有 jar 文件的文件夹，我必须以某种方式添加它们。对我来说，将我的Maven项目转换为Gradle.

plugins {
    id 'org.springframework.boot' version '2.2.2.RELEASE'
    id 'io.spring.dependency-management' version '1.0.8.RELEASE'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
    mavenCentral()
    flatDir {
       dirs 'libs' // local libs folder
   }
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
    
    implementation 'io.grpc:grpc-netty-shaded:1.29.0'
    implementation 'io.grpc:grpc-protobuf:1.29.0'
    implementation 'io.grpc:grpc-stub:1.29.0' // dependecies from maven central

    implementation name: 'akka-actor_2.12-2.6.1' // dependecies from lib folder
    implementation name: 'akka-protobuf-v3_2.12-2.6.1'
    implementation name: 'akka-stream_2.12-2.6.1'

 }