面试官问我精通Spring吗？我......

【What is Spring】

Spring 是为了提高开发人员的开发效率以及系统的可维护性的轻量级框架

Spring 框架指的都是 Spring Framework，它是很多模块的集合，多模块协调保障我们的日常开发

---

核心容器

核心容器由 spring-core，spring-beans，spring-context，spring-context-support和spring-expression（SpEL，Spring 表达式语言，Spring Expression Language）等模块组成，它们的细节如下：

• spring-core 模块提供了框架的基本组成部分，包括 IoC 和依赖注入功能。

• spring-beans 模块提供 BeanFactory，工厂模式的微妙实现，它移除了编码式单例的需要，并且可以把配置和依赖从实际编码逻辑中解耦。

• context 模块建立在由 core和 beans 模块的基础上建立起来的，它以一种类似于 JNDI 注册的方式访问对象。Context 模块继承自 Bean 模块，并且添加了国际化（比如，使用资源束）、事件传播、资源加载和透明地创建上下文（比如，通过 Servelet 容器）等功能。Context 模块也支持 Java EE 的功能，比如 EJB、JMX 和远程调用等。ApplicationContext 接口是 Context 模块的焦点。spring-context-support 提供了对第三方集成到 Spring 上下文的支持，比如缓存（EhCache, Guava, JCache）、邮件（JavaMail）、调度（CommonJ, Quartz）、模板引擎（FreeMarker, JasperReports, Velocity）等。

• spring-expression 模块提供了强大的表达式语言，用于在运行时查询和操作对象图。它是 JSP2.1 规范中定义的统一表达式语言的扩展，支持 set 和 get 属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从 Spring IoC 容器检索对象，还支持列表的投影、选择以及聚合等。

---

BeanFactory和ApplicationContext的关系

• BeanFactory 简单粗暴，可以理解为就是个 HashMap，Key 是 BeanName，Value 是 Bean 实例。（低级容器）

• ApplicationContext 可以称之为 “高级容器”。因为他比 BeanFactory 多了更多的功能如： 

         ①MessageSource, 提供国际化的消息访问  
         ②资源访问，如URL和文件  
         ③事件传播特性，即支持aop特性
         ④载入多个有继承关系的上下文 ，使得每一个上下文都专注于一个特定的层次比如应用的web层 

二者区别

一、BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化，这样，我们就不能发现一些存在的Spring的配置问题。而ApplicationContext则相反，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误。 相对于基本的BeanFactory，ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。BeanFacotry延迟加载,如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常；而ApplicationContext则在初始化自身是检验，这样有利于检查所依赖属性是否注入；所以通常情况下我们选择使用 ApplicationContext。应用上下文则会在上下文启动后预载入所有的单实例Bean。通过预载入单实例bean ,确保当你需要的时候，你就不用等待，因为它们已经创建好了。

二、BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。（Applicationcontext比 beanFactory 加入了一些更好使用的功能。而且 beanFactory 的许多功能需要通过编程实现而 Applicationcontext 可以通过配置实现。比如后处理 bean ， Applicationcontext 直接配置在配置文件即可而 beanFactory 这要在代码中显示的写出来才可以被容器识别）

三、beanFactory主要是面对与 spring 框架的基础设施，面对 spring 自己。而 Applicationcontex 主要面对与 spring 使用的开发者。基本都会使用 Applicationcontex 并非 beanFactory 

---

Spring的其他模块还有 AOP、Aspects、Instrumentation 以及 Test 模块，具体介绍如下：

• AOP 模块：提供了面向切面编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性。
• Aspects 模块：提供与 AspectJ 的集成，是一个功能强大且成熟的面向切面编程（AOP）框架。
• Instrumentation 模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
• Test 模块：支持 Spring 组件，使用 JUnit 或 TestNG 框架的测试

Spring 官网列出的 Spring 的 6 个特征:

• 核心技术 ：依赖注入(DI)，AOP，事件(events)，资源，i18n，验证，数据绑定，类型转换，SpEL。
• 测试 ：模拟对象，TestContext框架，Spring MVC 测试，WebTestClient。
• 数据访问 ：事务，DAO支持，JDBC，ORM，编组XML。
• Web支持 : Spring MVC和Spring WebFlux Web框架。
• 集成 ：远程处理，JMS，JCA，JMX，电子邮件，任务，调度，缓存。
• 语言 ：Kotlin，Groovy，动态语言。

【IOC是偏向于纯概念的内容，2022年了 如果还有公司问这个，只能说比较low~,建议避坑】

---

什么是Spring控制反转（IOC）

