0
0

Spring面试必备：Spring IOC和AOP的理解、如何解决Spring循环依赖

bff8a010ef164ad880984d2fa7709675.png

一、spring基础知识

1. Spring IOC和AOP

1.1 Spring IOC

Spring IOC其实是一种通过描述来创建和获取对象的技术，相比于最原始的通过new来创建对象，所有的对象都交由Spring IOC进行管理，我们管这些对象称为Spring Bean。

Spring Bean可以看成是班级里的学生，那IOC容器就是容纳学生的班级。每个Bean的分类、不同的生命周期，包括Prototype、Singleton、Request、Session、Global session都可以在IOC容器里进行管理。这其实是一种控制反转的思想，我们程序员把控制对象的权限都交由了靠谱的Spring IOC容器。

通过XML方式我们可以向Spring IOC描述我需要一个A对象。当Spring启动时这个Bean也就自动注入到IOC容器等待我们的使用。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">

  <bean id="bean1" class="org.springframework.beans.factory.ConcurrentBeanFactoryBenchmark$ConcurrentBean"
            scope="prototype">
    <property name="date" value="2004/08/08"/>
  </bean>

</beans>

现在商业公司通过以上XML的方式已经是很少见了，Spring Boot提供了另一种通过注解来描述Bean的方式。Spring Boot底层基于注解的IOC容器是

AnnotationConfigApplicationContext

，这个留到我后续的文章再来讲解。

// 通过注解的方式来创建Bean
@Configuration
public class TokenConfig {
    /**
     * 设置token的类型
     **/
    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(jwtAccessTokenConverter()); // 设置token类型为JWT
    }
}

1.2 Spring AOP

在整个软件编程的历史长河中，最先面世的一种编程范式叫做面向过程编程。但随着软件系统越来越复杂，面向过程编程越来越难以管理软件的复杂性。于是面向对象编程OOP诞生，它致力于解决困扰前者的软件复杂性问题。

但面向对象编程并不是银弹，它存在一些弊端，例如我们需要为整个项目的所有对象都引入一个公共行为：打印对象每个方法的执行耗时。如果采用OOP需要把公共行为的代码都重复贴到每个对象的类里。。。

现在救世主来了，AOP面向切面编程弥补了OOP的缺陷。

通过Spring AOP，我们可以为每个对象约定一套流程，为对象方法执行前执行后织入一些行为。如果是日志的话，在对象方法执行后触发就可以了。

Spring AOP提供了多个注解，我们来看看。

  1. @Before。前置通知，在方法执行之前执行。
  2. @After。后置通知，在方法执行之后执行。
  3. @AfterReturning。返回通知，方法不抛出异常，正常退出方法时执行。
  4. @AfterThrowing。异常通知，方法抛出异常后执行 。
  5. @Around。环绕通知，围绕着方法执行，可以自定义在方向执行前、执行后执行一段逻辑，自由度更高。
  6. @Pointcut。切点。定义了要拦截的对象。
// 防重复提交的切面
@Aspect
@Component
public class SubmitAspect {
    
    @Pointcut("@annotation(banRepeatSubmit)")
    public void pointCut(BanRepeatSubmit banRepeatSubmit) {}

    @Around("pointCut(banRepeatSubmit)")
    public Object around(ProceedingJoinPoint proceedingJoinPoint, BanRepeatSubmit banRepeatSubmit) throws Throwable {
        // 防止对象方法重复执行
    }
}

1.3 AOP的原理

在使用上文的六种注解时，这些注解是封装在一个由

@AspectJ

注解修饰的类，我们管这个类叫做切面。

Spring AOP扫描到@Pointcut定义的切点时，就会自动为该Bean创建一个代理。而Spring Boot目前底层的代理模式有两种：JDK动态代理、CGLIB动态代理。

如果被代理的对象实现了接口，则Spring会默认使用JDK动态代理；如果被代理对象没有实现接口，则Spring会改为使用CGLIB动态代理。原因是JDK动态代理要求被代理对象必须实现至少一个接口。

JDK动态代理通过生成代理对象的字节码文件，使要拦截的方法跳转到invoke()方法，而在invoke()里就是在切面里定义的各种拦截逻辑。

而CGLIB是通过生成代理类的子类实现，同时修改字节码文件让子类方法覆盖代理类的方法，从而实现对拦截方法的代理。

另外Spring AOP还集成了AspectJ，相比与以上的动态织入方式，AspectJ采用编译织入的方式来代理对象。

1.4 JDK和CGCLIB动态代理

JDK和CGCLIB动态代理哪个更快？这两者的生命周期可以分为创建对象阶段、实际运行阶段，我们要根据具体情况具体分析。

  1. 在实际运行阶段，CGLIB性能比JDK运行性能更高。
  2. 在创建对象阶段，基于两者的原理，CGLIB花费在创建对象的时间要比JDK多。JDK只需创建代理类的字节码，而CGLIB既要修改源代码的字节码文件，又要生成代理类的子类的字节码文件。

