Nelson França - Construção de arquétipos para o Apache Maven

(1)

Construção de arquétipos para o Apache Maven

Nelson Antonio Lataliza França, Marcos A. Lopes da Silva

Instituto de Informática – Centro Universitário do Triângulo (UNITRI) Caixa Postal 309 – 38.411-106 – Uberlândia – MG – Brasil

nelson336@yahoo.com.br, malopes21@gmail.com

Resumo. Este artigo apresenta quatro demonstrações de arquétipos (archetypes) construídos utilizando a ferramenta Maven. Foram construídos arquétipos do tipo Webapp, que utilizam framework e bibliotecas para desenvolvimento no ambiente java. Nesse contexto, cabe mencionar que os resultados obtidos se referem à automatização de projetos e, ainda, o ganho de agilidade no processo de desenvolvimento no ambiente java. É comum baixar arquivos de frameworks e componentes para adicioná-los em uma pasta de um projeto. Contudo, o Maven é uma ferramenta que baixa e referencia arquivos que necessitavam de download, eliminando a necessidade de baixa-los e centralizar as informações do projeto em um arquivo denominado de POM (Project Object Model).

1. Introdução

O Java além de linguagem, é também uma das plataformas de desenvolvimento mais utilizadas no mercado e, portanto, um dos fatores de contribuição é a flexibilidade da linguagem para o desenvolvimento em diversas plataformas quais sejam: dispositivos móveis, Desktops e Web.

O Maven é uma boa opção para gerenciar as dependências do projeto em Java e criar arquétipos ou usar os que estão prontos, conforme a necessidade do projeto.

Archtypes são modelos de projetos pré-definidos com uma estrutura pronta que podem

atender as necessidades do desenvolvedor. Cabe ainda, ao desenvolver, escolher a maneira pela qual irá modificar o arquétipo, para então, suprir os requisitos necessários ao projeto.

Pelos benefícios que o Maven apresenta, é crescente o número de usuários que optaram por usar a ferramenta e, no entanto, acabaram desistindo por não saber configurá-lo. Nesse contexto, este artigo contribui demonstrando a montagem de projetos utilizando o Maven e também para a construção de arquétipos.

2. Processo de Montagem (Build) em Java

O objetivo principal do processo de build (construção) é compilar os arquivos e empacotar todo o projeto, gerando um arquivo (package) único. No Java o arquivo gerado pelo empacotamento tem o formato ZIP (comprimido) com as extensões nos formatos: JAR, EAR, WAR ou RAR [Calvacanti 2008].

O processo de build realiza testes durante o empacotamento para constatar se existe algum erro no projeto. Os erros que podem ocorrer são relativos a falta de dependências para o funcionamento do projeto, implantação. Contudo, após a compactação, é constatado se houve êxito ou não no processo de build [Calvacanti 2008]. Cumpre mencionar ainda, que existem várias ferramentas que automatizam esse processo. As principais ferramentas são o Ant, Maven e o Gradle que serão citadas no decorrer deste artigo e será realizado uma breve síntese analítica das três ferramentas.

(2)

2.1. Apache Ant

O Ant também é uma ferramenta da Fundação Apache e como o seu antecessor, tem como principal tarefa realizar o processo de build (compilação, criação de arquivos finais, criação de documentação). Essa ferramenta utiliza a linguagem XML e através de tags, é executada uma série de ações dependentes umas das outras para alcançar um determinado objetivo. Por exemplo: para compilar um determinado arquivo, é preciso deletar arquivos antigos com extensão (.class), compilar todos os arquivos dos diretórios especificados e coloca-los em outros diretórios [Ricardo 2014].

O arquivo principal do Ant é o (build.xml) em que são executados roteiros escritos em XML. Esse arquivo se baseia em tarefas, alvos e pontos de extensão, ou seja, é composto de coleções de alvos, que são sequencias de tarefas e cada tarefa é uma instrução a ser feita [Rocha 2002].

Uma das vantagens do Apache Ant é a possibilidade de criar instruções (scripts) utilizando a linguagem XML. A finalidade é executar tarefas comuns em um projeto tais como: o processo de build, inicialização do banco de dados, atualização do código para um sistema de controle de Versões (GitHub, Google Code, etc) [Lozano 2008].

