Criando um aplicativo corporativo com o Maven no netbeans

49 views

Skip to first unread message

Paulo Sérgio da Silva Pacheco

unread,

Apr 2, 2014, 1:04:24 PM4/2/14

to evolucao...@googlegroups.com

https://netbeans.org/kb/docs/javaee/maven-entapp.html

Criando um aplicativo corporativo com o Maven

Este tutorial demonstra como criar um aplicativo corporativo simples usando o NetBeans IDE e arquétipos Maven. O tutorial também fornece algumas explicações e dicas sobre como usar o IDE para criar e construir aplicativos Maven.

Neste tutorial, você criar um aplicativo corporativo que é empacotado como um arquivo EAR e implantado GlassFish Server Open Source Edition 3. Você cria o aplicativo usando o arquétipo de aplicativo corporativo Maven no assistente Novo projeto. O aplicativo contém um projeto EJB que contém uma classe persistente entidade, um Bean controlado por mensagem e uma fachada bean de sessão para a entidade. O aplicativo também contém um projeto web que contém dois servlets.

Exercícios do tutorial

O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0

Para seguir este tutorial, você precisa dos seguintes recursos e softwares.

Software ou recurso	Versão necessária
NetBeans IDE	7.2, 7.3, 7.4, 8.0, versão do Java EE
Java Development Kit (JDK)	a versão 7 ou 8
GlassFish Server Open Source Edition	4.x

Pré-requisitos

Este documento assume que você tem algum conhecimento básico ou experiência de programação com as seguintes tecnologias:

Programação em Java
NetBeans IDE

Antes de começar este tutorial, talvez você queira se familiarizar com a seguinte documentação.

Você pode baixar um arquivo zip do projeto acabado .

Utilizando Maven no IDE

Suporte para Maven está totalmente integrado no NetBeans IDE. Desenvolver um projeto que utiliza a estrutura Maven é quase idêntico ao desenvolvimento de um projeto em Ant. No entanto, existem algumas diferenças que estão relacionados com a forma como Maven constrói projetos e obras com dependências. As dicas a seguir podem ajudá-lo a evitar alguns problemas se você estiver criando um aplicativo Maven pela primeira vez.

Verifique as configurações do Maven

Se este é seu primeiro projeto Maven você vai querer verificar as definições de configuração do Maven na janela Opções. Maven é fornecido com o IDE e instalado quando você instala o IDE.

Abrir a janela Opções no IDE (Ferramentas> Opções; NetBeans> Preferências no Mac).
Selecione a categoria Java na janela Opções e clique na aba Maven.
Confirme que a Maven inicial é especificado.
Você pode usar a versão Maven junto com o IDE ou especifique a localização de uma instalação local do Maven (requer 2.0.9 ou mais recente).
Clique em OK para fechar a janela Opções.

Notas.

Apoio Maven é ativado automaticamente quando o Java está habilitado no IDE. Você precisa ativar o plugin do Java EE se ele não está habilitado.

Atualize seus repositórios Maven

Repositórios Maven locais e remotos são usados para conclusão de código e na construção de projetos. Você deve atualizar os índices dos repositórios remotos do Maven para garantir que os artefatos que você pode precisar estão prontamente disponíveis quando você desenvolver seu projeto. Você pode configurar a frequência com que o IDE verifica se há atualizações na aba Maven da janela Opções. Você pode executar uma verificação imediata para atualizações e explorar os seus repositórios Maven locais e remotos na janela Serviços.

Escolha Janela> Serviços para abrir a janela Serviços.
Expanda o nó Repositórios Maven na janela Serviços.
Expandir um nó repositório para ver os artefatos.
O botão direito do mouse no nó de repositório e escolher Atualizar índice no menu pop-up.

Ao clicar em Atualizar índices, o IDE irá verificar e baixar o índice mais recente de cada um de seus repositórios remotos do Maven. Um índice representa o estado atual dos artefatos localizados no repositório e é usado para fornecer uma referência para os artefatos que estão disponíveis para a sua aplicação. Por padrão, o IDE não baixa um artefato de um repositório até que o artefato é explicitamente requerido.

Você pode procurar por um artefato ao clicar com o botão direito no nó Repositórios Maven na janela Serviços e escolha Localizar.

Notas.

