Day382.持久层整合 -Spring5

2024-03-15 09:08:47

持久层整合

一、持久层整合

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

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

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

JDBC
|- JDBCTemplate
Hibernate (JPA)
|- HibernateTemplate
MyBatis
|- SqlSessionFactoryBean MapperScannerConfigure

⼆、Spring与MyBatis整合

1. MyBatis开发步骤的回顾

实体
实体别名
表
创建DAO接⼝
实现Mapper⽂件
注册Mapper⽂件
MybatisAPI调⽤

2. Mybatis在开发过程中存在问题

配置繁琐代码冗余

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

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.achang.entity User
        Product
    </property>
    
    <property name="mapperLocations">
        指定 配置⽂件(映射⽂件)的路径 还有通⽤配置
        com.achang.mapper/*Mapper.xml
    </property>
    
</bean>

<!--DAO接⼝的实现类
	session ---> session.getMapper() --- xxxDAO实现类对象
	XXXDAO ---> xXXDAO
-->
<bean id="scanner" class="MapperScannerConfigure">
    指定我们上面配置的工厂bean
    <property name="sqlSessionFactoryBeanName" value="ssfb"/>
    
    <property name="basePacakge">
        指定 DAO接⼝放置的包 com.achang.dao
    </property>
</bean>

编码

# 实战经常根据需求 写的代码
1. 实体
2. 表
3. 创建DAO接⼝
4. 实现Mapper⽂件

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/achang?useSSL=false"></property>
    <property name="username" value="root"></property>
    <property name="password" value="123456"></property>
</bean>

<!--创建SqlSessionFactory SqlSessionFactoryBean-->
<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"></property>
    <property name="typeAliasesPackage" value="com.achang.entity"></property>
    <property name="mapperLocations">
        <list>
            <value>classpath:com.achang.mapper/*Mapper.xml</value>
        </list>
    </property>
</bean>

<!--创建DAO对象 MapperScannerConfigure-->
<bean id="scanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactoryBean"></property>
    <property name="basePackage" value="com.achang.dao">
    </property>
</bean>

编码
1. 实体
2. 表
3. DAO接⼝
4. Mapper⽂件配置

6. Spring与Mybatis整合细节

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

Connection --> tx
Mybatis(Connection)

本质上控制连接对象(Connection) —> 连接池(DataSource)
- Mybatis提供的连接池对象 —> 创建Connection
  Connection.setAutoCommit(false) ⼿⼯的控制了事务，操作完成后，⼿⼯提交
- Druid（C3P0 DBCP）作为连接池 —> 创建ConnectionConnection.setAutoCommit(true) true默认值保持⾃动控制事务，⼀条sql ⾃动提交
- 答案：因为Spring与Mybatis整合时，引⼊了外部连接池对象，保持⾃动的事务提交这个机制(Connection.setAutoCommit(true)),不需要⼿⼯进⾏事务的操作，也能进⾏事务的提交
- 注意：
  
  未来实战中，还会⼿⼯控制事务(多条sql⼀起成功，⼀起失败)，后续Spring通过事务控制解决这个问题。

三、Spring的事务处理

1. 什么是事务？

保证业务操作完整性的⼀种数据库机制

事务的4特点： A C I D

A 原⼦性
C ⼀致性
I 隔离性
D 持久性

2. 如何控制事务

JDBC:

Connection.setAutoCommit(false);
Connection.commit();
Connection.rollback();

Mybatis：
Mybatis⾃动开启事务

sqlSession(Connection).commit();
sqlSession(Connection).rollback();

结论：

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

3.Spring控制事务的开发

Spring是通过AOP的⽅式进⾏事务开发

1. 原始对象

public class XXXUserServiceImpl{
    private xxxDAO xxxDAO
        set/get()
        1. 原始对象 ---》 原始⽅法 ---》核⼼功能 (业务处理+DAO调⽤)
        2. DAO作为Service的成员变量，依赖注⼊的⽅式进⾏赋值
}

2. 额外功能

org.springframework.jdbc.datasource.DataSourceTransactionManager;注⼊DataSource

MethodInterceptor

public Object invoke(MethodInvocation invocation){
    try{
        Connection.setAutoCommit(false);
        Object ret = invocation.proceed();
        Connection.commit();
    }catch(Exception e){
        Connection.rollback();
    }
    return ret;
}

@Aspect

@Around

3. 切⼊点

@Transactional

事务的额外功能加⼊给那些业务⽅法。

类上：类中所有的⽅法都会加⼊事务
⽅法上：这个⽅法会加⼊事务

4.组装切⾯

切⼊点
额外功能

<tx:annotation-driven transaction-manager=""/>
他会自动的去扫描，我们上面配置的注解的信息

4. Spring控制事务的编码

搭建开发环境 (jar)

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

编码

原始对象
<bean id="userService" class="com.achang.service.UserServiceImpl">
    为Service对象，注入Dao接口
    <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;
}

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

此时，就会去service下去扫描到带@Transactional的类，就会为其进行实现事务的额外功能

细节

进⾏动态代理底层实现的切换 proxy-target-class
默认 false JDK
true Cglib

<tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true"/>

四、 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)
- 不可重复读
  
  ⼀个事务中，多次读取相同的数据，但是读取结果不⼀样。会在本事务中产⽣数据不⼀致的问题
  注意：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 1 1

IOSLATION_REPEATABLE_READ 1 0

ISOLATION_SERIALIZABLE 1 1

Oracle不⽀持REPEATABLE_READ值如何解决不可重复读

采⽤的是多版本⽐对的⽅式解决不可重复读的问题

隔离属性的值	MySQL	Oracle
ISOLATION_READ_COMMITTED	1	1
IOSLATION_REPEATABLE_READ	1	0
ISOLATION_SERIALIZABLE	1	1

默认隔离属性

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 通过拦截器⾃定义开发

2. 传播属性(PROPAGATION)

传播属性的概念

描述了事务解决嵌套问题的特征
- 什么叫做事务的嵌套：
  - 他指的是⼀个⼤的事务中，包含了若⼲个⼩的事务
- 问题：
  - ⼤事务中融⼊了很多⼩的事务，他们彼此影响，最终就会导致外部⼤的事务，丧失了事务的原⼦性
传播属性的值及其⽤法
默认的传播属性

REQUIRED是传播属性的默认值
推荐传播属性的使⽤⽅式

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

3. 只读属性(readOnly)

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

默认值：false

4. 超时属性(timeout)

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

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

现实中真的有充钱加速的，防止甲方赖皮，性能先调低一点，懂的都懂

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. 事务属性常⻅配置总结

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

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

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

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

原始对象
<bean id="userService" class="com.baizhiedu.service.UserServiceImpl">
    <property name="userDAO" ref="userDAO"/>
</bean>

spring封装的事务额外功能
<!--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>

spring封装的事务额外功能
<!--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.achang.service.UserServiceImpl.register(..))"></aop:pointcut>
    
    组装
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"></aop:advisor>
</aop:config>

基于标签的事务配置在实战中的应⽤⽅式

原始对象
<bean id="userService" class="com.achang.service.UserServiceImpl">
    <property name="userDAO" ref="userDAO"/>
</bean>

spring封装的事务额外功能
<!--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>
        指定register使用默认事务属性
        <tx:method name="register"></tx:method>
        指定方法开头为modify后面xxx都用默认的事务属性
        <tx:method name="modify*"></tx:method>
        指定除上面以外明确定义的以外都指定为如下的事务属性
        <tx:method name="*" propagation="SUPPORTS" read-only="true"></tx:method>
    </tx:attributes>
</tx:advice>

应⽤的过程中，service放置到service包中
<aop:config>
    切入点表达式，通过【包切入点】com.achang.service包下面及其子包中的所有方法
    <aop:pointcut id="pc" expression="execution(* com.achang.service..*.*(..))"></aop:pointcut>
    
    组装
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"></aop:advisor>
</aop:config>

码农公寓