Na Parte 1 e na Parte 2 desta série, você desenvolveu um aplicativo de conferência usando o Spring Roo 1.1. Na Parte 3 e na Parte 5 você desenvolveu complementos do Spring Roo. Nesse intervalo, na Parte 4, você examinou a integração do Cloud Foundry e do Spring Roo. Desde a Parte 2, não discutimos os diversos novos recursos ou mudanças introduzidos no Spring Roo no último ano. Muitos comandos que funcionavam nas versões anteriores não funcionam mais ou foram descontinuados. Outra faceta importante da versão atual é o uso do Spring Release 3.1, que é o último e maior release da estrutura do Spring com recursos como Perfil, Abstração de Ambiente, Abstração de Cache e muito mais. Trabalhar com a versão atual do Spring Roo significa a utilização da última versão da estrutura do Spring. Neste artigo, você terá uma visão rápida da última versão do Spring Roo, que é a Versão 1.2.1, e criará um aplicativo Google Web Toolkit (GWT) e Spring Web Model–View–Controller (MVC) multimódulos que implementará no Cloud Foundry.
Apresentando o Spring Roo 1.2
O Spring Roo é uma ferramenta de desenvolvimento de aplicativo rápido de linha de comando para desenvolvimento de aplicativos Spring. O Spring Roo progrediu no ano passado com os releases principais 1.1.5 e 1.2, que tornaram o Spring Roo mais eficiente e mais amigável ao desenvolvedor corporativo. Os principais recursos ou mudanças apresentados nesses releases são:
1. Suporte para MongoDB: Com versões mais antigas do Spring Roo, os aplicativos do Spring Roo necessários pelo RDBMS (por exemplo, MySQL ou PostgreSQL) como o backend, exceto para o suporte do Google App Engine BigTable (mas ele nunca funcionou com relacionamentos). A partir da Versão 1.2, o MongoDB pode ser usado como o armazenamento de dados. O MongoDB é um armazenamento de dados de documentos popular do NoSQL. A capacidade para desenvolver os aplicativos do Spring MongoDB mostra a natureza extensível do Spring Roo. Para visualizar todos os comandos relacionados com MongoDB, digite:
help --command mongo
2. Suporte do JavaServer Faces (JSF) 2.0: Antes da versão 1.2, por padrão o Spring Roo suportava o GWT e o Spring MVC como opções de visualização, mas com a versão 1.2, o Spring Roo também suporta o JSF 2.0 como uma das opções de visualização. O Spring Roo suporta atualmente as implementações do Apache MyFaces e Oracle Mojarra JSF, e os PrimeFaces como sua biblioteca de componentes. Esse era um dos problemas do JIRA mais populares que foi resolvido na versão 1.2. Para visualizar todos os comandos disponíveis para JSF, digite:
roo> help --command "web jsf" * web jsf all - Create JSF managed beans for all entities * web jsf media - Add a cross-browser generic player to embed multimedia content * web jsf scaffold - Create JSF managed bean for an entity * web jsf setup - Set up JSF environment
Este artigo não abordará os aplicativos JSF 2.0, que podem ser abordados nos artigos futuros. Os desenvolvedores que desejam desenvolver aplicativos JSF podem tentar o aplicativo bikeshop.roo, que vem empacotado com o Spring Roo. Uma pasta de amostra está na distribuição do Roo.
3. Suporte de projeto Maven multimódulos: Essa é uma das solicitações de recursos mais populares exigidas pela comunidade que está agora disponível. Antes da Versão 1.2, todo o código de aplicativo foi escrito em um projeto do Maven. Isso era inibitivo no desenvolvimento de aplicativos corporativos que comumente têm submódulos diferentes para interesse de aplicativos diferentes como web, persistência, serviço e outros. Agora, um projeto pai pode definir submódulos diferentes para persistência, serviço e web. Isso será abordado em detalhes posteriormente neste artigo onde você aprendeu a desenvolver um projeto Maven multimódulos usando o Spring Roo.
4. Suporte de repositório e camada de serviço: Até a Versão 1.2, o Spring Roo não forneceu o modo para ter o Repository (ou DAO) e a camada de serviço em um aplicativo. Por padrão, ele suportou o padrão Active Record que assegurou classes de entidade elaborada com todos os métodos relacionados à persistência. Esse também era um dos recursos populares solicitados pela comunidade que está agora disponível. Por padrão, o Spring Roo ainda suporta o Active Record como a estratégia de implementação, mas um repositório pode em vez disso ser escolhido criando entidade com –activeRecord false. Isso também será abordado em detalhes posteriormente neste artigo.
5. O suporte de banco de dados mais robusto e eficiente para suporte de engenharia reversa: Embora abordada na Parte 2, esse complemento passou por aprimoramentos importantes no último ano. Alguns dos aprimoramentos feitos são suportes multiesquema, permitindo que o DBRE faça a conexão do banco de dados por meio do Java Naming and Directory Interface (JNDI), visualizações de engenharia reversa e suporte para repositórios, em vez de objetos de entidade do Active Record. Além disso, muitos erros foram corrigidos. O DBRE não está no escopo deste artigo. Para obter mais detalhes, consulte a documentação do Spring Roo nos Recursos.
6. API Aprimorada do Complemento do Spring Roo: Parte 5 abordou a criação dos complementos do Spring Roo. Nesse artigo, eu usei o Spring Roo Versão 1.2 devido às alterações para a API. Algumas classes que existiam antes da Versão 1.2 não existem mais ou foram descontinuadas na Versão 1.2. A equipe Spring Roo tornou a API mais consistente e alinhada com os complementos do Spring Roo atuais. Atualizar seus complementos para a Versão 1.2 pode ser problemático.
7. Suporte GWT aprimorado: O suporte GWT do Spring Roo melhorou nos últimos releases. Anteriormente, um único comando gwt setup fazia toda a mágica de criar proxies e solicitar para outros itens relacionados a UI. Esse comando único foi descontinuado e substituído pelos 10 comandos na Listagem 1. O GWT será abordado posteriormente neste artigo.
Listagem 1. Exemplo de ajuda do gwt web
roo> help --command "web gwt" * web gwt all - Locates all entities in the project and creates GWT requests, proxies, and creates the scaffold * web gwt gae update - Updates the GWT project to support GAE * web gwt proxy all - Locates all entities in the project and creates GWT proxies * web gwt proxy request all - Locates all entities in the project and creates GWT requests and proxies * web gwt proxy request type - Creates a proxy and request based on the specified type * web gwt proxy type - Creates a GWT proxy based on the specified type * web gwt request all - Locates all entities in the project and creates GWT requests * web gwt request type - Creates a GWT proxy based on the specified type * web gwt scaffold - Creates a GWT request, proxy and scaffold for the specified type * web gwt setup - Install Google Web Toolkit (GWT) into your project
Além dos recursos ou aprimoramentos mencionados acima, eu destacarei outras mudanças menores por meio deste artigo. Vamos iniciar com a criação de um novo aplicativo de conferência do Spring Roo 1.2.
Introdução ao Spring Roo 1.2
Faça o download e instale os pré-requisitos. (Consulte a seção Recursos.)
- Os desenvolvedores Java™ 6 pacotes
- Apache Maven 3
- Spring Roo 1.2 e acima
Este artigo usa o Spring Roo 1.2.1, que é o release atual do Spring Roo.
Desenvolvendo o aplicativo de conferência
Você criará o mesmo aplicativo de conferência criado nas Partes 1 e 2. Um Palestrante pode dar uma ou mais palestras e uma Palestra será dada por apenas um palestrante. A Figura 1 mostra o diagrama de classe simples. (Speaker contém firstName, lastName, email, organization, birthDate, age, gender e Talk contém title e description.)
Figura 1. Diagrama de classe das tabelas Speaker e Talk
Criando um projeto multimódulos
Em vez de criar todo o projeto em um projeto Maven, você criará um projeto de conferência pai que conterá dois submódulos: core e view. O módulo core conterá todas as classes de domínio, repositório e serviço. O submódulo de visualização também será um projeto Project Object Model (POM) que terá dois submódulos: MVC e GWT. O projeto MVC conterá o aplicativo Spring MVC e o projeto GWT terá o aplicativo GWT. O aplicativo de conferência tem duas UIs: uma baseada no Spring MVC e a outra baseada no GWT. A Figura 2 mostra a estrutura do projeto.
Figura 2. Estrutura de projeto Maven
A estrutura na Figura 2 se parece com os aplicativos corporativos com muitos submódulos. Agora, vamos criar isso usando o Spring Roo.
1. Abra o shell de linha de comando do seu sistema operacional.
2. Crie um diretório chamado conference usando o comando mkdir.
3. Vá até o assistente conference no seu shell.
4. Tipo roo. Esse comando iniciará a shell do Roo.
5. O primeiro comando inserido na shell do Roo é o comando do projeto. Com a Versão 1.2, esse comando foi atualizado para dar suporte aos projetos POM. Os projetos POM em si não contêm nenhum código; eles apenas têm um arquivo pom.xml. O pacote desses projetos é POM, em vez de JAR ou WAR. Para criar um projeto POM de conferência, digite:
project --topLevelPackage org.xebia.conference --projectName conference --java 6 --packaging POM
O comando se parece similar ao comando do projeto usado na parte 1 com apenas uma mudança: ele tem outro atributo denominado empacotamento. O atributo de empacotamento pode assumir um valor de BUNDLE, JAR, POM ou WAR. Para o projeto pai, o valor é POM. Da Versão 1.2, o comando do projeto pode tomar um ou mais atributos denominados parent. Como o nome sugere, para que um POM de projeto herde de algum outro POM, use o atributo pai. Este será mostrado quando você cria um submódulo. Visualize o arquivo pom.xml gerado por esse comando e verifique se o pom.xml tem o POM de empacotamento.
6. Com o projeto POM de conferência, crie os submódulos core e view usando o comando do módulo. O comando module é similar ao comando do projeto, mas cria módulos Maven em vez de projetos Maven. Para criar o módulo core, digite o comando a seguir:
module create --moduleName core --topLevelPackage org.xebia.conference.core --parent org.xebia.conference:conference:0.1.0.BUILD-SNAPSHOT
O comando module create requer dois atributos obrigatórios: moduleName e topLevelPackage. O atributo moduleName é usado para especificar o nome do módulo e o atributo topLevelPackage é usado para especificar o nome do pacote do módulo. topLevelPackage também será o groupId desse módulo. Além desses atributos obrigatórios, há três atributos opcionais:
–-javapara especificar a versão Java--packagingpara especificar o pacote Maven do módulo--parentpara especificar se esse módulo é herdado de algum outro projeto Maven
No comando mostrado acima, o módulo core é herdado do projeto da conferência. Esse atributo pai toma o valor na forma groupId:artifactId:version. Esses valores podem ser obtidos do arquivo conference/pom.xml. O arquivo pom.xml do módulo core mostra que ele tem uma tag pai (como na Listagem 2).
Listagem 2. Seção pai do arquivo pom.xml
<parent> <groupId>org.xebia.conference</groupId> <artifactId>conference</artifactId> <version>0.1.0.BUILD-SNAPSHOT</version> </parent>
Também é possível dar uma olhada no pom.xml do projeto pai, ou seja conference/pom.xml, e verificar se ele tem uma tag module contendo o módulo core (como na Listagem 3).
Listagem 3. Seção do módulo do arquivo pom.xml
<modules> <module>core</module> </modules>
7. Em seguida, vamos criar o submódulo da visualização. Antes que seja possível criar isso, no entanto, mude seu foco novamente para o projeto raiz com este comando module focus:
module focus --moduleName ~
O til (~) especifica o projeto raiz. Opcionalmente, digite o nome do projeto Maven ou módulo Maven. Por exemplo, o seguinte comando obteve o mesmo resultado de comutação para o projeto core:
module focus --moduleName core
8. Agora crie o módulo de visualização. Esse módulo também será o projeto POM que terá dois submódulos: MVC e GWT. Para criar o módulo de visualização, digite:
module create --moduleName view --topLevelPackage org.xebia.conference.view --packaging POM --java 6
9. Para criar os submódulos do módulo GWT e MVC, execute os comandos na Listagem 4:
Listagem 4. Criando GWT e MVC
module create --moduleName gwt --topLevelPackage org.xebia.conference.view.gwt --java 6 --parent org.xebia.conference.view:view:0.1.0.BUILD-SNAPSHOT module focus --moduleName view module create --moduleName mvc --topLevelPackage org.xebia.conference.view.mvc --java 6 --parent org.xebia.conference.view:view:0.1.0.BUILD-SNAPSHOT
As nove etapas acima resultam em um projeto multimodos com quatro submódulos: core, view, GWT e MVC. O GWT e MVC são submódulos do submódulo de visualização. Agora, dispare o comando do pacote de execução de dentro da shell do Roo, que executará um desenvolvimento integral de todos os submódulos.
Incluindo persistência
Agora que você criou a estrutura do módulo Maven, é possível adicionar suporte à persistência. Use o comando de configuração do Java Persistence API (JPA) para definir a configuração relacionada à persistência. O comando de configuração de persistência foi descontinuado, assim o uso do comando de configuração de persistência não é recomendado. A configuração de persistência foi descontinuada porque o Spring Roo agora suporta diferentes tipos de soluções de armazenamento de dados persistentes, como o RDBMS, e armazenamento de dados de documentos, como o MongoDB. A configuração de persistência era um nome bastante genérico, assim, no futuro, se o Spring Roo decidir adicionar suporte para algum outro banco de dados NoSQL como o Cassandra, espere que o comando seja uma configuração do Cassandra. Para adicionar suporte de persistência ao aplicativo, digite o comando na Listagem 5. Você fará isso no módulo core, assim primeiro alterne o módulo core com o comando module focus.
Listagem 5. Comando para incluir suporte de persistência
module focus --moduleName core jpa setup --database DERBY_EMBEDDED --provider HIBERNATE
O Spring Roo agora suporta quinze bancos de dados, assim é provável que seja possível escolher o seu banco de dados. O comando e configuração do JPA, como o comando de configuração de persistência, tem dois atributos necessários: database e provider, ou seja, um provedor JPA como o Hibernate, ou Datanucleus, no caso do Google App Engine. Os atributos remanescentes são os mesmos que eram com o comando de persistência, assim não os discutiremos aqui.
Limpando a Shell do Roo
Anteriormente, talvez você tenha tentado limpar a shell do Roo usando o comando clear ou cls. Para executar os comandos do sistema operacional agora, digite ! <os command>. Para limpar o comando, digite:
core roo> ! clear
Criando as Entidades Speaker e Talk
Se você inserir o comando hint, ele avisará a criação de uma entidade. O comando entity mudou para a entidade JPA para distingui-la das entidades MongoDB, que são criadas usando o comando entity mongo. Outra mudança importante para o comando entity é a opção de ter entidades Active Record ou não. Neste artigo, você usará Repositories em vez das entidades Active Record. Para criar as entidades Speaker e Talk, digite os comandos na Listagem 6:
Listagem 6. Criando entidades
entity jpa --class ~.domain.Speaker --testAutomatically --activeRecord false --serializable entity jpa --class ~.domain.Talk --testAutomatically --activeRecord false –serializable
A Listagem 6 solicita explicitamente ao Roo para não gerar entidades activeRecord. O mecanismo padrão ainda é o activeRecord, portanto, você deve especificar activeRecord como false ou isso gerará entidades Active Record.
Incluindo campos em entidades
O comando Field é o mesmo e nada mudou na sua sintaxe. Digite os comandos na Listagem 7 para incluir campos nas classes de entidade.
Listagem 7. Incluir campos em classes de entidade
field string --fieldName firstname --class ~.domain.Speaker --notNull
field string --fieldName lastname --notNull
field string --fieldName email --class ~.domain.Speaker --unique --notNull --regexp
^([0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})
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
field date --fieldName created --type java.util.Date --notNull
field string --fieldName title --class ~.domain.Talk --notNull
field string --fieldName description --notNull --sizeMax 4000
field date --fieldName created --type java.util.Date --notNull
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
Observe o uso do regex no email, que validará o email em relação ao regex. Além disso, observe que o nome do campo é criado. Os campos com nomes criados da data do tipo não são atualizáveis. YouThis é um aprimoramento menor, mas útil. Na Listagem 8, o fragmento de código mostra que o valor do atributo atualizável na anotação da coluna está configurado como false.
Listagem 8. Exemplo de configuração ajustável como false
@NotNull @Column(updatable = false) @Temporal(TemporalType.TIMESTAMP) @DateTimeFormat(style = "M-") private Date created = new Date();
Incluindo o repositório e camadas de serviço
A comunidade do Spring Roo exigiu uma abordagem alternativa para o padrão ActiveRecord como repositório, e as camadas de serviço são mais comumente usadas nos aplicativos corporativos e os desenvolvedores são mais confortáveis com elas. O Spring Roo 1.2 torna possível ter Repositórios usando o projeto do Spring JPA. O Spring JPA é parte do projeto Spring Data que torna simples implementar os repositórios baseados em JPA. O Spring Roo usa os repositórios do Spring JPA que requer interfaces de repositório de gravação simples, e o Spring JPA fornece implementação para eles. Ele também suporta a inclusão do método do localizador customizado a parte das operações básicas do CRUD. É possível definir um método localizador na sua interface do repositório como segue:
List<Person> findPersonByNameAndCountry(String name, String country)
O Spring JPA fornecerá uma implementação para esse método, dividindo o nome do método, e retornará uma lista de todas as pessoas com nome e país fornecidos. Ele reduz o código, mas assegura que o nome do método esteja sempre alinhado com as propriedades da entidade. Se a classe Person não tiver a propriedade nome ou país, ela falhará. Este artigo não abordará o projeto do Spring Data JPA, mas considere ler sua documentação.
Para incluir interfaces Repository para suas entidades Speaker e Talk, digite os comandos em Listagem 9:
Listagem 9. Incluindo interfaces Repository
repository jpa --interface ~.repository.SpeakerRepository --entity ~.domain.Speaker repository jpa --interface ~.repository.TalkRepository --entity ~.domain.Talk
O comando repository jpa tem dois atributos: um é o nome da interface e o segundo é a entidade para qual você deseja criar o repositório. Neste caso, eu especifiquei a criação de um SpeakerRepository no pacote com.xebia.conference.core.repository para entidade Speaker. O mesmo é verdadeiro para a entidade Talk. Na saída do comando na Listagem 10), é possível ver que ele incluiu a dependência spring-data-jpa no pom.xml, e criou a interface SpeakerRepository.java e seu arquivo ITD correspondente SpeakerRepository_Roo_Jpa_Repository.aj.
Listagem 10. Saída de exemplo
Created core|SRC_MAIN_JAVA/org/xebia/conference/core/repository Created core|SRC_MAIN_JAVA/org/xebia/conference/core/repository/SpeakerRepository.java Created core|SPRING_CONFIG_ROOT/applicationContext-jpa.xml Updated core|ROOT/pom.xml [added dependency org.springframework.data:spring-data-jpa:1.0.2.RELEASE] Created core|SRC_MAIN_JAVA/org/xebia/conference/core/repository/ SpeakerRepository_Roo_Jpa_Repository.aj Created core|SRC_TEST_JAVA/org/xebia/conference/core/domain/ SpeakerDataOnDemand_Roo_DataOnDemand.aj Created core|SRC_TEST_JAVA/org/xebia/conference/core/domain/ SpeakerIntegrationTest_Roo_IntegrationTest.aj
O artefato mais interessante gerado pelo comando jpa é o ITD *Repository_Roo_Jpa_Repository.aj. O arquivo de declaração entre tipos (ITD) contém as três declarações em Listagem 11.
Listagem 11. Declarações no arquivo ITD
privileged aspect SpeakerRepository_Roo_Jpa_Repository {
declare parents: SpeakerRepository extends JpaRepository<Speaker, Long>; //1
declare parents: SpeakerRepository extends JpaSpecificationExecutor<Speaker> ; //2
declare @type: SpeakerRepository: @Repository; //3
}
A primeira linha diz que a interface do SpeakerRepository deve estender a interface do JpaRepository. A interface do JpaRepository contém declarações para todos os métodos CRUD e outros métodos comuns. A segunda linha diz que a interface SpeakerRepository deve estender a interface JpaSpecificationExecutor. Essa interface permite a execução das Especificações baseadas na API dos critérios JPA. A terceira linha e a linha final asseguram que a interface SpeakerRepository deve ter a anotação @Repository.
Incluindo camadas de serviço
Embora não seja necessário ter uma camada de serviço se você estiver usando Repositories, na maioria dos cenários faz sentido ter uma camada de serviço que tenha toda a lógica de negócios. Você descobrirá a necessidade para a classe de serviço, assim que começar a se mover do aplicativo CRUD gerado pelo Roo, portanto, faz sentido ter uma classe de serviço para as classes de entidade. Para criar os serviços para as entidades Speaker e Talk, execute os comandos na Listagem 12 na shell do Roo:
Listagem 12. Criando serviços
service --interface ~.service.SpeakerService --entity ~.domain.Speaker service --interface ~.service.TalkService --entity ~.domain.Talk
O comando service para SpeakerService gerou a saída na Listagem 13:
Listagem 13. Saída do SpeakerService
Created core|SRC_MAIN_JAVA/org/xebia/conference/core/service Created core|SRC_MAIN_JAVA/org/xebia/conference/core/service/SpeakerService.java Created core|SRC_MAIN_JAVA/org/xebia/conference/core/service/SpeakerServiceImpl.java Created core|SRC_MAIN_JAVA/org/xebia/conference/core/service/ SpeakerService_Roo_Service.aj Updated core|SRC_TEST_JAVA/org/xebia/conference/core/domain/ SpeakerDataOnDemand_Roo_DataOnDemand.aj Updated core|SRC_TEST_JAVA/org/xebia/conference/core/domain/ SpeakerIntegrationTest_Roo_IntegrationTest.aj Created core|SRC_MAIN_JAVA/org/xebia/conference/core/service/ SpeakerServiceImpl_Roo_Service.aj
Além de criar uma pasta de serviço e modificar classes de teste, ele criou SpeakerService, implementação SpeakerServiceImpl e dois ITDs: SpeakerService_Roo_Service.aj e SpeakerServiceImpl_Roo_Service.aj. O SpeakerService_Roo_Service.aj é ITD para interface SpeakerService e assegura que a interface SpeakerService contenha todas as declarações de método necessárias. O SpeakerServiceImpl_Roo_Service.aj contém o método de implementação definido no ITD SpeakerService_Roo_Service.aj e inclui todas essas implementações na classe SpeakerServiceImpl no tempo de compilação.
Com isso, o seu módulo core tem todo o código necessário para este artigo. Agora você criará a UI GWT e MVC usando o Spring Roo.
Desenvolver uma interface com o usuário GWT
Google Web Toolkit (GWT) (veja Recursos) é um kit de ferramentas de desenvolvimento de software livre para desenvolver aplicativos JavaScript complexos e elaborados na linguagem de programação Java. Com o GWT, é tão fácil para desenvolvedores Java escrever aplicativos da web complexos ativados para Ajax como o é para os desenvolvedores escrever código Java. E mais, o GWT compila o código para produzir JavaScript altamente otimizado.
O Spring Roo fornece suporte para aplicativos GWT de estruturação do modelo de domínio.
Nos releases anteriores, um comando único que chamou gwt setup fez toda a mágica de configurar o GWT para criar visualizações para entidades e assegurar a compatibilidade com o Google App Engine. Agora o comando gwt setup é dividido em dez comandos diferentes, dando aos desenvolvedores mais controle. A Listagem 14 mostra os comandos.
Listagem 14. Saída da ajuda do web gwt
view/gwt roo> help --command "web gwt" * web gwt all - Locates all entities in the project and creates GWT requests, proxies and creates the scaffold * web gwt gae update - Updates the GWT project to support GAE * web gwt proxy all - Locates all entities in the project and creates GWT proxies * web gwt proxy request all - Locates all entities in the project and creates GWT requests and proxies * web gwt proxy request type - Creates a proxy and request based on the specified type * web gwt proxy type - Creates a GWT proxy based on the specified type * web gwt request all - Locates all entities in the project and creates GWT requests * web gwt request type - Creates a GWT proxy based on the specified type * web gwt scaffold - Creates a GWT request, proxy and scaffold for the specified type * web gwt setup - Install Google Web Toolkit (GWT) into your project
Para criar um front-end GWT para o modelo de domínio, são necessários dois comandos: web gwt setup e web gwt all. Use os outros comandos para:
- Criar proxies, solicitações ou ambos, solicitações e proxies, quando você não deseja estruturar a UI
- Criar proxies, solicitações ou ambos, solicitações e proxy, além de estruturar a UI
- Atualizar o projeto GWT para suportar o Google App Engine
Este artigo aborda apenas web gwt setup e web gwt all. É possível usar os outros comandos facilmente com base no seu conhecimento de como esses dois comandos funcionam.
Configura o projeto GWT
O Spring Roo agora segue uma convenção que todos os seus complementos de visualização (como GTW, MVC e JSF) têm um comando de configuração. O comando de configuração tem a responsabilidade de incluir dependências necessárias do Maven, alguns arquivos de configuração, algumas classes simuladas, e criar a estrutura da pasta necessária pela tecnologia de visualização. Para configurar o projeto GWT, digite o comando na Listagem 15, que também mostra a saída do comando.
Listagem 15. Saída de amostra da web gwt setup
view/gwt roo> web gwt setup
Created view/gwt|ROOT/src/main/webapp/WEB-INF/spring
Created view/gwt|ROOT/src/main/webapp/WEB-INF/spring/webmvc-config.xml
Created view/gwt|ROOT/src/main/webapp/WEB-INF/web.xml
Updated view/gwt|ROOT/src/main/webapp/WEB-INF/spring/webmvc-config.xml
Created view/gwt|SRC_MAIN_JAVA/org/xebia/conference/view/gwt
Created view/gwt|SRC_MAIN_JAVA/org/xebia/conference/view/gwt/App.gwt.xml
Created view/gwt|SRC_MAIN_JAVA/org/xebia/conference/view/gwt/client
Created view/gwt|SRC_MAIN_JAVA/org/xebia/conference/view/gwt/client/AppEntryPoint.java
Updated view/gwt|ROOT/src/main/webapp/WEB-INF/web.xml
Updated view/gwt|ROOT/pom.xml
[added dependencies org.springframework:spring-webmvc:${spring.version},
org.springframework.webflow:spring-js-resources:2.2.1.RELEASE,
commons-digester:commons-digester:2.1, commons-fileupload:commons-fileupload:1.2.2,
javax.servlet.jsp.jstl:jstl-api:1.2, org.glassfish.web:jstl-impl:1.2,
javax.el:el-api:1.0, joda-time:joda-time:1.6, javax.servlet.jsp:jsp-api:2.1,
commons-codec:commons-codec:1.5; updated project type to war;
added repository http://maven.springframework.org/external;
added dependencies com.google.gwt:gwt-servlet:2.4.0, com.google.gwt:gwt-user:2.4.0,
org.json:json:20090211, com.google.gwt.inject:gin:1.5.0,
javax.validation:validation-api:1.0.0.GA,
javax.validation:validation-api:1.0.0.GA:sources, xalan:xalan:2.7.1;
added plugin org.codehaus.mojo:gwt-maven-plugin:2.2.0;
added plugin org.codehaus.mojo:exec-maven-plugin:1.2]
A saída do comando mostra que foi recém-criado um projeto GWT de modelo com as dependências e plugins do Maven necessários, uma classe AppEntryPoint de amostra, um descritor de módulo GWT de amostra App.gwt.xml e web.xml que é necessário para todos os aplicativos web. O comando web gwt setup não executa nada interessante, assim vamos examinar o comando web gwt all. Para estruturar uma UI do GWT para o domínio, execute o seguinte comando:
web gwt all --proxyPackage ~.client.proxy --requestPackage ~.client.request
O comando web gwt all faz todo o levantamento pesado e cria o descritor de implementação de módulo GWT ApplicationScaffold.gwt.xml, o ponto de entrada GWT Scaffold.java, as classes proxy SpeakerProxy e TalkProxy, várias classes de Atividade para as entidades Speaker e Talk, classes RequestFactory para Speaker e Talk, e várias classes Place.
Para configurar o log log4j para o projeto GWT, digite:
logging setup --level INFO
Para sair da shell, digite q ou quit. Esses comandos criarão um aplicativo de conferência front-end do GWT completamente funcional.
Para executar o aplicativo, vá para o diretório gwt da linha de comandos, digite mvn gwt:run (que inicia o servidor jetty e ativa o modo de desenvolvimento do GWT). Para abrir o aplicativo no navegador padrão, clique em Launch Default Browser, ou copie a URL para uma área de transferência e abra o aplicativo em outro navegador.
O aplicativo executará em http://127.0.0.1:8888/ApplicationScaffold.html?gwt.codesvr=127.0.0.1:9997. Você verá a tela na Figura 3. abaixo. Clique em Talks ou Speaker para visualizar todas as palestras ou oradores.
Figura 3. Executando aplicativo GWT
Desenvolver uma Interface com o Usuário do Spring MVC
Esta seção examina brevemente a criação da visualização na web do Spring MVC para o modelo do domínio que você criou neste artigo. O comando ‘controller all’ mencionado na Parte 1 foi descontinuado agora e não é recomendado. Antes de usar os novos comandos, concentre-se primeiro no módulo mvc. Digite este comando na shell do Roo:
module focus --moduleName view/mvc
O novo comando de configuração do Spring Roo faz toda a configuração relacionada à configuração dos aplicativos Spring MVC. Agora temos um controlador se você desejar estruturar os controladores ou quiser simplesmente fazer a configuração. Para configurar o Spring MVC no seu aplicativo, digite:
view/mvc roo> web mvc setup
A saída desse comando mostra que o comando fez a configuração relacionada à inclusão do arquivo de contexto webmvc-config.xml do Spring, as dependências incluídas do Maven, os arquivos de recursos estáticos incluídos e biblioteca de tags incluída no Spring Roo. Esse comando não criou visualizações para entidades. Isso é útil para aqueles que não precisam de uma visualização para duas entidades. É possível criar manualmente controladores e expor os serviços da web RESTful.
Depois de concluir a configuração básica do aplicativo de conferência, a próxima etapa é criar controladores e visualizações para entidades. Digite o seguinte comando:
view/mvc roo> web mvc all --package ~.web
O comando web mvc all criará controladores e visualizações jspx para todas as entidades. Para estruturar uma única entidade, use o comando web mvc scaffold para fornecer o nome da entidade e o nome completo do controlador. AListagem 16 mostra muitos outros comandos web mvc. A Parte 2 aborda alguns desses comandos, assim nem todos são abordados aqui.
Listagem 16. Saída de ajuda do web mvc
view/mvc roo> help --command "web mvc" * web mvc all - Scaffold Spring MVC controllers for all project entities without an existing controller * web mvc controller - Create a new manual Controller (where you write the methods) * web mvc embed document - Embed a document for your WEB MVC application * web mvc embed generic - Embed media by URL into your WEB MVC application * web mvc embed map - Embed a map for your WEB MVC application * web mvc embed photos - Embed a photo gallery for your WEB MVC application * web mvc embed stream video - Embed a video stream into your WEB MVC application * web mvc embed twitter - Embed twitter messages into your WEB MVC application * web mvc embed video - Embed a video for your WEB MVC application * web mvc embed wave - Embed Google wave integration for your WEB MVC application * web mvc finder add - Adds @RooWebFinder annotation to MVC controller type * web mvc finder all - Adds @RooWebFinder annotation to existing MVC controllers * web mvc install language - Install new internationalization bundle for MVC scaffolded UI. * web mvc install view - Create a new static view. * web mvc json add - Adds @RooJson annotation to target type * web mvc json all - Adds or creates MVC controllers annotated with @RooWebJson annotation * web mvc json setup - Set up Spring MVC to support JSON * web mvc language - Install new internationalization bundle for MVC scaffolded UI. * web mvc scaffold - Create a new scaffold Controller (that is where Roo maintains CRUD functionality automatically) * web mvc setup - Setup a basic project structure for a Spring MVC / JSP application * web mvc update tags - Replace an existing application tagx library with the latest version (use --backup option to backup your application first) * web mvc view - Create a new static view.
Implementando no Cloud Foundry
Agora que você criou um aplicativo de conferência, faz sentido implementá-lo. É possível implementar os aplicativos do Spring para a nuvem pública do Cloud Foundry sem nenhuma modificação. A Parte 4 aborda o Cloud Foundry em detalhes, incluindo como implementar os aplicativos do Spring Roo de dentro da shell do Roo usando o complemento Cloud Foundry do Spring Roo. No release 1.2.1, no entanto, o suporte parece estar interrompido. Portanto, neste artigo você usará vmc ruby gem para implementar o aplicativo de conferência no Cloud Foundry. Siga estas etapas:
1. Instale o cliente vmc. Para obter um tutorial passo a passo denominado “Instalando a Interface da Linha de Comandos (vmc),” veja Recursos.
2. Efetue login na nuvem pública do Cloud Foundry usando as credenciais que você registrou no Cloud Foundry. Digite o comando vmc login e ele solicitará o seu email e senha como na Listagem 17.
Listagem 17. Exemplo do login do vmc
shekhar@shekhar:~/dev/conference/view/mvc/target$ vmc login Attempting login to [http://api.cloudfoundry.com] Email: shekhargulati84@gmail.com Password: ************* Successfully logged into [http://api.cloudfoundry.com]
3. Assim que você instalar o cliente vmc, faça o desenvolvimento integral do Maven do aplicativo de conferência. Para fazer isso, digite:
mvn clean install
4. Depois de desenvolver o projeto, realize o push do aplicativo de conferência para o Cloud Foundry. Neste artigo, você realizará o push em dois aplicativos: um para o Spring MVC e outro para o GWT. Para realizar o push do aplicativo de conferência do Spring MVC, vá para a pasta conference/view/mvc/target e digite vmc push como na Listagem 18.
Listagem 18. Exemplo de push do aplicativo Spring MVC
shekhar@shekhar:~/dev/conference/view/mvc/target$ vmc push Would you like to deploy from the current directory? [Yn]: Y Application Name: mvcconference Application Deployed URL [mvcconference.cloudfoundry.com]: Detected a Java SpringSource Spring Application, is this correct? [Yn]: Y Memory Reservation (64M, 128M, 256M, 512M, 1G) [512M]: Creating Application: OK Would you like to bind any services to 'mvcconference'? [yN]: N Uploading Application: Checking for available resources: OK Processing resources: OK Packing application: OK Uploading (91K): OK Push Status: OK Staging Application: OK Starting Application: OK
O cliente vmc do Cloud Foundry fará perguntas sobre o nome do aplicativo, o tipo do aplicativo, a URL a ser implementada, a reserva de memória, se qualquer serviço deve ser vinculado ou não, e, finalmente, fará upload e implementará o aplicativo no Cloud Foundry. É possível visualizar o aplicativo Spring MVC executando em http://mvcconference.cloudfoundry.com/
Realize o push do aplicativo GWT no Cloud Foundry. Alterne para a pasta conference/view/gwt/target e digite vmc push como na Listagem 19.
Listagem 19. Exemplo de push do aplicativo GWT
shekhar@shekhar:~/dev/conference/view/gwt/target$ vmc push Would you like to deploy from the current directory? [Yn]: Y Application Name: gwtconference Application Deployed URL [gwtconference.cloudfoundry.com]: Detected a Java SpringSource Spring Application, is this correct? [Yn]: Y Memory Reservation (64M, 128M, 256M, 512M) [512M]: Creating Application: OK Would you like to bind any services to 'gwtconference'? [yN]: N Uploading Application: Checking for available resources: OK Processing resources: OK Packing application: OK Uploading (5M): OK Push Status: OK Staging Application: OK Starting Application: OK
Visualize o aplicativo em execução em: http://gwtconference.cloudfoundry.com/
Conclusão
Este artigo apresentou novamente o Spring Roo. Você aprendeu sobre novos recursos como projetos do Maven multimódulos, o repositório e a camada de serviço apresentados no Spring Roo 1.2, e criou o aplicativo usando o Roo 1.2 que incorporou alguns dos novos recursos. Você também examinou como usar o Spring Roo para criar aplicativos GWT. Finalmente, você implementou o aplicativo Spring MVC e GWT no Cloud Foundry. Alguns novos recursos como o suporte para JSF e MongoDB não foram examinados neste artigo.
A Parte 7 desta série abordará a criação dos aplicativos Spring MongoDB usando o Spring Roo e implementando o Cloud Foundry.
Download
| Descrição | Nome | Tamanho | Método de download |
|---|---|---|---|
| Sample code | conference.zip | 340KB | HTTP |
Informações sobre métodos de download
Recursos
Aprender
- Certifique-se de ler o restante desta série sobre o Spring Roo:
- Consulte as informações em incremental database reverse engineering (DBRE) add-on na documentação do Spring Roo.
- Verifique o tutorial, “Installing the Command-Line Interface (vmc).”
- Saiba mais na página website do Spring Roo e veja se essa ferramenta de desenvolvimento de aplicativo rápido para desenvolvedores Java se adapta às suas necessidades.
- Consulte o blogs do SpringSource sobre o Spring Roo.
- Em Software Livre, no developerWorks, encontre amplas informações instrutivas, ferramentas e atualizações de projeto para ajudá-lo a desenvolver com tecnologias de software livre e usá-las com produtos IBM.
- Na tela Zona de tecnologia Java do developerWorks, encontre artigos, tutoriais, fóruns e muito mais sobre cada aspecto da programação em Java.
- Fique por dentro dos eventos e webcasts técnicos do developerWorks com ênfase em uma variedade de produtos IBM e assuntos do segmento de mercado de TI.
- Participe de um briefing ao vivo e gratuito do developerWorks Live! para atualizar-se rapidamente sobre produtos e ferramentas IBM e tendências do segmento de mercado de TI.
- Escute os Podcasts do developerWorks para obter entrevistas interessantes e discussões para os desenvolvedores de software.
- Siga os tweets do developerWorks no Twitter.
- Acompanhe as Demos do developerWorks que vão desde instalação e configuração de produtos para iniciantes até funcionalidades avançadas para desenvolvedores experientes.
Obter produtos e tecnologias
- Faça o download do código fonte do módulo produto Java 6 no website do projeto.
- Faça o download do Apache Maven 3 no website do projeto.
- Faça o download do Spring Roo 1.2 e acima do website do projeto.
- Saiba mais sobre o Kit de ferramentas Google Web na página inicial do projeto.
- Registre-se para a nuvem pública CloudFoundry.
- Utilize o software de avaliação da IBM (disponível para download ou em DVD) e inove em seu próximo projeto de desenvolvimento de software livre próprio usando o software especialmente para desenvolvedores.
Discutir
- Conecte-se com outros usuários do developerWorks enquanto explora os blogs, fóruns, grupos e wikis voltados para desenvolvedores. Ajude a desenvolver o software livre do mundo real na comunidade do developerWorks.
***
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 experiência abrangente em projetos do portfólio do Spring, tais como o Spring, o Spring-WS e o Spring Roo. Seus interesses são Spring, bancos de dados NoSQL, Hadoop, estruturas RAD como o Spring Roo, computação em nuvem (principalmente serviços PaaS como o 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 publicado em: http://www.ibm.com/developerworks/br/library/os-springroo6/
De 0 a 10, o quanto você recomendaria este artigo para um amigo?