Criando a classe de entidade

Neste exercício, você criará a classe de entidades NewsEntity. Uma classe de entidade é uma classe Java simples que geralmente representa uma tabela em um banco de dados. Quando você cria a classe de entidade, o IDE adiciona a anotação @Entity para definir a classe como uma classe de entidade. Depois de criar a classe, você criará campos na classe para representar os dados que deseja incluir na tabela.

Cada classe de entidade deve ter uma chave primária. Quando você cria a classe de entidade, o IDE adiciona a anotação @Id para declarar o campo a ser usado como chave primária. O IDE também adiciona a anotação @GeneratedValue e especifica a estratégia de geração de chave para o Id primário.

Para criar a classe NewsEntity, execute as seguintes etapas.

1. Clique com o botão direito do mouse no módulo EJB na janela Projetos e escolha Novo > Outro para abrir o assistente para Novo arquivo.
2. Na categoria Persistência, selecione Classe de entidade e clique em Próximo.
3. Digite NewsEntity para Nome da classe.
4. Digite ejb para Pacote.
5. Deixe Tipo de chave primário como Longo no assistente Nova classe de entidade.
6. Selecione Criar unidade de persistência. Clique em Próximo.
7. Preserve o nome da unidade de persistência padrão.
8. Para o Provedor de persistência, escolha EclipseLink (JPA2.0)(default).
9. Em Fonte de dados, escolha uma fonte de dados (por exemplo, selecione jdbc/sample se quiser usar JavaDB).
10. Confirme que a unidade de persistência está utilizando o Java Transaction API e que a tabela Estratégia de geração é definida para criar, de forma que as tabelas com base nas suas entidades de classe são criadas quando o aplicativo é implantado.
    
11. Clique em Terminar.

Ao clicar em Terminar, o IDE cria persistence.xml e a classe de entidade NewsEntity.java O IDE abre NewsEntity.java no Editor de código-fonte.

No Editor de código-fonte, realize as etapas seguintes.

1. Adicione as seguintes declarações de campo à classe:

   private String title;
   private String body;

2. Clique com o botão direito do mouse no Editor de código-fonte e escolha Inserir código Alt-Insert; Ctrl-I no Mac) e selecione Getter e Setter para abrir a caixa de diálogo Gerar getters e setters.
3. Selecione os campos body e title na caixa de diálogo. Clique em Gerar.
   

   Quando você clica em Gerar, o IDE adiciona os métodos getter e setter nos campos.

4. Salve as alterações em NewsEntity.java.

Você pode fechar NewsEntity.java.

Para saber mais sobre classes de entidade, consulte o capítulo Introdução a API de Persistência Java no Tutorial do Java EE 6 , Volume I.

Criando o bean controlado por mensagem

Neste exercício, você usará um assistente para criar o Bean controlado por mensagem no módulo EJB. O assistente também ajudará você a criar os recursos JMS necessários. O Bean controlado por mensagem recebe e processa mensagens enviadas para a fila por um servlet no módulo Web.

Para criar o Bean controlado por mensagem, execute as seguintes etapas:

1. Clique com o botão direito do mouse no módulo EJB na janela Projetos e selecione Novo > Outro para abrir o assistente Novo arquivo.
2. Na categoria JavaBens Corporativo selecione o tipo de arquivo Bean controlado por mensagem. Clique em Próximo.

   Observação: No NetBeans IDE 6.9, o tipo de arquivo Bean controlado por mensagem está na categoria Java EE.

3. Digite NewMessage para Nome EJB.
4. Selecione ejb na lista suspensa Pacote.
5. Clique no botão Adicionar ao lado do campo Destino do projeto para abrir a caixa de diálogo Adicionar destino da mensagem.
6. Na caixa de diálogo Adicionar destino da mensagem, digite jms/NewMessage e selecione Fila como o tipo de destino. Clique em OK.
7. Certifique-se de que o destino do projeto esteja correto. Clique em Terminar.

Ao clicar em Terminar, a classe NewMessage.java do Bean se abrirá no Editor de código-fonte. Você pode ver que o IDE adiciona a anotação @MessageDriven e as propriedades de configuração à classe.

       
@MessageDriven(mappedName = "jms/NewMessage", activationConfig =  {
        @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
        @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
    })
