Utilizando Bibliotecas JAR: Primeiros Passos

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (1)  (0)

Veja neste artigo um roteiro para trabalhar com bibliotecas JAR sem exigir que o desenvolvedor domine os conceitos citados. O Java adotou o formato JAR como padrão para facilitar a distribuição e utilização de bibliotecas de classes reutilizáveis. Para facilitar a discussão, será apresentado um exemplo prático envolvendo a biblioteca “Gson” do Google.

1. Introdução

JAR (Java ARchive) é um arquivo compactado no formato ZIP que contém um conjunto de classes (arquivos “.class”) e arquivos de configuração. O formato JAR é utilizado para permitir a distribuição de bibliotecas ou, até mesmo, sistemas inteiros em Java (uma vez que é possível montar arquivos JAR formados por centenas de classes).

As principais bibliotecas Java desenvolvidas por terceiros – ou seja, bibliotecas que não fazem parte da JDK - são estruturadas e distribuídas em arquivos JAR. Apenas para citar alguns exemplos de bibliotecas populares, podemos relacionar: Joda (biblioteca para facilitar a manipulação de tipos data e hora), XStream (biblioteca para serializar objetos para XML), Weka (biblioteca de algoritmos para mineração de dados), Gson (biblioteca para serializar objetos para JSON), entre diversas outras.

Apesar de muito popular, o formato JAR “assusta” um pouco os iniciantes em Java, pois o uso dessas bibliotecas pressupõe o conhecimento de certos conceitos não muito triviais do universo Java, como por exemplo: configuração da variável CLASSPATH, definição da estrutura de diretórios/pacotes do sistema, conhecimento da estrutura interna do JAR, entre outros. Muitas vezes, um desenvolvedor quer apenas testar essas bibliotecas de uma forma básica, evitando lidar com esse monte de conceitos (e suas complicações associadas!). Felizmente, isso é possível. Na seção a seguir apresentamos um roteiro para que você possa testar e utilizar bibliotecas JAR de uma maneira rápida e direta em seus programas.

2. Roteiro para Testar/Utilizar Bibliotecas JAR

Para apresentar o roteiro, utilizaremos como exemplo a biblioteca “gson-2.2.2.jar”, apresentada em nosso artigo anterior: http://www.devmedia.com.br/introducao-ao-formato-json/25275. Execute as etapas a seguir:


Passo 1: crie uma pasta em seu computador, como por exemplo “C:\TESTE” e coloque o arquivo JAR nessa pasta (Figura 1).

Pasta C:\TESTE com o arquivo JAR

Figura 1: Pasta C:\TESTE com o arquivo JAR

Passo 2: Digite programa Java mostrado na Listagem 1 e salve-o na pasta “C:\TESTE”, com o nome “TesteGson.java” (Figura 2). Este programa faz uso da classe Gson, do pacote com.google.gson.Gson, que é distribuído exatamente no arquivo “gson-2.2.2.jar” (se você quiser conferir isso, renomeie temporariamente o arquivo de JAR para ZIP e explore a sua estrutura de pastas).


Listagem 1: Programa exemplo que utiliza a classe “Gson” de “gson-2.2.2.jar”

import com.google.gson.Gson;

    //classe com exemplo de uso do Gson
    public class TesteGson {

       public static void main(String[] args) {
 
            //instancia e preenche um vetor de strings
            String escritores[] = new String[5];
			
			escritores[0] = "George Orwell";
			escritores[1] = "Thomas More";
			escritores[2] = "Platão";
			escritores[3] = "Tommaso Campanella";
			escritores[4] = "Leonardo Boff";

            //instancia um objeto da classe Gson           
            Gson gson = new Gson();
             
            //serializa o conteúdo do vetor para o formato JSON 
			//e armazena em uma variável auxiliar
            String aux = gson.toJson(escritores);
             
            //imprime a string JSON
            System.out.println(aux);
         }
}
Pasta C:\TESTE com o arquivo JAR e o programa Java

