后端：事务

news/2024/11/25 3:44:42/

文章目录

    • 1. 事务
    • 2. Spring 单独配置DataSource
    • 3. 利用JdbcTemplate操作数据库
    • 4. 利用JdbcTemplate查询数据
    • 5. Spring 声明式事务
    • 6. 事务的隔离级别
      • 6.1 脏读
      • 6.2 不可重复读
      • 6.3 幻读
      • 6.4 不可重复读和幻读的区别
      • 6.5 三种方案的比较
    • 7. 事务的传播特性
    • 8. 设置事务 只读(readOnly)
    • 9. 超时属性(timeout)
    • 10. 异常属性
    • 11. 事务失效原因

1. 事务

一组关联的数据操作；要么全部成功，要么全部失败。
事务的四大特性：原子性、一致性、隔离性、持久性，即ACID。

  • 原子性：指一组业务操作下，要么全部成功，要么全部失败；
  • 一致性：在业务操作下，前后的数据保持一致；
  • 隔离性：并发操作下，事务之间要相互隔离；
  • 持久性：数据一旦保存，那么就是持久存在的。

2. Spring 单独配置DataSource

在Spring Boot项目中不需要单独配置DataSource，只需要在配置文件添加对应的数据库连接配置即可，在Spring项目中需要单独配置。
已经在application.properties文件做了相关数据库连接配置，为了在单元测试类中避免Spring Boot自动配置DataSource的影响，在单元测试类下新建spring文件夹，在这个文件夹下面新建相关类，用以演示Spring 单独配置DataSource，如下：
在这里插入图片描述
只要不要和启动类同在一个目录下，Spring Boot项目中DataSource就不会自动配置的，配置文件中的配置如下：

# 数据库连接配置
spring.datasource.url=jdbc:mysql://localhost:3306/mytest1
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

定义DataSource这个Bean的配置类代码如下：

package com.example.spring_database_1.spring;import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;import javax.sql.DataSource;@Configuration
public class MyConfiguration {@Value("${spring.datasource.url}")private String url;@Value("${spring.datasource.username}")private String usr;@Value("${spring.datasource.password}")private String pwd;@Value("${spring.datasource.driver-class-name}")private String driver;@Beanpublic DataSource dataSource(){DriverManagerDataSource dataSource = new DriverManagerDataSource();dataSource.setDriverClassName(driver);dataSource.setUrl(url);dataSource.setUsername(usr);dataSource.setPassword(pwd);return dataSource;}
}

单元测试类：

package com.example.spring_database_1.spring;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.ComponentScan;import javax.sql.DataSource;
import java.sql.SQLException;@SpringBootTest(classes =SpringDataSourceTest.class)
@ComponentScan
public class SpringDataSourceTest {@Testpublic void test1(@Autowired DataSource dataSource) throws SQLException {System.out.println(dataSource.getConnection());}
}

运行结果：
@SpringBootTest(classes =SpringDataSourceTest.class)表示当前这个类为单元测试类，并且还是一个启动类，不会和Spring Boot那个启动类产生关联，@ComponentScan表示自动扫描，没有指定的话默认是扫描当前包下的所有。
在这里插入图片描述

3. 利用JdbcTemplate操作数据库

在Spring项目中需要配置JdbcTemplate这个Bean，参考代码如下：

@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource){return new JdbcTemplate(dataSource);
}

这个和上面那个DataSource Bean放在同一个配置文件下，单元测试类如下，在mysql数据库中插入一条数据。

@Test
public void test2(@Autowired JdbcTemplate jdbcTemplate){int rows = jdbcTemplate.update("insert into user values(null,?)", "张三");System.out.println(rows);
}

在Spring Boot项目中，上述不需要单独配置，Spring Boot会自动进行配置的。

4. 利用JdbcTemplate查询数据

查询单个数据：

@Test
public void test3(@Autowired JdbcTemplate jdbcTemplate){String sql = "select * from user where u_id = ?";User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), 1);System.out.println(user);
}

运行结果：
在这里插入图片描述
实体用户类为：

package com.example.spring_database_1.entity;public class User {private Integer u_id;private String u_name;public Integer getU_id() {return u_id;}public void setU_id(Integer u_id) {this.u_id = u_id;}public String getU_name() {return u_name;}public void setU_name(String u_name) {this.u_name = u_name;}@Overridepublic String toString() {return "User{" +"u_id=" + u_id +", u_name='" + u_name + '\'' +'}';}
}

查询多个数据，可以改写上述代码为：

