Spring---频率最高面试题1

01. Spring 框架的基本理解

          •关键字：核心思想IOC\AOP、作用(解耦、简化)，简单描述框架组成

·          Spring 框架是一款轻量级的开发框架，核心思想是 IOC (控制反转) 和 AOP (面向切面编程), 为Java 应用程序开发提供组件管理服，用于组件之间的解耦，以及简化第三方JavaEE中间件技术的使用( JMS 、任务调度、缓存、 ORM 框架)，是一个基础架构型的开发框架;

            Spring 框架包括： IOC 容器、 Validation 数据校验、 AOP 面向切面编程、 Transactions 事务管理、 Spring JDBC 、 Spring MVC 框架、以及各类第三方 JavaEE 中间件技术集成；

02.Spring 框架由哪些模块组成?

         关键字：官方文档描述，由 7 个模块组成

          Spring Framework 根据官方文档的描述，主要包括以下常用 5 个模块：

        1.Core：核心模块

              包括：IoC Container (loc容器)，Events (事件通知机制)，Resources (资源加载机制)，i18n (国际化)，Validation (数据校验)，Data Binding (数据绑定)，Type Conversio n (类型转换)，SpEL (Spring表达式)，AOP (面向切面编程)；

         2.Testing：测试模块

               包括： Mock Objects (测试模拟对象)，TestContext Framework (测试框架)，Spring MV C Test (用于测试 Spring MVC )，WebTestClient (用于测试 WebClient 、 Restful 、 Webflux等)；

          3.Data Access：数据访问模块

                包括： Transactions (事务管理)，DAO Support (统一的 Data Access Object DAO 模式封装)，JDBC ( Spring 对于 JDBC 的操作封装)，O/R Mapping ( Spring 对于对象关系映射框架的封装，例如 Hibernate 等框架)等；

          4. Web Servlet: 基于Servlet的Web应用开发

                 包括：Spring MVC ( Spring 基于 MVC 模式设计封装的 Web框架), WebSocket ( Sprin g 集成 WebSocket ， WebSocket 是一个服务器与客户端双向通信的技术) 等；

          5. Integration：企业级系统集成模块(不同系统之间的交互集成)

                包括：Remoting ( Spring 用于在分布式系统中进行远程服务调用的通讯框架)，JMS (Spring集成各类Java消息中间件、Java消息服务[ Java Message Service ]，例如ActiveMQ等)，Java Email (邮件发送)，Tasks Scheduling (任务调度)；

03. Spring IOC的理解

·          关键字： IOC 名词解释，作用是解耦，使用 IOC 容器管理项目组件之间的耦合关系

           IOC( Inversion of Control ，中文释义：控制反转 )是 Spring 框架的核心思想之一，主要用于解耦。 IOC 是指将创建对象的控制权转移给 Spring 框架进行管理。由 Spring 框架根据配置文件或注解等方式，创建 bean 对象并管理各个 bean 对象之间的依赖关系。使对象之间形成松散耦合的关系，实现解耦；

            控制：指的是对象创建(实例化、管理)的权力

           反转：控制权交给外部环境(Spring 框架、IoC容器)

04.Spring IOC 容器的理解

·        关键字： IOC 容器的作用、存储形式、初始化过程

·         IOC 通常被理解为 IOC Container 容器，IOC 容器其实就是一个 Map，key 是每个 bean 对 APESOURCB象的 ID， value 是 bean 对象本身。 IOC 容器负责创建 bean 对象并管理 bean的生命周期。

并且根据配置好配置文件或注解，管理 IOC 容器中的每个 bean，以及根据 bean 之间的依赖关

系，完成 bean 之间的注入。

         IOC 容器属于 Spring Core 模块，用来创建和管理 Bean，默认使用单例的方式将 bean 存储