public class NewMessage implements MessageListener {

A anotação @MessageDriven informa o contêiner que o componente é um Bean controlado por mensagem e especifica o recurso JMS usado pelo Bean. Quando o IDE gera a classe, o Nome mapeado do recurso (jms/NewMessage) é derivado do nome da classe (NewMessage.java). O recurso JMS é mapeado para o nome JNDI do destino do qual o Bean recebe mensagens. O assistente para Novo Bean controlado por também adiciona as informações dos recursos JMS ao sun-resources.xml. Não é necessário configurar os descritores de deployment para especificar os recursos JMS. Se usar a ação Executar no IDE para implantar o aplicativo no GlassFish, os recursos JMS serão criados no servidor no deployment.

As especificações do EJB permitem que você use anotações para introduzir recursos diretamente em uma classe. Agora você usará anotações para introduzir o recurso MessageDrivenContext em sua classe e, em seguida, injetar o recurso PersistenceContext, que será usado pela API do gerenciador de entidades para gerenciar as instâncias de entidade persistentes. Você adicionará as anotações à classe no Editor de código-fonte.

1. Injetamos o recurso MessageDrivenContext na classe adicionando o seguinte campo anotado (em negrito) à classe:

   public class NewMessage implements MessageListener {
   
   @Resource
   private MessageDrivenContext mdc;

2. Introduza o gerenciador de entidades clicando com o botão direito do mouse no código e escolhendo Inserir código (Alt-Insert; Ctrl-I no Mac), e escolhendo Usar gerenciador de entidades no menu pop-up.

   Observação: No NetBeans IDE 6.9, escolha Persistência > Usar Gerenciador de entidade.

   O IDE adiciona a seguinte anotação @PersistenceContext ao seu código-fonte.

   @PersistenceContext(unitName = "NewsApp-ejbPU")
   private EntityManager em;

   O IDE também gera o seguinte método persist.

   public void persist(Object object) {
       em.persist(object);
   }

3. Modifique o método persist para alterar o nome para save. O método deve ter uma aparência semelhante a esta:

   public void save(Object object) {     
       em.persist(object);
   }

4. Modifique o método onMessage adicionando o seguinte código (em negrito) ao corpo do método.

   public void onMessage(Message message) {
       ObjectMessage msg = null;        
       try {
           if (message instanceof ObjectMessage) {
               msg = (ObjectMessage) message;
               NewsEntity e = (NewsEntity) msg.getObject();
               save(e);            
           }
       } catch (JMSException e) {
           e.printStackTrace();
           mdc.setRollbackOnly();
       } catch (Throwable te) {
           te.printStackTrace();
        }
   }

5. Clique com o botão direito do mouse no editor e escolha Corrigir importações (Alt-Shift-I; ⌘-Shift-I no Mac) para gerar quaisquer declarações de importação necessárias. Salve as alterações.

Observação: Quando geramos as instruções de importação, queremos garantir a importação das bibliotecas javax.jms e javax.annotation.Resource.

Para obter mais detalhes sobre beans controlados por mensagem, consulte o capítulo O que é um Bean controlado por mensagem? no Tutorial do Java EE 6 , Parte I.

Criando a fachada da sessão

Neste exercício, você criará uma fachada de sessão para a classe de entidade NewsEntity. A especificação EJB 3.0 simplificou a criação de Beans de sessão reduzindo a quantidade de códigos necessária e permitindo o uso de anotações para declarar uma classe como um Bean de sessão. A especificação EJB 3.1 simplifica também os requisitos dos Beans de sessão ao tornar opcionais as interfaces corporativas. Os Beans de sessão podem ser acessados por clientes locais através de uma interface local ou de uma exibição sem interface. Neste tutorial, você não criará uma interface para o Bean. Os servlets da aplicação Web acessarão o Bean através de uma exibição sem interface.

Para criar a fachada de sessão, execute as seguintes etapas:

1. Clique com o botão direito do mouse no módulo EJB e escolha Novo > Outro.
2. Na categoria Persistência, selecione Beans de sessão em Classes de entidade. Clique em Próximo.
3. Selecione ejb.NewsEntity na lista de classes de entidades disponíveis e clique em Adicionar para mover a classe para o painel Classes de entidades selecionadas. Clique em Próximo.
4. Verifique se o Pacote está definido como ejb. Clique em Concluir.

Quando você clica em Terminar, o IDE gera a classe de fachada da sessão NewsEntityFacade.java e AbstractFacade.java, e abre os arquivos no editor. Como pode-se ver no código gerado, a anotação @Stateless é usada para declarar a classe NewsEntityFacade.java como um componente de bean de sessão sem estado. O IDE também adiciona a anotação PersistenceContext para introduzir o recurso diretamente no componente do Bean de sessão. NewsEntityFacade.java estende AbstractFacade.java, que contém a lógica de negócio e gerencia a transação.

Observação. As interfaces remotas ainda são necessárias se os Beans forem acessados pelos clientes remotos.

Para obter mais informações sobre Beans de sessão, consulte o capítulo O que é um Bean de sessão no Tutorial do Java EE 6 , Volume I.

Criando o Bean de sessão simples

A especificação EJB 3.1 introduz a anotação @Singleton que permite criar facilmente Beans de sessão simples. O EJB 3.1 também define anotações adicionais para a configuração de propriedades de Beans de sessão simples como quando o Bean é iniciado.

Depois que o Bean de sessão simples é iniciado, ele existirá durante o ciclo de vida do aplicativo. Como o seu próprio nome diz, pode haver somente uma única instância de um Bean de sessão simples no aplicativo. Como os Beans de sessão sem estado, os Beans de sessão simples podem ter vários clientes.

Para criar o Bean da sessão simples, execute as seguintes etapas.

1. Clique com o botão direito do mouse do módulo Web e escolha Novo > Outro para abrir o assistente para Novo arquivo.
2. Selecione o Bean de sessão na categoria JavaBeans Enterprise.

