Spring事务

本文涉及的产品
RDS MySQL Serverless 基础系列,0.5-2RCU 50GB
RDS MySQL Serverless 高可用系列,价值2615元额度,1个月
简介: Spring事务

整合MyBatis

分析

最终需要管理的是Mapper实例

Mapper实例没有实现类,是通过SqlSession获得,但Sqlsession是线程不安全的,不能直接管理SqlSession,因为每个线程的SqlSession都是不一样的。

所以只能统一管理线程安全的SqlSessionFactory,通过他来获取SqlSsession,然后管理

mybatis对Spring支持的依赖中提供了注册SqlSessionFactory组件的工厂类

引入依赖

mybatis-spring、spring-jdbc、spring-tx

spring-xxx是官方的依赖,xxx-spring是第三方

<!--整合mybatis对Spring的支持-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
</dependency>
<!--spring-tx通过jdbc的引入可以一起引入进来-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.15.RELEASE</version>
</dependency>

注册SqlSessionFactory组件

提供了一个工厂bean → FactoryBean

SqlSessionFactoryBean

public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>{
    public SqlSessionFactory getObject() throws Exception {
        if (this.sqlSessionFactory == null) {
            this.afterPropertiesSet();
        }
        return this.sqlSessionFactory;
    }
    public Class<? extends SqlSessionFactory> getObjectType() {
        return this.sqlSessionFactory == null ? SqlSessionFactory.class : this.sqlSessionFactory.getClass();
    }
}

这个是已经提供好的,我们直接注册即可,不需要重新写

最终的返回值就是一个SqlSessionFactory

Mapper实例

找到所有的Mapper接口,将接口对应的代理实例注册为容器中的组件

我们需要提供的就是接口的位置

MapperScannerConfigurer 进行Mapper接口包目录管理的配置

注册DataSource组件需要引入druid依赖

<!--注册DataSource组件-->
<bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url"
                  value="jdbc:mysql://localhost:3306/practice?useSSL=false&amp;characterEncoding=utf8&amp;allowMultiQueries=true"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!--可以提供datasource组件-->
    <property name="dataSource" ref="datasource"/>
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!--告知接口的位置-->
    <property name="basePackage" value="com.cskaoyan.mapper"/>
    <!--告知SqlSessionFactory-->
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
</bean>

要注意,在导入以上这些依赖的同时,也需要导入mybatis本身!

同时也要注意url属性里面要配置合适的连接,比如编码格式等等

Spring事务

为什么要管理事务?

MyBatis整合完Spring之后,已经由Spring自动管理事务。每执行完一行Mapper方法,都会提交事务。

有一些情况需要将多行的执行作为一个事务,这时候就需要Spring做进一步的事务管理

事务

A原子性C一致性I隔离性D持久性

事务并发引起的问题:脏读、不可重复读、虚幻读

数据库隔离级别:读未提交、读已提交、可重复读、串行化

脏读 不可重复读 虚幻读
读未提交 × × ×
读已提交 × ×
可重复读 ×
串行化

mysql默认的隔离级别:可重复读,并可以解决虚幻读的问题

原理

代理

所做的增强 → 事务

BeanPostProcessor

核心接口

Spring管理事务就是使用这些核心接口中提供的方法。

代理

PlatformTransactionManager

平台事务管理器

提供了三个方法

由于平台事务管理器是一个接口,所以我们在使用的时候一般是使用实现类

DataSourceTransactionManager

public interface PlatformTransactionManager extends TransactionManager {
    //根据definition获得status
    TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;
  //根据status做提交或回滚
    void commit(TransactionStatus var1) throws TransactionException;
    void rollback(TransactionStatus var1) throws TransactionException;
}

TransactionStatus是一个过程值,而面向程序员的是TransactionDefinition

TransactionStatus

事务状态

TransactionDefinition

事务的定义

事务的名称、只读属性、隔离级别、超时时间、传播行为

PropagationBehavior传播行为

多个方法之间如何来共享事务 → 多个方法都增加上了事务,方法之间存在着调用关系,如果发生异常,存在着调用关系的方法哪一些回滚,哪一些提交

