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方式事务管理器实现类 DataSourceTransactionManager

	spring-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_study
	
	atguigu.driver=com.mysql.cj.jdbc.Driver
	
	atguigu.username=root
	
	atguigu.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()
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
    

    5、jdbcTemplate
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
    

	* 在Spring框架中，使用@Bean注解的方法意味着你正在定义一个Spring管理的bean，
	
	  这个bean可以被自动装配到其他需要它的地方，或者作为Spring容器内其他组件的依赖。
	
	* 对于"TransactionManager()"方法，尽管你可能没有在JavaConfig类或其他显式的类中看到对它的直接引用，它仍然是必要的，
	
	  原因如下：
		
		1、声明式事务管理：在Spring中，TransactionManager是用于声明式事务管理的关键组件，
			
			当你使用@Transactional注解来标记方法或类时，Spring会查找一个TransactionManager来管理这些事务，
			
			如果没有显式定义TransactionManager bean，Spring容器将无法找到它，
			
			就会导致使用@Transactional注解的方法不会获得预期的事务管理行为。
		
		2、自动装配：即使你没有直接调用TransactionManager方法，
		
			Spring框架内部可能会自动装配这个bean到需要它的地方，
			
			例如，如果你正在使用JpaTransactionManager或HibernateTransactionManager，
			
			Spring Data JPA或Hibernate集成可能会自动查找并使用这个bean。
	
		3、AOP代理：Spring使用面向切面编程（AOP）来创建代理对象，
		
			这些代理对象，会拦截标记为@Transactional的方法调用，并使用TransactionManager来管理事务，
			
			这个过程是自动的，你不需要显式地调用TransactionManager。
	
		因此，尽管你可能没有在JavaConfig类或其他显式的类中看到对TransactionManager的直接引用，
		
		但是，它仍然是配置中必不可少的一部分，以确保声明式事务管理能够正常工作。
	
	总结来说，
	
		TransactionManager方法不是多余的，它定义了Spring容器中的一个bean，
		
		该bean对于声明式事务管理至关重要，
		
		即使你没有直接调用它，
		
		Spring框架也会自动使用它来处理标记为@Transactional的方法的事务。
    @Bean
    public 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 {

    @Autowired
    private 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 {
    @Autowired
    private 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 {

    @Autowired
    private StudentService studentService;

    @Test
    public void test() throws FileNotFoundException {
        studentService.changeInfo();
    }


	@Test
    public void test1(){
        studentService.changePlone();  会改变数据库的内容
        studentService.changeName();  不会改变数据库的内容，因为报错，导致事务回滚了
    }

	@Test
	@Transactional  即使父方法这里加上"@Transactional"，但是下面着2个方法的"propagation = Propagation.REQUIRES_NEW"所以，结果如下：
    public void test2(){
        studentService.changePlone();  会改变数据库的内容
        studentService.changeName();  不会改变数据库的内容，因为报错，导致事务回滚了
    }

}