Pré-requisitos

Este tutorial pressupõe que você tenha algum conhecimento básico das tecnologias a seguir, ou alguma experiência de programação com elas:

• Programação em Java
• NetBeans IDE

Software necessário para o tutorial

Para este tutorial, você precisa ter instalados no computador os seguintes softwares:

• NetBeans IDE 5.5 (download).
• Java Standard Development Kit (JDK), versão 5.0 ou 6.0 (download)
• Sun Java System Application Server Platform Edition 9 (download)

Para este tutorial, é necessário registrar uma instância local do servidor de aplicativos Sun Java System com o IDE.

Exercícios do tutorial

• Configurando o projeto de aplicativo empresarial
• Codificando o módulo EJB
• Codificando o módulo da Web
• Executando o projeto
• Solução de problemas

Criando um aplicativo empresarial

1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N) no menu principal.
2. Selecione Aplicativo empresarial na categoria Empresa e clique em Próximo.
3. Nomeie o projeto NewsApp e defina o servidor como servidor de aplicativos Sun Java System.
4. Defina a versão J2EE como Java EE 5, e selecione Criar módulo EJB e Criar módulo de aplicativo da Web, se não estiverem selecionados.
5. Clique em Finalizar.

Resumo

Neste exercício, criamos um aplicativo empresarial Java EE 5 que contém um módulo EJB e um módulo da Web.

Criando uma unidade de persistência

Primeiro criaremos uma unidade de persistência que define a fonte de dados e o gerenciador de entidades usados no aplicativo.

1. Clique com o botão direito do mouse no módulo EJB e escolha Novo > Arquivo/Pasta.
2. Na categoria Persistência, selecione Unidade de persistência e clique em Próximo.
3. Preserve o nome de unidade de persistência padrão.
4. Para o Provedor de persistência, escolha TopLink (default).
5. Para Fonte de dados, escolha a fonte de dados padrão jdbc/sample.
6. Verifique se a unidade de persistência está usando a API de transação de Java e se a Estratégia de geração de tabela está definida como Criar, de modo que as tabelas baseadas nas classes de entidade sejam criadas quando o aplicativo for implantado.
7. Clique em Finalizar.

Ao clicar em Finalizar, o IDE cria persistence.xml e o abre no Editor de fontes na exibição Design. Feche persistence.xml.

Criando as classes de entidade NewsEntity

Neste exercício, criaremos a classe de entidades NewsEntity. Uma classe de entidade é uma classe java simples. Quando você cria a classe de entidade, o IDE adiciona a anotação @Entity para definir a classe como uma classe de entidade. Após criarmos a classe, criaremos campos na classe para representar os dados que desejamos 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 @Generated para especificar a estratégia de geração de chave para o Id primário.

Para criar a classe NewsEntity, adote o seguinte procedimento:

1. Clique com o botão direito do mouse no módulo EJB na janela Projetos e escolha Novo > Arquivo/Pasta 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 o nome da classe, digite ejb para o pacote e deixe o Tipo de chave primária como Long. Clique em Finalizar.

Ao clicar em Finalizar, a classe de entidade NewsEntity.java irá se abrir no Editor de fontes. No Editor de fontes, adote este procedimento:

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

   String title;
   String body;

2. Clique com o botão direito do mouse no Editor de fontes e escolha Refatorar > Encapsular campos para gerar getters e setters para cada campo. Na caixa de diálogo Encapsular campos, certifique-se de que as caixas de seleção getter e setter estejam marcadas nos campos id, title e body.
3. Na caixa de diálogo Encapsular campos, clique em Próximo e, em seguida, clique em Fazer refatoração na guia Refatoração da janela Saída. O IDE adiciona os métodos getter e setter para os campos e altera a visibilidade dos campos para private.
4. Salve as alterações feitas no arquivo.

Na próxima etapa criaremos o Bean controlado por mensagem NewMessage.

Criando o Bean controlado por mensagem NewMessage

Agora criaremos o Bean controlado por mensagem NewMessage no módulo EJB. Usaremos o assistente para Novo Bean controlado por mensagem para criar o Bean e os recursos JMS necessários.

Para criar o Bean controlado por mensagem NewMessage, adote o seguinte procedimento:

1. Clique com o botão direito do mouse no módulo EJB na janela Projetos e escolha Novo > Arquivo/Pasta para abrir o assistente para Novo arquivo.
2. Na categoria Empresa, selecione Beans controlado por mensagem e clique em Próximo.
3. Digite NewMessage para o nome da classe.
4. Selecione ejb na lista suspensa Pacote.
5. Selecione Fila como o Tipo de destino e clique em Finalizar.

Ao clicar em Finalizar, a classe do novo Bean controlado por mensagem NewMessage.java irá se abrir no Editor de fontes. Você pode ver que a classe tem a seguinte anotação:

@MessageDriven(mappedName = "jms/NewMessage")

Esta anotação informa ao recipiente que o componente é um Bean controlado por mensagem e 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 mensagem já criou os recursos JMS para nós. A API do EJB 3.0 permite que pesquisemos objetos no espaço de nome JNDI a partir da classe do Bean, de maneira que não é necessário configurar descritores de implantação para especificar os recursos JMS.