@Test
public void test3(@Autowired JdbcTemplate jdbcTemplate){String sql = "select * from user";List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));for (User user : users) {System.out.println(user);}
}

在这里插入图片描述

5. Spring 声明式事务

需要在一个配置类下定义事务管理的Bean，并且需要开启事务（使用注解 @EnableTransactionManagement），另外就是需要添加注解==@Transactional==（可以放在方法、类上）
配置类如下：

package com.example.spring_database_1.spring;import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.TransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;@Configuration
@EnableTransactionManagement
public class MyConfiguration {@Value("${spring.datasource.url}")private String url;@Value("${spring.datasource.username}")private String usr;@Value("${spring.datasource.password}")private String pwd;@Value("${spring.datasource.driver-class-name}")private String driver;@Beanpublic DataSource dataSource(){DriverManagerDataSource dataSource = new DriverManagerDataSource();dataSource.setDriverClassName(driver);dataSource.setUrl(url);dataSource.setUsername(usr);dataSource.setPassword(pwd);return dataSource;}@Beanpublic JdbcTemplate jdbcTemplate(DataSource dataSource){return new JdbcTemplate(dataSource);}@Beanpublic TransactionManager transactionManager(DataSource dataSource){return new DataSourceTransactionManager(dataSource);}
}

这是上述所有的Bean的配置。
示例方法为（添加了注解@Transactional）：

package com.example.spring_database_1.spring.dao;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;@Component
public class UserDao {@Autowiredprivate JdbcTemplate jdbcTemplate;@Transactionalpublic Integer insert(){int row = jdbcTemplate.update("insert into user values(null,?)", "张三");int a = 1 / 0;return row;}}

单元测试类为：

package com.example.spring_database_1.spring;import com.example.spring_database_1.spring.dao.UserDao;
import com.example.spring_database_1.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.List;@SpringBootTest(classes =SpringDataSourceTest.class )
@ComponentScan
public class SpringDataSourceTest {@Autowiredprivate UserDao ud;@Testpublic void test2(){int rows = ud.insert();}
}

运行结果当然也是会报错的，但是数据库中不会插入数据。
在这里插入图片描述
如果是Spring Boot项目，要达到上述效果，只需要在对应的类或者方法上添加注解 @Transactional 即可。
关于@Transactional注解的使用：

  • 放在类上面，表示当前这个类下的所有方法都会开启事务（这种通常不会使用，因为开启事务也是会占用一定资源的）；
  • 放在方法上面，表示当前这个方法开启事务（放在业务逻辑类下的方法上面）；

6. 事务的隔离级别

通过设置事务的隔离级别来解决并发过程中产生的一些问题。在并发情况下，对同一个数据（变量、对象）进行读写操作才产生的问题（脏读、不可重复读、幻读）。

6.1 脏读

现在有两个事务，事务2以微弱的优势首先进行修改操作，把一个值修改为100，此时事务1执行查询操作，得到值为100，但是事务2在执行过程中出现了异常，进行了事务回滚，此时的值没有得到修改，依旧是200，也就是说此时事务1得到值100是一个脏数据。
一个事务，读取了一个事务中没有提交的数据，会在本事务中产生数据不一致的问题。
解决方案：

@Transactional(isolation = Isolation.READ_COMMITTED)

这个不用设置，数据库默认都会保证都已提交

6.2 不可重复读

现在有两个事务，事务1以微弱的优势首先进行查询操作，得到结果为100，此时事务2执行修改操作，把对应的值修改为200，之后事务1又进行了一次查询操作，此时得到的值为200。
一个事务中，多次读取相同的数据，但是读取的结果不一样，从而造成在本事务中所读取的数据不一致的问题。
解决方案：

@Transactional(isolation = Isolation.REPEATABLE_READ)

相当于加上一个行锁。

6.3 幻读

现在有两个事务，事务1首先执行求和操作，对正常表里的一些数据进行求和操作，得到的值为100，而事务2执行了插入数据操作，插入了100，此时事务1又进行了一次求和操作，得到的值为200。
一个事务中，多次对数据进行整表数据读取，但是结果不一样，从而导致在本事务中产生数据不一致的问题。
解决方案：

@Transactional(isolation = Isolation.SERIALIZABLE)

相当于对整表上锁

6.4 不可重复读和幻读的区别

前者，只需要锁行；后者，需要锁表。

6.5 三种方案的比较

方案脏读不可重复都幻读
READ_COMMITTED不会可能出现可能出现
REPEATABLE_READ不会不会可能出现
SERIALIZABLE不会不会不会

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

