Como adicionar dependência de arquivo .jar local ao arquivo build.gradle?

Portanto, tentei adicionar minha dependência do arquivo .jar local ao meu arquivo 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')
} 

E você pode ver que eu adicionei os arquivos .jar na pasta referencedLibraries aqui: https://github.com/WalnutiQ/wAlnut/tree/version-2.3.1/referencedLibraries

Mas o problema é que, quando executo o comando: gradle build na linha de comando, recebo o seguinte erro:

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

Aqui está todo o meu repo: https://github.com/WalnutiQ/wAlnut/tree/version-2.3.1

Se você realmente precisar extrair esse arquivo .jar de um diretório local,

Adicione ao lado do seu módulo gradle (não é o arquivo do aplicativo gradle):

repositories {
   flatDir {
       dirs 'libs'
   }
}


dependencies {
   implementation name: 'gson-2.2.4'
}

No entanto, sendo um .jar padrão em um repositório real, por que você não tenta isso?

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

De acordo com a documentação , use um caminho relativo para uma dependência de jar local da seguinte maneira:

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

Você também pode fazer isso, incluindo todos os JARs no repositório local. Dessa forma, você não precisaria especificá-lo sempre.

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

O seguinte funciona para mim:

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

Consulte a documentação Gradle .

Você pode tentar reutilizar o repositório local do Maven para o Gradle:

• Instale o jar no seu repositório local do Maven:

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

• Verifique se o jar está instalado no ~/.m2/repositório local do Maven

• Habilite seu repositório local do Maven em seu build.gradlearquivo:

  repositories {
    mavenCentral()  
    mavenLocal()  
  }
  
  dependencies {  
    implementation ("com.company:utility:0.0.1")  
  }

  • Agora você deve ter o jar habilitado para implementação em seu projeto

A resposta aceita é boa, no entanto, eu precisaria de várias configurações de biblioteca em minha compilação Gradle de vários projetos para usar a mesma biblioteca Java de terceiros.

Adicionar ' $ rootProject.projectDir ' ao elemento do caminho ' dir ' dentro do meu fechamento ' allprojects ' significava que cada subprojeto referenciava o mesmo diretório ' libs ' e não uma versão local para esse subprojeto:

//gradle.build snippet
allprojects {
    ...

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

    ...
}

EDIT pelo Quizzie: alterado "$ {rootProject.projectDir}" para "$ rootProject.projectDir" (funciona na versão mais recente do Gradle).

Uma maneira simples de fazer isso é

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

ele compilará todos os arquivos .jar no diretório libs no aplicativo.

Uma solução para quem usa DSL Kotlin

As soluções adicionadas até agora são ótimas para o OP, mas não podem ser usadas com o Kotlin DSL sem antes traduzi-las. Aqui está um exemplo de como adicionei um .JAR local ao meu build usando o Kotlin DSL:

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

Lembre-se de que, se você estiver usando o Windows, suas barras invertidas precisarão ser escapadas:

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

E lembre-se também de que as aspas devem ser aspas duplas, não aspas simples.

Editar para 2020:

As atualizações do Gradle foram preteridas compilee a testCompilefavor de implementatione testImplementation. Portanto, o bloco de dependência acima ficaria assim nas versões atuais do Gradle:

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

Não foi possível obter a sugestão acima em https://stackoverflow.com/a/20956456/1019307 para funcionar. Isso funcionou para mim embora. Para um arquivo secondstring-20030401.jarque eu armazenei em um libs/diretório na raiz do projeto:

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'

A pergunta já foi respondida em detalhes. Eu ainda quero adicionar algo que me parece muito surpreendente:

A tarefa "gradle dependencies" não lista nenhuma dependência de arquivo. Mesmo que você pense assim, eles foram especificados no bloco "dependências".

Portanto, não confie na saída disso para verificar se os arquivos lib locais referenciados estão funcionando corretamente.

A solução que funcionou para mim é o uso de fileTree no arquivo build.gradle. Mantenha o .jar que precisa adicionar como dependência na pasta libs. O código abaixo é fornecido no bloco dependenices em build.gradle:

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

A melhor maneira de fazer isso é adicioná-lo ao seu arquivo build.gradle e clicar na opção sync

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

Você pode adicionar jar fazendo:

Para gradle basta colocar o seguinte código em build.gradle:

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

e para maven basta seguir os passos:

Para Intellij: Arquivo-> estrutura do projeto-> módulos-> guia dependência-> clique em + sinal-> jar e dependência-> selecione os frascos que deseja importar-> ok-> aplique (se visível) -> ok

Lembre-se de que, se você tiver alguma java.lang.NoClassDefFoundError: Could not initialize classexceção no tempo de execução, isso significa que as dependências no jar não estão instaladas e você precisará adicionar todas as dependências no projeto pai.

Saltar Arquivo -> Estrutura do Projeto -> Módulos -> Aplicativo -> Guia Dependências -> Clique em + (botão) -> Selecionar Dependência do Arquivo -> Selecionar arquivo jar na pasta lib

Esta etapa adicionará automaticamente sua dependência ao gralde

Muito simples

Tenha cuidado se estiver usando integração contínua, você deve adicionar suas bibliotecas no mesmo caminho no servidor de construção.

Por esse motivo, prefiro adicionar jar ao repositório local e, é claro, fazer o mesmo no servidor de compilação.

Outra maneira:

Adicione biblioteca na exibição em árvore. Clique com o botão direito neste. Selecione o menu "Adicionar como biblioteca". Uma caixa de diálogo é exibida, permitindo selecionar o módulo. OK e está feito.