Question

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

Answer 1

您可以直接添加本地依赖项（如build maven project with propriatery libraries included中所述），如下所示：

<dependency>
    <groupId>com.sample</groupId>
    <artifactId>sample</artifactId>
    <version>1.0</version>
    <scope>system</scope>
    <systemPath>${project.basedir}/src/main/resources/yourJar.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

<强>参考

Maven常见问题：I have a jar that I want to put into my local repository. How can I copy it in?
Maven安装插件用法：The install:install-file goal

Answer 3

首先，我想对这个匿名Stack Overflow用户的回答表示赞赏 - 我很确定我之前已经看过类似的答案 - 但现在我找不到了。

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

我的例子：我的主项目位于${master_project}位置，子项目1位于${master_project}/${subproject1}。

然后我在以下位置创建一个Maven存储库： ${master_project}/local-maven-repo。

在位于${master_project}/${subproject1}/pom.xml的子项目1的pom文件中，需要指定存储库，将文件路径作为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仓库可以提交到代码存储库，整个设置与系统无关。（Working example in GitHub）。

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

Answer 4

创建一个新文件夹，让我们在您的Maven项目的根目录中说local-maven-repo。

只需在<project>的{{1}}内添加一个本地仓库：

pom.xml

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

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

Answer 5

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

Answer 6

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

        <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中的任何其他maven依赖项中，并带有<dependency></dependency>标记）。也可以将jar install绑定到initialize步骤，而不是任何其他步骤。

Answer 7

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

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

另见

How to build maven project with propriatery libraries included

Answer 8

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

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

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

Answer 9

在POM文件中添加您自己的本地JAR，并在maven build中使用它。

   .bell-notification-max-words-display{
      overflow: hidden;
      display: -webkit-box;
      -webkit-line-clamp: 2;
      -webkit-box-orient: vertical;  
    }

例如：

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

然后将其添加到POM中：

Answer 10

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

如果您需要这些罐子进行编译，请查看以下相关问题：Can I add jars to maven 2 build classpath without installing them?

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

Answer 11

命令行：

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

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，然后将此{{1} }项目中的文件夹，以便使用项目特定的相对路径，并避免添加系统特定的绝对路径。

如果您有多个外部jar，只需对同一lib中的其他jar重复<execution>。

第2步：如上所示，在maven-install-plugin文件中配置了maven-install-plugin之后，您必须照常在pom.xml中使用这些jar ：

pom.xml

请注意，<dependency> <groupId>com.amazonservices.mws</groupId> <artifactId>mws-client</artifactId> <version>1.0</version> </dependency>仅将您的外部jar复制到本地maven-install-plugin Maven存储库。而已。它不会自动将这些jar作为项目的Maven依赖项包含在内。

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

Answer 13

另一个有趣的案例是你想在你的项目中拥有私人maven jar。您可能希望保持Maven的功能以解决传递依赖性。解决方案相当容易。

在项目中创建 libs 文件夹

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

expect(WallObject).to.have.schema(expectedSchema)

打开 .m2 / repository 文件夹，将要导入的项目的目录结构复制到 libs 文件夹中。

E.g。假设您要导入依赖项

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

继续 .m2 / repository ，您将看到以下文件夹

<强> COM / myCompany的/ myproject的/ 1.2.3

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

Answer 14

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

有关如何操作的详细信息，请参阅here。查看“上传到远程存储库”部分。

Answer 15

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

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 16

我想分享一个代码，你可以上传一个装满了罐子的文件夹。当提供商没有公共存储库并且您需要手动添加大量库时，这很有用。我决定构建一个.bat而不是直接调用maven，因为它可能是Out of Memory错误。它是为Windows环境准备的，但很容易适应Linux操作系统：

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运行此main后，运行update_repo_maven.bat。

Answer 17

另外看看......

<scope>compile</scope>

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

Answer 18

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

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

groupId使用唯一名称，以确保没有冲突。

现在，当您自动添加mvn install或mvn test个本地广告时。

Answer 19

将本地`def contains(a, b): n, m = len(a), len(b) j = 0 for i in range(n): if j < m and a[i] == b[j]: j += 1 return j == m`库，它们的`jar`和`sources`添加到Maven项目

如果您将javadoc文件与库，它们的jar和sources预编译，则可以javadoc将它们install到本地Maven存储库，如下所示：

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

然后在您的项目中可以使用以下库：

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

请参阅：subsequence用法。

或者您可以build自己sources和javadoc来使用maven-install-plugin和maven-source-plugin，然后install来使用它们。 / p>

示例项目：库

<?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 install目标：

mvn install

检查您本地的Maven存储库：

~/.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

然后您可以使用此库：

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

Answer 20

出于某种原因，在我正在进行维护的Web应用程序中，Alireza Fattahi's solution和JJ Roman's solution都没有正常工作。在这两种情况下，编译都没问题（它看到了jar），但包装无法在战争中包含jar。

