Parte 3 - Iniciando no JBoss Seam

Este blog deixou de ser mantido, mas o autor continua escrevendo aqui. Não deixe de assinar o novo feed!

Finalmente chegamos à última parte do tutorial e vamos fazer o Seam funcionar! É só ter fé e seguir todos os passos direitinho. Pronto para continuar? Então… vamos lá!

Adicionando as bibliotecas do Seam

Se você criou uma Library com os arquivos do Seam, como mostrado na primeira parte do tutorial, então adicioná-las no nosso projeto é bem simples. Clique com o botão direito sobre o projeto Registration-ejb e vá em Properties. Selecione a opção Libraries e adicione a Library Seam, como mostra a imagem:

seam_06.png

Faça o mesmo com o projeto Registration-war. Isso é necessário para que possamos utilizar a taglib do Seam.

Configurando o projeto web

Vamos começar as modificações no arquivo web.xml, adicionando um parâmetro de contexto e adicionando o listener do Seam, respectivamente:

seam_14.png

seam_15.png

Muita atenção para digitar esses dados conforme mostram as imagems! Aqui vão algumas informações para você entender o que está acontecendo:

  1. Quando o Seam for pesquisar por nossos EJBs via JNDI, ele precisa saber os nomes aos quais esses componentes estão ligados para poder obtê-los. Então, este parâmetro indica uma forma padrão - uma nomenclatura - para que o Seam possa montar o nome dos componentes antes de requisitá-los ao serviço de nomes. Então, se existisse um Bean chamado CalcularCredito, então o Seam iria pesquisar pelo nome “Registration/CalcularCredito/local” no serviço de nomes e, caso o Bean esteja registrado certinho, então uma referência local ao bean CalcularCredito é obtida.
  2. Este Listener serve para que o Seam seja carregado durante o startup da aplicação web, sendo também necessário para controlar o ciclo de vida e gerenciar os contextos de sessão e aplicação.

Vamos agora adicionar o PhaseListener do Seam no arquivo faces-config.xml, para permitir que o Seam se integre ao ciclo de vida da nossa aplicação JSF:

  1.  
  2. <?xml version=‘1.0′ encoding=‘UTF-8′?>
  3.  
  4. <faces-config>
  5.    <lifecycle>
  6.       <phase-listener>org.jboss.seam.jsf.SeamPhaseListener</phase-listener>
  7.    </lifecycle>
  8.  
  9.    <application>
  10.       …
  11.  

Note que a listagem só mostra um trecho do faces-config.xml, sendo que o resto deve ser mantido como está!

Configurando o projeto ejb

O Seam precisa que seja criado um arquivo chamado seam.properties… mesmo que este arquivo não tenha conteúdo nenhum! Sim, eu sei que isto é muito estranho, mas, fazer o quê?! Então, vamos criar o arquivo, no diretório /src/conf/:

seam_17.png

Não precisa colocar nada dentro do arquivo seam.properties. Bem, colocamos este arquivo dentro do diretório /src/conf por este diretório agrupar outros arquivos de configuração, como a configuração dos EJBs e da API de persistência.

Então você deve estar se perguntando: “Mas… então, qual é o lugar certo deste arquivo?”. A resposta é: “Na raíz do JAR!”. Vamos então criar uma task do Ant para copiar este arquivo para a raiz antes de efetuar o empacotamento da aplicação.

Abra o arquivo build.xml, através da guia Files. Cole a seguinte task no final deste arquivo:

  1.  
  2. <project>
  3.    …
  4.    <target name="-pre-compile">
  5.       <copy file="${meta.inf}/seam.properties" todir="${build.dir}/ear-module" />
  6.    </target>
  7. </project>
  8.  

Finalizando as configurações do Seam no projeto Registration-ejb, vamos criar um novo arquivo-padrão de Deployment e configurar o interceptor do Seam para que este possa, erhm, interceptar as chamadas aos nossos EJBs para tratar da “bijeção” de atributos de e para o contexto:

seam_19.png

Depois de criado o arquivo ejb-jar.xml, o edite para que fique de acordo com a imagem abaixo:

  1.  
  2. <?xml version="1.0" encoding="UTF-8" ?>
  3.  
  4. <ejb-jar>
  5.  
  6.    <assembly-descriptor>
  7.       <interceptor-binding>
  8.          <ejb-name>*</ejb-name>
  9.          <interceptor-class>
  10.             org.jboss.seam.ejb.SeamInterceptor
  11.          </interceptor-class>
  12.       </interceptor-binding>
  13.    </assembly-descriptor>
  14.  

* para conhecer melhor os conceitos do Seam, como “bijeção”, vale uma olhada na documentação do projeto Seam.

Modificando a aplicação

