¿Cómo agregar dependencia de archivo .jar local al archivo build.gradle?


608

Así que intenté agregar mi dependencia de archivo .jar local a mi archivo build.gradle:

apply plugin: 'java'

sourceSets {
    main {
        java {
            srcDir 'src/model'
        }
    }
}

dependencies {
    runtime files('libs/mnist-tools.jar', 'libs/gson-2.2.4.jar')
    runtime fileTree(dir: 'libs', include: '*.jar')
} 

Y puede ver que agregué los archivos .jar en la carpeta Bibliotecas referenciadas aquí: https://github.com/WalnutiQ/wAlnut/tree/version-2.3.1/referencedLibraries

Pero el problema es que cuando ejecuto el comando: gradle build en la línea de comando aparece el siguiente error:

error: package com.google.gson does not exist
import com.google.gson.Gson;

Aquí está mi repositorio completo: https://github.com/WalnutiQ/wAlnut/tree/version-2.3.1


¿Estás seguro de tiempo de ejecución en lugar de compilar? compilar archivos (....)
Gabriele Mariotti

3
parece que es una dependencia de compilación si no se puede construir jar. intente: compile archivos ('libs / mnist-tools.jar', 'libs / gson-2.2.4.jar') si aún tiene un problema, intente absolver rutas porque también podría ser un problema.
patrz jaka franca

1
Esta pregunta de desbordamiento de pila finalmente me dio la respuesta que necesitaba.
Craned

Respuestas:


456

Si realmente necesita tomar ese .jar de un directorio local,

Agregue al lado de su módulo gradle (No el archivo gradle de la aplicación):

repositories {
   flatDir {
       dirs 'libs'
   }
}


dependencies {
   implementation name: 'gson-2.2.4'
}

Sin embargo, al ser un .jar estándar en un repositorio real de Maven, ¿por qué no intentas esto?

repositories {
   mavenCentral()
}
dependencies {
   implementation 'com.google.code.gson:gson:2.2.4'
}

44
Vine buscando exactamente esto, pero descubrí que mi repositorio local no resuelve dependencias transitivas. (Gradle 2.7, ejemplo POM es com.mojang: authlib: 1.5.21 como extraído por minecraftforge.net)
Karl the Pagan

1
Si tiene archivos jar locales en varios directorios, debe agregarlos a flatDir. Ej: - flatDir {dirs 'libs1', 'libs2', 'libs3'}
Dhumil Agarwal

99
Tengo un gradle.buildarchivo: ¿qué es este "archivo de aplicación gradle" y el "módulo gradle"?
Lealo

2
¿Hay alguna posibilidad de que alguien actualice la respuesta con un enlace a la sección de documentación oficial de Gradle que describe estas características?
misanthrope

2
implementation(":gson:2.2.4")Parece ser la forma de hacerlo.
Eng.Fouad

697

De acuerdo con la documentación , use una ruta relativa para una dependencia jar local de la siguiente manera:

dependencies {
    implementation files('libs/something_local.jar')
}

8
@Gubatron está documentado ahora: gradle.org/docs/current/userguide/…
David Moles

