Criando a classe de entidade

Neste exercício, o assistente Nova classe de entidade será utilizado para criar uma classe de entidade simples e persistente. Também será utilizado o assistente para criar uma unidade de persistência que define a origem dos dados e o gerenciador de entidades utilizados no aplicativo. Um campo será adicionado 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. Ao criar a classe de entidade utilizando o assistente, o IDE, como padrão, gera o campo id e anota a anotação @Id no campo 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 Id primário.

Utilizar persistência Java em seu projeto simplifica tremendamente o desenvolvimento do aplicativo, removendo a necessidade de configurar os descritores de deployment para fornecer informações de mapeamento de objeto relacional para campos ou propriedades persistentes. Em vez disso, é possível 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 manipula o contexto de persistência e cada contexto de persistência é um grupo de instâncias de entidade. Ao desenvolver o aplicativo, é possível 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 é então manipulado 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 Avançar.
3. Digite Message para o nome da classe.
4. Digite entities para o pacote.
5. Selecione Criar unidade de persistência. Clique em Próximo.

   Nota. No NetBeans IDE 6.8, clique no botão Criar unidade de persistência para abrir a caixa de diálogo para a criação da unidade de persistência.

6. Selecione uma fonte de dados (por exemplo, selecione jdbc/sample se desejar utilizar o JavaDB).

   A fonte de dados para jdbc/sample é embutida com o IDE ao instalar o IDE e o servidor GlassFish, mas é possível especificar uma fonte de dados diferente se desejar utilizar um banco de dados diferente.

   É possível manter as outras opções padrão (nome da unidade de persistência, provedor da persistência EclipseLink). Confirme que a unidade de persistência está utilizando o Java Transaction API e que a tabela Estratégia de geração é definida para criar, de forma que as tabelas com base nas suas entidades de classe são criadas quando o aplicativo é implantado.

7. Clique em Terminar no assistente Nova classe de entidade.

   Ao clicar em Terminar, o IDE cria a classe de entidade e abre a classe no editor. É possível ver que o IDE gerou o campo id private Long id; e anotou @Id e @GeneratedValue(strategy = GenerationType.AUTO) no campo.

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 (Ctrl+I) 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.

    
11. Salve as alterações.

A classe de entidade representa uma tabela no banco de dados. Ao executar este aplicativo, 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 o aplicativo utilizará a API Java Transaction (JTA) (transaction-type="JTA"). Isto especifica que a responsabilidade para gerenciar o ciclo de vida de entidades no contexto de persistência é atribuída ao contêiner. Isto resulta em menos código, porque o ciclo de vida da entidade é gerenciado pelo contêiner e não pelo aplicativo. Para obter mais informações sobre o uso do JTA para gerenciar transações, consulte a documentação API do Java Transaction.

Criando a fachada de sessão

Neste exercício, o assistente será utilizado a fim de criar uma fachada de sessão sem estado para a entidade Mensagem. A especificação EJB 3.1. declara que as interfaces corporativas para beans de sessão agora são opcionais. Esse aplicativo, onde o cliente que acessa o bean é um cliente local, contém a opção de utilizar uma interface local ou uma visualização 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 classe de entidade na categoria Java EE. Clique em Avançar.
3. Selecione a entidade Mensagem e clique em Adicionar. Clique em Avançar.
4. Digite boundary para o pacote. Clique em Terminar.

   Observe que não foi necessário criar uma interface administrativa para o bean de sessão. Em vez disso, nesse aplicativo, o bean será exposto a um bean gerenciado local utilizando uma visualização sem interface.

   

Ao clicar em Terminar, o IDE gera a classe de fachada do bean MessageFacade.java e AbstractFacade.java e abre os arquivos no editor. Como é possível ver no código gerado, a anotação @Stateless é utilizada para declarar MessageFacade.java como um componente de bean de sessão sem estado. MessageFacade.java estende AbstractFacade.java, que contém a lógica corporativa e gerencia a transação.

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