数据库默认情况下设置了隔离级别：

在这里插入图片描述
上述是Mysql数据的隔离级别，如果是Oracle，它的隔离级别为READ_COMMITTED。

对于脏读，通过设置都已提交（行锁，读不会加锁）；对于不可重复读，需要设置重复读（行锁，读和写都会上锁）；对于幻读，通过设置串行化（表锁）。

7. 事务的传播特性

常用的 spring 的事务传播行为：

事务传播行为类型外部不存在事务（外层事务）外层存在事务（嵌套事务）使用方式
REQUIRED（默认）开启新的事务融合到外部事务中@Transactional(propagation = Propagation.REQUIRED)，适合增删改查，常用
SUPPORTS不开启新的事务融合到外部事务中@Transactional(propagation = Propagation.SUPPORTS)，适合查询
REQUIRES_NEW开启新的事务不用外部事务，创建新的事务中@Transactional(propagation = Propagation.REQUIRES_NEW)，适合内部事务和外部事务不存在业务关联，如日志，常用
NEVER不开启新的事务抛出异常@Transactional(propagation = Propagation.NEVER)，不常用

8. 设置事务 只读(readOnly)

readOnly：只会设置在查询的业务方法中
connection.setReadOnly(true)，通知数据库，当前数据库操作是只读，数据库就会当作只读做相应优化。

  1. readOnly并不是所有数据库都支持，不同的数据库下会有不同的结果；
  2. 设置readOnly后，connection都会被赋予readOnly，效果取决于数据库的实现。
package com.example.spring_database_1.spring.dao;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;@Component
public class UserDao {@Autowiredprivate JdbcTemplate jdbcTemplate;@Transactional(readOnly = true)public Integer insert(){return jdbcTemplate.update("insert into user values(null,?)", "张三");}
}

运行结果（设置为readOnly=true之后，在下面执行除查询之外的操作，所以报错。）：
在这里插入图片描述

9. 超时属性(timeout)

指定事务等待的最长时间（秒）
当前事务访问数据时，有可能访问的数据库被别的数据进行加锁处理，那么此时事务就必须等待，如果等待时间过长给用户造成的体验感差。

package com.example.spring_database_1.spring.dao;import com.example.spring_database_1.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;@Component
public class UserDao {@Autowiredprivate JdbcTemplate jdbcTemplate;@Transactional(timeout = 3)public Integer insert(){return jdbcTemplate.update("insert into user values(null,?)", "张三");}@Transactional(isolation = Isolation.SERIALIZABLE)public List<User> query(){List<User> users = jdbcTemplate.query("select * from user", new BeanPropertyRowMapper<>(User.class));try {Thread.sleep(100000);} catch (InterruptedException e) {e.printStackTrace();}return users;}}

package com.example.spring_database_1.spring;import com.example.spring_database_1.spring.dao.UserDao;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.ComponentScan;@SpringBootTest(classes =SpringDataSourceTest.class )
@ComponentScan
public class SpringDataSourceTest {@Testpublic void test1(@Autowired UserDao ud) throws InterruptedException {Thread thread = new Thread(()->{System.out.println("查询。。。");ud.query();});thread.start();Thread.sleep(1000);Thread thread2 = new Thread(()->{System.out.println("1。。。");ud.insert();System.out.println("2。。。");});thread2.start();thread.join();thread2.join();}}

运行结果：
在这里插入图片描述
查询操作那里使用了事务的隔离级别串行化，此时需要等待查询操作执行完毕，才会执行插入操作，但插入操作那里设置超时时间为3秒，超过3秒之后，此时报错。

10. 异常属性

设置当前事务出现的那些异常就进行回滚或者提交。
默认对于RuntimeException及其子类，采用的是回滚的策略。
默认对于非RuntimeException就不会回滚。

  1. 设置哪些异常不回滚（notRollbackFor）
  2. 设置那些异常回滚（rollbackFor）
@Transactional
public void rollbackFor() throws AlreadyBoundException {insert();throw new AlreadyBoundException("xxx异常");}

@Test
public void test2(@Autowired UserDao ud) throws AlreadyBoundException {ud.rollbackFor();
}

此时并没有回滚，数据库里边插入了一条数据，如下：
在这里插入图片描述
如果想所有异常都会回滚，可以设置如下：

@Transactional(rollbackFor = Exception.class)
public void rollbackFor() throws AlreadyBoundException {insert();throw new AlreadyBoundException("xxx异常");}

