Spring事务管理高层抽象主要包括3个接口，Spring的事务主要是由他们共同完成的：
PlatformTransactionManager：事务管理器—主要用于平台相关事务的管理
TransactionDefinition：    事务定义信息(隔离、传播、超时、只读)—通过配置如何进行事务管理。
TransactionStatus：事务具体运行状态—事务管理过程中，每个时间点事务的状态信息。

脏读:一个事务读取了另一个事务改写但还未提交的数据,如果这些数据被回滚，则读到的数据是无效的。

不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务已提交的更新数据。

相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已提交的更新数据。

幻读：一个事务读取了几行记录后，另一个事务插入一些记录，幻读就发生了。再后来的查询中，第一个事务就会发现有些原来没有的记录。

try {
        操作
    } catch (){
        rollback
    } finally {
        commit
}

<!-- 引入外部文件 -->
    <context:property-placeholder location="classpath:db.properties" />

    <!-- 配置数据源 -->
    <!-- c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 设置连接字符串 -->
        <property name="driverClass" value="${jdbcClass}" />
        <property name="jdbcUrl" value="${jdbcUrl}" />
        <property name="user" value="${user}" />
        <property name="password" value="${password}" />
    </bean>

     <!-- 配置dao，注入jdbctemplate 对象-->
    <bean id="AccounDaoImpl" class="cn.itcast.spring.dao.AccounDaoImpl">
        <!-- 方案二：BookDao类继承JdbcDaoSupport，直接注入数据源，就拥有了jdbctempate对象 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

public interface IAccountDao {
    //转入
    public void in(String name,Double money);
    //转出
    public void out(String name,Double money);
}

//账户操作持久层
//技术方案：jdbctempate
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

    //转入
    public void in(String name,Double money){
        String sql="update t_account set money = money+ ? where name = ?";
        super.getJdbcTemplate().update(sql, money,name);
    }

    //转出
    public void out(String name,Double money){
        String sql="update t_account set money = money- ? where name = ?";
        super.getJdbcTemplate().update(sql, money,name);
    }
}

public interface IAccountService {
    //转账业务
    void transfer(String outName,String inName,Double money);
}

//掌握操作的业务层
public class AccountServiceImpl implements IAccountService{

    //注入dao（xml方式）
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    //转账操作的业务逻辑
    public void transfer(String outName,String inName,Double money){
        //调用dao层
        //先取出
        accountDao.out(outName, money);
        //再转入
        accountDao.in(inName, money);
    }
}

  <!-- 配置dao-->
    <bean id="accountDao" class="cn.dao.AccountDaoImpl">
        <!--注入数据源  -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置service -->
    <bean id="accountService" class="cn.itcast.service.AccountServiceImpl">
        <!-- 注入dao  -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class SpringTest {
    //注入测试的service
    @Autowired
    private IAccountService accountService;

    //需求：账号转账，Tom账号取出1000元，存放到Jack账号上
    @Test
    public void testTransfer(){
        accountService.transfer("Tom", "Jack", 1000d);
        System.out.println("转账成功！");
    }
}

com.springsource.org.aopalliance-1.0.0.jar：aop切面编程
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar：注解开发切面
spring-aop-3.2.0.RELEASE.jar：aop切面编程
spring-aspects-3.2.0.RELEASE.jar：注解开发切面
spring-tx-3.2.0.RELEASE.jar：事务处理

  <!-- 引入外部属性配置文件-->
    <context:property-placeholder location="classpath:db.properties"/> 

     <!-- 配置数据源 -->
    <!-- c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.className}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    <!-- 配置dao -->
    <bean id="accountDao" class="cn.itcast.spring.dao.AccountDaoImpl">
        <!-- 注入数据源，才拥有jdbctemplate -->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 配置service -->
    <bean id="accountService" class="cn.itcast.spring.service.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <!-- 第一步：定义具体的平台事务管理器（DataSource事务管理器） -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 第二步：定义通知，通知中要处理的就是事务 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
     //注意：如果第一步的事务管理器id设为transactionManager,transaction-manager属性可以省略，默认
        <!-- 配置事务的属性定义 -->
        <tx:attributes>
            <!-- 配置具体的方法的事务属性
                name：事务添加在哪个方法上，需要自己定义
                Isolation：事务的隔离级别，默认是按数据库的隔离级别来
                Propagation：事务的传播行为，默认是同一个事务
                timeout="-1": 事务的超时时间，默认值使用数据库的超时时间。
                read-only="false": 事务是否只读，默认可读写。
                rollback-for: 遇到哪些异常就回滚，其他的都不回滚
                no-rollback-for：遇到哪些异常不回滚，其他的都回滚。和上面互斥的
             -->
            //method定义的方法都会添加事务管理
            <tx:method name="transfer" isolation="DEFAULT"    propagation="REQUIRED" timeout="-1" read-only="false"/>

            <!-- 支持通配符：切面中 方法名字符合下面规则的方法都会添加事务管理  -->
            <tx:method name="save*"/>
            <tx:method name="update*"/>
            <tx:method name="delete*"/>
            <tx:method name="find*" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!-- 第三步：配置切入点，让通知关联切入点，即事务控制业务层的方法 -->
    <aop:config>
        <!-- 切入点 -->
        <aop:pointcut expression="bean(*Service)" id="txPointcut"/>
        <!-- 切面 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class SpringTest {
    //注入测试的service
    @Autowired
    private IAccountService accountService;

    //需求：账号转账，Tom账号取出1000元，存放到Jack账号上
    @Test
    public void testTransfer(){
        accountService.transfer("Tom", "Jack", 1000d);
        System.out.println("转账成功！");
    }

}