在 DefaultListableBeanFactory 类的 beanDefinitionMap 中(一个 ConcurrentHashMap类

型的Map集合)；

          IOC 容器使用 ConcurrentHashMap 集合存储了 BeanDefinition 对象，该对象封装了 Sprin

g 对一个 Bean 所有配置信息，包括：类名，属性，构造方法参数，依赖，是否延迟加载，是否是

单例等配置信息；

05.Spring DI的理解

           ·关键字：名词解释

            DI ( Dependecy Inject ，中文释义：依赖注入) 是对 IOC 概念的不同角度的描述，是指应用程序在运行时，每一个 bean 对象都依赖 IOC 容器注入当前 bean 对象所需要的另外一个 bean 对象。(例如在 MyBatis 整合 Spring 时， SqlSessionFactoryBean 依赖 IOC 容器注入一个 D ataSource 数据源 bean )；

06.什么是Spring 的bean 

        简单来说，Bean 代表被 IoC 容器管理的对象。在Spring中，构成应用程序主干并由Spring IoC（控制反转）容器管理的对象称为Beans。Bean是一个由Spring IoC容器实例化、组装和管理的对象。

        我们通过配置文件或注解，告诉 IoC 容器帮助我们管理哪些对象。

<bean id="..." class="...">
    <constructor-arg value="..."/>
</bean>

 

 作用

* Bean是Spring应用程序的基础构建块，它们通过依赖注入相互连接，形成应用程序的骨架。
* Spring容器负责Bean的创建、配置、组装和销毁，从而简化了应用程序的复杂性和开发难度。
* 通过Bean，Spring实现了应用程序的解耦，提高了代码的可重用性和可测试性。

 

07.将一个类声明为Bean的注解有哪些?

        · @Component：定义通用Bean的注解，可标注任意类为 Bean 。如果一个 Bean 不知道属于哪个层，可以使用@Component 注解标注。

          • @Repository ：定义数据访问层Bean的注解。

           • @Service ：定义业务层Bean的注解。

          · @Controller ：定义控制器Bean的注解。

08.@Component和@Bean的区别是什么?

        · @Component 注解作用于类，而@Bean 注解作用于方法。

        · @Component 通常是通过类路径扫描来实现自动扫描并完成装配 Bean 到 Spring IOC 容器中。· @Bean 注解通常用于注解某个方法，通过 @Bean 注解告诉了 Spring IOC 容器，该方法的返回值实例是一个 Bean.

09.@Autowired和@Resource的区别是什么?

        · @Autowired 是 Spring 提供的注解，@Resource 是 JDK 提供的注解。

        · @Autowired 默认的注入方式为 byType (按类型自动注入)，@Resource 默认注入方式为 byN ame (按名称自动注入)。

10.Spring框架中的常见注入方式有几种?

        ·关键字：整体介绍三种注入方式、分别介绍每个注入方式的细节

        • Spring IOC 有三种注入方式：构造注入、Setter注入、属性注入；

                   构造注入：使用构造方法注入 bean ；

                    Setter注入：使用Setter方法注入 bean ；

                    属性注入：使用成员属性注入 bean，不推荐。原因：使用私有的成员属性变量，依靠反射实现，破坏封装，只能依靠 IOC 容器实现注入，不严谨；

11.Spring中常见的ApplicationContext实现类有哪些?·关键字：分别介绍每种实现类或子接口

          · ClassPathXmlApplicationContext ：根据项目类路径 classpath 下的配置文件加载 bean ；· FileSystemXmlApplicationContext：根据当前磁盘的一个绝对系统文件路径下的配置文件加载 bean ；

          • AnnotationConfigApplicationContext ： 根据读取到的注解加载 bean ；

· WebApplicationContext : Web 容器下按照配置文件加载 bean；

12.BeanFactory和ApplicationContext有什么区别?·关键字：两者之间的关系、区别与不同、Bean的创建加载方式

          ·两者之间的关系： BeanFactory 和 ApplicationContext 是 Spring 的两大核心接口，都可以当做 Spring 的容器；

         ·两者区别与不同：

           BeanFactory 是Spring 里面最底层的接口，是 IoC的核心，定义了 IoC的基本功能，包含

