12.Spring事务和事务传播机制

文章目录

  • 1.为什么需要事务
  • 2.Spring 中事务的实现
    • 2.1 MySQL 中的事务使⽤
    • 2.2 Spring 编程式事务
    • 2.3 Spring 声明式事务（自动）
      • 2.3.1 @Transactional 作⽤范围
      • 2.3.2 @Transactional 参数说明
      • 2.3.3 注意事项
      • 2.3.4 @Transactional ⼯作原理
  • 3.事务隔离级别
    • 3.1 事务特性回顾
    • 3.2 Spring 中设置事务隔离级别
      • 3.2.1 MySQL 事务隔离级别有 4 种
      • 3.2.2 Spring 事务隔离级别有 5 种
  • 4.Spring 事务传播机制
    • 4.1 事务传播机制是什么？
    • 4.2 为什么需要事务传播机制？
    • 4.3 事务传播机制有哪些？
    • 4.4 Spring 事务传播机制使⽤和各种场景演示
      • 4.4.1 ⽀持当前事务（REQUIRED）
      • 4.4.2 不⽀持当前事务（REQUIRES_NEW）
      • 4.4.3 不⽀持当前事务，NEVER 抛异常
  • 总结

大家好，我是晓星航。今天为大家带来的是 Spring事务和事务传播机制 相关的讲解！😀

1.为什么需要事务

事务定义

将⼀组操作封装成⼀个执⾏单元（封装到⼀起），要么全部成功，要么全部失败。

为什么要⽤事务？

⽐如转账分为两个操作：

第⼀步操作：A 账户 -100 元。

第⼆步操作：B 账户 +100 元。

如果没有事务，第⼀步执⾏成功了，第⼆步执⾏失败了，那么 A 账户平⽩⽆故的 100 元就“⼈间蒸发”了。⽽如果使⽤事务就可以解决这个问题，让这⼀组操作要么⼀起成功，要么⼀起失败。

2.Spring 中事务的实现

Spring 中的事务操作分为两类：

  1. 编程式事务（⼿动写代码操作事务）。
  2. 声明式事务（利⽤注解⾃动开启和提交事务）。

在开始讲解它们之前，咱们先来回顾事务在 MySQL 中是如何使⽤的？

2.1 MySQL 中的事务使⽤

事务在 MySQL 有 3 个重要的操作：开启事务、提交事务、回滚事务，它们对应的操作命令如下：

-- 开启事务
start transaction;
-- 业务执行-- 提交事务
commit;
-- 回滚事务
rollback;

2.2 Spring 编程式事务

Spring ⼿动操作事务和上⾯ MySQL 操作事务类似，它也是有 3 个重要操作步骤：

  • 开启事务（获取事务）
  • 提交事务
  • 回滚事务

SpringBoot 内置了两个对象，DataSourceTransactionManager ⽤来获取事务（开启事务）、提交或回滚事务的，⽽ TransactionDefinition 是事务的属性，在获取事务的时候需要将 TransactionDefinition 传递进去从⽽获得⼀个事务 TransactionStatus，实现代码如下：

@RestController
public class UserController {@Resourceprivate UserService userService;// JDBC 事务管理器@Resourceprivate DataSourceTransactionManager dataSourceTransactionManager;// 定义事务属性@Resourceprivate TransactionDefinition transactionDefinition;@RequestMapping("/sava")public Object save(User user) {// 开启事务TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);// 插⼊数据库int result = userService.save(user);// 提交事务dataSourceTransactionManager.commit(transactionStatus);
// // 回滚事务
// dataSourceTransactionManager.rollback(transactionStatus);return result;}
}

从上述代码可以看出，以上代码虽然可以实现事务，但操作也很繁琐，有没有更简单的实现⽅法呢？请看下⾯声明式事务。

2.3 Spring 声明式事务（自动）

声明式事务的实现很简单，只需要在需要的⽅法上添加 @Transactional 注解就可以实现了，⽆需⼿动开启事务和提交事务，进⼊⽅法时⾃动开启事务，⽅法执⾏完会⾃动提交事务，如果中途发⽣了没有处理的异常会⾃动回滚事务，具体实现代码如下：

@RequestMapping("/save")
@Transactional
public Object save(User user) {int result = userService.save(user);return result;
}

