Criando uma aplicação empresarial

1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N) no menu principal.
2. Selecione Aplicação empresarial na categoria Empresa e clique em Próximo.
3. Chame o projeto de NewsApp e defina a localização do projeto.
4. Desmarque a opção Usar pasta dedicada, se ela estiver selecionada.
   (Esta opção fica disponível se você estiver usando o NetBeans IDE 6.1. Para este tutorial, não há motivo para copiar as bibliotecas do projeto para uma pasta dedicada porque você não precisará compartilhar bibliotecas com outros usuários ou projetos.)
   Clique em Próximo.
5. Defina o servidor como GlassFish e defina a versão de Java EE Java EE 5.
6. Selecione Criar módulo EJB e Criar módulo da aplicação Web, caso esteja desmarcada.
7. Clique em Terminar.

Resumo

Neste exercício, criamos uma aplicação empresarial Java EE 5 que contém um módulo EJB e um módulo da Web.

Criando uma unidade de persistência

Primeiro você cria 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 > Outro.
2. Na categoria Persistência, selecione Unidade de persistência e clique em Próximo.
3. Preserve o nome da unidade de persistência padrão.
4. Para o Provedor de persistência, escolha TopLink (default).
5. Em Fonte de dados, escolha uma fonte de dados (por exemplo, selecione jdbc/sample se quiser usar JavaDB).
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 a aplicação for implantada.
7. Clique em Terminar.

Ao clicar em Terminar, o IDE cria persistence.xml e o abre no Editor de código-fonte na exibição Design. Feche persistence.xml.

Criando as classes de entidade NewsEntity

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, adote o seguinte procedimento:

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

Ao clicar em Terminar, a classe de entidade NewsEntity.java irá se abrir no Editor de código-fonte. No Editor de código-fonte, adote este procedimento:

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 e selecione Getter e Setter para gerar getters e setters de cada um dos campos.
3. Na caixa de diálogo Gerar getters e setters, selecione os campos body e title e clique em Gerar.
4. Salve as alterações.

Na próxima etapa, você criará o bean controlado por mensagem NewMessage .

Criando o bean controlado por mensagem NewMessage

Agora você criará 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 > Outro 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. 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. Verifique se o destino do projeto está correto e clique em Terminar.

Ao clicar em Terminar, a classe do novo Bean controlado por mensagem NewMessage.java irá se abrir no Editor de código-fonte. Você pode ver a anotação @MessageDriven e as propriedades de configuração são adicionadas à classe.

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

Esta anotação informa ao contêiner 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á adicionou as informações dos recursos JMS ao sun-resources.xml. A API do EJB 3.0 permite que você pesquise objetos no namespace JNDI a partir da classe do bean, de maneira que não seja necessário configurar descritores de deployment para especificar os recursos JMS.

As especificações do EJB 3.0 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. Adicionaremos 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 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) {
       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 ao corpo:

   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. Pressione Ctrl-Shift-I para gerar as instruções de importação necessárias.
   Observação: quando geramos as instruções de importação, queremos garantir a importação das bibliotecas jms e javax.annotation.Resource.
6. Salve o arquivo.

Criando o Bean de sessão

Agora você criará 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 > Outro.
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 ejb.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 Terminar.

Ao clicar em Terminar, a classe de fachada de sessão NewsEntityFacade.java será criada e aberta no Editor de código-fonte. 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, você codificou uma classe de entidades e um bean controlado por mensagem no módulo EJB. Em seguida, criou uma fachada de sessão para a classe de entidade. Você também criou os recursos JMS que serão usados pelo aplicativo.

Criando o servlet ListNews

Neste exercício, você criará um servlet simples para exibir dados. Usaremos anotações que chamem o 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 Nome do pacote e 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, 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 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.
5. 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 irá se abrir no Editor de código-fonte. No Editor de código-fonte, 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 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. Agora remova o comentário para imprimir o HTML e adicione 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>");
   
   // 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 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:
                    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 da aplicação está em execução, expandindo o nó Servidores na aba Tempo de execução 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