Apresentando Spring Roo, Parte 2: Desenvolvendo um aplicativo com Spring Roo

Criando um aplicativo corporativo completo usando o Spring Roo

Na Parte 1 desta série, criamos um aplicativo baseado em CRUD, em poucos minutos, usando Roo. Aqui, na Parte 2, vamos estender esse aplicativo para um aplicativo corporativo completo incluindo recursos como segurança de Spring, suporte a email, e muitos outros.

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

Na Parte 1 desta série sobre o Spring Roo, desenvolvemos um pequeno aplicativo de conferência corporativo usando o Spring Roo. Aqui, vamos estender esse aplicativo da web CRUD simples para se tornar um aplicativo corporativo completo usando o Spring Roo. Antes de começarmos, confirme se o Spring Roo está instalado e se o SpringSource Tool Suite foi transferido por download (consulte a Parte 1 para obter mais informações).

Vamos começar

Para estender nosso aplicativo de conferência, precisamos recriar o aplicativo da Parte 1. Podemos seguir as instruções anteriores ou usar o comando script do Roo. script executa todos os comandos especificados em um arquivo de recursos. Se você acompanhou a Parte 1, notou que o Roo criou um arquivo chamado log.roo, que contém todos os comandos disparados no shell do Roo. Executaremos esse arquivo log.roo e recriaremos o aplicativo.

  1. Esse arquivo é incluído no código de amostra. É possível renomeá-lo para conference.roo.
  2. Crie um novo diretório chamado conference e copie conference.roo para ele.
  3. Abra o shell de linha de comando do seu sistema operacional.
  4. Acesse o diretório conference que acabou de criar.
  5. Dispare o comando script --file conference.roo .

script recriará o aplicativo em alguns segundos se os JARs necessários estiverem no seu repositório do Maven. Caso contrário, levará um pouco mais de tempo visto que precisará fazer o download de todos os JARs. O comando script é útil no sentido de que pode ser utilizado como modelo para criar projetos gerenciados por Spring.

Antes de prosseguirmos, importe o projeto de Maven para STS. O STS vem pré-empacotado com o plug-in do Eclipse de Maven. Deve-se importar o projeto selecionando File > Import > Maven > Existing Maven Projects, e selecionando depois o diretório do projeto. Estamos importando o projeto para o STS visto que vamos escrever código customizado mais tarde.

O aplicativo da web que criamos até agora funciona, e podemos testá-lo manualmente criando, lendo, atualizando e excluindo as entidades Speaker e Talk. Mas não seria ótimo poder automatizar esse processo?


Teste da web automatizado

Este é o próximo recurso do Spring Roo que vamos analisar: o suporte a testes Selenium. O Selenium é um conjunto robusto de ferramentas com suporte a desenvolvimento rápido de automação de teste para aplicativos baseados na web. Para incluir suporte aos testes Selenium no seu aplicativo, execute os comandos mostrados abaixo:

	selenium test --controller ~.web.SpeakerController
	selenium test --controller ~.web.TalkController

O comando selenium test criará um teste Selenium para os controladores Speaker e Talk. Esse comando tem um atributo obrigatório chamado controller para especificar o nome do controlador a fim de criar o teste Selenium. Esse comando também tem dois atributos opcionais chamados name e serverUrl para especificar o nome do teste Selenium e do servidor onde o aplicativo da Web está disponível. O Spring Roo também incluirá o plug-in Selenium Maven ao disparar o comando selenium test .

Acima, criamos etapas de teste Selenium para nosso controlador, mas antes de executá-las, precisamos corrigir um pequeno defeito no conjunto de testes Selenium criado pelo Spring Roo. Incluímos uma restrição na nossa entidade Speaker de que a idade deve estar entre 25 e 60, mas o conjunto de testes não leva em conta essa restrição. Ele usou um valor de idade como 1, de modo que o teste falhará. Precisamos modificar um arquivo chamado test-speaker.xhtml e atualizar a seção mostrada na Listagem 1.

Listagem 1. Modificação de test-speaker.xhtml
		<tr>
			<td>type</td>
			<td>_age_id</td>
			<td>1</td>
		</tr>

to

		<tr>
			<td>type</td>
			<td>_age_id</td>
			<td>26</td>
		</tr>

Esse defeito será corrigido em um release futuro do Spring Roo.

Para executar as etapas de teste Selenium, precisamos iniciar o servidor Tomcat. Pode-se iniciá-lo usando o comando de Maven mvn tomcat:run. Por padrão, todos os aplicativos da web criados usando o Roo têm plug-ins Maven para servidores da web Tomcat e Jetty. Para executar selenium test, execute o comando de Maven mvn selenium:selenese.