   Observação: No NetBeans IDE 6.9, o Bean de sessão está na categoria Java EE.

3. Digite SessionManagerBean para Nome EJB.
4. Digite ejb para o nome do Pacote.
5. Selecione Simples. Clique em Concluir.

Quando você clica em Terminar, o IDE gera a classe do Bean de sessão simples e abre a classe no Editor. Você pode ver que o IDE adicionou a anotação @Singleton à classe para declarar um Bean de sessão simples. O assistente também anotou a classe com @LocalBean.

@Singleton
@LocalBean
public class SessionManagerBean {

}

1. Anote a classe com @WebListener e implemente HttpSessionListener.

   @Singleton
   @LocalBean
   @WebListener
   public class SessionManagerBean implements HttpSessionListener{
   
   }

   A anotação @WebListener é parte da API do Servlet 3.0 e permite implementar um listener diretamente no seu código.

   Quando você implementa HttpSessionListener, o IDE exibe um aviso na margem.

2. Clique no ícone de aviso na margem esquerda e escolha "Implementar todos os métodos abstratos".
   

   O IDE adiciona os métodos sessionCreated e sessionDestroyed.

3. Adicione o campo estático counter e defina o valor inicial como 0.

   @LocalBean
   @WebListener
   public class SessionManagerBean implements HttpSessionListener{
       private static int counter = 0;

4. Modifique os corpos gerados dos métodos sessionCreated e sessionDestroyed para aumentar o valor de um campo quando uma nova sessão se iniciar e para diminuir o valor quando a sessão terminar. O valor será armazenado no campo counter.

   public void sessionCreated(HttpSessionEvent se) {
       counter++;
   }
   
   public void sessionDestroyed(HttpSessionEvent se) {
       counter--;
   }

5. Adicione o método seguinte que retorna o valor atual de counter.

   public int getActiveSessionsCount() {
           return counter;
       }

   Você chamará este método de um servlet para exibir o número total de usuários/sessões abertas.

6. Salve as alterações.

O código a seguir do Bean de sessão deve ter agora a seguinte aparência.

@Singleton
@LocalBean
@WebListener
public class SessionManagerBean implements HttpSessionListener {
    private static int counter = 0;

    public void sessionCreated(HttpSessionEvent se) {
        counter++;
    }

    public void sessionDestroyed(HttpSessionEvent se) {
        counter--;
    }

