Modularize seu projeto com Maven

Postei isso no Blog da Summa Technologies, onde ainda trabalho, mas gostaria de manter estas informações registradas no meu blog, e por esta razão duplico-o aqui... :)


Organizar um projeto em módulos não é uma má idéia. Colocar um pacote em outro projeto, gerar um jar e fazer a dependência deste num projeto maior, agregador dos módulos, realmente não é complicado (se você entendeu tudo que escrevi!). O desafio aqui está em definir um modelo de release para o projeto e automatizar este processo. O Maven permite isto de uma forma inteligente, descomplicada e organizada. O sofrimento? A documentação de como obter e implantar este processo é pobre.

Após implantarmos este processo em um de nossos projetos, optei por compartilhar aqui o desafio que atravessamos, algo que é de conhecimento aberto a todos, mas que a documentação do Maven não apresenta com clareza.

Preparação

Antes de vermos com detalhe as definições dos POMs, é importante que haja uma noção da arquitetura do Maven e como é o seu funcionamento. Vamos tomar um exemplo quase igual com o que consta na pequena documentação:

-+ myProject/
-|- pom.xml
-+- common/
-|-- pom.xml
-+-- src/
-+--- main/
-+---- java/
-+- web/
-|-- pom.xml
-+-- src/
-+--- main/
-+---- webapp/

Repare que, além do POM principal, para cada módulo existe um POM (pom.xml). No POM raiz, é onde definimos quais os módulos do projeto:

<project>
  ..
  <groupId>summatech</groupId>
  <artifactId>myProject</artifactId>
  <version>1.0-SNAPSHOT</version>
  <name>My Maven Project</name>
  <modules>
    <module>common</module>
    <module>web</module>
  </modules>
  ..
</project>

Desta forma, ao compilarmos, através do Maven, o projeto myProject, este identifica módulos que também devem ser compilados. O processo então será o de executar o mesmo Goal executado em myProject nos subseqüêntes módulos. Caso o goal chamado install seja executado, será gerado pelo Maven os jars dos projetos e ainda o war do projeto web. Temos a partir de agora, uma única chamada para compilar todos os módulos e sub-módulos (sim, é possível definir sub-módulos, mas esse tópico fica para outro post.)

Herança de Dependências Comuns

Outro ponto importante na utilização de módulos, é a possibilidade de poder-se definir no POM principal, configurações de dependências (de outros projetos - como Hibernate) comuns a todos os módulos. Para definir as dependências comuns, vamos tomar um exemplo. No POM principal, inserimos a dependência ao Hibernate assim como em qualquer outro projeto Maven:

<project>
 ..
 <name>My Maven Project</name>
 <dependencies>
   <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate</artifactId>
      <version>3.2.5.ga</version>
   </dependency>
 </dependencies>
 ..
</project>

Além das dependências, configurações de plugins e outros dados podem ser herdados; mas não entrarei em detalhes agora.

Para que os módulos herdem esta dependência do Hibernate, ainda falta um último passo: é necessário que seus POMs façam referência ao parent - ao POM principal. Tomemos por exemplo o POM do módulo common:

<project>
  <modelVersion>4.0.0</modelVersion>
  <artifactId>common</artifactId>
  <name>Common Classes for My Project</name>
  <parent>
    <groupId>summatech</groupId>
    <artifactId>myProject</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>
  <packaging>jar</packaging>
</project>

Repare que não foi necessário incluir a tag groupId, já que este atributo será herdado do POM raiz e, afinal de contas, é um módulo e por esta razão, não faz sentido pertencer a outro grupo diferente do de myProject. Além disso, o módulo common também herdou a dependência do Hibernate automaticamente.

Este é o primeiro passo para a modularização de projetos com Maven. Em outro post, apresentarei detalhes sobre como, no módulo web haver uma dependência do módulo common, sem ter que alterar a version manualmente quando há nova versão do módulo. Em um terceiro post, apresentarei o processo para gerar uma versão do projeto modularizado através do Maven.

Até!