library Android Studio: Adicionar jar como biblioteca?




retrofit android doc (24)

Eu estou tentando usar o novo Android Studio, mas não consigo fazê-lo funcionar corretamente.

Estou usando a biblioteca Gson para serializar / desserializar objetos JSON. Mas a biblioteca de alguma forma não está incluída na compilação.

Eu criei um novo projeto com apenas uma MainActivity . Copiei o gson-2.2.3.jar na pasta / libs e incluí- lo como uma dependência de biblioteca (clique direito-> Adicionar como biblioteca). Isso inclui o jar no android studio para que ele possa ser referenciado nos arquivos de origem.

Quando tento executar o projeto, ele não pode compilar, então acrescentei:

compile files('libs/gson-2.2.3.jar')

às dependências no arquivo .gradle. Depois disso, compila corretamente, mas ao executar o aplicativo eu recebo um ClassDefNotFoundException .

Alguém sabe o que estou fazendo errado?


Faça o download e copie o arquivo .jar na pasta libs e adicione essa linha ao build.gradle:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.google.code.gson:gson:2.3.1'
}

Não esqueça de clicar em "Sincronizar agora"



Aqui estão as instruções para incluir um arquivo jar local como uma biblioteca em um módulo:

  1. Crie uma pasta 'libs' no nível superior do diretório do módulo (o mesmo diretório que contém o diretório 'src')

  2. No build.gradle file inclua o seguinte para que seu encerramento de dependências:

    dependencies {
        // ... other dependencies
        compile files('libs/<your jar's name here>')
    }
  3. O Android Studio já deve ter configurado um wrapper gradlew. Na linha de comando, navegue até o nível superior do seu projeto (o diretório que possui um arquivo gradlew ).

    Execute ./gradlew assemble . Isso deve compilar o projeto com a biblioteca. Talvez seja necessário corrigir erros no arquivo build.gradle conforme necessário.

  4. Para que o Android Studio reconheça os arquivos jar locais como bibliotecas para suporte durante a codificação no IDE, é necessário executar mais algumas etapas:

    4.1. Clique com o botão direito do mouse no módulo no painel esquerdo e escolha Open Library Settings .

    4.2. No painel esquerdo da caixa de diálogo, escolha Libraries .

    4.3. Clique no sinal + acima do segundo painel da esquerda -> Java

    4.4. Selecione seu jar local e adicione-o ao projeto.

  5. Você pode precisar executar o comando ./gradlew acima uma vez


IIRC, simplesmente usando "Adicionar como biblioteca" não é suficiente para compilar com o projeto.

Verifique a ajuda do Intellij sobre como adicionar bibliotecas a um projeto

A parte que mais lhe interessa é esta:

(Em File > Project Structure ) Abra as configurações do módulo e selecione a guia Dependências.

Na guia Dependências, clique em adicionar e selecione Biblioteca.

Na caixa de diálogo Escolher bibliotecas, selecione uma ou mais bibliotecas e clique em Adicionar selecionadas.

Se a biblioteca não aparecer na caixa de diálogo, adicione-a nas configurações de Bibliotecas, logo abaixo de Módulos.

Você não precisa mais adicionar compile files() , e a biblioteca deve ser adequadamente adicionada ao seu projeto.


Etapas fáceis para adicionar biblioteca externa no Android Studio

  1. Se você estiver no Android View no project explorer, altere-o para a visualização Project como abaixo

  1. Clique com o botão direito do mouse no módulo desejado onde você gostaria de adicionar a biblioteca externa, selecione New> Directroy e nomeie-a como ' libs '
  2. Agora copie o blah_blah.jar para a pasta ' libs '
  3. Clique com o botão direito no blah_blah.jar, depois selecione ' Add as Library .. '. Isto irá automaticamente adicionar e entrar em build.gradle como arquivos de compilação ('libs / blah_blah.jar') e sincronizar o gradle. E você está feito

Observação: se você estiver usando bibliotecas de terceiros, é melhor usar dependências nas quais o script Gradle baixa automaticamente o JAR e o JAR de dependência quando o script gradle é executado.

Ex: compile 'com.google.android.gms: play-services-ads: 9.4.0'

Leia mais sobre Gradle Dependency Mangement


Eu fiz o trabalho apenas adicionando uma linha para build.gradle:

 dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar']) ----> AS creates this
    implementation 'com.google.code.gson:gson:2.3.1'   ----------> I added this one
    }