Os índices são bastante grande e pode levar algum tempo para atualizá-los todos.
Se você estiver usando o NetBeans IDE 7.1 ou anteriores, você terá que escolher Janela> Outro> Navegador do repositório Maven e clique nos índices de atualização ( ) no topo da janela do navegador do repositório do Maven.

Para mais detalhes sobre como usar o Maven no NetBeans IDE, consulte a seção sobre Configurando Maven no Criando um aplicativo Maven Swing usando Hibernate tutorial e também Melhores práticas para o Apache Maven no NetBeans IDE .

Criando o projeto de aplicativo corporativo Maven

O objetivo deste exercício é criar um projeto de aplicativo corporativo utilizando o arquétipo de aplicativo corporativo Maven incluído no IDE. O arquétipo aplicativo corporativo também criará um projeto EJB e um projeto webapp.

O IDE inclui vários arquétipos Maven no assistente Novo projeto para ajudá-lo a criar rapidamente NetBeans comuns tipos de projetos, tais como projetos de aplicações corporativas (EAR), projetos de aplicativos da Web (WAR) e projetos de módulo EJB (JAR). O assistente também permite que você crie projetos de arquétipos em repositórios remotos registrados.

Escolha Arquivo> Novo projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu principal.
Selecione Enterprise Application na categoria Maven. Clique em Avançar.
Digite MavenEnterpriseApp para o nome do projeto e defina a localização do projeto.
(Opcional) Modifique os detalhes do artefato. Clique em Avançar.
Selecione GlassFish Server para o servidor.
Defina a versão Java EE para Java EE 6 ou Java EE 7.
Selecione Criar módulo EJB e Criar App Módulo Web. Clique em Concluir.

Ao clicar em Terminar, o IDE cria os seguintes projetos do arquétipo de aplicativo corporativo Maven.

EJB. (MavenEnterpriseApp-EJB) O projeto EJB geralmente contém o código-fonte com a lógica de negócios da aplicação. O projeto EJB é empacotado como um arquivo JAR EJB.
Webapp. (MavenEnterpriseApp-web) O projeto Webapp geralmente contém a camada de apresentação do aplicativo, como JSF e JSP e servlets páginas. O projeto Webapp também pode conter código-fonte com a lógica de negócios. O projeto Webapp é empacotado como um arquivo WAR.
Assembléia. (MavenEnterpriseApp) O projeto Assembly é usado para montar um arquivo EAR a partir dos arquivos EJB e WAR. O projeto Assembly não contém quaisquer fontes.
Enterprise Application. (MavenEnterpriseApp orelha) O projeto Enterprise Application não contém quaisquer fontes. O Enterprise Application contém apenas um arquivo POM ( pom.xml ) com detalhes sobre os módulos contidos no aplicativo corporativo.

Projetos mostrando janela Projetos gerados

Depois de criar o projeto do aplicativo corporativo, o projeto de aplicações corporativas serão badged se todas as dependências não estão disponíveis. Se você expandir o nó Dependências para o projeto MavenEnterpriseApp-ear, você pode ver se todas as bibliotecas necessárias estão em falta ou não no classpath. O projeto do aplicativo corporativo tem dependências do JAR e WAR, que serão embalados e disponível depois de compilar o projeto EJB eo projeto web. Você pode ver que MavenEnterpriseApp-ejb e MavenEnterpriseApp-web estão listados como dependências.

Em alguns casos, você verá um ícone de Maven na barra de status que você pode clicar para executar uma compilação priming e resolver dependências que estão faltando.

captura de tela do IDE mostrando ícone Maven na barra de status para a execução de construção priming

Codificação do Projeto EJB

O projeto EJB contém a lógica de negócios do aplicativo. Nesta aplicação, o recipiente GlassFish irá gerenciar transações usando a API de transação Java (JTA).Neste tutorial, você irá criar uma classe de entidade, um Bean controlado por mensagem e uma fachada de sessão para a classe de entidade no projeto EJB.

Criar unidade de persistência

Neste exercício, você cria uma unidade de persistência no projeto EJB. A unidade de persistência especifica os detalhes de conexão de banco de dados e especifica como as transações são gerenciadas. Para esta aplicação, você vai especificar JTA no assistente Nova unidade de persistência, porque você deseja que o servidor GlassFish para gerenciar as transações.

Para criar a unidade de persistência, execute os seguintes passos.

