Antes de criar seu primeiro projeto Maven, é aconselhável certificar-se de que o IDE esteja configurado corretamente para utilizar a instalação e repositório locais do Maven. Você não deveria utilizar o instantâneo incorporado do Maven para desenvolver o projeto.

1. Abra a janela Opções no IDE.
2. Selecione a categoria Diversos na janela Opções e clique na aba Maven.
3. Especifique a localização da instalação local do Maven (requer 2.0.9 ou mais recente).
4. Verifique se a localização do repositório local do Maven está correta.
5. Clique em OK para fechar a janela Opções.

Se o Maven não estiver instalado no seu sistema, é possível fazer o download do instalador no site do Maven.

Os repositórios remotos e locais do Maven são utilizados para o autocompletar de código e para construir projetos. É necessário atualizar os índices dos repositórios remotos do Maven para garantir que os artefatos necessários estejam prontamente disponíveis no momento de desenvolver o projeto. É possível configurar com a mesma frequência que o IDE verifica as atualizações na aba Maven da janela Opções. Também é possível executar uma verificação imediata das atualizações e explorar os repositórios remotos e locais do Maven no navegador do repositório Maven.

1. Selecione Janela > Outro > Navegador do repositório Maven.
2. Clique em Atualizar índices (   ) na parte superior da janela Navegador do repositório Maven.

Ao clicar em Atualizar índices, o IDE verificará e fará o download do índice mais recente de cada um dos repositórios remotos do Maven. Um índice representa o estado atual dos artefatos localizados no repositório e é utilizado para proporcionar referências aos artefatos que estão disponíveis no aplicativo. Por padrão, o IDE não baixa um artefato de um repositório até que o artefato seja explicitamente necessário.

Nota: os índices são bem grandes e podem levar mais tempo para serem atualizados.

Ao desenvolver aplicativos Maven, normalmente não é necessário especificar um servidor de aplicativos até que o aplicativo seja construído. No entanto, neste tutorial você definirá o servidor de destino antes de começar a escrever o seu código, para obter benefícios de alguns dos recursos de geração de código no IDE. Com a configuração do servidor de deployment, o IDE pode reconhecer as tecnologias suportadas pelo servidor e permite que várias opções de alguns assistentes gerem código otimizados para tal servidor.

1. Inicie o servidor GlassFish.
2. Clique com o botão direito do mouse no nó do projeto EJB na janela Projetos e selecione Propriedades.
3. Selecione a categoria Executar na janela Propriedades.
4. Selecione o servidor GlassFish. Clique em OK.

Ao especificar o GlassFish como servidor de deployment antes de criar o código, o IDE oferecerá a opção de selecionar JTA no assistente para a criação da unidade de persistência. Você também pode optar por usar qualquer uma das fontes de dados registradas no servidor.

Criando a unidade de persistência

Neste exercício, será criada uma unidade de persistência no projeto EJB. A unidade de persistência especifica os detalhes da conexão de banco de dados e como as transações são gerenciadas. Para este aplicativo, você especificará a JTA no assistente Nova unidade de persistência, já que deseja que o servidor GlassFish gerencie as transações.

Para criar a unidade de persistência, execute as seguintes etapas.

1. Clique com o botão direito do mouse no nó do projeto EJB e selecione Novo > Outro no menu pop-up para abrir o assistente Novo arquivo.
2. Selecione Unidade de persistência na categoria Persistência. Clique em Avançar.
3. Selecione EclipseLink como o Provedor de persistência na caixa de diálogo Nova unidade de persistência.
4. Selecione uma fonte de dados (por exemplo, selecione jdbc/sample se desejar utilizar o JavaDB).

   A fonte de dados jdbc/sample é incorporada ao IDE na sua instalação e do servidor GlassFish, mas é possível especificar uma fonte de dados diferente se quiser utilizar um outro banco de dados.

   É possível manter as outras opções padrão (nome da unidade de persistência, provedor da persistência EclipseLink).

5. Certifique-se de que a opção Utilizar APIs de transação Java esteja selecionada e que Estratégia de geração de tabela esteja definida como Criar, para que as tabelas baseadas nas classes de entidade sejam criadas quando o aplicativo for implantado. Clique em Terminar.

Quando você clica em Terminar, o IDE cria o arquivo XML persistence.xml e o abre no editor. Na janela Projetos, é possível observar que o arquivo foi criado no diretório Outras origens > src/main/resources > META-INF. O arquivo contém detalhes sobre a conexão ao banco de dados e como as transações são gerenciadas. Se clicar em XML no editor, é possível ver os seguintes elementos no persistence.xml.

<persistence-unit name="com.mycompany_MavenEnterpriseApp-ejb_ejb_1.0-SNAPSHOTPU" transaction-type="JTA">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <jta-data-source>jdbc/sample</jta-data-source>
    <exclude-unlisted-classes>false</exclude-unlisted-classes>
    <properties>
      <property name="eclipselink.ddl-generation" value="create-tables"/>
    </properties>
</persistence-unit>
            

É possível observar que a JTA está especificada como o tipo de transação e que o aplicativo utilizará a fonte de dados registrada jdbc/sample.

Criando a classe de entidade

Neste exercício, será criada uma classe de entidade no projeto EJB para representar os objetos que serão persistentes no banco de dados. Para criar a classe de entidade NewsEntity, execute as etapas a seguir.

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. Selecione Classe de entidade na categoria Persistência. Clique em Avançar.
3. Digite NewsEntity para nome da classe.
4. Digite ejb em Pacote e deixe Tipo de chave primária como Longa. Clique em Terminar.

Ao clicar em Terminar, a classe de entidade NewsEntity.java se abrirá no Editor de código-fonte. No Editor de código-fonte, adicione alguns campos executando as etapas a seguir.

1. Adicione as seguintes instruçõ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 selecione Inserir código e, em seguida, selecione Getter e Setter no menu pop-up.
3. Na caixa de diálogo Gerar getters e setters, selecione os campos body e title. Clique em Gerar.
4. Corrija as importações e salve as alterações.

Criando o bean controlado por mensagem

Neste exercício, será criado um Bean controlado por mensagem no projeto EJB. Um bean controlado por mensagem é um enterprise bean que permite a troca assíncrona de mensagens. O aplicativo NewsApp utiliza um bean controlado por mensagem para receber e processar mensagens enviadas à fila por um servlet no módulo da Web.

Para utilizar um bean controlado por mensagem em um aplicativo, os recursos de conector utilizados pelo bean precisam estar registrados no servidor. Enquanto estiver implantando no servidor GlassFish, você poderá criar os recursos diretamente no servidor através do Console administrativo ou poderá criá-los no deployment pela especificação de detalhes no arquivo resources.xml. Quando o aplicativo é implantado no servidor, o servidor registra os recursos com base no sun-resources.xml. Ao utilizar o assistente Novo arquivo no IDE para criar um bean controlado por mensagem, o IDE gerará os elementos em sun-resources.xml para você.

Em um projeto Maven, o arquivo resources.xml está localizado no diretório src/main/setup sob o nó Projeto na janela Arquivos.

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 Java EE, selecione Bean controlado por mensagem. Clique em Avançar.
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, o IDE gera a classe de bean e adiciona as anotações seguintes que identificam a classe como um bean controlado por mensagem e as propriedades de configuração.

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

8. Introduza o recurso MessageDrivenContext na classe, adicionando o seguinte campo anotado à classe.

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

9. Introduza o gerenciador de entidade na classe, adicionando o seguinte campo anotado (em negrito).

   public class NewMessage implements MessageListener {
   
   @Resource
   private MessageDrivenContext mdc;
   @PersistenceContext(unitName="com.mycompany_MavenEnterpriseApp-ejb_ejb_1.0-SNAPSHOTPU")
   private EntityManager em;
                      

   A anotação @PersistenceContext especifica o contexto ao declarar a unidade de persistência. O valor de unitName é o nome da unidade de persistência.

10. Adicione o seguinte método save (em negrito).

    public NewMessage() {
    }
    
    public void onMessage(Message message) {
    }
    
    public void save(Object object) {
        em.persist(object);
    }

11. Modifique o método onMessage, adicionando o seguinte (em negrito) 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();
         }
    }

12. Corrija as instruções de importação (Ctrl-Shift-I) e salve as alterações.

    Nota: quando geramos as instruções de importação, queremos garantir a importação das bibliotecas 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 o Bean de sessão

Neste exercício, será utilizado o assistente para criar uma fachada de sessão para a classe de entidade NewsEntity. O assistente gerará alguns métodos comuns para criar, editar e localizar os métodos que podem ser acessados a partir dos servlets no projeto webapp.

1. Clique com o botão direito do mouse no módulo EJB e selecione Novo > Outro.
2. Na categoria Persistência, selecione Beans de sessão para Classe de entidade e clique em Avançar.
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 Avançar.
4. Verifique se o Pacote está definido como ejb. Não é necessário criar uma interface local.
5. Clique em Terminar.

No Java EE 6, as interfaces são opcionais. No Java EE 5, era necessário criar uma interface local para o bean de sessão e, em seguida, chamá-lo através da interface. No Java EE 6, a interface local é opcional e o servlet do módulo da Web pode acessar o bean de sessão diretamente através da fachada sem interface.

Criando o servlet ListNews

Neste exercício, você criará o servlet ListNews que será utilizado para exibir uma lista de mensagens enviadas. As anotações serão utilizadas para introduzir a fachada de sessão, acessar o método findAll e recuperar as mensagens enviadas.

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

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

4. Clique com o botão direito do mouse no editor de código-fonte, selecione Inserir código e selecione Chamar bean corporativo.
5. Na caixa de diálogo Chamar bean corporativo, expanda o nó News-App-ejb e selecione NewEntityFacade. Clique em OK.
   

   Ao clicar em OK, o recurso EJB é introduzido no servlet utilizando a anotação @EJB.

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

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

7. Corrija as importações (Ctrl-Shift-I) e salve as alterações.

   Ao gerar as instruções de importação, você deseja importar as bibliotecas java.util.

Criação do servlet PostMessage

Neste exercício, será criado o servlet PostMessage que será utilizado para enviar mensagens. Utilizaremos 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 selecione Novo > Servlet.
2. Digite PostMessage para nome da classe.
3. Selecione web em nome do pacote. Clique em Terminar.

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

4. No Editor de código-fonte, utilize anotações para introduzir os recursos ConnectionFactory e Queue, adicionando as seguintes declarações de campo.

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

5. Corrija as importações (Ctrl-Shift-I) para importar as bibliotecas javax.jms.
   

   Nota. Se o IDE não oferecer o javax.jms como opção, é possível pesquisar os repositórios em busca do artefato correto clicando no ícone de sugestão da margem ao lado de private ConnectionFactory connectionFactory; e selecionando Pesquisar dependência nos repositórios Maven.

   

   É possível utilizar a caixa de diálogo Pesquisar nos repositórios Maven para localizar e selecionar o artefato que contém ConnectionFactory.

   
6. Adicione o código a seguir para enviar as mensagens JMS ao método processRequest.

   response.setContentType("text/html;charset=UTF-8");
   
   // Adicione o código a seguir para enviar a 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 a NewsEntity, que será enviada 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();
       }
   }

7. Remova o comentário para imprimir o HTML e adicione o formulário da Web para adicionar uma mensagem.

   out.println("Servlet PostMessage at " + request.getContextPath() + "</h1>");
   
   // O código a seguir adiciona o formulário para a 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>");
       

8. Corrija as importações (Ctrl-Shift-I) e salve as alterações.

   Nota. Você quer importar as bibliotecas javax.jms de Connection, ConnectionFactory, Session e Queue.

Trabalhando com dependências do projeto

Neste exercício, será modificado o pom.xml do projeto Webapp para evitar que o arquivo EJB seja incluído no WAR durante o empacotamento. Isso evitará que o arquivo EAR contenha duas cópias do arquivo EJB.

Cada projeto Maven contém um arquivo pom.xml que contém os detalhes sobre o conteúdo dos arquivos. Todas as bibliotecas externas que sejam necessárias para o projeto estão listadas como dependências em pom.xml. É possível modificar o pom.xml para especificar as dependências que precisam estar incluídas durante o empacotamento do arquivo.

Neste aplicativo, os arquivos JAR EJB e WAR serão empacotados em um arquivo EAR. Se observar o pom.xml do projeto Assembly, poderá notar que o EJB e o WAR estão declarados como dependências.

Se observar o pom.xml do projeto Webapp, poderá notar que o arquivo EJB está declarado como uma dependência. O projeto Webapp precisa do arquivo EJB como uma dependência, mas neste aplicativo não queremos que o arquivo EJB seja incluído no WAR durante o empacotamento. O arquivo EJB estará disponível e será fornecido para o Webapp como parte do arquivo EAR.

É possível clicar com o botão direito do mouse no pom.xml e selecionar Mostrar gráfico de dependência para ver uma representação visual das dependências do projeto. É possível colocar o cursor sobre um artefato para exibir uma dica de ferramenta com os detalhes do artefato.

