Maven: ¿la mejor manera de vincular JAR externo personalizado a mi proyecto?

Son mis primeros días aprendiendo Maven y todavía estoy luchando con lo básico. Tengo un archivo .jar externo (no disponible en los repositorios públicos) al que necesito hacer referencia en mi proyecto y estoy tratando de descubrir cuál es mi mejor opción.

Es un proyecto a pequeña escala sin un repositorio central para bibliotecas, por lo que tiene que ser un repositorio local (de alguna manera agregado al control de origen, ¿no sabe si se supone que funciona de esa manera?) O el .jar debe almacenarse en disco fuera de cualquier repositorio formal.

1) ¿Cuál es mi mejor opción para agregar el archivo .jar a las referencias de mi proyecto con maven dado que quiero que tanto el proyecto como la biblioteca estén en control de la fuente?

2) Todavía parece que Eclipse no puede ver la dependencia. Lo agregué manualmente a la sección del pom, y se muestra bien en la lista de Dependencias en m2eclipse. La compilación mvn y el paquete mvn tienen éxito, pero la ejecución del programa da como resultado:

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
        LibraryStuff cannot be resolved to a type

Esto es después de editar el POM como:

<dependency>
  <groupId>stuff</groupId>
  <artifactId>library</artifactId>
  <version>1.0</version>
  <systemPath>${lib.location}/MyLibrary.jar</systemPath>
  <scope>system</scope>
</dependency>

¿Debería ejecutar mvn install: install-file, incluso si ya tengo el pom.xml editado como se indica arriba?

¡Gracias!

Creo que debería usar mvn install:install-filepara llenar su repositorio local con los tarros de la biblioteca, luego debería cambiar el alcance del sistema para compilar.

Si está comenzando con maven, le sugiero usar maven directamente, no complementos IDE, ya que agrega una capa adicional de complejidad.

En cuanto al error, ¿pones los frascos necesarios en tu classpath? Si está utilizando tipos de la biblioteca, también debe tener acceso a él en tiempo de ejecución. Esto no tiene nada que ver con el propio Maven.

No entiendo por qué quieres poner la biblioteca en control de origen: es para código fuente, no para jarras binarias.

Puede crear un repositorio en el proyecto, para que no tenga que hacerlo run mvn install:install-filecada vez que trabaje en una computadora nueva

<repository>
    <id>in-project</id>
    <name>In Project Repo</name>
    <url>file://${project.basedir}/libs</url>
</repository>

<dependency>
    <groupId>dropbox</groupId>
    <artifactId>dropbox-sdk</artifactId>
    <version>1.3.1</version>
</dependency>

/groupId/artifactId/version/artifactId-verion.jar

detalle lea esta publicación de blog

https://web.archive.org/web/20121026021311/charlie.cu.cc/2012/06/how-add-external-libraries-maven

Esto se puede lograr fácilmente utilizando el elemento <scope> anidado dentro del elemento <dependency>.

Por ejemplo:

 <dependencies>
   <dependency>
     <groupId>ldapjdk</groupId>
     <artifactId>ldapjdk</artifactId>
     <scope>system</scope>
     <version>1.0</version>
     <systemPath>${basedir}\src\lib\ldapjdk.jar</systemPath>
   </dependency>
 </dependencies>

Referencia: http://www.tutorialspoint.com/maven/maven_external_dependencies.htm

El manual de Maven dice hacer esto:

mvn install:install-file -Dfile=non-maven-proj.jar -DgroupId=some.group -DartifactId=non-maven-proj -Dversion=1 -Dpackaging=jar

Actualización Desde entonces, acabamos de instalar nuestro propio servidor Nexus, mucho más fácil y limpio.

En nuestra empresa teníamos algunos frascos que teníamos frascos que eran comunes pero que no estaban alojados en ningún repositorio Maven, ni queríamos tenerlos en el almacenamiento local. Creamos un repositorio mvn (público) muy simple en Github (pero puede alojarlo en cualquier servidor o localmente):
tenga en cuenta que esto solo es ideal para administrar algunos archivos jar raramente cambiantes

1. Crear repositorio en GitHub:
   https://github.com/<user_name>/mvn-repo/

