声明式事务

一个简单的小例子关于声明式事务
/**
 * Created by Administrator on 2015/11/27.
 * 声明式事务管理类
 */

public class AddDAO{
    JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

    public AddDAO(){}
    /**使用这个注解可以声明这个方法是一个事务
    *            关于事务的传播性
            propagation = Propagation.REQUIRED属性为默认值，当在一个事务中调用一个事务的时候，
    它将采用原来的事务即同一个事务，第一个sql完成，异常，事务回滚。
    propagation = Propagation.REQUIRES_NEW的时候，当在一个事务中调用另一个事务，它
    将采取创建一个新的事务，这样，当第一个sql这行完成，就完成了一个事务，然后异常来了，
    接着抛出异常，第一个sql完成不再回滚。
            **/

    /**readOnly = false这个是只读属性*/

    /**timeout = 5设置指定强制回滚之前事务可以占用的时间**/

    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED,
    readOnly = false,timeout = 5)
    public void addBook(){
        String sql1="insert into Bookimformation values(100120,'zzyyxl','yxlzzy',30,900)";
        jdbcTemplate.execute(sql1);
        System.out.println(" first is success");
        /**可在这里加上人造异常测试事务**/
        String sql2="insert into Bookimformation values(100121,'zzyyxl','yxlzzy',30,900)";
        jdbcTemplate.execute(sql2);
        System.out.println(" second is success");
    }
}
/**
 使用声明式事务分为三步，第一，定义事务管理器，
 第二，<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>，
 定义这个可以使用注解的方式实现声明式事务。
 第三在相对应得类的方法前注解@Transactional//使用这个注解可以声明这个方法是一个事务
 **/

public class Main {
    //这个事务是成功的
    public static void main(String[]args){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-config.xml");
        AddDAO addDAO=(AddDAO)ctx.getBean("addDAO");
        addDAO.addBook();
    }
}

spring配置内容如下：（前提：配过dataSource和jdbcTemplate）

<!--定义事务管理器-->
<bean id="dataSourceTransactionManager"
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <property name="dataSource">
              <ref bean="dataSource2"></ref>
       </property>
</bean>

<!--定义这个可以使用注解的方式实现声明式事务-->
<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>

<!--配置一个普通的TransactionProxyFactoryBean包下的bean，实现声明式事务-->
<bean id="addDAO" class="Spring_AOP.TransactionProxyFactoryBean.AddDAO">
       <property name="jdbcTemplate">
              <ref bean="jdbcTemplate"></ref>
       </property>
</bean>

/**
 * 这个类用来测试事务的传播
 * 即propagation = Propagation.REQUIRES_NEW的时候，当在一个事务中调用另一个事务，它
 将采取创建一个新的事务，这样，当第一个sql这行完成，就完成了一个事务，然后异常来了，
 接着抛出异常，第一个sql完成不再回滚。
* **/
public class Testswcb {
    public Testswcb(){}

    private AddDAO addDAO;
    public void setAddDAO(AddDAO addDAO) {
        this.addDAO = addDAO;
    }

    @Transactional(propagation =Propagation.REQUIRED)
    public void cs(){
        addDAO.addBook();
        //这里可以人造异常，测试事务的传播
        addDAO.addBook();
    }
    public static void main(String[]args){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-config.xml");
        Testswcb testswcb=(Testswcb)ctx.getBean("testswcb");
        testswcb.cs();
    }
}

spring里面的配置如下：
<bean id="testswcb" class="Spring_AOP.TransactionProxyFactoryBean.Testswcb">
       <property name="addDAO" ref="addDAO"></property>
</bean>