接下⾥使⽤以下代码，分别设置 @Transactional 注解和不设置 @Transactional，观察它们的执⾏区别：

image-20240402183941080

2.3.1 @Transactional 作⽤范围

@Transactional 可以⽤来修饰⽅法或类：

  • 修饰⽅法时：需要注意只能应⽤到 public ⽅法上，否则不⽣效。推荐此种⽤法。

  • 修饰类时：表明该注解对该类中所有的 public ⽅法都⽣效。

2.3.2 @Transactional 参数说明

image-20240402184125234

2.3.3 注意事项

@Transactional 在异常被捕获的情况下，不会进⾏事务⾃动回滚，验证以下代码是否会发⽣事务回滚：

@RestController
public class UserController {@Resourceprivate UserService userService;@RequestMapping("/save")@Transactionalpublic Object save(User user) {// 插⼊数据库int result = userService.save(user);try {// 执⾏了异常代码(0不能做除数)int i = 10 / 0;} catch (Exception e) {System.out.println(e.getMessage());}return result;}
}

事务不会⾃动回滚解决⽅案

解决⽅案1：对于捕获的异常，事务是会⾃动回滚的，因此解决⽅案1就是可以将异常重新抛出，具体实现如下：

@RequestMapping("/save")
@Transactional(isolation = Isolation.SERIALIZABLE)
public Object save(User user) {// 插⼊数据库int result = userService.save(user);try {// 执⾏了异常代码(0不能做除数)int i = 10 / 0;} catch (Exception e) {System.out.println(e.getMessage());// 将异常重新抛出去throw e;}return result;
}

解决⽅案2：⼿动回滚事务，在⽅法中使⽤ TransactionAspectSupport.currentTransactionStatus() 可以得到当前的事务，然后设置回滚⽅法 setRollbackOnly 就可以实现回滚了，具体实现代码如下：

@RequestMapping("/save")
@Transactional(isolation = Isolation.SERIALIZABLE)
public Object save(User user) {// 插⼊数据库int result = userService.save(user);try {// 执⾏了异常代码(0不能做除数)int i = 10 / 0;} catch (Exception e) {System.out.println(e.getMessage());// ⼿动回滚事务TransactionAspectSupport.currentTransactionStatus().setRollbackOnl
y();}return result;
}

image-20240402202643135

2.3.4 @Transactional ⼯作原理

@Transactional 是基于 AOP 实现的，AOP ⼜是使⽤动态代理实现的。如果⽬标对象实现了接⼝，默认情况下会采⽤ JDK 的动态代理，如果⽬标对象没有实现了接⼝,会使⽤ CGLIB 动态代理。

@Transactional 在开始执⾏业务之前，通过代理先开启事务，在执⾏成功之后再提交事务。如果中途遇到的异常，则回滚事务。

@Transactional 实现思路预览：

image-20240402184341122

@Transactional 具体执⾏细节如下图所示：

image-20240402184350393

3.事务隔离级别

3.1 事务特性回顾

事务有4 ⼤特性（ACID），原⼦性、持久性、⼀致性和隔离性，具体概念如下：

  • 原⼦性：⼀个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执⾏过程中发⽣错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执⾏过⼀样。

  • ⼀致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写⼊的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以⾃发性地完成预定的⼯作。

  • 持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

  • 隔离性：数据库允许多个并发事务同时对其数据进⾏读写和修改的能⼒，隔离性可以防⽌多个事务并发执⾏时由于交叉执⾏⽽导致数据的不⼀致。事务隔离分为不同级别，包括读未提交（Readuncommitted）、读提交（read committed）、可重复读（repeatable read）和串⾏化（Serializable）。

上⾯ 4 个属性，可以简称为ACID。

原⼦性（Atomicity，或称不可分割性）

⼀致性（Consistency）

隔离性（Isolation，⼜称独⽴性）

持久性（Durability）。

⽽这 4 种特性中，只有隔离性（隔离级别）是可以设置的

为什么要设置事务的隔离级别？

设置事务的隔离级别是⽤来保障多个并发事务执⾏更可控，更符合操作者预期的。

什么是可控呢？