Botão direito do mouse no nó do projeto EJB e selecione Novo> Outro no menu pop-up para abrir o assistente Novo arquivo.
Selecione Unidade de persistência na categoria Persistência. Clique em Avançar.
Selecione EclipseLink como o Provedor de persistência na caixa de diálogo Nova unidade de persistência.
Selecione uma fonte de dados (por exemplo, selecione jdbc / sample se quiser usar JavaDB).
A fonte de dados jdbc / sample é fornecido com o IDE quando você instala o IDE eo servidor GlassFish, mas você pode especificar uma fonte de dados diferente se você quer usar um banco de dados diferente.

Você pode manter as outras opções padrão (nome da unidade de persistência, provedor da persistência EclipseLink).
Assegurar que o uso de Java APIs de transação é selecionado e que a Estratégia de geração de tabela está definida como Criar, para que as tabelas baseadas nas classes de entidade sejam criadas quando o aplicativo é implantado. Clique em Concluir.

Novo assistente de unidade de persistência

Ao clicar em Terminar, o IDE cria o arquivo XML persistence.xml e abre o arquivo no editor. Na janela Projetos, você pode ver que o arquivo foi criado naOutras Fontes> src / main / resources> META-INF diretório. O arquivo contém detalhes sobre a conexão com o banco de dados e como as transações são gerenciadas. Se você clicar na guia Origem do editor, você pode ver os seguintes detalhes sobre a unidade de persistência.

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

Você pode ver que JTA é especificada como o tipo de transação e que a aplicação irá utilizar o registrado fonte de dados jdbc / sample .

Criando a classe de entidade

Neste exercício, você irá criar uma classe de entidade no projeto EJB para representar os objetos que serão persistidos no banco de dados. Para criar a classe de entidade NewsEntity, execute os seguintes passos.

Botão direito do mouse no módulo EJB na janela Projetos e escolha Novo> Outro para abrir o assistente Novo arquivo.
Selecione Classe de entidade na categoria Persistência. Clique em Avançar.
Digite NewsEntity para o nome da classe.
Tipo ejb para o pacote e deixe o Tipo de chave primária como Long. Clique em Concluir.

Ao clicar em Terminar, a classe de entidade NewsEntity.java abre no editor de código-fonte. No Editor de código-fonte, adicionar alguns campos, executando as seguintes etapas.

Adicione as seguintes declarações de campo à classe.
```
private String title;
corpo private String;
```
Botão direito do mouse no Editor de código entre a definição de classe e escolha Inserir código (Alt-Insert; Ctrl-I no Mac)> Getter e Setter.
Na caixa de diálogo Gerar getters e setters, selecione os corpo e título campos. Clique em Gerar.
Salve as alterações para a classe.

Criando o bean controlado por mensagem

Neste exercício, você criará um bean controlado por mensagem no projeto EJB. Um bean controlado por mensagem é um bean corporativo que permite a troca assíncrona de mensagens. A aplicação NewsApp usa um Bean controlado por mensagem para receber e processar as mensagens enviadas para a fila por um servlet no módulo web.

Para usar um bean acionado por mensagens em um aplicativo, os recursos de conexão usadas pelo feijão precisa ser registrado com o servidor. Quando você estiver implantando no servidor GlassFish, você pode criar os recursos diretamente no servidor através do console de administração ou você pode criar os recursos em implantação, especificando os detalhes no glassfish-resources.xml arquivo descritor. Quando o aplicativo é implantado no servidor, o servidor registra os recursos com base no arquivo descritor. Quando você usa o assistente para Novo arquivo no IDE para criar um Bean controlado por mensagem, o IDE gerará os elementos no arquivo descritor para você.

Em um projeto Maven, o glassfish-resources.xml arquivo está localizado na principal src / / setup diretório sob o nó do projeto na janela Arquivos.

Botão direito do mouse no módulo EJB na janela Projetos e escolha Novo> Outro para abrir o assistente Novo arquivo.
Na categoria Enterprise JavaBeans, selecione Bean controlado por mensagem. Clique em Avançar.
Digite NewMessage para Nome EJB.
Selecione ejb na lista suspensa Pacote.
Clique no botão Adicionar ao lado do campo Destino do projeto para abrir a caixa de diálogo Adicionar destino da mensagem.
Na caixa de diálogo Adicionar destino da mensagem, tipo jms / NewMessage e selecione Fila para o tipo de destino. Clique em OK.
Confirme se o destino do projeto está correto. Clique em Avançar.

