Spring 事务处理

最新推荐文章于 2023-05-25 10:36:31 发布

lbb-luckly

最新推荐文章于 2023-05-25 10:36:31 发布

阅读量264

点赞数 1

分类专栏： javaweb spring 文章标签： spring mybatis

本文链接：https://blog.csdn.net/bing_bg/article/details/105919946

版权

javaweb 同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

spring

5 篇文章 0 订阅

订阅专栏

本质

事务是一组sql语句的集合，事务具有原子性（同步，即要么全部执行，要么全部不执行）、一致性（事务执行完之后表里面的约束等不变）、持久性（一旦提交不能再被撤销），隔离性（两个事物之间是隔离的，互补干扰，是通过加锁实现的）。

数据库操作最终都要使用到JDBC,那么无论上层如何封装,底层都是调用Connection的commit,rollback来完成

事务处理弊端

数据访问层(DAO)必然需要进行事务的处理,但是我们会发现,事务处理的代码通常是简单的重复的,编写这样的重复代码会浪费大量的时间,所以我们需要找到一种方案可以将这些重复的代码进行抽取,以便与管理维护和复用,

我们的需求:在一系列数据库操作上的方法上增加额外的事务处理代码,让原来的方法中只关注具体的数据处理,即在原本以及存在的数据库操作方法上添加额外的事务处理逻辑

解决方案：AOP

Spring的AOP:在结合目前的需求 :

1.将目标对象(DAO)放入Spring容器

2.告知Spring你的通知代码是什么(事务处理)

3.告知Spring 哪些方法(DAO的增删改查)要应用那些通知(不同的事务处理代码)

4.从Spring中获取代理对象来完成原本的增删改查,代理对象会自动完成事务处理

注意： 如果不涉及对表的修改，就不用使用事务。

Spring 事务处理API

Spring作为框架,需要进行详细的设计,全方位的考虑事务处理的各个方面,而不仅是简单的帮你执行commit,rollback;

Spring对事务处理进行了抽象定义,形成了一套具体的API结构,如下:

在这里插入图片描述

注解：

TransactionDefinition:定义事务的具体属性,如隔离级别,超时设置,传播行为等

TransactionStatus: 用于获取当前事务的状态信息

PlatformTransactionMananger: 主要的事务管理接口,提供三个实现类对应不同场景

类型	场景
DataSourceTransactionManager	使用Spring JDBC或 iBatis 进行持久化数据时使用
HibernateTransactionManager	使用Hibernate3.0版本进行持久化数据时使用
JpaTransactionManager	使用JPA进行持久化时使用
JtaTransactionManager	使用一个JTA实现来管理事务,跨数据源时使用

注意：其分布在不同的jar包中,使用时根据需要导入对应jar包

事物的传播行为

在一个执行sql的方法中调用了另一个方法时,该如何处理这两个方法之间的事务，如下图：

在这里插入图片描述

Spring定义了7种不同的处理方式:

常量名	含义
PROPAGATION_REQUIRED	支持当前事务。如果 A 方法已经在事务中，则 B 事务将直接使用。否则将创建新事务
PROPAGATION_SUPPORTS	支持当前事务。如果 A 方法已经在事务中，则 B 事务将直接使用。否则将以非事务状态执行
PROPAGATION_MANDATORY	支持当前事务。如果 A 方法没有事务，则抛出异常
PROPAGATION_REQUIRES_NEW	将创建新的事务，如果 A 方法已经在事务中，则将 A 事务挂起
PROPAGATION_NOT_SUPPORTED	不支持当前事务，总是以非事务状态执行。如果 A 方法已经在事务中，则将其挂起
PROPAGATION_NEVER	不支持当前事务，如果 A 方法在事务中，则抛出异常
PROPAGATION.NESTED	嵌套事务,当外层出现异常则连同内层一起回滚,若外层正常而内部异常,仅回滚内部操作

