Spring-事务

前言

今天开始学习我自己总结的 Java-学习路线 中的《Spring-事务》，小简从 0 开始学 Java 知识，并不定期更新所学笔记，期待一年后的蜕变吧！<有同样想法的小伙伴，可以联系我一起交流学习哦！>

• 🚩时间安排：预计1天更新完
• 🎯开始时间：04-17
• 🎉结束时间：04-17
• 🍀总结：使用很简单，一天搞定，源码部分后面再看

事物概念

• 事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败

• 典型场景：银行转账

  • 小明转账100元给小红
  • 小明少100，小红多100

• 事务四个特性(ACID)

  • 原子性：操作不可分割，要么都成功要么都失败
  • 一致性：操作之前和操作之后的总量不变
  • 隔离性：多事务操作，各个事务之间不会产生影响
  • 持久性：事务提交，表中数据发生变化

引出事务

• Dao——数据库操作

  • 少钱方法
  • 多钱方法

• Service——业务操作

  • 调用Dao的两个方法

1、创建数据表，添加记录

id	name	money
1	 小明	 1000
2	 小红	 1000

2、创建 service，搭建 dao，完成对象创建和注入关系

//在 dao 注入 JdbcTemplate，service 注入 dao
public interface UserDao{
  
}

@Repository
public class UserDaoImpl implements UserDao {
   //注入 JdbcTemplate
   @Autowired
   private JdbcTemplate jdbcTemplate;
}

@Service
public class UserService {
   //注入 dao
   @Autowired
   private UserDao userDao;
}

3、在 dao 创建两个方法：多钱和少钱的方法， 在 service 创建转账的方法

public interface UserDao{
  void reduceMoney();
  void addMoney(); 
}

@Repository
public class UserDaoImpl implements UserDao {
   @Autowired
   private JdbcTemplate jdbcTemplate;
   //少钱
   @Override
   public void reduceMoney() {
       String sql = "update account set money=money-? where username=?";
       jdbcTemplate.update(sql,100,"小明");
   }
   //多钱
   @Override
   public void addMoney() {
       String sql = "update account set money=money+? where username=?";
       jdbcTemplate.update(sql,100,"小红");
   }
}

@Service
public class UserService {
   //注入 dao
   @Autowired
   private UserDao userDao;
   //转账的方法
   public void accountMoney() {
       userDao.reduceMoney();
       userDao.addMoney();
   }
}

4、测试

@Test
public void testTransaction() {
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("jdbc.xml");
  UserService userService = context.getBean("userService", UserService.class);
  userService.accountMoney();
}

id	name	money
1	 小明	 900
2	 小红	 1100

上边代码正常执行没有问题，但是如果代码执行过程中出现异常，就有问题，如下模拟异常！

@Service
public class UserService {
    //这里执行后将会产生错误（异常），小明少100后，小红不会多100，这就不对了！！
    private UserDao userDao;
    //转账方法
    public void accountMoney(){
        userDao.reduceMoney();//小明少100
        int x=10/0; //异常
        userDao.addMoney(); //小红不会增加100
    }
}

id	name	money
1	 小明	 900
2	 小红	 1000 #没有增加100

上面问题如何解决呢？ 答：使用事务进行解决

//解决上边的异常方法——【编程式事务（传统方法）】
//转账的方法
public void accountMoney() {
  try {
    //第一步 开启事务

    //第二步 进行业务操作
    userDao.reduceMoney();

    //模拟异常
    int i = 10/0;

    userDao.addMoney();

    //第三步 没有发生异常，提交事务
  }catch(Exception e) {
    //第四步 出现异常，事务回滚
  }
}

事务管理

• 事务添加到 JavaEE 三层结构里面的 Service 层（业务逻辑层）

• 在 Spring 进行事务管理操作有两种方式

  • 编程式事务管理
  • 声明式事务管理（推荐使用）
    • 基于 xml 配置文件方式
    • 基于注解方式（推荐使用）

• 在 Spring 进行声明式事务管理，底层使用 AOP 原理

• Spring 事务管理 API ：提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

注解声明式

1、在 spring 配置文件配置事务管理器

<!--创建事务管理器-->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <!--注入数据源-->
 <property name="dataSource" ref="dataSource"></property>
</bean>

2、在 spring 配置文件，开启事务注解,引入tx名称空间

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd 
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
  
</beans>

3、开启事务注解

<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

4、在 service 类上面（或者 service 类里面方法上面）添加事务注解

• @Transactional，这个注解添加到类上面，也可以添加方法上面
• 如果把这个注解添加类上面，这个类里面所有的方法都添加事务
• 如果把这个注解添加方法上面，为这个方法添加事务

@Service
@Transactional  //添加事务注解
public class UserService {
    //注入 dao
    @Autowired
    private UserDao userDao;

    //转账的方法
    //@Transactional
    public void accountMoney() {
        userDao.reduceMoney();
        int x=10/0; //异常
        userDao.addMoney();
    }
}

@Test
public void testTransaction() {
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("jdbc.xml");
  UserService userService = context.getBean("userService", UserService.class);
  userService.accountMoney();
}

#有异常
id	name	money
1	 小明	 1000
2	 小红	 1000
#无异常
id	name	money
1	 小明	 900
2	 小红	 1100

