spring面试题【持续更新ing】

---

一、什么是循环依赖（高频）？

循环依赖是指两个或多个模块、类、组件之间相互依赖，形成一个依赖闭环。导致的无法确定加载或初始化。
例如：

@Service
public class A {
    @Autowired
    private B b;
}

@Service
public class B {
    @Autowired
    private A a;
}

//或者自己依赖自己
@Service
public class A {
    @Autowired
    private A a;
}

二、Spring 如何解决循环依赖？

第一种方法：Spring中 使用三级缓存来解决循环依赖问题
具体方法见后面这个博客：Spring中的循环依赖问题和三级缓存

第二种方法：使用@lazy注解
为什么可以解决？

• 假设Bean A 依赖于 Bean B，而 Bean B 又依赖于 Bean A。
• 如果Bean B 被标记为 @lazy，当Spring在创建Bean A时，检测到Bean B还不存在时，会使用代理对象进行“填充”，然后继续完成Bean A的创建。
• 随后当Bean A需要访问Bean B时，代理对象会触发堆Bean B的实际创建，此时Bean A已经创建完成，循环依赖因此被打破。

三、Spring都有哪些重要的模块？

Core Container （核心容器）

• Spring Core：提供了依赖注入（Dependency Injection，DI）和控制反转（Inversion of Control， IoC）的实现，是所有其他Spring模块的基础，别的模块都依赖此模块。
• Spring Beans：负责管理Bean的定义和生命周期。通过IoC容器完成Bean的实例化、依赖注入、初始化、销毁等操作
• Spring Context：基于Core和Beans的高级容器，提供了类似JNDI的上下文功能，还包含了国际化、事件传播、资源访问等功能。
• Spring Expression Language（SpEL）：一个强大的表达式语言，用于在运行时查询和操作对象的值。

AOP（面向切面编程）

• Spring AOP：提供面向切面编程的功能，可以在方法执行前后或抛出异常时动态插入额外的逻辑，比如日志记录、权限验证、事务管理等。

Data Access（数据访问）

• Spring JDBC：简化了原生JDBC的操作，提供模板方法
• Spring ORM：支持于主流ORM框架（如MyBatis等）集成，简化持久层开发
• Spring Transaction（事务管理）：提供声明式和编程式事务管理机制，与数据库操作结合

Web 层

• Spring Web：提供基础的Web开发支持
• Spring MVC：实现MVC模式的框架，用于构建基于HTTP请求的Web应用

Spring的扩展模块
… …

四、什么是Spring IOC？

IOC：（Inversion of Control）：是通过依赖注入（DI）实现的，IOC让对象的创建和管理由容器负责，而不是由对象自身控制。

• 核心思想：控制反转意味着将对象之间的创建和依赖关系交给Spring 容器控制，而不是由程序代码直接控制，这种机制使得程序更加灵活和解耦，提高了代码的可维护性和可扩展性。
• 依赖注入：通过构造器注入、setter注入或接口注入，将对象所需的依赖传递给他，而不是让对象自己去创建。

IoC即：控制反转，是一种思想而不是一种技术。
本质上控制的是对象的创建，IOC容器根据配置文件来创建对象，在对象的生命周期内，在不同时期根据不用的配置进行对象的创建和改造。
什么被反转了？

• 创建对象且注入对象的这个动作，本来应该是由程序员在代码中完成的，例如 对象 A 依赖 对象 B，在创建对象 A 代码中，我们需要写好如何创建 对象 B，这样才能构造出一个对象 A
• 而反转之后，这个动作就由IOC容器出发，IOC容器在创建对象 A 的时候发现依赖对象 B，根据配置文件，他会创建 B，并把对象 B 注入 A中。

五、Spring IOC有什么好处？

• 对象的创建都交给IOC容器来控制，对象之间不会有明确的依赖关系，非常容易设计出松耦合的程序
• 因为创建对象交给IOC容器控制，那么很方便让IOC基于扩展点来“加工”对象，例如我们要代理一个对象，IOC在对象创建完毕，直接判断下这个对象是否需要代理，需要则直接包装返回代理对象。

六、Spring中的DI是什么？

DI（Dependency Injection，依赖注入）普遍认为是Spring框架中用于实现 控制反转（IOC）的一种机制，DI的核心思想是由容器负责对象的依赖注入，而不是对象自行创建或查找依赖对象。
通过DI，Spring容器在创建一个对象时，会自动将这个对象依赖注入进去，可以让对象与其依赖的对象解耦，提升系统的灵活性和可维护性。

