Desenvolvimento

22 out, 2012

Apresentando Spring Roo – Parte 01

100 visualizações
Publicidade

A estrutura Spring foi lançada em fins de 2002 para simplificar o desenvolvimento J2EE (agora JavaEE). Nos últimos oito anos, o Spring teve sucesso nessa missão ao fornecer à comunidade Java estruturas ou recursos como Spring Security, Spring MVC, gerenciamento de transação, lote de Spring e integração de Spring, que são mais fáceis de entender e usar. O Spring queria tornar a vida do desenvolvedor Java ainda mais fácil e produtiva. Para isso, o Spring criou uma ferramenta de desenvolvimento chamada Spring Roo.

O Spring Roo (consulte Recursos) é uma ferramenta RAD extensível, de software livre e baseada em texto para tecnologia Java. É um recurso eficiente para a criação e o gerenciamento de aplicativos baseados em Spring. Esta é a declaração de missão:

A missão do Roo é melhorar de forma fundamental e sustentável a produtividade do desenvolvedor Java sem comprometer a integridade ou flexibilidade de engenharia.

Essa busca se traduziu em uma ferramenta desenvolvida sobre tecnologia Java, o que aumenta de forma sustentada a produtividade durante o ciclo de vida completo de um projeto e não bloqueia os desenvolvedores em uma abordagem específica. O Spring Roo usa bibliotecas populares, comprovadas e maduras, como a estrutura do Spring, a API de Java Persistence, Java Server Pages (JSP), Spring Security, Spring Web Flow, Log4J e Maven. Os aplicativos gerados pelo Roo usa normas como validação de bean (JSR-303) e injeção de dependência (JSR-330), e segue a arquitetura do aplicativo de melhor prática certificada por SpringSource.

Usando Spring Roo, é possível incluir e configurar recursos como JPA, Spring MVC, Spring Security, criação de log usando Log4j, estruturas de teste, como JUnit e Selenium, Solr, JMS, email, e muito mais, simplesmente digitando comandos no shell do Roo. O tempo poupado ao usar o Roo para incluir esses recursos aumenta a produtividade do desenvolvedor. O Roo não pode escrever lógica de negócios, mas pode gerenciar a infraestrutura ou a configuração de um aplicativo.

O Roo é uma ferramenta de tempo de desenvolvimento, o que significa que um aplicativo é independente do Roo no tempo de execução. Visto que o Roo não existe no tempo de execução, ele não tem nenhuma sobrecarga no desempenho ou na memória. Com isso, não ficamos amarrado ao Spring Roo, e é possível removê-lo do seu projeto a qualquer momento, apenas pressionando algumas teclas.

Este artigo trata da criação de um aplicativo da web simples usando o shell do Roo e demonstra como desenvolver o código de origem do Spring Roo em máquinas com Windows ou Ubuntu.

Introdução ao shell do Roo

É possível gerenciar e configurar um aplicativo carregando o shell do Roo e interagindo com ele por meio de comandos. O shell do Roo é um shell de comando que fornece sugestões, é sensível ao contexto e preenche com tab. Pode-se usar o comando de sugestão para perguntar ao Spring Roo sobre sua próxima ação lógica. O Roo é inteligente o suficiente para sugerir a próxima ação, determinando o contexto do seu aplicativo. Por exemplo, digamos que criamos uma entidade com o comando entity. Podemos então digitar o comando hint. O Roo lhe dirá que devemos incluir campos à nossa entidade usando field. Esse recurso reduz o peso conceitual do Roo e faz dele uma excelente ferramenta de aprendizado. Pode-se criar o aplicativo completo seguindo os comandos help e hint sem nunca consultar a documentação.

Pré-requisitos

Antes de começar a trabalhar com o Roo, certifique-se de que os seguintes estão instalados:

  1. Java V6 JDK
  2. Apache Maven V2.0.9 ou superior

Instalando o Spring Roo