添加事务注解后就不会出现小明转了钱但是小红没有收到的情况

完全注解声明式

//创建配置类，使用配置类替代xml配置文件
@Configuration //配置类
@ComponentScan(basePackages = "com.jwt") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/jwt");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }

    //创建 JdbcTemplate 对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {//从IOC容器中拿到配置注入的数据源
        //到 ioc 容器中根据类型找到 dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入 dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }


    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

测试

@Test
public void testTransaction2() {
  AnnotationConfigApplicationContext context =
    new AnnotationConfigApplicationContext(TxConfig.class);
  UserService userService = context.getBean("userService", UserService.class);
  userService.accountMoney();
}

#有异常
id	name	money
1	 小明	 1000
2	 小红	 1000
#无异常
id	name	money
1	 小明	 900
2	 小红	 1100

XML声明式

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:druid.properties"/>
    <!--配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClass}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--创建 JdbcTemplate 对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入dataSource-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 组件扫描 -->
    <context:component-scan base-package="com.jwt"></context:component-scan>


    <!--1、创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--2、配置通知-->
    <tx:advice id="txadvice">
        <!--配置事务参数-->
        <tx:attributes>
            <!--指定哪种规则的方法上面添加事务-->
            <tx:method name="accountMoney" propagation="REQUIRED"/>
            <!--指定匹配规则上的方法添加事务-->
            <!--<tx:method name="account*"/>-->
        </tx:attributes>
    </tx:advice>

    <!--3、配置切入点和切面-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pt" expression="execution(* com.jwt.transaction_.UserService.*(..))"/>
        <!--配置切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    </aop:config>
</beans>

测试

@Test
public void testTransaction3() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean7.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.accountMoney();
}

#有异常
id	name	money
1	 小明	 1000
2	 小红	 1000
#无异常
id	name	money
1	 小明	 900
2	 小红	 1100

声明式事务参数

propagation：事务传播行为

多事务方法直接进行互相调用，Spring 框架事务传播行为有7种

传播属性	描述
REQUIRED	如果有事务在运行,当前的方法就在这个事务内运行,否则就启动一个新事务,并在自己的事务内运行
REQUIRES_NEW	当前的方法必须启动新事务,并在它自己的事务内运行,如果有事务正在运行,应该将它挂起
SUPPORTS	如果有事务在运行,当前的方法就在这个事务内运行,否则它可以不运行在事务中
NOT_SUPPORTED	当前的方法不应该运行在事务中,如果有运行的事务,将它挂起
MANDATORY	当前的方法必须运行在事务内部,如果没有正在运行的事务,就抛出异常
NEVER	当前的方法不应该运行在事务中,如果有运行的事务,就抛出异常
NESTED	如果有事务运行,当前的方法就应该在这个事务的嵌套事务内运行,否则,就启动一个新的事务,并在它自己的事务内运行

如上，传播级别为 REQUIRED。

即：如果 add 方法本身有事务，调用 update 方法之后，update 使用当前 add 方法里面的事务。如果 add 方法本身没有事务，调用 update 方法之后，update 创建新事务

如上，传播级别为REQUIRES_NEW。即：add 方法本身无论是否有事务，update都创建新的事务

//配置
@Transactional(propagation = Propagation.REQUIRED)

ioslation：事务隔离级别

事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题

三个读问题：脏读、不可重复读、虚(幻)读

• 脏读：一个未提交事务读取到另一个未提交事务的数据
• 不可重复读：一个未提交事务读取到另一提交事务修改数据
• 虚读：一个未提交事务读取到另一提交事务添加数据

解决：通过设置事务隔离级别，解决读问题。MYSQL默认隔离级别:可重复读

	脏读	不可重复读	虚读
READ_UNCOMMITTED(读未提交)	不可解决	不可解决	不可解决
READ_COMMITTED(读已提交)	可解决	不可解决	不可解决
REPEATABLE_READ(可重复读)	可解决	可解决	不可解决
SERIALIZABLE(串行化)	可解决	可解决	可解决

//配置
@Transactional(isolation = Isolation.READ_COMMITTED)

timeout：超时时间

• 事务需要在一定时间内进行提交，如果不提交进行回滚

• 默认值是 -1 ，设置时间以秒单位进行计算

//设置
@Transactional(timeout = 60)

readOnly：是否只读

• 读：查询操作，写：添加修改删除操作

• readOnly 默认值 false，表示可以查询，可以添加修改删除操作

• 设置 readOnly 值是 true，设置成 true 之后，只能查询

//设置
@Transactional(readOnly = false)

rollbackFor：回滚

设置出现哪些异常进行事务回滚

//设置
@Transactional(rollbackFor = NullPointerException.class)

noRollBackFor：不回滚

设置出现哪些异常不进行事务回滚

//设置
@Transactional(noRollbackFor = NullPointerException.class)

❤️Sponsor

您的支持是我不断前进的动力，如果您恰巧财力雄厚，又感觉本文对您有所帮助的话，可以考虑打赏一下本文，用以维持本博客的运营费用，拒绝白嫖，从你我做起！🥰🥰🥰

支付宝支付	微信支付