Mostrando postagens com marcador Maven. Mostrar todas as postagens
Mostrando postagens com marcador Maven. Mostrar todas as postagens

segunda-feira, 10 de janeiro de 2011

Gerenciamento de Dependências com Maven - Parte 2

Neste post, será mostrada a view "Maven Repositories" do Eclipse, ilustrando algumas tarefas básicas, por exemplo, indexar um repositório para configurar / atualizar a busca de dependências pelo editor pom.xml do Eclipse.

A dinâmica do artigo será simular um projeto que utiliza usando Spring, JMS e ActiveMQ, para um projeto de mensageria. Durante os exercícios são sugeridas algumas dicas para selecionar as dependências corretas para o projeto.

Caso não tenha lido, a parte 1 desta série está disponível neste link.

Happy Maven!



Setup do Projeto - Dependências do Spring

Este exercício mostra como adicionar no projeto a dependência ao Spring Framework, uma poderosa biblioteca de Injeção de Dependências (uma excelente apostila sobre Spring pode ser acessada aqui).
  1. Crie um novo projeto Maven (se precisar de ajuda, leia este post).
  2. Clique no arquivo pom.xml, para abrir o editor do descritor do projeto.
  3. Na aba Dependencies, clique em Dependency / Add...
  4. Digite spring-context para adicionar esta dependência ao projeto. Verifique se o Eclipse sugeriu a versão desejada do Spring.
    1. Caso nenhuma sugestão seja mostrada, pode ser que nenhum repositório esteja habilitado, ou que os índices do repositório não tenham sido ainda inicializados. Esta situação é ilustrada na figura abaixo.
    2. Também pode ocorrer de o m2e não sugerir a versão desejada para a dependência. Além da reindexação, pode ser necessário configurar repositórios adicionais de pesquisa.


A view  "Maven Repositories" nos ajudará nesta tarefa. Através dela, é possível saber quais repositórios de dependências estão habilitados, bem como navegar pelos índices desses repositórios:


Note que esta view mostra
  • os artefatos presentes no repositório local (por padrão, o diretório USER_HOME/.m2/repositories)
  • os artefatos do workspace do Eclipse (neste caso, mostra o projeto jms que configuramos como projeto Maven com groupId:artifactId = projeto : projeto)
  • os repositórios globais, onde o repositório central do Maven é mostrado (configurados em USER_HOME/.m2/settings.xml). Note que seu índice está vazio, pois ainda não foi inicializado.
  • os repositórios do projeto, que estiverem configurados no pom.xml (veremos adiante).
Para saber mais sobre os tipos de repositórios, veja http://www.sonatype.com/books/m2eclipse-book/reference/eclipse-sect-repo-view.html.

A figura acima também é muito importante para entender um problema que o Maven resolve para o desenvolvedor: ele baixa automaticamente as bibliotecas e as organiza no diretório USER_HOME/.m2. Simples assim. E ele fará isso automaticamente para todo desenvolvedor que participar do projeto.

Na maioria dos projetos que não utiliza Maven ou algum outro gerenciador de dependências, o desenvolvedor tem que baixar as bibliotecas nos respectivos sites, selecionar os jars e configurá-los para que estejam no ClassPath da aplicação.

Este cenário, além de trabalhoso, é extremamente frágil. Basta que os desenvolvedores usem diferentes IDEs, ou diferentes sistemas operacionais, para inviabilizar o trabalho em equipe. Mesmo na mesma IDE, no mesmo sistema operacional, se o ClassPath da aplicação não estiver corretamente configurado na máquina de cada desenvolvedor, pode ser que a aplicação não funcione para todos no time.

Portanto, se você ainda não usa o Maven, pare de se torturar! Deixe o Maven gerenciar as dependências para vc e para o seu time!


Ao clicar com o botão direito no nome do repositório são mostradas as opções para habilitar o repositório e para indexá-lo. Para este artigo, optei pela opção "Minimum Index Enabled".

Após habilitado, a reindexação ocorre selecionando a opção "Rebuild Index".

Após a indexação, o repositório listará todas as bibliotecas que ele pode prover:


Neste momento, ao tentar adicionar a dependência spring-context, todas as opções (desde os releases mais recentes aos mais antigos) são disponibilizadas:


Similarmente, adicione a biblioteca spring-jms.


Ao salvar o arquivo pom.xml, o Maven baixa as dependências, o que pode ser visualizado no Console Maven do Eclipse:


Após esta operação, o Maven não só terá baixado as dependências, como configurado as dependências do Spring no Build Path do projeto.

Adicionando o ActiveMQ
Neste exercício, será adicionada a dependência ActiveMQ, e mostrar uma das principais armadilhas do uso incorreto do Maven: o de baixar dependências desnecessárias, devido a descuido na hora de selecionar corretamente as dependências.

PQP, o Maven faz backup da Internet no meu micro
Uma das críticas mais comuns que o Maven recebe é o fato de que, mesmo para projetos pequenos (neste momento ainda estamos com o projeto em branco!!!!) ele faz o download de muitos artefatos, antes que o desenvolvedor possa começar a trabalhar.

Isto pode ficar ainda pior, quando as dependências do projeto são mal configuradas, forçando o download de muitos artefatos que não são efetivamente necessários para o projeto. Isto é ruim tanto para os desenvolvedores - que são forçados a esperar o maven fazer downloads demorados após o primeiro checkout do projeto; e também para o build da aplicação, que além de mais demorado, tende a ficar muito maior do que o necessário.

Vamos entender agora porque isso acontece. O principal fator é que os repositórios públicos (como o Maven Central) estão abarrotados de artefatos, e nem sempre é fácil escolher qual o artefato adequado que deve ser utilizado (isto pode ser minimizado caso se decida gerenciar seus próprios repositórios em servidores locais, utilizando o Nexus, algo que poderá ser visto em artigos futuros).

Tomemos o ActiveMQ como exemplo. Veja a extensa lista de artefatos do grupo activemq que podem ser baixados:
Um desenvolvedor desavisado não perderá seu tempo analisando esta lista, e com certeza irá selecionar o primeiro item da mesma. Aí mora a primeira armadilha. Ao optar pela dependência "óbvia", o desenvolvedor acabará baixando mais artefatos do que ele efetivamente precisará, conforme pode ser visualizado na figura abaixo. Apenas para adicionar o ActiveMQ no projeto, foram baixados mais 40 jars!
Aqui nasce uma das maiores dificuldades de se usar o Maven: como escolher o artefato correto? A resposta pode ser difícil no começo, mas com o tempo, esta verificação tende a ficar mais natural.
  • Primeiramente fique atento às dependências Maven listadas no Package Explorer. Caso, ao adicionar uma dependência, muitos jars sejam adicionados (como na figura acima), isto é um mal sinal.
  • Orientações específicas podem ser encontradas nas documentações oficiais, wikis e foruns de cada biblioteca.
  • Quando o eclipse sugerir muitas opções para o mesmo artefato, seja paciente e analise as opções.
    • Evite artefatos com sufixo-all - eles normalmente contém muito mais jars do que o necessário para o projeto.
    • Procure os artefatos de sufixo -core, costumam conter apenas o essencial para a dependência pesquisada.
    • Fique atento à versão do artefato, para não baixar a dependência errada.
    • Consulte índices de repositório, por exemplo http://mvnrepository.com/, https://repository.jboss.org/nexus/index.html e https://ebr.springsource.com.
    • Faça pesquisas no Google ou outro mecanismo de busca, para ver como outros desenvolvedores estão fazendo.

A dependência correta seria org.apache.activemq : activemq-core. Não só a quantidade de jars importados é bem menor, como se descobre que a versão anterior estava totalmente defasada (a versão atual é 5.4.2, enquanto que a que havia sido baixada inicialmente era 3.2.4).
Portanto, ao usar o Maven, selecione cuidadosamente os artefatos necessários para o projeto!

A segunda armadilha pode ser visualizada na figura acima: perceba que a dependência commons-logging foi adicionada duas vezes, uma pelo Spring (commons-logging-1.1.1), e outra pelo ActiveMQ (commons-logging-api-1.1). Isto é ruim não só por aumentar o tamanho do build, como também por adicionar o risco de adicionar exceções em runtime, caso as APIs das versões não sejam compatíveis entre si.

