Criando um Projeto Web com Hibernate e Eclipse Kepler

O processo de mapear objetos Java para tabelas em Banco de Dados e vice-versa é chamado de "Object-Relational Mapping" (ORM) ou Mapeamento Objeto-Relacional. A Java Persistence API (JPA) prove as facilidades do mapeamento objeto/relacional para os desenvolvedores Java gerenciarem informações relacionais em aplicações Java.

A JPA é uma das possibilidades para o Mapeamento Objeto-Relacional. JPA é uma especificação e atualmente várias implementações estão disponíveis, entre elas Hibernate, EclipseLink e Apache OpenJPA.

JPA também permite ao desenvolvedor mapear, armazenar, atualizar e recuperar informações de uma base de dados relacional para objetos Java e o contrário também é permitido.

Na especificação da JPA também temos a definição de alguns conceitos importantes como: Entidades que são os mapeamentos das tabelas do Banco de Dados, Atributos que equivalem as colunas do Banco de Dados, Relacionamentos entre entidades através de anotações como @OneToOne, @OneToMany, @ManyToOne, @ManyToMany, EntityManager que é responsável por prover operações do Banco de dados e também para o Banco de Dados, encontrar objetos, persisti-los, remove-los, etc, e por fim temos também a Unidade de Persistência (Persistence Units) que define as propriedades de conexão com o banco de dados.

Hibernate

O Hibernate é uma ferramenta ORM open source e é a líder de mercado. A integração do Hibernate com uma aplicação Java é bastante simples e fácil.

Olhando à primeira vista a distribuição do Hibernate possui diversas bibliotecas. Mas para começarmos a desenvolver com Hibernate precisamos configurar o banco de dados, arquivos de mapeamento ou anotações, arquivos de configurações e objetos POJOs da nossa aplicação.

O Hibernate pode ser usado por uma aplicação Java diretamente, ou podemos acessar Hibernate através de outro framework. Podemos chamar o Hibernate através de uma aplicação Swing, Servlet, Portlet, JPS ou qualquer outra aplicação Java que tenha acesso a uma Base de Dados. O Hibernate possui suporte para Java Management Extensions (JMX), J2EE Connector Architecture (JCA), e Java Naming and Directory Interface (JNDI). Com JMX podemos configurar o Hibernate enquanto ele está rodando. Hibernate também pode ser publicado (deployed) como um JCA Connector e ainda usar JNDI para obter uma fábrica de sessão do Hibernate. Por fim, Hibernate usa drivers Java Database Connectivity (JDBC) para acessar base de dados relacionais. Vale ressaltar que Hibernate não sobrepõe o JDBC como uma camada de conectividade de base de dados e sim situa-se um nível acima do JDBC.

Configurações Necessárias para o Hibernate

Para integrarmos a nossa aplicação com Hibernate necessitamos usar algumas bibliotecas Java. A primeira delas é o arquivo jar para o JDBC, devemos procurar uma que seja especifica para o nosso banco de dados relacional. Por exemplo, o postgre possui um jar JDBC específico, o Oracle possui outro e assim por diante. Cada Banco de dados possui seu próprio JAR exclusivo. O Hibernate não inclui drivers JDBC, por isso necessitamos obter esse JAR como um download separado, provavelmente encontrado diretamente no site do fabricante.

Após conseguirmos esse JAR específico da nossa base de dados basta colocarmos junto com o arquivo hibernate3.jar na nossa aplicação. Essa biblioteca possui os pacotes org.hibernate que necessitamos e também vários DTDs e arquivos XML.

O Hibernate também requer várias bibliotecas além do hibernate3.jar. Essas bibliotecas estão incluídas no diretório lib/required da instalação do Hibernate 3.5. Além das bibliotecas encontradas em lib/required, o Hibernate também usa a biblioteca JPA, na qual está incluída no diretório lib/jpa.

O Hibernate também requer uma biblioteca de bytecode para funções. Existem duas bibliotecas bytecode com a distribuição do Hibernate - javassist e CGLib. Com o Hibernate 3.5, necessitamos usar um ou o outro. Para o nosso exemplo usaremos o javassist.

Existem várias bibliotecas opcionais incluídas no Hibernate 3.5. Se construirmos o Hibernate a partir do código, algumas dessas são necessárias para o Hibernate compilar. Outras bibliotecas proveem pools de conexões, funcionalidades de cache, e API JCA.