Execute as etapas a seguir para modificar o pom.xml do projeto Webapp para adicionar um elemento escopo à dependência no arquivo EJB.

1. Expanda o nó Arquivos do projeto no projeto Webapp.
2. Clique duas vezes em pom.xml para abrir o arquivo no editor.
3. Modifique a dependência no artefato MavenEnterpriseApp-ejb editando o POM a fim de adicionar o seguinte elemento <scope>provided</scope>.

   <dependency>
       <groupId>com.mycompany</groupId>
       <artifactId>MavenEnterpriseApp-ejb</artifactId>
       <scope>provided</scope>
       <version>1.0-SNAPSHOT</version>
   </dependency>

4. Salve as alterações.

É possível utilizar o autocompletar de código no editor POM para ajudá-lo a editar o arquivo.

Ao declarar que a dependência é fornecida, o Maven não empacotará o artefato ao construir o arquivo WAR.

Construindo com dependências

A estrutura de construção Maven percorre uma sequência específica de fases, e cada fase compreende uma ou mais metas e pode ser configurada para utilizar vários plug-ins Maven. O item de menu Construir com dependências é mapeado para a fase instalar do ciclo de vida de construção do Maven e é configurado para utilizar o plug-in Reactor. Ao selecionar Construir com dependências no menu pop-up, o Maven constrói o aplicativo e as dependências necessárias, bem como copia os artefatos construídos no repositório local.

É possível modificar como as fases e as metas do Maven são mapeados para as ações do menu no painel Ações da caixa de diálogo Propriedades do projeto.

Para construir o arquivo EAR, execute os passos a seguir.

• Clique com o botão direito do mouse no nó do projeto Assembly e selecione Construir com dependências.

Quando você constrói o projeto Assembly utilizando o plug-in Reactor, as dependências dos subprojetos são construídas antes da construção do projeto Assembly. A janela Saída exibe a ordem de construção.

Os resultados da construção também são exibidos na janela Saída.

Após construir o projeto Assembly, é possível ver o arquivo EAR final dentro do diretório target no nó do projeto Assembly na janela Arquivos.

Se o nome de artefato padrão com.mycompany foi utilizado, é possível utilizar o Navegador do repositório Maven para visualizar os artefatos de construção expandindo com.mycompany no Repositório local.

Para obter mais detalhes sobre a construção de projetos Maven, consulte Maven: Introdução ao ciclo de vida de construção em maven.apache.org.

Implantando a partir do IDE

Neste exercício, serão modificadas as metas do Maven que são mapeadas para a ação Executar. Após modificar a ação, é possível utilizar a ação Executar para implantar o EAR no servidor.

1. Clique com o botão direito do mouse no nó do projeto Assembly na janela Projetos e selecione Propriedades.
2. Selecione Ações na lista Categorias no painel esquerdo da janela Propriedades.
3. Selecione Executar projeto na lista Ações no painel direito.
4. No campo de texto Executar metas, exclua a meta package e digite install. Clique em OK.
   
5. Clique com o botão direito do mouse no nó do projeto Assembly na janela Projetos e selecione Executar.
6. Selecione o servidor GlassFish na caixa de diálogo Selecionar servidor de deployment. Clique em OK.
   

Após selecionar o servidor de deployment, o IDE cria os recursos JMS no servidor e implanta o arquivo EAR.

Implantando a partir do console de administração do GlassFish

Neste exercício, o arquivo EAR será implantado utilizando a ferramenta de implantação do console de administração do GlassFish.

1. Expanda o nó Servidores na janela Serviços.
2. Inicie o servidor GlassFish.
3. Clique com o botão direito do mouse no nó Servidor GlassFish e selecione Visualizar console Admin para abrir o console Admin do GlassFish no navegador.
4. Clique no nó Aplicativos no painel esquerdo do console Admin.
5. Clique no botão Implantar no painel principal do console Admin.
6. Clique em Procurar para localizar o arquivo EAR do aplicativo corporativo.

   O arquivo EAR está localizado no diretório target dentro do diretório do aplicativo corporativo no sistema local.

7. Clique em OK.

Ao clicar em OK, a ferramenta de implantação do GlassFish implanta o aplicativo.

Nota. Se implantar o aplicativo utilizando a ferramenta de implantação, você também precisará criar manualmente os recursos necessários para o aplicativo, caso estes não existam.