    public int getActiveSessionsCount() {
        return counter;
    }

}

Para obter mais detalhes sobre Beans de sessão simples, consulte o capítulo O que é um Bean de sessão? no Tutorial do Java EE 6 , Volume I.

Criando o servlet ListNews

Neste exercício, você criará um servlet simples para exibir as mensagens armazenadas. Você usará anotações para chamar o Bean corporativo NewsEntityFacade do servlet.

1. Clique com o botão direito do mouse em um projeto de módulo e escolha Novo > Servlet.
2. Digite ListNews para o nome da classe.
3. Insira web como o nome do pacote. Clique em Terminar.

Ao clicar em Terminar, a classe persistence.xml irá se abrir no Editor de código-fonte. No Editor de código-fonte, realize as etapas seguintes.

1. Clique com o botão direito do mouse no editor de código-fonte, selecione Inserir (Alt-Insert; Ctrl-I no Mac) código e selecione Chamar bean corporativo.
2. Na caixa de diálogo Chamar bean corporativo, expanda o nó News-App-ejb e selecione NewEntityFacade. Clique em OK.

   O IDE adiciona a anotação @EJB para introduzir o Bean corporativo.

3. Use a caixa de diálogo Chamar Bean corporativo novamente para introduzir SessionManagerBean no nó NewsApp-war.

   Você verá no seu código as seguintes anotações que introduzem dois Beans corporativos.

   @WebServlet(name = "ListNews", urlPatterns = {"/ListNews"})
   public class ListNews extends HttpServlet {
   
       @EJB
       private SessionManagerBean sessionManagerBean;
       @EJB
       private NewsEntityFacade newsEntityFacade;
                   

   Também pode ver que a anotação @WebServlet é usada para declarar a classe de um servlet e especificar o nome do servlet. A anotação @WebServlet faz parte da API do Servlet 3.0 introduzida na especificação Java EE 6. Você pode identificar os servlets usando a anotação em vez de no descritor de deployment web.xml. O aplicativo NewsApp não contém web.xml.

4. No método processRequest, adicione o seguinte código (em negrito) para retornar a sessão atual ou criar uma nova sessão.