了各种 Bean的定义、加载、实例化，依赖注入和生命周期管理等行为；

           ApplicationContext 接口作为 BeanFactory 接口的子接口，包含 BeanFactory 所具备的功能外，还提供了其它框架功能：继承 MessageSource(支持国际化)，资源文件访问、可以同时加载多个配置文件、可以通过监听器管理 bean 的生命周期；

           Bean的创建加载方式：

BeanFactroy 采用的是延迟加载形式来注入 Bean，只有在使用到某个 Bean 时，才对该 Bea n 进行加载实例化。这样不能提前发现一些存在的 Spring 的配置问题。如果 Bean 的某一个属性没有注入，BeanFacotry 加载后，直至第一次使用调用 getBean()方法才会抛出异常；ApplicationContext 是在容器启动时，一次性创建了所有的 Bean 。这样，在容器启动时，我们就可以发现 Spring 中存在的配置错误，这样有利于检查所依赖属性是否注入。 Applicat ionContext 启动后预载入所有的单实例 Bean，所以在运行的时候速度比较快，因为它们已经创建好了。相对于 BeanFactory ，ApplicationContext 唯一的不足是占用内存空间，当应用程序配置 Bean 较多时，程序启动较慢；

13.Spring框架的启动流程

          主要是指Spring容器从开始加载配置文件到创建并初始化所有Bean的过程。以下是Spring框架的基本启动流程：

         1. 初始化Spring容器：

             容器的启动从创建`ApplicationContext`实例开始。`ApplicationContext`是Spring中高级的IoC容器。

             通常使用`ClassPathXmlApplicationContext`或`AnnotationConfigApplicationContext`来加载配置。

         2. 加载配置文件：

             当`ApplicationContext`被创建时，Spring将加载配置信息。这些配置信息可以是XML文件、Java注解或Java配置类。

         3. Bean定义：

             Spring容器读取配置信息，并将这些信息转换为内部结构，如BeanDefinition对象。

             BeanDefinition包含了Bean的类名、属性、构造器参数以及其他元数据。

        4. Bean的注册：

            容器将这些BeanDefinition注册到BeanFactory中。

       5. Bean的创建：

            容器负责创建Bean实例。这一过程是通过反射或CGLIB动态代理来完成的。

            默认情况下，Spring在容器启动时会创建并配置所有单例模式的Bean。

       6. 依赖注入：

            一旦Bean实例化，Spring就会根据BeanDefinition中的信息进行依赖注入。

            这包括设置属性值和解决Bean之间的依赖关系。

       7. Bean的初始化：

           如果Bean实现了`InitializingBean`接口，Spring将调用`afterPropertiesSet()`方法。

           如果Bean有指定`init-method`，Spring也会调用相应的方法。

       8. 使用Bean：

            此时，Bean已经准备好，可以被应用程序使用。

      9. 关闭容器：

          当应用结束时，可以关闭ApplicationContext。

          在关闭的过程中，如果Bean实现了`DisposableBean`接口，Spring将调用`destroy()`方法。

          如果Bean有指定`destroy-method`，Spring也会调用相应的方法。

下面是Spring启动流程中涉及的一些关键类和接口：

           `ApplicationContext`: Spring容器的接口，负责初始化、配置和创建Bean。

           `BeanFactory`: Spring核心的IoC容器，负责管理Bean的实例化、配置和依赖注入。

           `BeanDefinition`: 封装了Bean的定义信息。

           `BeanPostProcessor`: 允许自定义修改新实例化Bean的扩展点。

            `InitializingBean`: 接口，定义了Bean初始化的方法。

            `DisposableBean`: 接口，定义了Bean销毁前的方法。

        Spring框架的启动流程可以根据具体的应用场景和配置有所不同，例如使用Spring Boot时，许多配置和启动步骤都是自动化的。