Figura 2: Pasta C:\TESTE com o arquivo JAR e o programa Java

Passo 4 - Compilação: agora devemos compilar o programa Java. Como os dois arquivos estão na mesma pasta, isto pode ser feito através da linha de comando mostrada na Listagem 2

Listagem 2: Compilando o programa

C:\TESTE>javac -cp .;gson-2.2.2.jar TesteGson.java

Passo 5 - Execução: para executar o programa, o processo é análogo, como mostra a Listagem 3:

Listagem 3: Executando o programa

C:\TESTE>java -cp .;gson-2.2.2.jar TesteGson

["George Orwell","Thomas More","Platão","Tommaso Campanella","Leonardo Boff"]

Explicação: o parâmetro –cp (ou –classpath) serve para indicar ao Java quais são as pastas onde ele deve procurar pelas classes que compõem o seu programa. Após o –cp você deve indicar uma lista de diretórios ou de arquivos JAR separados pelo caractere “ ; ” (ponto-e-vírgula) caso o seu sistema seja Windows (ou “ : ” no caso de Linux).


Observe com calma a linha de comando mostrada na Listagem 3. Veja que o primeiro item após o –cp é “ . ” (um ponto!), que significa o diretório corrente. Já o segundo item é “gson-2.2.2.jar”, o arquivo JAR que contém a classe Gson. O resultado disto é: o Java irá procurar por classes tanto no diretório corrente, como “dentro” do arquivo “gson-2.2.2.jar”. O uso do ponto “ . ” como primeira entrada após o parâmetro –cp assume que o arquivo TesteGson.java está no diretório corrente (“C:\TESTE”) e faz com que o mesmo possa localizado pelo compilador.


A maioria dos iniciantes em Java não percebe esse detalhe de usar o “pontinho” como primeira entrada e quase enlouquece na hora de tentar executar o programa. Quando você esquecer de colocar o “ . ” como primeira entrada, o programa não é executado e o Java retorna uma mensagem de erro como a mostrada na Listagem 4 (exceção do tipo ClassNotFoundException).

Listagem 4:Erro – Esquecemos de especificar o ponto “ . ” após o -cp

C:\TESTE>java -cp gson-2.2.2.jar TesteGson
Erro: Não foi possível localizar nem carregar a classe principal TesteGson

3. Utilizando Diversos arquivos JAR

O exemplo apresentado na seção anterior envolveu o uso de apenas um arquivo JAR. No entanto, é possível utilizar diversos arquivos, bastando separá-los por “ ; ”. Supondo que todos os JAR estejam em um mesmo diretório, a sintaxe seria similar à mostrada na Listagem 5. No exemplo, temos três arquivos JAR: “lib1.jar”, ‘lib2.jar” e “lib3.jar” e o programa “MinhaClasse.class” todos localizados na mesma pasta.

Listagem 5: Executando o programa

C:\TESTE>java -cp .;lib1.jar;lib2.jar;lib3.jar MinhaClasse

A partir do Java 6, foi adicionada a possibilidade de utilizar o caractere asterisco para incluir todos os arquivos de uma vez no classpath, como mostra a Listagem 6 (obs: no caso do Linux, o asterisco deve vir entre aspas simples – ‘ * ’).

Listagem 6: Executando o programa

C:\TESTE>java -cp .;"*" MinhaClasse

4. Conclusões

Este artigo apresentou um roteiro direto para facilitar o processo de incorporação e teste de bibliotecas JAR em programas Java. Este assunto sempre confunde os iniciantes em Java, já que o formato JAR possui uma série de conceitos associados que não são tão triviais. Mas agora que você já conhece o método mais simples para trabalhar com bibliotecas JAR poderá “avançar de nível” e estudar esses conceitos. É importante que todo programador Java entenda o significado de CLASSPATH e aprenda sobre a estrutura e a criação de arquivos JAR.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?