TOC

Guia rápido do Spring Roo

Guia rápido do Spring Roo

1. Visão geral

O Spring Roo é uma ferramenta de Desenvolvimento Rápido de Aplicativos (RAD) que visa fornecer resultados rápidos e instantâneos focados em aplicativos Web do Spring e em novas tecnologias Spring. Ele nos permite gerar código padrão e estrutura de projeto para aplicativos Spring com comandos simples de usar.

O Roo pode ser usado como um aplicativo independente em execução na linha de comando do sistema operacional. Não há necessidade de usar Eclipse, Spring Tool Suite (STS) ou qualquer outro IDE; na verdade, podemos usar qualquer editor de texto para escrever código!

No entanto, para simplificar, usaremos o STS IDE com a extensão Roo.

2. Instalando Spring Roo

2.1. Exigências

Para seguir este tutorial, eles precisam ser instalados:

  1. Java JDK 8

  2. STS

  3. Spring Roo

2.2. Instalação

Depois de baixar e instalar o Java JDK e STS, precisamos descompactar o Spring Roo e adicioná-lo ao caminho do sistema.

Vamos criar a variável de ambienteROO_HOME e adicionar%ROO_HOME%in ao caminho.

Para verificar se o Roo está instalado corretamente, podemos abrir a linha de comando e executar os seguintes comandos: 

mkdir example
cd example
roo quit

Após alguns segundos, veremos: 

                _
 ___ _ __  _ __(_)_ __   __ _   _ __ ___   ___