Isso ativará o navegador Firefox para executar as etapas de teste Selenium. Durante a execução dos testes, deve aparecer uma imagem similar à Figura 1.

Figura 1. Testes Selenium
Testes Selenium

No momento, qualquer um pode acessar nosso aplicativo e criar, atualizar ou excluir em Speaker e Talk. Em um aplicativo em tempo real, é aplicada segurança quanto a quem pode executar qual operação.


Tornar seguro o aplicativo da web

O Roo usa Spring Security para incluir segurança no seu aplicativo em uma linha. Spring Security é uma estrutura de autenticação e controle de acesso poderosa e altamente customizável. Na prática, trata-se do padrão para tornar seguros os aplicativos baseados em Spring.

Incluindo Spring Security

Para incluir o Spring Security, digite o seguinte comando: security setup.

Esse comando incluirá todos os JARs de Spring Security necessários e configurará a segurança básica para o seu aplicativo. Esse comando também cria outros arquivos, mas o mais importante é applicationContext-security.xml, que contém todas as definições de bean relacionadas à segurança. O contexto applicationContext-security.xml se parece com o conteúdo da Listagem 2. Substituí a senha com hash por pontos para torná-la mais legível.

Listagem 2. Contexto de applicationContext-security.xml
<beans:beans xmlns="http://www.springframework.org/schema/security"
    xmlns:beans="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans \
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                        http://www.springframework.org/schema/security \
http://www.springframework.org/schema/security/spring-security-3.0.xsd">

	<!-- HTTP security configurations -->
    <http auto-config="true" use-expressions="true">
    	<form-login login-processing-url="/resources/j_spring_security_check" \
login-page="/login" authentication-failure-url="/login?login_error=t"/>
        <logout logout-url="/resources/j_spring_security_logout"/>
        
        <!-- Configure these elements to secure URIs in your application -->
        <intercept-url pattern="/choices/**" access="hasRole('ROLE_ADMIN')"/>
        <intercept-url pattern="/member/**" access="isAuthenticated()" />
        <intercept-url pattern="/resources/**" access="permitAll" />
        <intercept-url pattern="/**" access="permitAll" />
    </http>

	<!-- Configure Authentication mechanism -->
    <authentication-manager alias="authenticationManager">
    	<!-- SHA-256 values can be produced using \
'echo -n your_desired_password | sha256sum' \
(using normal *nix environments) -->
    	<authentication-provider>
	    	<password-encoder hash="sha-256"/>
	        <user-service>
	            <user name="admin" password="..." authorities="ROLE_ADMIN"/>
		        <user name="user" password="..." authorities="ROLE_USER"/>
		    </user-service>
    	</authentication-provider>
	</authentication-manager>

</beans:beans>

A segurança configurada pelo Roo é genérico e não faz referência ao seu aplicativo. Tenha em mente que o Roo ajuda a configurar um aplicativo para iniciação rápida, mas é responsabilidade do desenvolvedor customizar o produto final. Nesse caso, o Roo simplesmente forneceu um modelo para Spring Security, e é sua responsabilidade customizá-lo de acordo com as suas necessidades.

Customizando o Spring Security

No nosso aplicativo, qualquer um pode criar um Speaker, mas apenas um Speaker pode criar um Talk. Precisamos modificar applicationContext-security.xml como mostrado abaixo. A Listagem 3 mostra apenas a parte do XML que precisa de modificação.

Listagem 3. Modificando applicationContext-security.xml
<http auto-config="true" use-expressions="true">
    	<form-login login-processing-url="/resources/j_spring_security_check" \
login-page="/login" authentication-failure-url="/login?login_error=t"/>
        <logout logout-url="/resources/j_spring_security_logout"/>
        
        <!-- Configure these elements to secure URIs in your application -->
        <intercept-url pattern="/talks/**" access="hasRole('ROLE_USER')"/>
        <intercept-url pattern="/speakers/**" access="permitAll" />
        <intercept-url pattern="/resources/**" access="permitAll" />
        <intercept-url pattern="/**" access="permitAll" />
</http>

Atualizei o intercept-url para que apenas usuários com função de usuário possam criar um Talk, e todos os usuários têm permissão de se registrar como Speaker.

O Spring Security gerado por Roo e mostrado acima usa um provedor de autenticação na memória configurado na tag <user-service> . Visto que nosso aplicativo gerencia entidades Speaker, devemos desenvolver um provedor de autenticação customizado que use dados do Speaker. Para autenticação, usaremos o email de Speaker como nome de usuário e incluiremos um campo de senha na entidade Speaker, que usaremos como senha de autenticação.