比如现在有一个method1,method1调用了method2,如果method1发生了异常,谁提交谁回滚;如果method2发生了异常谁提交谁回滚。

默认传播行为REQUIRED

如果没有事务,则新增一个;如果有事务,则加入进来,作为一个事务。

同生共死,要么一起提交,要么一起回滚

比如现在有一个method1,method1调用了method2,

如果method1发生了异常,谁提交谁回滚? 都回滚

如果method2发生了异常,谁提交谁回滚? 都回滚

REQURIES_NEW

如果没有事务,则新增一个;如果有事务,则新增一个新事务。

自私型。外围不能影响内部,但是内部可以响应外围。

比如现在有一个method1,method1调用了method2,

如果method1发生了异常,谁提交谁回滚? 1回滚2提交

如果method2发生了异常,谁提交谁回滚? 都回滚

NESTED

如果没有事务,则新增一个;如果有事务,则以嵌套事务的方式运行。

无私型。外围会响应内部,但是内部不会影响外围。

PDD 砍一刀,拉新客,获得新用户的成本。

注册 → 发放新用户优惠券

注册相对于发放优惠券更重要,而注册是外围方法,保外围方法 → nested

Definition接口
public interface TransactionDefinition {
    int PROPAGATION_REQUIRED = 0;
    int PROPAGATION_SUPPORTS = 1;
    int PROPAGATION_MANDATORY = 2;
    int PROPAGATION_REQUIRES_NEW = 3;
    int PROPAGATION_NOT_SUPPORTED = 4;
    int PROPAGATION_NEVER = 5;
    int PROPAGATION_NESTED = 6;
    int ISOLATION_DEFAULT = -1;
    int ISOLATION_READ_UNCOMMITTED = 1;
    int ISOLATION_READ_COMMITTED = 2;
    int ISOLATION_REPEATABLE_READ = 4;
    int ISOLATION_SERIALIZABLE = 8;
    int TIMEOUT_DEFAULT = -1;
    default int getPropagationBehavior() {
        return 0;
    }
    default int getIsolationLevel() {
        return -1;
    }
    default int getTimeout() {
        return -1;
    }
    default boolean isReadOnly() {
        return false;
    }
    @Nullable
    default String getName() {
        return null;
    }
    static TransactionDefinition withDefaults() {
        return StaticTransactionDefinition.INSTANCE;
    }
}

案例

Spring要管理事务,容器中要管理PlatformTransactionManager组件

这个时候可以用Spring提供好的组件

<!--PlatformTransactionManager组件-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="datasource"/>
</bean>

手动编程

首先要添加一个管理事务的组件

<!--手动增加事务 → TransactionTemplate-->
<bean class="org.springframework.transaction.support.TransactionTemplate">
    <property name="transactionManager" ref="transactionManager"/>
</bean>

相当于实现了一个接口

@FunctionalInterface
public interface TransactionCallback<T> {
    @Nullable
    T doInTransaction(TransactionStatus var1);
}

在这个接口之中,我们做业务的操作,即将事务都写在接口里面,这样就能达到一体的效果

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    AccountMapper mapper; //从容器中取出mapper
    @Autowired
    TransactionTemplate txTemplate; //取出手动增加事务的组件
    @Override
    public void exchangeMoney(String fromName, String toName, Integer money) {
        int fromMoney = mapper.selectMoneyByName(fromName);
        int toMoney = mapper.selectMoneyByName(toName);
        fromMoney -= money;
        toMoney +=money;
        int finalToMoney = toMoney;
        int finalFromMoney = fromMoney;
        Object execute = txTemplate.execute(new TransactionCallback<Object>() {
            @Override
            public Object doInTransaction(TransactionStatus transactionStatus) {
                mapper.updateAccount(fromName, finalFromMoney);
//                System.out.println(1/0);
                mapper.updateAccount(toName, finalToMoney);
                return "doInTransaction"; //这里的返回值最终给到了execute
            }
        });
        System.out.println(execute);
    }
}