综上所述，对于需要创建大量对象的场景，JD动态代理K比CGLIB动态代理效率更高，反之CGLIB效率更高。

2. Spring循环依赖

2.1. 解决Spring循环依赖

谈到循环依赖，大多数人都是望而生畏。一旦发生了循环依赖，说明了这部分软件设计的职责划分出现了问题，而且要修复起来不是一件容易的事。如果是屎山代码，那可就头大了。。。

如下例子，对象A的成员变量引用了对象B，而对象B的成员变量引用了对象A。也就是说，对象A的初始化完成要先完成对象B的初始化，但对象B的初始化完成又要先完成对象A的初始化，形成了一个永远无法实现的环。

    class A {
        B b = new B();
    }
    class B {
        A a = new A();
    }

Spring设计出了三个级别的缓存。一级缓存存放实例化、初始化的bean、二级缓存存放已实例化但没有初始化的bean、三级缓存存放创建bean的工厂对象。

例如现在有对象A依赖对象B，对象B依赖对象A。

Spring首先从三级缓存获得实例化的A、B；接着让A进入二级缓存，同时将未初始化的B注入A，这就得到了实例化、初始化的A，此时A就会进入一级缓存；最后一步，只需要再把初始化的A注入到B，此时循环依赖解决。

二、spring常见面试题

1. 什么是 Spring IOC（控制反转）？

回答: IOC（Inversion of Control）是 Spring 框架的核心概念，指的是将对象的创建和管理交给 Spring 容器，而不是在应用程序中显式地进行控制。通过 IOC，依赖对象可以通过依赖注入（Dependency Injection, DI）进行传递，简化了对象的创建过程，降低了耦合度。

2. Spring IOC 是如何实现依赖注入的？

回答: Spring IOC 实现依赖注入有三种主要方式：构造器注入、Setter 方法注入和接口注入。最常用的是构造器注入和 Setter 方法注入。Spring 容器通过配置文件（XML 或 Java 配置）或注解（如 

@Autowired

）来管理对象的依赖关系。

3. 什么是 Spring AOP（面向切面编程）？

回答: AOP 是 Spring 提供的用于横切关注点（如日志记录、事务管理、安全性）的编程方式。AOP 允许开发者在不修改核心业务逻辑的情况下，将这些关注点分离出来。AOP 的关键概念包括切面（Aspect）、连接点（Joinpoint）、通知（Advice）和切入点（Pointcut）。

4. Spring 中的 Bean 是什么？如何定义一个 Bean？

回答: 在 Spring 中，Bean 是由 Spring 容器管理的对象，通常是一个单例对象。可以通过 XML 配置文件、Java 配置类或使用注解（如 

@Component

、

@Bean

）来定义一个 Bean。Spring 容器根据这些定义来实例化、配置和管理 Bean 的生命周期。

5. 如何在 Spring 中处理循环依赖问题？

回答: Spring 通过三级缓存（singletonFactories、earlySingletonObjects、singletonObjects）来解决循环依赖问题。当 A、B 两个 Bean 相互依赖时，Spring 会提前暴露一个 Bean 的代理对象，使另一个 Bean 可以引用到它，从而打破循环依赖。

6. 什么是 Spring 中的自动装配？

回答: 自动装配是指 Spring 容器自动满足 Bean 的依赖关系，而不需要手动配置。常用的自动装配方式包括 

@Autowired

注解，它可以自动匹配类型兼容的 Bean 来注入依赖。自动装配可以基于构造器、字段或 Setter 方法。

7. Spring 的 Bean 生命周期是怎样的？

回答: Spring Bean 的生命周期包括：实例化（Instantiation）、属性注入（Populate Properties）、初始化（Initialization）和销毁（Destruction）。Bean 的生命周期可以通过实现 

InitializingBean

接口、配置 

init-method

和 

destroy-method

来进行自定义。

8. 什么是代理对象？Spring AOP 是如何使用代理对象的？

回答: 代理对象是 AOP 的关键技术之一，用于在运行时拦截方法调用。Spring AOP 使用 JDK 动态代理或 CGLIB 来创建代理对象。如果目标类实现了接口，Spring 默认使用 JDK 动态代理；否则使用 CGLIB。代理对象负责在调用目标方法前后执行横切逻辑。

9. 如何在 Spring 中配置 AOP 切面？

回答: 可以通过 XML 配置文件、注解（如 

@Aspect

、

@Before

、

@After

）或 Java 配置类来配置 AOP 切面。切面定义了切入点（Pointcut）和通知（Advice），其中切入点用于指定在哪些方法或类上应用通知。

10. **Spring 中的

@Component

和 

@Bean

有什么区别？**

回答: 

@Component