Novamente, o shell do Roo foi usado para incluir o campo de senha na entidade Speaker:

field string --class ~.domain.Speaker --fieldName password --notNull --sizeMin 6 –sizeMax
10

Uma restrição de que a senha não deve ser nula e que deve ter entre 6 e 10 caracteres também foi acrescentada.

Visto que estamos usando email e senha como parâmetros de autenticação, gostaríamos de encontrar um Speaker com determinado email e senha. O Spring Roo fornece um recurso para criar localizadores no seu aplicativo usando o comando finder add :

finder add --finderName findSpeakersByEmailAndPasswordEquals --class ~.domain.Speaker

É possível localizar todos os localizadores de uma entidade usando o comando finder list . finder add escreve o código do localizador no arquivo Speaker_Roo_Finder.aj e escreve alguns arquivos relacionados à visualização. Isso permite procurar oradores a partir da interface gráfica com o usuário.

Escrevendo AuthenticationProvider customizado

Vamos escrever um provedor de autenticação customizado estendendo a classe chamada AbstractUserDetailsAuthenticationProvider, que funciona com nome de usuário/senha para autenticação. As classes que estendem o AbstractUserDetailsAuthenticationProvider precisam fornecer implementação para seus dois métodos abstratos: additionalAuthenticationChecks e retrieveUser. O provedor chama o método retrieveUser para autenticar o Speaker usando o email e a senha inseridos. A consulta ao banco de dados pelo Speaker é feita usando o localizador criado acima. Se o Speaker for localizado, GrantedAuthority ROLE_USER é designado ao Speaker. O método finalmente retorna um objeto UserDetails preenchido se o login for bem-sucedido ou lança uma exceção BadCredentialsException com a mensagem adequada se não for (consulte a Listagem 4).

Listagem 4. Autenticação customizada
package com.dw.roo.conference.security;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityNotFoundException;
import javax.persistence.NonUniqueResultException;

import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.authentication.\
dao.AbstractUserDetailsAuthenticationProvider;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.GrantedAuthorityImpl;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.util.StringUtils;

import com.dw.roo.conference.domain.Speaker;

public class ConferenceAuthenticationProvider extends \
AbstractUserDetailsAuthenticationProvider {

    @Override
    protected void additionalAuthenticationChecks(UserDetails userDetails, \
UsernamePasswordAuthenticationToken authentication)
            throws AuthenticationException {
        // TODO Auto-generated method stub

    }

    @Override
    protected UserDetails retrieveUser(String username,
UsernamePasswordAuthenticationToken \
authentication) throws AuthenticationException {
        String password = (String) authentication.getCredentials();
        if (!StringUtils.hasText(password)) {
            throw new BadCredentialsException("Please enter password");
        }
        List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
        try {
            Speaker speaker = Speaker.findSpeakersByEmailAndPasswordEquals(username, \
password).getSingleResult();
            authorities.add(new GrantedAuthorityImpl("ROLE_USER"));
        } catch (EmptyResultDataAccessException e) {
            throw new BadCredentialsException("Invalid username or password");
        } catch (EntityNotFoundException e) {
            throw new BadCredentialsException("Invalid user");
        } catch (NonUniqueResultException e) {
            throw new BadCredentialsException("Non-unique user, contact administrator");
        }
        return new User(username, password, true, // enabled
                true, // account not expired
                true, // credentials not expired
                true, // account not locked
                authorities);
    }
}

Em applicationContext-security.xml, precisamos definir o bean conferenceAuthenticationProvider e substituir o provedor de autenticação na memória gerado pelo Roo pelo nosso conferenceAuthenticationProvider , conforme a Listagem 5.

Listagem 5. conferenceAuthenticationProvider
<beans:bean name="conferenceAuthenticationProvider"
class="com.dw.roo.conference.security.ConferenceAuthenticationProvider">
</beans:bean>

<!-- Configure Authentication mechanism -->
<authentication-manager alias="authenticationManager">
	<authentication-provider ref="conferenceAuthenticationProvider"/>
</authentication-manager>

Agora, se inicializarmos o servidor e tentarmos criar um Talk, aparecerá uma tela de login onde será preciso inserir o email e a senha do Speaker criado. O provedor de autenticação customizado foi criado para mostrar o que o Roo faz e o que é necessário fazer sozinho, e não criar um provedor ideal.


Notificação por email

