Spring 使用注解对事务控制详解与实例

1.什么是事务

一荣俱荣，一损俱损，很多复杂的操作我们可以把它看成是一个整体，要么同时成功，要么同时失败。

事务的四个特征ACID：

原子性（Atomic）：表示组成一个事务的多个数据库的操作的不可分割的单元，只有所有的操作成功才算成功，整个事务提交，其中任何一个操作失败了都是导致整个所有操作失败，事务会回滚。

一致性（Consistentcy）：事务操作成功后，数据库所处的状态和业务规则一致。如果A账户给B账户汇100，A账户减去100，B加上100，两个账户的总额是不变的。
隔离性（islation）：在多个数据库的操作相同的数据并发时，不同的事务有自己的数据空间，事务与事务之间不受干扰（不是绝对的）。干扰程度受数据库或者操作事务的隔离级别来决定，隔离级别越高，干扰就越低，数据的一致性越好，并发性就越差。
持久性（Druability）：一旦事务提交成功，数据就被持久化到数据库，不可以回滚。

2.spring使用注解对事务的控制

　　Spring 事务管理有两种方式：编程式事务管理、声明式事务管理
　　　　编程式事务管理通过TransactionTemplate手动管理事务，在实际应用中很少使用，我们来重点学习声明式事务管理
　　　　声明式事务管理有三种实现方式：基于TransactionProxyFactoryBean的方式、基于AspectJ的XML方式、基于注解的方式
　　

　　1. 新建一个java工程——导入spring 和事务管理所需要的jar   ——然后选择全部jar 右键Build path   ——最后如图           （我的java版本jre是1.8）                             Spring事务需要的jar

 

2.在src目录下新建5个包   如图

　　　　dao ：数据连接层，主要用于存放对数据进行操作的类

　　　　model：模型层，主要用于存放实体类

　　　　service：服务层，主要用于对数据连接层进行操作的一些服务类。

　　　　util：工具类，主要用于存储工具方法

　　　　test：用于测试类

3.在dao数据连接层，建立里与数据库操作的类与对应的接口 （Order 订单 ，detail订单明细）

　3.1　定义detailDao接口　代码如下：

 package com.spring.dao;

 import com.spring.model.Detail;
 import com.spring.model.Order;

 public interface detailDao {
     //保存订单明细
     public void saveDetail(Detail detail);

 }

　　3.2  定义OrderDao接口 代码如下：

 package com.spring.dao;

 import com.spring.model.Order;

 public interface OrderDao {
     //保存订单
     public void saveOrder(Order order);

 }

　　3.3 实现以上接口

detailDaoImp 代码如下：

 package com.spring.dao;

 import javax.sql.DataSource;

 import org.springframework.jdbc.core.JdbcTemplate;

 import com.spring.model.Detail;
 import com.spring.model.Order;

 public class detailDaoImp implements detailDao {

     private DataSource dataSource;
     private JdbcTemplate jdbcTemplate;

     public void setDataSource(DataSource dataSource) {
         this.dataSource = dataSource;
         this.jdbcTemplate = new JdbcTemplate(dataSource);
     }
     //保存订单明细
     public void saveDetail(Detail detail) {
         String SQL = "insert into t_detail values(null,?,?,?))";
         jdbcTemplate.update(SQL, new Object[] { detail.getItemName(),detail.getQuantity(),detail.getOrderId() });
         System.out.println("Insert detail success!");
     }

 }

　　

     OrderDaoImp代码如下：

package com.spring.dao;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;

import com.spring.model.Order;

public class OrderDaoImp implements OrderDao {

    private DataSource dataSource;
    private JdbcTemplate jdbcTemplate;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }
    //插入订单
    public void saveOrder(Order order) {
        String SQL = "insert into t_order values (null,?)";
        System.out.println(SQL);
        System.out.println(order.getTotal_price());
        jdbcTemplate.update(SQL, new Object[]{order.getTotal_price()});
        System.out.println("Insert order success!");
    }

}

4.在model层中新建两个实体类　　（Order订单类，detail订单明细类）

　　Order订单类代码如下：

 package com.spring.model;

 /*
  * 订单表
  */
 public class Order {
     //订单编号
     private Integer order_id;
     //订单总金额
     private Integer total_price;
     public Integer getOrder_id() {
         return order_id;
     }
     public void setOrder_id(Integer order_id) {
         this.order_id = order_id;
     }
     public Integer getTotal_price() {
         return total_price;
     }
     public void setTotal_price(Integer total_price) {
         this.total_price = total_price;
     }
 }

　

　detail订单明细类代码如下：

 package com.spring.model;

 /**
  * 商品明细表
  * @author Administrator
  *
  */
 public class Detail {
     //ID
     private Integer detailId;
     //外键　　暂时可以忽略
     private Integer orderId;
     public Integer getDetailId() {
         return detailId;
     }
     public void setDetailId(Integer detailId) {
         this.detailId = detailId;
     }
     public Integer getOrderId() {
         return orderId;
     }
     public void setOrderId(Integer orderId) {
         this.orderId = orderId;
     }
     public Integer getQuantity() {
         return quantity;
     }
     public void setQuantity(Integer quantity) {
         this.quantity = quantity;
     }
     public String getItemName() {
         return itemName;
     }
     public void setItemName(String itemName) {
         this.itemName = itemName;
     }
     //商品数量
     private Integer quantity;
     //商品数量
     private String itemName;

 }

5.在service中定义一个接口并且实现它

