Automatyczne zarządzanie transakcjami hibernacji ze sprężyną?

Question

Jak daleko posuwa się struktura wiosenna z obsługą transakcji? Czytając książki z sugestiami "Wiosna w akcji" z ich przykładami, stworzyłeś metody DAO, które nie martwią Cię o zarządzanie sesjami i transakcjami, po prostu ustawiając fabrykę sesji i szablon transakcji w XML, a następnie podłączając je do DAO. Z drugiej strony, dokumentacja SpringSource.org sugeruje, że potrzeba mnóstwa XML i/lub adnotacji, aby tak się stało.

Jaka jest prawda tutaj, co jest najprostszym sposobem mogę wziąć kod wzdłuż linii

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

i sprawiają, że właśnie

preform database actions 

zmniejszenie ilości płytki kotła kodu transakcyjnego, że Mam do moich metod do minimum?

Answer 1

Wiosna dostarcza co najmniej 3 sposoby rozgraniczenia transakcji:

1) programistyczny traktowania, poprzez TransactionTemplate lub PlatformTransactionManager - światło o konfiguracji, ale inwazyjne

2) deklaratywne poprzez XML - pełne XML, ale nie- inwazyjna

3) deklaratywna poprzez adnotacje - światło na XML, nie inwazyjne

który z nich wybierzesz zależy od których jeden najlepiej odpowiada twoim potrzebom, Wiosna nie dokonać tego wyboru dla Ciebie . Z twojego pytania wynika, że ​​podejście do adnotacji jest tym, czego szukasz.

Sugeruję przeczytanie instrukcji Spring Reference, sekcji obsługi transakcji opartej na adnotacjach. Jest to jasne i zwięzłe.

Zawsze najpierw konsultuję się z dokumentami doktora i sprawdzam tylko książkę, jeśli nie ma jej w dokumentach.

Answer 2

Jest trochę pracy, którą powinieneś zrobić, aby móc to zrobić, ale to wcale nie jest dużo. Podobno użyjesz JPA z własnym dostawcą, np. Hibernować. Następnie należy umieścić persistence.xml definiujący jednostkę trwałości w folderze 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> 

Następnie określić wszystko co niezbędne do połączenia z bazą danych w kontekście aplikacji Wiosny używanego przy minimum powinien zawierać te:

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

Niektóre właściwości powyżej mogą być zmienione lub dodane w zależności od potrzeb. Przykładem jest JPA z bazą danych Hibernate i PostgreSQL, jak można się domyślić.

Teraz można po prostu zdefiniować metody dostępu do danych tak:

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

gdzie użytkownik jest podmiotem WZP zdefiniowany przez aplikację. Możesz zarządzać transakcjami w warstwie menedżera/kontrolera, które nazywają twoje DAO - w rzeczywistości robię to w ten sposób - ale umieściłem to tutaj, aby nie zaśmiecać przykład za dużo.

Dobrym odniesieniem, które możesz chcieć pójść prosto zamiast moich przykładów jest http://icoloma.blogspot.com/2006/11/jpa-and-spring-fucking-cooltm_26.html Najlepsze 3 odnośniki, do których się odnosi, są również warte.