2024年最全【Spring源码】Spring事务原理_transactiontemplate，java虚拟机内存模型面试

2401_84557608

已于 2024-05-07 23:58:40 修改

阅读量741

点赞数 8

分类专栏：程序员文章标签： java spring 面试

于 2024-05-07 23:58:38 首次发布

本文链接：https://blog.csdn.net/2401_84557608/article/details/138550220

版权

程序员专栏收录该内容

121 篇文章 1 订阅

订阅专栏

最后

Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务高级架构开发等等。

还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。
在这里插入图片描述

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

tx:attributes
<tx:method name=“add*” propagation=“REQUIRED”/>
<tx:method name=“update*” propagation=“REQUIRED”/>
<tx:method name=“delete*” propagation=“REQUIRED”/>
<tx:method name=“get*” propagation=“SUPPORTS” read-only=“true”/>
<tx:method name=“find*” propagation=“SUPPORTS” read-only=“true”/>
</tx:attributes>
</tx:advice>

aop:config
<aop:pointcut id=“serviceMethod” expression=“execution(* com.example.service..(…))”/>
<aop:advisor advice-ref=“txAdvice” pointcut-ref=“serviceMethod”/>
</aop:config>


在上述配置文件中，我们首先定义了一个名为 txAdvice 的事务切面，其中通过 tx:attributes 标签来为不同的方法配置传播特性。


例如，我们为 add、update 和 delete 方法配置了 REQUIRED 传播特性，表示如果当前存在事务，则加入该事务，如果不存在，则新建一个事务。而对于 get 和 find 方法，我们配置了 SUPPORTS 传播特性，并设置了 read-only 属性为 true，表示这些方法是只读操作，不需要开启事务。


最后，我们通过 aop:config 标签来定义一个切入点和一个切面，并将切面和切入点关联起来，从而实现对服务类中的方法进行事务管理。


#### 2.1.3、Spring事务的隔离级别


**问：数据库事务的隔离级别**


ChatGPT答：常见的隔离级别包括：


1. READ UNCOMMITTED（读未提交）：最低的隔离级别，允许一个事务读取另一个未提交的事务所做的修改，可能导致脏读、不可重复读和幻读问题。
2. READ COMMITTED（读已提交）：一个事务只能读取已经提交的数据，可以避免脏读问题，但是可能会出现不可重复读和幻读问题。
3. REPEATABLE READ（可重复读）：保证在事务处理期间多次读取同一数据时，数据保持一致。可以避免脏读和不可重复读问题，但仍可能出现幻读问题。
4. SERIALIZABLE（串行化）：最高的隔离级别，完全禁止不同事务之间的并发操作，可以避免所有可能的并发问题，但可能导致性能问题。


在实际应用中，可以通过设置数据库连接的隔离级别来指定事务的隔离级别。例如，在MySQL中可以使用如下SQL语句来设置隔离级别：

SET SESSION TRANSACTION ISOLATION LEVEL <隔离级别>




---


**问：Spring事务的隔离级别**


**ChatGPT答：**Spring支持以下五个隔离级别：


1. DEFAULT（默认）：使用底层数据源的默认隔离级别，这通常是数据库的隔离级别。
2. READ\_UNCOMMITTED（读未提交）：最低的隔离级别，允许读取尚未提交的数据更改，可能导致脏读，不可重复读和幻读问题。
3. READ\_COMMITTED（读已提交）：允许读取已提交的数据更改，可以避免脏读问题，但仍可能出现不可重复读和幻读问题。
4. REPEATABLE\_READ（可重复读）：保证在事务处理期间多次读取同一数据时，数据保持一致。可以避免脏读和不可重复读问题，但仍可能出现幻读问题。
5. SERIALIZABLE（串行化）：最高的隔离级别，完全禁止不同事务之间的并发操作，可以避免所有可能的并发问题，但可能导致性能问题。


在选择隔离级别时，需要权衡数据的一致性和性能之间的关系，选择适合应用程序需求的隔离级别。隔离级别越高，可能会导致性能下降和死锁等问题，因此在选择隔离级别时需要谨慎考虑。




---


**问：解析一下什么是脏读，不可重复读取，幻读**


**ChatGPT答：**脏读、不可重复读和幻读是数据库中并发操作时可能出现的问题，这些问题与事务隔离级别有关。


