Maximiliano Guzenski :: Desenvolvedor Web

Spring Roo é um dos mais novos projetos do Spring Source que possibilita o desenvolvimento ágil de aplicações web nos melhores moldes do Ruby on Rails e Grails, mas em 100% puro Java. A arquitetura base dos projetos criados a partir dele utilizam Maven 2, Spring 3 (com restful na camada de controller), JPA, Bean Validator (JSR 303), JUnit, Selenium e entre outros.

Para compreender essa introdução você precisa conhecer o básico do Maven, ApectJ e Spring-mvc.

Instalação

Baixe a última versão do Spring Roo (que atualmente está na versão 1.0.0.M2) e adicione a pasta "bin" no path do seu sistema operacional. Você também vai precisar ter o Maven (versão igual ou superior a 2.0.9) instalado, para mais informações consulte o site oficial.

Criando nosso primeiro projeto

Para exemplificar o uso do Spring Roo vamos criar uma aplicação web simples para uma livraria. Nossa primeira tarefa é desenvolver uma tela para o cadastro de livros, os demais recursos serão desenvolvidos em artigos futuros.

Agora que temos uma ideia do sistema que queremos vamos usar o Roo para construí-lo! Nosso primeiro passo é criar um diretório vazio e carregar o terminal do Roo:

$ mkdir livraria-roo
$ cd livraria-roo
$ roo

Se você seguiu os passos de instalação você deverá ver a imagem abaixo, caso contrário reveja sua instalação!

Dica: Há alguns recursos de usabilidade no shell do Roo. Se você digitar "hint" instruções passo-a-passo irão lhe guiar durante todo o ciclo de desenvolvimento. Se você digitar "help" uma lista com descrição de todos os comandos será apresentada. Você pode utilizar o TAB para auto completar praticamente todos os comandos e parâmetros disponíveis. Não esqueça, durante a fase de aprendizado que o "hint" é o seu melhor amigo

Agora vamos iniciar nosso projeto:

roo$ create project -topLevelPackage br.com.livraria -projectName livraria-roo
Created E:\tmp\livraria-roo\pom.xml
Created SRC_MAIN_JAVA
Created SRC_MAIN_RESOURCES
Created SRC_TEST_JAVA
Created SRC_TEST_RESOURCES
Created SRC_MAIN_WEBAPP
Created SRC_MAIN_RESOURCES\applicationContext.xml

O comando "create" cria a estrutura maven 2 de diretórios e alguns arquivos. Mesmo que você pare de usar o Roo nesse momento já terá uma aplicação spring-mvc 3 configurada e com um tomcat embutido através do maven.

Se você digitar "hint" o Roo irá lhe sugerir para instalar o jpa e um banco de dados. Então vamos fazê-lo:

roo$ install jpa -provider HIBERNATE -database HYPERSONIC_PERSISTENT
Created SRC_MAIN_RESOURCES\META-INF
Created SRC_MAIN_RESOURCES\META-INF\persistence.xml
Created SRC_MAIN_RESOURCES\database.properties
Managed SRC_MAIN_RESOURCES\applicationContext.xml
Managed ROOT\pom.xml

Veja que escolhemos o hibernate como implementação do JPA e um banco de dados Hypersonic, lembre-se que você não precisa decorar estes comandos nem seus parâmetros, basta utilizar a tecla TAB. Note também que o Roo atualizou nosso pom.xml do maven com as novas dependências.

Passos opcionais:

Caso queira ver as configurações do banco de dados digite:

roo$ database propertie
database.driverClassName = org.hsqldb.jdbcDriver
database.password =
database.url = jdbc:hsqldb:${user.home}/livraria-roo
database.username = sa

Você pode alterar essas configurações pelo shell:

roo$ database set -key database.url -value jdbc:hsqldb:${user.home}/dev-livraria-roo
Managed SRC_MAIN_RESOURCES\database.properties

Claro que você pode editar o arquivo database.properies no seu editor preferido pois não irá fazer diferença para o Roo.

Criando uma nova classe de persistência (entity)