每一处出现事务的地方,都需要手动编程增加上TransactionTemplate的方法

代理对象

生成一个代理对象 → 增强是事务

TransactionProxyFactoryBean

委托类组件是谁、TransactionManager、TransactionDefinition

通知不需要

spring提供好的动态代理对象,需要在容器中注册

<bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="target" ref="accountServiceImpl"/>
    <property name="transactionManager" ref="transactionManager"/>
    <!--事务参数 → Definition-->
    <property name="transactionAttributes">
        <props>
            <!--key:方法名-->
            <!--value:definition-->
            <!--
                ISOLATION_XXX 隔离级别
                PROPAGATION_XXX 传播行为
                timeout_数字 超时时间,单位是秒
                readOnly 只读
                +Exception noRollBack
                -Exception rollBack
            -->
            <prop key="transfer">ISOLATION_DEFAULT,PROPAGATION_REQUIRES_NEW,timeout_5</prop>
        </props>
    </property>
</bean>

aspectj → advisor(可用)

pointcut和advice

<aop:config>
    <aop:pointcut id="transactionPointcut" expression="execution(* com.cskaoyan.service..*(..))"/>
    <!--advisor的通知 implements MethodInterceptor-->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>
<!--spring给我们提供了一种直接配置TransactionInterceptor的写法 → tx:advice-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--对方法增加上个性化的definition:方法和definition的对应关系-->
    <tx:attributes>
        <!--name属性:方法名,可以使用通配符*-->
        <tx:method name="transfer" read-only="true"/>
        <!--<tx:method name="transfer2"/>-->
    </tx:attributes>
</tx:advice>

***声明式事务

事务注解加在哪个方法上,哪个方法就被增强了 → 事务

注解 @Transactional

注解和方法绑定起来,Definition也是和注解绑定起来 → 注解的属性

注解加在类上就表示该类的所有方法都增加事务

//可以写在类上,也可以写在方法上
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    @AliasFor("transactionManager")
    String value() default "";
    @AliasFor("value")
    String transactionManager() default "";
    Propagation propagation() default Propagation.REQUIRED;
    Isolation isolation() default Isolation.DEFAULT;
    int timeout() default -1;
    boolean readOnly() default false;
    Class<? extends Throwable>[] rollbackFor() default {};
    String[] rollbackForClassName() default {};
    Class<? extends Throwable>[] noRollbackFor() default {};
    String[] noRollbackForClassName() default {};
}

打开注解开关

<!--PlatformTransactionManager组件-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="datasource"/>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>
@Transactional(isolation = Isolation.REPEATABLE_READ,
        propagation = Propagation.REQUIRES_NEW,noRollbackFor = ArithmeticException.class)