是一个通用的注解，用于标记一个类为 Spring Bean，通常与 

@Autowired

配合使用。

@Bean

则用于方法级别，通常在配置类中使用，用来显式声明一个 Spring Bean。

@Component

通过组件扫描自动检测，

@Bean

则是通过显式配置。

11. 什么是依赖注入的优点？

回答: 依赖注入的主要优点包括：降低了代码的耦合性、提高了代码的可测试性、增加了灵活性和可维护性。通过依赖注入，类不再负责自身的依赖管理，使得业务逻辑更简洁清晰。

12. **什么是

ApplicationContext

和 

BeanFactory

？它们的区别是什么？**

回答: 

ApplicationContext

和 

BeanFactory

都是 Spring 容器的核心接口，负责管理 Bean 的生命周期。

BeanFactory

是 Spring 的基本容器，提供了延迟加载（Lazy Loading）支持；而 

ApplicationContext

是 

BeanFactory

的子接口，提供了更丰富的功能，如事件发布、国际化支持和自动 Bean 发现。

13. **Spring 中的

@Qualifier

注解的作用是什么？**

回答: 

@Qualifier

注解用于在存在多个同类型的 Bean 时，指定需要注入的具体 Bean。它常与 

@Autowired

一起使用，以避免自动装配时的歧义问题。

14. 如何在 Spring 中使用 AOP 实现事务管理？

回答: 可以使用 

@Transactional

注解和 Spring AOP 来实现事务管理。当方法被 

@Transactional

标记时，Spring 会在方法执行前后自动开启和提交事务，如果方法执行过程中抛出异常，则会回滚事务。Spring AOP 通过代理机制来拦截方法调用，管理事务的开启、提交和回滚。

15. 如何理解 Spring 中的循环依赖问题？它的常见场景是什么？

回答: 循环依赖是指两个或多个 Bean 互相依赖，导致在实例化时形成死循环。常见的场景包括构造器注入或属性注入中的相互依赖。Spring 通过三级缓存来解决属性注入中的循环依赖，但无法解决构造器注入的循环依赖。

16. Spring 的 AOP 和 AspectJ 有什么区别？

回答: Spring AOP 通过代理机制实现面向切面编程，主要支持方法级别的切面，运行时生成代理对象。AspectJ 是一套功能更强大的 AOP 框架，支持编译时和类加载时的切面，能够处理字段和构造函数的切面。Spring AOP 是 Spring 框架的一部分，而 AspectJ 是独立的 AOP 框架。

17. 如何在 Spring 中自定义注解实现 AOP？

回答: 可以通过定义一个自定义注解，并在 AOP 切面中使用 

@Around

或其他通知类型来拦截带有该注解的方法。例如：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
}

@Aspect
public class MyAspect {
    @Around("@annotation(MyAnnotation)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 切面逻辑
        return joinPoint.proceed();
    }
}

18. **Spring 中的

@Autowired

注解如何处理多个候选 Bean？**

回答: 当 

@Autowired

注解遇到多个候选 Bean 时，可以通过 

@Qualifier

注解指定注入的 Bean。如果没有指定，Spring 会尝试按照 Bean 的名称进行匹配，或者通过 

@Primary

标注一个默认的 Bean。

19. **什么是 Spring 中的

@Primary

注解？**

回答: 

@Primary

注解用于标记一个 Bean 为默认的候选对象，当自动装配时遇到多个同类型的 Bean，且未使用 

@Qualifier

指定具体 Bean 时，Spring 会优先选择带有 

@Primary

注解的 Bean 进行注入。

20. **Spring 中的

@PostConstruct

和 

@PreDestroy

注解的作用是什么？**

回答: 

@PostConstruct

和 

@PreDestroy

注解分别用于指定 Bean 在初始化后和销毁前需要执行的操作。

@PostConstruct

标注的方法会在依赖注入完成后调用，

@PreDestroy

标注的方法会在 Bean 销毁前调用。它们是管理 Bean 生命周期的一部分。

让我们一起学习，一起进步！期待在评论区与你们见面。

祝学习愉快！

1026e0f119ef42e78e05858060a7e8d2.png

标签： spring 面试 java
本文转载自: https://blog.csdn.net/weixin_68811816/article/details/141755546
版权归原作者 程序员-杨胡广 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Spring面试必备：Spring IOC和AOP的理解、如何解决Spring循环依赖”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

java+vue计算机毕设茶叶产品质量安全可追溯系统【源码+程序+论文+开题】

Postman：Postman API测试：Postman数据驱动测试实践

解决：IntelliJ IDEA 项目中代码文件不能运行的问题(即：J 标文件的问题)

Docker：安装 MongoDB 的详细指南

Git - 两种方式撤销已提交到远端仓库的记录并删除提交记录

Kafka 原理

Flink Memory Management原理与代码实例讲解

文章导航