1. 脏读（Dirty Read）：一个事务读取了另一个事务尚未提交的数据，如果另一个事务回滚了操作，那么第一个事务读取的数据就是无效的。
2. 不可重复读（Non-Repeatable Read）：一个事务在读取某一行数据时，另一个事务修改了该行数据并提交了事务，导致第一个事务多次读取同一数据时得到的结果不一致。
3. 幻读（Phantom Read）：一个事务在读取一组数据时，另一个事务插入了符合该条件的新数据并提交了事务，导致第一个事务再次读取同一数据时得到的结果不一致。


这三种问题可以通过设置不同的事务隔离级别来避免或减少发生。例如，READ COMMITTED隔离级别可以避免脏读问题，REPEATABLE READ隔离级别可以避免脏读和不可重复读问题，而SERIALIZABLE隔离级别可以避免所有并发问题。




---


### 2.2、基本原理


由上诉ChatGPT的答复，以及自己以往Spring事务的使用可知。Spring事务管理就是基于AOP实现，主要作用就是统一封装非功能性需求。Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，Spring也无法提供事务功能。


如果我们纯操作JDBC，那么我们可以按照如下步骤进行事务控制：


1. Connection conn = DriverManager.getConnection();获取数据库连接
2. 开启事务是否自动提交，conn.setAutoCommit(true/false)
3. JDBC操作
4. 提交事务conn.commit()或事务回滚conn.rollback()
5. 关闭连接conn.close()


如果使用了Spring事务，我们就不需要手动开启或关闭事务操作（上述第2步和第4步）。而是交由Spring自己完成。那么Spring使用事务的方式有哪些呢？在 Spring 中，我们可以通过声明式事务管理和编程式事务管理两种方式来管理事务。


* 声明式事务管理是指将事务的定义和管理与业务逻辑分离，通过配置文件或注解等方式来实现事务管理。在 Spring 中，可以使用 @Transactional 注解来声明事务。
* 编程式事务管理是指在代码中通过编程的方式来控制事务，即在代码中手动开启、提交和回滚事务。Spring 提供了 TransactionTemplate 类来实现编程式事务管理。


示例代码如下：

// 声明式事务
@Service
public class TestServiceImpl {
@Transactional(rollbackFor = Exception.class)
public void reduce(){
…
}
}

// 编程式事务
@Service
public class TestServiceImpl {
@Autowired
TransactionTemplate transactionTemplate;

 public void reduce(){
     transactionTemplate.execute(status -> {
       ......
    });
 }

}


真正的数据库层的事务提交和回滚是通过binglog或redo log实现的。


网上借来一张Spring事务API架构图：