No nosso aplicativo, Speakers deve receber um email quando criar um Talk. Por isso, vamos incluir suporte a email no nosso aplicativo. O Gmail será usado como nosso servidor SMTP para nos concentrar em enviar email usando o Roo. A inclusão de suporte a email em um aplicativo é feita com o uso do seguinte comando:

email sender setup --hostServer smtp.gmail.com --username \
<Your email address> --password <Your email password> --port 587 --protocol SMTP

O comando do remetente de email instala um JavaMailSender de Spring no seu projeto. É possível alterar as propriedades relacionadas ao email no arquivo email.properties.

Após um Talk ser criado, precisamos enviar o email. Para isso, precisamos incluir um campo de email em TalkController. Para incluir o campo de email, digite:

field email template --class ~.web.TalkController

Isso incluirá um modelo MailSender e um método sendMessage em TalkController. Agora, precisamos acionar o método sendMessage após um Talk ser persistido no banco de dados. Visto que todo o código de TalkController existe no arquivo TalkController_Roo_Controller.aj, a forma mais fácil de executar essa tarefa é criar um método encodeUrlPathSegment a partir do arquivo .aj na classe TalkController e incluir uma chamada para o método sendMessage após a linha talk.persist() , como mostrado na Listagem 6.

Listagem 6. Criando um método encodeUrlPathSegment a partir do arquivo .aj em TalkController
public class TalkController {

	@Autowired
	private transient MailSender mailTemplate;

	public void sendMessage(String mailFrom, String subject, String mailTo,
			String message) {
		org.springframework.mail.SimpleMailMessage \
simpleMailMessage = new org.springframework.mail.SimpleMailMessage();
		simpleMailMessage.setFrom(mailFrom);
		simpleMailMessage.setSubject(subject);
		simpleMailMessage.setTo(mailTo);
		simpleMailMessage.setText(message);
		mailTemplate.send(simpleMailMessage);
	}

	@RequestMapping(method = RequestMethod.POST)
	public String create(@Valid Talk talk, BindingResult result, Model model,
			HttpServletRequest request) {
		if (result.hasErrors()) {
			model.addAttribute("talk", talk);
			return "talks/create";
		}
		talk.persist();
		sendMessage("spring.roo.playground@gmail.com", "Your talk is created",
				talk.getSpeaker().getEmail(), \
"Congrats your talk is created");
		return "redirect:/talks/"
				+ encodeUrlPathSegment(talk.getId().toString(), request);
	}

	private String encodeUrlPathSegment(String pathSegment,
			HttpServletRequest request) {
		String enc = request.getCharacterEncoding();
		if (enc == null) {
			enc = WebUtils.DEFAULT_CHARACTER_ENCODING;
		}
		try {
			pathSegment = UriUtils.encodePathSegment(pathSegment, enc);
		} catch (UnsupportedEncodingException uee) {
		}
		return pathSegment;
	}
}

De agora em diante, os oradores receberão um email em suas contas especificadas após a criação de um Talk.


Suporte a internacionalização

Visto que estamos desenvolvendo um aplicativo da web baseado na Internet, é importante oferecer suporte a idiomas diferentes para que usuários de diferentes locais possam utilizá-lo. O Spring Roo inclui suporte a internacionalização ao usar o comando web mvc install language , que instala um novo idioma no seu aplicativo. Por exemplo, os comandos para espanhol e italiano são:

web mvc install language --code es 
web mvc install language --code it

Atualmente, o Roo oferece suporte a seis idiomas, e é possível escrever um complemento para qualquer idioma à sua escolha. Agora, quando o aplicativo estiver em execução, duas bandeiras serão exibidas (da Itália e da Espanha), juntamente com a bandeira britânica. Se clicarmos em uma dessas bandeiras, o aplicativo da web será visualizado no idioma correspondente à bandeira.


Socializar o aplicativo da web

Estamos na era da mídia social, e recursos sociais costumam ser incluídos nos aplicativos atuais. Faz sentido incluir vídeo de Talks. O Roo fornece suporte para inclusão de vídeos transferidos por upload para YouTube, Vimeo, Viddler e Google Video, etc. Para incluir um vídeo, use o seguinte comando:

web mvc embed video --provider VIMEO --videoId 16069687

Se iniciar o servidor e ativar seu aplicativo em um navegador, será possível assistir ao vídeo integrado acima. De modo semelhante, também é possível incluir vídeos do YouTube ou Viddler.

O Roo também fornece a opção de integrar mensagens do Twitter, documentos, barras de notícias, mapas, fotos e conexões de vídeo ao seu aplicativo. Os vários comandos encontram-se na Listagem 7.

Listagem 7. Integrar comandos
web mvc embed document 
web mvc embed finances 
web mvc embed map
web mvc embed photos 
web mvc embed stream video 
web mvc embed twitter
web mvc embed video