/ __| '_ \| '__| | '_ \ / _` | | '__/ _ \ / _ \
\__ \ |_) | |  | | | | | (_| | | | | (_) | (_) |
|___/ .__/|_|  |_|_| |_|\__, | |_|  \___/ \___/
    |_|                 |___/          2.0.0.RC1

Welcome to Spring Roo. For assistance press TAB or type "hint" then hit ENTER.

O Roo está instalado e está funcionando. Observe que a versão do Spring Roo variará e as etapas e instruções podem depender da versão real usada.

Importante: O Spring Roo 2.0 não é compatível com versões anteriores do 1.x.

2.3. Adicionar e configurar extensão STS

Pronto para uso, o STS suporta o desenvolvimento de aplicativos Spring e inclui extensões prontas para uso. No entanto, a extensão Spring Roo não está incluída. Portanto, precisaremos adicioná-lo manualmente.

No STS, vamos paraInstall New Softwaree importar favoritos paraAvailable Software Sites. Atualmente, os favoritos estão na pasta%ROO_HOME%\conf. Depois de importar os favoritos, podemos pesquisar simplesmenterooe instalar a versão mais recente deSpring IDE Roo Support. No final, seremos solicitados a reiniciar o STS.

Para etapas detalhadas e atualizadas, podemos sempre ir e verificar a documentaçãoSpring Roo Getting Started.

Depois de instalar o Suporte Roo no STS, precisamos configurar a extensão. É tão fácil quanto apontar o Suporte Roo para a pasta%ROO_HOME%. Novamente,Spring Roo Getting Started fornece etapas detalhadas de como fazer isso.

Agora podemos ir ao menu do aplicativo “Janela” mais uma vez e selecionarShow View > Roo Shell.

3. Primeiro Projeto

3.1. Configurando um Projeto no STS

No STS, vamos abrir a janelaRoo Shell e clicar no íconeCreate New Roo Project. Isso abrirá uma janelaNew Roo Project.

Vamos nomear o projetorooe usarcom.example como nosso nome de pacote de nível superior. Podemos deixar todos os outros valores padrão e prosseguir até o final para criar um novo projeto usando o Roo.

No STS, ele executará o seguinte comando para nós: 

project setup --topLevelPackage com.example --projectName "roo" --java 8 --packaging JAR

Como já mencionado, não precisamos de um IDE e poderíamos ter executado esse comando do Roo Shell nós mesmos! Para simplificar, estamos usando recursos internos do STS.

Se recebermos o seguinte erro: 

Could not calculate build plan: Plugin org.codehaus.mojo:aspectj-maven-plugin:1.8
  or one of its dependencies could not be resolved:
  Failed to read artifact descriptor for org.codehaus.mojo:aspectj-maven-plugin:jar:1.8

a maneira mais fácil de corrigir é editar manualmente o arquivopom.xmle atualizaraspectj.plugin.version de1.8 para1.9: 

1.9

Nesta fase, não deve haver nenhum erro no projeto, e haverá alguns arquivos gerados automaticamente para nós.

3.2. Roo Shell

Agora é hora de se familiarizar com o Roo Shell. A interface de usuário principal do Spring Roo é, na verdade, o prompt de comando!

Portanto, vamos voltar para a janela Roo Shell. Nele, vamos executar o primeiro comando digitando 'h' e pressionando CTRL + ESPAÇO: 

roo> h

help    hint

O Roo sugerirá e completará automaticamente os comandos para nós. Podemos digitar ‘hi’, pressionar CTRL + ESPAÇO e o Roo irá sugerir automaticamente o comandohint.

Outro grande recurso do Roo Shell é ocontext awareness. Por exemplo, a saída do comandohint mudará dependendo da entrada anterior.

Vamos agora executar o comandohint e ver o que acontece: 

roo> hint
Roo requires the installation of a persistence configuration.

Type 'jpa setup' and then hit CTRL+SPACE. We suggest you type 'H'
then CTRL+SPACE to complete "HIBERNATE".

After the --provider, press CTRL+SPACE for database choices.
For testing purposes, type (or CTRL+SPACE) HYPERSONIC_IN_MEMORY.
If you press CTRL+SPACE again, you'll see there are no more options.
As such, you're ready to press ENTER to execute the command.

Once JPA is installed, type 'hint' and ENTER for the next suggestion.

Isso nos dá os próximos passos que precisamos executar. Vamos adicionar um banco de dados agora: 

roo> jpa setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY
Created SRC_MAIN_RESOURCES\application.properties
Updated SRC_MAIN_RESOURCES\application.properties
Updated SRC_MAIN_RESOURCES\application-dev.properties
Updated ROOT\pom.xml [added dependencies org.springframework.boot:spring-boot-starter-data-jpa:, org.springframework.boot:spring-boot-starter-jdbc:, org.hsqldb:hsqldb:; added property 'springlets.version' = '1.2.0.RC1'; added dependencies io.springlets:springlets-data-jpa:${springlets.version}, io.springlets:springlets-data-jpa:${springlets.version}; added dependencies io.springlets:springlets-data-commons:${springlets.version}, io.springlets:springlets-data-commons:${springlets.version}]

Nesta fase, precisaremos executar alguns comandos. Entre cada um deles, sempre podemos executar o comandohint para ver o que é sugerido pelo Roo. Este é um recurso muito útil.

Let’s run the commands first, e vamos examiná-los depois: 

roo>
entity jpa --class ~.domain.Book
field string --fieldName title --notNull
field string --fieldName author --notNull
field string --fieldName isbn --notNull
repository jpa --entity ~.domain.Book
service --all
web mvc setup
web mvc view setup --type THYMELEAF
web mvc controller --entity ~.domain.Book --responseType THYMELEAF

Agora estamos prontos para executar nosso aplicativo. No entanto, vamos voltar aos comandos para ver o que fizemos.

Primeiro, criamos uma nova entidade persistente JPA na pastasrc/main/java. Em seguida, criamos três camposString na classeBook, demos a eles um nome e definimos como nãonull.

Depois disso, geramos o repositório Spring Data para a entidade especificada e criamos uma nova interface de serviço.

No final, incluímos a configuração do Spring MVC, instalamos o Thymeleaf e criamos um novo controlador que gerencia nossa entidade. Como passamos o Thymeleaf como o tipo de resposta, os métodos e visualizações gerados refletirão isso.

3.3. Executando o aplicativo

Vamos atualizar o projeto e clicar com o botão direito no projetoroo e selecionarRun As > Spring Boot App.

Assim que o aplicativo for iniciado, podemos abrir um navegador da web e ir parahttp://localhost:8080. Em seguida, no ícone do Roo, veremos o menuBook abaixo de duas opções:Create BookeList Books. Podemos usar isso para adicionar um livro ao nosso aplicativo e visualizar a lista de livros adicionados.

3.4. Outras características

Quando abrirmos o arquivo de classeBook.java, notaremos que a classe está anotada com anotações@Roo. Eles foram adicionados pelo Roo Shell e são usados ​​para controlar e personalizar o conteúdo dos arquivos de declaração inter-tipos (ITD) da AspectJ. Podemos visualizar os arquivos no Package Explorer no STS desmarcando o filtro “Ocultar ITDs Spring Roo gerados” no Menu Exibir ou podemos abrir os arquivos diretamente do sistema de arquivos.

As anotações do Roo têm política de retençãoSOURCE. Isso significathe annotations won’t be present in compiled class bytecode, e não haverá nenhuma dependência do Roo em aplicativos implantados.

Outra parte, obviamente ausente na classeBook.java, sãogettersesetters. Eles são armazenados em arquivos separados de AspectJ ITDs, como já mencionado. O Roo manterá ativamente esse código padrão para nós. Portanto, as alterações nos campos de qualquer classe serão refletidas automaticamente nos ITDs da AspectJ, pois o Roo está "monitorando" todas as alterações - feitas via Roo Shell ou diretamente por um desenvolvedor no IDE.

O Roo cuidará do código repetitivo, como os métodostoString() ouequals().

Além disso, a estrutura pode ser facilmente removida do projeto, evitando o aprisionamento do fornecedor, removendo anotações e inserindo o AspectJ ITD no código java padrão.

4. Conclusão

Neste exemplo rápido, conseguimos instalar e configurar o Spring Roo no STS e criamos um pequeno projeto.

Usamos o Roo Shell para configurá-lo e não precisamos escrever uma única linha de código Java real! Conseguimos obter um protótipo de aplicativo em poucos minutos e o Roo cuidou de todo o código padrão para nós.

Como sempre, o código usado em toda a discussão pode ser encontradoover on GitHub.

Related