@Override
public void transfer(Integer fromId, Integer destId, Integer money) {
    //原始money
    Integer fromMoney = accountMapper.selectMoneyById(fromId);
    Integer destMoney = accountMapper.selectMoneyById(destId);
    //计算转账后的money
    fromMoney -= money;
    destMoney += money;
    //执行更新,更新转账后的money
    accountMapper.update(fromId, fromMoney); //事务提交了
    int i = 1 / 0;  //发生异常
    try {
        Thread.sleep(1000);
        //Thread.sleep(6000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    accountMapper.update(destId, destMoney); //没有执行到
}

JavaConfig

以Java代码和注解的方式来替代xml配置的 → 铺垫、SpringBoot推荐使用的配置方式

我们是xml标签做了哪些事情

  1. 组件注册
  2. 扫描包配置context:component-scan base-package √
  3. 引入properties配置文件 context:property-placeholder location √
  4. 打开aspectj的注解开关 aop:aspectj-autoproxy √
  5. 事务的注解驱动 tx:annotation-driven √

配置类 @Configuration

@Configuration

把当前类作为配置类,同时也是容器中的组件

扫描包配置

@ComponentScan(“包目录”)

写在配置类上

@Configuration
@ComponentScan("com.cskaoyan")
public class SpringConfig {
}

properties配置文件

@Configuration
@ComponentScan("com.cskaoyan")
//@PropertySource("classpath:param.properties")
public class SpringConfig {
}

配置类加载不到properties文件的值

aspectj注解开关

@Configuration
@ComponentScan("com.cskaoyan")
//@PropertySource("classpath:param.properties")
@EnableAspectJAutoProxy    //要引入aspectjweaver依赖
public class SpringConfig {
}

事务注解驱动

@Configuration
@ComponentScan("com.cskaoyan")
//@PropertySource("classpath:param.properties")
@EnableAspectJAutoProxy       //要引入aspectjweaver依赖
@EnableTransactionManagement  //容器中要有TransactionManager组件
public class SpringConfig {
}

***组件注册

组件注册以方法的形式存在,方法的返回值作为组件注册到容器中,默认的id就是方法名,也可以自定义

@Configuration //标记为配置类
@ComponentScan("com.fh") //扫描包
@EnableAspectJAutoProxy //aspectj注解开关
@EnableTransactionManagement //事务注解驱动,打开之后一定要注册TransactionManager组件
public class SpringConfig {
    //组件id:默认值 👉 方法名
    //       设定值 👉 @Bean注解的value属性值
    //@Bean // id = dataSource
    @Bean
    public DruidDataSource dataSource(){ //引入数据源
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/practice?useSSL=false&characterEncoding=utf8&allowMultiQueries=true");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        return dataSource;
    }
    //形参:从容器中按照类型取出组件(该类型组件在容器中只有一个),如果该类型组件不止一个,需要指定组件id @Qualifier
    //维护一个sqlSessionFactory
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(@Qualifier("dataSource")DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){ //扫描包配置
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.fh.mapper");
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactoryBean");
        return mapperScannerConfigurer;
    }
    @Bean
    public DataSourceTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }
}

测试类

@RunWith(SpringJUnit4ClassRunner.class)
//配置文件加载的是配置类
@ContextConfiguration(classes = SpringConfig.class)
public class MyTest {}
相关实践学习
基于CentOS快速搭建LAMP环境
本教程介绍如何搭建LAMP环境,其中LAMP分别代表Linux、Apache、MySQL和PHP。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心,利用清洁计算为万物互联的新世界提供源源不断的能源动力,目前开服的区域包括中国(华北、华东、华南、香港)、新加坡、美国(美东、美西)、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程,来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品:云服务器ECS 云服务器 ECS(Elastic Compute Service)是一种弹性可伸缩的计算服务,助您降低 IT 成本,提升运维效率,使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
目录
相关文章
|
1月前
|
Java 数据库 开发者
|
5天前
|
Java 开发者 Spring
spring事务类型,事务传递,隔离级别?
spring事务类型,事务传递,隔离级别?
|
7天前
|
Java Spring 容器
Spring 中一个事务方法调用另一个事务方法会怎样?
【6月更文挑战第5天】如果我们在一个包含事务的方法中,调用了另一个包含里事务的方法,那么,Spring 会创建新的事物吗?如果方法抛出异常导致事务会滚了呢?
17 0
|
13天前
|
Java 关系型数据库 MySQL
【JavaEE进阶】Spring中事务的实现
【JavaEE进阶】Spring中事务的实现
|
19天前
|
Java 关系型数据库 MySQL
Spring 事务和事务传播机制
Spring 事务和事务传播机制
Spring 事务和事务传播机制
|
19天前
|
Java 关系型数据库 MySQL
Spring 事务和事务传播机制
Spring 事务和事务传播机制
|
19天前
|
Java 数据库 Spring
Spring 事务
Spring 事务
23 1
|
19天前
|
Java 数据库 Spring
Spring 事务 (编程式 & 声明式, Spring 事务传播机制)
Spring 事务 (编程式 & 声明式, Spring 事务传播机制)
24 1
|
1月前
|
SQL Java 关系型数据库
Spring 事务
Spring 事务
22 1
|
1月前
|
Java 数据库连接 数据库
Spring事务简介,事务角色,事务属性
Spring事务简介,事务角色,事务属性
24 2