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

608

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

Wang-Zhao-Liu, QM
fonte
Você tem certeza sobre o tempo de execução em vez de compilar? compilar arquivos (....)
Gabriele Mariotti
3
parece que é uma dependência de compilação se o jar não puder ser construído. try: compile arquivos ('libs / mnist-tools.jar', 'libs / gson-2.2.4.jar') se você ainda tiver um problema, tente os caminhos absolutos porque também podem ser um problema.
patrz jaka franca
1
Esta questão do Stack Overflow finalmente me deu a resposta que eu precisava.
craned 16/10

Respostas:

456

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'
}
Jorge_B
fonte
4
Eu vim procurando exatamente isso, mas descobri que meu repositório local não resolve dependências transitivas. (Gradle 2.7, o POM de exemplo é com.mojang: authlib: 1.5.21 conforme extraído por minecraftforge.net)
Karl the Pagan
1
Se você tiver arquivos jar locais em vários diretórios, precisará adicionar todos eles ao flatDir. Ex: - flatDir {dirs 'libs1', 'libs2', 'libs3'}
Dhumil Agarwal
9
Estou tendo um gradle.buildarquivo - O que são esses "arquivos de classificação do aplicativo" e "módulo de classificação"?
Lealo 10/10
2
Alguma chance de alguém atualizar a resposta com um link para a seção de documentação oficial da Gradle que descreve esses recursos?
misantropo
2
implementation(":gson:2.2.4")parece ser o caminho para fazê-lo.
Eng.Fouad
697

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')
}
leeor
fonte
8
@Gubatron está documentado agora: gradle.org/docs/current/userguide/…
David Moles
7
só queria acrescentar que para aqueles que estão usando caminhos relativos ao nosso jar: dependências {arquivos de compilação ("libs / something_local.jar"} (ou seja, aspas duplas e não aspas simples) são necessários pelo Groovy para avaliar o caminho. citações são tomadas literalmente em Groovy.
specialk1st
Então, eu estou usando a mesma coisa e recebo um erro de compilação (parece que ele não encontra o jar lá.) Se eu der o caminho absoluto, ele funcionará bem.
RV_Dev
Eu preferiria esta solução, mas descobri que, se o arquivo não existir, nenhum erro será gerado pelo Gradle. Eu descobri isso pessoalmente, Veja esta questão SO para mais detalhes: stackoverflow.com/q/42527631/4851565
entpnerd
Eu estava recebendo um erro semelhante, mesmo depois de usar esta solução. Erro que eu fiz colocar libs pasta em aplicativos não no mesmo nível que aplicativos
Rishabh Dugar
315

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'])
}
Lobo da noite
fonte
3
Isso é usado para compilar todos os jars no diretório lib. É a solução perfeita (y)
Sheraz Ahmad Khilji
1
... a menos que você planeje compartilhar esse diretório libs com diferentes módulos com diferentes conjuntos de dependências, como não inserir código do servidor no código do cliente ou ter mais de uma versão de uma dependência em um submódulo diferente.
Ajax
Esta é a minha implementação preferida sobre a resposta aceita, porque indica explicitamente o local dos arquivos. É útil quando você se refere a um repositório como o mavenCentral para algumas bibliotecas e cópias locais para outros. Nesse caso, pode haver um atraso enquanto o gradle pesquisa as bibliotecas locais nos outros repositórios.
Satbot # 11/17
1
Observe que dir também pode ser um caminho absoluto. Além disso, em vez de 'incluir', tive que usar 'inclui'.
Eriel marimon
53

O seguinte funciona para mim:

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

Consulte a documentação Gradle .

Misha
fonte
6
brilhante resposta, a única solução que funcionou para mim depois de procurar por dias
Stardust
É importante lembrar que esse método é necessário. Se você não deseja que uma biblioteca específica seja compilada com o seu projeto, lembre-se de excluí-la da pasta libs ... não gosto desse método porque não vejo qual biblioteca adicionado, a menos que eu entre na biblioteca
Jesus Dimrix 19/09/17
1
Como isso é diferente da resposta do @ Nightwolf?
Trenton
2
Não foi possível encontrar o método compile () para argumentos [diretório 'libs'] no objeto do tipo org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler
ieXcept
33

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
Daniel Mora
fonte
Este me ajudou quando tudo mais falhou!
precisa
Enquanto isso funciona, esta é uma solução alternativa e não deve ser usada no ambiente de produção / estágio automatizado, pois isso adiciona uma dependência adicional de ter uma pasta .m2 (instalação maven) no sistema de construção.
Saurav.varma
29

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

