Série Spring:Spring 3 com Hibernate 3.x

Olá Pessoal,

No post de hoje, veremos como integrar Spring com Hibernate. Ou seja, como podemos deixar tudo ao comando do Spring?  Deixar ele abrir ,fechar, commit , dar roll back nas transações? Diretamente o Spring não faz isso, mas ele delega para um cara que pode fazer isso. A moral da história que ao invés de nós programadores ter que dar beginTransaction, isso serrá feito nos bastidores. No exemplo a seguir fazeremos apenas um insert no banco de dados.

Lets go…

 

Requisitos

Antes de mais nada certifique que vc 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 na massa agora.

Starting…

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:

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns:context=“http://www.springframework.org/schema/context”

xmlns:tx=“http://www.springframework.org/schema/tx”

xsi:schemaLocation=“http://www.springframework.org/schema/beans

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

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

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

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

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd”>

 

Se vc vem acompanhando os outros posts 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.

<!– buscando os beans –>

<context:component-scan base-package=“*” />

<!– transaction via annotations –>

<tx:annotation-driven />

<!– Translate exception –>

<bean class=“org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor”/>

 Aqui  temos um cara novo que é o PersistenceExceptionTransalationPostProcessor que é 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 conectado em qual url e com o usuário xxxx, com a senha yyyyy.

<bean id=“dataSource” class=“org.springframework.jdbc.datasource.DriverManagerDataSource”>

<property name=“driverClassName” value=“com.mysql.jdbc.Driver”/>

<property name=“url” value=“jdbc:mysql://localhost/test”/>

<property name=“username” value=“root”/>

<property name=“password” value=“bahia”/>

</bean>

 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:

<bean id=“sessionFactory” class=“org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean”>

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

<property name=“dataSource” ref=“dataSource”/>

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

<property name=“packagesToScan” value=“br.com.camilolopes.model.bean”/>

<!– as configs do orm – hibernate –>

<property name=“hibernateProperties”>

      <props>

<prop key=“hibernate.dialect”>org.hibernate.dialect.MySQL5InnoDBDialect”</prop>

      <prop key=“hibernate.hbm2ddl.auto”>update</prop>

      </props>

</property>

</bean>

 

Agora precisamos criar o cara que vai gerenciar as transaction no nosso caso como estamos usando o Hibernate será o HibernateTransactionManager:

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

<bean id=“transactionManager” class=“org.springframework.orm.hibernate3.HibernateTransactionManager”>

<property name=“sessionFactory” ref=“sessionFactory”/>

</bean>

 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.

public interface ProductDAO {

      void save(ProductTech product);

}

 Agora vem a classe que implementa a interface:

@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”);

      }

}

 

E a nossa entidade:

@Entity

public class ProductTech implements Serializable{

      @Id

      @GeneratedValue

      private Long id;

      private String nameProduct;

                //getters/setters ommitidos

 

Testando

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

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);

      }

}

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 post.

Abraços see ya!!