Troubleshooting PersistenceExceptionTranslationInterceptor Spring

 

Olá Pessoal,

O troubleshooting de hoje é para qume está sobrendo com o Hibernate e Spring.  Vamos ver os erros e como podemos resolver. 

Caused by: java.lang.IllegalStateException: No persistence exception translators found in bean factory. Cannot perform exception translation.

                at org.springframework.dao.support.PersistenceExceptionTranslationInterceptor.detectPersistenceExceptionTranslators

Esse erro acontece normalmente quando estamos usando a versão do Hibernate 4 no Spring, porém usando as configurações do Hibernate 3. A resolução é simples, veja:

No hibernate 3 usamos o translation assim:

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

No Hibernate 4.x deve ser assim:

<bean class=”org.springframework.orm.hibernate4.HibernateExceptionTranslator”/>

O sessionFactory também deve ser alterado, veja:

No Hibernate 3 é assim:

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

Mas no Hibernate 4 deve ser assim:

<bean id=”sessionFactory” class=”org.springframework.orm.hibernate4.LocalSessionFactoryBean”>

Pronto! Assim resolvemos a exception de translation com Hibernate. Fiquem espertos com esses detalhes para não gastar tanto tempo.

Abracos, see ya!!

Série Spring: Transaction via Annotation Spring 3 + Hibernate

Olá Pessoal,

No post de hoje veremos como usar Annotations nas nossas transaction. Para isso teremos como exemplo uma aplicação bem simples para irmos direto ao ponto.

Lets go…

 Starting…

Primeiro ponto é iniciarmos pelo arquivo de configuração do Spring. Antes disso,  vou assumir que você tem os .jars necessário: mysql 5, hibernate 3.x, spring 3.x, aop, aspectJ.

Esse é o projeto:

springannotationtransactionproject

Configurando o Spring

A seguir segue a configuração do Spring, aproveitei e coloquei o comentário in line para facilitar o entendimento:

Cabeçalho

<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”>

 

E o restante:

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

<!– declarando a transation por default busca pelo id transactionManager –>

<tx:annotation-driven/> 

<!– faz o translate das exception para Spring Exception –>

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

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

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

</bean>

 

<!– criando meu datasource –>

<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=“camilo2593”/>

</bean> 

<!– configurando o sessionFactory  –>

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

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

<!– informando o package onde estão os beans annotated –>

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

<!– aqui o Hibernate properties –>

<property name=“hibernateProperties”>

      <props>

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

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

      </props>

</property>

</bean>

</beans>

 

Onde está o segredo?

Exatamente nessa linha:

<!– declarando a transation por default busca pelo id transactionManager –>

<tx:annotation-driven/>

Pronto essa linha habilita reconhecer annotation @Transactional. Que faremos logo a seguir

Desenvolvendo

Vamos meter mão na massa na parte Java:

Entidade

@Entity

public class ProductTech implements Serializable{

      private static final long serialVersionUID = -206121128264026525L;

      @Id

      @GeneratedValue

      private Long id;

      private String nameProduct;

                //getters/setters omitidos

 

Interface DAO

public interface ProductDAO {

      void save(ProductTech product);

}

 

Implementação da 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”);

      }

}

Testando

E para testar vamos fazer dessa vez com uma classe que tem o método main, caso você ainda não esteja tão acostumado com unit test (deveria):

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

      }

}

Resultado:

springtransactionannotationresult

É isso ia. Simples e fácil usar anotações para transações no Spring.

Abracos! Vou ficando por aqui.

See ya!!!