挂起:是开启一个独立的事务,已存在的事务暂停执行,等待新事务执行完毕后继续执行,两个事务不会互相影响

Spring整合Mybatis

要将MyBatis整合到Spring中来,要明确一下两者的关系和定位

Spring Java开发框架,其本质是一个对象容器,可以帮助我们完成IOC,DI,AOP
MyBatis是一个持久层框架,用于简化对数据库的操作

将两者整合起来,就是将MyBatis中的对象交给Spring来管理,且将这些对象的依赖也交给Spring来管理;

添加依赖

配置pom.xml依赖：

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- Spring整合MyBatis依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.3</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>

        <!--JDBC-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

        <!--Spring JDBC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <!--事务管理-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <!--AspectJ-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.0</version>
        </dependency>
    </dependencies>

SM的基础使用

在这里我采用逆向工程生成mybatis文件：

配置pom.xml文件：

<build>
    <plugins>
      <plugin>
      	<groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-maven-plugin</artifactId>
        <version>1.3.7</version>
	      <configuration>
          			<!-- 是否覆盖已存在的接口和POJO该配置不包括Mapper  
									若为False将会生成版本记录-->
                <overwrite>true</overwrite>
        </configuration>
        </plugin>
    </plugins>
</build>

创建 jdbc.properties

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql:///mybatisdb?characterEncoding=utf8&nullCatalogMeansCurrent=true
jdbc.username = root
jdbc.password = 123456
location = D:/maven/repository/mysql/mysql-connector-java/5.1.47/mysql-connector-java-5.1.47.jar

创建generatorConfig.xml：

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--导入属性配置-->
    <properties resource="jdbc.properties"></properties>
    <!--指定特定数据库的jdbc驱动jar包的位置-->
    <classPathEntry location="${location}"/>
    <context id="default" targetRuntime="MyBatis3">
        <!-- optional，旨在创建class时，对注释进行控制 -->
        <commentGenerator>
            <property name="suppressDate" value="true"/>
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>

        <!--jdbc的数据库连接 -->
        <jdbcConnection
               driverClass="${jdbc.driver}" connectionURL="${jdbc.url}" userId="${jdbc.username}" password="${jdbc.password}">
        </jdbcConnection>

        <!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>

        <!--Model模型生成器,用来生成含有主键key的类，记录类 以及查询Example类
        targetPackage 指定生成的model生成所在的包名
        targetProject 指定在该项目下所在的路径 -->
        <javaModelGenerator targetPackage="com.lbb.pojo" targetProject="src/main/java">
            <!-- 是否允许子包，即targetPackage.schemaName.tableName -->
            <property name="enableSubPackages" value="false"/>
            <!-- 是否对model添加 构造函数 -->
            <property name="constructorBased" value="true"/>
            <!-- 是否对类CHAR类型的列的数据进行trim操作 -->
            <property name="trimStrings" value="true"/>
            <!-- 建立的Model对象是否 不可改变 即生成的Model对象不会有 setter方法，只有构造方法 -->
            <property name="immutable" value="false"/>
        </javaModelGenerator>

        <!--mapper映射文件生成所在的目录 为每一个数据库的表生成对应的SqlMap文件 -->
        <sqlMapGenerator targetPackage="com.lbb.dao"
                         targetProject="src/main/resources">
            <property name="enableSubPackages" value="false"/>
        </sqlMapGenerator>

        <!--mapper接口文件生成所在的目录 为每一个数据库的表生成对应的接口文件 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.lbb.dao" targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema(数据库名称)作为包的后缀 -->
            <property name="enableSubPackages" value="false"/>
        </javaClientGenerator>
       <!--指定需要生成的表-->
        <table tableName="kuser"></table>
    </context>
</generatorConfiguration>

在maven中运行，生成mybatis文件.

上面过程没有配置mybatis-config.xml,那是因为我们整合Spring和mybatis可以通过spring去管理，所以不需要再单独建一个配置文件，在applicationContext.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--  引入jdbc配置文件  -->
    <context:property-placeholder location="jdbc.properties"/>
    <!--  配置属性 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="username" value="${jdbc.username}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--会话工厂-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--        取别名-->
        <property name="typeAliasesPackage" value="com.lbb.pojo"/>
    </bean>
    <!--    扫描mapper-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.lbb.mapper"/>
    </bean>
</beans>

service层：

KuserService

public interface KuserService {
    void updateUserName(Integer id,String name);
}

实现类：KuserServiceImpl

@Service
public class KuserServiceImpl implements KuserService {
    @Autowired
    private KuserMapper kuserMapper;

    @Override
    public void updateUserName(Integer id, String name) {
        Kuser kuser = kuserMapper.selectByPrimaryKey(id);
        kuser.setUsername(name);
        kuserMapper.updateByPrimaryKeySelective(kuser);
        //制造异常
        //int i = 1 / 0;
    }
}

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class UserTest {
    @Autowired
    private KuserService kuserService;
    @Test
    public void test2(){
       kuserService.updateUserName(1,"承诺2");
    }
}

编码式事务

编码式事务,即在源代码中加入事务处理的代码, 即commit,rollback等,这是非常原始的做法仅作为了解

手动事务：

xml中配置：

	
	<!--事务管理器-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--指定数据源：datasource上面已经配置好，直接引用-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

在测试类中使用事务：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class UserTest {
    @Autowired
    private KuserMapper kuserMapper;
    @Autowired
    private KuserService kuserService;
    @Autowired
    DataSourceTransactionManager transactionManager;
    @Test
    public void test2(){
        DefaultTransactionDefinition td = new DefaultTransactionDefinition();
        //设置隔离级别
        td.setIsolationLevel(4);
        //获得事务
        TransactionStatus transaction = transactionManager.getTransaction(td);
        try {
            kuserService.updateUserName(1,"承诺2");
            transactionManager.commit(transaction);
        }catch (Exception e){
            transactionManager.rollback(transaction);
        }
    }

}

上述代码仅用于测试事务处理的有效性;

我们已经在Spring中配置了MyBatis,并进行了事务处理,但是没有解决重复代码的问题

使用事务模板

事务模板原理是将要执行的具体代码交给模板,模板会在执行这写代码的同时处理事务,当这写代码出现异常时则自动回滚事务,以此来简化书写

配置文件配置：

	<!--事务管理器-->
    <bean id="manager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--指定数据源：datasource上面已经配置好，直接引用-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--事务模板-->
    <bean class="org.springframework.transaction.support.TransactionTemplate">
        <!--引用事务管理器-->
        <property name="transactionManager" ref="manager"/>
    </bean>

使用：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class UserTest {
    @Autowired
    TransactionTemplate template;
    @Test
    public void test3() {
        //TransactionCallback是一个接口。doInTransaction是要加事务的执行语句。使用匿名内部类实现
        template.execute(new TransactionCallback<Kuser>() {
            @Override
            public Kuser doInTransaction(TransactionStatus transactionStatus) {
                kuserService.updateUserName(1, "承诺2");
                return null;
            }
        });
    }

}

声明式事务

需要在原来的业务逻辑代码中加入任何事务相关的代码,而是通过xml,或者注解的方式,来告诉框架,哪些方法需要添加事务处理代码,让框架来完成在原始业务逻辑前后增加事务处理的代码(通过AOP),这也是AOP使用较多的场景之一;

**强调:**事务增强应该应用到Service层,即业务逻辑层,应为一个业务方法可能涉及多个数据库操作,当某个操作遇到异常时需要将所有操作全部回滚

tx名称空间的xml配置：

需要引入aop和tx名称空间