七、什么是 Spring Bean？

任何通过Spring容器实例化、组装和管理的Java对象都被称为Spring Bean。Bean可以在Spring容器中被定义并且通过依赖注入来与其他Bean进行相互依赖。
即：Bean 可以看作是Spring 容器中的一个对象，它的生命周期（创建、初始化、使用、销毁等过程）完全由Spring 容器控制。
Spring Bean 的生命周期

• 实例化：当Spring 容器启动时，根据配置文件或注解，Spring 会实例化 Bean
• 依赖注入：实例化之后，Spring 容器会通过构造器、setter方法或注解的方式将其他Bean的依赖 诸如进来
• 初始化：如果Bean 实现了 InitializingBean 接口或者使用了@PostConstruct 注解，Spring 会在依赖注入完成后调用相应的初始化方法
• 销毁：如果 Bean 实现了 DisposableBean 接口或使用了 @PreDestroy 注解，Spring 会在容器关闭时调用销毁方法
  定义 Spring Bean 的方式
• XML配置：使用标签来指定类、构造器参数和依赖关系
• 基于注解的配置：使用 @Component、@Service、@Repository、@Controller等注解可以将类标记为Spring Bean，Spring 会自动扫描这些类将其注册为Bean
• Java 配置类：通过 @Configuration 和 @Bean 注解，可以在Java类中手动定义Bean

八、Spring 中的 BeanFactory 是什么？

BeanFactory 是IOC的底层容器：负责管理和配置应用中的 Bean，他是 Spring IOC 容器的基础实现，提供了创建和管理 Bean 的基本功能

• 核心概念：BeanFactory 负责从配置源（XML、Java配置类、注解等）中读取 Bean 的定义，并负责创建、管理这些 Bean 的生命周期
• 延迟加载：BeanFactory 的一个重要特性就是 延迟初始化，即他只会在 Bean 首次请求时才会实例化该 Bean，而不是在容器启动时就立即创建所有的 Bean

BeanFactory的实现：
我们调用 getBean，这个就是 BeanFactory定义的方法，通过他得到 Bean。
不过 BeanFactory 本身是一个接口，一般我们所说的 BeanFactory 是指他的实现类：

• DefaultListableBeanFactory：BeanFactory 的默认实现，通常用于内部处理 Bean 的实例化和管理工作。
• XmlBeanFactory（已废弃）：现在推荐使用 ApplicationContext

九、Spring 中的 FactoryBean 是什么？

FactoryBean 是 Spring 提供的一个特殊接口，允许开发者通过自定义的逻辑创建复杂的 Bean 示例，与普通的 Bean 不同，通过FactoryBean 创建的 Bean 不一定是 FanctoyBean 本身，而可能是他生产的对象。
提供了一种灵活的方式来控制 Bean 的创建过程，尤其适用于生成动态代理或需要复杂配置的Bean

• 核心概念：FactoryBean 是实现了 FactoryBean接口的Bean，通过它可以自定义复杂对象的创建逻辑，Spring 容器会调用 getObject()方法来获取实际的Bean实例
• 使用场景：FactoryBean 通常需要创建复杂对象或使用代理模式生成Bean的场景

实例：
1、实现 FactoryBean 接口：定义一个类实现FactoryBean接口，并实现三个方法：

public class MyFactoryBean implements FactoryBean<MyBean> {
   @Override
   public MyBean getObject() throws Exception {
       // 复杂逻辑创建 MyBean 对象
       return new MyBean();
   }

   @Override
   public Class<?> getObjectType() {
       return MyBean.class;
   }

   @Override
   public boolean isSingleton() {
       return true;
   }
}

2、使用 FactoryBean：在Spring 容器中定义 FactoryBean，Spring 会通过 FactoryBean 创建实际的 Bean 实例：

<bean id="myBean" class="com.example.MyFactoryBean"/>

这样我们使用 getBean("myBean")会得到MyFactoryBean#getObject 的结果

十、Spring 中的 ObjectFactory 是什么？

Object Factory 是 Spring 框架中的一个接口，主要用于：延迟获取 Bean 实例
ObjectFactory 提供了一种延迟加载的机制，通过 getObject()方法返回一个 Bean 的实例。使用 ObjectFactory 可以避免在容器启动时立即创建所有 Bean，在真正需要使用 Bean 时才会从 Spring 容器中获取该 Bean 的实例。

ObjectFactory使用场景