Para instalar o Spring Roo de forma independente:

  1. Pode-se fazer o download do shell de linha de comando independente do Roo ou usar o plug-in integrado Roo SpringSource Tool Suite (STS). Sugiro fazer o download de ambos e usá-los em conjunto porque o STS oferece muitos recursos adicionais em relação ao Eclipse para aplicativos baseados em Spring:
    1. Spring Roo
    2. SpringSource Tool Suite
  2. Descompacte o arquivo ZIP do Spring Roo em um local à sua escolha;
  3. Configure a variável de ambiente:
    1. Em máquina com Windows, inclua %ROO_HOME% /bin no caminho onde ROO_HOME é o caminho para os arquivos ZIP descompactados do Roo.
    2. Em máquinas com *nix, crie um link simbólico para $ROO_HOME/bin/roo.sh(p.ex., sudo ln -s ~/spring-roo-1.x.x/bin/roo.sh/usr/bin/roo)

Desenvolvendo um aplicativo

Para lhe mostrar o poder do Roo, vamos criar um aplicativo simples de conferências corporativas. Um aplicativo de conferência tem duas entidades: Speaker e Talk. O Speaker pode apresentar uma ou mais palestras e Talk será dado por apenas um orador. O diagrama de classes simples é mostrado na Figura 1.

Crie o aplicativo:

  1. Abra o shell de linha de comando do seu sistema operacional;
  2. Crie um diretório chamado conference usando o comando mkdir ;
  3. Acesse o diretório conference no seu shell;
  4. Digite roo. Esse comando iniciará o shell do Roo, como mostrado na Listagem 1.
C:\Users\xebia\demo\conference>roo
____  ____  ____
/ __ \/ __ \/ __ \
/ /_/ / / / / / / /
/ _, _/ /_/ / /_/ /
/_/ |_|\____/\____/       1.1.B.RELEASE [rev 793f2b0]
Welcome to Spring Roo. For assistance press TAB or type "hint" then hit ENTER.
roo>

Agora que estamos dentro do shell do Roo, usaremos o comando hint do Roo para nos guiar pelas próximas etapas. hint sugere criar um novo projeto Spring baseado em Maven usando project (consulte a Listagem 2).

Welcome to Spring Roo. For assistance press TAB or type "hint" then hit ENTER.
roo> hint
Welcome to Roo! We hope you enjoy your stay!
Before you can use many features of Roo, you need to start a new project.

To do this, type ’project’ (without the quotes) and then hit TAB.

Enter a --topLevelPackage like ’com.mycompany.projectname’ (no quotes).
When you're finished completing your --topLevelPackage, press ENTER.
Your new project will then be created in the current working directory.

Note that Roo frequently allows the use of TAB, so press TAB regularly.
Once your project is created, type ’hint’ and ENTER for the next suggestion.
You're also welcome to visit http://forum.springframework.org`for Roo help.
roo>

Conforme sugerido pelo comando hint , criaremos um projeto usando o comando project. Esse comando tem um atributo obrigatório, topLevelPackage, para especificar o nome do pacote raiz. Além do atributo obrigatório, usaremos dois atributos opcionais: java (para especificar a versão de Java) e projectName (para especificar o nome do projeto). Digite o seguinte:

project --topLevelPackage com.dw.roo.conference --java 6 --projectName conference

Esse comando criará um projeto baseado em Spring e gerenciado por Maven V2, como mostrado na saída a seguir:

Created C:\Users\xebia\demo\conference\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\META-INF\spring
Created SRC_MAIN_RESOURCES\META-INF\spring\applicationContext.xml
Created SRC_MAIN_RESOURCES\log4j.properties

Novamente, digite hint para perguntar ao Roo qual a próxima ação. Desta vez, é sugerido configurar o mecanismo de persistência. Digite persistence setup no shell e pressione Tab três vezes. Aparecerão opções para —provider. Pressione H e, então, Tab para concluir “HIBERNATE”. Após o provedor, pressione tab para as opções de banco de dados, e aparecerão várias opções. Visto que estamos usando Hibernate como nosso provedor, não podemos escolher um banco de dados não relacional, como o Google App Engine. Por enquanto, vamos usar o banco de dados HYPERSONIC_IN_MEMORY.