![](https://img-blog.csdnimg.cn/9da6ec8c604e40b09dec4a69dbdf64d0.png)



## 3、事务嵌套


前面2章节都是从理论知识的角度阐述了事务的一些基本特性。显然这些背诵的八股文一下子就忘记了。接下来我们以实际业务的角度来分析一下几种传播机制。且以我们平时最常见到的调用方式来说明：那就是事务嵌套。


看一段代码：

@Service
class OrderService {
@Resource
ReduceService reduceService;

@Transactional(rollbackFor = Exception.class)
public void createOrder(){
    // 下单
    this.createOrder0();
    // 扣除库存
    reduceService.reduce();
}

}

@Service
class ReduceService {

@Transactional(rollbackFor = Exception.class)
public void reduce(){
    ......
}

}


这时候，OrderService的createOrder()调用ReduceService的reduce()方法，两个方法都声明了事务，这时候就形成了事务嵌套。


### 3.1、PROPAGATION\_REQUIRED


当执行orderService.createOrder()时，spring已经发起事务，这时候调用reduceService.reduce()时，reduceService.reduce()发现自己已经运行在事务内部，就会直接使用外部事务。如果发现外部没有事务，那么就会给reduce()方法新建事务。


当orderService.createOrder()或reduceService.reduce()发生异常时，事务都会被回滚。![](https://img-blog.csdnimg.cn/896c7d1ba88e4d21b21d55bb869e9aec.png)



### 3.2、PROPAGATION\_REQUIRES\_NEW


当reduceService.reduce()设置了PROPAGATION\_REQUIRES\_NEW，orderService.createOrder()属性为PROPAGATION\_REQUIRED。那么当执行到reduce()方法时，会判断外部是否有事务，如果有，则会挂起外部事务，然后自身创建一个新的内部事务，等到内部事务执行结束后，才会继续执行被挂起的外部事务。


这样的话，由于reduce()是新发起一个事务，且与外部事务是独立的。当createOrder()发生异常时，如果reduce()事务被提交了，那么是reduce()不会回滚的。相应的，如果reduce()抛出异常，被createOrder()捕获，那么createOrder()的事务仍然可能提交，取决于外部事务的回滚操作。


![](https://img-blog.csdnimg.cn/67603c11b118470cb7fb2284205a1567.png)




### 3.3、PROPAGATION\_SUPPORTS


与PROPAGATION\_REQUIRED类似，只是当执行到reduceService.reduce()方法时，会判断createOrder()是否开启了事务，如果是的话，那么直接支持该事务。如果没有的话，那么自己也不支持事务。这个事务属性是完全取决于外部的事务。


![](https://img-blog.csdnimg.cn/d80647567292427f89438c21fa7be080.png)




### 3.4、PROPAGATION\_NESTED


当执行到ReduceService.reduce()方法时，如果reduce()出现内部异常，则reduce()会回滚到他执行之前的SavePoint，因此是不会产生脏数据的，相当于该方法从未执行过。


此时createOrder()方法可以直接try-catch异常，然后进行分支逻辑事务处理。如：

@Service
class OrderService {
@Resource
ReduceService reduceService;

@Transactional(rollbackFor = Exception.class)
public void createOrder(){
    // 下单
    this.createOrder0();
    // 扣除库存
    try {
        reduceService.reduce();
    } catch (Exception e) {
        // 如果扣除异常，则取消订单
        this.cancelOrder()
        return ;
    }
    
    // 进行下一步操作
    doSomething();
}

}

@Service
class ReduceService {

@Transactional(propagation = PROPAGATION.NESTED, rollbackFor = Exception.class)
public void reduce(){
    ......
}

}


也可以根据外部事务的具体配置决定要提交还是回滚。不过该方式只对DataSourceTransactionManager事务管理器有效。


![](https://img-blog.csdnimg.cn/6e868444d7d4463da7bf97393dcb5b09.png)




## 4、源码看事务


Spring中通过注解@EnableTransactionManagement开启事务，那么我们从这个注解开始入手：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
boolean proxyTargetClass() default false;
AdviceMode mode() default AdviceMode.PROXY;
int order() default Ordered.LOWEST_PRECEDENCE;
}


可以看到@Import了TransactionManagementConfigurationSelector，而这个类实现了ImportSelector接口，提供了实现方式PROXY和ASPECTJ。默认PROXY

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector {

/**
* Returns {@link ProxyTransactionManagementConfiguration} or
* {@code AspectJ(Jta)TransactionManagementConfiguration} for {@code PROXY}
* and {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()},
* respectively.
*/
@Override
protected String[] selectImports(AdviceMode adviceMode) {
switch (adviceMode) {
case PROXY:
// AutoProxyRegistrar ：主要是注册了 InfrastructureAdvisorAutoProxyCreator 自动代理创建器。
// 而 InfrastructureAdvisorAutoProxyCreator 的逻辑基本上和 Aop 的逻辑相同
// ProxyTransactionManagementConfiguration ：注册了事务实现的核心 Bean，
// 包括 BeanFactoryTransactionAttributeSourceAdvisor 、 TransactionAttributeSource 、 TransactionInterceptor 等
return new String[] {AutoProxyRegistrar.class.getName(),
ProxyTransactionManagementConfiguration.class.getName()};
case ASPECTJ:
return new String[] {determineTransactionAspectClass()};
default:
return null;
}
}

private String determineTransactionAspectClass() {
return (ClassUtils.isPresent(“javax.transaction.Transactional”, getClass().getClassLoader()) ?
TransactionManagementConfigUtils.JTA_TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME :
TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME);
}

}


* AutoProxyRegistrar：就是完成事务代理类创建的部分，也就是我们熟悉的AOP代理创建注册的流程，可以跟进查看源码org.springframework.context.annotation.AutoProxyRegistrar#registerBeanDefinitions
* ProxyTransactionManagementConfiguration：注册事务的实现核心


查看源码org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration

@Configuration(proxyBeanMethods = false)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {

// 设置了切面拦截方法，以及切点
@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {

  BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
  advisor.setTransactionAttributeSource(transactionAttributeSource);
  advisor.setAdvice(transactionInterceptor);
  if (this.enableTx != null) {
     advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
  }
  return advisor;

}

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionAttributeSource transactionAttributeSource() {
return new AnnotationTransactionAttributeSource();
}

// 设置事务拦截器，增强式事务的逻辑就是在这里

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
TransactionInterceptor interceptor = new TransactionInterceptor();
interceptor.setTransactionAttributeSource(transactionAttributeSource);
if (this.txManager != null) {
interceptor.setTransactionManager(this.txManager);
}
return interceptor;
}

}


而TransactionInterceptor这个类，就是我们切面的实现类，用于事务方法的拦截，然后通过Spring事务管理器PlatformTransactionManager进行管理。

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {

public TransactionInterceptor() {}

/**
* 创建一个新的事务拦截器TransactionInterceptor.
* @param ptm 默认的事务管理器，通过该事务管理器进行实际的事务管理
* @param tas properties形式的事务属性
* @since 5.2.5
* @see #setTransactionManager
* @see #setTransactionAttributeSource
*/
public TransactionInterceptor(TransactionManager ptm, TransactionAttributeSource tas) {
setTransactionManager(ptm);
setTransactionAttributeSource(tas);
}

@Override
@Nullable
public Object invoke(MethodInvocation invocation) throws Throwable {
// Work out the target class: may be {@code null}.
// The TransactionAttributeSource should be passed the target class
// as well as the method, which may be from an interface.
Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

  // 配到父类TransactionAspectSupport的invokeWithinTransaction方法
  // 第三个参数是InvocationCallback接口，可以保证在父类TransactionAspectSupport#invokeWithinTransaction方法中回调到当前方法的拦截器链条
  return invokeWithinTransaction(invocation.getMethod(), targetClass, new CoroutinesInvocationCallback() {
     @Override
     @Nullable
     public Object proceedWithInvocation() throws Throwable {
        return invocation.proceed();
     }
     @Override
     public Object getTarget() {
        return invocation.getThis();
     }
     @Override
     public Object[] getArguments() {
        return invocation.getArguments();
     }
  });

}
…
}


查看org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction

@Nullable
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {

// 获取事务属性源TransactionAttributeSource
TransactionAttributeSource tas = getTransactionAttributeSource();
// 获取当前调用的方法的事务属性，如果TransactionAttribute为null，则该方法就是非事务方法
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
// 获取事务管理器TransactionManager
final TransactionManager tm = determineTransactionManager(txAttr);

// 判断不同的事务管理器
if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
// ReactiveTransactionManager事务管理器不常用，这里省略
…
}

// 获取到常用的PlatformTransactionManager事务管理器
PlatformTransactionManager ptm = asPlatformTransactionManager™;
//连接点识别符，也就是事务所作用的方法，如OrderService.createOrder()
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
// Standard transaction demarcation with getTransaction and commit/rollback calls.
// 创建一个标准事务
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

  Object retVal;
  try {

最后

毕竟工作也这么久了，除了途虎一轮，也七七八八面试了不少大厂，像阿里、饿了么、美团、滴滴这些面试过程就不一一写在这篇文章上了。我会整理一份详细的面试过程及大家想知道的一些问题细节

美团面试经验

美团面试
字节面试经验

菜鸟面试经验

蚂蚁金服面试经验

唯品会面试经验

因篇幅有限，图文无法详细发出

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

问题细节

美团面试经验

[外链图片转存中…(img-oPteAiZB-1715097502198)]
字节面试经验
[外链图片转存中…(img-Vibx9nCC-1715097502198)]
菜鸟面试经验
[外链图片转存中…(img-ykAumSIn-1715097502198)]
蚂蚁金服面试经验
[外链图片转存中…(img-icUkaWXC-1715097502199)]
唯品会面试经验
[外链图片转存中…(img-LO2lEg9n-1715097502199)]

因篇幅有限，图文无法详细发出

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

2401_84557608

关注

8
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
2024年最全【Spring源码】Spring事务原理_transactiontemplate，java虚拟机内存模型面试

Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务高级架构开发等等。还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录。
复制链接

扫一扫