⽐如近⼏年⽐较严重的新冠病毒，我们会把直接接触到确证病例的⼈员隔离到酒店，⽽把间接接触者（和直接接触着但未确诊的⼈）隔离在⾃⼰的家中，也就是针对不同的⼈群，采取不同的隔离级别，这种隔离⽅式就和事务的隔离级别类似，都是采取某种⾏动让某个事件变的“更可控”。⽽事务的隔离级别就是为了防⽌，其他的事务影响当前事务执⾏的一种策略。

3.2 Spring 中设置事务隔离级别

Spring 中事务隔离级别可以通过 @Transactional 中的 isolation 属性进⾏设置，具体操作如下图所示：

image-20240402184727628

3.2.1 MySQL 事务隔离级别有 4 种

  1. READ UNCOMMITTED：读未提交，也叫未提交读，该隔离级别的事务可以看到其他事务中未提交的数据。该隔离级别因为可以读取到其他事务中未提交的数据，⽽未提交的数据可能会发⽣回滚，因此我们把该级别读取到的数据称之为脏数据，把这个问题称之为脏读。

  2. READ COMMITTED：读已提交，也叫提交读，该隔离级别的事务能读取到已经提交事务的数据，因此它不会有脏读问题。但由于在事务的执⾏中可以读取到其他事务提交的结果，所以在不同时间的相同 SQL 查询中，可能会得到不同的结果，这种现象叫做不可重复读。

  3. REPEATABLE READ：可重复读，是 MySQL 的默认事务隔离级别，它能确保同⼀事务多次查询的结果⼀致。但也会有新的问题，⽐如此级别的事务正在执⾏时，另⼀个事务成功的插⼊了某条数据，但因为它每次查询的结果都是⼀样的，所以会导致查询不到这条数据，⾃⼰重复插⼊时⼜失败（因为唯⼀约束的原因）。明明在事务中查询不到这条信息，但⾃⼰就是插⼊不进去，这就叫幻读（Phantom Read）。

  4. SERIALIZABLE：序列化，事务最⾼隔离级别，它会强制事务排序，使之不会发⽣冲突，从⽽解决了脏读、不可重复读和幻读问题，但因为执⾏效率低，所以真正使⽤的场景并不多。在数据库中通过以下 SQL 查询全局事务隔离级别和当前连接的事务隔离级别：

image-20240402184803680

● 脏读：⼀个事务读取到了另⼀个事务修改的数据之后，后⼀个事务⼜进⾏了回滚操作，从⽽导致第⼀个事务读取的数据是错误的。

● 不可重复读：⼀个事务两次查询得到的结果不同，因为在两次查询中间，有另⼀个事务把数据修改了。

● 幻读：⼀个事务两次查询中得到的结果集相同，但在两次查询中另⼀个事务有新增了⼀部分数据，明明在事务中查询不到这条信息，但⾃⼰就是插⼊不进去，这就叫幻读

在数据库中通过以下 SQL 查询全局事务隔离级别和当前连接的事务隔离级别：

select @@global.tx_isolation,@@tx_isolation;

以上 SQL 的执⾏结果如下：

image-20240402184901840

3.2.2 Spring 事务隔离级别有 5 种

⽽ Spring 中事务隔离级别包含以下 5 种：

  1. Isolation.DEFAULT：以连接的数据库的事务隔离级别为主。

  2. Isolation.READ_UNCOMMITTED：读未提交，可以读取到未提交的事务，存在脏读。

  3. Isolation.READ_COMMITTED：读已提交，只能读取到已经提交的事务，解决了脏读，存在不可重复读。

  4. Isolation.REPEATABLE_READ：可重复读，解决了不可重复读，但存在幻读（MySQL默认级别）。

  5. Isolation.SERIALIZABLE：串⾏化，可以解决所有并发问题，但性能太低

从上述介绍可以看出，相⽐于 MySQL 的事务隔离级别，Spring 的事务隔离级别只是多了⼀个Isolation.DEFAULT（以数据库的全局事务隔离级别为主）。

Spring 中事务隔离级别只需要设置 @Transactional ⾥的 isolation 属性即可，具体实现代码如下：

@RequestMapping("/save")
@Transactional(isolation = Isolation.SERIALIZABLE)
public Object save(User user) {// 业务实现
}

4.Spring 事务传播机制

