spring中配置事务

事务确实是数据库的事情，但是我们得要把事务的起点和终点告诉数据库吧。
如果你直接使用jdbc的话就会需要如下类似的代码

try{
  conn=DriverManager.getConnection("jdbc:odbc:grade");
  defaultCommit=conn.getAutoCommit();
  conn.setAutoCommit(false);
  stmt=conn.createStatement();
  stmt.executeUpdate(strSQL1);
  stmt.executeUpdate(strSQL2);
  conn.commit();
  }
  catch(Exception e){
  conn.rollback();
  e.printStackTrace();
  }
  finally{
  conn.setAutoCommit(defaultCommit);
  if(stmt!=null){
        stmt.close();
  }
  if(conn!=null){
        stmt.close();
  }
  }

就是将自动提交设为false之后，连续的几个数据库操作，如果成功的话，则提交完成一个事务，如果某个发生异常，则回滚。
而Spring的事务处理，底层也就是这样的，只是spring的方式给程序员提供了便捷，AOP，让程序员不要在关心这些重复的try catch ，只需要关心业务代码。
一般的使用方式是：将Service的方法设置成切点，将dao中的数据库曾、删、改、查操作设置成切面。
将事务的操作方法conn.setAutoCommit(false);conn.commit();conn.rollback();等提取出来做成了一个切面，这样通过配置文件或注解等方式，执行Service切点时会将切面穿进去，实现业务层的事务。

事务都是放在service层的，
使用spring来管理事务的话，可以把事务代码抽取出来，
这样的话，service层的代码简洁了，同时也降低了耦合度。
这一点对大项目来说尤其重要的。 aop确实是强大。

一、      XML，使用tx标签配置拦截器实现事务

Entity类User.java，持久化类，对应数据库表user

package com.lei.demo.entity;

import javax.persistence.*;

@Entity(name="users")
public class Users {

    public Users(){
        super();
    }

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="id")
    private Integer id;

    @Column(name="user_name",length=32)
    private String user_name;

    @Column(name="age")
    private Integer age;

    @Column(name="nice_name",length=32)
    private String nice_name;

    //属性实现......

}
package com.lei.demo.dao;

import java.util.List;

import javax.annotation.Resource;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Repository;

import com.lei.demo.entity.Users;

public class UsersDAO {
    private SessionFactory sessionFactory;

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public List<Users> getAllUser(){
        String hsql="from users";
        Session session = sessionFactory.getCurrentSession();
        Query query = session.createQuery(hsql);

        return query.list();
    }
}

package com.lei.demo.service;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.lei.demo.dao.*;

public class UserService {
    private UsersDAO userDao;

    public int userCount(){
        return userDao.getAllUser().size();
    }

    public UsersDAO getUserDao() {
        return userDao;
    }

    public void setUserDao(UsersDAO userDao) {
        this.userDao = userDao;
    }

}

xml文件配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""
    xmlns:context=""
    xmlns:xsi=""
    xmlns:tx=""
    xmlns:aop=""
    xsi:schemaLocation="

        /spring-beans-4.0.xsd

        /spring-context-4.0.xsd

        /spring-aop-4.0.xsd

        /spring-tx-4.0.xsd
        ">

    <!-- Hibernate4 -->
    <!-- 加载资源文件  其中包含变量信息，必须在Spring配置文件的最前面加载，即第一个加载-->
    <context:property-placeholder location="classpath:persistence-mysql.properties" />

    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan">
            <list>
                <!-- 可以加多个包 -->
                <value>com.lei.demo.entity</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <!-- <prop key="hibernate.current_session_context_class">thread</prop> -->
            </props>
        </property>
    </bean>

    <!-- 数据库映射 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName" value="${jdbc.driverClassName}" />
      <property name="url" value="${jdbc.url}" />
      <property name="username" value="${jdbc.user}" />
      <property name="password" value="${jdbc.pass}" />
   </bean>

    <!-- 配置Hibernate事务管理器 -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate4.HibernateTransactionManager">
      <property name="sessionFactory" ref="sessionFactory" />
   </bean>

   <!-- 配置事务异常封装 -->
   <bean id="persistenceExceptionTranslationPostProcessor"
       class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />

   <!--  声明式容器事务管理 ,transaction-manager指定事务管理器为transactionManager -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add*" propagation="REQUIRED" />
            <tx:method name="get*" propagation="REQUIRED" />
            <tx:method name="*" read-only="true" />
        </tx:attributes>
    </tx:advice>

    <aop:config expose-proxy="true">
        <!-- 只对业务逻辑层实施事务 -->
        <aop:pointcut id="txPointcut" expression="execution(* com.lei.demo.service..*.*(..))" />
        <!-- Advisor定义，切入点和通知分别为txPointcut、txAdvice -->
        <aop:advisor pointcut-ref="txPointcut" advice-ref="txAdvice"/>
    </aop:config>

</beans>

其中主要配置中是tx:advice和aop:config两个配置节，以Spring AOP的方式实现事务管理。

tx:advice配置了事务的管理者是transactionManager，同时tx:method也规定了如果方法名匹配“add*”和“get*”方法时使用事务，propagation是设定事务的传播级别。除了“add*”和“get*”方法，其他的方法的事务是只读的（典型地，对于只执行查询的事务你会将该属性设为true，如果出现了更新、插入或是删除语句时只读事务就会失败）

aop:config指定了一个aop:pointcut去引用上边的advice。

这样就通过AOP的拦截机制实现了事务，当然你还要用Spring的方式自己配置UserDAO和UserService。
joinpoint：切入点
pointcut ：切入点集合
aspect：切面
advice：切面上的建议，例如before或after（每个切点方法对应一个advice，一个切面上可有多个advice）
target：被代理对象
weave：织入

参考：
http://www.cnblogs.com/leiOOlei/p/3725911.html