Apresentando Spring Roo, Parte 1: Criando a partir da origem

O Spring Roo é uma ferramenta leve de produtividade para tecnologia Java™ que torna o desenvolvimento de aplicativos baseados em Spring mais fácil e rápido. Os aplicativos criados usando o Spring Roo seguem a melhor prática do Spring e se baseiam em normas como JPA, validação de bean (JSR-303) e injeção de dependência (JSR-330). O Roo oferece um shell utilizável e sensível ao contexto de preenchimento com tab para criação de aplicativos. O Spring Roo é extensível e permite complementos, o que aprimora seus recursos. Este artigo apresenta o Spring Roo e fornece instruções passo a passo sobre a criação da origem do Spring Roo em sistemas Windows ® e *nix.

Shekhar Gulati, Senior Consultant, Xebia

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.



28/Nov/2011

Introdução

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.

Figura 1. Diagrama de classes Speaker e Talk
Diagrama de classes Speaker e Talk

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.
Listagem 1. Iniciando o shell do Roo
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).

Listagem 2. Usando hint no shell do Roo
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_SPRING

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 ouquit.

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.

Figura 2. Página inicial do aplicativo de conferência
Página inicial do aplicativo de conferência

É 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

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:

  1. InstaleGit, 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.
  2. 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.
  3. 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.
  4. Dispare o comando gpg --list-secret-keys. A saída deve ser parecida com a Listagem 3.
    Listagem 3. Resultado do comando listar gpg
    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>_
  5. 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.
  6. 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).
  7. 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..
  8. 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:

  1. Instale 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.
    Listagem 4. Instalando msysGit
            { 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
  2. 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.
    Listagem 5. Prompt de comandos do Git
    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:\>_
  3. 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.
  4. 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.
    Listagem 6. Resultado do comando listar gpg
    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>_
  5. 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.
  6. 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).
  7. 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..
  8. 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.
  9. 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.
Figura 3. Configurando a variável ROO-DEV
Configurando a variável ROO-DEV

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.

Listagem 7. Shell de ROO-DEV
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.

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre, Tecnologia Java
ArticleID=778686
ArticleTitle=Apresentando Spring Roo, Parte 1: Criando a partir da origem
publish-date=11282011