【面试题】Spring

一、Spring事务失效的场景

0、开启事务

1、Spring开启事务

在Spring中，开启事务主要有两种方式：
方法一：使用注解 @Transactional
在Spring的配置文件中，首先需要声明事务管理器，然后开启注解驱动的事务管理。

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>
 
<!-- 开启注解驱动的事务管理 -->
<tx:annotation-driven transaction-manager="transactionManager" />

然后在需要事务管理的方法上使用@Transactional注解。

import org.springframework.transaction.annotation.Transactional;
 
@Transactional
public void someMethod() {
    // 方法内容
}

方法2：使用XML配置
在Spring的配置文件中，可以使用tx:advice标签定义事务通知，然后通过aop:config标签将事务通知和切入点结合起来。

在这个配置中，tx:method标签的propagation属性设置了事务的传播行为，这里使用REQUIRED，表示如果当前存在事务，就加入该事务，如果不存在，就创建一个新的事务。

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>
 
<!-- 定义事务通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
 
<!-- 配置AOP -->
<aop:config>
    <aop:pointcut id="serviceOperation" expression="execution(* com.example.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation"/>
</aop:config>

aop:pointcut定义了切入点，即哪些方法会被应用事务通知。
aop:advisor将事务通知和切入点结合起来。

2、SpringBoot开启事务

在Spring Boot中启用事务非常简单，你可以使用@Transactional注解来标记一个方法或一个类，使其支持事务。
首先，确保你的Spring Boot项目已经添加了Spring Transactions的依赖，通常这是自动添加的，如果不是，可以在pom.xml中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

确保你的Spring Boot应用启动类上有@EnableTransactionManagement注解

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;
 
@SpringBootApplication
@EnableTransactionManagement
public class YourApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

使用@Transactional注解来标记方法开启事务

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class YourService {
 
    @Transactional
    public void someTransactionalMethod() {
        // 方法内的操作将在事务中执行
    }
}

当someTransactionalMethod被调用时，Spring将开启一个事务，并在该方法执行完毕后提交事务，除非抛出异常，这时Spring将回滚事务。
注意：@Transactional注解可以配置很多属性，比如事务的隔离级别、传播行为、超时设置等。

一、事务失效的场景

1、手动捕获了异常，未将异常抛出

2、捕获的异常类型为非检查异常

@Transactional默认处理的异常为检查异常，当方法抛出非检查异常时，注解@Transactional不会处理回滚，因此事务会失效。
解决方法：修改捕获的异常类型

	@Transactional(rollbackFor = Exception) // rollbackFor 设置需要处理的异常类型
    public void someTransactionalMethod() {
        // 方法内的操作将在事务中执行
    }

3、非public方法

事务拦截器在目标方法执行前后进行拦截，内部会调用方法来获取Transactional 注解的事务配置信息，调用前会检查目标方法的修饰符是否为 public，不是 public则不会获取@Transactional 的属性配置信息。

4、同一个类中方法相互调用，导致@Transactional失效

开发中避免不了会对同一个类里面的方法调用，比如有一个类Test，它的一个方法A，A再调用本类的方法B（不论方法B是用public还是private修饰），但方法A没有声明注解事务，而B方法有。则外部调用方法A之后，方法B的事务是不会起作用的。这也是经常犯错误的一个地方。

那为啥会出现这种情况？其实这还是由于使用Spring AOP代理造成的，因为只有当事务方法被当前类以外的代码调用时，才会由Spring生成的代理对象来管理。

二、Bean的生命周期

Bean的生命周期主要

1、bean的构造函数调用：调用构造方法，创建一个空的bean对象
2、依赖注入：构造器注入/set注入
3、Aware接口
4、bean前处理器
5、bean的初始化方法
6、bean后处理器
7、销毁bean

三、Spring中的循环引用/依赖

1、什么是循环依赖/引用？

循环依赖就是循环引用，两个或两个以上的bean互相持有对方，形成了闭环。

2、怎么解决循环依赖？

Spring中允许存在循环依赖。并且提供了三级缓存解决了大部分循环依赖（无法解决构造器注入）

• 一级缓存：单例池，存放已经创建完成（经历了完整的生命周期），可以直接使用的Bean

• 二级缓存：缓存早起的bean对象（未走完所有生命周期的bean对象）
  
  注：二级对象无法解决代理对象的循环依赖，需要使用三级缓存解决

• 三级缓存：缓存ObjectFactory，表示对象工厂，用来创建某个对象（bean对象或代理对象）
  

3、构造器循环依赖怎么解决？

@Component // spring管理，bean
public class A{
	private B b; 
	public A(B b) { // A的构造方法
		this.b = b;
	}
}

@Component
public class B{
	private A a;
	public B(A a) { // B的构造方法
		this.a = a;
	}
}

在上例中，A、B对象的构造方法中都对彼此的私有属性进行复制，即在Bean创建过程中，在构造方法阶段产生了循环依赖，spring的三级缓存无法解决此类循环依赖。
解决方法：在构造方法赋值bean时使用注解 @Lazy 延迟加载

@Component // spring管理，bean
public class A{
	private B b; 
	public A(@Lazy B b) { // A的构造方法
		this.b = b;
	}
}