Spring的事务控制总结

虾米姐 阅读:361 2021-06-22 16:24:32 评论:0

一、事务的概念

  事务是一组操作的执行单元,相对于数据库操作来讲,事务管理的是一组SQL指令,比如增加,修改,删除等,事务的一致性,要求,这个事务内的操作必须全部执行成功,如果在此过程种出现了差错,比如有一条SQL语句没有执行成功,那么这一组操作都将全部回滚

  事务特性(ACID)
  (1)Atomic(原子性):要么都成功,要么都失败
  (2)Consistent(一致性):数据应该不被破坏
  (3)Isolate(隔离性):用户间操作不相混淆
  (4)Durable(持久性):永久保存

二、Spring提供的事务控制方式

  编程式事务管理

  编写程序式的事务管理可以清楚的定义事务的边界,可以实现细粒度的事务控制,比如你可以通过程序代码来控制你的事务何时开始,何时结束等,与后面介绍的声明式事务管理相比,它可以实现细粒度的事务控制,例如jdbc,hibernate,spring中不提倡使用。

  声明式事务管理

  如果你并不需要细粒度的事务控制,你可以使用声明式事务,在Spring中,你只需要在Spring配置文件中做一些配置,即可将操作纳入到事务管理中,解除了和代码的耦合, 这是对应用代码影响最小的选择,从这一点再次验证了Spring关于AOP的概念。当你不需要事务管理的时候,可以直接从Spring配置文件中移除该设置

三、Spring对事务控制的实现

  Spring的声明式事务管理,核心实现就是基于AOP,但该管理只能进行粗粒度的事务控制,只能给整个方法应用事务而不能对某几行代码应用事务(因为AOP拦截的是方法)

  下面介绍Spring声明式事务管理的实现:

  步骤1.包括数据源的配置,事务管理器的配置,事务的切面和只读属性配置

<?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:p="http://www.springframework.org/schema/p" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
         http://www.springframework.org/schema/beans/spring-beans.xsd 
          http://www.springframework.org/schema/context 
         http://www.springframework.org/schema/context/spring-context.xsd 
         http://www.springframework.org/schema/aop 
         http://www.springframework.org/schema/aop/spring-aop.xsd 
         http://www.springframework.org/schema/tx 
          http://www.springframework.org/schema/tx/spring-tx.xsd">    
           
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
            <!-- 加载jdbc驱动 --> 
            <property name="driverClass" value="com.mysql.jdbc.Driver"></property> 
            <!-- jdbc连接地址 --> 
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/kk"></property> 
            <!-- 连接数据库的用户名 --> 
            <property name="user" value="root"></property> 
            <!-- 连接数据库的密码 --> 
            <property name="password" value="123456"></property> 
            <!-- 数据库的初始化连接数 --> 
            <property name="initialPoolSize" value="3"></property> 
            <!-- 数据库的最大连接数 --> 
            <property name="maxPoolSize" value="10"></property> 
            <!-- 数据库最多执行的事务 --> 
            <property name="maxStatements" value="100"></property> 
            <!-- 连接数量不够时每次的增量 --> 
            <property name="acquireIncrement" value="2"></property>            
        </bean> 
         
        <!--  创建jdbcTemplate对象 --> 
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 
            <property name="dataSource" ref="dataSource"> 
            </property> 
        </bean> 
         
        <bean id="personDao" class="com.jyk.spring.transaction.PersonDao"> 
            <property name="jdbcTemplate" ref="jdbcTemplate"></property> 
        </bean> 
         
        <bean id="personService" class="com.jyk.spring.transaction.PersonService"> 
            <property name="personDao" ref="personDao"> 
            </property> 
        </bean> 
         
       <!-- 配置事务管理器类 --> 
        <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
            <property name="dataSource" ref="dataSource"></property> 
        </bean> 
         
        <!--  只读指定为false表示对数据的操作是读取,报异常后不用回滚 --> 
        <tx:advice id="txAdvice" transaction-manager="txManager"> 
            <tx:attributes> 
                <tx:method name="*" read-only="false"/> 
            </tx:attributes> 
        </tx:advice>    
         
        <!-- 5.3 Aop配置: 拦截哪些方法(切入点表表达式) + 应用上面的事务增强配置 --> 
        <aop:config> 
            <aop:pointcut expression="execution(* com.jyk.spring.transaction.PersonService.operateMethod(..))" id="pt"/> 
            <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/> 
        </aop:config> 
</beans>

  步骤2.编写业务接口和实现

package com.jyk.spring.transaction; 
 
public class PersonService { 
 
    private PersonDao personDao; 
 
    public void setPersonDao(PersonDao personDao) { 
        this.personDao = personDao; 
    } 
     
    public void operateMethod(Person person) 
    { 
        personDao.addPerson(person); 
         
        //人为制造异常方便测试回滚 
        int a = 1/0; 
         
        //personDao.addPerson(person); 
    } 
}
package com.jyk.spring.transaction; 
 
