Primeiros passos com JSF 2.0, Injeção de dependência e contextos

Contribuição de Andy Gibson, mantido por Troy Giunipero

A injeção de dependência e contextos (CDI), especificada por JSR-299, é uma parte integral do Java EE 6 e fornece uma arquitetura que permite que os componentes Java EE, como servlets, enterprise beans e JavaBeans, existam dentro do ciclo de vida de um aplicativo com escopos bem definidos. Além disso, os serviços CDI permitem que os componentes Java EE, tais como beans de sessão EJB e beans gerenciados do JavaServer Faces (JSF), sejam injetados e interajam de uma maneira acoplada flexível com a queima e a observação de eventos.

Este tutorial tem base no blog fornecido por Andy Gibson, intitulado Primeiros passos com JSF 2.0 e CDI no JEE 6. Ele demonstra como utilizar o IDE para configurar um projeto web Java com suporte para JSF 2.0 e o CDI. Ele prossegue mostrando como conectar beans gerenciados CDI com as páginas Facelets e conclui com um breve exemplo da integração CDI com a tecnologia EJB.

O NetBeans IDE fornece suporte embutido para a Injeção de dependência e contextos, incluindo a opção de geração do arquivo de configuração CDI beans.xml no momento da criação do projeto, suporte ao editor e à navegação para anotações, assim como vários assistentes para a criação de artefatos CDI comumente usados.

• O conjunto NetBeans IDE Java também inclui o servidor GlassFish edição de código-fonte aberto 3.x, que é um recipiente compatível com o Java EE 6.
• O suporte para CDI também está disponível para o NetBeans 6.8 através do Patch 1.

Criação do Projeto Web Java com o suporte CDI

Neste exercício será criado um projeto web Java JSF 2.0 ativado com o suporte CDI.

1. Clique no botão Novo projeto ( ) na barra de ferramentas principal do IDE (Ctrl-Shift-N; ⌘-Shift-N no Mac).
2. No assistente Novo projeto, selecione a categoria Java Web e, em seguida, selecione Aplicativo da Web. Clique em Próximo.
3. Digite cdiDemo como o nome do projeto e defina a localização do projeto. Clique em Próximo.
4. Defina o servidor como GlassFish 3.x e a versão do Java EE para Java EE 6 Web. Confirme se a opção "Ativar a injeção de dependência e contextos" está selecionada.
   
   A opção "Habilitar injeção de dependência e contextos", quando selecionada, gera um arquivo beans.xml na pasta do projetoWEB-INF quando o modelo do projeto é criado. O arquivo beans.xml é utilizado pelo CDI para instruir o servidor compatível Java EE que o projeto é um módulo contendo beans CDI.
5. Clique em Próximo.
6. No painel Frameworks, selecione a opção JavaServer Faces.
7. Clique na aba Configuração e confirme se Facelets está selecionada como a Linguagem de página preferida. Clique em Terminar.

   Ao clicar em Terminar, o IDE gera o projeto de aplicação Web e abre a página do arquivo de boas vindas index.xhtml no editor.

8. Na janela Projetos, expanda os nós da pasta Páginas da Web > WEB-INF e observe que o arquivo beans.xml é exibido. Esse arquivo está atualmente vazio, mas pode ser utilizado para especificar uma informação do bean relacionado no XML como alternativa para anotações.
   

   Se você expandir o nó Bibliotecas > GlassFish Server, poderá ver que a biblioteca weld-osgi-bundle.jar foi automaticamente adicionada. O GlassFish Sever inclui o Weld, que é uma implementação JBoss da especificação JSR-299 CDI.

Acessando o Beans a partir da linguagem de expressão JSF

Este exercício demonstra como conectar o beans gerenciado CDI às páginas Facelets utilizando a sintaxe EL.

1. Na janela Projetos, clique com o botão direito do mouse no nó Pacotes de código-fonte e selecione Novo > Classe Java.
2. No assistente Nova classe Java, nomeie a classe como MessageServerBean e digite no exercício1 como o Pacote. (O novo pacote é criado após a conclusão do assistente.)
   