persistence setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY

Há outros atributos opcionais, como nome de usuário e senha, que não necessitamos no momento.Agora que configuramos o mecanismo de persistência, utilizaremos novamente o comando hint. Desta vez, ele nos diz para criarmos entidades usando o comando entity. Entity é usado para criar os objetos de domínio reais e tem um atributo obrigatório, class, para especificar o nome da entidade. Além do atributo obrigatório --class , usaremos o atributo --testAutomatically, que cria testes de integração para o objeto de domínio. Vamos entidade duas entidades: Speaker e Talk.

entity --class ~.domain.Speaker –testAutomatically

entity --class ~.domain.Talk --testAutomatically

Usei ~ como marcador para o pacote de nível superior do projeto.

Entity criará uma entidade JPA flexível e cheia de recursos. As entidades criadas terão JPA @Entity com ID, versão, EntityManager e desenvolvedor sem argumento. A entidade gerada terá métodos como persist, merge, remove, flush, count, find e findById, etc. Se observarmos a saída desse comando, notaremos que ele, além de criar arquivos Java (para Speaker e Talk), também cria arquivos AspectJ terminados com *Roo_*.aj. Esses *Roo_*.aj são chamados de Intertype Declaration (ITD), Mixins ou introduções. O Roo usa ITD como artefato de geração de códigos. Os ITDs permitem que o Roo gere código em uma unidade de compilação separada, mas eles são combinados na mesma classe compilada no tempo de compilação. As declarações intertipo AspectJ são usadas para gerar automaticamente campos de ID e versão, e métodos getter e setter para os campos de persistência nas classes de domínio.

Usar hint novamente fornece a sugestão de incluir campos na entidade usando o comando field. Vamos incluir alguns campos na entidade Speaker:

field string --fieldName firstname --class ~.domain.Speaker --notNull
field string --fieldName lastname --notNull
field string --fieldName email --unique --notNull
field string --fieldName organization
field date --fieldName birthdate --type java.util.Date --past --notNull
field number --type java.lang.Long --fieldName age --min 25 --max 60

--class : suas opções nos permitem especificar em que classe queremos incluir campos.

O comando field pode ser usado para especificar anotações específicas de validação JavaBean com opções como --max e --min, etc. Também pode ser usado para especificar anotações específicas de JPA com opções como --fetch, --column e --unique, etc. Para campos de data, também é possível especificar se a data deve ser no passado ou no futuro, como usado acima. Usando field, não é preciso lembrar dessas anotações.

Agora vamos incluir alguns campos na entidade Talk:

field string --fieldName title --class ~.domain.Talk --notNull
field string --fieldName description --notNull --sizeMax 4000

Até agora, criamos as entidades e incluímos campos nelas, mas não especificamos o relacionamento entre elas. O relacionamento entre Speaker e Talk é ONE_TO_MANY (ou seja, um orador pode fazer qualquer número de palestras). Isso é feito usando field, conforme mostrado abaixo:

field set --fieldName talks --type ~.domain.Talk --class \
~.domain.Speaker --cardinality ONE_TO_MANY

field reference --fieldName speaker --type ~.domain.Speaker \
--class ~.domain.Talk –-notNull

Queremos executar scaffold em uma camada da web para o aplicativo de conferência. Isso é feito usando o comando controller . O modo mais conveniente de gerar controladores e todos os artefatos da web relevantes é usar controller all.

controller all --package ~.web

O primeiro uso do comando do controlador também incluirá dependências adicionais, como Spring MVC e Tiles, no seu projeto. Isso pode levar algum tempo para ser executado visto que precisa fazer o download de todas as dependências (se não existirem em seu repositório do Maven). Esse comando também mostra um dos recursos do Roo: ele inclui dependências apenas quando necessárias.

A seguir, vamos configurar log4j usando o comando de criação de log:

