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

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

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

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')
}

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'])
}

Lo siguiente funciona para mí:

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

Consulte la documentación de Gradle .

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

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

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")
}

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.

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'

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.

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'])
}

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')
}

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.

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

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.

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.