• 控制反转即IOC (Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。

• Spring IOC 负责创建对象，管理对象（通过依赖注入（DI），装配对象，配置对象，并且管理这些对象的整个生命周期。

控制反转(IOC)有什么作用

• 管理对象的创建和依赖关系的维护。对象的创建并不是一件简单的事，在对象关系比较复杂时，如果依赖关系需要程序猿来维护的话，那是相当头疼的

• 解耦，由容器去维护具体的对象

• 托管了类的产生过程，比如我们需要在类的产生过程中做一些处理，最直接的例子就是代理，如果有容器程序可以把这部分处理交给容器，应用程序则无需去关心类是如何完成代理的

                               Spring 中的 IOC 的实现原理就是工厂模式加反射机制                                      

依赖注入(DI)

组件之间的依赖关系由容器在应用系统运行期来决定，也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。组件不做定位查询，只提供普通的Java方法让容器去决定依赖关系。

依赖注入的基本原则

• 依赖注入的基本原则是：应用组件不应该负责查找资源或者其他依赖的协作对象。配置对象的工作应该由IOC容器负责，“查找资源”的逻辑应该从应用组件的代码中抽取出来，交给IOC容器负责。容器全权负责组件的装配，它会把符合依赖关系的对象通过属性（JavaBean中的setter）或者是构造器传递给需要的对象。

依赖注入有什么优势

• 依赖注入之所以更流行是因为它是一种更可取的方式：让容器全权负责依赖查询，受管组件只需要暴露JavaBean的setter方法或者带参数的构造器或者接口，使容器可以在初始化时组装对象的依赖关系。其与依赖查找方式相比，主要优势为：
  • 查找定位操作与应用代码完全无关。
  • 不依赖于容器的API，可以很容易地在任何容器以外使用应用对象。
  • 不需要特殊的接口，绝大多数对象可以做到完全不必依赖容器。

依赖注入实现方式：

• 构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。

• Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。

 

---

Spring Beans

• Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中 的形式定义。

 Spring Bean 定义 ？

• 一个Spring Bean 的定义包含容器必知的所有配置元数据，包括如何创建一个bean，它的生命周期详情及它的依赖。

Spring基于xml注入bean的几种方式

1. Set方法注入
2. 构造器注入
3. 静态工厂注入
4. 实例工厂

Spring框架支持以下五种bean的作用域：

• singleton : bean在每个Spring ioc 容器中只有一个实例。
• prototype：一个bean的定义可以有多个实例。
• request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。
• session：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
• global-session：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。

---

什么是面向切面（AOP）？

• AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构
• AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范
• 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术
• AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型
• 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

Spring框架的AOP的底层实现

1.基于JDK的动态代理

2.基于CGLIB动态代理 

如果实现类接口，使用JDK动态代理完成AOP

如果没有实现接口，采用CGLIB动态代理完成AOP

JDK动态代理和CGLIB动态代理的区别

• Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理：

  • JDK动态代理只提供接口的代理，不支持类的代理。核心InvocationHandler接口和Proxy类，InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；接着，Proxy利用 InvocationHandler动态创建一个符合某一接口的的实例, 生成目标类的代理对象。

  • 如果代理类没有实现 InvocationHandler 接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现AOP。CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。

• 静态代理与动态代理区别在于生成AOP代理对象的时机不同，相对来说AspectJ的静态代理方式具有更好的性能，但是AspectJ需要特定的编译器进行处理，而Spring AOP则无需特定的编译器处理。

Spring AOP名词解释：

• （1）切面（Aspect）：切面是通知和切点的结合。通知和切点共同定义了切面的全部内容。 在Spring AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以 @AspectJ 注解来实现。

• （2）连接点（Join point）：指方法，在Spring AOP中，一个连接点 总是 代表一个方法的执行。 应用可能有数以千计的时机应用通知。这些时机被称为连接点。连接点是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。

• （3）通知（Advice）：在AOP术语中，切面的工作被称为通知。

• （4）切入点（Pointcut）：切点的定义会匹配通知所要织入的一个或多个连接点。我们通常使用明确的类和方法名称，或是利用正则表达式定义所匹配的类和方法名称来指定这些切点。

• （5）引入（Introduction）：引入允许我们向现有类添加新方法或属性。

• （6）目标对象（Target Object）： 被一个或者多个切面（aspect）所通知（advise）的对象。它通常是一个代理对象。也有人把它叫做 被通知（adviced） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied） 对象。

• （7）织入（Weaving）：织入是把切面应用到目标对象并创建新的代理对象的过程。在目标对象的生命周期里有多少个点可以进行织入：

  • 编译期：切面在目标类编译时被织入。AspectJ的织入编译器是以这种方式织入切面的。
  • 类加载期：切面在目标类加载到JVM时被织入。需要特殊的类加载器，它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5的加载时织入就支持以这种方式织入切面。
  • 运行期：切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。SpringAOP就是以这种方式织入切面。

---

Spring如何处理线程并发问题？

• 在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域，因为Spring对一些Bean中非线程安全状态采用ThreadLocal进行处理，解决线程安全问题。

• ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。同步机制采用了“时间换空间”的方式，仅提供一份变量，不同的线程在访问前需要获取锁，没获得锁的线程则需要排队。而ThreadLocal采用了“空间换时间”的方式。

• ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

---

Spring Bean的生命周期

①根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。
②利用依赖注入完成 Bean 中所有属性值的配置注入。
③如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。
④如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。
⑤如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。
⑥如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP 就是利用它实现的。
⑦如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。
⑧如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。
⑨如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了。
⑩如果在 <bean> 中指定了该 Bean 的作用范围为 scope="singleton"，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在 <bean> 中指定了该 Bean 的作用范围为 scope="prototype"，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean。
最后如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。 

---

 【简单聊一聊Spring的后代 SpringBoot】

SpringBootApplication 相关注解：

• @Target(ElementType.TYPE)：注解的适用范围，其中TYPE用于描述类、接口（包括包注解类型）或enum声明

• @Retention(RetentionPolicy.RUNTIME)：注解的生命周期，保留到class文件中（三个生命周期）

• @Documented ：表明这个注解应该被javadoc记录

• @Inherited ：子类可以继承该注解

• @SpringBootConfiguration ：继承了Configuration，表示当前是注解类

• @EnableAutoConfiguration ：开启springboot的注解功能，springboot的四大神器之一，其借助@import的帮助

• @ComponentScan用于类或接口上主要是指定扫描路径，spring会把指定路径下带有指定注解的类自动装配到bean容器里。会被自动装配的注解包括@Controller、@Service、@Component、@Repository等等

SpringBoot启动过程

 

 从上图能看出主要两个步骤：

①构造一个SpringApplication应用

 public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        //资源加载器默认为null
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        //primarySources这里指的是执行main方法的主类
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        //根据classpath推断出应用类型,主要有NONE,SERVLET,REACTIVE三种类型
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        //通过SpringFactoriesLoader工具类获取META-INF/spring.factories中配置的一系列
        //ApplicationContextInitializer接口的子实现类
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));
        //基本同上，也是通过SpringFactoriesLoader工具类获取配置的ApplicationListener
        //接口的子实现类
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        //通过方法调用堆栈获取到main执行方法的主类
        this.mainApplicationClass = deduceMainApplicationClass();
    }