Aceite as configurações padrão nas Propriedades de Configuração de Ativação. Clique em Concluir.

Ao clicar em Terminar, o IDE gera a classe bean e adiciona as seguintes anotações que identificam a classe como um propriedades de feijão e configuração orientados a mensagens.

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

    NewMessage pública () {
    }

    @ Override
    onMessage public void (mensagem Mensagem) {
    }
}

Injectar a MessageDrivenContext recurso para a classe adicionando o seguinte campo anotado à classe.

public class NewMessage implementa MessageListener {

@ Resource
mdc MessageDrivenContext privado;

Introduzir o gerenciador de entidades para a classe adicionando o seguinte campo anotado (em negrito).

public class NewMessage implementa MessageListener {

@ Resource
mdc MessageDrivenContext privado;
@ PersistenceContext (unitName = "com.mycompany_MavenEnterpriseApp-ejb_ejb_1.0-SNAPSHOTPU")
los EntityManager privado;

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

Adicione o seguinte salvar método (em negrito).

NewMessage pública () {
}

@ Override
onMessage public void (mensagem Mensagem) {
}

private void salvar (objeto Object) {
    em.persist (objeto);
}

Modifique o onMessage método, adicionando a seguinte (em negrito) para o corpo:

onMessage public void (mensagem Mensagem) {
      ObjectMessage msg = null;
     try {
          if (mensagem instanceof ObjectMessage) {
          msg = mensagem (ObjectMessage);
              NewsEntity e = (NewsEntity) msg.getObject ();
              salvar (e);
          }
     } Catch (JMSException e) {
          e.printStackTrace ();
          mdc.setRollbackOnly ();
     } Catch (te Throwable) {
          te.printStackTrace ();
     } 
}

Corrija as instruções de importação (Ctrl-Shift-I; ⌘-Shift-I no Mac) e salvar as alterações.
Nota: Ao gerar as instruções de importação, você quer certificar-se de importar os jms e javax.annotation.Resource bibliotecas.

Para mais detalhes sobre beans orientados a mensagens, consulte o capítulo O que é um Message-Driven Bean? no 6 Tutorial Java EE, Parte I .

Criando o Bean de sessão

Neste exercício, você vai usar um assistente para criar uma fachada de sessão para a classe de entidade NewsEntity. O assistente irá gerar criar , editar eencontrar métodos que serão acessados a partir dos servlets no projeto webapp.

Botão direito do mouse no módulo EJB e selecione Novo> Outro.
Na categoria Persistência, selecione Beans de sessão para classes de entidade e clique em Avançar.
Selecione ejb.NewsEntity da 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.
Selecione ejb como o pacote. Clique em Concluir.

Quando você clica em Terminar, o IDE gera duas classes de fachada de sessão: AbstractFacade.java e NewsEntityFacade.java que estende a classe fachada abstrato. A classe fachada abstrata define vários métodos que são comumente usados com classes de entidade.

screenshot do Session Beans para assistente Classes de entidade

Codificação da Aplicação Web

Nesta seção, você criará dois servlets no projeto webapp.

Criando o servlet ListNews

Neste exercício, você criará o servlet ListNews que será usado para exibir uma lista de mensagens postadas. Você vai usar anotações para injetar a fachada de sessão e acessar o findAll método e recuperar as mensagens postadas.

Botão direito do mouse o projeto de módulo e escolha Novo> Servlet.
Digite ListNews para o nome da classe.
Digite web para o nome do pacote. Clique em Concluir.
Ao clicar em Terminar, a classe persistence.xml irá se abrir no Editor de origem.
Botão direito do mouse no Editor de código entre a definição de classe e escolha Inserir código (Alt-Insert; Ctrl-I no Mac)> Chamar bean corporativo.
Na caixa de diálogo Chamar bean corporativo, expanda o nó MavenEnterpriseApp-ejb e selecione NewsEntityFacade. Clique em OK.
Ao clicar em OK, o recurso EJB é injetado no servlet usando o @ EJB anotações.
```
@ WebServlet (name = "ListNews", urlPatterns = {"/ ListNews"})
public class ListNews estende HttpServlet {
    @ EJB
    privado NewsEntityFacade NewsEntityFacade;
```

No processRequest método, modificar o método através da adição dos seguintes linhas (em negrito) para o corpo do método:

out.println ("<h1> Servlet ListNews em" + request.getContextPath () + "</ h1>");

Lista de notícias = 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'> Adicionar nova mensagem </ a>");

out.println ("</ body>");

Nota. Talvez seja necessário descomentar o código se você estiver usando uma versão anterior do IDE.

Corrija suas importações (Ctrl-Shift-I; ⌘-Shift-I no Mac) e salvar as alterações.
Ao gerar as instruções de importação, você deseja importar os java.util bibliotecas.

Criando o servlet PostMessage

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

Botão direito do mouse o projeto de módulo e escolha Novo> Servlet.
Digite PostMessage para o nome da classe.
Selecione web para o nome do pacote. Clique em Concluir.
Ao clicar em Terminar, a classe PostMessage.java abre no editor de código-fonte.

No Editor de código-fonte, use anotações para injetar os ConnectionFactory e Fila recursos adicionando as seguintes declarações de campo.

@ WebServlet (name = "PostMessage", urlPatterns = {"/ PostMessage"})
public class PostMessage estende HttpServlet {
   @ Resource (mappedName = "jms / NewMessageFactory")
   privado ConnectionFactory connectionFactory;

