Use Maven para gerenciar suas dependências Java
Concentre-se na solução de problemas enquanto esta ferramenta de código aberto monitora suas bibliotecas Java.
Como entusiasta do código aberto, usei dezenas (centenas?) de bibliotecas que estão muito além da minha habilidade ou interesse como programador. Para muitas pessoas, inclusive eu, as bibliotecas disponíveis são uma das coisas que fazem valer a pena usar uma linguagem de programação específica.
Uma biblioteca de código aberto representa horas e dias em que você não precisa trabalhar em um problema que não é central para o seu projeto ou, inversamente, tão central que seu projeto estaria fora de alcance. Melhor ainda, é um código que você não precisa manter – a menos que seja tão importante para você que você decida contribuir com ele.
Como as bibliotecas de código aberto são um componente vital da programação de código aberto, a maioria das linguagens de programação tem uma maneira conveniente de garantir que sejam fáceis de incluir em sua base de código.
Existem diversas formas de gerenciar bibliotecas em Java, mas a que utilizo é o Maven.
Maven é uma estrutura de gerenciamento de código que ajuda você a controlar dependências, criar alvos, relatórios e documentação, tudo a partir de um local central. Esse local central é um arquivo Project Object Model (POM), que é escrito em XML para descrever os requisitos e expectativas do seu projeto.
Ao decidir atualizar uma biblioteca, você pode atualizar apenas seu arquivo pom.xml
.
Se você adicionar uma compilação de depuração ao seu projeto, adicione-a como destino em pom.xml
.
Ao atualizar para uma nova Java Virtual Machine (JVM), faça isso em pom.xml
.
Se isso parece fácil, você ficará satisfeito em saber que é igualmente fácil começar.
Instale o Maven
O Maven está disponível na maioria das distribuições Linux no seu gerenciador de pacotes.
No Fedora, Mageia e distribuições semelhantes:
$ sudo dnf install maven
Em Elementary, Mint e outras distribuições baseadas em Debian:
$ sudo apt install maven
No macOS, use MacPorts ou Homebrew.
No Windows, use Chocolatey.
Configurando
Na maioria dos sistemas, o Maven já está configurado após a instalação.
Entretanto, se você tiver uma configuração Java complexa, com versões diferentes instaladas para projetos diferentes, talvez seja necessário definir sua variável de ambiente JAVA_HOME
.
Se você não sabe o que é isso, leia meu artigo sobre como encontrar e configurar seu JAVA_HOME.
Primeiro, verifique se o Maven está instalado e usando a versão do Java que você pretende:
$ mvn -version
Apache Maven x.y.z
Maven home: /usr/share/maven
Java version: X.Y.Z, vendor: Red Hat, Inc.,
runtime: /usr/lib/jvm/java-XX-openjdk-XX
Seu primeiro arquivo POM
O Maven baseia tudo o que faz no arquivo POM de um projeto. Você pode pensar em pom.xml
como o equivalente do Maven ao Makefile do Autotool ou ao arquivo CMakeLists.txt do CMake. Você coloca instruções que são significativas para o Maven em pom.xml
e ele executa essas instruções quando solicitado.
Um bom IDE, como Eclipse ou NetBeans, pode fornecer um arquivo padrão pom.xml
ao criar um projeto Maven.
Dependendo de quão confortável você está com XML, esse processo pode parecer mais complexo do que realmente é. Há uma vantagem distinta em usar XML aqui, então dê uma olhada mesmo se você não estiver familiarizado com a linguagem.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>example4Maven</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>
</project>
Os primeiros elementos ( e
<project>
) contêm informações sobre o próprio arquivo, identificando o documento como XML escrito de acordo com o esquema Maven POM. O próximo grupo de elementos corresponde ao esquema Maven usado e às configurações do projeto que forneci ao NetBeans.
O elemento <packaging>
especifica que este projeto deve ser empacotado como um arquivo JAR.
O elemento <properties>
informa ao Maven sobre o código-fonte (ainda inexistente) do meu projeto. Está escrito em codificação UTF-8 para OpenJDK versão 11.
Tudo isso foi gerado automaticamente pelo NetBeans para mim quando criei um projeto de exemplo.
Se você não usa um IDE que se integre ao Maven ou simplesmente prefere escrever o seu do zero, você pode encontrar o esboço do esqueleto de um arquivo POM em maven.apache.org/pom.html#Quick_Overview. Está claramente comentado e já possui as declarações XML preenchidas.
Adicionando uma dependência ao seu POM
Há muito tempo, quando você escreveu um aplicativo Java e decidiu usar uma biblioteca externa, você poderia baixar um JAR da biblioteca, salvá-lo em sua base de código e usar uma instrução import
para referenciá-la em seu Java. código. Era um sistema manual e, embora funcionasse tão bem quanto usar, digamos, uma biblioteca C ou C++, sua manutenção poderia ser muito trabalhosa.
Maven usa repositórios, assim como o Linux usa repositórios para instalação de software e o Python usa pip. O repositório padrão é o Repositório Central do Sonatype, que você pode pesquisar em search.maven.org. No Central, você pode encontrar bibliotecas e os metadados apropriados necessários para preencher os campos de dependência obrigatórios do Maven. Na prática, porém, a maioria das bibliotecas Java fornece essas informações em seus arquivos README ou na documentação.
Suponha que você tenha um script Java simples que lista os arquivos em um diretório, mas você decide que deseja que ele liste apenas os arquivos que terminam em jpg
ou png
. A biblioteca fileUtils
do Apache oferece um filtro de nome de arquivo exatamente para esse tipo de operação, mas não está incluído na distribuição Java.
package com.example.example4maven;
import java.io.File;
import java.util.Iterator;
import java.util.List;
// external libs
import org.apache.commons.io.FileUtils;
public class Main {
private static final File myDir = new File("/home/tux/img");
private static final String[] ext = new String[] { "jpg","png" };
public static void main(String[] args) {
List<File> images = (List<File>) FileUtils.listFiles(myDir, ext, false);
for (Iterator<File> i = images.iterator(); i.hasNext();) {
System.out.println(i.next().getName());
}
}
}
Você pode pesquisar a biblioteca no Central ou visitar o site do projeto e obter as informações de dependência lá.
As informações de dependência são assim:
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.11.0</version>
</dependency>
Insira isso entre as tags <dependencies>
e em seu arquivo
pom.xml
e você adicionou o Apache biblioteca commons.io
ao seu projeto.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" \
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" \
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 \
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>example4Maven</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.11.0</version>
<type>jar</type>
</dependency>
</dependencies>
</project>
Agora, quando você cria seu projeto, o Maven pode baixar automaticamente qualquer biblioteca que você não tenha em sua base de código local.
Construa um JAR com Maven
Você pode criar arquivos JAR com ferramentas como fastjar ou gjar, mas o Maven possui plug-ins que permitem executar tarefas comuns de construção, incluindo empacotamento. Para um pacote JAR padrão, que contém seu código-fonte, você pode usar maven-jar-plugin
.
Para que o Maven crie um "Uber JAR" para você, que contém seu código e todas as bibliotecas dependentes que seu código exige, use maven-assembly-plugin
. Os dois plug-ins são semelhantes em finalidade e configuração, e ambos são plug-ins de construção, portanto, são inseridos em uma seção <build>
do seu pom.xml
.
Tal como acontece com as bibliotecas, os metadados do Maven para plug-ins estão disponíveis na página inicial do plug-in. Você inclui maven-assembly-plugin
listando seu groupId
, artifactId
e version
entre
Existem opções de configuração adicionais, incluindo:
- um conjunto de comportamentos predefinidos
- a capacidade de alterar o nome da saída com base no nome do projeto em vez do codinome do seu projeto
- a capacidade de anexar suas próprias entradas em
MANIFEST.MF
.
Isto é útil quando sua classe principal não é chamada Main.class
.
Para informar ao plug-in quando ele deve ser invocado, você também deve definir qual palavra-chave em sua compilação do Maven o aciona.
Para maven-assembly-plugin
, você provavelmente deseja que ele seja ativado ao usar o pacote mvn
.
<build>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.3.0</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<finalName>Lister-${project.version}</finalName>
<appendAssemblyId>false</appendAssemblyId>
<archive>
<manifestFile>src/main/resources/META-INF/MANIFEST.MF \
</manifestFile>
</archive>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
Teste sua construção:
$ mvn clean package
Após a construção do seu projeto, você poderá encontrar seu Uber JAR no diretório targets
gerado automaticamente:
$ java -jar targets/Lister-1.0.jar
foo.png
foo.jpg
bar.jpg
bar.png
Funciona como esperado.
Construa com Maven
O Maven torna o gerenciamento do seu projeto Java fácil e resiliente. Com o Maven, os colaboradores podem inicializar seu ambiente rapidamente, obtendo todas as bibliotecas necessárias e criando compilações previsíveis para seus usuários. Sua configuração XML mantém a sintaxe simples e lintável e facilita a adição de novas opções.
Experimente o Maven com seu próximo projeto Java e veja o que você acha.