Vamos criar agora a entity Book que representará uma tabela do banco de dados. Você pode criar entities utilizando um editor de texto, uma IDE como o Eclipse (ensinarei no próximo artigo) ou o shell do Roo:

roo$ new persistent class jpa -name ~.model.Book
Created SRC_MAIN_JAVA\br\com\livraria\model
Created SRC_MAIN_JAVA\br\com\livraria\model\Book.java
Created SRC_MAIN_JAVA\br\com\livraria\model\Book_Roo_Entity.aj
Created SRC_MAIN_JAVA\br\com\livraria\model\Book_Roo_ToString.aj
Created SRC_MAIN_JAVA\br\com\livraria\model\Book_Roo_Configurable.aj

Nesse momento você deve estar se perguntando o que são todos esses *.aj. Resumidamente são arquivos do AspectJ, é neles que os códigos gerados pelo Roo ficarão (getters, setters, entityManager, etc) e como são criados e deletados pelo Roo é uma forma muito eficiente de manter compatibilidade com versões futuras e não se misturam com o seu código. Você não deve editar esses arquivos manualmente, mas mostrarei no próximo artigo como personaliza-los.

Você deve ter percebido que utilizei um "~" antes do nome da entity, ele representa o topLevelPackage que no nossa caso é "br.com.livraria".

Naturalmente uma entity sem campos não é muito útil, então vamos criar alguns campos:

roo$ add field string title -notNull -sizeMin 2 -sizeMax 30
roo$ add field string author -notNull -sizeMax 30
roo$ add field date jpa createdAt -type java.util.Date

Como você pode perceber criamos os campos com os argumentos -notNull, -sizeMin e -sizeMax. Eles fazem referencias ao novo padrão chamado de "Bean Validator" mais conhecido como JSR 303. E as aplicações escritas em Roo tiram total proveito de padrões como JSR 303, Restful e JPA sem nenhum esforço adicional do desenvolvedor. Obviamente você não é obrigado a utilizar os argumentos do JSR 303 caso não queira.

Note também que não informei qual a entity deve receber as campos criados acima, nesse caso o Roo irá setar na última entity criada.

Criando a camada de Controller

Agora que temos a camada de persistência funcional falta apenas criar um controller para cadastrar nossos Livros:

roo$ new controller automatic ~.controller.BooksController -formBackingObject ~.model.Book
Created SRC_MAIN_JAVA\br\com\livraria\controller
Created SRC_MAIN_JAVA\br\com\livraria\controller\BooksController.java
Created SRC_MAIN_WEBAPP\WEB-INF
Created SRC_MAIN_WEBAPP\WEB-INF\livraria-roo-servlet.xml
Created SRC_MAIN_JAVA\br\com\livraria\controller\BooksController_Roo_Controller.aj
Created SRC_MAIN_WEBAPP\images
Created SRC_MAIN_WEBAPP\images\banner-graphic.png
Created SRC_MAIN_WEBAPP\images\springsource-logo.png
Created SRC_MAIN_WEBAPP\images\list.png
Created SRC_MAIN_WEBAPP\images\show.png
Created SRC_MAIN_WEBAPP\images\create.png
Created SRC_MAIN_WEBAPP\images\update.png
Created SRC_MAIN_WEBAPP\images\delete.png
Created SRC_MAIN_WEBAPP\styles
Created SRC_MAIN_WEBAPP\styles\roo.css
Created SRC_MAIN_WEBAPP\WEB-INF\jsp
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\header.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\footer.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\includes.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\dataAccessFailure.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\uncaughtException.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\book
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\book\list.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\book\show.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\book\create.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\book\update.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\menu.jsp
Managed SRC_MAIN_WEBAPP\WEB-INF\jsp\menu.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\web.xml
Created SRC_MAIN_WEBAPP\WEB-INF\jsp\index.jsp
Created SRC_MAIN_WEBAPP\WEB-INF\urlrewrite.xml
Managed SRC_MAIN_WEBAPP\WEB-INF\web.xml
Managed ROOT\pom.xml