   @ Resource (mappedName = "jms / NewMessage")
   fila fila privado;

Corrija as importações para importar os javax.jms bibliotecas.

Nota. Se o IDE não oferece javax.jms como uma opção, você pode procurar os repositórios para o artefato correto clicando no ícone de sugestão da margem ao lado privado ConnectionFactory connectionFactory; e escolhendo Pesquisa dependência nos repositórios Maven.

Você pode usar a Pesquisa em diálogo Maven Repositórios para localizar o javaee-api-6.0 artefato que contém ConnectionFactory .

Adicione o seguinte código para enviar mensagens JMS ao processRequest método.

response.setContentType ("text / html; charset = UTF-8");

/ / Adicione o seguinte código para enviar a mensagem JMS
Título String = request.getParameter ("title");
Cordas corpo = request.getParameter ("corpo");
if ((title! = null) && (body! = null)) {
    try {
        CONEXÃO = connectionFactory.createConnection ();
        Session session = connection.createSession (false, Session.AUTO_ACKNOWLEDGE);
        MessageProducer messageProducer = session.createProducer (fila);

        ObjectMessage mensagem = session.createObjectMessage ();
        / / Aqui criamos NewsEntity, que será enviado em mensagem JMS
        NewsEntity e = new NewsEntity ();
        e.setTitle (título);
        e.setBody (corpo);

        message.setObject (e);
        messageProducer.send (mensagem);
        messageProducer.close ();
        Connection.Close ();
        response.sendRedirect ("ListNews");

    } Catch (JMSException ex) {
        ex.printStackTrace ();
    }
}

Adicione o seguinte código (em negrito) para o formulário da Web para adicionar uma mensagem.

out.println ("Servlet PostMessage em" + request.getContextPath () + "</ h1>");

/ / O código a seguir adiciona o formulário para a página web
out.println ("<form>");
out.println ("Título: <input type='text' name='title'> <br/>");
out.println ("Mensagem: <textarea name='body'> </ textarea> <br/>");
out.println ("<input type='submit'> <br/>");
out.println ("</ form>");

out.println ("</ body>");

Nota. Talvez seja necessário descomentar o código se você estiver usando uma versão anterior do IDE.

Corrija as importações e salve as alterações.
Nota. Você deseja importar os javax.jms bibliotecas para conexão , ConnectionFactory , Session e Queue .

Construção do aplicativo com Maven

Agora que você terminou a codificação do aplicativo, você pode usar o Maven para construir o aplicativo corporativo. Nesta seção, você irá construir e empacotar os projetos em um arquivo EAR. O arquivo EAR conterá um arquivo JAR EJB e um arquivo WAR. Depois de criar o arquivo EAR, você pode implantar o arquivo para o servidor de destino.

Trabalhando com dependências do projeto

Neste exercício, você vai examinar o POM ( pom.xml ) do projeto web e modificar o POM para evitar artefatos desnecessários de ser incluído no WAR durante o empacotamento. Cada projeto Maven contém um pom.xml arquivo que contém detalhes sobre o conteúdo da arquivos. Todas as bibliotecas externas que são requeridos pelo projeto são listados como dependências no POM. Você pode modificar o POM para especificar as dependências que precisam ser incluídos ou devem ser excluídos ao empacotar o arquivo.

Nesta aplicação, o JAR EJB e os arquivos WAR serão empacotados em um arquivo EAR. Se você olhar para o pom.xml do projeto MavenEnterpriseApp-ear, você pode ver que o EJB e WAR são declarados como dependências.

Se você olhar para o pom.xml do projeto web no editor você pode ver que o arquivo EJB é declarado como uma dependência eo escopo é especificado comoprevisto . Quando o valor do elemento de alcance de um artefacto é fornecido , o artefacto não irá ser incluída durante a embalagem. O projeto web requer que o arquivo EJB como uma dependência, mas para esta aplicação, você não quer que o arquivo EJB seja incluído no WAR durante a embalagem porque o arquivo EJB estará disponível e fornecido como parte do arquivo EAR.

Você pode abrir pom.xml no editor e clique na guia Graph para ver uma representação visual das dependências do projeto. Se você estiver usando uma versão mais antiga do IDE você pode clicar com o botão direito em pom.xml no editor e escolha Mostrar gráfico de dependência. Você pode colocar o cursor sobre um artefato para exibir uma dica de ferramenta com os detalhes do artefato.

Execute as seguintes etapas para modificar o POM do projeto web para adicionar um escopo elemento para a dependência do javaee-api artefato.

Expanda o nó Arquivos do projeto no âmbito do projecto web.
Clique duas vezes em pom.xml para abrir o arquivo no editor.
Confirme que forneceu está definido para o valor do <scope> para o javaee-api artefato.
Se o valor não for fornecido você precisa editar o POM para fazer as seguintes alterações:
```
<dependency>
    <groupId> javax </ groupId>
    <artifactId> javaee-api </ artifactId>
    <versão> 7.0 </ version>
    jar <tipo> </ type>
    <scope> fornecido </ scope> 
</ dependency>
```
Você pode usar a conclusão de código no editor POM para ajudá-lo a editar o arquivo.

Ao declarar que a dependência é fornecida, o Maven não vai empacotar o artefato ao construir o arquivo WAR.
Salve as alterações.

Construir com dependências

A estrutura de construção Maven prossegue através de uma seqüência específica de fases, e cada fase consiste em um ou mais gols e pode ser configurado para usar vários plugins Maven. A construção com item de menu Dependências é mapeado para o instalar fase do ciclo de vida e construir Maven está configurado para usar o plugin Reactor. Quando você escolhe Construir com dependências no menu pop-up, o Maven constrói o aplicativo e todas as dependências e copia os artefatos construídos necessários para o repositório local.

Você pode modificar a forma como as fases e objetivos Maven são mapeadas para as ações do menu no painel Ações da caixa de diálogo Propriedades do projeto.

Para construir o arquivo EAR, execute o passo seguinte.

Botão direito do mouse no nó do projeto MavenEnterpriseApp-ear e escolha Construir com dependências.

Quando você constrói o projeto EAR usando o plugin do reator, os sub-projetos que são dependências do projeto EAR são construídos antes que o projeto EAR é construído. A janela Saída exibe a ordem de compilação.

Janela Saída mostrando Reactor ordem de construção

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

Saída janela mostrando o status de construção do reator

Depois de construir o projeto EAR, você pode ver o arquivo EAR final dentro do alvo diretório sob o nó do projeto EAR na janela Arquivos.

Se você usou o nome de artefato padrão com.mycompany , você pode usar o navegador do repositório Maven para visualizar os artefatos de construção expandindo com.mycompany no Repositório Local.

Para mais detalhes sobre a construção de projetos Maven, consulte Maven - Introdução ao Ciclo de Vida Envergadura em maven.apache.org .

Implantando e executando o aplicativo

Esta seção descreve dois métodos para a implantação do arquivo EAR no servidor. Você pode implantar o aplicativo no servidor GlassFish, usando uma ação do menu no IDE ou usando a ferramenta Deploy no GlassFish Admin Console.

Implantando e executando o aplicativo a partir do IDE

Neste exercício, você vai usar a ação de execução para implementar o arquivo EAR no servidor GlassFish. Depois de implantar o aplicativo que irá abrir a página ListNews do aplicativo em seu navegador e adicione uma mensagem.

Botão direito do mouse no nó do projeto EAR na janela Projetos e escolha Executar.
Ao clicar em Executar, o IDE irá implantar o arquivo EAR e criar os recursos JMS no servidor. O IDE abrirá a página de índice de projeto padrão (http://localhost:8080/MavenEnterpriseApp-web/ ) no seu browser.
Abra o seu navegador para a seguinte URL para exibir a página ListNews.
http://localhost:8080/MavenEnterpriseApp-web/ListNews .

Quando você executar o projeto, o banco de dados está vazia e não há mensagens para mostrar.
Clique em Adicionar nova mensagem.
Digite uma mensagem na forma em que o servlet PostMessage. Clique em Enviar consulta.

Quando você adiciona uma mensagem com o servlet PostMessage, a mensagem é enviada para o bean controlado por mensagem para escrever em armazenamento persistente eo servlet ListNews é chamado para exibir as mensagens no banco de dados. A lista de mensagens no banco de dados recuperados por ListNews em geral ainda não contém a nova mensagem, porque o serviço de mensagem é assíncrono.

Compilar ao salvar e implantar em Save está activa por defeito em projetos Maven que especificam servidor GlassFish como servidor de destino. Por exemplo, se você modificar a salvar um servlet, você pode recarregar o servlet no navegador e exibir as alterações sem reimplantar o aplicativo.

Implementando a partir do GlassFish Admin Console

Neste exercício, você irá implementar o arquivo EAR usando a ferramenta Deploy no GlassFish Admin Console.

Expanda o nó Servidores na janela Serviços.
Inicie o servidor GlassFish.
Botão direito do mouse no nó do servidor GlassFish e escolha Exibir console de administração para abrir o GlassFish Admin Console no seu browser.
Clique no nó de aplicativos no painel esquerdo do Console Admin.
Clique no botão Implantar no painel principal do Admin Console.
Clique em Procurar para localizar o arquivo EAR do aplicativo corporativo.
O arquivo EAR está localizado no alvo diretório dentro do diretório de aplicativos empresariais em seu sistema local.
Clique em OK.

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

Nota. Se você implantar o aplicativo usando a ferramenta de implantação do GlassFish Admin Console, você também precisará criar manualmente os recursos que são necessários para a aplicação, se eles não existem.

Baixando o projeto da solução

Você pode baixar a solução para este tutorial como um projeto das seguintes formas.

Baixar um arquivo zip do projeto acabado .
Checkout os fontes do projeto a partir das amostras do NetBeans executando as seguintes etapas:
1. Escolha Equipe> Subversion> Checkout no menu principal.
2. Na caixa de diálogo Checkout, insira a seguinte URL Repository: https://svn.netbeans.org/svn/samples ~-code samples-sourceClique em Avançar.
3. Clique em Procurar para abrir a caixa de diálogo Procurar por pastas do repositório.
4. Expanda o nó raiz e selecione amostras / javaee / MavenEnterpriseApp . Clique em OK.
5. Especifique a pasta local para as fontes (a pasta local precisa estar vazia).
6. Clique em Concluir.
  Ao clicar em Terminar, o IDE inicializa a pasta local como um repositório Subversion e verifica as fontes do projeto.
7. Clique em Abrir projeto na caixa de diálogo que aparece quando a retirada estiver completada.
Notas. Para mais informações sobre a instalação do Subversion, consulte a seção sobre Configurando o Subversion no Guia do Subversion no NetBeans IDE.

Envie seu comentário sobre este tutorial

Consulte também

Para mais informações sobre o uso do NetBeans IDE para desenvolver aplicações Java EE, consulte os seguintes recursos:

Você pode encontrar mais informações sobre o uso do Enterprise Beans na EE 7 Tutorial Java .

Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimentos dos recursos de desenvolvimento do NetBeans IDE Java EE, juntar-se à lista de discussão nbj2ee .

Saudações:

Nome...: PAULO PACHECO
E-Mail.: PauloSS...@gmail.com.br
MSN....: PauloSS...@Hotmail.com

Yahoo..: PauloSSPacheco@yahoo .com

Fixo...: 085 3086 6769
Celular: 085 8888 4498 OI

085 9702 4498 TIM

Reply all

Reply to author

Forward

0 new messages