77
solo quería agregar eso para aquellos que están usando rutas relativas a nuestro jar: las dependencias {compilar archivos ("libs / something_local.jar"} (es decir, comillas dobles, no comillas simples) son necesarias para que Groovy evalúe la ruta. las citas se toman literalmente en Groovy.
specialk1st

Así que estoy usando lo mismo y obtengo un error de compilación (parece que no encuentra el jar allí). Si doy la ruta absoluta, funciona bien.
RV_Dev

Preferiría esta solución, pero he descubierto que si el archivo no existe, Gradle no genera ningún error. He encontrado esto personalmente. Consulte esta pregunta SO para obtener más detalles: stackoverflow.com/q/42527631/4851565
entpnerd

Estaba recibiendo un error similar incluso después de usar esta solución. Error, puse la carpeta libs debajo de las aplicaciones que no están en el mismo nivel que las aplicaciones
Rishabh Dugar

315

También puede hacer esto que incluiría todos los JAR en el repositorio local. De esta manera, no tendría que especificarlo cada vez.

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

3
Esto se utiliza para compilar todos los archivos jar en el directorio lib. Es la solución perfecta (y)
Sheraz Ahmad Khilji

1
... a menos que planee compartir ese directorio libs con diferentes módulos que tengan diferentes conjuntos de dependencias, como no poner el código del servidor con el código del cliente o tener más de una versión de una dependencia en un submódulo diferente.
Ajax

Esta es mi implementación preferida sobre la respuesta aceptada porque indica explícitamente la ubicación de los archivos. Es útil cuando se refiere a un repositorio como mavenCentral para algunas bibliotecas y copias locales para otras. En ese caso, puede haber un retraso mientras Gradle busca las bibliotecas locales en los otros repositorios.
satbot

1
Tenga en cuenta que dir también puede ser una ruta absoluta. También en lugar de 'incluir' tuve que usar 'incluye'.
eriel marimon

53

Lo siguiente funciona para mí:

compile fileTree(dir: 'libs', include: '*.jar')

Consulte la documentación de Gradle .


66
respuesta brillante, la única solución que funcionó para mí después de buscar durante días
Stardust

es importante recordar que es este método si no desea que una biblioteca específica se compile con su proyecto, deberá recordar eliminarlo de la carpeta libs ... No me gusta este método porque no veo qué biblioteca agregado a menos que entre a la biblioteca
Jesus Dimrix

1
¿Cómo es esto diferente a la respuesta de @ Nightwolf?
Trenton

2
No se pudo encontrar el método compile () para argumentos [directorio 'libs'] en el objeto de tipo org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler
decir

33

Puede intentar reutilizar su repositorio local de Maven para Gradle:

  • Instale el jar en su repositorio local de Maven:

    mvn install:install-file -Dfile=utility.jar -DgroupId=com.company -DartifactId=utility -Dversion=0.0.1 -Dpackaging=jar

  • Comprueba que tienes el jar instalado en tu ~/.m2/repositorio local de Maven

  • Habilite su repositorio local de Maven en su build.gradlearchivo:

    repositories {
      mavenCentral()  
      mavenLocal()  
    }
    
    dependencies {  
      implementation ("com.company:utility:0.0.1")  
    }
    • Ahora debería tener el jar habilitado para la implementación en su proyecto

¡Este me ayudó cuando todo lo demás falló!
Usuario3

Si bien esto funciona, es una solución alternativa y no debe usarse en un entorno de producción / etapa automatizado, ya que esto agrega una dependencia adicional de tener una carpeta .m2 (instalación de Maven) en el sistema de compilación.
saurav.varma

29

La respuesta aceptada es buena, sin embargo, habría necesitado varias configuraciones de biblioteca dentro de mi compilación de Gradle multiproyecto para usar la misma biblioteca Java de terceros.

Agregar ' $ rootProject.projectDir ' al elemento de ruta ' dir ' dentro de mi cierre ' allprojects ' significaba que cada subproyecto hacía referencia al mismo directorio ' libs ', y no a una versión local de ese subproyecto:

//gradle.build snippet
allprojects {
    ...

    repositories {
        //All sub-projects will now refer to the same 'libs' directory
        flatDir {
            dirs "$rootProject.projectDir/libs"
        }
        mavenCentral()
    }

    ...
}

EDITAR por Quizzie: cambió "$ {rootProject.projectDir}" a "$ rootProject.projectDir" (funciona en la versión más reciente de Gradle).


2
¿pero cómo referir esta carpeta libs en el archivo de la biblioteca build.gradle? Cualquier ayuda en eso.
jeevs

1
Simplemente cambie "$ {rootProject.projectDir}" a "$ rootProject.projectDir" para que vuelva a funcionar.
Quizzie

44
Asegúrese de utilizar comillas dobles en lugar de comillas simples, ya que estas últimas no se interpolarán.
FP libremente

1
Este enfoque me ayudó.
Shreyash

1
Todas las respuestas aquí me ayudaron mucho. Este patrón es uno que estamos usando y facilita a las personas que trabajan en equipos simplemente colocar JAR en ese directorio cuando trabajan en sucursales.
Lucy

13

Una solución para quienes usan Kotlin DSL

Las soluciones agregadas hasta ahora son excelentes para el OP, pero no se pueden usar con Kotlin DSL sin antes traducirlas. Aquí hay un ejemplo de cómo agregué un .JAR local a mi compilación usando Kotlin DSL:

dependencies {
    compile(files("/path/to/file.jar"))
    testCompile(files("/path/to/file.jar"))
    testCompile("junit", "junit", "4.12")
}

Recuerde que si está utilizando Windows, sus barras invertidas tendrán que escapar:

...
compile(files("C:\\path\\to\\file.jar"))
...

Y también recuerde que las comillas deben ser comillas dobles, no comillas simples.


Editar para 2020:

Las actualizaciones de Gradle han quedado obsoletas compiley están testCompilea favor de implementationy testImplementation. Entonces, el bloque de dependencia anterior se vería así para las versiones actuales de Gradle:

dependencies {
    implementation(files("/path/to/file.jar"))
    testImplementation(files("/path/to/file.jar"))
    testImplementation("junit", "junit", "4.12")
}

1
¡+1 funcionó para mí! ¿Sabes cómo hacer lo mismo sin tener que producir el archivo jar (en caso de que yo produzca el jar)?
Kareem Jeiroudi

2
@KareemJeiroudi Puedo estar malinterpretando su pregunta, pero si está hablando de hacer que un módulo sea una dependencia del proyecto, haría algo como esto: compile(project(":MyProject"))donde "MyProject" se define en su settings.gradlearchivo con algo así include("MyProject").
Jonathan Landrum

12

Una manera simple de hacer esto es

compile fileTree(include: ['*.jar'], dir: 'libs')

compilará todos los archivos .jar en su directorio libs en la aplicación.


Es fileTree funciona para todos los subdirectorios en la carpeta libs. Ejemplo, algunos frascos dentro de libs / sping / spring.jar, en este caso, ¿incluye también el spring .jar?
mgr

No lo hace Técnicamente no debería ser así, ya que estamos dando 'dir: libs' no subdirectorios de libs.
ZygoteInit

En este caso, cómo obtener todas las bibliotecas de los subdirectorios con tareas mínimas (porque nuestro proyecto contiene tantos subdirectorios.
mgr

Hola @mallikgm, perdón por la respuesta tardía, ¿intentaste agregar comodines en la ruta de directorio como compilar fileTree (incluye: [' .jar'], dir: 'libs ')
ZygoteInit

2
¿Cómo es esto diferente a la respuesta de @ Nightwolf?
Trenton

8

No pude obtener la sugerencia anterior en https://stackoverflow.com/a/20956456/1019307 para que funcione. Sin embargo, esto funcionó para mí. Para un archivo secondstring-20030401.jarque almacené en un libs/directorio en la raíz del proyecto:

repositories {
    mavenCentral()
    // Not everything is available in a Maven/Gradle repository.  Use a local 'libs/' directory for these.
    flatDir {
       dirs 'libs'
   }
}

...

compile name: 'secondstring-20030401'

¡gracias! No tengo idea de por qué, pero solo esto funcionó para mí. hice una carpeta 'libs' en la raíz de mi proyecto, metí el .jar allí y copié la entrada de 'nombre de compilación'. Eliminó la extensión .jar también, por supuesto.
anon58192932

No, esto no me funciona No se pudo encontrar: miglayout-core :. Buscado en las siguientes ubicaciones: archivo: /user/path/to/miglayout-core.jar
Well Smith

esto funciona si desea agregar un directorio de archivos como repositorio: docs.gradle.org/current/userguide/…
Grubhart

7

La pregunta ya ha sido respondida en detalle. Todavía quiero agregar algo que me parece muy sorprendente:

La tarea "dependencias de gradle" no enumera ninguna dependencia de archivo. Aunque pueda pensarlo, ya que se han especificado en el bloque "dependencias" después de todo ...

Por lo tanto, no confíe en el resultado de esto para verificar si sus archivos lib locales referenciados funcionan correctamente.


6

La solución que funcionó para mí es el uso de fileTree en el archivo build.gradle. Mantenga el .jar que necesita agregar como dependencia en la carpeta libs. El código siguiente en el bloque de dependencias en build.gradle:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

5

La mejor manera de hacerlo es agregar esto en su archivo build.gradle y presionar la opción de sincronización

dependency{
    compile files('path.jar')
}

3

Puedes agregar jar haciendo:

Para gradle simplemente ponga el siguiente código en build.gradle:

dependencies {
...
compile fileTree(dir: 'lib', includes: ['suitetalk-*0.jar'])
...
}

y para maven solo sigue los pasos:

Para Intellij: Archivo-> estructura del proyecto-> módulos-> pestaña de dependencia-> haga clic en + signo-> jar y dependencia-> seleccione los frascos que desea importar-> ok-> aplicar (si está visible) -> ok

Recuerde que si tiene alguna java.lang.NoClassDefFoundError: Could not initialize classexcepción en el tiempo de ejecución, esto significa que las dependencias en jar no están instaladas, por lo que debe agregar todas las dependencias en el proyecto principal.


0

Ir a archivo -> Estructura del proyecto -> Módulos -> aplicación -> Pestaña Dependencias -> Haga clic en + (botón) -> Seleccionar dependencia de archivo -> Seleccionar archivo jar en la carpeta lib

Estos pasos agregarán automáticamente su dependencia a gralde

Muy simple


3
¿Es esa una ruta a través de algunos menús IDE de Java? Probablemente idea?
Utgarda

1
Sí, eso parece algo para IntelliJ IDEA, y no creo que funcione. O parecerá que funciona hasta que se realice un cambio en la configuración de Gradle que resulte en una "sincronización", y la sincronización sea unidireccional desde Gradle a la configuración de IntelliJ. No se sincroniza a la inversa, al menos no lo creo.
RenniePet

1
Si tiene seleccionada la importación automática, el .JAR importado manualmente se eliminará en el próximo cambio a build.gradle.
Jonathan Landrum

-1

Tenga cuidado si está utilizando la integración continua, debe agregar sus bibliotecas en la misma ruta en su servidor de compilación.

Por esta razón, prefiero agregar jar al repositorio local y, por supuesto, hacer lo mismo en el servidor de compilación.


-3

De otra manera:

Agregar biblioteca en la vista de árbol. Haga clic derecho sobre este. Seleccione el menú "Agregar como biblioteca". Aparece un cuadro de diálogo, le permite seleccionar el módulo. OK y ya está hecho.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.