Spring5学习笔记3——持久层整合（转载三方+补充）

最新推荐文章于 2024-05-03 10:06:59 发布

_dolphin

最新推荐文章于 2024-05-03 10:06:59 发布

阅读量238

点赞数

分类专栏： Java框架文章标签： spring java

本文链接：https://blog.csdn.net/qq_30591155/article/details/109613413

版权

Java框架专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Spring5学习笔记3——持久层整合

第三部分：整合持久层框架及相关问题

第一章、持久层整合

1. Spring框架为什么要与持久层技术进行整合？

JavaEE开发需要持久层进行数据库的访问操作。
JDBC、Hibernate、MyBatis开发过程存在大量的代码冗余
Spring基于模板设计模式对于上述的持久层技术进行了封装

2. Spring可以与那些持久层技术进行整合？

1. JDBC
     |-  JDBCTemplate 
2. Hibernate (JPA)
     |-  HibernateTemplate
3. MyBatis
     |-  SqlSessionFactoryBean MapperScannerConfigure

3. Spring与MyBatis整合

3.1 MyBatis开发步骤的回顾

1. 实体
2. 实体别名  
3. 表
4. 创建DAO接口
5. 实现Mapper文件
6. 注册Mapper文件
7. MybatisAPI调用

3.2 Mybatis在开发过程中存在问题

配置繁琐  代码冗余 

1. 实体
2. 实体别名         配置繁琐 
3. 表
4. 创建DAO接口
5. 实现Mapper文件
6. 注册Mapper文件   配置繁琐 
7. MybatisAPI调用  代码冗余

3.3 Spring与Mybatis整合思路分析

3.4 Spring与Mybatis整合的开发步骤分析：

配置文件（ApplicationContext.xml) 的相关配置：

<!-- 注意：以下一个项目只需要配置一次 --> 
<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. 创建DAO接口
4. 实现Mapper文件

3.5 Spring与Mybatis整合真实编码：

搭建开发环境(jar)：

<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配置文件中的配置：

<!--连接池-->
<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. DAO接口
4. Mapper文件配置

3.6 Spring与Mybatis整合细节

问题：Spring与Mybatis整合后，为什么DAO不提交事务，但是数据能够插入数据库中？

事务本质上是由连接对象控制的(Connection) ---> 连接池(DataSource)
1. Mybatis提供的连接池对象 ---> 创建Connection
     Connection.setAutoCommit(false) 关闭了自动提交，即需要手动控制事务（提交/回滚）
2. Druid（C3P0 DBCP）作为连接池        ---> 创建Connection
     Connection.setAutoCommit(true) true默认值 自动提交 
答案：因为Spring与Mybatis整合时，引入了外部连接池对象，保持自动的事务提交这个机制(Connection.setAutoCommit(true)),不需要手动进行事务的操作，也能进行事务的提交 

注意：未来实战中，使用手动控制事务(多条sql一起成功，一起失败)，后续Spring通过事务控制解决这个问题。

第二章、Spring的事务处理

1. 什么是事务？

事务是保证业务操作完整性的一种数据库机制。

事务的4特点： A C I D
1. A(Atomicity) 	原子性 
2. C(Consistency) 	一致性
3. I(Isolation)		隔离性
4. D(durability) 	持久性

2. 如何控制事务

JDBC:
    Connection.setAutoCommit(false);
    Connection.commit();
    Connection.rollback();
Mybatis：
    Mybatis自动开启事务
    
    sqlSession(Connection).commit();
    sqlSession(Connection).rollback();

结论：控制事务的底层 都是Connection对象完成的。

3. Spring控制事务的开发步骤：

Spring是通过AOP的方式进行事务的开发

3.1 目标对象

public class XXXUserServiceImpl{
   private xxxDAO xxxDAO
   set get

   1. 原始对象 ---》 原始方法 ---》核心功能 (业务处理+DAO调用)
   2. DAO作为Service的成员变量，依赖注入的方式进行赋值
}

3.2 额外功能

1. org.springframework.jdbc.datasource.DataSourceTransactionManager
2. 注入DataSource 
1. MethodInterceptor
   public Object invoke(MethodInvocation invocation){
   	  //原理：
      try{
        Connection.setAutoCommit(false);
        Object ret = invocation.proceed();
        Connection.commit();
      }catch(Exception e){
        Connection.rollback();
      }
        return ret;
   }
2. @Aspect
   @Around

3.3 切入点

@Transactional 
事务的额外功能加入给哪些业务方法。

1. 类上：类中所有的方法都会加入事务
2. 方法上：这个方法会加入事务

3.4 组装切面

1. 切入点
2. 额外功能

<tx:annotation-driven transaction-manager=""/>

4. Spring控制事务的真实编码：

搭建开发环境：

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>5.1.14.RELEASE</version>
</dependency>

编码：

<!-- 原始对象 -->
<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"/>

细节：

<tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true"/>
进行动态代理底层实现的切换   proxy-target-class
	默认	false JDK
		 true  Cglib

第三章、Spring的事务属性（Transaction Attribute）

1. 什么是事务属性？

