spring面试题【持续更新ing】-CSDN博客

本文链接：https://blog.csdn.net/qq_45817631/article/details/149126210

spring面试题

一、什么是循环依赖（高频）？
二、Spring 如何解决循环依赖？
三、Spring都有哪些重要的模块？
四、什么是Spring IOC？
五、Spring IOC有什么好处？
六、Spring中的DI是什么？
七、什么是 Spring Bean？
八、Spring 中的 BeanFactory 是什么？
九、Spring 中的 FactoryBean 是什么？
十、Spring 中的 ObjectFactory 是什么？
十一、Spring 中的ApplicationContext是什么？
十二、Spring Bean 一共有几种作用域？
十三、Spring 一共有几种Bean的注入方法？
十四、什么是AOP？

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

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

@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配置：使用<bean>标签来指定类、构造器参数和依赖关系
基于注解的配置：使用 @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<T>接口的Bean，通过它可以自定义复杂对象的创建逻辑，Spring 容器会调用 getObject()方法来获取实际的Bean实例
使用场景：FactoryBean 通常需要创建复杂对象或使用代理模式生成Bean的场景

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

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使用场景

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

十一、Spring 中的ApplicationContext是什么？

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

核心容器（BeanFactory）
国际化（MessageSource）
资源获取（ResourceLoader）
环境信息（EnvironmentCapable）
时间发布（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）：织入是将切面应用到目标对象的过程。可以在编译时、类加载时或运行时进行织入

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