Usando Hibernate com a API de persistência Java

Se estiver usando a API de persistência Java, você poderá escolher o provedor de persistência que deseja usar em seu aplicativo. O servidor da aplicação GlassFish inclui o provedor de persistência Toplink da Oracle, mas você pode configurar facilmente seu aplicativo para usar o provedor de persistência do Hibernate e desenvolver rapidamente um aplicativo que acesse um banco de dados com a API de persistência Java.

Antes de começar este tutorial, talvez você queira se familiarizar com os seguintes documentos:

• Documentação do Hibernate em hibernate.org.
• Gerando um aplicativo CRUD do JavaServer Faces a partir de um banco de dados

Conteúdo

• Criando o projeto de aplicação Web
• Criando as classes de entidade e a unidade de persistência
• Criando as páginas JSP
• Testando a aplicação Web

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

Software ou recurso	Versão necessária
NetBeans IDE	6.5 Java
Java Development Kit (JDK)	versão 6 ou versão 5
Servidor da aplicação GlassFish	2.1

Observação. Antes de começar, você precisa registrar o servidor da aplicação no IDE. Se o servidor da aplicação não estiver registrado no IDE, registre-o, escolhendo Ferramentas > Servidores e clicando no botão Adicionar servidor. Você pode ver todos os servidores da aplicação registrados, abrindo a janela Serviços e expandindo o nó Servidores.

Criando o projeto de aplicação Web

Neste exercício, você criará um projeto de aplicação Web simples para acessar o banco de dados de amostra. A aplicação usará uma interface da Web JSF para visualizar e modificar os dados de forma que você especifique o framework JSF ao criar o projeto.

1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N). Na categoria Java Web, selecione Aplicação Web.
2. Digite HibernateApp para o Nome do projeto e especifique uma localização.
3. Desmarque a opção Usar pasta dedicada, se ela estiver selecionada.
   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.
   Clique em Próximo. Clique em Próximo.
4. Defina o servidor como GlassFish e defina a versão de Java EE como Java EE 5. Clique em Próximo.
5. Selecione o framework JavaServer Faces (NÃO o Visual Web JavaServer Faces). Clique em Terminar.

Quando você clica em Terminar, o IDE cria o projeto e abre welcomeJSF.jsp no editor.

Criando as classes de entidade e a unidade de persistência

Você agora usa o assistente para Classes de entidade do banco de dados para criar classes de entidade com base nas tabelas incluídas no banco de dados de amostra. O banco de dados de amostra é um banco de dados JavaDB, mas você pode usar o assistente para gerar rapidamente as classes de entidade a partir de qualquer banco de dados suportado, caso a conexão do banco de dados esteja registrada no IDE.

Quando cria as classes de entidade no assistente, você também criará uma unidade de persistência onde especifica como as entidades são gerenciadas. O IDE inclui suporte a Hibernate e o Hibernate é listado como uma das opções do provedor de persistência. Quando você escolhe o Hibernate como o provedor de persistência, o IDE adiciona automaticamente as bibliotecas necessárias do Hibernate para o projeto.

1. Na janela Projetos, clique com o botão direito do mouse no nó do projeto e escolha Novo > Classes de entidade do banco de dados. Na lista suspensa Fonte de dados, selecione o banco de dados jdbc/sample. Caso seja solicitado um nome de usuário e senha, use app e app. Selecione a tabela CUSTOMER na lista, clique em Adicionar e clique em Próximo.
2. Deixe as tabelas e os nomes de classe como padrão, e digite hibernatesample.db para o Pacote.
3. Clique no botão Criar unidade de persistência.
4. Escolha Hibernate como o provedor de persistência, e selecione Nenhuma como a estratégia de geração de tabela. Preserve o nome da unidade de persistência padrão. Clique em Criar para fechar a caixa de diálogo.
   
   Clique em Próximo no assistente.
5. Selecione eager na lista suspensa Obter associação.
6. Selecione java.util.Set na lista suspensa Tipo de coleção. Clique em Terminar.
   

Quando você clica em Terminar, o IDE cria uma classe de entidade das tabelas selecionadas e cria persistence.xml sob o nó Arquivos de configuração. Você pode abrir persistence.xml para visualizar os detalhes da unidade de persistência.

Como você escolheu o Hibernate como o provedor de persistência, o IDE também adicionou as bibliotecas do Hibernate ao projeto. Você pode expandir o nó Bibliotecas na janela Projetos para visualizar as bibliotecas do Hibernate que o IDE adicionou ao projeto.

Você pode modificar persistence.xml para adicionar algumas propriedades específicas do Hibernate.