Big Rich
fonte
2
mas como consultar esta pasta libs no arquivo build.gradle da biblioteca? Qualquer ajuda nisso.
jeevs
1
Apenas mude "$ {rootProject.projectDir}" para "$ rootProject.projectDir" para fazê-lo funcionar novamente.
Quizzie
4
Certifique-se de usar aspas duplas em vez de aspas simples, pois estas não serão interpoladas.
FP livremente
1
Essa abordagem me ajudou.
Shreyash
1
Todas as respostas aqui me ajudaram muito. Esse padrão é o que estamos usando e facilita para as pessoas que trabalham em equipes simplesmente soltar JARs nesse diretório ao trabalhar em ramificações.
Lucy
12

Uma maneira simples de fazer isso é

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

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

ZygoteInit
fonte
O fileTree funciona para todos os subdiretórios da pasta libs. Exemplo de alguns jars dentro de libs / sping / spring.jar; nesse caso, inclui também o .jar de primavera?
mgr
Não, não faz. Tecnicamente, não deveria, pois estamos dando aos diretórios 'dir: libs' não subdiretórios de libs.
ZygoteInit
Neste caso como obter todas as bibliotecas dos subdiretórios com tarefas mínimas (porque o nosso projeto contém tantas subdiretórios.
mgr
Hey @mallikgm pena de resposta tardia, pois não tentei adicionar curinga no dir caminho como filetree compilação (incluem: [ ' dir .jar'],: 'libs ')
ZygoteInit
2
Como isso é diferente da resposta do @ Nightwolf?
Trenton
12

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")
}
Jonathan Landrum
fonte
1
+1 funcionou para mim! Você sabe como fazer o mesmo sem precisar produzir o arquivo jar (no caso de eu produzir o jar)?
Kareem Jeiroudi
2
@KareemJeiroudi Posso estar entendendo mal a sua pergunta, mas se você está falando sobre tornar um módulo uma dependência do projeto, você faria algo assim: compile(project(":MyProject"))onde "MyProject" é definido no seu settings.gradlearquivo com algo parecido include("MyProject").
Jonathan Landrum
8

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'
HankCa
fonte
obrigado! não faço ideia do porquê, mas apenas isso funcionou para mim. criei uma pasta 'libs' na raiz do meu projeto, empurrou o .jar e copiei a entrada 'nome da compilação'. Também caiu a extensão .jar, é claro.
anon58192932
Não, isso não funciona comigo Não foi possível encontrar: miglayout-core :. Pesquisado nos seguintes locais: file: /user/path/to/miglayout-core.jar
Well Smith
este trabalho se você quiser adicionar um diretório de arquivos como repositório: docs.gradle.org/current/userguide/…
Grubhart
7

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.

icyerasor
fonte
6

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'])
}
Jince Martin
fonte
5

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

dependency{
    compile files('path.jar')
}
saunlogan
fonte
3

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.

ankit
fonte
0

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

Jaya
fonte
3
Esse é um caminho através de alguns menus do Java IDE? Provavelmente idéia?
Utgarda
1
Sim, isso parece algo para o IntelliJ IDEA, e não acho que funcione. Ou, parece que está funcionando até que seja feita uma alteração na configuração do Gradle que resulta em uma "sincronização" sendo executada, e a sincronização é unidirecional do Gradle para as configurações do IntelliJ. Não sincroniza de outra maneira - pelo menos acho que não.
RenniePet
1
Se você tiver selecionado a importação automática, o .JAR importado manualmente será removido na próxima alteração para build.gradle.
Jonathan Landrum
-1

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.

Akostha
fonte
-3

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.

YannXplorer
fonte