¿Cómo agregar archivos jar locales a un proyecto Maven?

¿Cómo agrego archivos jar locales (que aún no forman parte del repositorio de Maven) directamente en las fuentes de la biblioteca de mi proyecto?

Instale el JAR en su repositorio local de Maven de la siguiente manera:

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

Donde cada uno se refiere a:

<path-to-file>: la ruta al archivo a cargar, por ejemplo → c:\kaptcha-2.3.jar

<group-id>: el grupo en el que se debe registrar el archivo, por ejemplo, → com.google.code

<artifact-id>: el nombre del artefacto para el archivo, por ejemplo, → kaptcha

<version>: la versión del archivo, por ejemplo, → 2.3

<packaging>: el paquete del archivo, por ejemplo, → jar

Referencia

• Preguntas frecuentes de Maven: Tengo un jar que quiero poner en mi repositorio local. ¿Cómo puedo copiarlo?
• Uso del complemento de instalación de Maven: el install:install-fileobjetivo

Puede agregar dependencias locales directamente (como se menciona en el proyecto build maven con bibliotecas de propiedad incluidas ) de esta manera:

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

Actualizar

En las nuevas versiones, esta característica está marcada como obsoleta pero aún funciona y aún no se ha eliminado (solo verá una advertencia en el registro durante el inicio de Maven). Se plantea un problema en el grupo Maven sobre este https://issues.apache.org/jira/browse/MNG-6523 (puede participar y describir por qué esta función es útil en algunos casos). ¡Espero que esta característica permanezca allí!

Si me está preguntando, siempre y cuando la característica no se elimine, lo uso para hacer que solo dependa de un archivo jar travieso en mi proyecto que no se ajusta al repositorio. Si se elimina esta característica, bueno, ¡hay muchas buenas respuestas aquí que puedo elegir más adelante!

En primer lugar, me gustaría dar crédito por esta respuesta a un usuario anónimo de Stack Overflow. Estoy bastante seguro de que he visto una respuesta similar aquí antes, pero ahora no puedo encontrarla.

La mejor opción para tener archivos JAR locales como dependencia es crear un repositorio local de Maven. Tal repositorio no es más que una estructura de directorio adecuada con archivos pom.

Para mi ejemplo: tengo mi proyecto maestro en ${master_project}ubicación y el subproyecto1 está activado ${master_project}/${subproject1}.

Luego de crear un repositorio Maven en: ${master_project}/local-maven-repo.

En el archivo pom en el subproyecto1 ubicado en ${master_project}/${subproject1}/pom.xml, se debe especificar el repositorio que tomaría la ruta del archivo como un parámetro de URL:

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

La dependencia se puede especificar como para cualquier otro repositorio. Esto hace que su repositorio pom sea independiente. Por ejemplo, una vez que el JAR deseado esté disponible en Maven central, solo necesita eliminarlo de su repositorio local y se extraerá del repositorio predeterminado.

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

Lo último, pero no menos importante, es agregar el archivo JAR al repositorio local utilizando el conmutador -DlocalRepositoryPath de esta manera:

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

Una vez que se instala el archivo JAR, su repositorio de Maven puede comprometerse a un repositorio de código, y toda la configuración es independiente del sistema. ( Ejemplo de trabajo en GitHub ).

Estoy de acuerdo en que tener JAR comprometidos con el repositorio de código fuente no es una buena práctica, pero en la vida real, las soluciones rápidas y sucias a veces son mejores que un repositorio Nexus completo para alojar un JAR que no puede publicar.

Cree una nueva carpeta, digamos local-maven-repoen la raíz de su proyecto Maven.

Simplemente agregue un repositorio local dentro <project>de su pom.xml:

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

Luego, para cada jar externo que desee instalar, vaya a la raíz de su proyecto y ejecute:

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

Me gustaría tal solución: usar maven-install-pluginen el archivo 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>

En este caso, puede realizar mvn initializey jar se instalará en el repositorio local de Maven. Ahora este jar está disponible durante cualquier paso de maven en esta máquina (no olvide incluir esta dependencia como cualquier otra dependencia de maven en pom con <dependency></dependency>etiqueta). También es posible vincular la instalación de jar no al initializepaso, sino a cualquier otro paso que desee.

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

Sí, puedes tener pero no es buena idea.

En su lugar, instale todos estos frascos en repositorios Maven

Ver también

• Cómo construir un proyecto Maven con bibliotecas de propiedad incluidas

La forma realmente rápida y sucia es señalar un archivo local:

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