我设法让它发挥作用的唯一方法是将jar放在/src/main/webapp/WEB-INF/lib/上，然后将其与Fattahis或Roman的解决方案相结合。

Answer 21

请注意，使用本地仓库不一定是个好主意。如果这个项目与其他人共享，那么当它不起作用时，其他人都会遇到问题和疑问，即使在您的源代码管理系统中也无法使用jar！

虽然共享仓库是最好的答案，但如果由于某种原因你不能这样做，那么嵌入jar比本地仓库更好。仅限本地的回购内容可能会导致很多问题，特别是随着时间的推移。

Answer 22

在本地存储库中，您可以通过发出命令

来安装jar

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

按照这个有用的link在mkyoung的网站上做同样的事情。您还可以查看maven guide for the same

Answer 23

我的pom.xml中的一组依赖项出现了同样的错误，结果是pom.xml中没有指定依赖项的版本，并在父存储库中提到过。由于某种原因，版本细节未与此回购同步。因此，我使用标签手动输入版本，它就像一个魅力。查找父项中的版本并在此处指定所需的时间很少。但这只能用于显示artifactid错误并且有效的罐子。希望这有助于某人。

Answer 24

此答案仅供ECLIPSE用户使用：

如果您正在使用Eclipse，请将jar放在lib /中，右键单击jar名称并单击＆＃34;添加到构建路径＆＃34;。 Eclipse将创建一个＆＃34;引用的库＆＃34;并为你放置罐子

它解决了我在程序中立即导入jar的问题

Answer 25

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

：应在例如-> com.google.code

下注册文件的组

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

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

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

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

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

Answer 26

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

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

Answer 27

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

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

yourproject
+- pom.xml
+- src

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

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

将工件部署到仓库中，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

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

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

在您的pom文件中添加仓库：

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

在您的pom中添加依赖项：

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

Answer 29

要安装第三方jar，请调用以下命令

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

Answer 30

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

没有使用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'

 }

Answer 31

我的阴影jar文件不包含使用AlirezaFattahi解决方案的第三方库。但是，我记得上一次在同一项目中尝试过该功能后，它就会起作用。因此，我尝试了自己的解决方案：

mkdir .m2 / repositories目录下的项目路径（类似于该目录中的其他maven依赖项目录）
将第三方jar文件放入其中。
像在Maven存储库中一样添加依赖项。

最后，它为我工作。：）

Answer 32

也许有人会对以下内容感兴趣： https://github.com/Limraj/maven-artifact-generator

控制台程序，用于根据jar的路径在本地存储库中生成Maven工件，并为pom.xml配置依赖项。您可以为一个文件执行此操作，但是如果您有多个jar文件，这将非常有用。

路径罐： java -jar maven-artifact-generator-X.X.X.jar -p path_to_jars -g com.test -V 1.2.3 -P jar

jar： java -jar maven-artifact-generator-X.X.X.jar -f file_jar -g com.test -V 1.2.3 -P jar

这将在本地Maven存储库中生成工件，并在gen.log中生成pom.xml的依赖项。 ArtifactId是jar文件的名称。

需要已安装的Maven。在Widnows 7和macOS X（unix / linux）上进行测试。

Answer 33

就我而言，事实证明我现有的 maven 构建已经将有问题的 jar 文件安装到我的本地存储库中，但我没有看到预期的结果，因为本地构建会生成带有后缀“-SNAPSHOT”的工件。对我来说非常简单的解决方案是更新使用本地构建 jar 文件的项目的 pom.xml 文件，以匹配名称。

<myproject.foo.version>1.88-SNAPSHOT</myproject.foo.version>

代替

<myproject.foo.version>1.88</myproject.foo.version>

要点是，如果您的 jar 文件看起来应该已经在您本地的 .m2/maven 存储库中，那很有可能，您只需要相应地更新您的依赖项即可。

Answer 34

我和ojdbc6有同样的问题。我看到了这个链接，但它没有用。命令是正确的，但我需要一个参数，

这是链接：http://roufid.com/3-ways-to-add-local-jar-to-maven-project/

以下是示例：

install:install-file -Dfile=C:\driversDB\ojdbc6.jar -DgroupId=com.oracle -DartifactId=ojdbc6 -Dversion=11.2.0.3 -Dpackaging=jar

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

34 个答案:

将本地`def contains(a, b): n, m = len(a), len(b) j = 0 for i in range(n): if j < m and a[i] == b[j]: j += 1 return j == m`库，它们的`jar`和`sources`添加到Maven项目

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

34 个答案:

将本地def contains(a, b): n, m = len(a), len(b) j = 0 for i in range(n): if j < m and a[i] == b[j]: j += 1 return j == m 库，它们的jar和sources添加到Maven项目

将本地`def contains(a, b): n, m = len(a), len(b) j = 0 for i in range(n): if j < m and a[i] == b[j]: j += 1 return j == m`库，它们的`jar`和`sources`添加到Maven项目