4.1 事务传播机制是什么？

Spring 事务传播机制定义了多个包含了事务的⽅法，相互调⽤时，事务是如何在这些⽅法间进⾏传递的。

4.2 为什么需要事务传播机制？

事务隔离级别是保证多个并发事务执⾏的可控性的（稳定性的），⽽事务传播机制是保证⼀个事务在多个调⽤⽅法间的可控性的（稳定性的）。

例⼦：像新冠病毒⼀样，它有不同的隔离⽅式（酒店隔离还是居家隔离），是为了保证疫情可控，然⽽在每个⼈的隔离过程中，会有很多个执⾏的环节，⽐如酒店隔离，需要负责⼈员运送、物品运送、消杀原⽣活区域、定时核算检查和定时送餐等很多环节，⽽事务传播机制就是保证⼀个事务在传递过程中是可靠性的，回到本身案例中就是保证每个⼈在隔离的过程中可控的。

事务隔离级别解决的是多个事务同时调⽤⼀个数据库的问题，如下图所示：

image-20240402185238897

⽽事务传播机制解决的是⼀个事务在多个节点（⽅法）中传递的问题，如下图所示：

image-20240402185246741

4.3 事务传播机制有哪些？

Spring 事务传播机制包含以下 7 种：

  1. Propagation.REQUIRED：默认的事务传播级别，它表示如果当前存在事务，则加⼊该事务；如果当前没有事务，则创建⼀个新的事务。

  2. Propagation.SUPPORTS：如果当前存在事务，则加⼊该事务；如果当前没有事务，则以⾮事务的⽅式继续运⾏。

  3. Propagation.MANDATORY：（mandatory：强制性）如果当前存在事务，则加⼊该事务；如果当前没有事务，则抛出异常。

  4. Propagation.REQUIRES_NEW：表示创建⼀个新的事务，如果当前存在事务，则把当前事务挂起。也就是说不管外部⽅法是否开启事务，Propagation.REQUIRES_NEW 修饰的内部⽅法会新开启⾃⼰的事务，且开启的事务相互独⽴，互不⼲扰。

  5. Propagation.NOT_SUPPORTED：以⾮事务⽅式运⾏，如果当前存在事务，则把当前事务挂起。

  6. Propagation.NEVER：以⾮事务⽅式运⾏，如果当前存在事务，则抛出异常。

  7. Propagation.NESTED：如果当前存在事务，则创建⼀个事务作为当前事务的嵌套事务来运⾏；如果当前没有事务，则该取值等价于 PROPAGATION_REQUIRED。

以上 7 种传播⾏为，可以根据是否⽀持当前事务分为以下 3 类：

image-20240402185319461

以情侣关系为例来理解以上分类：

image-20240402185331155

4.4 Spring 事务传播机制使⽤和各种场景演示

4.4.1 ⽀持当前事务（REQUIRED）

以下代码实现中，先开启事务先成功插⼊⼀条⽤户数据，然后再执⾏⽇志报错，⽽在⽇志报错是发⽣了异常，观察 propagation = Propagation.REQUIRED 的执⾏结果

@RestController
public class UserController {@Resourceprivate UserService userService;@Resourceprivate LogService logService;@RequestMapping("/save")@Transactional(propagation = Propagation.REQUIRED)public Object save(User user) {// 插⼊⽤户操作userService.save(user);// 插⼊⽇志logService.saveLog("⽤户插⼊：" + user.getName());return true;}
}

UserService 实现代码如下：

@Service
public class UserService {@Resourceprivate UserMapper userMapper;@Transactional(propagation = Propagation.REQUIRED)public int save(User user) {System.out.println("执⾏ save ⽅法.");return userMapper.save(user);}
}

LogService 实现代码如下：

@Service
public class LogService {@Resourceprivate LogMapper logMapper;@Transactional(propagation = Propagation.REQUIRED)public int saveLog(String content) {// 出现异常int i = 10 / 0;return logMapper.saveLog(content);}
}

执⾏结果：程序报错，数据库没有插⼊任何数据。

执⾏流程描述：