Sin embargo, esto solo vivirá en su máquina (obviamente), para compartirlo generalmente tiene sentido usar un archivo m2 adecuado (nexus / artefacto) o si no tiene ninguno de estos o no desea configurar uno para un experto local. archivo estructurado y configurar un "repositorio" en su pom: local:

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

remoto:

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

para esto también es posible una ruta relativa utilizando la variable basedir:

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

Agregue su propio JAR local en el archivo POM y úselo en la compilación maven.

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

Por ejemplo:

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

Luego agréguelo al POM así:

Una forma es subirlo a su propio administrador de repositorio Maven (como Nexus). Es una buena práctica tener un administrador de repositorio propio de todos modos.

Otra buena manera que he visto recientemente es incluir el complemento de instalación de Maven en su ciclo de vida de compilación: declara en el POM que instala los archivos en el repositorio local. Es una sobrecarga pequeña pero pequeña y no implica ningún paso manual.

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

Por supuesto, puede agregar frascos a esa carpeta. Pero tal vez no sea lo que quieres lograr ...

Si necesita estos frascos para compilar, consulte esta pregunta relacionada: ¿Puedo agregar frascos a la ruta de clase de compilación de maven 2 sin instalarlos?

Además, antes de que alguien lo sugiera, NO use el alcance del sistema.

Otro caso interesante es cuando desea tener en su proyecto jarras privadas de Maven. Es posible que desee mantener las capacidades de Maven para resolver dependencias transitivas. La solución es bastante fácil.

1. Crea una carpeta libs en tu proyecto

2. Agregue las siguientes líneas en su archivo 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. Abra la carpeta .m2 / repository y copie la estructura de directorios del proyecto que desea importar a la carpeta libs .

Por ejemplo, suponga que desea importar la dependencia

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

Simplemente vaya a .m2 / repositorio y verá la siguiente carpeta

com / mycompany / myproject / 1.2.3

Copie todo en su carpeta libs (de nuevo, incluidas las carpetas en .m2 / repositorio ) y ya está.

línea de comando :

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

Parte importante en la dependencia es: $ {pom.basedir} (en lugar de solo $ {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>

Creo que una mejor solución para este problema es usar maven-install-plugin para instalar automáticamente los archivos en el momento de la instalación. Así es como lo configuré para mi proyecto.

Primero, agregue la ruta (donde almacena los .jars locales) como una propiedad.

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

Luego, debajo de pluginsagregar un complemento para instalar los frascos al compilar.

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

Finalmente, en dependencias, puedes agregar los frascos

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

Al configurar su proyecto de esta manera, el proyecto continuará desarrollándose incluso cuando lo lleve a otra computadora (dado que tiene todos los archivos jar en la ruta especificada por la propiedad local.sdk).

por groupId usar un nombre único solo para asegurarse de que no haya conflictos.

Ahora cuando usted mvn installo mvn testlos frascos locales se agregarán automáticamente.

La forma preferida sería crear su propio repositorio remoto.

Consulte aquí para obtener detalles sobre cómo hacerlo. Eche un vistazo a la sección ' Carga en un repositorio remoto '.

Quiero compartir un código donde puedes subir una carpeta llena de tarros. Es útil cuando un proveedor no tiene un repositorio público y necesita agregar muchas bibliotecas manualmente. Decidí construir un .bat en lugar de llamar directamente a maven porque podría haber errores de falta de memoria. Fue preparado para un entorno Windows, pero es fácil adaptarlo al sistema operativo 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();
    }

}

Después de ejecutar este main desde cualquier IDE, ejecute update_repo_maven.bat.

Esta es una sintaxis corta para las versiones más nuevas:

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

Funciona cuando el JAR fue construido por Apache Maven, el caso más común. Luego contendrá un pom.xml en una subcarpeta del directorio META-INF, que se leerá de manera predeterminada.

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

También eche un vistazo a ...

<scope>compile</scope>

Dependencias de Maven . Este es el valor predeterminado, pero en algunos casos he encontrado explícitamente que ese alcance también Maven encuentre bibliotecas locales en el repositorio local.

Por alguna razón, en la aplicación web a la que le estoy dando mantenimiento, ni la solución de Alireza Fattahi ni la solución de JJ Roman funcionaron correctamente. En ambos casos, la compilación funciona bien (ve el frasco), pero el empaque no incluye el frasco dentro de la guerra.

La única forma en que pude hacerlo funcionar fue poniendo el frasco /src/main/webapp/WEB-INF/lib/y luego combinándolo con la solución de Fattahis o Roman.

