Introdução às Aplicações Java EE

Este documento fornece uma breve introdução a algumas das funcionalidades apresentadas como parte da especificação Java Enterprise Edition 6 (Java EE 6). Para ilustrar as novas funcionalidades, este tutorial demonstrará como criar uma aplicação web Java EE simples que contenha uma fachada de bean de sessão sem estado EJB 3.1 para uma classe de entidade. Você utilizará assistentes no IDE para gerar a classe de entidade no bean de sessão. O código gerado pelo assistente utiliza consultas as quais estão definidas na API de critérios, que faz parte do JPA 2.x e está contida na especificação Java EE 6. Em seguida, você criará um bean gerenciado e nomeado que acessa a fachada de sessão, bem como uma camada de apresentação que utiliza o framework de view do Facelets como especificado no JSF 2.x.

Este tutorial é baseado no post do blog Simplest Possible JSF 2 / EJB 3.1 / JPA Component - With WAR Deployment de Adam Bien. Você pode encontrar exemplos adicionais de Java EE no projeto do Kenai de Adam Bien Java EE Patterns and Best Practices e no seu livro "Real World Java EE Patterns - Rethinking Best Practices", disponível em http://press.adam-bien.com.

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, são necessários os recursos e o software a seguir.

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

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

Você pode fazer download de um arquivo compactado zip do projeto finalizado.

Criando o Projeto de Aplicação Web

Neste exercício será criada uma aplicação web simples. Quando você cria uma aplicação web, o GlassFish Server é especificado como o contêiner Java EE de destino. O GlassFish Server é compatível com o Java EE e inclui as bibliotecas JSF 2.x que são necessárias nesta aplicação.

No assistente Novo Projeto, você pode selecionar o Java EE 6 Web ou Java EE 7 como a versão Java EE. Java EE 6 Web e Java EE 7 Web são perfis de Java EE leves que contêm um subconjunto da plataforma Java EE completa. Os perfis Java EE Web foram criados para aplicações web que não requerem as tecnologias Java EE avançadas, como o suporte a interfaces remotas, a especificação completa do EJB 3.1 e a API Java Message Service (JMS).

Os perfis Web suportam o processamento da transação e o gerenciamento de persistência que normalmente são utilizados em aplicações web corporativas. Você pode utilizar os perfis Java EE Web para aplicações Web que utilizam beans de sessão com uma interface local ou sem uma interface. O perfil Java EE completo é necessário se a aplicação utilizar uma interface remota.

  1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu principal.
  2. Selecione Aplicação Web na categoria Java Web e clique em Próximo.
  3. Digite SimpleEE6App como o nome do projeto e defina a localização do projeto.
  4. Desmarque a opção Usar Pasta Dedicada, se ela estiver selecionada. Clique em Próximo.
    (Para este tutorial, não há motivo para copiar as bibliotecas de projeto em uma pasta dedicada, pois você não precisará compartilhar bibliotecas com outros usuários ou projetos).
  5. Selecione o servidor GlassFish Server e defina a versão do Java EE como Java EE 6 Web ou Java EE 7 Web. Clique em Próximo.
    Assistente Novo Projeto
  6. Selecione JavaServer Faces no painel Frameworks. Clique em Finalizar.

    Se você estiver desenvolvendo uma aplicação web Java EE e implantando-a no GlassFish Server, o IDE selecionará a biblioteca JSF 2.x como default. A versão da biblioteca JSF default depende da versão encapsulada de seu servidor GlassFish. A biblioteca JSF 2.x permite utilizar Facelets como a linguagem da página e também fornece o suporte para JSF 1.2 e JSP.

    Assistente Novo Projeto

Quando você clica em Finalizar, o IDE cria o projeto e o abre na janela Projetos. O IDE cria automaticamente a página index.xhtml e abre a página no editor.

Criando a Classe de Entidade e a Fachada de Sessão

Nesta sessão, você criará uma classe de entidade e uma fachada de sessão para a classe de entidade. Uma classe de entidade é um objeto Java simples e antigo (POJO), uma classe Java simples que é identificada como uma entidade pela anotação @Entity. A partir da especificação Java EE 5, você pode utilizar classes de entidade como objetos persistentes para representar tabelas em um banco de dados. A Java Persistence API permite utilizar a persistência em aplicações web sem a necessidade de criar um módulo EJB.