Para remover as duplicações, é necessário configurar exclusões. O processo é bem parecido com a adição de dependências: o Eclipse ajuda a pesquisar / selecionar a exclusão, através do editor pom.xml. Como sempre, selecione cuidadosamente os artefatos para fazer a exclusão correta.


Além de facilitar a configuração de dependências do projeto, o Maven dá de brinde duas facilidades: a aba Dependency Hierachy evidencia as relações hierárquicas entre os jars importados:

Já a aba Dependency Graph exibe estas relações na forma de um grafo:


Conclusão

Espero que as informações o tenha estimulado a adotar o Maven e as facilidades que ele oferece. O Maven é uma ferramenta poderosa que pode auxiliar e muito o setup de projetos em times de desenvolvimento. No entanto, é necessário utilizá-lo com cuidado e bastante atenção, para que erros grosseiros não degradem o ganho de produtividade que ele nos oferece.

O próximo artigo mostrará como utilizar JMS num container Spring, baseado no setup do projeto realizado neste post.

sábado, 18 de dezembro de 2010

Hands-on: Dependency Management com Maven - Parte 1

"E disse: Maven, a vida é pra valer..."

Neste post, listarei algumas vantagens de se usar o maven em projetos Java - todas de situações que já vivenciei na pele, e que o Maven resolve com agilidade e elegância. No final, segue uma série de screenshots mostrando desde a instalação do Maven no Eclipse, à criação de um projeto e à configuração de algumas dependências.

Happy Maven!

A parte 2 está disponível aqui.

Por que usar Maven?

  • Organização da Aplicação: layout-padrão amplamente aceito entre desenvolvedores
    • classes principais em src/main/java
    • classes de teste em src/test/java
    • arquivos de configuração e recursos em src/main/resources e src/test/resources
    • arquivos de aplicações web (html, jsps, css, etc) em src/main/webapp
  • Baixar e configurar automaticamente as dependências do projeto
    • bibliotecas (jars)
    • os javadocs das dependências, úteis para recursos como auto-complete das IDEs
    • os códigos-fonte das dependências, úteis para debug
  • Configuração de Builds da Aplicação
    • Possui tarefas para compilar (mvn:compile), testar (mvn:test) e empacotar (mvn:package) a aplicação.
    • Build pode ser customizado (mvn:build)
  • Versionamento de código
    • Não coloca jars no controle de versão: Menor tamanho-util do projeto no SCM
    • O pom.xml armazena o histório de dependências
      • Se num determinado branch é usado GWT 1.7, e em outro branch é feito o upgrade para o GWT 2.0
      • Como o pom.xml é versionado, ao migrar entre os branches, o Maven saberá exatamente qual versão da dependência utilizar
  • Trabalho em equipes / Configurações de SO e IDE
    • Versionamento de configurações de IDE são muito frágeis
      • Atreladas ao Sistema Operacional (por exemplo, localização de bibliotecas no filesystem)
      • Atreladas à versão da IDE (pode dar conflito quando são usadas versões diferentes da mesma IDE)
      • Atreladas à IDE (impede que o desenvolvedor utilize sua IDE favorita)
    • Como o Maven pode ser utilizado independente de SO, IDE ou versão da IDE, ele resolve também estes problemas.

ATENÇÃO

Quando mal-configurado, faz "backup da internet inteira no seu micro" - culpa de quem o configurou!

Hands On

Instalar Plugin Maven no Eclipse

Help > Install new software

Digitar o update site do Maven e clicar em Add...

Fornecer um nome para o Repositório Maven (neste caso, M2E)

Selecionar o plugin para a instalação

Em seguida, basta aceitar a Licença de Uso do Maven, aguardar o download e instalação do plugin M2E e reiniciar o Eclipse.


Criar projeto Maven

Após reiniciar o Eclipse, vamos criar um projeto Maven

Ao tentar criar o projeto, o plugin M2E alerta que o Eclipse precisa estar rodando sobre uma JDK. Por padrão, o Eclipse roda sobre a JRE default do sistema, que é simplesmente uma Máquina Virtual Java. O Maven, porém, depende de bibliotecas do Kit de Desenvolvimento Java (JDK) para funcionar. 

Caso ainda não tenha feito, instale uma JDK em sua máquina (por exemplo OpenJDK ou a Oracle JDK), e siga os passos abaixo para o plugin M2E funcionar.

Configurando JDK para o Maven

JRE nas Preferências do Eclipse

Window > Preferences

Java > Installed JREs (note que o Eclipse está usando a jre6 por default). Selecione a jre6 e clique em Editar.

Altere a propriedade JRE home para o diretório onde sua SDK foi instalada, e a propriedade JRE name para jdk6 (ou outro de sua preferência).

Pronto, agora o Eclipse está configurado para usar a Máquina virtual da JDK ao invés da JRE padrão.

Parâmetro -vm no eclipse.ini

Resta apenas alterar a Máquina Virtual sobre a qual o Eclipse é inicializado, o que é feito no arquivo eclipse.ini. localizado no diretório do Eclipse.

Adicione, no início do arquivo, o parâmetro -vm, apontando para a localização do executável javaw.exe que existe no diretório bin da instalação da JDK.

Criar projeto Maven (continuação)

Ao tentar criar o projeto Maven novamente, a mensagem de erro do Maven rodar sobre JDK não mais deve aparecer, e a sequência é ilustrada pelas telas abaixo.

Na tela seguinte, marque a checkbox "Create a simple project", pois neste primeiro momento, não queremos trabalhar com nenhum arquétipo do Maven.

Ao prosseguir, é necessário informar os dados do projeto. Em Group Id, é uma boa prática colocar o nome do pacote do projeto, em Artifact Id, o nome do Projeto. Por enquanto, deixe as demais opções como estão e clique em Finalizar.


Resultado:

Note que o projeto criado pelo Maven foi configurado, por padrão, para usar um ambiente de execução Java 5. Isto pode ser consertado com alguns passos simples:

Clique com o botão direito sobre o nome da JRE do projeto, e selecione a opção Configure Build Path

Selecione a JRE e clique no botão Edit

Marque a opção "Workspace default JRE" ao invés de "Execution Environment / J2SE5"

Layout final do Projeto e o arquivo POM (Project Object Model)

Agora, com o projeto corretamente configurado, abra o arquivo pom.xml. Trata-se de um arquivo xml onde são feitas as configurações do projeto. O Eclipse possui editores visuais que facilitam a edição deste arquivo, evitando que tenha que escrever xml "à mão". O arquivo xml pode ser editado diretamente, na aba pom.xml, mas para este tutorial, usaremos os recursos visuais que o Eclipse oferece.



Adicionando algumas dependências no Projeto

Como em próximos artigos pretendo abordar o desenvolvimento de projetos GWT usando Maven, simularei a adição das bibliotecas gwt-user e gwt-servlet no projeto. O mesmo conceito é válido para adicionar a maioria das bibliotecas existentes, como Spring, Hibernate, Guice, Struts, etc... Na aba Dependency, clique em Add.

Digite o nome da biblioteca que deseja localizar. Note que o Eclipse exibe o resultado da pesquisa exibindo o groupId (com.google,gwt) e o artifactId (gwt-user) do artefato localizado. Note também que, por padrão, o Eclipse realiza pesquisa de dependências no repositório central do maven (http://repo1.maven.org/).


É possível configurar o Eclipse para pesquisar dependências em outros repositórios - por exemplo https://repository.jboss.org/nexus/content/groups/public/. Para tal, é necessário configurar um arquivo MAVEN_HOME/settings.xml (isso será abordado em um outro artigo).

Importamos também a biblioteca GWT-Servlet:

Depois de adicionar as dependências e salvar o arquivo pom.xml, o plugin do Maven se encarrega de baixar as dependências e configurar o Build Path da aplicação.

Pronto! O projeto está configurado, e as bibliotecas do GWT disponíveis para desenvolvimento.
Note, ao lado das bibliotecas em Maven Dependencies, que o plugin do Maven as salvou no diretório HOME do usuário, em um subdiretório .m2. Este será o repositório de bibliotecas que o Maven utilizará para gerenciar as dependências dos projetos.

Por agora é só, espero que este tutorial seja esclarecedor e motive a utilizar essa ferramente poderosa que é o Maven!