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 总金额）

巴特西

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

1.什么是事务

事务的四个特征ACID：

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

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

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

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

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

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

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

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

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

9.　数据库设计

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

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

最新文章

热门文章

巴特西

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

1.什么是事务

事务的四个特征ACID：

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

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

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

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

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

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

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

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

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

9. 数据库设计

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

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

最新文章

热门文章

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

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

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

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

　9.　数据库设计