logging setup --level INFO --package ALL_SPRIN

A última coisa que devemos fazer antes de sair do shell do Roo é executar os testes de integração gerados quando especificamos --testAutomatically com o comando entity . Para executar os testes dentro do shell, digite perform tests.

O Roo delega a chamada ao Maven para executar os testes. Portanto, perform tests é equivalente a um comando mvn test. Saia do shell digitando q ou quit.

Esses comandos criarão um aplicativo de conferências totalmente funcional. A seguir, executaremos esse aplicativo.

Para executar o aplicativo, digite mvn tomcat:run que iniciará o servidor jetty. Abra um navegador da web e acesse http://localhost:8080/conference/. Aparecerá a tela mostrada na Figura 2.

 

É possível clicar em Create new Speaker para criar um orador de conferência. Também é possível visualizar, editar e excluir um usuário clicando em List all Speakers. Da mesma forma, é possível criar um Talk, mas só depois que Speaker tiver sido criado.

Esse é um aplicativo simples, mas mostra como é fácil criar um aplicativo da web baseado em Spring do zero e em poucos minutos. Na segunda parte desta série, mostrarei como desenvolver um aplicativo usando diferentes recursos e complementos do Roo.

Agora que criamos um aplicativo simples, mostrarei como desenvolver a origem do Spring Roo em Windows e Ubuntu.

Criando Spring Roo a partir da origem

O Spring Roo V1.1.0 é a versão de liberação mais recente, e está sendo feito desenvolvimento ativo sob o release V1.1.1. Há alguns motivos pelos quais pode ser necessário criar o Spring Roo da origem:

  1. O Spring Roo não fornece criações noturnas. Assim, se quisermos os recursos mais recentes do Spring Roo precisaremos desenvolver a origem dele;
  2. Queremos fazer algum tipo de desenvolvimento no projeto do Spring Roo;
  3. Queremos escrever um complemento para Spring Roo;
  4. Queremos apenas brincar com o código do Spring Roo para ver como é implementado ou escrito.

Resultado

No fim desta seção, seremos capazes de executar uma criação Maven bem-sucedida do código de origem mais recente do Spring Roo em sistemas Windows e *nix. Poderemos trabalhar com o Spring Roo mais recente e importaremos os projetos do Spring Roo para Eclipse ou STS (SpringSource Tool Suite).

Processo para criação da origem do Spring Roo em Ubuntu

É fácil criar o código de origem em Ubuntu (e em outros sistemas *nix). Basta seguir estas etapas:

  • Instale o Git, um sistema de gerenciamento de controle de código de origem distribuído. Para instalá-lo em seu sistema Ubuntu, digite sudo apt-get install git-core gitk;
  • Efetue o registro de saída do Spring Roo usando o Git e digitando git clone git://git.springsource.org/roo/roo.git. Aparecerá uma pasta roo no seu diretório inicial que contém todo o código de origem do Roo;
  • GnuPG permite criptografar e assinar seus dados e comunicação, e possui um sistema de gerenciamento de chaves versátil e módulos de acesso para todos os tipos de diretórios de chave pública. O Roo usa o GPG para assinar automaticamente as saídas de desenvolvimento;
  • Dispare o comando gpg --list-secret-keys. A saída deve ser parecida com a Listagem 3:
C:\dev\roo-sourcecode\roo>gpg --1ist-secret-keys
C:/Users/xebia/AppData/Roaming/gnupg\secring.gpg
sec 2048R/2F96093B 2010-07-03
uid                shekhar (spring-roo) <shekhargu1ati84@gmai1.com>
ssb 2048R/B77E5C63 2010-07-03
C:\dev\roo-sourcecode\roo>_
  • Se não aparecer saída, primeiro é preciso criar uma chave. Use gpg –gen-key e ele vai percorrer uma série de etapas de criação da chave. Depois, verifique se sua chave recém-criada foi gerada usando gpg –list-secret-keys;
  • A seguir, é preciso publicar sua chave em um servidor de chave pública. Anote o ID de chave sec mostrado em –list-secret-keys. No meu caso, o ID de chave é 2F96093B. Execute Push em sua chave pública para um servidor de chave por meio de gpg –keyserver hkp://pgp.mit.edu –send-keys 2F96093B (mude o ID de chave no final);
  • Alguns módulos do Roo exigem JARs que ainda não estão na forma de OSGi. Ou seja, não têm um manifesto sensível a OSGi. O Roo tem um projeto especial chamado wrapping que pode converter JARs normais em JARs OSGi. Será preciso executar o wrapper antes de tentar trabalhar com o Roo. Sem o wrapper, aparecerão erros dizendo que o Maven não consegue localizar o org.springframework.roo.wrapping.some_module. Para criar os JARs em wrapper, no local raiz de registro de saída do Roo, digite:
cd wrapping
mvn clean install
cd..
  • A seguir, execute o comando mvn clean install . (O Maven V2 deve estar instalado no seu sistema. Se não estiver, instale-o agora.) O Maven solicitará a senha/passphrase da sua chave (a passphrase foi inserida ao criar a chave GPG) cada vez que criar o código de origem. Digite a passphrase e pressione Enter. Levará alguns minutos para criar o código de origem.

Processo de criação da origem de Spring Roo em Windows

