Introdução ao Spring Roo
20/06/2009 por Maximiliano GuzenskiSpring 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!