import org.springframework.jdbc.core.JdbcTemplate; 
 
public class PersonDao { 
 
    private JdbcTemplate jdbcTemplate; 
         
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { 
        this.jdbcTemplate = jdbcTemplate; 
    } 
 
    public void addPerson(Person person) 
    { 
        String sql = "insert into aa(id,name) values (?,?)"; 
        jdbcTemplate.update(sql,person.getId(),person.getName()); 
    } 
}

四、Spring的事务注解式使用

  使用注解实现Spring的声明式事务管理,更加简单快捷,准备工作如下

  (1)必须引入Aop相关的jar文件

  (2)bean.xml中指定注解方式实现声明式事务管理以及应用的事务管理器类

  (3)在需要添加事务控制的地方,写上: @Transactional

   @Transactional注解:

  (1)应用事务的注解

  (2)定义到方法上:当前方法应用spring的声明式事务

  (3)定义到类上:当前类的所有的方法都应用Spring声明式事务管理;

  (4)定义到父类上:当执行父类的方法时候应用事务。

  步骤1.配置数据源,事务管理器和开启事务注解自动扫描

<?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:p="http://www.springframework.org/schema/p" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
         http://www.springframework.org/schema/beans/spring-beans.xsd 
          http://www.springframework.org/schema/context 
         http://www.springframework.org/schema/context/spring-context.xsd 
         http://www.springframework.org/schema/aop 
         http://www.springframework.org/schema/aop/spring-aop.xsd 
         http://www.springframework.org/schema/tx 
          http://www.springframework.org/schema/tx/spring-tx.xsd">    
           
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
            <!-- 加载jdbc驱动 --> 
            <property name="driverClass" value="com.mysql.jdbc.Driver"></property> 
            <!-- jdbc连接地址 --> 
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/kk"></property> 
            <!-- 连接数据库的用户名 --> 
            <property name="user" value="root"></property> 
            <!-- 连接数据库的密码 --> 
            <property name="password" value="123456"></property> 
            <!-- 数据库的初始化连接数 --> 
            <property name="initialPoolSize" value="3"></property> 
            <!-- 数据库的最大连接数 --> 
            <property name="maxPoolSize" value="10"></property> 
            <!-- 数据库最多执行的事务 --> 
            <property name="maxStatements" value="100"></property> 
            <!-- 连接数量不够时每次的增量 --> 
            <property name="acquireIncrement" value="2"></property>            
        </bean> 
         
        <!--  创建jdbcTemplate对象 --> 
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 
            <property name="dataSource" ref="dataSource"> 
            </property> 
        </bean> 
         
        <!-- 配置事务管理器类 --> 
        <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
            <property name="dataSource" ref="dataSource"></property> 
        </bean> 
         
        <!-- 开启注解扫描 --> 
        <context:component-scan base-package="com.jyk.spring.annotation.transaction.property"> 
        </context:component-scan> 
         
        <!--  注解方式实现事务,指定注解方式实现事务 --> 
        <tx:annotation-driven transaction-manager="txManager"/> 
</beans>

  步骤2.编写业务实现Service层和Dao层

package com.jyk.spring.annotation.transaction.property; 
 
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; 
 
@Service 
public class PersonService { 
 
    @Resource 
    private PersonDao personDao; 
     
    /* 
     * @Transactional的使用位置 
     * 1、定义到方法上:当前方法应用的spring的声明式事务 
     * 2、定义到类上:当前类的所有方法都应用spring的声明式事务 
     * 3、定义到父类上:当执行父类的方法的时候应用Spring的声明式事务 
     */ 
    @Transactional( 
            readOnly=false, //读写事务,只读事务不修改任何数据 
            timeout = -1,//事务的超时时间没有限制 
        //    noRollbackFor = ArithmeticException.class, //遇到数学异常不回滚 
            isolation = Isolation.DEFAULT, //事务的隔离级别     
            propagation = Propagation.REQUIRED //传播行为 
            ) 
     
    public void operateMethod(Person person) 
    { 
        personDao.addPerson(person);//添加用户 
        int myexception = 1/0; 
    } 
}
package com.jyk.spring.annotation.transaction.property; 
 
import javax.annotation.Resource; 
 
import org.springframework.jdbc.core.JdbcTemplate; 
import org.springframework.stereotype.Repository; 
 
@Repository 
public class PersonDao { 
 
    @Resource 
    private JdbcTemplate jdbcTemplate; 
 
    public void addPerson(Person person) 
    { 
        String sql = "insert into aa(id,name) values (?,?)"; 
        jdbcTemplate.update(sql,person.getId(),person.getName()); 
    } 
}

标签:Spring
声明

1.本站遵循行业规范,任何转载的稿件都会明确标注作者和来源;2.本站的原创文章,请转载时务必注明文章作者和来源,不尊重原创的行为我们将追究责任;3.作者投稿可能会经我们编辑修改或补充。

我的关注

搜索
排行榜
关注我们