Por fim, o Hibernate também requer um conjunto de configurações que são frequentemente colocadas num arquivo de propriedades chamado hibernate.properties ou como um arquivo XML chamado hibernate.cfg.xml. Recomenda-se a utilização do arquivo em formato XML.

Criando um Projeto Web com Hibernate

Abaixo iremos criar um novo projeto Web no Eclipse utilizando Hibernate 3.5. Assegure que o seu Banco de Dados esteja instalado e com uma tabela “msgteste” criada. Além disso, crie duas colunas nessa tabela chamadas id (chave primária) e uma coluna mensagem do tipo text ou varchar.

Voltando para a criação do nosso projeto Web primeiramente devemos criar um projeto clicando com o botão direito do mouse em Project Explorer e escolhendo o menu New -> Other conforme ilustra a imagem abaixo:

Figura 1: Criando um novo projeto no Package Explorer.

Na próxima janela que é aberta selecione Web e Dynamic Web Project para criarmos um novo projeto Web. Por fim selecione o botão Next.

Figura 2: Criando um projeto Web no Eclipse.

Na próxima tela coloque o nome do projeto e dê um Next para prosseguir.

Figura 3: Configurando as propriedades do projeto.

Na próxima tela deixamos como está e clicamos em Next para prosseguir.

Figura 4: Configurando detalhes do projeto.

Por fim dê um Finish na próxima tela.

Figura 5: Configurando detalhes finais do projeto.

Agora podemos notar que um novo projeto foi criado na janela Project Explorer. Com o projeto criado já podemos fazer as configurações para acessarmos nossa base de dados e manipularmos a base com o Hibernate. A figura abaixo demonstra o projeto criado na janela Project Explorer.

Figura 6: Projeto criado na janela Project Explorer.

Primeiramente vamos configurar o Hibernate na pasta lib do nosso projeto. Extraia o zip que baixamos anteriormente do Hibernate 3.5 e copie tudo que estiver nas pastas lib/jpa, lib/bytecode/javassist e lib/required para a pasta WebContent/WEB-INF/lib do projeto. Também não esqueça de colocar o jar hibernate3.jar que está na pasta principal do Hibernate (antes da lib).

Figura 7: Pasta lib com os jars do Hibernate.

Agora que já adicionamos as bibliotecas do Hibernate devemos adicionar o arquivo de propriedades no formato XML (hibernate.cfg.xml) conforme mostra a listagem abaixo.

Listagem 1: Arquivo hibernate.cfg.xml com as propriedades configuradas.

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
		<property name="hibernate.connection.url">jdbc:postgresql://localhost:5432/BancoTestePostgre</property>
		<property name="hibernate.connection.username">username</property>
		<property name="hibernate.dialect">org.hibernate.dialect.HSQLDialect</property>
		<property name="connection.password">senhadefault</property>
		<property name="show_sql">true</property>

		<mapping class="com.exemplo.entidade.Mensagem"/>

	</session-factory>
</hibernate-configuration>

Podemos notar acima que estamos nos conectando a um banco postgre 8 e configuramos o nome da base de dados e seu nome de usuário e senha. Na propriedade configuramos as entidades que serão mapeadas da base de dados para os nossos objetos java e vice-versa.

Também não podemos esquecer de adicionar a biblioteca do postgre que é fornecido pelo próprio provedor. Portanto, feito download do driver de acesso ao banco de dados ela deve ser adicionada na pasta lib do nosso projeto. A figura abaixo mostra a imagem do nosso projeto com o driver adicionado na pasta lib e o arquivo de propriedades adicionado.

Figura 8: Adicionado o arquivo de propriedade e o driver de acesso ao postgre.

Agora vamos criar um novo pacote para adicionarmos as nossas classes de acesso ao Banco de Dados usando Hibernate e o mapeamento de uma tabela do Banco de Dados.

Clique com o botão direito do mouse em cima da pasta src do projeto e seleciona a opção New e por fim Package conforme ilustrado na figura abaixo:

Figura 9: Criando um novo pacote no Eclipse.

Digite o nome do pacote como “com.exemplo.entidade” que é o pacote onde ficarão as nossas entidades mapeadas.

Figura 10: Configurando um pacote.