A fachada de sessão para a classe de entidade nesta aplicação é um bean de sessão sem estado. A arquitetura Enterprise JavaBean (EJB) 3.1 introduzida como parte da especificação Java EE 6 permite criar beans de sessão sem as interfaces de negócios que eram necessárias no EJB 3.0. A especificação Java EE 6 também permite encapsular componentes do EJB diretamente em um arquivo compactado WAR. Isso simplifica o desenvolvimento de aplicações web menores eliminando a necessidade de criar módulos EJB separados, que são encapsulados como um arquivo compactado JAR em um arquivo compactado EAR. No entanto, para aplicações enterprise maiores que são distribuídas entre diferentes máquinas, você ainda precisará criar arquivos compactados EAR para separar sua lógica de negócios da camada de apresentação.

Para obter mais informações sobre o uso do EJB 3.1 no IDE, consulte o tutorial Criando uma Aplicação Corporativa com o EJB 3.1.

Para saber mais sobre classes de entidade, consulte o capítulo Introdução à Java Persistence API no Tutorial do Java EE 7.

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 7.

Criando a Classe de Entidade

Neste exercício, você utilizará o assistente Nova Classe de Entidade para criar uma classe de entidade persistente simples. Você também utilizará o assistente para criar uma unidade de persistência que define a origem dos dados e o gerenciador de entidade utilizado na aplicação. Você adicionará um campo na classe para representar os dados em sua tabela e gerar um getter e um setter para o novo campo.

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

Utilizar a Java Persistence em seu projeto simplifica tremendamente o desenvolvimento da aplicação, removendo a necessidade de configurar os descritores de implantação para fornecer informações de mapeamento relacional de objeto para campos ou propriedades persistentes. Em vez disso, você pode utilizar anotações para definir essas propriedades diretamente em uma classe Java simples.

A persistência de entidade é gerenciada pela API EntityManager. A API EntityManager trata o contexto de persistência e cada contexto de persistência é um grupo de instâncias de entidade. Ao desenvolver a aplicação, você pode utilizar anotações em sua classe para especificar a instância do contexto de persistência das suas instâncias de entidade. O ciclo de vida das instâncias de entidade será então tratado pelo contêiner.

Para criar a classe de entidade, execute as seguintes etapas.

  1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.
  2. Selecione Classe de Entidade na categoria Persistência. Clique em Próximo.
  3. Digite Message como o nome da classe.
  4. Digite entities para o Pacote.
  5. Selecione Criar Unidade de Persistência. Clique em Próximo.
  6. Selecione uma fonte de dados (por exemplo, selecione jdbc/sample se desejar utilizar o JavaDB).

    A fonte de dados para jdbc/sample é incluída com o IDE ao instalar o IDE e o GlassFish Server, mas você pode especificar uma fonte de dados diferente se desejar utilizar um banco de dados diferente.

    Você pode manter as outras opções default (nome da unidade de persistência, provedor da persistência EclipseLink). Confirme se a unidade de persistência está utilizando a Java Transaction API e se a Estratégia de Geração de Tabela é definida como Criar, para que as tabelas com base nas suas classes de entidade sejam criadas quando a aplicação é implantada.

  7. Clique em Finalizar no assistente Nova Classe de Entidade.

    Quando você clica em Finalizar, o IDE cria a classe de entidade e abre a classe no editor. Você pode ver que o IDE gerou o campo de id private Long id; e anotou o campo com @Id e @GeneratedValue(strategy = GenerationType.AUTO).

  8. No editor, adicione o campo mensagem (em negrito) abaixo do campo id.
    private Long id;
    private String message;
  9. Clique com o botão direito do mouse no editor e selecione Inserir Código (Alt-Insert; Ctrl+I no Mac) e, em seguida, selecione Getter e Setter.
  10. Na caixa de diálogo Gerar Getters e Setters, selecione o campo mensagem e clique em Gerar.

    O IDE gera os métodos getter e setter para o campo mensagem.

    Assistente Criar Unidade de Persistência
  11. Salve as alterações.

A classe de entidade representa uma tabela no banco de dados. Quando você executa esta aplicação, uma tabela do banco de dados para Mensagem será criada automaticamente. A tabela conterá as colunas id e mensagem.