A primeira - e mais significativa - mudança é a seguinte: iremos remover o managed bean User e mapear as variáveis do contexto JSF diretamente a um Entity Bean! Então, você está livre para ir até ao arquivo faces-config.xml e remover o nosso Managed Bean.

Já no projeto Registration-ejb, renomeie o pacote mbean para bean. Vá até o pacote bean, na guia Projects, e o arraste, do projeto Registration-war, para o projeto Registration-ejb.

Criando um Entity Bean

Chegou a hora de fazermos um upgrade no nosso ex-ManagedBean e promovê-lo a Entity Bean! Oh, meu Deus! Este deve ser um momento glorioso na vida da classe User :D

Modifique a classe User de acordo com a listagem:

  1.  
  2. // …
  3. @Name("user")
  4. @Scope(ScopeType.EVENT)
  5.  
  6. @Entity
  7. @Table(name="users")
  8. @NamedQuery(name="users.findByUsername",
  9.    query="SELECT u FROM User u WHERE u.username = :username")
  10. public class User implements Serializable {
  11.  
  12.    @Id
  13.    @Column(length=20, nullable=false)
  14.    @NotNull @Length(min=5, max=20)
  15.    private String username;
  16.  
  17.    @Column(length=20, nullable=false)
  18.    @NotNull @Length(min=5, max=20)
  19.    private String password;
  20.  
  21.    @Column(length=150)
  22.    @Length(max=150)
  23.    private String name;
  24.  
  25.    // …
  26. }
  27.  

Algumas coisas merecem ser explicadas. Oh, a primeira: não implementei aqui os métodos equals(), hashCode() e toString() pelo fato de o exemplo funcionar perfeitamente sem esses métodos, embora eles DEVAM ser implementados em um Bean de uma aplicação real! Ah, e o resto do código do Bean User continua do jeito que estava antes.

Agora, deixe-me explicar algumas coisas coisas. As anotações @Entity, @Table, @NamedQuery, @Id e @Column fazem parte da especificação JPA e, portanto, estão fora do escopo deste tutorial. Agora, as anotações @Name, @Scope, @NotNull e @Length:

  • @Name - É utilizada pelo Seam para registrar um componente sob um determinado nome único na aplicação. É através desse nome que o Seam faz a localização dos componentes;
  • @Scope - É utilizada pelo Seam para determinar o escopo de um componente. Caso esta anotação não esteja presente, o Seam atribui um escopo ao componente de acordo com o seu tipo. Por exemplo, Session Beans Stateless são associados ao escopo Stateless. Session Beans Stateful são associados ao escopo Conversation. Mais detalhes sobe a atribuição de escopos-padrão aos componentes e sobre os tipos de escopo disponíveis no Seam, leia a documentação;
  • @NotNull - O Seam integra facilmente com o Hibernate Validator e esta anotação serve para validar um determinado atributo, não permitindo que este seja nulo. Caso algum problema de validação seja detectado, podemos fazer com que o Seam mostre novamente o formulário para que os dados sejam re-digitados pelo usuário;
  • @Length - Assim como @NotNull, mas permite que façamos uma validação de comprimento, onde, nos exemplos, só permitimos que a requisição seja aceita caso os atributos username e password tenham tamanhos entre 5 e 20 caracteres.

Configurando o Persistence Unit

Ok… vamos prosseguir com a modificação da nossa aplicação. Você notou que o NetBeans sublinhou a anotação @Entity? O que ele quer dizer é que nós não criamos nenhuma unidade de persistência na nossa aplicação:

seam_22.png

Provavelmente você ainda não vai ter o Data Source criado e configurado, portanto, no combo Data Source, selecione a opção New Data Source. Na janela que aparecer, basta configurar uma conexão com um banco de dados e dar um nome para o Data Source:

seam_24.png

No meu caso, eu criei uma base chamada test no meu servidor MySQL e dei o nome “db_registration” para o Data Source. Confirme a criação do Data Source e conclua também a criação da unidade de persistência:

seam_25.png

Ainda precisamos fazer uma mudança no arquivo persistence.xml para que ele funcione corretamente no JBoss. Troque o nome do Data Source de “db_registration” para “java:/db_registration”. Também devemos informar o dialeto do banco de dados:

  1.  
  2. <?xml version=‘1.0′ encoding=‘UTF-8′?>
  3. <persistence>
  4.    <persistence-unit name="default" transaction-type="JTA">
  5.       <provider>org.hibernate.ejb.HibernatePersistence</provider>
  6.       <jta-data-source>java:/db_registration</jta-data-source>
  7.       <properties>
  8.          <property name="hibernate.hbm2ddl.auto" value="update" />
  9.          <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLInnoDBDialect" />
  10.       </properties>
  11.    </persistence-unit>
  12. </persistence>
  13.  