11. 事务失效原因

事务实现原理：动态代理
在这里插入图片描述

失效原因：

  • 保证事务类配置为一个Bean，@Component、@Service。。。；
  • 事务的方法不能是private；
  • 自己把异常捕捉了，并且没抛出去；
  • 动态代理层面失效原因：
    • 要让aop、事务生效，一定要通过动态代理的对象调用目标方法，不能通过普通对象去调用；
    • 直接调用本类的方法，没有通过动态代理的对象调用目方法，解决方案；
      • 将本类Bean自动装配进来（会产生循环依赖，Spring Boot中需要单独开启循环依赖支持，直接在配置文件中配置即可）；
      • ((xxx类)AopContext.currentProxy()).xxx方法（获取当前类）
        1. 前提需要 @EnableAspectJAutoProxy(exposeProxy = true)；
        2. 添加aop的依赖；
        3. 把本类的方法移动到其他类的Bean中，然后再把其他类自动装配进来；

http://www.ppmy.cn/news/1549713.html

相关文章

vue3封装echarts，传入配置即可使用，支持适配

vue3封装echarts，传入配置即可使用，支持适配

代码 <template><divref"chartRef"class"chart-container":style"{ width: Props.width, height: Props.height }"><!-- 当加载状态为 true 且图表尚未初始化时&#xff0c;显示 Loading 文本 --><div v-if"loading …
阅读更多...
中小企业人事管理自动化：SpringBoot实践

中小企业人事管理自动化：SpringBoot实践

第1章 绪论 1.1背景及意义 随着社会的快速发展&#xff0c;计算机的影响是全面且深入的。人们生活水平的不断提高&#xff0c;日常生活中人们对中小企业人事管理系统方面的要求也在不断提高&#xff0c;随着中小企业人事受到广大员工的关注&#xff0c;使得中小企业人事管理系统…
阅读更多...
Java 序列化详解

Java 序列化详解

一、什么是序列化和反序列化? 如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中&#xff0c;或者在网络传输 Java 对象&#xff0c;这些场景都需要用到序列化。 简单来说&#xff1a; 序列化&#xff1a;在序列化过程中&#xff0c;对象的状态被保存为一连串的字节…
阅读更多...
什么是驱动芯片？

什么是驱动芯片？

驱动芯片&#xff08;Driver Chip&#xff09;是一种集成电路芯片&#xff0c;主要用于驱动和控制各种电子设备或系统中的外部负载&#xff0c;如电机、显示屏、音频设备、LED 灯等&#xff0c;以下是关于驱动芯片的详细介绍&#xff1a; 主要功能 信号转换与放大&#xff1a;…
阅读更多...
中国电信星辰大模型：软件工厂与文生视频技术的深度解析

中国电信星辰大模型：软件工厂与文生视频技术的深度解析

在科技日新月异的今天，人工智能（AI）技术正以惊人的速度改变着我们的生活和工作方式。作为这一领域的领军企业之一，中国电信凭借其强大的研发实力和深厚的技术积累，推出了星辰大模型，旨在为用户带来更加智能、高效、便捷的服务体验。本文将重点介绍中国电信星辰大模型中的…
阅读更多...
ubuntu安装ros1

ubuntu安装ros1

以Ubuntu 18.04为例&#xff1a; 1.如果源没有切换到国内的建议切换 sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak sudo vi /etc/sources.list删除原来的源切换到清华大学源 # 默认注释了源码镜像以提高 apt update 速度&#xff0c;如有需要可自行取消注释 de…
阅读更多...
并查集---服务器广播

并查集---服务器广播

题目描述 服务器连接方式包括直接相连&#xff0c;间接相连。A和B直接连接&#xff0c;B和C直接连接&#xff0c;则A和C间接连接。直接连接和间接连接都可以发送广播。 给出一个 N * N 数组&#xff0c;代表N个服务器&#xff0c; matrix[i][j] 1&#xff0c;则代表 i 和 j …
阅读更多...
IText创建加盖公章的pdf文件并生成压缩文件

IText创建加盖公章的pdf文件并生成压缩文件

第一、前言 此前已在文章&#xff1a;Java使用IText根据pdf模板创建pdf文件介绍了Itex的基本使用技巧&#xff0c;本篇以一个案例为基础&#xff0c;主要介绍IText根据pdf模板填充生成pdf文件&#xff0c;并生成压缩文件。 第二、案例 以下面pdf模板为例&#xff0c;生成一个p…
阅读更多...
最新文章

Copyright @ 2022~2023