Não se esqueça de clicar em "Sincronizar agora" no canto superior direito.

Estou usando o Android Studio 1.0.1.


Minha resposta é basicamente reunir algumas das respostas certas, mas incompletas, fornecidas acima.

  1. Abrir build.gradle
  2. Adicione o seguinte:

    dependencies {
    compile 'com.android.support:appcompat-v7:19.+'
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.google.code.gson:gson:2.3'
    }

    Isso permitirá suporte para duas maneiras diferentes de adicionar dependências. A compile fileTree(dir: 'libs', include: ['*.jar']) (como mencionado pelo @Binod) diz ao compilador para olhar sob a pasta libs para ANY jar. É uma boa prática criar essa pasta 'libs' que conterá os pacotes jar que nosso aplicativo precisa usar.

Mas isso também permitirá suporte à dependência do Maven. A compilação 'com.google.code.gson:gson:2.3' (como mencionado por @saneryee) é outra maneira recomendada de adicionar dependências que estão em um repositório remoto central e não em nosso / "repositório local" libs. É basicamente dizer ao gradle para procurar por aquela versão daquele pacote e dizer ao compilador para considerá-lo quando compilar o projeto (tê-lo no classpath)

PS: eu uso os dois


Eu achei o Dependency Manager do Android Studio bastante prático e poderoso para gerenciar dependências de terceiros (como o gson mencionado aqui). Fornecendo guia passo a passo que funcionou para mim (Observação: essas etapas são testadas para o Android Studio 1.6 e versões posteriores na plataforma Windows).

Passo-1: Ir para "Construir> Editar Bibliotecas e Dependências ..." abriria a caixa de diálogo "Estrutura do Projeto"

Etapa 2: selecione "app" e, em seguida, selecione a guia "Dependências". Em seguida, selecione "Add> 1 Library dependency"

Etapa 3: A caixa de diálogo "Escolher Dependência da Biblioteca" será exibida, especifique "gson" na pesquisa e pressione o botão "pesquisar"

Passo 4: A dependência desejada seria mostrada na lista de pesquisa, selecione com.google.code.gson: gson: 2.7 (esta é a versão mais recente no momento em que escrevi a resposta), pressione OK

Pressione OK na caixa de diálogo "Estrutura do Projeto". Gradle atualizaria seus scripts de construção de acordo.

Espero que isso ajude :)


Ao contrário do Eclipse, não precisamos baixar o jar e colocá-lo na pasta / libs. Gradle lida com essas coisas nós só precisamos adicionar dependências Gradle, Gradle faz o download e coloca no cache gradle.

Precisamos adicionar dependências como:

dependencies {implementação 'com.google.code.gson: gson: 2.2.4'}

No entanto, também podemos fazer download do jar e adicionar isso como biblioteca, mas a melhor prática é adicionar as dependências do Gradle.


Eu fiz acima de 3 etapas e seu charme de trabalho para mim.

(Estou usando o Android Studio 2.1.2)

Passo 1

  • Adicione o nome do seu pacote jar (como exemplo compile 'com.squareup.okhttp3:okhttp:3.3.1' ) no script de compilação gradle em build.gradle (Module: app) .

Passo 2: clique com o botão direito na pasta da aplicação -> Novo -> Módulo

Etapa 3: Clique em Importar pacote JAR / .AAR. Em seguida, procure seu pacote. como exemplo: OkHttp.jar


  1. Adicionado a pasta libs no nível do app .
  2. Adicionado todos os jars neste projeto.
  3. Em seguida, selecione todos os jars, na pasta libs ,
  4. clique com o botão direito nos itens selecionados e diga add library
  5. então você encontrará a opção de expansão de jars, dentro do próprio explorador do projeto.