属性：描述物体特征的一系列值
     性别 身高 体重 ...
事务属性：描述事务特征的一系列值 
1. 隔离属性
2. 传播属性
3. 只读属性
4. 超时属性
5. 异常属性

2. 如何添加事务属性

@Transactional(isloation=,propagation=,readOnly=,timeout=,rollbackFor=,noRollbackFor=,)

3. 事务属性详解

3.1 隔离属性 (ISOLATION)

隔离属性的概念

概念：他描述了事务解决并发问题的特征
1. 什么是并发
       多个事务(用户)在同一时间，访问操作了相同的数据
       
       同一时间：0.000几秒 微小前 微小后
2. 并发会产生那些问题
       1. 脏读
       2. 不可重复读
       3. 幻影读
3. 并发问题如何解决
       通过隔离属性解决，隔离属性中设置不同的值，解决并发处理过程中的问题。

事务并发会产生的问题

脏读

一个事务，读取了另一个事务中没有提交的数据。会在本事务中产生数据不一致的问题
解决方案  @Transactional(isolation=Isolation.READ_COMMITTED)

不可重复读

一个事务中，多次读取相同的数据，但是读取结果不一样。会在本事务中产生数据不一致的问题
注意：1 不是脏读 2 一个事务中
解决方案 @Transactional(isolation=Isolation.REPEATABLE_READ)
本质： 一把行锁

幻影读

一个事务中，多次对整表进行查询统计，但是结果不一样，会在本事务中产生数据不一致的问题
解决方案 @Transactional(isolation=Isolation.SERIALIZABLE)
本质：表锁

总结

并发安全： SERIALIZABLE > REPEATABLE_READ > READ_COMMITTED
运行效率： READ_COMMITTED > REPEATABLE_READ > SERIALIZABLE

数据库对于隔离属性的支持

隔离属性值 MySQL Oracle
ISOLATION_READ_COMMITTED ✅ ✅
IOSLATION_REPEATABLE_READ ✅ ❎
ISOLATION_SERIALIZABLE ✅ ✅
```
Oracle不支持REPEATABLE_READ值 如何解决不可重复读?
采用的是多版本比对的方式 解决不可重复读的问题
```

隔离属性值	MySQL	Oracle
ISOLATION_READ_COMMITTED	✅	✅
IOSLATION_REPEATABLE_READ	✅	❎
ISOLATION_SERIALIZABLE	✅	✅

默认隔离属性

ISOLATION_DEFAULT：会调用不同数据库所设置的默认隔离属性

MySQL : REPEATABLE_READ 
Oracle: READ_COMMITTED

查看数据库默认隔离属性

MySQL
```
select @@tx_isolation;
```

Oracle

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');

隔离属性在实战中的建议

推荐使用Spring指定的ISOLATION_DEFAULT
 1. MySQL   repeatable_read
 2. Oracle  read_commited 

未来实战中，并发访问情况，很少

如果真遇到并发问题，乐观锁 
   Hibernate(JPA)  Version 
   MyBatis         通过拦截器自定义开发

3.2 传播属性（PROPAGATION）

传播属性的概念：

概念：他描述了事务解决嵌套问题的特征

什么叫做事务的嵌套：他指的是一个大的事务中，包含了若干个小的事务

问题：大事务中融入了很多小的事务，他们彼此影响，最终就会导致外部大的事务，丧失了事务的原子性

自己的理解：
当事务方法被另一个事务方法所调用时，Spring如何处理方法间存在的多个事务。spring传播属性定义了多个事务同时存在时如何处理的解决方案。

这里存在几个疑问点？
1. 什么是事务方法被另一个事务方法调用？
2. 多个事务同时存在什么意思？
首先你应该知道，spring事务是通过动态代理实现的，当对service层下的某个方法或者类标注@Transaction注解或者通过<tx:advice>和<aop:config>标签配置的事务，不管是对方法进行事务配置还是整个类进行事务配置，最终在容器中拿到的类对象是代理对象（默认是采用JDK的动态代理）。
示例：
class Service {
	@Transaction
	public void service1() {
		...
		service2()	↓
	}
	public void service2() {
	...
	}
}
getBean->service代理对象 service调用service1
(1)调用其service1方法进行dao操作,此时service1方法是会受到事务控制的，方法中如果出现运行时异常，事务自动回滚，如果service1中对service2方法进行了调用，service2同样也会受到service1当前存在事务的控制，异常或者其他错误行为，会被service1事务处理。
比如在service2中模拟算数异常，抛出异常后，若service2没有异常处理的话，异常就会被service1的事务拦截到，保证了数据完整性和一致性。

class Service {
	@Transaction
	public void service1() {
		...
		service2()	↓
	}
	@Transaction
	public void service2() {
	...
	}
}
(2)service1内部调用service2，并且service2()标注了事务注解@Transaction，如果service2出现异常，这时候依然能够保证事务，注意，并不是service2保证的事务，而是service1所做的，当前service对象调用service1，方法内部又调用了service2，尽管service2标注了事务注解@Transaction，但自始至终类中运行的事务只存在一个。为什么？其实不难理解，IOC容器拿到的service是代理对象，调用对象的service1方法，实质是调用代理对象的service1方法，以JDK动态代理为例，在原始对象的真实方法执行之前会调用invoke方法，其中通过控制method.invoke(真实对象，args)来调用真实对象的方法servic1，而service1内部对service2的调用是通过真实对像(this)调用的而不是代理对象，就是因为method.invoke(真实对象，args)。好好理解一下。

