La gestion des exceptions est-elle requise dans Spring Transaction?

Question

Je doute de la gestion des exceptions avec une transaction. Pour énoncer clairement mon problème, je voudrais montrer ma configuration:

<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"> 
    <property name="sessionFactory" ref="sessionFactory" /> 
</bean> 

<tx:annotation-driven transaction-manager="transactionManager" /> 

<bean id="transactionInterceptor" abstract="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
    <property name="transactionManager" ref="transactionManager" /> 
    <property name="transactionAttributeSource"> 
     <bean class="org.springframework.transaction.annotation.AnnotationTransactionAttributeSource" /> 
    </property> 
</bean> 

<bean id="baseService" abstract="true"> 
    <property name="daoProvider" ref="daoProvider" /> 
</bean> 

<bean id="customerService" parent="transactionInterceptor"> 
    <property name="target"> 
     <bean class="com.edfx.adb.service.CustomerService" parent="baseService" /> 
    </property> 
</bean> 

<bean id="daoProvider" class="com.edfx.adb.dao.provider.DaoProvider"> 
    <property name="customerDao" ref="customerDao" /> 
</bean> 

<bean id="customerDao" class="com.edfx.adb.dao.CustomerDao"> 
    <constructor-arg value="#{T(com.edfx.adb.persist.entity.Customer)}" /> 
    <property name="sessionFactory" ref="sessionFactory" /> 
</bean> 

La classe transaction active est:

@Transactional 
public class CustomerService extends BaseService implements ICustomerService { 

    @Transactional(readOnly = true) 
    public Customer getCustomerById(String id) { 
     return getDaoProvider().getCustomerDao().getCustomerById(id); 
    } 

    @Transactional(readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = { Throwable.class }) 
    public void addNewCustomer(CustomerDTO customerDTO) { 
     Customer customer = new Customer(); 

     customer.setCustomerId(customerDTO.getCustomerId()); 
     customer.setCustomerName(customerDTO.getCustomerName()); 
     customer.setActive(customerDTO.isActive()); 

     getDaoProvider().getCustomerDao().save(customer); 
    } 
} 

Mes doutes se trouve dans la méthode addNewCustomer. J'ai mis rollbackFor = { Throwable.class }.

Comment ça marche?

faire aussi que je dois gérer explicitement exception comme:

@Transactional(readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = { Throwable.class }) 
public boolean addNewCustomer(CustomerDTO customerDTO) { 
    Customer customer = new Customer(); 

    customer.setCustomerId(customerDTO.getCustomerId()); 
    customer.setCustomerName(customerDTO.getCustomerName()); 
    customer.setActive(customerDTO.isActive()); 

    try { 
     getDaoProvider().getCustomerDao().save(customer); 
    } catch (Throwable throwable) { 
     return false; 
    } 

    return true; 
} 

avec force que j'ai créé une exception en supprimant une colonne de la table client, mais cette exception n'était pas attraper dans le bloc try-catch, je peux plutôt attraper cette exception du bean géré où j'ai invoqué la méthode addNewCustomer.

Answer 1

Voici un extrait du printemps docs

Dans sa configuration par défaut, le code d'infrastructure transaction Spring Framework marque seulement une transaction pour annulation dans le cas d'exécution, exceptions non vérifiées; c'est-à-dire, lorsque l'exception levée est une instance ou sous-classe de RuntimeException. (Les erreurs seront également - par par défaut - entraîner une annulation). Les exceptions vérifiées lancées à partir d'une méthode transactionnelle n'aboutissent pas à la restauration dans la configuration par défaut.

Vous définissez rollbackFor = Throwable.class, maintenant Spring annulera toute exception/erreur. Par défaut, que cela nous plaise ou non, Spring annulera seulement pour RuintimeException, et commettra autrement

Answer 2

La structure Spring ne lance que les RuntimeExceptions, techniquement vous n'avez jamais à intercepter d'exception.