Integrando Hibernate3 ao Spring e DAO Generico

Bom, galera como prometido neste post irei continuar o tópico anterior adicionando o suporte ao Hibernate em nosso WebService. O Hibernate é um Framework podereso de mapeamento objeto-relacional muito conhecido e utilizado, não pretendo entrar em detalhes sobre como configurar o Hibernate nem como mapear seus objetos para acessar o banco, porém, caso tenha dúvidas acesse este tutorial que mostra como tirar proveito deste freamework e caso tenha alguma dúvida pode deixe um comentário ou enviar um email que tentarei ajudar.

O Spring possui um módulo para acesso a banco de dados extremamente robusto, podemos  fazer controle de transações via AOP, cache, gerenciar pool de conexões diretamente no contexto do Spring sem se preocupar com qual tecnologia que está implementada e caso seja necessário podemos trocar o modo de acesso sem precisar modificar todo o projeto, nos dando assim maior mobilidade e escalabilidade. O Hibernate porém não é o único framework que o Spring provê integração, o Spring se integra facilmente a diversos frameworks de persistência como JPA, iBATIS, JDBC e proprio Hibernate que iremos demonstrar neste tutorial. Mostrarei também como desenvolver um DAO generico para o Hibernate que nos da acesso as principais funcões básicas de um CRUD em apenas uma interface, evitando repetição de código. Modificaremos um pouco o projeto anterior para poder demonstrar todas as funcionalidades dessa integração. Primeiramente precisamos modificar nosso POM para baixar todas as dependências necessárias:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.wordpress.dchohfi</groupId>
	<artifactId>ServiceSample</artifactId>
	<packaging>war</packaging>
	<version>2.0</version>
	<developers>
		<developer>
			<id>dchohfi</id>
			<name>Diego Chohfi</name>
			<email>diegochohfi@hotmail.com</email>
			<url>http://dchohfi.wordpress.com</url>
		</developer>
	</developers>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>maven-jetty-plugin</artifactId>
				<configuration>
					<scanIntervalSeconds>10</scanIntervalSeconds>
				</configuration>
			</plugin>
		</plugins>

	</build>
	<dependencies>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-bundle</artifactId>
			<version>2.2.3</version>
			<exclusions>
				<exclusion>
					<groupId>org.springframework</groupId>
					<artifactId>spring-beans</artifactId>
				</exclusion>
				<exclusion>
					<groupId>org.springframework</groupId>
					<artifactId>spring-context</artifactId>
				</exclusion>
				<exclusion>
					<groupId>org.springframework</groupId>
					<artifactId>spring-core</artifactId>
				</exclusion>
				<exclusion>
					<artifactId>asm</artifactId>
					<groupId>asm</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>xerces</groupId>
			<artifactId>xercesImpl</artifactId>
			<version>2.9.1</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring</artifactId>
			<version>2.5.6</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate</artifactId>
			<version>3.2.6.ga</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-annotations</artifactId>
			<version>3.3.0.ga</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-commons-annotations
			</artifactId>
			<version>3.3.0.ga</version>
		</dependency>
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.2.2</version>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.15</version>
		</dependency>
		<dependency>
			<groupId>commons-collections</groupId>
			<artifactId>commons-collections</artifactId>
			<version>3.2.1</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.8</version>
		</dependency>
	</dependencies>
</project>

Verifique que além das dependências do Spring e do Apache CXF, temos também as dependências do Hibernate. Note que adicionei como dependência o commons-dbcp da Apache, iremos utiliza-lo para gerenciar nosso pool de conexões ao banco de dados, o Hibernate por default vem com o c3p0 para gerenciar o pool de conexões, porém eu prefiro o commons-dbcp pois já tive problemas com o c3p0 portanto recomendo a vocês utilizarem. O bacana de se utilizar o commons-dbcp é que podemos ter maior controle sobre como as conexões são abertas e fechadas no Hibernate e também evitar que conexões fiquem abertas sem serem utilizadas. Vamos ao arquivo de configuração do Spring.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cxf="http://cxf.apache.org/core"
	xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:jaxrs="http://cxf.apache.org/jaxrs"
	xsi:schemaLocation="