2. Agregar repositorio en pom.xml
   (Tenga en cuenta que el archivo sin formato de la ruta completa será un poco diferente al nombre del repositorio)
   

   <repository>
       <id>project-common</id>
       <name>Project Common</name>
       <url>https://github.com/<user_name>/mvn-repo/raw/master/</url>
   </repository>

3. Agregar dependencia al host (Github o servidor privado)
   a. Todo lo que necesita saber es que los archivos se almacenan en el patrón mencionado por @glitch
   /groupId/artifactId/version/artifactId-version.jar
   b. En su host, cree las carpetas para que coincidan con este patrón.
   es decir, si tiene un archivo jar llamado service-sdk-0.0.1.jar, cree la carpeta service-sdk/service-sdk/0.0.1/y coloque el archivo jar service-sdk-0.0.1.jaren él.
   C. Pruébelo intentando descargar el jar desde un navegador (en nuestro caso:https://github.com/<user_name>/mvn-repo/raw/master/service-sdk/service-sdk/0.0.1/service-sdk-0.0.1.jar
   

4. Agregue dependencia a su archivo pom.xml:
   

   <dependency>
       <groupId>service-sdk</groupId>
       <artifactId>service-sdk</artifactId>
       <version>0.0.1</version>
   </dependency>

5. Disfrutar

No uses systemPath. Al contrario de lo que la gente ha dicho aquí, puede colocar un jar externo en una carpeta debajo de su directorio de proyecto desprotegido y hacer que Maven lo encuentre como otras dependencias. Aquí hay dos pasos cruciales:

1. Utilice "mvn install: install-file" con -DlocalRepositoryPath.
2. Configure un repositorio para apuntar a esa ruta en su POM.

Es bastante sencillo y puede encontrar un ejemplo paso a paso aquí: http://randomizedsort.blogspot.com/2011/10/configuring-maven-to-use-local-library.html

Manera Maven de agregar frascos no Maven al proyecto Maven

Proyecto Maven y jarras no Maven

Agregue los complementos de instalación de Maven en su sección de compilación

<plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-install-plugin</artifactId>
        <version>${version.maven-install-plugin}</version>
        <executions>

            <execution>
                <id>install-external-non-maven1-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar1.group</groupId>
                    <artifactId>non-maven1</artifactId>
                    <version>${version.non-maven1}</version>
                    <file>${project.basedir}/libs/non-maven1.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
            <execution>
                <id>install-external-non-maven2-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar2.group</groupId>
                    <artifactId>non-maven2</artifactId>
                    <version>${version.non-maven2}</version>
                    <file>${project.basedir}/libs/non-maven2.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
            <execution>
                <id>install-external-non-maven3-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar3.group</groupId>
                    <artifactId>non-maven3</artifactId>
                    <version>${version.non-maven3}</version>
                    <file>${project.basedir}/libs/non-maven3.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
        </executions>
    </plugin>

Agregar la dependencia

<dependencies>
    <dependency>
        <groupId>jar1.group</groupId>
        <artifactId>non-maven1</artifactId>
        <version>${version.non-maven1}</version>
    </dependency>
    <dependency>
        <groupId>jar2.group</groupId>
        <artifactId>non-maven2</artifactId>
        <version>${version.non-maven2}</version>
    </dependency>
    <dependency>
        <groupId>jar3.group</groupId>
        <artifactId>non-maven3</artifactId>
        <version>${version.non-maven3}</version>
    </dependency>
</dependencies>

Referencias Nota Soy el propietario del blog.

Si encuentra el mismo problema y está utilizando spring-boot v1.4 + , puede hacerlo de esta manera.

Hay un includeSystemScope que puede usar para agregar dependencias del alcance del sistema al jar.

p.ej

Estoy usando el controlador Oracle en mi proyecto.

<dependency>
        <groupId>com.oracle</groupId>
        <artifactId>ojdbc14</artifactId>
        <version>10.2.0.3.0</version>
        <scope>system</scope>
        <systemPath>${project.basedir}/src/main/resources/extra-jars/ojdbc14-10.2.0.3.0.jar</systemPath>
    </dependency>

luego haga includeSystemScope = true para incluir el jar en la ruta / BOOT-INF / lib / **

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <includeSystemScope>true</includeSystemScope>
    </configuration>
</plugin>

y excluir del recurso para evitar la inclusión duplicada, el frasco es lo suficientemente gordo ~

<build>
    <testSourceDirectory>src/test/java</testSourceDirectory>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <excludes>
                <exclude>**/*.jar</exclude>
            </excludes>
        </resource>
    </resources>
</build>

¡Buena suerte!

Cambia tu ruta del sistema .

<dependency>
  <groupId>stuff</groupId>
  <artifactId>library</artifactId>
  <version>1.0</version>
  <systemPath>${project.basedir}/MyLibrary.jar</systemPath>
  <scope>system</scope>
</dependency>

El pom.xml buscará en su repositorio local para tratar de encontrar la dependencia que coincida con su artefacto. Además, en realidad no debería usar el alcance del sistema o los atributos de systemPath, estos normalmente están reservados para cosas que están en el JDK y no en el JRE

Consulte esta pregunta para saber cómo instalar artefactos maven.

Tenga en cuenta que todos los ejemplos que usan

<repository>...</respository> 

requiere exterior

<repositories>...</repositories> 

etiquetas adjuntas. No está claro en algunos de los ejemplos.

La mejor solución aquí es instalar un repositorio: Nexus o Artifactory. Si te da un lugar para colocar cosas como esta, y además acelera las cosas almacenando en caché tus cosas desde el exterior.

Si lo que está tratando es de código abierto, también puede considerar ponerlo en el centro.

Ver la guía .

Con Eclipse Oxygen puede hacer las siguientes cosas:

1. Coloque sus bibliotecas en WEB-INF / lib
2. Proyecto -> Configurar ruta de compilación -> Agregar biblioteca -> Biblioteca de aplicaciones web

Maven los tomará al instalar el proyecto.

Si el jar externo es creado por un proyecto de Maven solamente, entonces puede copiar todo el proyecto en su sistema y ejecutar un

mvn install

en el directorio del proyecto. Esto agregará el jar al directorio .m2 que es el repositorio local de Maven.

Ahora puedes agregar el

<dependency>
     <groupId>copy-from-the=maven-pom-of-existing-project</groupId>
     <artifactId>copy-from-the=maven-pom-of-existing-project</artifactId>
     <version>copy-from-the=maven-pom-of-existing-project</version>
</dependency>

Esto asegurará que usted

mvn exec:java 

trabajos. Si usa sugerido aquí

<scope>system</scope>

Luego tendrá que agregar clases individualmente mientras usa la ejecución a través de la línea de comando.

Puede agregar los frascos externos con el siguiente comando que se describe aquí

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

La forma más eficiente y limpia de resolver este problema es mediante el uso de paquetes Github

1. Cree un repositorio público / privado vacío simple en GitHub según sus requisitos, ya sea que desee que su jar externo se aloje públicamente o no.

2. Ejecute debajo del comando maven para desplegar su jar externo en el repositorio github creado anteriormente

   mvn deploy:deploy-file \ -DgroupId= your-group-id \ -DartifactId= your-artifact-id \ -Dversion= 1.0.0 -Dpackaging= jar -Dfile= path-to-file \ -DrepositoryId= id-to-map-on-server-section-of-settings.xml \ -Durl=https://maven.pkg.github.com/github-username/github-reponame-created-in-above-step

   El comando anterior desplegará tu jar externo en el repositorio de GitHub mencionado en -Durl=. Puede consultar este enlace en Cómo implementar dependencias como paquetes de GitHub Tutorial de implementación de paquetes de GitHub

3. Después de eso, puede agregar la dependencia usando groupId, artifactIdy versionmencionado en el paso anterior en maven pom.xmly ejecutarmvn install

4. Maven buscará la dependencia del jar externo del registro de paquetes GitHub y lo proporcionará en su proyecto maven.

5. Para que esto funcione, también necesitará configurar sus maven's settings.xmlpara que se obtengan del registro del paquete GitHub.