持久层整合、Spring中的事务属性
持久层整合
1、Spring框架为什么要与持久层技术进行整合
- JavaEE开发需要持久层进行数据库的访问操作。
- JDBC Hibernate MyBatis进行持久开发过程存在大量的代码冗余
- Spring基于模板设计模式对于上述的持久层技术进行了封装
2、Spring可以与那些持久层技术进行整合?
JDBC
|- JDBCTemplate
Hibernate (JPA)
|- HibernateTemplate
MyBatis
|- Sq1SessionFactoryBean MapperScannerConfigure
Spring与MyBatis整合
1、MyBatis开发步骤及存在问题
1. 实体
2. 实体别名 配置繁琐
3. 表
4. 创建DA0接口
5. 实现Mapper文件
6. 注册Mapper文件 配置繁琐
7. MybatisAPI调用 代码冗余
2、简易实现
准备工作
<!--mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.19</version>
</dependency>
<!-- mybatis依赖-->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.4</version>
</dependency>
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration核心配置文件-->
<configuration>
<!--配置MyBatis运行环境-->
<environments default="development">
<environment id="development">
<!--配置JDBC事务管理-->
<transactionManager type="JDBC"/>
<!-- POOLED配置JDBC数据源连接池-->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test?useSSL=true"/>
<property name="username" value="root"/>
<property name="password" value="abc8658539"/>
</dataSource>
</environment>
</environments>
<mappers>
</mappers>
</configuration>
开发步骤
1. 实体
public class User implements Serializable {
private Integer id;
private String name;
private String password;
...
}
2. 实体别名
<typeAliases>
<typeAlias alias="user" type="com.company.entity.User"/>
</typeAliases>
3. 表
create table t_users(
id int primary key auto_increment,
name varchar(12)
password varchar(12));
4. 创建DA0接口
public interface UserDAO {
public void save(User user);
}
5. 实现Mapper文件 (命名空间:UserDao)
<mapper namespace="com.company.entity.UserDAO">
<insert id="save" parameterType="user">
insert into t_users(name,password) values (#{name},#{password})
</insert>
</mapper>
6. 注册Mapper文件
<mappers>
<mapper resource="UserDAOMapper.xml"/>
</mappers>
7. MybatisAPI调用
@Test
public void test() throws IOException {
// 读取配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
// 获取工厂
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 通过工厂获取sqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过User接口获取userDao
UserDAO userDAO = sqlSession.getMapper(UserDAO.class);
User user = new User();
user.setName("我");
user.setPassword("123");
userDAO.save(user);
sqlSession.commit();
}
}
错误:
org.apache.ibatis.binding.BindingException: Type interface com.company.entity.UserDAO is not known to the MapperRegistry.
<mapper namespace="com.company.entity.User"> 命名空间写错
<mapper namespace="com.company.entity.UserDAO"> 应该为接口
3、Spring与Mybatis整合思路
4、Spring与Mybatis整合的开发步骤
- 配置文件(ApplicationContext.xml)进行相关配置的开发
# 这些配置,实际上只需要配置一次
<bean id="dataSource" class=""/>
<!-- 创建SqlSessionFactory -->
<bean id="ssfb" class="SqlSessionFactoryBean">
<property name="dataSource" ref=""/>
<property name="typeAliasesPackage">
指定 实体类所在的包 com.company.entity
User
Product
...
</property>
<prpoperty name="mapperLocations">
指定配置文件(映射文件)的路径还有通用配置
com.baizhiedu.mapper/*Mapper .Xml
</prpoperty>
</bean>
<!--DA0接口的实现类
session -> session.getMapper() - xxxDA0实现类对象
XXXDAO-> xXXDAO
-->
<bean id="scanner" class="MapperScannerConfigure">
<property name="sqlSessionFactoryBeanName" value="ssfb" />
<property name="basePacakge">
指定DAO接口放置的包com.baizhiedu.dao
</property>
</bean>
- 编码:实战经常根据需求写的代码
- 实体
- 表
- 创建DAO接口
- 实现Mapper文件
5、Spring与Mybatis整合编码
-
搭建开发环境
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.19</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.4</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.2.6.RELEASE</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.3</version> </dependency> <!-- 连接池 --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.22</version> </dependency>
-
编码
applicationContext.xml <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/test"/> <property name="username" value="root"/> <property name="password" value="abc8658539"/> </bean> <!--创建SqlSessionFactory SqlSession FactoryBean--> <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="typeAliasesPackage" value="com.company.entity"/> <property name="mapperLocations"> <list> <value>classpath:com.company.mapper/*Mapper.xml</value> </list> </property> </bean> <!--创建DA0对象MapperScannerConfigure--> <bean id="scanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="sqlSessionFactoryBeanName" value="sqlSessionFactoryBean"/> <property name="basePackage" value="com.company.dao"/> </bean>
UserDAOMapper.xml <mapper namespace="com.company.dao.UserDAO"> <insert id="save" parameterType="User"> insert into t_users(name,password) values (#{name},#{password}) </insert> </mapper>
Test @Test public void test(){ ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml"); UserDAO userDao = (UserDAO) ctx.getBean("userDAO"); User user = new User(); user.setName("张三"); user.setPassword("123456"); userDao.save(user); }
6、Spring与Mybatis整合细节
问题:Spring与Mybatis整合后,为什么DAO不提交事务,但是数据能够插入数据库中?
Connection --> tx
Mybatis(Connection)
本质上控制连接对象(Connection) ---> 连接池(DataSource)
1. Mybatis提供的连接池对象 ---> 创建Connection
Connection.setAutoCommit(false)手工的控制了事务,操作完成后, 手工提交
2. Druid (C3PO DBCP) 作为连接池 ---> 创建Connection
Connection.setAutoCommit(true) true默认值保持自动控制事务,一条sql自动提交
答案:因为Spring与Mybatis整合时, 引入了外部连接池对象,保持自动的事务提交这个机制(Connection. setAutoCommit(true)) ,不需要手工进行事务的操作,也能进行事务的提交
注意:未来实战中,还会手工控制事务(多条sq1一起成功,一起失败),后续Spring通过事务控制解决这个问题。
Spring的事务处理
1、什么是事务?
保证业务操作完整性的一种数据库机制
事务的4特点: A C I D
- A:原子性
- C:一致性
- I:隔离性
- D:持久性
2、如何控制事务
JDBC:
Connection.setAutoCommit(false);
Connection.commit() ;
Connection.rollback() ;
Mybatis:
Mybatis自动开启事务
sq1Session(Connection).commit();
sqlSession(Connection).rollback();
结论:控制事务的底层 都是Connection对象完成的。
3、Spring控制事务的开发
Spring是通过AOP的方式进行事务开发
1 . 原始对象
public class XXXUserSerivcerImpl{
private xxxDAO xxxDAO;
set get
1. 原始对象 ---> 原始方法 ---> 核心功能 (业务处理+DAO调用)
2. DAO作为Service的成员变量,使用依赖注入的方式进行赋值
}
2 . 额外功能
1. MethodInterceptor
public Object invoke(MethodInvocation invacation){
try{
Connection.setAutoCommit(false);
Object ret = invocation.proceed();
Connection.commit();
}catch(Exception e){
Connection.rollback();
}
return ret;
}
2. @Aspect
@Around
public Object invoke(MethodInvocation invacation){
try{
Connection.setAutoCommit(false);
Object ret = invocation.proceed();
Connection.commit();
}catch(Exception e){
Connection.rollback();
}
return ret;
}
实际上都是相同的代码 ---> spring帮我们进行了封装
1.org.springframework.jdbc.datasource.DataSourceTransactionManager
2.注入DataSource(本质还是取得Connection,只不过是从连接池取而已)
3 . 切入点
@Transactional
事务的额外功能加入给那些业务方法
1. 类上:类中的所有方法都会加上事务
2. 方法上:这个方法会加上事务
4 . 组装切面
1.切入点
2.额外功能
<tx :annotation-driven transaction-manager=""/>
4、Spring控制事务的编码
-
搭建开发环境
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>5.2.6.RELEASE</version> </dependency>
-
编码
<bean id="userService" class="com.company.service.UserServiceImpl"> <property name="userDAO" ref="userDAO"/> </bean> <!-- DataSourceTransactionManager--> <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean> @Transactional public class UserServiceImpl implements UserService { private UserDAO userDAO; <!-- xmlns:tx="http://www.springframework.org/schema/tx" --> <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
@Transactional public class UserServiceImpl implements UserService { private UserDAO userDAO; get/set @Override public void login(User user) { // 插入数据 userDAO.save(user); } }
-
细节
<tx :annotation-driven transaction-manager="datalSourceTransactionManager" proxy-target-class="true" /> 进行动态代理底层实现的切换 proxy-target-class 默认 false JDK true Cglib
Spring中的事务属性(Transaction Attribute)
1、什么是事务属性
属性:描述物体特征的一系列值 (如:性别、身高、体重)
事务属性:描述事务特征的一系列值
- 隔离属性
- 传播属性
- 只读属性
- 超时属性
- 异常属性
2、如何添加事务属性
@Transactional(isloation= ,propagation= ,readonly= ,timeout= , rollbackFor= ,noRollbackFor=, )
3、事务属性详解
1. 隔离属性(ISOLATION)
-
隔离属性的概念
概念:他描述了事务解决并发问题的特征 1.什么是并发 多个事务(用户)在同一时间,访问操作了相同的数据 同一时间: 0. 000几秒微小前微小后 2.并发会产生那些问题 1.脏读 2.不可重复读 3.幻影读 3.并发问题如何解决 通过隔离属性解决,隔离属性中设置不同的值,解决并发处理过程中的问题。
-
事务并发产生的问题
-
脏读:一个事务,读取了另一个事务中没有提交的数据。会在本事务中产生数据不一致的问题。
解决方案 @Transactional (isolation=Isolation.READ_COMMITTED) (isolation:隔离 READ_COMMITTED:读取用户已提交的数据)
-
不可重复读:一个事务中,多次读取相同的数据,但是读取结果不一样。会在本事务中产生数据不一致的问题
注意: 1.不是脏读 2.一个事务中 解决方案 @Transactional(isolation=Isolation.REPEATABLE_READ) (REPEATABLE_READ:可重复读取:锁住一行数据)
-
幻影读:一个事务中,多次对整表进行查询统计,但是结果不一样。会在本事务中产生数据不一致的问题
解决方案 @Transactional(isolation=Isolation.SERIALIZABLE) 本质:表锁 (SERIALIZABLE:可序列化:锁住整个表)
-
总结
并发安全: SERIALIZABLE>REPEATABLE READ>READ_COMMITTED 运行效率: READ_COMMITTED>REPEATABLE READ>SERIALIZABLE
-
-
数据库对于隔离属性的支持
-
默认隔离属性
ISOLATION_DEFAULT:会调用不同数据库所设置的默认隔离属性 MySQL : REPEATABLE_READ Oracle: READ_ COMMITTED
-
查看数据库默认隔离属性
-
MySQL
select @@tx_isolation;
-
Qracle
SELECT s.sid, s.serial#, CASE BITAND(t.flag,POWER(2, 28)) WHEN 0 THEN 'READ COMMITTED' ELSE 'SERIALIZABLE' END AS isolation_level FROM v$transaction t JOIN v$session s ON t.addr = s.taddr AND s.sid = sys_context('USERENV','SID') ;
-
-
2. 传播属性
-
传播属性的概念
概念:他描述了事务解决嵌套问题的特征 什么叫做事务的嵌套:他指的是一个大的事务中,包含了若干个小的事务 问题:大事务中融入了很多小的事务,他们彼此影响,最终就会导致外部大的事务,丧失了事务的原子性
-
传播属性的值及其用法
-
默认的传播属性
REQUIRED是传播属性的默认值
-
推荐传播属性的使用方式
增删改方法:直接使用默认值REQUIRED 查询操作:显示指定传播属性的值为SUPPORTS
3. 只读属性
-
针对于只进行查询操作的业务方法,可以加入只读属性,提供运行效率
-
默认值: false
-
@Transactional public class UserServiceImpl implements UserService { private UserDAO userDAO; public UserDAO getUserDAO() { return userDAO; } public void setUserDAO(UserDAO userDAO) { this.userDAO = userDAO; } @Override public void register(User user) { userDAO.save(user); } // 查询操作 @Override @Transactional(propagation = Propagation.SUPPORTS,readOnly = true) public void login(String name, String password) {} }
4. 超时属性(timeout)
指定了事务等待的最长时间
1.为什么事务进行等待?
当前事务访问数据时,有可能访问的数据被别的事务进行加锁的处理,那么此时本事务就必须进行等待。
2.等待时间秒
3.如何应用@Transactional (timeout=2)
4.超时属性的默认值-1
最终由对应的数据库来指定
5. 异常属性
Spring事务处理过程中
默认对于RuntimeException及其子类采用的是回滚的策略
默认对于Exception及其子类采用的是提交的策略
rollbackFor = {java.lang.Exception.xxx.xxx}
noRollbackFor = {java.lang.RuntimeException.xxx.xxx}
@Transactional(rollbackFor = {java.lang.Exception.class}, noRollbackFor = {java.lang.RuntimeException.class})
建议:实战中使用RuntimeExceptin及其子类使用事务异常属性的默认值
4、事务属性常见配置总结
1.隔离属性 默认值
2.传播属性 Required(默认值)增删改Supports 查询操作
3.只读属性 read0nly false 增删改 true 查询操作
4.超时属性 默认值-1
5.异常属性 默认值
增删改操作
@Transactional
查询操作
@Transactional(propagation=Propagation.SUPPORTS, read0nly=true)