http://www.springframework.org/schema/beans


http://www.springframework.org/schema/beans/spring-beans-2.5.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context-2.5.xsd


http://www.springframework.org/schema/tx


http://www.springframework.org/schema/tx/spring-tx-2.5.xsd


http://cxf.apache.org/core


http://cxf.apache.org/schemas/core.xsd


http://cxf.apache.org/jaxws


http://cxf.apache.org/schemas/jaxws.xsd


http://cxf.apache.org/jaxrs


http://cxf.apache.org/schemas/jaxrs.xsd">

	<!-- Carrega as configurações presentes nos jars do Apache CXF -->
	<import resource="classpath:META-INF/cxf/cxf.xml" />
	<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
	<import resource="classpath:META-INF/cxf/cxf-extension-jaxrs-binding.xml" />
	<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

	<!-- Endpoint WSDL para o Apache CXF -->
	<!-- Dizemos o endereço, o ID do serviço, em qual bean ele depende -->
	<jaxws:endpoint id="service" depends-on="serviceImpl"
		implementor="#serviceImpl" address="/service">
	</jaxws:endpoint>

	<!-- Mapeamento do REST para o Apache CXF -->
	<jaxrs:server id="myService" address="/rest">
		<jaxrs:serviceBeans>
			<ref bean="serviceImpl" />
		</jaxrs:serviceBeans>
		<!-- Aqui declaramos o nosso Mapper para a Exception -->
		<jaxrs:providers>
			<ref bean="ClienteExceptionMapper" />
		</jaxrs:providers>
	</jaxrs:server>

	<!-- Referencia ao bean Mapper da nossa Exception -->
	<bean id="ClienteExceptionMapper" class="com.wordpress.dchohfi.exception.ClienteExceptionMapper" />

	<!-- Bean que implementa o endpoint do nosso webservice -->
	<bean id="serviceImpl" class="com.wordpress.dchohfi.service.ServiceImpl">
		<property name="clienteDAO" ref="clienteHibernateDao" />
	</bean>

	<!-- Bean abstrato para evitar repetição de código -->
	<bean id="baseSessionFactory" abstract="true">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<!-- Implementacao da interface ClienteDAO -->
	<bean id="clienteHibernateDao"
		class="com.wordpress.dchohfi.model.dao.hibernate.ClienteHibernateDAO"
		parent="baseSessionFactory" />

	<!-- Carregar arquivos de configuracao -->
	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:/jdbc.properties</value>
			</list>
		</property>
	</bean>

	<!--
		Bean com as configuracoes de conexao com o banco, estamos utilizando o
		CommonsDBCP da Apache para gerenciar nosso pool de conexão
	-->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="${database.driver}" />
		<property name="url" value="${database.url}" />
		<property name="username" value="${database.user}" />
		<property name="password" value="${database.pass}" />
		<property name="initialSize" value="${database.initConnections}" />
		<property name="maxActive" value="${database.maxActive}" />
		<property name="maxIdle" value="${database.maxIdle}" />
		<property name="removeAbandoned" value="${database.removeAbandoned}" />
	</bean>

	<!-- Configuracoes de uma fabrica de sessões -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource">
			<ref local="dataSource" />
		</property>
		<property name="annotatedClasses">
			<list>
				<value>com.wordpress.dchohfi.model.entity.Cliente
				</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.MySQLInnoDBDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">false</prop>
			</props>
		</property>
	</bean>
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory">
			<ref local="sessionFactory" />
		</property>
	</bean>
	<tx:annotation-driven transaction-manager="transactionManager" />
</beans>

