Spring学习笔记：持久层整合、Spring中的事务属性

最新推荐文章于 2021-03-23 23:35:18 发布

Don’t care.

最新推荐文章于 2021-03-23 23:35:18 发布

阅读量277

点赞数

分类专栏： spring 文章标签： java spring

本文链接：https://blog.csdn.net/studyeglish/article/details/106455377

版权

spring 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Spring笔记汇总

持久层整合、Spring中的事务属性

持久层整合
- 1、Spring框架为什么要与持久层技术进行整合
- 2、Spring可以与那些持久层技术进行整合?
Spring与MyBatis整合
Spring的事务处理
Spring中的事务属性(Transaction Attribute)

持久层整合

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)

MVC框架整合

Don’t care.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring学习笔记：持久层整合、Spring中的事务属性

第一章、持久层整合1、Spring框架为什么要与持久层技术进行整合JavaEE开发需要持久层进行数据库的访问操作。JDBC Hibernate MyBatis进行持久开发过程存在大量的代码冗余Spring基于模板设计模式对于上述的持久层技术进行了封装2、Spring可以与那些持久层技术进行整合?JDBC |- JDBCTemplateHibernate (JPA) |- HibernateTemplateMyBatis |- Sq1SessionFactoryBean Mapper
复制链接

扫一扫

专栏目录