As especificações do EJB 3.0 permitem que usemos anotações para introduzir recursos diretamente em uma classe. Agora usaremos anotações para introduzir o recurso MessageDrivenContext em nossa 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. Adicionaremos as anotações à classe no Editor de fontes.

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 selecionando Persistência > Usar gerenciador de entidades no menu pop-up.
   Isto adiciona a seguinte anotação ao código-fonte:

   @PersistenceContext
   private EntityManager em;

   e gera o seguinte método no código:

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

3. Modifique o método persist de modo que tenha esta aparência:

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

4. Modifique o método onMessage adicionando o seguinte ao corpo:

       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. Pressione Alt-Shift-F para gerar instruções de importação necessárias. Quando geramos instruções de importação, queremos garantir que importamos as bibliotecas jms e javax.annotation.Resource;.
6. Salve o arquivo.

Criando o Bean de sessão

Agora criamos uma fachada de sessão para a classe de entidade NewsEntity. Para criar uma fachada de sessão, adote o seguinte procedimento:

1. Clique com o botão direito do mouse no módulo EJB e escolha Novo > Arquivo/Pasta.
2. Na categoria Persistência, selecione Beans de sessão em Classe de entidade e clique em Próximo.
3. Na lista de classes de entidade disponíveis, selecione NewsEntity, clique em Adicionar e, em seguida, clique em Próximo.
4. Verifique se Pacote está definido como ejb e se uma interface de local será criada.
5. Clique em Finalizar.

Ao clicar em Finalizar, a classe de fachada de sessão NewsEntityFacade.java será criada e aberta no Editor de fontes. O IDE também cria a interface de local NewsEntityFacadeLocal.java.

A tecnologia EJB 3.0 simplifica a criação de Beans de sessão reduzindo a quantidade de códigos necessária. Você pode ver que a anotação @Stateless é usada para declarar a classe como um componente de Bean de sessão sem estado e que a classe não requer mais uma instrução para implementar javax.ejb.SessionBean. O código também é mais claro, porque com a tecnologia EJB 3.0 os métodos empresariais não precisam mais ter código que declare que eles lançam exceções verificadas.

Você pode ver que o recurso PersistenceContext foi injetado diretamente no componente do Bean de sessão quando criamos uma fachada de sessão.

Resumo

Neste exercício, codificamos uma classe de entidades e um Bean controlado por mensagem no módulo EJB. Em seguida criamos uma fachada de sessão para a classe de entidade. Criamos também os recursos JMS que serão usados por nosso aplicativo.

Criando o servlet ListNews

Neste exercício, criaremos um servlet simples para exibir dados. Usaremos anotações que chamem nosso Bean de entidade 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 para o nome do pacote e clique em Finalizar.

Ao clicar em Finalizar, a classe persistence.xml irá se abrir no Editor de fontes. No Editor de fontes, adote este procedimento:

1. Clique com o botão direito do mouse no código-fonte e selecione Recursos empresariais > Chamar Enterprise Bean.
2. Na caixa de diálogo Chamar Enterprise Bean, selecione NewsEntityFacade e clique em OK. Ao clicar em OK, o recurso do Bean de entidade será injetado no servlet usando a anotação @EJB.
3. No método processRequest, modifique o método removendo o comentário do código e adicionando as seguintes linhas em negrito ao corpo do método:

   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>");
                       

4. Pressione Alt-Shift-F para gerar instruções de importação necessárias para a classe. Quando geramos as instruções de importação, queremos importar classes do pacote util.
5. Salve as alterações feitas no arquivo.

Criando o servlet PostMessage

Neste exercício, criaremos 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 Finalizar.

Ao clicar em Finalizar, a classe PostMessage.java irá se abrir no Editor de fontes. No Editor de fontes, adote este procedimento:

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

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

2. Agora inserimos 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");
   
   // Adicione o seguinte código para enviar mensagem JMS
   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();
           // aqui criamos NewsEntity, que será enviado em mensagem JMS
           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. Agora removemos o comentário para imprimir o HTML e adicionamos o formulário da Web para adicionar uma mensagem. Adicione as linhas em negrito abaixo ao método processRequest

   out.println("Servlet PostMessage at " + request.getContextPath() + "</h1>");
   
   // Adicione o seguinte código para adicionar o formulário à página da Web
   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 Alt-Shift-F para gerar instruções de importação necessárias para a classe.
   Observação: Ao selecionar as bibliotecas a serem importadas para Connection, ConnectionFactory, Session e Queue, certifique-se de importar as bibliotecas java.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:
                    JMS resource not created : jms/Queue]
                

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

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

1. Confirme que o servidor de aplicativos Sun Java System está em execução expandindo o nó Servidores na guia Tempo de execução do IDE. Uma pequena seta verde ao lado do nó do servidor de aplicativos Sun Java System indica que o servidor está em execução.
2. Clique com o botão direito do mouse no nó do servidor de aplicativos Sun Java System e selecione Exibir console de administração para abrir a janela de logon no navegador.
3. Efetue o logon no servidor de aplicativos Sun Java System. 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 de aplicativos Sun Java System.

Os seguintes recursos devem estar registrados com o servidor de aplicativos 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