Por fim, clique em Finish. Crie também outro pacote chamado “com.exemplo.acessobd” seguindo o mesmo processo descrito acima.

Dentro do pacote “com.exemplo.entidade” crie a classe Mensagem abaixo que é a tabela “msgteste” que está criada no nosso Banco de dados no postgre.

Listagem 2: Classe Mensagem mapeando a tabela msgteste do banco de dados.

package com.exemplo.entidade;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="msgteste", schema="public")
public class Mensagem implements java.io.Serializable {

	@Column(name="\"msg\"")
	private String msg;
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name="\"id\"")
	private Integer id;

	

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

}

Podemos notar que essa tabela também possui duas colunas chamadas id e msg sendo que id é uma chave primária. Outra situação a notar é a presença de \ seguido de aspas em @Column(name="\"msg\""). Isso se faz necessário apenas quando usamos um Banco de dados postgre, por algum motivo interno ele requer que se escape as aspas. Normalmente teríamos apenas um mapeamento como abaixo:

@Column(name="msg")
private String msg;

Agora devemos criar uma classe dentro do pacote “com.exemplo.acessobd” que fará o acesso a base de dados através do Hibernate. Crie a classe abaixo:

Listagem 3: Classe de acesso ao Banco de Dados através do Hibernate.

package com.exemplo.acessobd;

import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;

import com.exemplo.entidade.Mensagem;


public class TesteBanco {

	public TesteBanco() {
		
	}
	
	public void teste() {		
		List<Mensagem> list= null;
		
		SessionFactory sessions = new AnnotationConfiguration().configure().buildSessionFactory();
		Session session = sessions.openSession();
		
		try {
			session.beginTransaction();
			list = session.createQuery("select msg from Mensagem msg").list();
			session.getTransaction().commit();
			
			for (Mensagem msg : list) {
				System.out.println(msg.getMsg());
			}

		} catch ( HibernateException e ) {
			if ( session.getTransaction() != null )
				session.getTransaction().rollback();
		} finally {
			session.close();
		}
				
	}
	
}

Podemos notar que existem alguns erros na nossa classe. Para concertar esses problemas devemos adicionar as classes do Hibernate no classpath do nosso projeto. Para isso clique com o botão direito do mouse em cima do nome do nosso projeto e clique em Propriedades. Por fim, clique em Java Build Path.

Figura 11: Acessando as propriedades do Projeto.

Figura 12: Acessando o Java Build Path do projeto.

Por fim, selecione “Add Jars...” e adicione as bibliotecas da pasta lib e clique em OK conforme ilustra a figura abaixo:

Figura 13: Adicionando as bibliotecas no classpath do projeto.

Note que agora os erros não aparecem mais. Agora vamos criar uma simples página index.jsp que fará o acesso a nossa classe de teste criada e exibirá as mensagens armazenadas no Banco de Dados. Segue abaixo o código da página index.jsp que deve ser colocada na pasta WebContent.

Listagem 4: Página de teste para nosso projeto web.

<%@page import="com.exemplo.acessobd.TesteBanco"%>
<html>
<body>

<%

TesteBanco testeBanco = new TesteBanco();
testeBanco.teste();

%>

</body>
</html>

Não esqueça de ter instalado o Apache Tomcat 7. Para acessar o nosso projeto digite localhost:8080/ProjetoHibernate/index.jsp

Caso o seu projeto reclame do slf4j tente baixar a versão slf4j-api-1.7.5.jar e tente restartar o servidor novamente.

Após a execução da url no browser verifique o console do eclipse e veja se as mensagens do Banco de dados foram listadas. Assim terminamos o acesso ao Banco de dados usando o Hibernate. Muitas funcionalidades e características do Hibernate serão vistos nos artigos posteriores, porém já demos um grande passo configurando o acesso ao nosso Banco de dados usando o Hibernate.

Conclusão

Neste artigo vimos o que é JPA e Hibernate. Também configuramos um projeto web desde o inicio e acessamos uma base de dados postgre utilizando o Hibernate 3.5.

Bibliografia

1. Jeff Linwood and Dave Minter. An introduction to persistence using Hibernate 3.5, Second Edition. Apress.
2. Steve Perkins. Hibernate Search by Example: Explore the Hibernate Search system and use its extraordinary search features in your own applications. Packt Publishing.