②调用run方法，启动应用

 /**创建并刷新应用上下文**/
    public ConfigurableApplicationContext run(String... args) {
        //spring-core包下的计时器类，在这里主要用来记录应用启动的耗时
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        
        //系统配置设置为headless模式
        configureHeadlessProperty();
        //通过SpringFactoriesLoader工具类获取META-INF/spring.factories
        //文件中SpringApplicationRunListeners接口的实现类，在这里是
        //EventPublishingRunListener
        SpringApplicationRunListeners listeners = getRunListeners(args);
        
        //广播ApplicationStartingEvent事件使应用中的ApplicationListener
        //响应该事件
        listeners.starting();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
            //准备应用环境，这里会发布ApplicationEnvironmentPreparedEvent事件
            //并将environment绑定到SpringApplication中
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            
            configureIgnoreBeanInfo(environment);
            //打印彩蛋
            Banner printedBanner = printBanner(environment);
            //根据成员变量webApplicationType创建应用上下文
            context = createApplicationContext();
            exceptionReporters = getSpringFactoriesInstances(
                    SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);
            //准备上下文，见文章顶部流程图
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
            //刷新上下文，见文章顶部流程图
            refreshContext(context);
            //上下文后处理，空实现
            afterRefresh(context, applicationArguments);
            //计时停止
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
            //广播ApplicationStartedEvent事件使应用中的ApplicationListener
            //响应该事件
            listeners.started(context);
            
            //应用上下文中的ApplicationRunner,CommandLineRunner执行run方法
            callRunners(context, applicationArguments);
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, exceptionReporters, listeners);
            throw new IllegalStateException(ex);
        }

        try {
            //广播ApplicationReadyEvent事件使应用中的ApplicationListener
            //响应该事件     
            listeners.running(context);
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, exceptionReporters, null);
            throw new IllegalStateException(ex);
        }
        //返回应用上下文
        return context;
    }

• 在启动过程中，SpringApplicationListener在不同阶段通过调用自身的不同方法(如starting()、environmentPrepared())发布相应事件，通知ApplicationListener进行响应。

• refreshContext(context)方法是构建IOC容器最复杂的一步，绝大多数bean的定义加载以及实例化都在这一步执行。包括但不限于BeanFactoryPostProcessor、BeanPostProcessor、ApplicationEventMulticaster、@Controller,@Component等注解的组件。

• SpringFactoriesLoader工具类，在SpringApplication的构造过程中、运行过程中都起到了极其重要的作用。SpringBoot的自动化配置功能一个核心依赖点就在该类上，该类通过读取类路径下的META-INF/spring.factories文件获取各种各样的工厂接口的实现类，通过反射获取这些类的类对象、构造方法，最终生成实例。