Criar o código de origem em Windows é um pouco mais difícil se comparado ao Ubuntu. Siga estas etapas:

  • Instale o Git, um sistema de gerenciamento de controle de código de origem distribuído. Para iniciar o processo, é preciso instalar o Git na sua máquina com Windows. Eu instalei msysGit em minha máquina com Windows. Se o Git já estiver instalado na sua máquina, poderá ignorar esta etapa. Quando instalar msysGit, ele pedirá um local da instalação. Abrirá um prompt de comandos e iniciará o disparo de vários comandos. Isso continuará por um minuto, mais ou menos. Após a instalação, aparecerá uma tela, como mostrado na Listagem 4:
{ test "$bindir/" = "$execdir/" || \
{ rm -f "$execdir/git.exe" && \
test -z "" &amp;&amp; \
ln "$bindir/git.exe" "$execdir/git.exe" 2>/dev/null || \
cp "$bindir/git.exe" "$execdir/git.exe"; } ; } && \
{ for p in git-add.exe git-annotate.exe git-apply.exe git-archive.exe
git-bisect--helper.exe git-blame.exe git-branch.exe git-bundle.exe git-cat-file.exe
git-check-attr.exe git-check-ref
rm -f "$execdirf$p" && \
ln "Sexecdir/git.exe" "Sexecdir/$p" 2>/dev/null ll \
ln -s "git.exe" "$execdir/$p" 2>/dev/null || \
cp "Sexecdir/git.exe" "$execdir/$p" Il exit; \
done; } && \
{ test x"git-renote-https.exe git-renote-ftp.exe \
git-renote-ftps.exe" = x ll \
{ for p in git-remote-https.exe git-remote-ftp.exe \
git-remote-ftps.exe; do \
rm -f "$execdir{$p" && \
ln "Sexecdir/git-remote-http.exe" "$execdir/$p" 2>/dev/null ll \
ln -s “git-renote—http.exe" "$execdir/$p" 2>/dev/null || \
cp "Sexecdir/git-remote-http.exe" "Sexecdir/$p" ll exit; \
done; } ; } && \
./check_bindir "z$bindir" "z$execdir" "Sbindir/git—add.exe"

-------------------------
Hello, dear Git developer.

This is a minimal MSYS environment to work on Git.

You are in the git working tree, and all is ready for you to hack.

Welcome to msysGit

Run 'git help git' to display the help index.
Run 'git help <command>' to display help for specific commands.
Run '/share/msysGit/add-shortcut.tcl' to add a shortcut to msysGit.

It appears that you installed msysGit using the full installer.
To set up the Git repositories, please run /share/msysGit/initialize.sh
  • Configure a variável de ambiente Git. É preciso configurar o Git no seu caminho do Windows. Inclua ${MSYSGIT}\msysgit\bin e {MSYSGIT}\msysgit\mingw\bin no seu caminho do Windows, onde ${MSYSGIT} é o local onde o msysGit está instalado. Abra um novo prompt de comandos e digite git. Aparecerá a saída da Figura 7:
C:\>git
usage: git [--version] [--exec-path[=GIT_EXEC_PATH]] [--html-path]
[-pl--paginate|I--no-pager] [--no-replace-objects]
[--bare] [--git-dir=GIT_DIR] [--work-tree=GIT_WORK_TREE]
[-c name=value
[--help] COMMAND [ARGS]
The most commonly used git commands are:
add        Add file contents to the index
bisect     Find by binary search the change that introduced a bug
branch     List, create, or delete branches
checkout   Checkout a branch or paths to the working tree
clone      Clone a repository into a new directory
commit     Record changes to the repository
diff       Show changes between commits, commit and working tree, etc
fetch      Download objects and refs from another repository
grep       Print lines matching a pattern
init       Create an empty git repository or reinitialize an existing
log        Show commit logs
merge      Join two or more development histories together
mv         Move or rename a file, a directory, or a symlink
pull       Fetch from and merge with another repository or a local bra
push       Update remote refs along with associated objects
rebase     Forward-port local commits to the updated upstream head
reset      Reset current HEAD to the specified state
rm         Remove files from the working tree and from the index
show       Show various types of objects
status     Show the working tree status
tag        Create, list, delete or verify a tag object signed with GPG

See ’git help COMMAND’ for more information on a specific command.
C:\>_
  • Efetue o registro de saída do Spring Roo usando o Git. Nesta etapa, criaremos um clone local do Spring Roo efetuando o registro de saída da origem mais recente usando o Git. Abra um prompt de comandos e vá até o local onde deseja efetuar o registro de saída do Spring Roo. Insira git clone git://git.springsource.org/roo/roo.git . Aguarde ser concluído. Isso criará uma nova pasta chamada roo no local onde efetuou registro de saída do Spring Roo;
  • Faça o download e instale o GPG for Windows. O GnuPG é uma ferramenta GNU para comunicação segura e armazenamento de dados. Pode ser suado para criptografar dados e criar assinaturas digitais. O Roo usa o GPG para assinar automaticamente as saídas de desenvolvimento. Depois de instalar o GPG, use gpg –list-secret-keys. Deve aparecer uma saída similar à Listagem 6:
C:\dev\roo-sourcecode\roo>gpg --1ist-secret-keys
C:/Users/xebia/AppData/Roaming/gnupg\secring.gpg
sec 2048R/2F96093B 2010-07-03
uid                shekhar (spring-roo) <shekhargu1ati84@gmai1.com>
ssb 2048R/B77E5C63 2010-07-03
C:\dev\roo-sourcecode\roo>_
  • Se não aparecer a saída, isso significa que primeiro é preciso criar uma chave. Use gpg –gen-key. Ele vai percorrer uma série de etapas de criação da chave. Depois, verifique se sua chave recém-criada foi gerada usando gpg –list-secret-keys.
  • Publique sua chave em um servidor de chave pública. Anote o ID de chave sec mostrado em –list-secret-keys. No meu caso, o ID é 2F96093B. Execute Push em sua chave pública para um servidor de chave por meio de gpg –keyserver hkp://pgp.mit.edu –send-keys 2F96093B. (Mude o ID de chave no final);
  • Primeiro crie o projeto de wrapper. Alguns módulos do Roo exigem JARs que ainda não estão na forma de OSGi. Ou seja, não têm um manifesto sensível a OSGi. O Roo tem um projeto especial chamado wrapping que pode converter JARs normais em JARs OSGi. Será preciso executar o wrapper antes de tentar trabalhar com o Roo. Sem o wrapper, aparecerão erros dizendo que o Maven não consegue localizar o org.springframework.roo.wrapping.some_module. Para criar os JARs em wrapper, no local raiz de registro de saída do Roo, digite:
cd wrapping
mvn clean install
cd..
  • Execute o comando mvn clean install . (O Maven V2 deve estar instalado no seu sistema. Se não estiver, instale-o agora.) Ele solicitará a senha/passphrase da sua chave (a passphrase foi inserida ao criar a chave GPG) cada vez que criar o código de origem. Digite a passphrase e pressione Enter. Levará alguns minutos para criar o código de origem;
  • Configure a variável de ambiente ROO-DEV nas configurações do sistema, que devem apontar para a pasta de autoinicialização dentro do projeto Roo. Também é preciso incluir essa variável na variável de ambiente PATH, como mostrado na Figura 3:

Agora é possível trabalhar com a versão de desenvolvimento mais recente do Roo. Abra o prompt de comandos, crie uma pasta chamada mkdir roo_dev_demo e dispare o comando roo-dev . Aparecerá a tela mostrada na Listagem 7:

C:\Users\xebia\demo\conference>roo
____  ____  ____
/ __ \/ __ \/ __ \
/ /_/ / / / / / / /
/ _, _/ /_/ / /_/ /
/_/ |_|\____/\____/       1.1.B.RELEASE [rev 793f2b0]
Welcome to Spring Roo. For assistance press TAB or type "hint" then hit ENTER.
roo>

É bom atualizar o código de origem do Spring Roo de modo a trabalhar com a versão mais recente dele. Abra um prompt de comandos e vá até o local da código de origem do Spring Roo. Dispare o comando git pull, que efetuará Pull em todas as mudanças remotas para seu clone local e depois execute um mvn clean install para criar as origens atualizadas.

 Conclusão

Neste ponto, desenvolvemos um aplicativo da web simples sem precisar abrir nosso editor ou consultar alguma documentação. O aplicativo permite executar operações CRUD em suas entidades. Espero que tenha ficado claro que o Roo oferece enormes ganhos de produtividade para os desenvolvedores Java. Ele usa tecnologias maduras e estáveis que a maioria dos desenvolvedores já conhece.

Na Parte 2, tornaremos nosso aplicativo mais seguro, incluiremos suporte a internacionalização e ao sistema de mensagens (SMTP e JMS), e customizaremos o aplicativo. Também daremos uma olhada no recurso de engenharia reversa de banco de dados do Roo, e converteremos esse aplicativo em um aplicativo corporativo completo.

***

O IBM® Tivoli® Endpoint Manager, desenvolvido com a tecnologia® BigFix, ajuda a alcançar um gerenciamento de terminal mais rápido e mais inteligente. Ele combina o gerenciamento de segurança e terminal em uma única solução que possibilita a visualização e o gerenciamento de terminais virtuais e físicos. O Tivoli Endpoint Manager fornece uma abordagem de agente e consoles únicos que ajuda, todo o espectro de requisitos de gerenciamento de terminal, que inclui gerenciamento de ciclo de vida, configuração de segurança, conformidade, e proteção de terminal.

Recursos

Aprender

Obter produtos e tecnologias

Discutir

***

Sobre o autor: Shekhar Gulati é consultor de Java que trabalha na Xebia Índia. Ele tem seis anos de experiência corporativa em Java. Ele tem extensa experiência em projetos do portfólio Spring, como Spring, Spring-WS, Spring Roo etc. Seus interesses são Spring, bancos de dados NoSQL, Hadoop, estruturas RAD como Spring Roo, computação em nuvem (principalmente serviços PaaS, como Google App Engine, CloudFoundry, OpenShift), Hadoop. Ele escreve constantemente para JavaLobby, Developer.com, IBM developerWorks e seu próprio blog em http://whyjava.wordpress.com/. Você pode segui-lo no Twitter @ http://twitter.com/#!/shekhargulati.

***

Artigo original disponível em: http://www.ibm.com/developerworks/br/library/os-springroo1/index.html