3. Clique em Terminar. O novo pacote e a nova classe são gerados e a classe é aberta no editor.
4. Anote a classe com a anotação javax.inject.Named e crie um método simples para retornar uma string.

   package exercise1;
   
   import javax.inject.Named;
   
   @Named
   public class MessageServerBean {
   
       public String getMessage() {
           return "Hello World!";
       }
   }

   Ao digitar a anotação @Named, pressione Ctrl-Espaço para chamar o suporte da conclusão do código do editor, assim como uma documentação Javadoc. Se aplicar uma anotação utilizando as facilidades de conclusão do código (ex., selecionar a anotação apropriada e pressionar Enter), a declaração importar será automaticamente adicionada ao arquivo.
   
   No pop-up Javodoc, também é possível clicar no botão "Mostrar documentação no navegador externo ( ) para exibir o Javadoc em tamanho real em uma janela separada.
5. Salve o arquivo (Ctrl-S; ⌘-S on Mac). Com a adição da anotação @Named, a classe MessageServerBean se torna um bean gerenciado, como definido pelo CDI.
6. Alterne a página Facelets index.xhtml (pressione Crtl-Tab) no editor e adicione o conteúdo seguinte às marcações <h:body>.

   <h:body>
       Hello from Facelets
       <br/>
       Message is: #{messageServerBean.message}
       <br/>
       Message Server Bean is: #{messageServerBean}
   </h:body>

   É possível pressionar Ctrl-Espaço nas expressões EL para obter benefícios das sugestões do autocompletar de código. O autocompletar de código do editor lista os beans gerenciados e suas propriedades. Como a anotação @Named transforma a classe MessageServerBean em um bean gerenciado CDI, ela se torna acessível dentro da sintaxe EL, como se fosse um bean gerenciado JSF.
   
7. Clique no botão Executar projeto ( ) na barra de ferramentas principal do IDE. Quando o projeto é compilado e implantado para o GlassFish a página de boas vindas do aplicativo (index.xhtml) é aberta no navegador. É possível ver a mensagem "Olá Mundo!" mensagem do MessageServerBean é exibida na página.
   
8. Volte para o bean da mensagem e altere a mensagem para algo diferente (ex., "Olá Weld!"). Salve o arquivo (Ctrl-S;⌘-S no Mac) e, em seguida, atualize o navegador. A nova mensagem aparece automaticamente. Graças à implantação do IDE no recurso Salvar, quaisquer alterações salvas resultarão numa compilação automática e na reimplantação do servidor.
   
   A partir da terceira linha da página, é possível ver que o nome da classe é exercise1.MessageServerBean. Observe que o bean é só um POJO (Simples objeto Java antigo). Mesmo desenvolvendo no Java EE, não há hierarquia de classe complexa envolvida em camadas de operações, interceptores e todas as coisas "pesadas" que se costuma ouvir.

Atualizando para um EJB

Como estamos utilizando uma pilha Java EE, podemos facilmente implantar os beans como um EJB com algumas pequenas alterações, graças ao EJB 3.1.

1. Abra o MessageServerBean e adicione a anotação javax.ejb.Stateless no nível da classe e altere a sequência de caracteres para 'Hello EJB!'.

   package exercise1;
   
   import javax.ejb.Stateless;
   import javax.inject.Named;
   
   /**
    *
    * @author nbuser
    */
   @Named
   @Stateless
   public class MessageServerBean {
   
       public String getMessage() {
           return "Hello EJB!";
       }
   }

2. Salve o arquivo (Ctrl-S; ⌘-S no Mac), vá para o navegador e atualize-o. Um resultado similar ao seguinte será visto:
   
   De uma maneira impressionante, transformamos o POJO em um EJB com todos os recursos com somente uma anotação. Salvamos as alterações, atualizamos a página, e nossas alterações aparecem. Ao fazer isso não foi necessário criar nenhuma configuração estranha do projeto, interfaces locais ou descritores de implantação arcano.

Consulte também

O próximo artigo desta série foca na injeção CDI e fornece um olhar mais atento do uso do CDI para as dependências de gerenciamento em um ambiente Java EE 6.

• Trabalhando com qualificadores e injeção no CDI

Para mais informações sobre o CDI e o JSF 2.0, consulte os seguintes recursos.