有什么方法在service1中调用代理对象的service2吗？
有的，将Service implements ApplicationContextAware接口，重写setApplicationContext拿到容器，再次在容器中获取service对象，调用的时候使用代理对象调用就可以了。


class Service {
	@Transaction
	public void service1() {
		...
	}

	public void service2() {
		... 
		service1()	↑
	}
}
(3) 没有事务的service2()方法内部调用service1
service对象任然是代理对象，service.service2()执行，当在service2或者service1中出现的任何异常都不会得到事务控制，原因就是代理对象的service2()方法没有加入事务控制，内部service1()的调用是通过this对象调用的而不是代理对象。

(1)(2)(3)案例提醒我们在开发中，在一个事务方法中去调用同类中的另一个事务方法或者非事务方法，调用本类下的的非事务方法或者事务方法事务都是可以保障的，是通过本事务方法中的事务所保证，事务方法内部被调用的事务方法不会开启新事务，因为动态代理底层的原理是事务方法内部的调用是通过this而不是代理对象。

以上就是单个事务的情况，什么时候会出现多事务方法之间同时存在呢？
事务属于额外功能，而代理就是给原始类增加额外功能，代理对象就是原始对象的增强，当一个类下的事务方法通过对象调用另一个类的事务方法时，就会出现多事务方法同在的情况，因为对象是代理对象(只要某个类下存在了事务，该类在的对象就是代理对象)，如下
class ServiceA {
	//autowired 或者 setter注入
	private ServiceB serviceB;
	@Transaction
	public void serviceA() {
		...
		serviceB.serviceB() ↓
	}
}
class ServiceB {
	@Transaction
	public void serviceB() {
		...
	}
}
执行 serviceA.serviceA(); 
serviceA和serviceB对象都是代理对象，都调用被事务管理的方法，方法都会得到增强，这样就会有
tx-A
...
    tx-B
    ...
    tx-B
...
tx-A
tx-B所增强的方法能成功执行，但是tx-A在最后出现了错误，这时候tx-B之前的操作是有效还是无效。
传播属性就解决当外部存在事务时，内部事务和外部事务如何协商的问题。

传播属性的值极其用法：

传播属性的值	外部不存在事务	外部存在事务	用法	备注
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

推荐传播属性的使用方式

增删改 方法：直接使用默认值REQUIRED 
查询   操作：显示指定传播属性的值为SUPPORTS

3.3 只读属性(readOnly)

针对于只进行查询操作的业务方法，可以加入只读属性，提供运行效率

默认值：false

3.4 超时属性(timeout)

指定了事务等待的最长时间

1. 为什么事务进行等待？
   当前事务访问数据时，有可能访问的数据被别的事务进行加锁的处理，那么此时本事务就必须进行等待。
2. 等待时间 秒
3. 如何应用 @Transactional(timeout=2)
4. 超时属性的默认值 -1 
   最终由对应的数据库来指定

3.5 异常属性

Spring事务处理过程中
默认 对于RuntimeException及其子类 采用的是回滚的策略
默认 对于Exception及其子类 采用的是提交的策略

rollbackFor = {java.lang.Exception,xxx,xxx} 
noRollbackFor = {java.lang.RuntimeException,xxx,xx}

@Transactional(rollbackFor = {java.lang.Exception.class},noRollbackFor = {java.lang.RuntimeException.class})

建议：实战中使用RuntimeExceptin及其子类 使用事务异常属性的默认值

4. 事务属性常见配置总结

1. 隔离属性   默认值 
2. 传播属性   Required(默认值) 增删改   Supports 查询操作
3. 只读属性   readOnly false  增删改   true 查询操作
4. 超时属性   默认值 -1
5. 异常属性   默认值 

增删改操作   @Transactional
查询操作     @Transactional(propagation=Propagation.SUPPORTS,readOnly=true)

5. 基于标签的事务配置方式(事务开发的第二种形式)

基于注解 @Transaction的事务配置回顾

<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"/>

基于标签的事务配置：

<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>

基于标签的事务配置在实战中的应用方式

<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>

_dolphin

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring5学习笔记3——持久层整合（转载三方+补充）

Spring5学习笔记3——持久层整合文章目录Spring5学习笔记3——持久层整合第三部分：整合持久层框架及相关问题第一章、持久层整合1. Spring框架为什么要与持久层技术进行整合？2. Spring可以与那些持久层技术进行整合？3. Spring与MyBatis整合3.1 MyBatis开发步骤的回顾3.2 Mybatis在开发过程中存在问题3.3 Spring与Mybatis整合思路分析3.4 Spring与Mybatis整合的开发步骤分析：3.5 Spring与Mybatis整合真实编码：3.
复制链接

扫一扫