Se examinar a unidade de persistência no editor XML, verá que a aplicação utilizará a API de Transação Java (JTA) (transaction-type="JTA"). Isso especifica que a responsabilidade por gerenciar o ciclo de vida de entidades no contexto da persistência é designada ao contêiner. Isso resulta em menos código, porque o ciclo de vida da entidade é gerenciado pelo contêiner e não pela aplicação. Para obter mais informações sobre o uso de JTA para gerenciar transações, consulte a documentação da API de Transação Java.

Criando a Fachada da Sessão

Neste exercício você utilizará um assistente para criar uma fachada de sessão sem estado para a entidade Mensagem. A especificação EJB 3.1. declara que as interfaces de negócios para beans de sessão agora são opcionais. Nesta aplicação, onde o cliente que acessa o bean é um cliente local, você tem a opção de utilizar uma interface local ou uma view sem interface para expor o bean.

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

  1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.
  2. Selecione Beans de Sessão para Classes de Entidade na categoria Enterprise JavaBeans. Clique em Próximo.
  3. Selecione a entidade Mensagem e clique em Adicionar. Clique em Próximo.
  4. Digite boundary para o pacote. Clique em Finalizar.

    Observe que não foi necessário criar uma interface de negócios para o bean de sessão. Em vez disso, nessa aplicação, o bean será exposto a um bean gerenciado local utilizando uma view sem interface.

    Assistente Beans de Sessão para Classes de Entidade

Quando você clica em Finalizar, o IDE gera a classe de fachada da sessão MessageFacade.java e AbstractFacade.java e abre os arquivos no editor. Como podemos ver no código gerado, a anotação @Stateless é usada para declarar a classe MessageFacade.java como um componente de bean de sessão sem estado. MessageFacade.java estende AbstractFacade.java, que contém a lógica de negócio e gerencia a transação.

@Stateless
public class MessageFacade extends AbstractFacade<Message> {
    @PersistenceContext(unitName = "SimpleEE6AppPU")
    private EntityManager em;
            

Quando você cria a fachada para a entidade utilizando o assistente, como default, o IDE adiciona a anotação PersistenceContext (@PersistenceContext(unitName = "SimpleEE6AppPU")) para injetar recurso de gerenciador de entidades no componente do bean de sessão e para especificar o nome da unidade de persistência. Neste exemplo, o nome da unidade de persistência é explicitamente declarado, mas o nome é opcional se a aplicação tiver somente uma unidade de persistência.

O IDE também gera métodos em AbstractFacade.java para criar, editar, remover e localizar entidades. A API EntityManager define os métodos que são utilizados para interagir com o contexto da persistência. Você pode ver que o IDE gera alguns métodos de consulta default usados com frequência que podem ser utilizados para localizar objetos de entidade. Os métodos findAll, findRange e count utilizam os métodos definidos na API Critérios para criar consultas. A API Critérios faz parte da especificação JPA 2.x, que está incluída na especificação Java EE 6.

Criando as Páginas Bean Gerenciado JSF e JSF

Nesta seção, você criará a camada de apresentação para a aplicação utilizando o JavaServer Faces (JSF) 2.x e um backing bean gerenciado que é utilizado pelas páginas JSF. A especificação JSF 2.x adiciona o suporte para Facelets, como a tecnologia de exibição preferencial para aplicações com base em JSF. Começando com o JSF 2.x, você também poderá utilizar a anotação @ManagedBean em seu código-fonte para declarar uma classe como bean gerenciado. Não é mais necessário adicionar entradas no arquivo faces-config.xml para declarar beans gerenciados JSF. Você pode utilizar nomes de beans em páginas JSF para acessar métodos no bean gerenciado.

Para obter mais informações sobre o suporte do IDE para a especificação JavaServer Faces 2.x, consulte Suporte JSF 2.x no NetBeans IDE.

Para obter mais informações sobre a especificação JavaServer Faces 2.x, consulte o capítulo Tecnologia do JavaServer Faces no Tutorial Java EE 7.

Criando o Bean Gerenciado

Neste exercício, será criado um bean gerenciado JSF simples, que é utilizado para acessar a fachada de sessão. A especificação do JSF 2.x permite utilizar anotações em uma classe do bean para identificá-la como um bean gerenciado pelo JSF e especificar o escopo e um nome para o bean.

Para criar o bean gerenciado, execute as seguintes etapas:

  1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.
  2. Selecione Bean Gerenciado pelo JSF na categoria JavaServer Faces. Clique em Próximo.
  3. Digite MessageView para o Nome da Classe.

    Você utilizará o bean gerenciado de nome MessageView como o valor para inputText e commandButton na página JSF index.xhtml ao chamar métodos no bean.

  4. Digite my.presentation para o Pacote.
  5. Digite MessageView para o Nome que será utilizado para o bean gerenciado.

    Observação. Quando você cria um bean gerenciado utilizando o assistente, o IDE designará, por default, um nome para o bean, com base no nome da classe bean com uma letra minúscula. Para este tutorial e para fins de demonstração, você designa explicitamente ao bean um nome que começa com uma letra maiúscula. Ao referenciar o bean nas páginas JSF, você usará MessageView, em vez de messageView. Se você não tiver designado o nome explicitamente, deverá usar messageView default na página JSF.

  6. Defina Escopo como Requisição. Clique em Finalizar.
Novo assistente de Bean Gerenciado pelo JSF

Quando você clicar em Finalizar, o IDE gerará a classe bean e abrirá a classe no editor. Na janela Projetos, você verá os seguintes arquivos.

Janela Projeto que mostra estrutura de arquivos

No editor, você pode ver que o IDE adicionou as anotações @ManagedBean e @RequestScoped e o nome do bean.

@ManagedBean(name="MessageView")
@RequestScoped
public class MessageView {

    /** Creates a new instance of MessageView */
    public MessageView() {
    }

}

Agora, você adicionará uma anotação @EJB será adicionada para utilizar injeção de dependência para obter uma referência ao bean de sessão MessageFacade. Você também chamará os métodos findAll e create que estão expostos na fachada. A funcionalidade autocompletar código do IDE pode ajudá-lo enquanto você digita os métodos.

  1. Clique com o botão direito do mouse no editor, selecione Inserir Código (Alt-Insert; Ctrl-I no Mac) e Chamar Enterprise Bean no menu pop-up.
  2. Selecione MessagFacade na caixa de diálogo Chamar Enterprise Bean. Clique em OK.
    Caixa de diálogo Chamar Enterprise Bean

    Quando você clica em OK, o IDE adiciona o seguinte código (em negrito) para injetar o bean.

    public class MessageView {
    
        /** Creates a new instance of MessageView */
        public MessageView() {
        }
    
        // Injects the MessageFacade session bean using the @EJB annotation
        @EJB
        private MessageFacade messageFacade;
    }
    
  3. Adicione o código a seguir para criar uma nova instância.
    /** Creates a new instance of MessageView */
        public MessageView() {
           this.message = new Message();
        }
  4. Adicione o seguinte código à classe.
        // Creates a new field
        private Message message;
    
    
        // Calls getMessage to retrieve the message
        public Message getMessage() {
           return message;
        }
    
        // Returns the total number of messages
        public int getNumberOfMessages(){
           return messageFacade.findAll().size();
        }
    
        // Saves the message and then returns the string "theend"
        public String postMessage(){
           this.messageFacade.create(message);
           return "theend";
        }
    
  5. Clique com o botão direito do mouse no editor, selecione Corrigir Importações (Alt-Shift-I; ⌘-Shift-I no Mac) e salve as alterações.

Você pode utilizar a funcionalidade para autocompletar código no editor para ajudar a digitar seu código.

Observe que o método postMessage retorna a string "theend". A especificação JSF 2.x permite a utilização de regras de navegação implícitas em aplicações que utilizam a tecnologia Facelets. Nesta aplicação, não há regras de navegação configuradas em faces-config.xml. Em vez disso, o handler de navegação tentará localizar a página adequada na aplicação. Neste caso, o handler de navegação tentará localizar uma página nomeada theend.xhtml quando o método postMessage for chamado.

Modificando a Página de Índice

Neste exercício, você fará algumas alterações simples na página index.xhtml para adicionar alguns componentes de interface do usuário. Você adicionará um form com um campo de entrada de texto e um botão.

