Gerenciamento de dependências no Java

Linguagens orientadas a objetos são, hoje em dia, dominantes na maioria dos sistemas corporativos em funcionamento. Com diversos benefícios como o baixo acoplamento e a divisão de responsabilidades, a criação e manutenção de aplicações projetadas a partir desse conceito se torna uma tarefa extremamente produtiva e, devido a isso, altamente atrativa para a indústria.

Essa produtividade se deve, principalmente, à capacidade de reuso de componentes criados seguindo os conceitos da orientação a objeto. Explicando um pouco mais, linguagens que seguem esse tipo de paradigma (orientado a objetos) tendem a permitir que o desenvolvedor crie módulos totalmente desacoplados, ou seja, sem nenhuma dependência entre si. Portanto, a solução de um problema maior pode ser dividida em diversas soluções menores que, em conjunto, resolvem o objetivo principal.

A vantagem disso é que, caso surja um novo projeto que seja semelhante a um já resolvido, essas pequenas soluções podem ser reaproveitadas, evitando duplicação de código e outros problemas.

No Java, o reuso de código pode ser feito através da utilização de pacotes JAR, arquivos compactados que contêm classes já desenvolvidas e que podem ser adicionados a um projeto.

No entanto, para projetos de grande porte, a configuração manual dessas bibliotecas se torna extremamente complexa e custosa, especialmente do ponto de vista de manutenção da aplicação, o que pode gerar um oneroso trabalho na busca e inclusão de todos os arquivos necessários para o funcionamento de uma biblioteca.

Visando resolver esse problema, foram criadas algumas ferramentas chamadas de Gerenciadores de dependências que têm como objetivo gerenciar essas bibliotecas externas ao projeto.

Em nosso artigo, pretendemos introduzir algumas delas, explicando seu funcionamento e mostrando suas vantagens e desvantagens.

Também pretendemos, no decorrer da explicação, apresentar exemplos de situações em que o uso de dependências se faz necessário, mostrando sua utilidade no dia-a-dia.

Reuso de componentes no Java

A aplicação dos conceitos do paradigma de orientação a objetos dentro de um projeto tende a permitir que o desenvolvedor possa dividir sua aplicação em módulos de baixo acoplamento entre si. E graças a essa baixa dependência entre os componentes, é possível a utilização dos mesmos em não somente um, mas em diversos outros projetos.

Por padrão, no Java, o uso desses pacotes é possível ao adicionar o arquivo JAR no classpath da aplicação em desenvolvimento. Para quem não está familiarizado com o termo classpath, este representa o caminho, dentro de sua máquina, que a JVM utiliza para carregar, dinamicamente, as classes e bibliotecas que são utilizadas dentro de um sistema Java.

Portanto, a adição de dependências pode ser feita simplesmente copiando arquivos .jar para os diretórios de classpath de nossa aplicação, sem nenhum segredo.

O grande problema, no entanto, vem quando precisamos gerenciar essas dependências, ou seja, alterar versões, corrigir conflitos de pacotes e encontrar as dependências encadeadas dos arquivos JAR que desejamos utilizar.

Exemplificando, vamos imaginar que, em um projeto, se faça uso da biblioteca A.jar. Esse pacote, por sua vez, faz referência à biblioteca B.jar e C.jar. Portanto, para conseguirmos utilizar A, precisamos, obrigatoriamente, adicionar B e C em nosso classpath, uma tarefa um tanto trabalhosa.

Pior ainda, caso B ou C façam referência a uma biblioteca D.jar, também precisaríamos adicionar essa ao nosso projeto. Através desse exemplo é fácil observar como uma situação de gerenciamento de dependências pode fugir do controle de nosso time de desenvolvimento, causando um trabalho enorme no gerenciamento de um projeto.

Ferramentas para gerenciar suas dependências

Com o intuito de resolver esse problema, existem os chamados gerenciadores de dependências. Esse tipo de aplicação serve para que seja possível, ao desenvolvedor, facilmente definir as bibliotecas que devem ser incluídas, bem como a versão de cada uma.

Além disso, uma das grandes vantagens desse tipo de ferramenta é a capacidade de realizar o download das bibliotecas automaticamente, através do uso de certos sites que fornecem o chamado repositório de dependências.

Esses repositórios servem como uma espécie de arquivo público com diversos pacotes, que por sua vez podem ser baixados através dos gerenciadores de dependências.

Em nosso artigo, iremos abordar três ferramentas para gerenciar dependências: o Apache Maven, o Apache Ivy e, por fim, o Gradle. Pretendemos introduzir as características de cada uma, bem como suas vantagens e desvantagens, expondo exemplos de utilização de cada uma.

Configurando nossa IDE

Antes de começarmos a desenvolver nossos exemplos, no entanto, é necessário adequarmos nossa IDE a trabalhar com esses três tipos de ferramentas.

Para isso, existem diversos plug-ins prontos que, uma vez baixados e instalados, facilitam a utilização e o desenvolvimento com essas ferramentas.

Nesse artigo, a IDE de escolha para trabalharmos será o Eclipse. Caso você não tenha essa aplicação instalada, o download da mesma pode ser feito através do endereço que apresentamos no fim do artigo, na seção Links.

Uma vez que o Eclipse esteja instalado, precisamos baixar nossos plug-ins.

Isso é feito clicando no menu Help > Eclipse Marketplace, localizado no menu superior da IDE, e escolhendo, dentro da lista de plug-ins disponíveis, os que iremos utilizar. Para auxiliar no processo de encontrar os plug-ins, na Figura 1 colocamos todos os que iremos utilizar e que precisam ser instalados pelo Eclipse Marketplace.

" [...] continue lendo...