Engenharia reversa de banco de dados

A engenharia reversa de banco de dados (DBRE) permite uma introspecção em um banco de dados existente e expô-lo como aplicativo. Para mostra como funciona a DBRE, um aplicativo de feedback será criado a partir de um esquema de feedback existente. MySQL será usado como banco de dados.

Antes de ativar o Roo, precisamos criar um esquema em nossa instalação do MySQL. Execute o script SQL da Listagem 8 para criar um esquema de feedback em seu banco de dados MySQL.

Listagem 8. Script SQL para criar esquema de feedback
create database feedback_schema;
use feedback_schema;
CREATE TABLE feedback (
  id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  TalkTitle VARCHAR(45) NOT NULL,
  SpeakerName VARCHAR(45) NOT NULL,
  Feedback VARCHAR(4000) NOT NULL,
  PRIMARY KEY (id)
)
ENGINE = InnoDB;

Esse é um esquema simples, com uma tabela e nenhum relacionamento, mas o Roo também consegue fazer engenharia reversa de um esquema complexo, com diversas tabelas e relacionamentos.

Depois de executar o script SQL acima e gerado seu esquema, crie um aplicativo de feedback:

  1. Crie um diretório chamado feedback.
  2. Na sua linha de comando do sistema operacional, acesse o diretório feedback.
  3. Abra o shell do Roo digitando o comando roo .
  4. Digite project --topLevelPackage com.dw.roo.feedback para criar um projeto de Maven.
  5. Nesse aplicativo, usarei MySQL como banco de dados. Para configurar a persistência do seu aplicativo, use:
    persistence setup --provider HIBERNATE 
    --database MYSQL --databaseName feedback_schema 
      --userName root --password password

    Considerando que criei o esquema com usuário raiz, uso root como meu nome de usuário. Digite o nome de usuário e a senha criados no seu esquema. Esse comando também incluirá todos os JARs necessários para persistência.

  6. Pode-se fazer a introspecção do esquema do banco de dados usando database introspect --schema feedback_schema. O comando database introspect mostra os metadados relacionados ao esquema do banco de dados. Esse comando lhe mostrará os metadados do seu esquema no console de shell do Roo. Também é possível exportar o xml de metadados para um arquivo usando --file attribute.
  7. Depois de ter feito a introspecção do seu esquema de banco de dados, poderá fazer a engenharia reversa desse esquema usando database reverse engineer --schema feedback_schema --package ~.domain.

    O comando database reverse engineer tem dois atributos obrigatórios, schema e package, para especificar o nome do esquema no qual se deseja realizar engenharia reversa e o pacote no qual o Roo gerará as origens. Isso criará todas as entidades no pacote com.dw.roo.feedback.domain.

  8. A próxima etapa é gerar os controladores do seu aplicativo. Isso pode ser feito disparando controller all --package ~.web.
  9. Antes de executar nosso aplicativo, precisamos fazer uma pequena mudança em uma propriedade de persistence.xml. A propriedade hibernate.ejb.naming_strategy está usando ImprovedNamingStrategy, que não funciona em bancos de dados MySQL e gerará uma exceção se for executado mvn clean install tomcat:run. Para fazê-lo funcionar, é preciso alterar hiberate.ejb.naming_strategy para DefaultNamingStrategy, conforme mostrado abaixo:
    <property name="hibernate.ejb.naming_strategy" 
    value="org.hibernate.cfg.DefaultNamingStrategy"/>
  10. Agora é possível executar o aplicativo de feedback usando o comando de Maven mvn clean install tomcat:run.

É possível fazer o download do código de origem para conferência e feedback (consulte Download).


Conclusão

Neste ponto, estendemos nosso aplicativo da web simples CRUD para se tornar um aplicativo corporativo completo. Demonstramos como é simples incluir recursos como teste Selenium, Spring Security, suporte a internacionalização e outros. Também mostrei como criar um aplicativo a partir de um banco de dados existente usando o recurso de engenharia reversa de banco de dados do Spring Roo. Ainda há muitos recursos, como JMS, Solr e suporte a JSON, etc. que o Roo pode incluir facilmente no seu aplicativo.

Na Parte 3 desta série, falarei sobre como podemos transferir o aplicativo de conferência para um Google App Engine.


Download

DescriçãoNomeTamanho
Part 2 source codeos-springroo2-sample_code.zip11KB

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=778690
ArticleTitle=Apresentando Spring Roo, Parte 2: Desenvolvendo um aplicativo com Spring Roo
publish-date=11282011