  1. Abra o index.xhtml no editor.
  2. Modifique o arquivo para adicionar o seguinte form simples entre as tags <h:body>.
    <h:body>
        <f:view>
            <h:form>
                <h:outputLabel value="Message:"/><h:inputText value="#{MessageView.message.message}"/>
                <h:commandButton action="#{MessageView.postMessage}" value="Post Message"/>
            </h:form>
        </f:view>
    </h:body>

    A funcionalidade autocompletar código JSF pode ajudá-lo ao digitar o código.

    Autocompletar código no editor de código-fonte

    Observação. Se você copiar e colar o código no arquivo, receberá uma advertência na margem esquerda ao lado da linha que contém <f:view>. Você pode colocar o cursor de inserção na linha e digitar Alt-Espaço para abrir a dica sobre como resolver o erro. A dica informa que é necessário adicionar a declaração de biblioteca xmlns:f="http://xmlns.jcp.org/jsf/core".

  3. Salve as alterações.

Os componentes inputText e commandButton chamarão os métodos no bean gerenciado JSF nomeado MessageView. O método postMessage retornará "theend" e o handler de navegação procurará por uma página nomeada theend.xhtml.

Criando a Página de Resultados

Neste exercício, você criará a página JSF theend.xhtml. A página será exibida quando o usuário clicar no botão Postar Mensagem no index.xhtml e chamar o método postMessage no bean gerenciado JSF.

  1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.
  2. Selecione a Página JSF na categoria JavaServer Faces. Clique em Próximo.
  3. Digite theend como o Nome do Arquivo.
  4. Certifique-se de que a opção Facelets esteja selecionada. Clique em Finalizar.
    tela do assistente Novo Arquivo JSF
  5. Modifique o arquivo digitando o seguinte entre as tags <h:body>.
    <h:body>
        <h:outputLabel value="Thanks! There are "/>
        <h:outputText value="#{MessageView.numberOfMessages}"/>
        <h:outputLabel value=" messages!"/>
    </h:body>

Quando você começa a digitar, o IDE adiciona automaticamente a definição de biblioteca de tags xmlns:h="http://xmlns.jcp.org/jsf/html" ao arquivo para os elementos JSF.

Executando a Aplicação

Você agora finalizou a codificação da aplicação. Agora você pode testar a aplicação no browser.

  1. Clique com o botão direito do mouse no nó na janela Projetos e selecione Executar.

    Quando você seleciona Executar, o IDE constrói e implanta a aplicação e abre o index.xhtml no browser.

  2. Digite uma mensagem no campo de texto. Clique em Postar Mensagem.
    Aplicação no browser

Quando você clica em Postar Mensagem, a mensagem será salva no banco de dados e o número de mensagens será recuperado e exibido.

Aplicação no browser mostrando resultados

Fazendo Download do Projeto da Solução

Você pode fazer o download dos projetos de amostra usados neste tutorial das seguintes formas:

  • Faça download de um arquivo compactado zip do projeto finalizado.
  • Faça o check-out do código-fonte do projeto das Amostras do NetBeans ao executar as etapas a seguir:
    1. Escolha Equipe > Subversion > Efetuar check-out no menu principal.
    2. Na caixa de diálogo Efetuar Check-out, insira o Repositório URL a seguir:
      https://svn.netbeans.org/svn/samples~samples-source-code
      Clique em Próximo.
    3. Clique em Procurar para abrir a caixa de diálogo Procurar Pastas do Repositório.
    4. Expanda o nó de raiz e selecione samples/javaee/SimpleEE6App. Clique em OK.
    5. Especifique a Pasta Local para o códigos-fonte (a pasta local precisa estar vazia).
    6. Clique em Finalizar.

      Quando você clica em Finalizar, o IDE inicializa a pasta local como um repositório Subversion e verifica os códigos-fonte do projeto.

    7. Clique em Abrir Projeto na caixa de diálogo exibida quando o check-out for concluído.

    Observações.



Consulte Também

Para obter 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 das tecnologias Java EE 6 para desenvolver aplicações no Tutorial do Java EE 7.

Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimentos das funcionalidades de desenvolvimento do Java EE do NetBeans IDE, inscreva-se na lista de correspondência de nbj2ee.

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo