本质
事务是一组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;