1. 懒加载 Bean（@lazy）：当某个 Bean 创建过程时间较长或依赖资源较多时，可以通过ObjectFactory进行懒加载。
2. 避免循环依赖：在Spring 的循环依赖中的三级缓存的 Map(SingltonObjectFactories) 中存储的就是 ObjectFactory，用于延迟代理对象的创建。

十一、Spring 中的ApplicationContext是什么？

ApplicationContext 是Spring 框架的一个核心接口，是Spring IoC容器的高级形态，提供了BeanFactory 更丰富的功能。它是Spring 一应用程序的核心，不仅负责创建和管理Bean，还提供对Bean的全面管理以及对应用程序环境的支持，它是多个底层接口组合后的接口，它主要提供五大功能：

1. 核心容器（BeanFactory）
2. 国际化（MessageSource）
3. 资源获取（ResourceLoader）
4. 环境信息（EnvironmentCapable）
5. 时间发布（ApplicationEventPublisher）

核心容器
BeanFactory 是 Spring 的核心容器，是ApplicationContext 的父接口。SpringBoot默认返回ConfigurableApplicationContext 是 ApplicationContext 的子接口，它组合了一个 ConfigurableListableBeanFactory，并提供它对外提供的 BeanFactory 的功能，

十二、Spring Bean 一共有几种作用域？

一共六种作用域：

• Singleton：也是默认的单例
• prototype：原型，多实例的
• request：每个请求都会新建一个属于自己的Bean 实例，这种作用域仅存在于 Spring Web 应用中
• session：一个 http session 中有一个 bean 的实例
• application：整个 ServetContext 生命周期中，只有一个这个 bean
• websocket：一个WebSocket 生命周期内只有一个 bean 实例

十三、Spring 一共有几种Bean的注入方法？

• 构造器注入，Spring 提倡构造函数注入，因为构造器注入返回给客户端使用的时候一定是完整的

  public class MyService {  
     private final MyDependency myDependency;  
     
     @Autowired  
     public MyService(MyDependency myDependency) {  
     	  this.myDependency = myDependency;  
     }  
  } 
  

• setter 注入：可选的注入方式，在有变更的情况下，可以重新注入

   public class MyService {  
      private MyDependency myDependency;  
  
      @Autowired  
      public void setMyDependency(MyDependency myDependency) {  
          this.myDependency = myDependency;  
      }  
  }
  
  

• 字段注入：就是@Autowired 标记字段

• 方法注入：就是@Autowired 标记方法

• 接口回调注入：就是实现 Spring 定义的一些内建接口，例如： BeanFactoryAware，会进行 BeanFactory 的注入。

十四、什么是AOP？

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，用于将跨领域的关注点（如日志记录、安全检查、事务管理等）与业务逻辑分离开，它允许开发者通过“切面”（Aspect）将这些通用功能模块化，并将其应用到应用程序中的多个地方，从而避免代码重复。

• 核心思想：AOP核心思想是将 与业务逻辑无关的横切关注点抽取出来，通过声明的方式动态地应用到业务方法上，而不是将这些代码直接嵌入业务逻辑中
• 主要组成部分：AOP包括几个关键概念：切面(Aspect)、连接点(Join Point)、通知(Advice)、切入点(Pointcut)和织入(Weaving)

切面：是一个模块，包含跨领域的关注点，比如日志、事务等，它可以包含多个通知（Advice）来定义在何时何地应用特定的逻辑

@Aspect
public class LoggingAspect{
	@Before("execution(* com.example.service.*.*(..))")
	public void logBefore(){
		System.out.println("Logging before method execution");
	}
}

连接点：是程序执行中的一个特定位置，例如方法调用或异常抛出。AOP允许在这些点上插入切面逻辑。
通知：通知是定义在连接点执行的操作，常见的通知类型包括：

• 前置通知（Before）：在方法执行之前执行的操作
• 后置通知（After）：在方法中执行之后执行的操作
• 环绕通知（Around）：在方法执行前后都可以执行的操作，且可以控制方法是否执行
• 异常通知（AfterThrowing）：在方法抛出异常后执行的操作
• 返回通知（AfterReturning）：在方法成功返回后执行的操作

切入点：定义了在何处应用通知，通常是通过表达式来匹配方法或类，例如可以定义某个包下的所有方法未切入点。

@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods(){}

织入（Weaving）：织入是将切面应用到目标对象的过程。可以在编译时、类加载时或运行时进行织入

通俗理解：通过代理的方式，在调用想要的对象方法的时候，进行拦截处理，执行切入的逻辑，然后再调用真正的方法实现。

---