  1. UserService 中的保存⽅法正常执⾏完成。
  2. LogService 保存⽇志程序报错，因为使⽤的是 Controller 中的事务，所以整个事务回滚。
  3. 数据库中没有插⼊任何数据，也就是步骤 1 中的⽤户插⼊⽅法也回滚了。

4.4.2 不⽀持当前事务（REQUIRES_NEW）

UserController 类中的代码不变，将添加⽤户和添加⽇志的⽅法修改为 REQUIRES_NEW 不⽀持当前事务，重新创建事务，观察执⾏结果：

@RequestMapping("/save")
@Transactional
public Object save(User user) {// 插⼊⽤户操作userService.save(user);// 插⼊⽇志logService.saveLog("⽤户插⼊：" + user.getName());return true;
}

UserService 实现代码：

@Service
public class UserService {@Resourceprivate UserMapper userMapper;@Transactional(propagation = Propagation.REQUIRES_NEW)public int save(User user) {System.out.println("执⾏ save ⽅法.");return userMapper.save(user);}
}

LogService 实现代码：

@Service
public class LogService {@Resourceprivate LogMapper logMapper;@Transactional(propagation = Propagation.REQUIRES_NEW)public int saveLog(String content) {// 出现异常int i = 10 / 0;return logMapper.saveLog(content);}
}

程序执⾏结果：User 表中成功插⼊了数据，Log 表执⾏失败，但没影响 UserController 中的事务。

4.4.3 不⽀持当前事务，NEVER 抛异常

UserController 实现代码：

@RequestMapping("/save")
@Transactional
public Object save(User user) {// 插⼊⽤户操作userService.save(user);return true;
}

UserService 实现代码：

@Transactional(propagation = Propagation.NEVER)
public int save(User user) {System.out.println("执⾏ save ⽅法.");return userMapper.save(user);
}

程序执⾏报错，⽤户表未添加任何数据

4.4.4 NESTED 嵌套事务

UserController 实现代码如下：

@RequestMapping("/save")
@Transactional
public Object save(User user) {// 插⼊⽤户操作userService.save(user);return true;
}

UserService 实现代码如下：

@Transactional(propagation = Propagation.NESTED)
public int save(User user) {int result = userMapper.save(user);System.out.println("执⾏ save ⽅法.");// 插⼊⽇志logService.saveLog("⽤户插⼊：" + user.getName());return result;
}

LogService 实现代码如下：

@Transactional(propagation = Propagation.NESTED)
public int saveLog(String content) {// 出现异常int i = 10 / 0;return logMapper.saveLog(content);
}

最终执⾏结果，⽤户表和⽇志表都没有添加任何数据。

执⾏流程描述：

1.UserController 中调⽤了 UserService 的添加⽅法，UserService 使⽤ NESTED 修饰循环嵌套了UserController 的事务，并成功执⾏了添加⽅法。

2.UserService 中调⽤了 LogService 的添加⽅法，LogService 使⽤ NESTED 修饰循环嵌套了上⼀个调⽤类的事务，执⾏了添加⽅法，但在执⾏的过程中出现了异常，回顾当前事务，⽇志添加失败。

3.因为是嵌套事务，所以⽇志添加回顾之后，往上找调⽤它的⽅法和事务回滚了⽤户添加，所以⽤户添加也失败了，所以最终的结果是⽤户表和⽇志表都没有添加任何数据。

4.4.5 嵌套事务和加⼊事务有什么区别？

先来看嵌套事务 NESTED 示例，示例中使⽤ UserController 调⽤ UserService，UserService 中调⽤LogService，⽽UserService 和 LogService 中的事务传播特性都是 NESTED，具体实现代码如下。UserController 实现代码如下

@RequestMapping("/save")
@Transactional
public Object save(User user) {// 插⼊⽤户操作userService.save(user);return true;
}

UserService 实现代码如下：

@Transactional(propagation = Propagation.NESTED)
public int save(User user) {int result = userMapper.save(user);System.out.println("执⾏ save ⽅法.");// 插⼊⽇志logService.saveLog("⽤户插⼊：" + user.getName());return result;
}

LogService 实现代码如下：

@Transactional(propagation = Propagation.NESTED)
public int saveLog(String content) {// 添加⽇志int result = logMapper.saveLog(content);try {// 出现异常int i = 10 / 0;} catch (Exception e) {// 回滚当前事务TransactionAspectSupport.currentTransactionStatus().setRollbackOnl
y();}return result;
}

在 LogService 进⾏当前事务的回滚操作，最终执⾏效果是：

User 表中成功添加数据，⽽ Log 表中没有添加数据。

说明：Log 中的事务已经回滚，但是嵌套事务不会回滚嵌套之前的事务，也就是说嵌套事务可以实现部分事务回滚。

加⼊事务 REQUIRED 示例演示

把 NESTED 传播特性改为 REQUIRED 实现代码如下，UserController 中的实现代码不变：

@RequestMapping("/save")
@Transactional
public Object save(User user) {// 插⼊⽤户操作userService.save(user);return true;
}

UserService 中的实现代码如下：

@Transactional(propagation = Propagation.REQUIRED)
public int save(User user) {int result = userMapper.save(user);System.out.println("执⾏ save ⽅法.");// 插⼊⽇志logService.saveLog("⽤户插⼊：" + user.getName());return result;
}

⾸先添加⽤户没有任何问题，⽤户添加成功。

LogService 中的实现代码如下:

@Transactional(propagation = Propagation.REQUIRED)
public int saveLog(String content) {// 添加⽇志int result = logMapper.saveLog(content);try {// 出现异常int i = 10 / 0;} catch (Exception e) {// 回滚当前事务TransactionAspectSupport.currentTransactionStatus().setRollbackOnl
y();}return result;
}

添加⽇志报错了，将 LogService 中的事务回滚。

最终程序的执⾏结果：

⽤户表和⽇志表中都没有添加任何数据，说明整个事务都回滚了。也就是说 REQUIRED 如果回滚就是回滚所有事务，不能实现部分事务的回滚

嵌套事务只所以能够实现部分事务的回滚，是因为事务中有⼀个保存点（savepoint）的概念，嵌套事务进⼊之后相当于新建了⼀个保存点，⽽滚回时只回滚到当前保存点，因此之前的事务是不受影响的，这⼀点可以在 MySQL 的官⽅⽂档汇总找到相应的资料：https://dev.mysql.com/doc/refman/5.7/en/savepoint.html

image-20240402190222352

⽽ REQUIRED 是加⼊到当前事务中，并没有创建事务的保存点，因此出现了回滚就是整个事务回滚，这就是嵌套事务和加⼊事务的区别。

嵌套事务（NESTED）和加⼊事务（REQUIRED ）的区别:

  • 整个事务如果全部执⾏成功，⼆者的结果是⼀样的。
  • 如果事务执⾏到⼀半失败了，那么加⼊事务整个事务会全部回滚；⽽嵌套事务会局部回滚，不会影响上⼀个⽅法中执⾏的结果

总结

Spring 事务使⽤中，重点的内容有 3 个:

  1. 在 Spring 项⽬中使⽤事务，⽤两种⽅法⼿动操作和声明式⾃动提交，其中后者使⽤的最多，在⽅法上添加 @Transactional 就可以实现了。

  2. 设置事务的隔离级别 @Transactional(isolation = Isolation.SERIALIZABLE)，Spring 中的事务隔离级别有 5 种。

  3. 设置事务的传播机制 @Transactional(propagation = Propagation.REQUIRED)，Spring 中的事务传播级别有 7 种。

回时只回滚到当前保存点，因此之前的事务是不受影响的，这⼀点可以在 MySQL 的官⽅⽂档汇总找到相应的资料：https://dev.mysql.com/doc/refman/5.7/en/savepoint.html

⽽ REQUIRED 是加⼊到当前事务中，并没有创建事务的保存点，因此出现了回滚就是整个事务回滚，这就是嵌套事务和加⼊事务的区别。

嵌套事务（NESTED）和加⼊事务（REQUIRED ）的区别:

  • 整个事务如果全部执⾏成功，⼆者的结果是⼀样的。
  • 如果事务执⾏到⼀半失败了，那么加⼊事务整个事务会全部回滚；⽽嵌套事务会局部回滚，不会影响上⼀个⽅法中执⾏的结果

感谢各位读者的阅读，本文章有任何错误都可以在评论区发表你们的意见，我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞，你的每一次鼓励都是作者创作的动力哦！😘

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/web/48905.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

vue+element的table合并单元格(竖着合并行)及合计行添加并计算

vue+element的table合并单元格(竖着合并行)及合计行添加并计算

1 效果: 代码分析: 1 表格头配置: 2 懒得写的:自己复制吧 <el-table:data"tableData"style"width: 98%":height"height"v-loading"isLoading"stripe"false" :span-method"objectSpanMethod"show-summary:summ…
阅读更多...
视图、存储过程、触发器

视图、存储过程、触发器

一、视图 视图是从一个或者几个基本表&#xff08;或视图&#xff09;导出的表。它与基 本表不同&#xff0c;是一个虚表&#xff0c;视图只能用来从查询&#xff0c;不能做增删改(虚拟的表) 1.创建视图 创建视图的语法&#xff1a; create view 视图名【view_xxx / v_xxx】 a…
阅读更多...
深入理解MySQL锁机制与性能优化：详解记录锁、间隙锁、临键锁及慢SQL查询分析

深入理解MySQL锁机制与性能优化：详解记录锁、间隙锁、临键锁及慢SQL查询分析

1. 事务隔离和锁机制详解 记录锁 第一种情况，当我们对于唯一性的索引（包括唯一索引和主键索引）使用等值查询，精准匹配到一条记录的时候，这个时候使用的就是记录锁。 比如 where id = 1 4 7 10。 间隙锁 第二种情况，当我们查询的记录不存在，无论是用等值查询还是范围…
阅读更多...
Thinkphp开发文档二次整理版

Thinkphp开发文档二次整理版

基础部分 安装 环境要求 ​ *php>7.1.0 命令下载 通过Composer进行下载&#xff0c;操作步骤下载软件 phpstudy --->点击软件管理 --->安装Composer --->再点击网站 --->点击管理 --->点击Composer --->复制如下命令代码&#xff1a; ​ 稳定版&…
阅读更多...
国际化技术参考

国际化技术参考

一、概述 国际化就是用户可以选择对应的语言，页面展示成对应的语言； 一个系统的国际化按照信息的所在位置，可以分为三种国际化信息： 前端页面信息后端提示信息数据库的字典类信息二、前端页面国际化 使用i18n库实现国际化 i18n国际化库思路：通过jquery或者dom操作拿到需…
阅读更多...
推荐4款简单高效的视频转文字工具。

推荐4款简单高效的视频转文字工具。

最近我要将很多的以前的培训视频转换成笔记&#xff0c;觉得很麻烦&#xff0c;于是就搜索有没有什么工具可以帮助。结果就真的找到了很多将视频转换成文字的软件和网站。解决了一个大工程&#xff0c;后来发现其实很多人都会碰到像我这样的问题&#xff0c;于是在这里将我使用…
阅读更多...
类和对象：完结

类和对象：完结

1.再深构造函数 • 之前我们实现构造函数时&#xff0c;初始化成员变量主要使⽤函数体内赋值&#xff0c;构造函数初始化还有⼀种⽅ 式&#xff0c;就是初始化列表&#xff0c;初始化列表的使⽤⽅式是以⼀个冒号开始&#xff0c;接着是⼀个以逗号分隔的数据成 员列表&#xf…
阅读更多...
通信原理-思科实验三：无线局域网实验

通信原理-思科实验三：无线局域网实验

实验三 无线局域网实验 一&#xff1a;无线局域网基础服务集 实验步骤&#xff1a; 进入物理工作区&#xff0c;导航选择 城市家园; 选择设备 AP0&#xff0c;并分别选择Laptop0、Laptop1放在APO范围外区域 修改笔记本的网卡&#xff0c;从以太网卡切换到无线网卡WPC300N 切…
阅读更多...
力扣Hot100-543二叉树的直径

力扣Hot100-543二叉树的直径

给你一棵二叉树的根节点&#xff0c;返回该树的 直径 。 二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。 两节点之间路径的 长度 由它们之间边数表示。 示例 1&#xff1a; 输入&#xff1a;root [1,2,3,4,5] 输出&a…
阅读更多...
C++ 基础（类和对象下）

C++ 基础（类和对象下）

目录 一. 再探构造函数 1.1. 初始化列表&#xff08;尽量使用列表初始化&#xff09; 二. static成员 2.1static成员初始化 三.友元 3.1友元&#xff1a;提供了⼀种 突破类访问限定符封装的方式. 四.内部类 4.1如果⼀个类定义在另⼀个类的内部&#xff0c;这个内部类就叫…
阅读更多...
2024.7.24 作业

2024.7.24 作业

1.二叉树的创建、遍历自己实现一遍 bitree.h #ifndef BITREE_H #define BITREE_H#include <myhead.h>typedef char datatype;typedef struct Node {datatype data;struct Node *left_child;struct Node *right_child; }Node,*BiTreePtr;//创建二叉树 BiTreePtr tree_cr…
阅读更多...
我在百科荣创企业实践——简易函数信号发生器（5）

我在百科荣创企业实践——简易函数信号发生器（5）

对于高职教师来说，必不可少的一个任务就是参加企业实践。这个暑假，本人也没闲着，报名参加了上海市电子信息类教师企业实践。7月8日到13日，有幸来到美丽的泉城济南，远离了上海的酷暑，走进了百科荣创科技发展有限公司。在这短短的一周时间里，我结合自己的教学经验和企业的…
阅读更多...
【Java语法基础】9.异常处理

【Java语法基础】9.异常处理

9. 异常处理 Error是程序无法处理的错误&#xff0c;出现时线程被JVM终止。 Exception&#xff0c;指的是程序运行时可以处理的异常。其继承关系如下表&#xff1a; 运行时异常&非运行时异常 运行时异常 都是RuntimeException类及其子类异常&#xff0c;如NullPointerE…
阅读更多...
模拟实现c++中的string

模拟实现c++中的string

c内置string库的相关函数&#xff1a;string - C Reference 目录 一string类构造&#xff0c;拷贝构造和析构&#xff1a; 二string内正向迭代器实现&#xff1a; 三赋值运算符重载实现&#xff1a; 四reserve&#xff0c;empty&#xff0c;clear实现&#xff1a; 五push_b…
阅读更多...
动手学深度学习——6.循环神经网络

动手学深度学习——6.循环神经网络

1.序列模型 处理序列数据需要统计工具和新的深度神经网络架构。 为了简单起见&#xff0c;我们以 图8.1.1所示的股票价格&#xff08;富时100指数&#xff09;为例。 图8.1.1 近30年的富时100指数 其中&#xff0c;用&#x1d465;&#x1d461;表示价格&#xff0c;即在时间…
阅读更多...
LIS检验信息软件源码，适合二级医院的应用

LIS检验信息软件源码，适合二级医院的应用

LIS系统主要面向医院检验科&#xff0c;包含检验医生日常处理、报告处理、质量控制、条码管理、仪器双工通讯、无人值守等诸多功能模块&#xff0c;能与HIS系统、体检系统和电子病历信息系统实现无缝连接&#xff0c;已成功应用于多家各种规模的医院&#xff0c;满足客户各方面…
阅读更多...
Git之repo sync -c与repo sync -dc用法区别(四十八)

Git之repo sync -c与repo sync -dc用法区别(四十八)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a;多媒…
阅读更多...
InternLM学习笔记

InternLM学习笔记

入门岛 1. Linux基础知识 2. Python 基础知识 from collections import Countertext """ Got this panda plush toy for my daughters birthday, who loves it and takes it everywhere. Its soft and super cute, and its face has a friendly look. Its a …
阅读更多...
论文阅读【检测】：Facebook ECCV2020 | DETR

论文阅读【检测】：Facebook ECCV2020 | DETR

文章目录 论文地址AbstractMotivation模型框架详细结构小结 论文地址 DETR Abstract 提出了一种将目标检测视为直接集预测问题的新方法。简化了检测pipeline&#xff0c;有效地消除了许多手工设计的组件的需求&#xff0c;例如非最大抑制过程或锚生成&#xff0c;这些组件明…
阅读更多...
设计模式|观察者模式

设计模式|观察者模式

观察者模式是一种行为设计模式&#xff0c;它定义了一种一对多的依赖关系&#xff0c;让多个观察者对象同时监听某一个主题对象。当主题对象发生变化时&#xff0c;它的所有观察者都会收到通知并更新。观察者模式常用于实现事件处理系统、发布-订阅模式等。在项目中&#xff0c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023