Observei CTRL + ALT + SHIFT + S -> estrutura do projeto -> app-module -> Dependências "já tinha uma entrada como (dir: 'libs', include: '*.jar') na compile-option , Inicialmente, e depois de adicionar o jarro de acordo com as etapas acima, o build.gradle obteve as entradas para o novo jar adicionado, ele mesmo.


1) crie uma pasta 'your_libs' dentro da pasta Project / app / src.

2) Copie seu arquivo jar para esta pasta 'your_libs'

3) No Android Studio, vá para Arquivo -> Estrutura do Projeto -> Dependências -> Adicionar -> Dependência de Arquivo e navegue até o seu arquivo jar, que deve estar em 'src / your_libs'

3) Selecione seu arquivo jar e clique em 'Ok'

e então você pode ver no seu build.gradle assim: compile files ('src / your_libs / your.jar')


Com o Android Studio 3+:

Você deve simplesmente ser capaz de simplesmente copiar o arquivo jar para a pasta libs logo abaixo da pasta do aplicativo.

... myproject \ app \ libs \ myfile.jar

Em seguida, selecione Arquivos de Projeto na lista suspensa da janela Projetos, clique com o botão direito do mouse no projeto, selecione Sincronizar para ver o arquivo em Arquivos de Projeto. Ele adicionará automaticamente as dependências no arquivo gradle (Módulo: app).

dependencies {
...
    implementation files('libs/myfile.jar')

Aqui está outra solução:

Vá para a visualização Arquivos de Projeto (selecione Arquivos de Projeto no menu suspenso).

Selecione Novo ... Diretório, crie uma pasta chamada libs logo abaixo do aplicativo.

Abra o File Explorer, copie e cole seu arquivo jar na pasta libs.

No Android Studio, clique com o botão direito do mouse no arquivo jar e selecione Incluir como biblioteca ... no menu pop-up.

Você deve ver o arquivo listado na lista de dependências no arquivo gradle:

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

Abra seu arquivo java e inclua a instrução de importação lá:

import com.xxx.xxx;

menu File -> project struct -> module select "app" -> dependencies tab -> + button 
-> File dependency -> PATH/myfile.jar

Você pode fazer isso com duas opções.

primeira maneira simples.

Copie o arquivo .jar para a área de transferência e adicione-o à pasta libs. Para ver a pasta libs no projeto, escolha o projeto da caixa de combinação acima das pastas.

em seguida, clique com o botão direito do mouse no arquivo .jar e clique em adicionar como uma biblioteca, em seguida, escolha um módulo e, em seguida, clique em ok. Você pode ver o arquivo .jar no arquivo build.gradle dentro do bloco de dependências.

 dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        implementation 'com.android.support:appcompat-v7:21.0.3'
        implementation project(':okhttp-2.0.0')
        implementation 'com.google.code.gson:gson:2.3.1'
    }

A segunda forma é a seguinte: Podemos adicionar um arquivo .jar a um módulo importando esse arquivo .jar como um módulo .jar e, em seguida, adicionar esse módulo a qualquer módulo que desejarmos.

import module ---> escolha seu arquivo .jar -> do que importar como .jar -

Então CTRL + ALT + SHIFT + S -> projeto sturure -> escolha o módulo que você quer ato de adicionar um jar -> Dependência -> Dependência do Módulo. build.gradle do módulo será atualizado automaticamente.


No android Studio 1.1.0. Eu resolvi essa questão seguindo os seguintes passos:

1: Coloque o arquivo jar no diretório libs. (no Finder)

2: Abra as configurações do módulo, vá para Dependências, no canto inferior esquerdo há um botão de adição. Clique no botão mais, em seguida, escolha "File Dependency" .Aqui você pode ver o arquivo jar. Selecione e está resolvido.


