Spring-事务


前言

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

小简目前研一,每天都有很多课程,另外还有科研的压力,只能利用空余时间更新文章,最近开始学习 SSM 框架了,一起加油吧✊。

  • 🚩时间安排:预计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

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

支付宝支付 微信支付

文章作者: 简简
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 简简 !
评论
填上邮箱会收到评论回复提醒哦!!!
 上一篇
Spring5-新特性 Spring5-新特性
前言今天开始学习我自己总结的 Java-学习路线 中的《Spring5-新特性》,小简从 0 开始学 Java 知识,并不定期更新所学笔记,期待一年后的蜕变吧!<有同样想法的小伙伴,可以联系我一起交流学习哦!> 小简目前研一,每
2022-04-17
下一篇 
Spring-JDBCTemplate Spring-JDBCTemplate
前言今天开始学习我自己总结的 Java-学习路线 中的《Spring-JDBCTemplate》,小简从 0 开始学 Java 知识,并不定期更新所学笔记,期待一年后的蜕变吧!<有同样想法的小伙伴,可以联系我一起交流学习哦!>
2022-04-15
  目录