Leia atentamente os comentários feitos no decorrer do arquivo pois desta vez temos uma configuração mais avançada do Spring, estamos utilizando diversos recursos disponíveis no framework, um deles é o PropertyPlaceholderConfigurer onde podemos montar um arquivo .properties fora do nosso contexto do Spring e colocar diversas configurações importantes lá, gosto deste método pois podemos colocar em uma pasta separada, por exemplo, os dados de conexão com o banco, assim qualquer pessoa pode modificar os dados de configuração se for necessário, sem precisar entender o arquivo de configuração do Spring.

jdbc.properties:
database.driver=com.mysql.jdbc.Driver
database.url=jdbc:mysql://localhost:3306/test
database.user=root
database.pass=serviceSample
database.initConnections=1
database.maxActive=10
database.maxIdle=5
database.removeAbandoned=true

A integração do Spring ao Hibernate3 começa quando configuramos nosso sessionFactory, observe que utilizamos a classe AnnotationSessionFactoryBean, aqui utilizamos um dataSource configurado previamente, dizemos também ao Spring quais são as entidades anotadas com @Entity entre outras diversas configurações disponíveis. Nós criamos então um Bean abstrato dentro do contexto do Spring para evitar repetição de código, nosso Bean clienteHibernateDao precisa então apenas herdar nosso bean abstrato para obter a sessionFactory, simples não? No final do arquivo temos também um bean de controle de transações, não pretendo aprofundar nesse assunto pois criarei outro tutorial abordando apenas controle de transações no Spring pois é um assunto muito bacana. Vamos ao nosso DAO generico integrado ao Spring.

Precisamos primeiramente de uma interface contendo as operações basicas de um CRUD(criar, ler, atualizar e deletar):

package com.wordpress.dchohfi.model.dao;

public interface GenericDAO<T, ID extends Serializable> {
    T findById(ID id);
    List<T> listAll();
    T save(T entity);
    void delete(T entity);
}

Agora vem a “mágica” da integração do Hibernate ao Spring e o DAO generico:

package com.wordpress.dchohfi.model.dao.hibernate;

//Adicionando herança ao HibernateDaoSupport temos diversas funcionalidades do Spring
//junto ao Hibernate, implementamos também nosso DAO generico para ter mobilidade.
public class HibernateDAOGenerico<T, ID extends Serializable> extends
	HibernateDaoSupport implements GenericDAO<T, ID> {

    private static Log LOG = LogFactory.getLog(HibernateDAOGenerico.class);

    // Nosso construtor vai setar automaticamente via Reflection qual classe
    // estamos tratando.
    @SuppressWarnings("unchecked")
    public HibernateDAOGenerico() {
	this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
				.getGenericSuperclass()).getActualTypeArguments()[0];
    }
    
    // Classe que será persistida.
    private Class<T> persistentClass;
    public Class<T> getPersistentClass() {
	return this.persistentClass;
    }
    
    @Override
    public void delete(T entity) {
	try {
	    this.getHibernateTemplate().delete(entity);
	} catch (final HibernateException ex) {
	    HibernateDAOGenerico.LOG.error(ex);
	    throw convertHibernateAccessException(ex);
	}
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public T findById(ID id) {
	try {
	    return (T) this.getHibernateTemplate().get(getPersistentClass(), id);
	} catch (final HibernateException ex) {
	    HibernateDAOGenerico.LOG.error(ex);
	    throw convertHibernateAccessException(ex);
	}
    }
    
    @Override
    public List<T> listAll() {
	try {
	    return this.getHibernateTemplate().loadAll(getPersistentClass());
	} catch (final HibernateException ex) {
	    HibernateDAOGenerico.LOG.error(ex);
	    throw convertHibernateAccessException(ex);
	}
    }
    
    @Override
    public T save(T entity) {
	try {
	    this.getHibernateTemplate().save(entity);
	    return entity;
	} catch (final HibernateException ex) {
	    HibernateDAOGenerico.LOG.error(ex);
	    throw convertHibernateAccessException(ex);
	}
    }
    
    protected List<T> findByCriteria(Criterion... criterion) {
	try {
	    Criteria crit = this.getHibernateTemplate()
	    			.getSessionFactory()
	    			.getCurrentSession()
	    			.createCriteria(getPersistentClass());
	    for (Criterion c : criterion) {
		crit.add(c);
	    }
	    return crit.list();
	} catch (final HibernateException ex) {
	    HibernateDAOGenerico.LOG.error(ex);
	    throw convertHibernateAccessException(ex);
	}
    }
}