1. Clique duas vezes em persistence.xml para abrir o arquivo no editor e clique no botão XML na parte superior do editor para alternar para a visualização XML.
2. Modifique o XML para adicionar a seguinte propriedade.
   

     <persistence-unit name="HibernateApp" transaction-type="JTA">
       <provider>org.hibernate.ejb.HibernatePersistence</provider>
       <jta-data-source>jdbc/sample</jta-data-source>
       <properties>
           <property name="hibernate.show_sql" value="true" />
       </properties>
     </persistence-unit>
   </persistence>

   Essa propriedade faz com que todas as instruções SQL sejam impressas no arquivo de log do servidor da aplicação.

3. Salve as alterações.

Criando as páginas JSP

Agora você pode usar o assistente CRUD JPA JSF para gerar rapidamente as páginas JSF para exibir e modificar os dados. No assistente, selecione as classes de entidade e para cada classe de entidade, o assistente irá gerar o seguinte:

• uma classe de controlador JPA
• uma classe de controlador JSF
• uma classe de conversor JSF
• um diretório contendo quatro arquivos JSP (Detail.jsp, Edit.jsp, List.jsp, New.jsp)
• elementos de bean gerenciado, elementos de conversor e regras de navegação para a classe em faces-config.xml

O assistente também gera automaticamente as classes e as classes de entidade usadas pelas classes geradas.

1. Clique com o botão direito do mouse no nó do projeto e escolha Novo > Páginas JSF de classes de entidade.
2. Clique em Adicionar tudo para adicionar as classes Customer e DiscountCode à lista de classes selecionadas. Clique em Próximo.
3. Digite hibernatesample.db para o pacote do controlador JPA.
4. Digite hibernatesample.jsf para o pacote de classes JSF. Clique em Terminar.

Quando você clica em Terminar, o IDE cria as classes do controlador JPA de cada classe de entidade no pacote hibernatesample.db. Cada classe do controlador manipula as operações da classe de entidade correspondente, incluindo a criação, edição e destruição de instâncias da classe de entidade por meio da API de persistência Java. O IDE gerou classes de exceção no pacote hibernatesample.db.exceptions para manipular exceções lançadas pelas classes do controlador JPA.

Para cada classe de entidade, o IDE também criou o conversor JSF e as classes do controlador no pacote hibernatesample.jsf. Cada classe do conversor JSF implementa a interface javax.faces.convert.Converter definida pelo JavaServer Faces e converte as instâncias da classe de entidade correspondente para objetos String e vice-versa. O IDE gerou três classes de utilitário no pacote hibernatesample.jsf.util contendo a lógica JSF geral usada pelos controladores JSF.

Se expandir o nó Páginas da Web, você poderá ver que o IDE gerou uma pasta de cada uma das classes de entidade. Cada pasta contém os arquivos Detail.jsp, Edit.jsp, List.jsp e New.jsp. O IDE também modificou welcomeJSF.jsp para inserir links em cada uma das páginas List.jsp.

Se expandir o nó Arquivos de configuração e abrir faces-config.xml no editor XML, você poderá ver que o IDE inseriu o bean gerenciado e os elementos de conversor de cada controlador e classes de conversor. O IDE também inseriu um elemento de regra de navegação de cada JSP, indicando o resultado lógico que faz com que o aplicativo navegue para esse JSP.

Depois de criar as páginas JSF e modificar o código nas classes do controlador, você deve poder executar e testar o aplicativo.

Testando o projeto

Agora precisamos executar o projeto para testar se o aplicativo está funcionando corretamente.

1. Clique com o botão direito do mouse no nó do projeto e escolha Executar projeto. O IDE inicia o servidor da aplicação, constrói e implanta o aplicativo, e mostra welcomeJSF.jsp no navegador da Web externo.
2. Clique no link Mostrar todos os itens do consumidor e você deverá ver a seguinte página da Web:
   
3. Use o link Novo consumidor para criar um consumidor. Em seguida, verifique o log do servidor, clicando com o botão direito do mouse no nó do servidor da aplicação na janela Serviços e escolhendo Visualizar log do servidor. O SQL para criar o consumidor deve ser listado no log do servidor.

Próximas etapas

Para obter mais informações sobre o uso do NetBeans IDE 6.5 para desenvolver aplicações Web usando o Hibernate e a API de persistência Java, consulte os seguintes recursos:

• Trilha do aprendizado da aplicação Web de Java
• Trilha do aprendizado das aplicações de serviço Web e EJB
• Gerando um aplicativo CRUD do JavaServer Faces a partir de um banco de dados

Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimentos dos recursos de desenvolvimento de Java EE do NetBeans IDE, inscreva-se na lista de endereçamento de .