Tenga en cuenta que NO es necesariamente una buena idea usar un repositorio local. Si este proyecto se comparte con otros, todos los demás tendrán problemas y preguntas cuando no funcione, ¡y el jar no estará disponible incluso en su sistema de control de fuente!

Aunque el repositorio compartido es la mejor respuesta, si no puede hacerlo por alguna razón, entonces incrustar el jar es mejor que un repositorio local. El contenido de repositorios solo local puede causar muchos problemas, especialmente con el tiempo.

En su repositorio local, puede instalar su jar emitiendo los comandos

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

Siga este enlace útil para hacer lo mismo desde el sitio web de mkyoung. También puede consultar la guía de Maven para el mismo

Para instalar jar de terceros, por favor llame al comando como a continuación

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

1. mvn install

Puede escribir el código a continuación en la línea de comando o si está utilizando eclipse builtin maven, haga clic derecho en proyecto -> Ejecutar como -> ejecutar configuraciones ... -> en el panel izquierdo, haga clic derecho en Maven Build -> nueva configuración -> escriba el código en Objetivos y en el directorio base: $ {project_loc: NameOfYourProject} -> Ejecutar

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

Donde cada uno se refiere a:

<ruta-a-archivo>: la ruta al archivo a cargar, por ejemplo -> c: \ kaptcha-2.3.jar

<group-id>: el grupo en el que el archivo debe registrarse, por ejemplo, -> com.google.code

<artifact-id>: el nombre del artefacto para el archivo, por ejemplo, -> kaptcha

<versión>: la versión del archivo, por ejemplo, -> 2.3

<packaging>: el embalaje del archivo, por ejemplo, -> jar

2. Después de instalar, solo declara jar en pom.xml.

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

Paso 1: Configure el maven-install-plugincon el objetivo install-fileen supom.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>

Asegúrese de editar la fileruta en función de su ruta de archivo real (se recomienda colocar estos frascos externos no maven dentro de alguna carpeta, digamos lib, y colocar estolib carpeta dentro de su proyecto para usar la ruta relativa específica del proyecto y evitar agregar sistema Ruta absoluta específica.

Si tiene varios frascos externos, solo repita los <execution>otros frascos dentro del mismomaven-install-plugin .

Paso 2: Una vez que haya configurado lo maven-install-pluginque se muestra arriba en su pom.xmlarchivo, debe usar estos frascos en su archivo pom.xmlhabitual:

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

Tenga en cuenta que maven-install-pluginsolo copia sus frascos externos a su local.m2 repositorio Maven. Eso es. No incluye automáticamente estos frascos como dependencias de Maven para su proyecto.

Es un punto menor, pero a veces es fácil pasarlo por alto.

Tuve el mismo error para un conjunto de dependencias en mi pom.xml, resulta que las versiones de las dependencias no se especificaron en el pom.xml y se mencionaron en el repositorio principal. Por alguna razón, los detalles de la versión no se sincronizaban con este repositorio. Por lo tanto, ingresé manualmente las versiones con la etiqueta y funcionó a las mil maravillas. Se necesita un poco de tiempo para buscar las versiones en el padre y especificar aquí. Pero esto se puede hacer solo para los frascos que muestran el error de artefacto y funciona. Espero que esto ayude a alguien.

En Apache Maven 3.5.4, tuve que agregar comillas dobles. Sin doble cita no me funcionó.

ejemplo: mvn install: install-file "-Dfile = ubicación del archivo jar" "-DgroupId = identificación del grupo" "-DartifactId = identificación del artefacto" "-Dversion = versión" "-Dpackaging = tipo de paquete"

1. Cree un directorio de repositorio local de Maven. La raíz de su proyecto debería verse así:

yourproject
+- pom.xml
+- src

2. Agregue un directorio de repositorio Maven estándar llamado repo para el grupo com.example y la versión 1.0:

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

3. Despliegue el artefacto en el repositorio, Maven puede desplegar el artefacto por usted usando el objetivo 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. instale el archivo pom correspondiente a su jar para que su proyecto pueda encontrar jar durante la compilación maven desde el repositorio local:

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

5. agregue repositorio en su archivo pom:

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

6. agrega la dependencia en tu pom:

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

ESTA RESPUESTA ES SOLO PARA USUARIOS DE ECLIPSE:

Si está utilizando Eclipse, coloque el jar en lib /, haga clic derecho en el nombre del jar y haga clic en "agregar a la ruta de compilación". Eclipse creará una "biblioteca referenciada" y colocará el jar por usted

Resolvió la importación del jar de inmediato en el programa para mí.