O nosso DAO generico não precisa saber qual classe ele está relacionando, ele precisa apenas fazer as operações básicas de um CRUD. Porém com o suporte ao Hibernate temos algo a mais além das operações básicas. Verifique que o método findByCriteria pode receber ou não um Array de Criterion onde podemos fazer buscas mais específicas no banco de dados.

package com.wordpress.dchohfi.model.dao.hibernate;

public class ClienteHibernateDAO extends HibernateDAOGenerico<Cliente, Long>
	implements ClienteDAO {

    @Override
    public List<Cliente> findClietsWithPhone() {
	return findByCriteria(Expression.isNotNull("telefone"), Expression.ne("telefone", ""));
    }
}

Nossa implementação de ClienteHibernateDao consegue consultar por exemplo todos os Clientes que possuem telefone, dessa forma você consegue ter um DAO generico para as operações básicas, mas também tem a opção de fazer buscas mais avançadas via Criteria. Agora você pode ter diversos DAO’s utilizando apenas uma classe, acredite em mim, você da pra economizar muito tempo com isso. O Spring também nos da suporte para tratar as excecões lançadas pelo Hibernate, fica mais fácil saber o que aconteceu e porque aconteceu e com o controle de transações você não precisa se preocupar em dar rollback caso algum problema aconteça

Veja também que nossa interface de acesso ao serivço não mudou muito:

package com.wordpress.dchohfi.service;

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@WebService(endpointInterface = "com.wordpress.dchohfi.service.Service")
public class ServiceImpl implements Service {

    private ClienteDAO clienteDao;

    @Override
    public Cliente getCliente(Long id) throws ClienteException {
	Cliente cliente = this.clienteDao.findById(id);
	if (cliente == null)
	    throw new ClienteException("Nenhum usuario com id" + id + " encontrado!");
	return cliente;
    }

    @Override
    public Collection<Cliente> getClientes() {
	return this.clienteDao.listAll();
    }

    @Override
    public Collection<Cliente> getClientesWithPhone() {
	return this.clienteDao.findClietsWithPhone();
    }

    @Override
    public Cliente saveCliente(Cliente cliente) {
	return this.clienteDao.save(cliente);
    }

    public void setClienteDAO(ClienteDAO clienteDao) {
	this.clienteDao = clienteDao;
    }
}

Note como temos todas as operações de acesso a dados a partir da assunatura da interface, nós não sabemos nem precisamos saber o que acontece. Não se preocupe com a anotação de @Transactional pois irei explicar em outro post, mas aguarde que o Spring vai se tornar ainda mais interessante.

É importante entender que o nosso projeto ainda esta funcionando a partir de interfaces, você por exemplo não é obrigado ao utilizar o Hibernate como framework de acesso a dados, utilizando a interface generica você pode ter acesso via JDBC normal caso você ache necessário, modificando apenas a parte de acesso ao dado.

Acho que isso é tudo, temos agora mais uma demonstração de quanto o Spring Framework é poderoso, integrando ele a outros frameworks podersos temos uma forma fácil e rápida de se implementar  aplicações robustas. Utilizei o MySQL para banco de dados e caso você tenha problema com a lib da Sun você precisa fazer o download dela diretamente no site para aceitar os termos. Qualquer outra dúvida deixe um comentário ou envie um email.

Obrigado e espero que seja util!