spring - tx 事务的使用（事务的传播行为是啥）

补充：事务的传播行为是啥

事务的传播行为：指的是，当一个事务方法被另一个事务方法调用时，这个被调用的事务方法应该如何进行，
简单来说，它决定了事务方法是在调用者的事务中运行，还是为自己开启一个新的事务运行。

在Spring框架中，
事务的传播行为，是通过@Transactional注解的propagation属性来配置的，
Spring定义了七种类型的事务传播行为，每种行为都有其特定的用途和场景。其中最常见的包括：

PROPAGATION_REQUIRED（默认值）：如果，父方法有事务，我们就加入到父方法的事务，最终是同一个事务
如果，父方法没有事务，就新建自己独立的事务
PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED行为。
PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

这些传播行为提供了灵活的事务管理策略，可以根据具体的应用场景和需求来选择合适的传播行为。通过合理配置事务的传播行为，可以确保数据的一致性和完整性，同时提高系统的性能和可靠性。

Spring事务管理器

1、Spring声明式事务对应依赖

	spring-tx：包含声明式事务实现的基本规范（事务管理器规范接口 和 事务增强等等）spring-jdbc：包含DataSource方式事务管理器实现类 DataSourceTransactionManagerspring-orm：包含其他持久层框架的事务管理器实现类，如：Hibernate/Jpa等

2、spring声明式事务对应事务管理器接口

							TransactionManager 顶层接口||PlatformTransactionManager 接口|			        	||	         			|DataSourceTransactionManager实现类	  HibernateTransactionManager实现类Spring框架中，"TransactionManager"是一个顶层接口，用于，定义事务管理行为的顶层接口，提供了开始事务、提交事务、回滚事务等方法的定义。作用：定义了事务管理的标准行为，可以有不同的实现类来实现具体的事务管理逻辑。"PlatformTransactionManager"是Spring框架中的事务管理平台接口，定义了对事务进行管理的方法。作用：作为事务管理的核心接口，定义了事务的开始、提交、回滚等操作，具体的事务管理器实现类需要实现这些方法。"DataSourceTransactionManager"是Spring框架中，用于基于数据源的事务管理的实现类，用于，管理JDBC事务。作用：通过数据源管理事务，可以在Spring应用中使用JDBC进行数据库访问，并通过该事务管理器实现事务管理。"HibernateTransactionManager"是Spring框架中，用于与Hibernate集成的事务管理器实现类，用于，管理Hibernate事务。作用：通过与Hibernate集成，可以在Spring应用中使用Hibernate进行ORM操作，并通过该事务管理器实现事务管理。

我们现在使用的事务管理器是：org.springframework.jdbc.datasource.DataSourceTransactionManager

将来整合JDBC方式、JdbcTemplate方式、Mybatis方式的事务实现。

3、DataSourceTransactionManager类中主要方法

	doBegin()：开启事务doSuspend()：挂起事务doResume()：恢复挂起的事务doCommit()：提交事务doRollback()：回滚事务

举个例子

1、数据库的配置文件：`src/main/resources/jdbc.properties`

	atguigu.url=jdbc:mysql:///my_studyatguigu.driver=com.mysql.cj.jdbc.Driveratguigu.username=rootatguigu.password=root

2、配置类：`src/main/java/com.atguigu.config/JavaConfig.java`

package com.atguigu.config;import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;import javax.sql.DataSource;@Configuration  1、说明这是个配置类
@ComponentScan("com.atguigu")  2、包扫描
@PropertySource("classpath:jdbc.properties")  3、引入配置文件
@EnableAspectJAutoProxy  开启aspectj注解的支持
@EnableTransactionManagement  开启事务注解的支持
public class JavaConfig {这里读取 src/main/resources/jdbc.properties文件的数据库相关配置@Value("${atguigu.driver}")private String driver;@Value("${atguigu.url}")private String url;@Value("${atguigu.username}")private String username;@Value("${atguigu.password}")private String password;4、druid连接池实例化，"DruidDataSource"实现了"DataSource"接口，所以这里用 public DataSource dataSource()@Beanpublic DataSource dataSource() {DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName(driver);dataSource.setUrl(url);dataSource.setUsername(username);dataSource.setPassword(password);return dataSource;}5、jdbcTemplate@Beanpublic JdbcTemplate jdbcTemplate(DataSource dataSource){JdbcTemplate jdbcTemplate = new JdbcTemplate();jdbcTemplate.setDataSource(dataSource);return jdbcTemplate;}@Beanpublic TransactionManager transactionManager(DataSource dataSource){* 内部需要进行事务的操作，基于的连接池DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();* 需要连接池对象dataSourceTransactionManager.setDataSource(dataSource);return dataSourceTransactionManager;}
}

3、dao层：`src/main/java/com.atguigu.dao/StudentDao.java`

