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

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

如下所示将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

参考

• Maven常见问题解答：我有一个要放入本地存储库的jar。如何复制？
• Maven的安装插件使用方法：将install:install-file目标

您可以像这样直接添加本地依赖项（如在包含专有库的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文件，该文件不适合存储库。如果此功能被删除，那么，这里有很多不错的答案，我以后可以选择！

首先，我想把这个答案归功于一个匿名的Stack Overflow用户-我很确定以前在这里看到过类似的答案-但现在找不到了。

将本地JAR文件作为依赖项的最佳选择是创建本地Maven存储库。这样的存储库只不过是带有pom文件的适当目录结构。

以我的示例为例：我的主项目位于${master_project}location上，subproject1在上${master_project}/${subproject1}。

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

在位于的subproject1中的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回购来托管一个您无法发布的JAR更好。

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]

我想要这样的解决方案- 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步骤中都可用（不要忘记将此依赖项与pom中带有<dependency></dependency>tag的任何其他Maven依赖项一起包括在内）。也可以将jar安装绑定到initialize步骤，而不是您喜欢的任何其他步骤。

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

是的，您可以拥有，但不是个好主意。

而是将所有这些jar安装到Maven仓库中

另请参阅

• 如何使用专有属性库构建Maven项目

真正快捷而肮脏的方法是指向本地文件：

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

但是，这只能在您的机器上运行（很明显），因为共享它通常使用合理的m2归档文件（关系/人工工厂），或者如果您没有这些文件或者不想在本地建立Maven，结构化归档文件，并在pom中配置“存储库”：本地：

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

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

一种方法是将其上传到您自己的Maven存储库管理器（例如Nexus）。无论如何，拥有自己的存储库管理器是一个好习惯。

我最近看到的另一种不错的方法是在构建生命周期中包括Maven安装插件：您在POM中声明将文件安装到本地存储库。这只是一点点但很小的开销，并且不需要手动步骤。

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

当然，您可以将jar添加到该文件夹​​。但这也许不是您想要实现的目标...

如果需要这些jar进行编译，请检查以下相关问题：是否可以在不安装jar的情况下将jar添加到maven 2 build classpath？

另外，在任何人建议之前，请勿使用系统范围。

另一个有趣的情况是，您想在项目中使用私有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下的文件夹），就可以完成了。

命令行 ：

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

