Automatisches Hibernate-Transaktionsmanagement mit Spring?

Question

Wie weit geht der Federrahmen bei der Transaktionsabwicklung? Meine Lektüre des Buches "Spring In Action" mit seinen Beispielen, dass Sie DAO-Methoden erstellen, die sich nicht um Session- und Transaktionsverwaltung kümmern, indem Sie einfach eine Sitzungsfactory und eine Transaktionsvorlage in XML einrichten und diese dann in Ihr DAO integrieren. Die Dokumentation von SpringSource.org weist dagegen darauf hin, dass eine Menge XML und/oder Anmerkungen benötigt werden, um dies zu ermöglichen.

Was die Wahrheit ist hier, was der einfachste Weg ist, ich Code entlang der Linien von

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

nehmen kann und es nur Transaktionscode

preform database actions 

Verringerung der Menge an Kesselblech machen, dass Ich habe über meine Methoden ein Minimum?

Answer 1

Feder stellt mindestens 3 Arten von Transaktions Abgrenzung:

1) Programmgesteuerte Handhabung, über TransactionTemplate oder PlatformTransactionManager - Licht auf Konfiguration, aber invasive

2) Declarative über XML - ausführliche XML, aber nicht- invasive

3) deklarative über Annotationen - Licht auf XML, nicht invasive

Welches Sie wählen, auf das man am besten Ihre Bedürfnisse abhängig, Frühling für Sie nicht diese Wahl treffen . Aus Ihrer Frage klingt es nach dem Annotationsansatz, nach dem Sie suchen.

Ich empfehle Ihnen, das Spring-Referenzhandbuch zu lesen, den Abschnitt zur anmerkungsgesteuerten Transaktionsverarbeitung. Es ist klar und prägnant.

Ich konsultiere immer zuerst die Ref Docs und konsultiere nur ein Buch, wenn es nicht in der Dokumentation ist.

Answer 2

Es gibt einige Arbeiten, die Sie tun sollten, um genau das zu tun, aber es ist nicht viel. Angeblich verwenden Sie JPA mit wählen Sie Ihren eigenen Anbieter, z. Überwintern. Dann müssen Sie persistence.xml stellen, die die Persistenzeinheit im Ordner META-INF definiert:

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

Als nächstes definieren alles Notwendige für die Datenbankverbindung im Frühjahr Anwendungskontext Sie verwenden, mindestens sollte es diese enthalten:

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

Einige der oben genannten Eigenschaften können je nach Bedarf geändert oder hinzugefügt werden. Das Beispiel ist für JPA mit Hibernate und PostgreSQL-Datenbank, wie Sie vielleicht erraten haben.

Jetzt können Sie einfach Ihre Datenzugriffsmethoden wie folgt definieren:

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

wo Benutzer eine JPA-Entität von der Anwendung definiert ist. Sie können Manager-Transaktionen auf Manager-/Controller-Ebene, die Ihre DAOs aufruft - in der Tat mache ich es so - aber ich habe es hier zusammengestellt, um nicht zu viel zu tun.

Nizza Referenzen, die Sie gerade gehen wollen anstelle meiner Beispiele ist http://icoloma.blogspot.com/2006/11/jpa-and-spring-fucking-cooltm_26.html Die Top-3-Links Verweise auf und gehen wert sind.