package com.atguigu.dao;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;@Repository
public class StudentDao {@Autowiredprivate JdbcTemplate jdbcTemplate;public void updateNameById(String name, Integer id){String sql = "update my_user set name = ? where id = ?";int rows = jdbcTemplate.update(sql, name, id);}public void updatePloneById(String plone, Integer id){String sql = "update my_user set plone = ? where id = ?";int rows = jdbcTemplate.update(sql, plone, id);}
}

4、service层：`src/main/java/com.atguigu.service/StudentService.java`


package com.atguigu.service;import com.atguigu.dao.StudentDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;import java.io.FileInputStream;
import java.io.FileNotFoundException;@Service
public class StudentService {@Autowiredprivate StudentDao studentDao;* 怎样添加事务呢？使用 "@Transactional"注解 即可* 这个"@Transactional"注解在哪加呢？方式1、加到某个方法上，那么，这个方法就有事务了方式2、加到某个类上，那么，这个类的所有方法就都有事务了* "@Transactional"注解，的属性1、只读模式只读模式，可以提升查询事务的效率，推荐事务中只有查询代码时，使用只读模式默认情况下（源码）：boolean readOnly() default false解释，一般情况下，都是直接把 "@Transactional"注解 加到类上，则，这个类的所有方法，就都有事务了，但是，你可以在查询方法上再加一次 "@Transactional"注解，并且设置只读模式，提高效率2、超时时间事务在执行过程中，可能会由于某些问题导致卡住，从而长时间占用数据库资源，而长时间占用数据库资源，大概率是因为程序出现了问题(可能是Java程序、Mysql数据库、网络连接等问题)此时，这个很可能出现问题的程序就应该被回滚，撤销他已做的操作，事务结束，把资源让出来，让其他程序可以正常执行总之，就是，超时回滚、释放资源默认，永不超时（值是-1）设置 "timeout = 秒数"，超时后，就会回滚事务和释放异常，超时的异常是："TransactionTimedOutException"如果，类上设置了 "@Transactional"注解 和 这个"timeout"属性，并且，方法上也设置了 "@Transactional"注解，但是没有设置"timeout"属性，那么，此时，"方法上的timeout值是 默认值 -1" 哦3、指定异常回滚 和 指定异常不回滚默认情况下：发生运行时异常，才会回滚我们可以指定Exception异常来控制所有异常都会滚rollbackFor = Exception.class，意思是：所有的异常都回滚noRollbackFor = FileNotFoundException.class，意思是：指定FileNotFoundException异常不回滚@Transactional(timeout = 3, rollbackFor = Exception.class, noRollbackFor = FileNotFoundException.class)public void changeInfo() throws FileNotFoundException {studentDao.updatePloneById("1390002", 1);加这句代码，是为了测试事务是否加上了，int i = 1/0; 这句代码本身是会报错的，因为，有事务的话，即使 int i = 1/0; 这句代码上面的代码没有错，但是 int i = 1/0; 报错了，会造成，回滚，所以整个方法里的代码都不会生效。但是，如果没有事务的话，int i = 1/0; 这句代码上面正确的代码会执行生效的// int i = 1/0;//        try {
//            Thread.sleep(5000); // 等5秒，为了测试 timeout这个属性
//        } catch (InterruptedException e) {
//            throw new RuntimeException(e);
//        }测试：异常回滚new FileInputStream("xxx");System.out.println("----------------------------");studentDao.updateNameById("springtx-改名", 2);}事务传播行为：声明两个独立修改数据库的事务业务方法propagation = Propagation.REQUIRED意思是：如果，父方法有事务，我们就加入到父方法的事务，最终是同一个事务如果，父方法没有事务，就新建自己独立的事务propagation = Propagation.REQUIRES_NEW意思是：不管父方法是否有事务，我都是独立的事务@Transactional(propagation = Propagation.REQUIRES_NEW)public void changePlone(){studentDao.updatePloneById("1390004", 1);}@Transactional(propagation = Propagation.REQUIRES_NEW)public void changeName(){studentDao.updateNameById("spring-tx-嘎嘎", 2);int i = 1 / 0; // 报错}}

5、最后，写一个测试类：`src/test/com.atguigu.test/SpringTest.java`

package com.atguigu.test;import com.atguigu.config.JavaConfig;
import com.atguigu.service.StudentService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;import java.io.FileNotFoundException;@SpringJUnitConfig(JavaConfig.class)
public class SpringTxTest {@Autowiredprivate StudentService studentService;@Testpublic void test() throws FileNotFoundException {studentService.changeInfo();}@Testpublic void test1(){studentService.changePlone();  会改变数据库的内容studentService.changeName();  不会改变数据库的内容，因为报错，导致事务回滚了}@Test@Transactional  即使父方法这里加上"@Transactional"，但是下面着2个方法的"propagation = Propagation.REQUIRES_NEW"所以，结果如下：public void test2(){studentService.changePlone();  会改变数据库的内容studentService.changeName();  不会改变数据库的内容，因为报错，导致事务回滚了}}