Ufa! Configuramos a parte de persistência da aplicação. Ahhhh claro: não esqueça de copiar o seu driver JDBC para o diretório lib do seu JBoss! Senão, durante o startup do Hibernate, ele não conseguirá localizar o driver JDBC e te mostrará um belo de um erro! :P

Criando um Stateless Session Bean

Vamos agora criar um Session Bean do tipo Stateless para tratar os eventos de submissão do formulário de cadastro. Clique com o botão direito do mouse no projeto Registration-ejb e selecione a opção New-Session Bean…. Dê o nome RegisterUser ao Session Bean. AH, crie-o no pacote business:

seam_27.png

Modifique a interface RegisterUserLocal:

  1.  
  2. package business;
  3.  
  4. import javax.ejb.Local;
  5.  
  6. @Local
  7. public interface RegisterUserLocal {
  8.    String register();
  9. }
  10.  

Modifique também a implementação da interface:

  1.  
  2. // …
  3. @Name("registerUser")
  4. @Stateless
  5. public class RegisterUserBean implements RegisterUserLocal {
  6.  
  7.    @PersistenceContext
  8.    private EntityManager em;
  9.  
  10.    @In
  11.    private User user;
  12.  
  13.    public String register() {
  14.  
  15.       List l = em.createNamedQuer("users.findByUsername")
  16.          .setParameter("username", user.getUsername()).getResultList();
  17.  
  18.       if (l.size() == 0) {
  19.          em.persist(user);
  20.          return "registered";
  21.       }
  22.  
  23.       FacesMessages.instance().add("User #{user.username} already exists.");
  24.       return null;
  25.    }
  26. }
  27.  

Finalmente… integrando o JSF ao EJB!

Ok!! Tenha calma, pois falta muito pouco! Para finalizar, volte até o arquivo welcomeJSF.jsp e modifique a tag para chamar o método register() do componente “registerUser”. Para que possamos mostrar as mensagens de validação do Hibernate Validator, utilize também a tag validateAll:

  1.  
  2. <%@page contentType="text/html" %>
  3. <%@page pageEncoding="UTF-8" %>
  4.  
  5. <%@taglib prefix="f" uri="http://java.sun.com/jsf/core" %>
  6. <%@taglib prefix="h" uri="http://java.sun.com/jsf/html" %>
  7. <%@taglib prefix="s" uri="http://jboss.com/products/seam/taglib" %>
  8.  
  9. <f:view>
  10. <f:loadBundle basename="bundle.messages" var="msg" />
  11. <html>
  12.    <head>
  13.       <title><h:outputText value="#{msg.register_title}" /></title>
  14.    </head>
  15.    <body>
  16.       <h:form>
  17.          <s:validateAll>
  18.             <h1><h:outputText value="#{msg.register_message}" /></h1>
  19.             <h:panelGrid columns="2">
  20.                <h:outputLabel for="username" value="#{msg.register_label_username}" />
  21.                <h:inputText id="username" value="#{user.username}" required="true" />
  22.  
  23.                <h:outputLabel for="password" value="#{msg.register_label_password}" />
  24.                <h:inputSecret id="password" value="#{user.password}" required="true" />
  25.  
  26.                <h:outputLabel for="name" value="#{msg.register_label_name}" />
  27.                <h:inputText id="name" value="#{user.name}" />
  28.  
  29.                <h:commandButton id="submit" value="#{msg.register_label_submit}"
  30. ction="#{registerUser.register}" />
  31.             </h:panelGrid>
  32.          </s:validateAll>
  33.       </h:form>
  34.    </body>
  35. </html>
  36. </f:view>
  37.  

É isso! Rode sua aplicação e veja o Seam ligando os nossos EJBs com as páginas JSF! :D

Conclusão

Você deve estar traumatizado com a quantidade de configuração necessária.. mas pare um pouco para pensar: todas as configurações que fizemos não são do tipo que aumentam conforme a aplicação vai crescendo, ou seja, provavelmente você poderá ter dezenas de EJBs interagindo com diversas páginas JSF e tabelas do banco de dados sem ter que acrescentar nenhuma linha à configuração já criada. Isso é uma bênção em aplicações de médio a grande porte.

E então? Você gostou deste tutorial? Ou achou o mesmo um belo pé-no-saco? Ele funcionou com você? Ou só deu problemas? Comente!

* Créditos ao tutorial Trying out JBoss’Seam, de Brian Leonard, que deu uma força para que eu conseguisse montar este tutorial!

UPDATE: Não deixe de conferir as partes um e dois do tutorial!

Tags: , , , , ,
4 de novembro de 2006 | programação