public interface IAccountDao {
    //（存入）转入
    public void in(String name,Double money);
    //（取出）转出
    public void out(String name,Double money);
}

//账户操作持久层
//技术方案：jdbctempate
/**
 * @Repository("accountDao")
 * 相当于容易中定义<bean id="accountDao" class="cn.itcast.spring.anntx.dao.AccountDaoImpl"/>
 */
@Repository("accountDao")
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

 /*
    演示:注入数据源的错误方式：
    //注入数据源
    /*@Autowired
    private DataSource dataSource;
    //注入失败，@Autowired的原理是为属性生成setter方法通过setter方法注入，但是JdbcDaoSupport 类有setter方法方法且为最终方法，不可重写
    注意：xml配置与注解注入数据源的区别：xml配置是在配置文件中注入数据源到dao，不生成setter方法，注解注入的@Autowired会底层生成setter方法，
 */

    //注入数据源的正确方式：自定义方法，在方法内调用父类方法注入数据源
    @Autowired   //当初始化dao的时候，会调用该方法，通过set方法的形参注入数据源
    public void setSuperDataSource(DataSource dataSource){      //方法名自定义
        //调用父类的setDataSource方法，注入数据源
        super.setDataSource(dataSource);
    }

    //（存入）转入
    public void in(String name,Double money){
        String sql="update t_account set money = money+ ? where name = ?";
        super.getJdbcTemplate().update(sql, money,name);
    }

    //（取出）转出
    public void out(String name,Double money){
        String sql="update t_account set money = money- ? where name = ?";
        super.getJdbcTemplate().update(sql, money,name);
    }
}

public interface IAccountService {
    void transfer(String outName,String inName,Double money);
}

//掌握操作的业务层
/**
 * @Service("accountService")
 * 相当于spring容器中定义：<bean id="accountService" class="cn.itcast.spring.anntx.service.AccountServiceImpl">
 */
@Service("accountService")
@Transactional  //在类上添加事务管理，自动对类中所有的公有的方法添加事务
public class AccountServiceImpl implements IAccountService{

    //注入dao
    @Autowired
    private IAccountDao accountDao;

    //转账操作的业务逻辑
    @Transactional   //在方法上添加事务管理，事务管理只在此方法上
    public void transfer(String outName,String inName,Double money){

        //调用dao层
        //先取出
        accountDao.out(outName, money);
        //异常
        int d = 1/0;
        //再转入
        accountDao.in(inName, money);
    }

    @Transactional(readOnly=true)    //在方法和类上同时定义了事务的属性，且属性值不同，局部会覆盖全局
    public void findAccount(){
        System.out.println("查询帐号的信息了");
    }
}

    <!-- 引入外部属性文件 -->
    <context:property-placeholder location="classpath:db.properties" />

    <!-- 配置数据源 -->
    <!-- c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.className}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.user}" />
        <property name="password" value="${jdbc.password}" />
    </bean>    

    <!-- 配置bean注解扫描 -->
    <context:component-scan base-package="cn.itcast.spring.anntx"/>

    <!-- 事务管理 -->
    <!-- 配置事务管理器（DataSource事务管理器） -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 配置事务注解驱动 ：识别事务的注解@tr
          transaction-manager:具体的平台事务管理器
    -->
    <!-- 默认的平台事务管理器的名字叫：transactionManager，如果与自定义的事务管理器id相同，transaction-manager="transactionManager"可以省略 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

//掌握操作的业务层
/**
 * @Service("accountService")
 * 相当于spring容器中定义：<bean id="accountService" class="cn.itcast.spring.anntx.service.AccountServiceImpl">
 */
@Service("accountService")
@Transactional()  //会对该类中，所有的共有的方法，自动加上事务--全局的设置，默认是可写
public class AccountServiceImpl implements IAccountService{

    //注入dao
    @Autowired
    private IAccountDao accountDao;

    //转账操作的业务逻辑
    @Transactional(readOnly=false)//在方法上添加事务
    public void transfer(String outName,String inName,Double money){
        //调用dao层
        //先取出
        accountDao.out(outName, money);
        int d = 1/0;
        //再转入
        accountDao.in(inName, money);

    }

    @Transactional(readOnly=true)  //使用局部覆盖全局的
    public void findAccount(){
        System.out.println("查询帐号的信息了");
    }
}