14.Spring 框架中的Bean的作用域 

        singleton:Spring 只会为该 bean 对象只会创建唯一实例， Spring 中的 bean 默认都是单例

       ·prototype：每次获取 bean ，Spring 会创建一个新的 bean 实例；

      ·request：每一次 HTTP 请求，Spring 会创建一个新的 bean 实例；

·      session：不同的HTTP 会话，Spring 会创建不同的 bean 实例；

通过XML方式设置bean的作用域 

<bean id="demoDaoBean" class="com.apesource.dao.DemoDAOImpl" scope="singleton"/>

通过注解方式设置bean的作用域          

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

public class DemoDAOImpl implements IDemoDAO{ }

15.Spring 框架中的Bean的线程安全

       ·对于 prototype 作用域的 Bean ，每次都创建一个新对象，也就是线程之间不存在Bean共享，因此不会有线程安全问题

·      对于 singleton 作用域的 Bean，所有的线程都共享一个单例状态的 Bean，存在资源竞争，因此是存在线程安全问题的

     解决办法：

         对于 singleton 作用域的单例 bean，它的线程安全问题，常见有两种解决办法：

                在 bean 中尽量避免定义可变的成员变量(用于保存数据的成员变量)；

                在类中定义一个 ThreadLocal 成员变量，将需要可变的成员变量保存在 ThreadLocal中；

16.Spring 框架中的Bean生命周期

          Spring Bean 的生命周期总体分四个阶段：实例化=> 属性注入 => 初始化 => 销毁·

        Step1 实例化 Bean：根据配置文件中 Bean 的定义，利用 Java Reflection 反射技术创建 Bean 的实例

         Step2 注入对象依赖的属性值(或对象)

         Step3 处理各种Aware接口： Spring 会检测该 Bean 是否实现了 xxxAware 接口，通过 Aware 类型的接口，可以让Spring框架为当前 Bean注入相应的内容。

                    如果 Bean 实现 BeanNameAware 接口，会调用它实现的 setBeanName(String beanId)方法，注入 Bean 的名字；

                    如果 Bean 实现 BeanClassLoaderAware 接口，调用 setBeanClassLoader()方法，注入ClassLoader 对象的实例； 

                     如果 Bean 实现 BeanFactoryAware 接口，会调用它实现的 setBeanFactory()方法，注入的是 Spring 工厂；

                     如果 Bean 实现 ApplicationContextAware 接口，会调用 setApplicationContext()方法，注入 Spring 上下文；

        Step4 执行BeanPostProcessor前置处理：如果想对 Bean 进行一些自定义的前置处理，那么可以让 Bean 实现了 BeanPostProcessor 接口，将会在该阶段调用 postProcessBeforeInitializat ion(Object obj, String s)方法。

         Step5 执行InitializingBean初始化方法：如果 Bean 实现了 InitializingBean 接口，执行 afeterPropertiesSet()方法。

·        Step6 执行init-method自定义初始化方法： 如果 Bean 在 Spring 配置文件中配置了 init-met hod 属性，则会自动调用其配置的初始化方法。

           Step7 执行BeanPostProcessor后置处理： 如果这个 Bean 实现了BeanPostProcessor接口，将会调用 postProcessAfterInitialization(Object obj, String s)方法，由于这个方法是在 Bea n 初始化结束后调用；

                  以上几个步骤完成后， Bean 已经被正确创建，可以正常使用这个 Bean 了。

         Step8 执行DisposableBean销毁Bean：当 Bean 不再需要时，会经过清理阶段，如果 Bean 实现了DisposableBean 这个接口，会调用其实现的 destroy()方法执行销毁；

         Step9 执行destroy-method自定义销毁方法： 如果这个 Bean 的 Spring 配置中配置了 destroy -method 属性，会自动调用其配置的自定义销毁方法。