依赖项的重要部分是： $ {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>

我认为针对此问题的更好解决方案是使用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>

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

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

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

为了groupId使用唯一的名称，只是为了确保没有冲突。

现在，当您mvn install或mvn test本地jars会自动添加。

首选方法是创建自己的远程存储库。

有关如何执行的详细信息，请参见此处。看一下“ 上传到远程存储库 ”部分。

我想分享一个代码，您可以在其中上传一个装满jar的文件夹。当提供者没有公共存储库，而您需要手动添加许多库时，这很有用。我决定构建一个.bat而不是直接调用maven，因为它可能是内存不足错误。它是为Windows环境准备的，但是很容易使其适应Linux OS：

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;

public class CreateMavenRepoApp {

    private static final String OCB_PLUGIN_FOLDER = "C://your_folder_with_jars";

    public static void main(String[] args) throws IOException {

    File directory = new File();
    //get all the files from a directory
    PrintWriter writer = new PrintWriter("update_repo_maven.bat", "UTF-8");
    writer.println("rem "+ new Date());  
    File[] fList = directory.listFiles();
    for (File file : fList){
        if (file.isFile()){               
        String absolutePath = file.getAbsolutePath() ;
        Manifest  m = new JarFile(absolutePath).getManifest();
        Attributes attributes = m.getMainAttributes();
        String symbolicName = attributes.getValue("Bundle-SymbolicName");

        if(symbolicName!=null &&symbolicName.contains("com.yourCompany.yourProject")) {
            String[] parts =symbolicName.split("\\.");
            String artifactId = parts[parts.length-1];
            String groupId = symbolicName.substring(0,symbolicName.length()-artifactId.length()-1);
            String version = attributes.getValue("Bundle-Version");
            String mavenLine= "call mvn org.apache.maven.plugins:maven-install-plugin:2.5.1:install-file -Dfile="+ absolutePath+" -DgroupId="+ groupId+" -DartifactId="+ artifactId+" -Dversion="+ version+" -Dpackaging=jar ";
            writer.println(mavenLine);          
        }

        }
    }
    writer.close();
    }

}

从任何IDE运行此主文件后，请运行update_repo_maven.bat。

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

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

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

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

也看看...

<scope>compile</scope>

Maven依赖。这是默认设置，但是我发现在某些情况下，Maven也会明确设置该范围，以便在本地存储库中查找本地库。

由于某种原因，在我要维护的Web应用程序中，Alireza Fattahi的解决方案和JJ Roman的解决方案均无法正常工作。在这两种情况下，编译都可以（可以看到罐子），但是包装无法将罐子包含在战争中。

我设法使其起作用的唯一方法是将广口瓶放上/src/main/webapp/WEB-INF/lib/，然后与Fattahis或Roman的解决方案结合使用。

请注意，使用本地存储库不一定是一个好主意。如果该项目与他人共享，那么当它不起作用时，其他所有人都会有问题和疑问，即使您的源代码控制系统中也无法使用该jar！

尽管共享存储库是最好的答案，但是如果由于某种原因您不能执行此操作，则嵌入jar会比本地存储库更好。仅本地的回购内容可能会导致很多问题，尤其是随着时间的推移。

在本地存储库中，您可以通过发出以下命令来安装jar

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

单击此有用的 链接，可以从mkyoung的网站进行操作。您也可以检查Maven指南

要安装第三方jar，请按如下所示调用命令

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

1. mvn安装

您可以在下面的命令行中编写代码，或者如果您使用的是eclipse内置的maven，请右键单击项目->运行方式->运行配置...->在左面板中右键单击Maven Build->新配置->编写目标和基本目录中的代码：$ {project_loc：NameOfYourProject}->运行

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

其中每个都指：

<文件路径>：要加载的文件的路径，例如-> c：\ kaptcha-2.3.jar

<group-id>：文件应注册的组，例如-> com.google.code

<artifact-id>：文件的工件名称，例如-> kaptcha

<版本>：文件的版本，例如-> 2.3

<包装>：文件的包装，例如-> jar

2.安装后，只需在pom.xml中声明jar。

 <dependency>
      <groupId>com.google.code</groupId>
      <artifactId>kaptcha</artifactId>
      <version>2.3</version>
 </dependency>

第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>对同一容器中的其他jar 重复上述操作即可maven-install-plugin。

第2步：maven-install-plugin在pom.xml文件中配置完上述内容后，就必须pom.xml照常使用这些jars ：

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

请注意，maven-install-plugin仅会将您的外部jar复制到本地.m2 Maven存储库。而已。它不会自动将这些jar作为项目的Maven依赖项包含在内。

这是次要的要点，但有时容易错过。

对于我的pom.xml中的一组依赖项，我遇到了相同的错误，结果证明未在pom.xml中指定依赖项的版本，而在父存储库中提到了依赖项的版本。由于某种原因，版本详细信息未与此仓库同步。因此，我使用标记手动输入了版本，它的工作原理就像一个魅力。需要一点时间在父级中查找版本并在此处指定。但这仅适用于显示人工错误的罐子，并且可以正常工作。希望这对某人有帮助。

在Apache Maven 3.5.4中，我必须添加双引号。没有双引号对我来说是行不通的。

例如：mvn install：install-file“ -Dfile = jar文件的位置”“ -DgroupId = group id”“ -DartifactId = artifact id”“ -Dversion = version”“ -Dpackaging =软件包类型”

1. 创建一个本地Maven存储库目录，您的项目根目录应类似于以下内容：

yourproject
+- pom.xml
+- src

2. 为组com.example和版本1.0添加一个名为repo的标准Maven存储库目录：

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

3. 将工件部署到仓库中，Maven可以使用mvn deploy：deploy-file目标为您部署工件：

mvn deploy:deploy-file -Durl=file:///pathtoyour/repo -Dfile=your.jar -DgroupId=your.group.id -DartifactId=yourid -Dpackaging=jar -Dversion=1.0

4. 安装与您的jar相对应的pom文件，以便您的项目可以在从本地存储库进行maven构建期间找到jar：

mvn install:install-file -Dfile=/path-to-your-jar-1.0.jar -DpomFile=/path-to-your-pom-1.0.pom

5. 在您的pom文件中添加回购：

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

6. 在您的pom中添加依赖项：

<dependency>
    <groupId>com.groupid</groupId>
    <artifactId>myid</artifactId>
    <version>1.0</version>
</dependency>

此答案仅适用于日食用户：

如果使用的是Eclipse，请将jar放在lib /中，右键单击jar名称，然后单击“添加到构建路径”。Eclipse将创建一个“引用库”并为您放置jar

它立即为我解决了程序中jar的导入