Existem 2 tipos de controller, controllers manuais e automáticos. Os automáticos criam os jsp para listar, visualizar, criar e atualizar entities. O Roo utiliza o excelente suporte a restful do spring-mvc 3 e todos os métodos do controller automatic são escritos dessa forma.

No exemplo acima criamos um controller automatic para a entity Book.

Verificando se tudo funciona

É sempre uma boa prática de programação escrever testes (e bons testes) para todas as suas classes e naturalmente o Roo ajuda a escreve-los. Vamos começar com o teste de integração com JUnit:

roo$ new integration test -entity ~.model.Book
Created SRC_TEST_JAVA\br\com\livraria\model
Created SRC_TEST_JAVA\br\com\livraria\model\BookDataOnDemand.java
Created SRC_TEST_JAVA\br\com\livraria\model\BookIntegrationTest.java
Created SRC_TEST_JAVA\br\com\livraria\model\BookDataOnDemand_Roo_Configurable.aj
Created SRC_TEST_JAVA\br\com\livraria\model\BookDataOnDemand_Roo_DataOnDemand.aj
Created SRC_TEST_JAVA\br\com\livraria\model\BookIntegrationTest_Roo_Configurable.aj
Created SRC_TEST_JAVA\br\com\livraria\model\BookIntegrationTest_Roo_IntegrationTest.aj

O teste de integração irá verificar as operações comuns do JPA, como persist, remove, find, etc num total de 8 testes.

Criar um teste com selenium é igualmente trivial:

roo$ new selenium test -controller ~.controller.BooksController
Created SRC_MAIN_WEBAPP\selenium
Created SRC_MAIN_WEBAPP\selenium\test-book.xhtml
Created SRC_MAIN_WEBAPP\selenium\test-suite.xhtml
Managed SRC_MAIN_WEBAPP\WEB-INF\jsp\menu.jsp
Managed ROOT\pom.xml

Caso você não conheça, o selenium é um framework que abre um browser e simula a navegação do cliente na tela (preenchendo campos e clicando em botões).

Ok, agora vamos ver a aplicação rodando de verdade:

roo$ quit
$ mvn test
$ tomcat:run

O comando "mvn test" irá executar todos os testes de integração existentes e o segundo irá startar o tomcat embutido que o Roo configurou no maven.

Caso as dependências e o plug-in para maven do tomcat não estejam instalados na sua máquina, o maven irá baixa-los da internet e isso pode levar algum tempo.

Quando o tomcat iniciar, abra um browser e "brinque" na sua aplicação http://localhost:8080/livraria-roo

E é claro, execute o selenium. Deixe o tomcat rodando e abra um novo terminal na pasta do projeto:

$ mvn selenium:selenese

Se tudo ocorrer bem um browser abrirá e testes de navegação serão visualmente executados!

Conclusão

O Spring Roo é um novo marco na desenvolvimento web, utilizando de forma extremamente inteligente o suporte a aspectos conseguiu trazes para o Java as facilidades e a agilidade de desenvolvimento antes só alcançadas em linguagens de script como ruby on rails e grails.

Outra inovação é que a dependência do Roo no seu projeto é 0 (zero). O código gerado utiliza apenas spring, jpa e demais frameworks padrões de mercado (apenas algumas anotações no entity fazem referencia ao Roo mas que podem ser removidos), dessa forma você pede utiliza-lo para desenvolver toda uma aplicação, parte de uma aplicação ou mesmo abandona-lo a qualquer momento.

O que vimos aqui foi apenas a ponta do iceberg do Spring Roo, há muito a explorar nos próximos artigos, tais como: utilizar apenas o Eclipse e não mais o shell, enviar e-mails, criar a camada de segurança , instalar finders dinâmicos e web flow, personalizar os arquivos do aspectJ e desenvolver controller manuais com as suas regras de negócio.

O Roo esta em rápido desenvolvimento e novos recursos vão aparecer nas próximas versões!

Tópicos relacionados

• Nenhum tópico relacionado foi encontrado.

    

Se você gostou deste artigo, deixe um comentário ou assine o feed e acompanhe os próximos artigos em seu leitor de feeds preferido.