Gestione automatica dell'attivazione della sospensione con molla?

Question

Fino a che punto è la struttura della molla con la gestione delle transazioni? La mia lettura del libro "Spring In Action" suggerisce con i suoi esempi che si creano metodi DAO che non si preoccupano della gestione delle sessioni e delle transazioni semplicemente impostando una factory di sessione e un modello di transazione in XML e quindi collegandoli nel DAO. La documentazione di SpringSource.org, d'altra parte, suggerisce che occorrono tonnellate di XML e/o annotazioni per far sì che ciò accada.

Qual è la verità qui, qual è il modo più semplice che posso prendere il codice sulla falsariga di

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

e renderlo solo

preform database actions 

riducendo la quantità di piastra caldaia codice di natura commerciale che Ho attraversato i miei metodi al minimo?

Answer 1

Spring fornisce almeno 3 modi di demarcazione transazione:

1) manipolazione Programmatic, tramite TransactionTemplate o PlatformTransactionManager - luce sulla configurazione, ma invasivo

2) dichiarativa tramite XML - XML ​​dettagliato, ma non invasiva

3) dichiarativa, tramite annotazioni - luce su XML, non invasivo

che uno si sceglie dipende da quale meglio si adatta alle tue esigenze, Primavera non fare questa scelta per voi . Dalla tua domanda, sembra che l'approccio di annotazione sia ciò che stai cercando.

Suggerisco di leggere il manuale di riferimento Spring, la sezione della gestione delle transazioni guidata dall'annotazione. È chiaro e conciso.

Ho sempre consultato prima i documenti ref e solo un libro se non è presente nei documenti.

Answer 2

C'è del lavoro che devi fare per essere in grado di fare proprio questo, ma non è molto. Presumibilmente, userai JPA per scegliere il tuo provider, ad es. Sospensione. Allora avete bisogno di inserire il persistence.xml che definisce l'unità di persistenza nella cartella 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> 

successivo, definire tutto il necessario per la connessione al database nel contesto dell'applicazione Primavera si utilizza, come minimo dovrebbe contenere questi:

<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"/> 

Alcune strutture sopra possono essere modificati o aggiunti a seconda delle esigenze. L'esempio è per JPA con database Hibernate e PostgreSQL, come puoi immaginare.

Ora si può semplicemente definire i metodi di accesso ai dati in questo modo:

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

in cui l'utente è un'entità JPA definito dall'applicazione. Puoi gestire le transazioni a livello manager/controller che chiama i tuoi DAO - in effetti lo faccio in quel modo - ma l'ho messo insieme qui per non confondere troppo l'esempio.

Nizza riferimenti che si può desiderare di andare direttamente al posto dei miei esempi è http://icoloma.blogspot.com/2006/11/jpa-and-spring-fucking-cooltm_26.html I primi 3 collegamenti informatici riferimenti vale la pena di andare a pure.