Ao criar a fachada para a entidade utilizando o assistente, como padrão, o IDE adiciona a anotação PersistenceContext (@PersistenceContext(unitName = "SimpleEE6AppPU")) para injetar recurso de gerenciador de entidades no componente bean da 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 o aplicativo possuir 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 de persistência. É possível ver que o IDE gera alguns métodos de consulta utilizados 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ério para criar consultas. A API Critério faz parte da especificação JPA 2.0, que está incluída na especificação Java EE 6.

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 JSF 2.0 que faz parte do Java EE, permite utilizar anotações na classe bean para identificar a classe como um bean gerenciado JSF, para especificar o escopo e para indicar 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 JSF na categoria JavaServer Faces. Clique em Avançar.
3. Digite MessageView para o nome da classe.

   O nome MessageView do bean gerenciado será utilizado como o valor para inputText e commandButton na página JSFindex.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.

   Nota. Ao criar o bean gerenciado utilizando o assistente, o IDE atribuirá, como padrão, um nome com base no nome da classe bean e que começa com uma letra minúscula. Neste tutorial e para demonstração, você atribui explicitamente ao bean um nome que começa com uma letra minúscula. O fazer referência ao bean nas páginas JSF, você utilizará MessageView em vez de messageView. Se não tivesse atribuído o nome explicitamente, você utilizaria messageView padrão na página JSF.

6. Defina Escopo como Requisição. Clique em Terminar.

Ao clicar em Terminar, o IDE cria a classe bean e abre a classe no editor. Na janela Projetos, você verá os seguintes 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, uma anotação @EJB será adicionada para utilizar injeção de dependência a fim de obter uma referência ao bean de sessão MessageFacade. Os métodos findAll e create que estão expostos na fachada também serão chamados. O autocompletar de código do IDE pode ajudá-lo enquanto você digita os métodos.

1. Clique com o botão direito do mouse no editor e selecione Inserir código (Ctrl+I) para abrir o menu pop-up.
2. Marque Chamar Enterprise Bean no menu pop-up.
3. Marque MessagFacade na caixa de diálogo Chamar Enterprise Bean. Clique em OK.
   

   Ao clicar em OK, o IDE adiciona o seguinte código (em negrito) para injetar o bean.

   public class MessageView {
   
       /** Cria uma nova instância de MessageView */
       public MessageView() {
       }
   
       // Introduz o bean de sessão MessageFacade utilizando a anotação @EJB
       @EJB
       private MessageFacade messageFacade;
   }
   

4. Adicione o código a seguir para criar uma nova instância.

   /** Creates a new instance of MessageView */
       public MessageView() {
          this.message = new Message();
       }

5. Adicione o seguinte código à classe .

       // Crie um novo campo
       private Message message;
   
   
       // Nomeie a getMessage para recuperar a mensagem
       public Message getMessage() {
          return message;
       }
   
       // Retorne o número total de mensagens
       public int getNumberOfMessages(){
          return messageFacade.findAll().size();
       }
   
       // Salve a mensagem e, em seguida, retorna a string "theend"
       public String postMessage(){
          this.messageFacade.create(message);
          return "theend";
       }
   

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

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

Observe que o método postMessage retorna a string "theend". A especificação JSF 2.0 permite o uso de regras de navegação implícitas em aplicativos que utilizam a tecnologia Facelets. Nesse aplicativo, nenhuma regra de navegação está configurada em faces-config.xml. Em vez disso, o manipulador de navegação tentará localizar a página adequada no aplicativo. Neste caso, o manipulador de navegação tentará localizar a página nomeada theend.xhtml quando o método postMessage for chamado.

Modificando a página de índice

Neste exercício, serão feitas algumas alterações simples na página index.xhtml para adicionar alguns componentes de interface de usuário. Será adicionado um formulário 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 formulário simples entre as marcações <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>

   O autocompletar de código JSF pode ajudá-lo ao digitar o código.

   
3. Salve as alterações.

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

Criando a página de resultados

Neste exercício, será criada 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 Avançar.
3. Digite theend como o nome de arquivo.
4. Certifique-se de que a opção Facelets está selecionada. Clique em Terminar.
5. Modifique o arquivo ao digitar o seguinte entre as marcações <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 automaticamente adiciona a definição de biblioteca de marcações xmlns:h="http://java.sun.com/jsf/html ao arquivo para os elementos JSF.