2.2. Apache Maven

O Maven pode ser considerado o sucessor do Ant, também da Fundação Apache. Essa ferramenta gerencia a configuração do seu projeto de uma maneira descomplicada, além de compilar o código-fonte e o de teste, empacota todo o projeto [Branas 2012].

O arquivo principal do Maven é o pom.xml (POM - Project Object Model), onde são declaradas todas as suas configurações do projeto. É semelhante ao build.xml do ant, em que o arquivo principal fica na raiz do projeto e lá são declaradas targets em

xml. A diferença entre os dois, é que no Ant, o XML é utilizado praticamente como uma

linguagem de programação, na qual são usados comandos para se executar determinada tarefa. Essa linguagem é utilizada apenas para definir a estrutura do projeto, que por meio dela, são incluídas as targets específicas para realizar uma tarefa. A exemplo disso, para compilar um projeto no Ant cria-se uma tag chamada Javac, porém, no Maven não há necessidade dessa configuração, pois o mesmo possui uma tag própria, excluindo a necessidade de criá-la, sendo que este por padrão vem configurado [Calvacanti 2008].

No Maven existem targets de plugins, no qual em grande parte, possibilita a execução via linha de comando no (prompt) de comandos no Windows, ou, o console no Linux. A sintaxe do comando é simples, e é apresentada da seguinte forma: (mvn [nomedoplugin]:[target]) onde o nome do plugin é o objetivo de execução, a target é a ação a ser executada com o objetivo, por exemplo, para criar um arquétipo simples usa-se o usa-seguinte comando: (mvn archetype:create), onde o archetype é o alvo (plugin), a ação (targets) a ser executada é criar o modelo de arquétipo mencionado [Calvacanti 2008].

2.3 Gradle

O Gradle é a mais recente ferramenta para automatização de builds, desenvolvido pela Gradle Inc, uma empresa pioneira em ferramentas de construção de software. Esta ferramenta proporciona os mesmos benefícios das ferramentas que foram referidas anteriormente, quais sejam: gerenciamento de dependências e padronização do projeto de maneira eficaz, além de melhorias e novas funcionalidades [Maciel 2014].

(3)

Ainda sobre o Gradle, essa ferramenta não utiliza a linguagem XML como as ferramentas especificadas anteriormente. Este utiliza uma linguagem própria para criação de scripts denominada Groovy, gerando um contexto simples em seu script, o qual facilita o entendimento. Antigamente utilizava-se o Apache Yvy (gerenciador de dependências), atualmente a própria ferramenta gerencia as dependências [Farcic 2014]. Na época em que foram desenvolvidas as ferramentas mencionadas, havia a necessidade de uma linguagem simples e que sua estrutura fosse de fácil entendimento. Portanto, optaram por usar a linguagem XML como linguagem padrão que viesse a atender esses requisitos. O XML é ser considerado simples, porém, limita o desenvolvedor, a seguir à risca as instruções XML criadas pelas ferramentas. Nesse contexto, dependendo do tamanho do código-fonte, parecerá confuso aos usuários iniciantes [T. Berglund, M. McCullough 2011].

Em contrapartida, sobre as desvantagens da linguagem mencionada, a versão atual da ferramenta integra o Groovy (linguagem de programação que executa a JVM com sintaxe similar a do Java) em seus arquivos de compilação, permitindo a configuração e implementação de lógica de programação, proporcionando ainda mais recursos ao programador, melhorando assim, a usabilidade dos scripts [T. Berglund, M. McCullough 2011].

Pelo fato da linguagem Groovy ser baseada no Java, herda algumas de suas principais características, que no ato da compilação dessas linguagens, são transformadas em bytecode (linguagem de nível intermediário) que é executada pela JVM [Castellani 2009].

3. Características e Estrutura do Maven

Conforme mencionado, o Maven proporciona ao usuário boas práticas de desenvolvimento e, ainda, vários benefícios referentes a centralização das configurações e informações em um arquivo único, facilitando dessa forma, a manutenção do projeto.

Sua característica principal é o gerenciamento de dependências, que elimina a necessidade de adicionar arquivos de frameworks e API’s dentro do projeto, o que causa lentidão no processo de desenvolvimento. A estrutura de projeto é padronizada de forma que todos os projetos têm a mesma estrutura, evitando o estranhamento do desenvolvedor ao fazer migração [Ricardo 2014]. Nesse contexto, a seguir serão exibidos em tópicos, o detalhamento sobre os conceitos principais da ferramenta.

3.1 Ciclos de vidas padrões do Maven

Ciclo de vida é um conjunto de fases pré-definidas que são executados na compilação do projeto o qual segue uma ordem ou sequência. Existem 3 tipos de ciclos (clean,

default e site) e cada um é dividido em um conjunto de fases [Sonatype 2008].

O clean é o primeiro ciclo executado e, ainda, é o mais simples comparado aos outros, pois sua função é limpar. Este ciclo executa ainda, a reciclagem dos arquivos criados no ciclo default, que será especificado adiante [Sonatype 2008]. Este ciclo é subdivido em outras 3 etapas:

1. Pré-clean: responsável por verificar a existência de arquivos inutilizáveis. 2. Clean: a principal atividade do ciclo, onde é feito a limpeza das saídas do

processo de construção (build), deletando os diretórios gerados na compilação que não tem mais utilidade.

(4)

O ciclo default é o principal ciclo nesse contexto, pois ele é responsável por instalar arquivos, representados pelas dependências mencionadas no arquivo de centralização do projeto, que é o pom.xml [Sonatype 2008]. Este ciclo é composto por 8 etapas:

1. Validate: responsável pela validação do projeto, verificando a falta de dependências, repositórios e arquivos.

2. Compile: compilação do projeto. 3. Test: testa o projeto em busca de erro.

4. Package: empacota o projeto em um arquivo zipado, com a extensão que foi determinada no arquivo pom.xml, que pode ser JAR, EAR, WAR ou

RAR.

5. Integration-test: instala e executa o pacote criado pelo ante exposto, em um ambiente voltado apenas para teste.

6. Verify: verifica se ocorreu algum erro na etapa anterior. 7. Install: instala o pacote em um ambiente local para uso. 8. Deploy: copia o pacote para repositórios remotos (servidores).

Existe também um ciclo responsável pela documentação (Site), no qual dentre suas funções principais, está o gerenciamento de toda a documentação e criação dos arquivos relacionado a documentação [Sonatype 2008].

3.2 Tipos de Estrutura (Arquétipos) do Maven

Desenvolver um novo projeto do início, se torna uma tarefa fácil, bastando poucos passos para sua execução. O Maven contém o recurso de Arquétipos, que automatiza a criação de uma nova estrutura, criando-a de forma simples, sem a necessidade de o usuário implementar manualmente [Mantovani 2014].

As IDE’s (Integrated Development Environments - Ambientes de Desenvolvimento Integrado) do mercado como o Eclipse, possuem a opção de escolher o template que o usuário deseja utilizar [Mantovani 2014]. No entanto, caso os

arquetypes existentes não atendam a necessidade do desenvolvedor, basta procurar o

nome de um modelo e utilizar o comando (mvn [nome do arquétipo]:generate) para criá-lo. Existem diversos arquétipos prontos e disponíveis para uso, que são então mencionados na tabela 1 [Apache Maven Inc 2015].

Tabela 1. Exemplos de Archtypes prontos

Archtypes _Descrição

maven-archetype-archetype Gera um arquétipo padrão simples

maven-archetype-j2ee-simple Gera um modelo simplificado que contém o Java EE_{para utilização.} maven-archetype-quickstart Gera uma demonstração de projeto Maven.

(5)

maven-archetype-site-simple Projeto Web simples.

maven-archetype-webapp Projeto Maven Webapp.

Cada modelo da tabela 1, depois de criado, basta importar para o ambiente de desenvolvimento (IDE) para a continuidade do projeto, que será especificado no decorrer deste artigo.

O objetivo principal é que o usuário alvo gere um modelo pré-definido de projeto, de acordo com a sua necessidade, após isso o arquétipo se encarrega de organizar a estrutura inicial. Por exemplo, ao criar um projeto utilizando o arquétipo (maven-archetype-webapp) referente a figura 1, o Maven gera uma estrutura padrão para o projeto com a finalidade de facilitar o desenvolvimento Web, utilizando a linguagem XML. Entretanto, a raiz do projeto é composta pelo src (diretório com os arquivos principais de código-fonte do projeto), o arquivo pom.xml (arquivo de centralização na linguagem XML, contendo as configurações e informações do projeto) e também a pasta target cuja função é adicionar arquivos outrora compilados, como, por exemplo: o package do projeto [Souza 2009].

Figura 1. Estrutura do Arquétipo WebApp

Conforme mencionada, a pasta src contém os arquivos de código-fonte do projeto e o mesmo é divido em 2 pastas: pasta a main (principal) e a pasta test (teste). Dentro da main estão contidas as pastas Java que tem a finalidade de agregar os arquivos e as classes pertencentes ao projeto. Codificado em linguagem Java, a pasta

resource armazena outros arquivos. No arquétipo ante exposto, além dessas duas pastas

mencionadas, existe também a pasta webapp, cuja a função é armazenar todos os arquivos relacionados a web, tais como: páginas, arquivos “.js” e etc, voltando para a pasta src. Na pasta test estão contidos os diretórios java e resource que possuem a mesma finalidade dos diretórios, e também a mesma finalidade da pasta main, porém seu foco está voltado para testes [Souza 2009].

3.3 Arquivo de centralização do Projeto

Um projeto Maven contém um arquivo XML denominado pom.xml, que contém todas as informações do projeto como, por exemplo, suas dependências, tal como a principal função do Maven, que é gerenciar todas dependências [Fidel 2015].

O POM, conforme apresenta a figura 2, começa com uma tag principal denominada project que remete a todo o projeto informações e configurações, bem como a versão, que no caso desse exemplo que referencia a versão: “0.0.1-SNAPSHOT”, representado que o projeto ainda está na fase de desenvolvimento, contendo o nome do projeto, tipo de empacotamento, entre outras [Fidel 2015].

(6)

<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/maven-v4_0_0.xsd">

<version>0.0.1-SNAPSHOT</version> <name>TCC Maven Webapp</name> <url>http://maven.apache.org</url> <dependencies>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>org.apache.commons</groupId>

<artifactId>commons-lang3</artifactId>

Figura 2. Arquivo POM.XML

A tag dependencies estabelece as dependências do projeto. Cada biblioteca e

framework que é usado como dependência do projeto é especificado pela tag dependency e todas ficam dentro da tag que a agrega (dependencies). Para especificar

cada dependência na sua própria tag que é denominada dependency, é necessário determinar ainda outras 3 tags: (groupId, artifactId e version), dentro do mesmo [Fidel 2015].

O groupId descreve o autor (empresa, pessoa ou projeto) em que a dependência (biblioteca) referenciada pertence. Na figura 2 utiliza-se a biblioteca Apache Commons, o groupId é org.apache.commons, que representa o nome do projeto e a empresa onde foi desenvolvido a biblioteca. Em seguida, é determinado o artifactId, em que é especificado o nome da biblioteca, depois na version que é a versão da biblioteca [Fidel 2015].

4 Criação de Modelos de projeto (Arquétipos)

Essa seção demonstrara como instalar o Maven, seus requisitos de instalação e, ainda, a criação de alguns exemplos de arquétipos.

4.1 Requisitos e instalação do Maven

A página oficial do Maven concede várias versões para diversos Sistemas Operacionais quais sejam: Windows, Linux e Mac para download, porém, a melhor opção é escolher a última versão por obviamente estar atualizada, sendo uma destas, a plataforma que o desenvolvedor irá utilizar [Ricardo 2014].

Ao instalar, necessita-se configurar a variável de ambiente (que aponta o local da instalação) M2_HOME e verificar se existe a variável JAVA_HOME. Caso não exista é necessário criá-la, pois ela indica a localização do ambiente Java. A

(7)

configuração dessas variáveis muda de acordo com o Sistema Operacional, e no caso do Windows fica nas propriedades do sistema [Ricardo 2014].

Dependendo da organização responsável pelo projeto, é comum o uso do proxy para controle de portas e acesso à internet. Essas organizações na maioria das vezes terão problemas de bloqueio no Maven quando for necessário buscar dependências em repositórios. Para eliminar o problema narrado deve realizar a configuração de tais requisitos quais sejam: portas, host, usuário e senha do servidor no arquivo settings.xml, dentro da pasta conf, situada na raiz da ferramenta [Ricardo 2014].

4.2 Escolha de Arquétipos

Os arquétipos escolhidos estão voltados para desenvolvimento na plataforma Web com frameworks, onde algumas funcionalidades usadas atualmente no mercado facilitam o empenho em tarefas comuns nesse ambiente. Foram estritivamente criados 4 arquétipos para estudo de caso:

1. Projeto JEE (Java Platform, Enterprise Edition – Plataforma Java Edição Empresarial);

2. Projeto JSF (Java JavaServer Faces – especificação para o desenvolvimento na plataforma WEB utilizando a linguagem Java e componentes voltados para este ambiente), JPA (Java Persistence API (Interface de Programação de Aplicação) e CDI (Contexts and Dependency Injection - especificação integrada da JEE, responsável por gerenciar as dependências do projeto);

3. Projeto JSP (JavaServer Pages – especificação da JEE que dar suporte nas construções de páginas em XML e HTML), e, ainda JPA;

4. Projeto com Spring (framework com função semelhante ao CDI, responsável por injetar as dependências no projeto), e, também a JPA.

4.3 Criação de Arquétipos

Para criar os arquétipos citados no tópico 4.3, utiliza-se como modelo de referência o arquétipo webapp, sendo necessário executar um script no prompt de comando para gerá-lo. Por conseguinte, é necessário navegar até o local onde está situada a instalação do Maven. Se tudo estiver configurado da maneira correta, basta executar o script na raiz da instalação para que seja gerado um arquétipo webapp. O dado script é composto por um conjunto de comandos simples que definem o arquétipo escolhido e as informações básicas do projeto quais sejam:

1. Mvn archetype:generate: é uma target padrão do maven para criar um arquétipo. 2. -DarchetypeGroupId=org.apache.maven.aorchetypes: comando que especifica o

local onde será buscado o arquétipo para download.

3. -DarchetypeArtifactId=maven-archetype-webapp: comando que demonstra qual o arquétipo escolhido, e nesse caso foi um do tipo webapp.

4. -Dversion=1.0-SNAPSHOT: comando com a versão do projeto, nesse caso demonstra que essa versão está em desenvolvimento ainda.

5. -DgroupId=grupo.exemplo: comando em que é especificado o grupo ou pessoa responsável pelo projeto.

6. -DartifactId=exemplo: comando em que é colocado o nome do projeto.

Após criar os arquétipos, é necessário adicionar as dependências das plataformas e frameworks para utilização do projeto, dentro do arquivo pom, onde estão

(8)

centralizadas todas as informações. O arquivo pom contém as informações especificadas pelo script de criação do arquétipo, quais sejam: nome, autor e versão. Todavia, por ser um projeto do tipo web, o tipo da extensão do pacote especificado por padrão é WAR.

Após a especificação das dependências, utiliza-se o comando (mvn compile) para compilar todo o projeto. Caso tudo esteja correto, o Maven faz o download das dependências mencionados no arquivo pom, em um repositório especificado e que por padrão é utilizado o seu próprio repositório local. Para importar para uma IDE, a qual uma possui um comando que prepara o projeto para permitir a importação para IDE desejada. No caso do eclipse utiliza-se o comando: (mvn eclipse:eclipse) e, ainda, é possível empacotar todo o projeto bastando utilizar o comando: (mvn package) que gerará o pacote com a extensão mencionada no arquivo pom do projeto.

4.4 Arquetipo WebApp JEE

Esse arquétipo é utilizado em conjunto com frameworks e ferramentas de tal forma, que este torna-se completo para desenvolvimento em Java (JEE - Java Platform, Enterprise

Edition), especialmente voltado para web por utilizar um modelo do tipo WebApp.

Após a etapa de criação do o arquétipo WebApp utilizando o script mencionado no tópico 4.3 (Criação de Archtypes), basta adicionar as dependências que o Maven faz o download automaticamente para um repositório local padrão. É possível alterar o repositório no arquivo: settings.xml, localizado na raiz da instalação da ferramenta.

A figura 3 (Dependências do projeto JEE), demonstra as dependências necessárias para o referido arquétipo.

<dependencies> <dependency> <groupId>javax.jms</groupId> <artifactId>javax.jms-api</artifactId> <version>2.0.1</version> </dependency> <dependency> <groupId>com.sun.faces</groupId> <artifactId>jsf-api</artifactId> <version>2.2.12</version> </dependency> <dependency> <groupId>com.sun.faces</groupId> <artifactId>jsf-api</artifactId> <version>2.2.12</version> </dependency> <dependency> <groupId>javax.enterprise</groupId> <artifactId>cdi-api</artifactId> <version>1.2</version> </dependency> <dependency> <groupId>org.jboss.spec.javax.ejb</groupId>

(9)

<artifactId>jboss-ejb-api_3.2_spec</artifactId> <version>1.0.0.Final</version> </dependency> <dependency> <groupId>javax</groupId> <artifactId>javaee-api</artifactId> <version>7.0</version> <scope>provided</scope> </dependency> </dependencies>

Figura 3. Dependências do Projeto JEE 4.5 Arquétipo WebApp JSF, JPA e CDI

Este projeto utiliza a especificação JSF do Java composto por componentes para desenvolvimento web, em que é necessário utilizar as classes (beans), que é onde está localizado o código fonte Java com os métodos e propriedades que são utilizados na página JSF. O CDI é uma especificação (documentação) cujo foco é administrar a injeção de dependência do projeto.

O Weld é uma implementação do CDI. A JPA é uma API que auxilia o desenvolvedor no ato de implementar a comunicação entre a aplicação e o banco. Existem diversas implementações do JPA para utilização em projetos, mas, para a demonstração do estudo de caso será utilizado o Hibernate, que é uma implementação da JPA.

A figura 4 (Dependências do Projeto com JSF, JPA e CDI), demonstra as dependências necessárias para o referido arquétipo.

<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <dependency> <groupId>com.sun.faces</groupId> <artifactId>jsf-api</artifactId> <version>2.2.12</version> </dependency> <dependency> <groupId>org.hibernate.javax.persistence</groupId>

(10)

<artifactId>hibernate-jpa-2.1-api</artifactId> <version>1.0.0.Final</version> </dependency> <dependency> <groupId>javax.enterprise</groupId> <artifactId>cdi-api</artifactId> <version>1.2</version> </dependency> </dependencies>

Figura 4. Dependências do Projeto com JSF, JPA e CDI 4.6 Arquétipo WebApp JSP e JPA

Esse arquétipo utiliza a tecnologia JSP, que é uma especificação para construir páginas associando outras linguagens, tais como: HTML e JSTL (JavaServer Pages Standard

Template Library) que é uma biblioteca de tags da JSP e, ainda, o Hibernate (JPA) que

facilita a programação no ato de utilização do banco de dados na aplicação.

A figura 5 (Dependências do Projeto com JSP e JPA), demonstra as dependências necessárias para o arquétipo ante exposto.

<dependencies> <dependency> <groupId>org.hibernate.javax.persistence</groupId> <artifactId>hibernate-jpa-2.1-api</artifactId> <version>1.0.0.Final</version> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jsp-api</artifactId> <version>2.0</version> </dependency> <dependency> <groupId>jstl</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> </dependencies>

Figura 5. Dependências do Projeto com JSP e JPA 4.7 Arquétipo WebApp Spring e JPA

Esse arquétipo utiliza framework Spring para controlar as injeções de dependências declaradas no Maven e também no Hibernate (JPA). No dado exemplo a seguir, é

(11)

declarado o repositório oficial conforme demonstra a figura 6, onde será buscado o

framework, para que dessa forma, seja executado o download automaticamente pelo

Maven, (Dependências do projeto com spring e JPA e repositório do spring).

<groupId>junit</groupId>

<artifactId>junit</artifactId> <version>3.8.1</version>

<groupId>org.springframework</groupId>

<artifactId>spring</artifactId> <version>2.5.6</version>

</dependency> <dependency>

<groupId>org.springframework.data</groupId>

<artifactId> spring-data-jpa</artifactId>

<version>1.9.0.RELEASE</version> </dependency>

<groupId>org.hibernate.javax.persistence</groupId>

<artifactId> hibernate-jpa-2.0-api</artifactId>

<version>1.0.1.Final</version> </dependency> </dependencies> <repositories> <repository> <id>repository.springframework.maven.release</id>

(12)

<name>Spring Framework Maven Release Repository</name>

<url>http://maven.springframework.org/release</url> </repository>

</repositories>

Figura 6. Dependências do projeto com spring e JPA e repositório do spring 5.Conclusão

Um dos problemas comuns ao desenvolvedor é configurar todo o ambiente de desenvolvimento, e só então começar o projeto. O narrado problema faz com que seja necessário fazer o download de diversos arquivos, ne dessa forma consome um certo tempo do desenvolvedor, e consequentemente atrasando o desenvolvimento. A fim de eliminar o problema, surgiram no mercado algumas ferramentas para automatização de projetos, essas ferramentas focam em facilitar o desenvolvimento e, no entanto, o Ant, o Maven e o Gradle são consideradas as principais ferramentas de automatização de projetos.

Esse trabalho demonstrou os benefícios de se utilizar Maven e a facilidade que essa ferramenta proporciona no que se refere a criação de arquétipos voltados para desenvolvimento em Java. Cumpriu a este trabalho, a implementação de 4 distintos arquétipos, do tipo WebAPP (aplicação com foco no desenvolvimento para web), executando um script utilizando comandos simples na raiz da instalação da ferramenta. Despois de criado foi declarado as dependências no arquivo POM do projeto, que é o responsável por centralizar todas as informações do projeto. Em seguida foi executado outro comando comum ao Maven para a compilação do projeto, e caso não existam erros, o projeto é empacotado.

Não foram encontradas muitas dificuldades para a implementação dos arquétipos. Em contrapartida, houveram alguns erros no ato de criar o arquétipo

Web-App. O erro era gerado no ato da execução do script, que exibia uma mensagem de erro

informando que o arquétipo não havia sido encontrado. Cabe acrescentar ainda, que se houvessem erros nas dependências do projeto no momento de empacotar do projeto, ocasionava uma falha no processo de build.

Após o descrito, os resultados que foram obtidos são 4 arquétipos prontos para utilização, bastando apenas importar para a IDE, para dar início ao desenvolvimento. Para o estudo de caso deste trabalho foi escolhido o Eclipse. Antes de fazer as devidas importações para ele, foi necessário executar o comando que gera os arquivos e as pastas do Eclipse. Contudo, após executar o comando basta importar o arquétipo para a

IDE.

O Maven é o sucessor do Ant, e como esperado ele tem algumas vantagens em comparação ao Ant, essas vantagens traduzem-se em comandos pré-definidos, prontos para utilização os quais executam tarefas comuns no que se refere a compilação ou empacotação do projeto, excluindo a necessidade de declarar o código para executá-lo no arquivo de centralização (build.xml), no caso do Ant.

O Gradle por ser uma ferramenta muito recente, leva a maior parte dos desenvolvedores a optarem por utilizar o Maven. O Gradle utiliza a linguagem Grovvy que pode ser uma vantagem. Isso ocorre pelo falo de sua sintaxe ser de fácil

(13)

entendimento. Em contrapartida, é uma desvantagem por esta ser uma linguagem pouca conhecida.

Contudo, o Maven em relação ao Gradle se destaca pela sua simplicidade, o que facilita a familiarização para com os desenvolvedores iniciantes. Por falta de conhecimento dos desenvolvedores de como o utilizar, pelo motivo de ainda não ser reconhecido no mercado atual, sugere-se para trabalhos futuros pesquisar profundamente os conceitos do Gradle, utilização da linguagem Grovvy e a construção de projetos utilizando a ferramenta.

7. Referências

Apache Maven Inc (2015), Guide to Creating Archetypes. Disponível em < https://maven.apache.org/guides/mini/guide-creating-archetypes.html>. Acessado em 26 de setembro de 2015.

Branas, Rodrigo (2012), Maven em 10 minutos. Disponível em <http://pt.slideshare.net/rodrigobranas/maven-em-10-minutos?qid=83cd2914-9850-4264-812c-dda661ab58f8&v=qf1&b=&from_search=1>. Acessado em 20 de setembro de 2015.

Castellani, Marcelo (2009), Artigo Java Magazine 69 - Um pouco de Groovy disponível em <http://www.devmedia.com.br/artigo-java-magazine-69-um-pouco-de-groovy/12874#ixzz3rxvwD8Py>. Acessado em 21 de setembro de 2015.

Calvacanti, Lucas (2008), Processo de build com o Maven. Disponível em < http://blog.caelum.com.br/processo-de-build-com-o-maven/>. Acessado em 20 de setembro de 2015.

Farcic, Viktor (2014), Java Build Tools: Ant vs Maven vs Gradle. Disponível em < http://technologyconversations.com/2014/06/18/build-tools/>. Acessado em 20 de setembro de 2015.

Fidel, Brunno (2015), Gerenciamento de dependências no Java. Disponível em < http://www.devmedia.com.br/gerenciamento-de-dependencias-no-java/32811>.

Acessado em 27 de setembro de 2015.

Lozano, Fernando (2008), Conhecendo o Ant. Disponível em Revista Java Magazine Edição 36.

Maciel, Lucio (2014), Gradle??? É de comer ou passar no cabelo?. Disponível em < http://luciofm.com/gradle-de-comer-ou-passar-no-cabelo//>. Acessado em 20 de setembro de 2015.

Mantovani, Ricardo (2014), Maven – Utilizando o Apache Maven e M2Eclipse. Disponível em <http://desenvolvimentoaberto.org/2014/10/16/maven-utilizando-o-apache-maven-no-eclipse-java/#respond>. Acessado em 26 de setembro de 2015.

Ricardo, Luiz 2014, Uma introdução ao Ant. Disponível em <http://luizricardo.org/2014/03/uma-introducao-ao-ant/>. Acessado em 15 de setembro. Rocha, Helder (2002-2003), Introdução ao Apache Ant. Disponível em <http://argonavis.com.br/cursos/java/j820/j820_02_ant.pdf>. Acessado em 15 de setembro de 2015.

Ricardo, Luiz (2014), Instalando, configurando e usando o Maven para gerenciar suas

(14)

<http://luizricardo.org/2014/06/instalando-configurando-e-usando-o-maven-para-gerenciar-suas-dependencias-e-seus-projetos-java/>. Acessado em 26 de setembro de 2015.

Ricardo, Luiz (2014), Instalando, configurando e usando o Maven para gerenciar suas dependências e seus projetos Java. Disponível em <

http://luizricardo.org/2014/06/instalando-configurando-e-usando-o-maven-para-gerenciar-suas-dependencias-e-seus-projetos-java/>. Acessado em 24 de setembro de 2015.

Sonatype, Inc. (2008), Cap 4: The Build Lifecycle. Disponível em Livro Maven: The Complete Reference Edição 1, pags 52 a 58. Acessado em 25 de setembro de 2015. Souza, Fabrício (2009), Criando um projeto Maven no Linux. Disponível em < http://fabriciojf.blogspot.com.br/2009/03/criando-um-projeto-maven-no-linux.html>. Acessado em 27 de setembro de 2015.

T. Berglund, M. McCullough. (2011), Build Files in Groovy, Disponivel em livro Building and Testing with Gradle pag 2. Acessado em 21 de setembro de 2015.