   protected void processRequest(HttpServletRequest request, HttpServletResponse response)
           throws ServletException, IOException {
           request.getSession(true);
           response.setContentType("text/html;charset=UTF-8");

5. Adicione o seguinte código (em negrito) ao método processRequest para imprimir as mensagens e adicionar um link ao servlet PostMessage. (Remova os comentários do código no método se necessário.)

   out.println("<h1>Servlet ListNews at " + request.getContextPath () + "</h1>");
   
   List news = newsEntityFacade.findAll();
   for (Iterator it = news.iterator(); it.hasNext();) {
       NewsEntity elem = (NewsEntity) it.next();
       out.println(" <b>"+elem.getTitle()+" </b><br />");
       out.println(elem.getBody()+"<br /> ");
   }
   out.println("<a href='PostMessage'>Add new message</a>");
   
   out.println("</body>");
                       

6. Adicione o código seguinte (em negrito) para recuperar e imprimir o número de usuários/sessões abertas.

   out.println("<a href='PostMessage'>Add new message</a>");
   
   out.println("<br><br>");
   out.println(sessionManagerBean.getActiveSessionsCount() + " user(s) reading the news.");
   
   out.println("</body>");
                       

7. Pressione Ctrl-Shift-I para gerar as instruções de importação necessárias para a classe. Ao gerar as instruções de importação, você deseja importar as bibliotecas java.util.
8. Salve as alterações feitas no arquivo.

Criando o servlet PostMessage

Neste exercício, você criará o servlet PostMessage que será usado para enviar mensagens. Usaremos anotações para injetar os recursos JMS que criamos diretamente no servlet, especificando o nome variável e o nome para o qual é mapeado. Em seguida, adicionaremos o código para enviar a mensagem JMS e o código para o formulário HTML para adicionar uma mensagem.

1. Clique com o botão direito do mouse em um projeto de módulo e escolha Novo > Servlet.
2. Digite PostMessage para Nome da classe.
3. Insira web para Nome do pacote e clique em Terminar.

Ao clicar em Terminar, a classe PostMessage.java se abrirá no Editor de código-fonte. No Editor de código-fonte, realize as etapas seguintes.

1. Use anotações para injetar os recursos ConnectionFactory e Queue adicionando as seguintes declarações de campo (em negrito):

   @WebServlet(name="PostMessage", urlPatterns={"/PostMessage"})
   public class PostMessage extends HttpServlet {                
       @Resource(mappedName="jms/NewMessageFactory")
       private  ConnectionFactory connectionFactory;
   
       @Resource(mappedName="jms/NewMessage")
       private  Queue queue;

2. Agora você insere o código para enviar mensagens JMS adicionando ao método o seguinte código em negrito processRequest:

   response.setContentType("text/html;charset=UTF-8");
   
   // Add the following code to send the JMS message
   String title=request.getParameter("title");
   String body=request.getParameter("body");
   if ((title!=null) && (body!=null)) {
       try {
           Connection connection = connectionFactory.createConnection();
           Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
           MessageProducer messageProducer = session.createProducer(queue);
   
           ObjectMessage message = session.createObjectMessage();
           // here we create NewsEntity, that will be sent in JMS message
           NewsEntity e = new NewsEntity();
           e.setTitle(title);
           e.setBody(body);
   
           message.setObject(e);                
           messageProducer.send(message);
           messageProducer.close();
           connection.close();
           response.sendRedirect("ListNews");
   
       } catch (JMSException ex) {
           ex.printStackTrace();
       }
   }
                           
   PrintWriter out = response.getWriter();
                       

3. Adicione as linhas a seguir (em negrito) ao método processRequest para adicionar o formulário web de adição de mensagens. (Remova o comentário para imprimir o HTML se necessário.)

   out.println("Servlet PostMessage at " + request.getContextPath() + "</h1>");
   
   // The following code adds the form to the web page
   out.println("<form>");
   out.println("Title: <input type='text' name='title'><br/>");
   out.println("Message: <textarea name='body'></textarea><br/>");
   out.println("<input type='submit'><br/>");
   out.println("</form>");
   
   out.println("</body>");
                   

4. Pressione Ctrl-Shift-I para gerar as instruções de importação necessárias para a classe.

   Observação: Ao selecionar bibliotecas para importação para Connection, ConnectionFactory, Session eQueue, certifique-se de importar as bibliotecas javax.jms.

   
5. Salve as alterações feitas no arquivo.

Problema com os recursos JMS

Ao usar o assistente para criar recursos JMS, você poderá ver a seguinte mensagem de erro do servidor na janela de saída:

[com.sun.enterprise.connectors.ConnectorRuntimeException:
                    recurso JMS não criado : jms/Queue]
                

Esta mensagem pode indicar que o recurso JMS não foi criado ou não foi registrado com o servidor da aplicação. Você pode usar o console de administração do servidor da aplicação para verificar, criar e editar recursos JMS.

Para abrir o console de administração, faça o seguinte:

1. Confirme que o servidor do aplicativo está em execução, expandindo o nó Servidores na janela Serviços do IDE. Uma pequena seta verde ao lado do nó do servidor da aplicação indica que o servidor está em execução.
2. Clique com o botão direito do mouse no nó do servidor da aplicação e escolha Exibir console de administração para abrir a janela de logon no navegador.
3. Faça logon no servidor. O nome de usuário e a senha padrão são admin e adminadmin.
4. No console de administração no navegador, expanda o nó Recursos e o nó Recursos JMS no quadro à esquerda.
5. Clique nos links Fábricas de conexão e Recursos de destino no quadro à esquerda para verificar se os recursos estão registrados com o servidor e, se necessário, modificar os recursos. Se os recursos não existirem, crie-os no console de administração.

Certifique-se de que o recurso de fábrica de conexão JMS no servlet PostMessage esteja mapeado para o nome JNDI correto do recurso de fábrica de conexão JMS registrado com o servido da aplicação Sun Java System.

Os seguintes recursos devem estar registrados com o servidor da aplicação Sun Java System:

• um recurso de destino com o nome JNDI jms/NewMessage e digite javax.jms.Queue
• um recurso de Fábrica de conexão com o nome JNDI jms/NewMessageFactory e digite javax.jms.QueueConnectionFactory