Olá, pessoal! No artigo de hoje veremos como integrar Spring com Hibernate. Ou seja, como podemos deixar tudo ao comando do Spring.

Como fazer pra ele abrir, fechar, commit, dar roll back nas transações? Diretamente, o Spring não faz isso, mas ele delega para quem o faça. A moral da história é que, ao invés de nós, programadores, termos que dar beginTransaction, isso será feito nos bastidores. No exemplo a seguir faremos apenas um insert no banco de dados.

Antes de começar a falar pra valer do assunto, quero abrir um parênteses aqui para falar de uma promoção que consegui junto à editora dos meus livros: até o dia 14 quem comprar 2 livros meus leva o terceiro de graça!  Você pode levar o Guia do Exame SCJP, o TDD na Prática e leva de graça o JEE com Frameworks. Gostou? Então veja os detalhes dessa super promoção aqui!

Bom, vamos ao que interessa – a integração do Spring com Hibernate!

Requisitos

Antes de mais nada, certifique-se que você tem os .jars baixados:

• Mysql 5 .x;
• Hibernate 3.6;
• Spring 3.x;
• AOP 1.x;
• AspectJ;
• commons-logging 1.x.

Depois de garantir que você tem todos os .jars, mãos à obra!

O primeiro passo é que nosso exemplo será um Java Application. O objetivo é fazer a integração de maneira mais simples e funcional possível. Então, crie seu Java Project e deixe conforme a imagem a seguir:

No final, teremos os seguintes packages e classes:

Por onde começar?

Eu gosto sempre de iniciar pela parte de configuração, assim, quando vou começar o desenvolvimento não preciso voltar para configurar – exceto quando é algo bem pontual. Então, iniciaremos pelo arquivo de configuração do Spring. No package config, crie um springconfiguration.xml.

Vou colocar o arquivo por partes e explicando (além disso coloquei uns comentários no .xml para facilitar o entendimento):

[xml]

[/xml]

Se você vem acompanhando os outros artigos e já conhece o básico do Spring, deve conhecer o beans. A única coisa de novo que adicionamos aqui foi o xmlns tx para as transaction, que veremos mais na frente a sua importância. Portanto, deixe seu beans conforme o código acima.

[xml]
<!– buscando os beans –>

<!– transaction via annotations –>

<!– Translate exception –>

[/xml]

Aqui  temos um cara novo que é o PersistenceExceptionTransalationPostProcessor, responsável por “traduzir” as exceções checked em unchecked do Spring, assim não precisamos ficar tratando na nossa application. Habilitamos que as transaction serão via annotation, ou seja, o Spring vai procurar pela annotation @Transaction. E também informamos que todo bean do Spring será via annotation e base de package colocamos todos.

DataSource

Agora precisamos criar um DataSource, assim vamos dizer a que banco estaremos conectados, em qual url e com o usuário xxxx e senha yyyyy.

[xml]

[/xml]

SessionFactory

Agora precisamos configurar nossa sessionFactory. Nesse caso, estamos dizendo que vamos usar annotation  para persistência. Lembra que fazíamos isso diretamente no Hibernate na hora de criar a sessionFactory (new annotationXXX)? Aqui há alguns pontos importantes:

[xml]

<!– informando o datasource, de onde vem a conexão? –>

<!– onde estão as classes com annotation? informando aqui –>

<!– as configs do orm – hibernate –>

org.hibernate.dialect.MySQL5InnoDBDialect”
update
[/xml]

Agora precisamos criar quem vai gerenciar as transactions – no nosso caso, como estamos usando o Hibernate, será o HibernateTransactionManager:

[xml]
<!– esse é o cara que gerencia as transactions –>

[/xml]

Pronto! Terminamos a parte de configuração. Vamos agora para parte Java.

Development

No package dao criaremos uma interface. Nossa aplicação vai salvar um produto apenas.

[java]
public interface ProductDAO {
void save(ProductTech product);
}
[/java]

Agora vem a classe que implementa a interface:

[java]
@Repository
public class ProductDAOImpl implements ProductDAO {
private SessionFactory sessionFactory;

@Autowired
public ProductDAOImpl(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}

private Session currentSession(){
return sessionFactory.getCurrentSession();
}

@Override
//para execução deste método é requerido uma transação, é isso que estamos dizendo aqui
@Transactional(propagation=Propagation.REQUIRED,readOnly=false)
public void save(ProductTech product) {
currentSession().save(product);
System.out.println("product saved with sucess");
}
}
[/java]

E a nossa entidade:

[java]
@Entity
public class ProductTech implements Serializable{
@Id
@GeneratedValue
private Long id;
private String nameProduct;
//getters/setters ommitidos
[/java]

Testando

Vamos criar uma classe com método main para testar:

[java]
public class MainTestDAO {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("config/springconfiguration.xml");
ProductDAO bean = (ProductDAO) applicationContext.getBean("productDAOImpl");
ProductTech product= new ProductTech();
product.setNameProduct("tablet samsung galaxy");
bean.save(product);
}
}
[/java]

Antes de rodar, garanta que o banco está rodando.  Ao executar:

Fácil, não? Nos preocupamos mais com a parte de negócio. Toda aquela parte chata de transação, por exemplo, está sendo cuidada nos bastidores.

Bom, vou ficando por aqui. E espero que tenham gostado do artigo! E lembrem-se da promoção “leve 3 pague 2” – veja os detalhes dessa super promoção aqui!

Abraços!