Crie uma pasta libs. Adicione seu arquivo .jar. Clique com o botão direito sobre ele e você encontrará add jar como dependency. Clique nisso. É tudo que você precisa fazer. Você pode encontrar as dependências adicionadas ao seu arquivo build.gradle.


1. Coloque o jar (no meu caso, gson-2.2.4.jar ) na pasta libs.

2. Certifique-se de que os arquivos de compilação ( libs/gson-2.2.4.jar ) estejam em seu arquivo build.gradle.

3. Agora, clique em "Sincronizar projeto com arquivos Gradle" (Esquerda para o botão do gerenciador AVD na barra superior).

Depois que fiz os três acima, tudo começou a funcionar bem.


compile fileTree(dir: 'libs', include: '*.jar') funciona bem mas não compile files(...) testados com o Studio Beta 0.8.1


Eu tenho lutado com a mesma coisa por muitas horas, tentando fazer o jar do Gson funcionar não menos. Eu finalmente decifrei - aqui estão os passos que eu dei:

  1. Coloque o jar do Gson (no meu caso, gson-2.2.4.jar ) na pasta libs
  2. Clique com o botão direito e clique em "Adicionar como biblioteca"
  3. Certifique-se de que os compile files('libs/gson-2.2.4.jar') estejam em seu arquivo build.gradle (ou compile fileTree(dir: 'libs', include: '*.jar') se você estiver usando muitos arquivos jar )

    Editar: Use os implementation files('libs/gson-2.2.4.jar') (ou a implementation fileTree(dir: 'libs', include: '*.jar') ) no Android Studio 3.0+

  4. Faça uma compilação limpa (provavelmente você pode fazer isso bem no Android Studio, mas para ter certeza de que naveguei em um terminal para a pasta raiz do meu aplicativo e digite gradlew clean . Estou no Mac OS X, o comando pode ser diferente em Seu sistema

Depois que fiz os quatro acima, tudo começou a funcionar bem. Acho que o passo "Adicionar como biblioteca" foi o que eu já havia perdido, e não funcionou até que eu limpei também.

[Edit - adicionado o passo build.gradle que também é necessário como outros apontaram]


Eu li todas as respostas aqui e todas elas parecem cobrir versões antigas do Android Studio!

Com um projeto criado com o Android Studio 2.2.3 eu só precisava criar um diretório de libs sob app e colocar meu jar lá. Eu fiz isso com o meu gerenciador de arquivos, sem necessidade de clicar ou editar qualquer coisa no Android Studio.

Por que isso funciona? Abra Construir / Editar Bibliotecas e Dependências e você verá:

{include=[*.jar], dir=libs}

Todas essas soluções estão desatualizadas. É muito fácil agora no Android Studio:

Arquivo> Novo Módulo ...

A próxima tela parece estranha, como se você estivesse selecionando algum widget ou algo assim, mas mantenha-a na primeira imagem e abaixo da rolagem e encontre "Importar pacote JAR ou .AAR"

Em seguida, pegue Project Structure do Project Structure no menu Arquivo.Selecione o app da janela aberta, em seguida, selecione dependencies , pressione green plus button botão green plus button , selecione a module dependency seguida, selecione o módulo que você importou e pressione OK


No Mac OS X:

  1. Adicione jar como biblioteca (arraste jar para libs, clique com o botão direito em add como lib)

  2. Adicionar instrução compile ao build.grade

  3. Instale o gradle v1.6 (use homebrew)

    • brew instalar gradle
    • gradle -v
    • se não for v1.6, atualize o homebrew
  4. gradle clean (reconstrução android não funcionou)

Isso me separou.


Passo 1: Agora, sob a app folder seu app folder você deve ver libs , se você não vê-lo, então crie-o .

Etapa 2: Drag & Drop the .jar file here , você pode receber um aviso "This file does not belong to the project" , basta clicar no botão OK .

Passo 3: Agora você deve ver o arquivo jar na pasta libs , clique com o botão direito do mouse no arquivo jar e selecione "Add as library", Click OK for prompt "Create Library"

Passo 4: Agora este frasco foi adicionado.





dependency-management