Gestion automatique des transactions en veille prolongée avec Spring ?

Question

Jusqu’où va le framework Spring dans la gestion des transactions ?Ma lecture du livre "Spring In Action" suggère avec ses exemples que vous créez des méthodes DAO qui ne se soucient pas de la gestion des sessions et des transactions en configurant simplement une fabrique de sessions et un modèle de transaction en XML, puis en les connectant à votre DAO.La documentation de SpringSource.org, en revanche, suggère qu'il faut des tonnes de XML et/ou d'annotations pour que cela se produise.

Quelle est la vérité ici, quelle est la manière la plus simple de prendre du code dans le sens de

get session from sessionfactory
open transaction
preform database actions
commit transaction with error handling

et fais-le juste

preform database actions

réduire au minimum la quantité de code transactionnel standard dont je dispose dans mes méthodes ?

Answer 1

Spring propose au moins 3 méthodes de démarcation des transactions :

1) Gestion programmatique, via TransactionTemplate ou PlatformTransactionManager - légère en configuration, mais invasive

2) Déclaratif via XML - XML ​​détaillé, mais non invasif

3) Déclaratif via des annotations - léger sur XML, non invasif

Celui que vous choisissez dépend de celui qui correspond le mieux à vos besoins, Spring ne fait pas ce choix à votre place.D'après votre question, il semble que l'approche d'annotation soit ce que vous recherchez.

Je suggère de lire le manuel de référence Spring, la section sur la gestion des transactions basées sur les annotations.C'est clair et concis.

Je consulte toujours les documents de référence en premier, et je ne consulte un livre que s'il ne figure pas dans la documentation.

Answer 2

Il y a un travail que vous êtes censé faire pour être en mesure de faire cela, mais ce n'est pas grand-chose. Soi-disant, vous utiliserez JPA avec choisir votre fournisseur, par exemple Hiberner. Ensuite, vous devez placer persistence.xml qui définit l'unité de persistance dans le dossier META-INF:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" 
             version="1.0">
    <persistence-unit name="YourDatabasePersistenceUnitName" transaction-type="RESOURCE_LOCAL"/>           
</persistence>

Ensuite, au minimum, il doit contenir tout le nécessaire pour définir la connexion de base de données dans le contexte d'application Spring que vous utilisez, celles-ci:

<bean id="propertyConfigurer"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>/WEB-INF/jdbc.properties</value>     
        </property>
    </bean>

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" 
          destroy-method="close" scope="singleton">
        <property name="driverClassName" value="org.postgresql.Driver"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="YourDatabasePersistenceUnitName"/>
        <property name="dataSource" ref="dataSource"/>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="database" value="POSTGRESQL" />
                <property name="databasePlatform" value="org.hibernate.dialect.PostgreSQLDialect"/>
                <property name="showSql" value="true"/>
                <property name="generateDdl" value="false"/>
            </bean>
        </property>     
    </bean>

    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
        <property name="dataSource" ref="dataSource"/>
    </bean>

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

<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

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

Certaines propriétés ci-dessus peuvent être modifiées ou ajoutées en fonction de vos besoins. L'exemple est pour JPA avec base de données Hibernate et PostgreSQL comme vous avez pu le deviner.

Maintenant, vous pouvez simplement définir vos méthodes d'accès aux données comme ceci:

@Repository
@Transactional
public class UserJpaDAO {

    protected EntityManager entityManager;

    @PersistenceContext
    public void setEntityManager(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public void save(User theUser) {
        entityManager.persist(theUser);
    }

    public User update(User theUser) {
        return entityManager.merge(theUser);
    }
 }

où l'utilisateur est une entité JPA définie par votre application. Vous pouvez les transactions de gestionnaire à couche gestionnaire / contrôleur qui appelle votre OTI - en fait, je le faire de cette façon - mais je l'ai placé ensemble ici de ne pas encombrer par exemple trop.

références de Nice que vous pouvez aller directement à la place de mes exemples est http://icoloma.blogspot.com/2006/11 /jpa-and-spring-fucking-cooltm_26.html Les 3 liens haut il fait référence sont la peine d'aller aussi bien.