Spring5学习笔记3持久层整合
Spring5学习笔记3——持久层整合
配套视频参考:孙哥说Spring5
第三部分:整合持久层框架及相关问题
第一章、持久层整合
1. Spring框架为什么要与持久层技术进行整合?
- JavaEE开发需要持久层进行数据库的访问操作。
- JDBC、Hibernate、MyBatis开发过程存在大量的代码冗余
- Spring基于模板设计模式对于上述的持久层技术进行了封装
2. Spring可以与那些持久层技术进行整合?
1 | 1. JDBC |
3. Spring与MyBatis整合
3.1 MyBatis开发步骤的回顾
1 | 1. 实体 |
3.2 Mybatis在开发过程中存在问题
1 | 配置繁琐 代码冗余 |
3.3 Spring与Mybatis整合思路分析
3.4 Spring与Mybatis整合的开发步骤分析:
-
配置文件(ApplicationContext.xml) 的相关配置:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26<!-- 注意:以下一个项目只需要配置一次 -->
<bean id="dataSource" class=""/>
<!--注册SqlSessionFactoryBean 为了创建SqlSessionFactory-->
<bean id="ssfb" class="SqlSessionFactoryBean">
<property name="dataSource" ref=""/>
<property name="typeAliasesPackage">
指定 实体类所在的包 com.baizhiedu.entity User
Product
</property>
<property name="mapperLocations">
指定 配置文件(映射文件)的路径 还有通用配置
com.baizhiedu.mapper/*Mapper.xml
</property>
</bean>
<!--DAO接口的实现类
session ---> session.getMapper() --- xxxDAO实现类对象
XXXDAO ---> xXXDAO
-->
<bean id="scanner" class="MapperScannerConfigure">
<property name="sqlSessionFactoryBeanName" value="ssfb"/>
<property name="basePacakge">
指定 DAO接口放置的包 com.baizhiedu.dao
</property>
</bean> -
编码步骤:
1
2
3
4
5# 实战经常根据需求 写的代码
1. 实体
2. 表
3. 创建DAO接口
4. 实现Mapper文件
3.5 Spring与Mybatis整合真实编码:
-
搭建开发环境(jar):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.14.RELEASE</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.18</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.48</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency> -
Spring配置文件中的配置:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25<!--连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/suns?useSSL=false"></property>
<property name="username" value="root"></property>
<property name="password" value="123456"></property>
</bean>
<!--注册SqlSessionFactoryBean 为了创建SqlSessionFactory-->
<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="typeAliasesPackage" value="com.baizhiedu.entity"></property>
<property name="mapperLocations">
<list>
<value>classpath:com.baizhiedu.mapper/*Mapper.xml</value>
</list>
</property>
</bean>
<!--注册MapperScannerConfigure 用于创建Dao的实现类-->
<bean id="scanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactoryBean"></property>
<property name="basePackage" value="com.baizhiedu.dao"></property>
</bean> -
编码:
1
2
3
41. 实体
2. 表
3. DAO接口
4. Mapper文件配置
3.6 Spring与Mybatis整合细节
问题:Spring与Mybatis整合后,为什么DAO不提交事务,但是数据能够插入数据库中?
1 | 事务本质上是由连接对象控制的(Connection) ---> 连接池(DataSource) |
第二章、Spring的事务处理
1. 什么是事务?
1 | 事务是保证业务操作完整性的一种数据库机制。 |
2. 如何控制事务
1 | JDBC: |
3. Spring控制事务的开发步骤:
Spring是通过AOP的方式进行事务的开发
3.1 目标对象
1 | public class XXXUserServiceImpl{ |
3.2 额外功能
1 | 1. org.springframework.jdbc.datasource.DataSourceTransactionManager |
3.3 切入点
1 | @Transactional |
3.4 组装切面
1 | 1. 切入点 |
4. Spring控制事务的真实编码:
-
搭建开发环境:
1
2
3
4
5<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.1.14.RELEASE</version>
</dependency> -
编码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16<!-- 原始对象 -->
<bean id="userService" class="com.baizhiedu.service.UserServiceImpl">
<property name="userDAO" ref="userDAO"/>
</bean>
<!--DataSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 需要Connection 而Connection又在dataSource里 -->
<property name="dataSource" ref="dataSource"/>
</bean>
@Transactional
public class UserServiceImpl implements UserService {
private UserDAO userDAO;
<!-- 告诉Spring开启基于注解的事务管理 -->
<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/> -
细节:
1
2
3
4<tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true"/>
进行动态代理底层实现的切换 proxy-target-class
默认 false JDK
true Cglib
第三章、Spring的事务属性(Transaction Attribute)
1. 什么是事务属性?
1 | 属性:描述物体特征的一系列值 |
2. 如何添加事务属性
1 |
3. 事务属性详解
3.1 隔离属性 (ISOLATION)
-
隔离属性的概念
1
2
3
4
5
6
7
8
9
10
11概念:他描述了事务解决并发问题的特征
1. 什么是并发
多个事务(用户)在同一时间,访问操作了相同的数据
同一时间:0.000几秒 微小前 微小后
2. 并发会产生那些问题
1. 脏读
2. 不可重复读
3. 幻影读
3. 并发问题如何解决
通过隔离属性解决,隔离属性中设置不同的值,解决并发处理过程中的问题。 -
事务并发会产生的问题
-
脏读
1
2一个事务,读取了另一个事务中没有提交的数据。会在本事务中产生数据不一致的问题
解决方案 @Transactional(isolation=Isolation.READ_COMMITTED)
-
-
不可重复读
1
2
3
4一个事务中,多次读取相同的数据,但是读取结果不一样。会在本事务中产生数据不一致的问题
注意:1 不是脏读 2 一个事务中
解决方案 @Transactional(isolation=Isolation.REPEATABLE_READ)
本质: 一把行锁-
幻影读
1
2
3一个事务中,多次对整表进行查询统计,但是结果不一样,会在本事务中产生数据不一致的问题
解决方案 @Transactional(isolation=Isolation.SERIALIZABLE)
本质:表锁 -
总结
1
2并发安全: SERIALIZABLE > REPEATABLE_READ > READ_COMMITTED
运行效率: READ_COMMITTED > REPEATABLE_READ > SERIALIZABLE -
-
数据库对于隔离属性的支持
隔离属性值 MySQL Oracle ISOLATION_READ_COMMITTED ✅ ✅ IOSLATION_REPEATABLE_READ ✅ ❎ ISOLATION_SERIALIZABLE ✅ ✅ 1
2Oracle不支持REPEATABLE_READ值 如何解决不可重复读?
采用的是多版本比对的方式 解决不可重复读的问题 -
默认隔离属性
1
2
3
4ISOLATION_DEFAULT:会调用不同数据库所设置的默认隔离属性
MySQL : REPEATABLE_READ
Oracle: READ_COMMITTED -
查看数据库默认隔离属性
-
MySQL
1
select @@tx_isolation;
-
Oracle
1
2
3
4
5
6
7
8SELECT 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');
-
-
隔离属性在实战中的建议
1
2
3
4
5
6
7
8
9推荐使用Spring指定的ISOLATION_DEFAULT
1. MySQL repeatable_read
2. Oracle read_commited
未来实战中,并发访问情况,很少
如果真遇到并发问题,乐观锁
Hibernate(JPA) Version
MyBatis 通过拦截器自定义开发
3.2 传播属性(PROPAGATION)
-
传播属性的概念:
1
2
3
4
5概念:他描述了事务解决嵌套问题的特征
什么叫做事务的嵌套:他指的是一个大的事务中,包含了若干个小的事务
问题:大事务中融入了很多小的事务,他们彼此影响,最终就会导致外部大的事务,丧失了事务的原子性
-
传播属性的值极其用法:
传播属性的值 外部不存在事务 外部存在事务 用法 备注 REQUIRED 开启新的事务 融合到外部事务中 @Transactional(propagation = Propagation.REQUIRED) 增删改方法 SUPPORTS 不开启事务 融合到外部事务中 @Transactional(propagation = Propagation.SUPPORTS) 查询方法 REQUIRES_NEW 开启新的事务 挂起外部事务,创建新的事务 @Transactional(propagation = Propagation.REQUIRES_NEW) 日志记录方法中 NOT_SUPPORTED 不开启事务 挂起外部事务 @Transactional(propagation = Propagation.NOT_SUPPORTED) 及其不常用 NEVER 不开启事务 抛出异常 @Transactional(propagation = Propagation.NEVER) 及其不常用 MANDATORY 抛出异常 融合到外部事务中 @Transactional(propagation = Propagation.MANDATORY) 及其不常用 -
默认传播属性:
Propagation.REQUIRED
-
推荐传播属性的使用方式
1
2增删改 方法:直接使用默认值REQUIRED
查询 操作:显示指定传播属性的值为SUPPORTS
3.3 只读属性(readOnly)
针对于只进行查询操作的业务方法,可以加入只读属性,提供运行效率
默认值:false
3.4 超时属性(timeout)
1 | 指定了事务等待的最长时间 |
3.5 异常属性
1 | Spring事务处理过程中 |
4. 事务属性常见配置总结
1 | 1. 隔离属性 默认值 |
5. 基于标签的事务配置方式(事务开发的第二种形式)
-
基于注解 @Transaction的事务配置回顾
1
2
3
4
5
6
7
8
9
10
11
12
13
14<bean id="userService" class="com.baizhiedu.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(isolation=,propagation=,...)
public class UserServiceImpl implements UserService {
private UserDAO userDAO;
<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/> -
基于标签的事务配置:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27<bean id="userService" class="com.baizhiedu.service.UserServiceImpl">
<property name="userDAO" ref="userDAO"/>
</bean>
<!--DataSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 事务属性 -->
<tx:advice id="txAdvice" transacation-manager="dataSourceTransactionManager">
<tx:attributes>
<tx:method name="register" isoloation="",propagation=""></tx:method>
<tx:method name="login" .....></tx:method>
等效于
@Transactional(isolation=,propagation=,)
public void register(){
}
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="pc" expression="execution(* com.baizhiedu.service.UserServiceImpl.register(..))"></aop:pointcut>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pc"></aop:advisor>
</aop:config> -
基于标签的事务配置在实战中的应用方式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38<bean id="userService" class="com.baizhiedu.service.UserServiceImpl">
<property name="userDAO" ref="userDAO"/>
</bean>
<!--DataSourceTransactionManager-->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
编程时候 service中负责进行增删改操作的方法 都以modify开头
查询操作 命名无所谓
<tx:advice id="txAdvice" transacation-manager="dataSourceTransactionManager">
<tx:attributes>
<tx:method name="register"></tx:method>
<tx:method name="modify*"></tx:method>
<tx:method name="*" propagation="SUPPORTS" read-only="true"></tx:method>
</tx:attributes>
</tx:advice>
应用的过程中,service放置到service包中
<aop:config>
<aop:pointcut id="pc" expression="execution(* com.baizhiedu.service..*.*(..))"></aop:pointcut>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pc"></aop:advisor>
</aop:config>
查询操作 命名无所谓
<tx:advice id="txAdvice" transacation-manager="dataSourceTransactionManager">
<tx:attributes>
<tx:method name="register"></tx:method>
<tx:method name="modify*"></tx:method>
<tx:method name="*" propagation="SUPPORTS" read-only="true"></tx:method>
</tx:attributes>
</tx:advice>
应用的过程中,service放置到service包中
<aop:config>
<aop:pointcut id="pc" expression="execution(* com.baizhiedu.service..*.*(..))"></aop:pointcut>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pc"></aop:advisor>
</aop:config>
评论