<?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: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
       https://www.springframework.org/schema/beans/spring-beans.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
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--  引入jdbc配置文件  -->
    <context:property-placeholder location="jdbc.properties"/>
    <!--  配置属性 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="username" value="${jdbc.username}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--会话工厂-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--取别名-->
        <property name="typeAliasesPackage" value="com.lbb.pojo"/>
    </bean>
    <!--    扫描mapper-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.lbb.mapper"/>
    </bean>
    <!--扫描包-->
    <context:component-scan base-package="com.lbb"/>
    
    
    <!--   事务相关的配置 -->

    <!--事务管理器-->
    <bean id="manager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--指定数据源：datasource上面已经配置好，直接引用-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--  声明式  transaction-manager 指定事务管理器-->
    <tx:advice id="myadvice" transaction-manager="manager">
        <!--定义要使用事务的方法 可以设置隔离级别  传播行为-->
        <!-- name指定方法*代表所有 isolation设置隔离级别  read-only只读  propagation传播行为-->
        <tx:attributes>
            <tx:method name="*insert*" isolation="REPEATABLE_READ" read-only="false" propagation="REQUIRED"/>
            <tx:method name="*update*" isolation="REPEATABLE_READ" read-only="false" propagation="REQUIRED"/>
            <tx:method name="*delete*" isolation="REPEATABLE_READ" read-only="false" propagation="REQUIRED"/>
            <tx:method name="*save*" isolation="REPEATABLE_READ" read-only="false" propagation="REQUIRED"/>
            <tx:method name="*select*" isolation="DEFAULT" read-only="true" propagation="NEVER"/>
        </tx:attributes>
    </tx:advice>

    <!-- 定义切点 指定在service配置事务-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.lbb.service..*(..))"/>
        <aop:advisor advice-ref="myadvice" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

tx:method属性:

属性名	含义
name	匹配的方法名称
isolation	事务隔离级别
read-only	是否采用优化的只读事务
timeout	超时
rollback-for	需要回滚的异常类
propagation	传播行为
no-rollback-for	不需要回滚的异常类

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class UserTest2 {
    @Autowired
    private KuserService kuserService;

    @Test
    public void test3() {
        kuserService.updateUserName(1, "承诺2");
    }
}

基于注解的配置

Spring当然也支持采用注解形式来处理事务

开启注解事务支持:

	<!--   事务相关的配置 -->
    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--指定数据源：datasource上面已经配置好，直接引用-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--开启事务-->
    <tx:annotation-driven/>

注意：无论何种方式事务管理器都是必须的,使用注解id必须是transactionManager

使用：

@Override
    //事务注解
    @Transactional(propagation = Propagation.REQUIRED,readOnly = false)
    public void upName(Integer id, String name) {
        Kuser kuser = kuserMapper.selectByPrimaryKey(id);
        kuser.setUsername(name);
        kuserMapper.updateByPrimaryKeySelective(kuser);
        //模拟异常
        int i = 1 / 0;
    }

注：Transactional里面定义属性，使用，隔开

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class UserTest2 {
    @Autowired
    private KuserService kuserService;
    @Test
    public void test3() {
        kuserService.upName(1, "lbb00");
    }
}

注解的方式比xml配置简单的多,但是考虑一下,当你的项目特别大,涉及的表很多的时候呢,你可能需要些很多很多的注解,假设后期需要修改某些属性,还得一个个改;

所以大项目建议采用XML,小项目使用注解也ok;

lbb-luckly

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring 事务处理

本质事务是一组sql语句的集合，事务具有原子性（同步，即要么全部执行，要么全部不执行）、一致性（事务执行完之后表里面的约束等不变）、持久性（一旦提交不能再被撤销），隔离性（两个事物之间是隔离的，互补干扰，是通过加锁实现的）。数据库操作最终都要使用到JDBC,那么无论上层如何封装,底层都是调用Connection的commit,rollback来完成事务处理弊端数据访问层(DAO)必然需要进...
复制链接

扫一扫

专栏目录