　　　　OrderService代码如下：

 package com.spring.service;

 import com.spring.model.Detail;
 import com.spring.model.Order;

 public interface OrderService {
     //插入订单和订单明细
     public void saveOrderAndDetail(Order order,Detail detail);
 }

　　OrderServiceImp代码如下：

 package com.spring.service;

 import org.springframework.transaction.annotation.Transactional;

 import com.spring.dao.OrderDaoImp;
 import com.spring.dao.detailDaoImp;
 import com.spring.model.Detail;
 import com.spring.model.Order;

 /**
  * 服务层 使用注解来实现事务管理
  *
  * @author Administrator
  *
  */

 public class OrderServiceImp implements OrderService {
     // 注入两个对象
     public OrderDaoImp OrderDaoImp;

     public detailDaoImp detailDaoImp;

     @Transactional
     @Override
     // 如果加上@Transaction时，方法执行有异常，整个事务数据都会回滚，数据库中不会存在有数据。
     public void saveOrderAndDetail(Order order, Detail detail) {
         OrderDaoImp.saveOrder(order);
         /**
          * 如果不加@transaction时有异常存在，OrderDaoImp.saveOrder(order)方法将会执行。
          * 但detailDaoImp.saveDetail(detail)不会执行
          **/
         int i = 100 / 0;
         detailDaoImp.saveDetail(detail);

     }

     public OrderDaoImp getOrderDaoImp() {
         return OrderDaoImp;
     }

     public void setOrderDaoImp(OrderDaoImp orderDaoImp) {
         OrderDaoImp = orderDaoImp;
     }

     public detailDaoImp getDetailDaoImp() {
         return detailDaoImp;
     }

     public void setDetailDaoImp(detailDaoImp detailDaoImp) {
         this.detailDaoImp = detailDaoImp;
     }

 }

6.在util包中定义一个通知方法类

 package com.spring.util;

 public class SeizedAdvice {
     /**
      * 定义通知
      */

     public void beforeAdvice(){
         System.out.println("——————我是前置通知————————");

     }
     public void afterAdvice(){
         System.out.println("------我是后置通知-------");

     }
     public void afterReturningAdvice(Object object){
         System.out.println("————————我是返回后通知——————————"+object.toString());

     }
     public void afterThrowingAdvice(IllegalAccessError illegalAccessError){
         System.out.println("--------我是异常返回异常返回通知---------"+illegalAccessError.toString());

     }

 }

7.在test中定义个测试类，用于测试

 package com.test;

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.spring.model.Detail;
 import com.spring.model.Order;
 import com.spring.service.OrderServiceImp;

 public class Test {

     public static void main(String[] args) {
         ApplicationContext applicationContext=new ClassPathXmlApplicationContext("bean.xml");
         OrderServiceImp imp=(OrderServiceImp)applicationContext.getBean("OrderServiceImp");

         Order order=new Order();
         order.setTotal_price(699);
         Detail detail=new Detail();
         detail.setItemName("牙刷");
         detail.setQuantity(3);
         detail.setOrderId(4);
         imp.saveOrderAndDetail(order,detail);

     }
 }

8.最后就是我们的配置文件和数据库中的两张表

　　　Spring  bean.xml代码如下：

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
     <!-- 定义数据源 -->
     <bean id="dataSource"
         class="org.springframework.jdbc.datasource.DriverManagerDataSource">
         <property name="driverClassName" value="com.mysql.jdbc.Driver" />
         <property name="url" value="jdbc:mysql://localhost:3306/jerry" />
         <property name="username" value="root" />
         <property name="password" value="1234" />
     </bean>

     <!-- 事务管理方式注解驱动 -->
     <tx:annotation-driven transaction-manager="transactionManager" />

     <!-- 配置数据   proxy-target-class属性值决定是基于接口的还是基于类的代理被创建。
         如果proxy-target-class 属性值被设置为true，那么基于类的代理将起作用-->
     <aop:config proxy-target-class="true">
         <!-- 切 面-->
         <aop:aspect id="myAspect" ref="SeizedAdvice">
             <!-- 切 点-->
             <aop:pointcut expression="execution(* com.spring.service.OrderServiceImp.*(..))"
                 id="myPointCut" />
             <aop:before pointcut-ref="myPointCut" method="beforeAdvice" />
             <aop:after pointcut-ref="myPointCut" method="afterAdvice" />
         </aop:aspect>
     </aop:config>

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

     <!-- 定义我们所需的bean -->
     <bean id="SeizedAdvice" class="com.spring.util.SeizedAdvice"></bean>

     <bean id="OrderServiceImp" class="com.spring.service.OrderServiceImp">
         <property name="detailDaoImp" ref="detailDaoImp"></property>
         <property name="OrderDaoImp" ref="OrderDaoImp"></property>
     </bean>

     <bean id="detailDaoImp" class="com.spring.dao.detailDaoImp">
         <property name="dataSource" ref="dataSource" />
     </bean>

     <bean id="OrderDaoImp" class="com.spring.dao.OrderDaoImp">
         <property name="dataSource" ref="dataSource" />
     </bean>

 </beans>

　9.　数据库设计

detail（订单明细表  detail_id   订单明细ID，item_name  商品名称，quantity  订单数量  ，order_id  外键   暂时不用管这个属性）

Order（订单表，order_id   订单id，total_price   总金额）

 10. 没有加@transaction测试如下：

这就会造成数据错误，不符合事务管理要求。加上@transaction再次测试如下图；