当前位置：首页社区如何理解 Spring 的核心？

如何理解 Spring 的核心？

面试官：我看到你的简历写着熟悉Spring

面试官：要不你来讲讲Spring 的IOC和AOP你是怎么理解的呗？

候选者：嗯嗯，IOC和AOP是Spring非常核心的知识点

候选者：我就先来讲讲Spring IOC？

面试官：嗯

候选者：我个人理解下：Spring IOC 解决的是对象管理和对象依赖的问题。

候选者：本来是我们自己手动new出来的对象，现在则把对象交给Spring的IOC容器管理

候选者：IOC容器可以理解为一个对象工厂，我们都把该对象交给工厂，工厂管理这些对象的创建以及依赖关系

候选者：等我们需要用对象的时候，从工厂里边获取就好了

面试官：嗯，说起IOC，就可以在网上或书籍经常看到的两个概念

候选者：哦，你说的就是「控制反转」和「注入依赖」吧？

面试官：你怎么还抢答的咯…那你顺便说说你对这两个概念的理解呗？

候选者：我认为「控制反转」指的就是：把原有自己掌控的事交给别人去处理

候选者：它更多的是一种思想或者可以理解为设计模式

候选者：比如：本来由我们自己new出来的对象，现在交由IOC容器，把对象的控制权交给它方了

候选者：而「依赖注入」在我的理解下，它其实是「控制反转」的实现方式

候选者：对象无需自行创建或者管理它的依赖关系，依赖关系将被「自动注入」到需要它们的对象当中去

面试官：嗯，那我想问问，用Spring IOC有什么好处吗？

面试官：或者换个问法：本来我可以new出来的对象，为什么我要交由Spring IOC容器管理呢？

候选者：主要的好处在于「将对象集中统一管理」并且「降低耦合度」

候选者：如果面试官理解了「工厂模式」，那就知道为什么我们不直接new对象

面试官：好家伙，不行，这答案我观众不满意！

候选者：要说理由的话，可以举很多例子，比如说：

候选者：我用Spring IOC 可以方便单元测试、对象创建复杂、对象依赖复杂、单例等等的，什么都可以交给Spring IOC

候选者：理论上自己new出来的都可以解决上面的问题，Spring在各种场景组合下有可能不是最优解

候选者：但new出来的你要自己管理，可能你得自己写工厂，得实现一大套的东西才能满足需求

候选者：写着写着有可能还是Spring的那一套

候选者：但现在Spring现在已经帮你实现了啊！

候选者：如果项目里的对象都是就new下就完事了，没有多个实现类，那没事，不用Spring也没啥问题

候选者：并且Spring核心不仅仅IOC啊，除了把对象创建出来，还有一整套的Bean生命周期管理

候选者：比如说你要实现对象增强，AOP不就有了吗？不然你还得自己创建代理..

面试官：好好好

面试官：但我看这届观众好像还是不太满意？

候选者：不，他们已经满意了。

面试官：那你继续来聊下Spring AOP呗？

候选者：Spring AOP 解决的是非业务代码抽取的问题

候选者：AOP 底层的技术是动态代理，在Spring内实现依赖的是BeanPostProcessor

候选者：比如我们需要在方法上注入些「重复性」的非业务代码，就可以利用Spring AOP

候选者：所谓的「面向切面编程」在我理解下其实就是在方法前后增加非业务代码

面试官：那你在工作中实际用到过AOP去优化你的代码吗？

候选者：有的。当时我用AOP来对我们公司现有的监控客户端进行封装

候选者：一个系统离不开监控，监控基本的指标有QPS、RT、ERROR等等

候选者：对外暴露的监控客户端只能在代码里写对应的上报信息（灵活，但会与业务代码掺杂在一起）

候选者：于是我利用注解+AOP的方式封装了一把，只要方法/类上带有我自定义的注解

候选者：方法被调用时，就会上报AQS、RT等信息

候选者：实现了非业务代码与业务代码分离的效果（：

面试官：你们项目一般是怎么把对象交给IOC容器管理的？

面试官：换个问法：一般是怎么定义Bean的？

候选者：Spring提供了4种方式，分别是：

候选者：1):注解 2):XML 3):JavaConfig 4):基于Groovy DSL配置

候选者：一般项目我们用注解或XML比较多，少部分用JavaConfig

候选者：日常写业务代码一般用注解来定义各种对象，责任链这种一般配置在XML，「注解」解决不了的就用JavaConfig

候选者：总体而言，还是得看项目的代码风格吧（：

候选者：反正就是定义元数据，能给到Spring解析就好了

面试官：嗯，了解。

面试官：要不来聊聊你使用Spring的感受？

候选者：嗯嗯..

候选者：当我还是初学Spring的时候，我觉得Spring很麻烦，需要有一大堆的配置信息才能跑起来

候选者：光是搭建环境就需要耗费我好长的时间

候选者：毕竟版本冲突，依赖冲突什么的就可能一个下午就过去了

候选者：但毕竟一个系统环境只搭一次嘛，所以还好

候选者：（后来用上了SpringBoot这又更方便了）

面试官：嗯…

候选者：话说回来，IOC和AOP在工作用的时候还是很爽的

候选者：毕竟搞个注解什么的，配置下就可以把对象交给Spring管理了

候选者：配合Spring的生态，@Transactional注解什么的，都好用得飞起

候选者：不过，Spring给我们封装得太好了

候选者：经常就会有奇奇怪怪的”bug“出现，也踩过很多的坑了

候选者：Bean经常没办法创建成功，导致项目启动失败

候选者：对象的循环依赖问题…

候选者：同一个接口，多个实现，识别不出我要创建哪个对象…

候选者：为什么catch了异常，Spring事务为什么还会自动回滚

候选者：等等等…..

候选者：总的来说，Spring给我们封装了一个很好的环境，实现对我们屏蔽了

候选者：但是如果理解不深的话，很有可能就会触发各种bug

面试官：了解

面试官：今天要不来聊聊Spring对Bean的生命周期管理？

候选者：嗯，没问题的。

候选者：很早之前我就看过源码，但Spring源码的实现类都太长了

候选者：我也记不得很清楚某些实现类的名字，要不我大概来说下流程？

面试官：没事，你开始吧

候选者：首先要知道的是

候选者：普通Java对象和Spring所管理的Bean实例化的过程是有些区别的

候选者：在普通Java环境下创建对象简要的步骤可以分为：

候选者：1):java源码被编译为被编译为class文件

候选者：2):等到类需要被初始化时（比如说new、反射等）

候选者：3):class文件被虚拟机通过类加载器加载到JVM

候选者：4):初始化对象供我们使用

候选者：简单来说，可以理解为它是用Class对象作为「模板」进而创建出具体的实例

候选者：而Spring所管理的Bean不同的是，除了Class对象之外，还会使用BeanDefinition的实例来描述对象的信息

候选者：比如说，我们可以在Spring所管理的Bean有一系列的描述：@Scope、@Lazy、@DependsOn等等

候选者：可以理解为：Class只描述了类的信息，而BeanDefinition描述了对象的信息

面试官：嗯，这我大致了解你的意思了。

面试官：你就是想告诉我，Spring有BeanDefinition来存储着我们日常给Spring Bean定义的元数据（@Scope、@Lazy、@DependsOn等等），对吧？

候选者：不愧是你

面试官：赶紧的，继续吧

候选者：Spring在启动的时候需要「扫描」在XML/注解/JavaConfig 中需要被Spring管理的Bean信息

候选者：随后，会将这些信息封装成BeanDefinition，最后会把这些信息放到一个beanDefinitionMap中

候选者：我记得这个Map的key应该是beanName，value则是BeanDefinition对象

候选者：到这里其实就是把定义的元数据加载起来，目前真实对象还没实例化

候选者：接着会遍历这个beanDefinitionMap，执行BeanFactoryPostProcessor这个Bean工厂后置处理器的逻辑

候选者：比如说，我们平时定义的占位符信息，就是通过BeanFactoryPostProcessor的子类PropertyPlaceholderConfigurer进行注入进去

候选者：当然了，这里我们也可以自定义BeanFactoryPostProcessor来对我们定义好的Bean元数据进行获取或者修改

候选者：只是一般我们不会这样干，实际上也很有少的使用场景

面试官：嗯….

候选者：BeanFactoryPostProcessor后置处理器执行完了以后，就到了实例化对象啦

候选者：在Spring里边是通过反射来实现的，一般情况下会通过反射选择合适的构造器来把对象实例化

候选者：但这里把对象实例化，只是把对象给创建出来，而对象具体的属性是还没注入的。

候选者：比如我的对象是UserService，而UserService对象依赖着SendService对象，这时候的SendService还是null的

候选者：所以，下一步就是把对象的相关属性给注入（：

候选者：相关属性注入完之后，往下接着就是初始化的工作了

候选者：首先判断该Bean是否实现了Aware相关的接口，如果存在则填充相关的资源

候选者：比如我这边在项目用到的：我希望通过代码程序的方式去获取指定的Spring Bean

候选者：我们这边会抽取成一个工具类，去实现ApplicationContextAware接口，来获取ApplicationContext对象进而获取Spring Bean

候选者：Aware相关的接口处理完之后，就会到BeanPostProcessor后置处理器啦

候选者：BeanPostProcessor后置处理器有两个方法，一个是before，一个是after（那肯定是before先执行、after后执行）

候选者：这个BeanPostProcessor后置处理器是AOP实现的关键（关键子类AnnotationAwareAspectJAutoProxyCreator）

候选者：所以，执行完Aware相关的接口就会执行BeanPostProcessor相关子类的before方法

候选者：BeanPostProcessor相关子类的before方法执行完，则执行init相关的方法，比如说@PostConstruct、实现了InitializingBean接口、定义的init-method方法

候选者：当时我还去官网去看他们的被调用「执行顺序」分别是：@PostConstruct、实现了InitializingBean接口以及init-method方法

候选者：这些都是Spring给我们的「扩展」，像@PostConstruct我就经常用到

候选者：比如说：对象实例化后，我要做些初始化的相关工作或者就启个线程去Kafka拉取数据

候选者：等到init方法执行完之后，就会执行BeanPostProcessor的after方法

候选者：基本重要的流程已经走完了，我们就可以获取到对象去使用了

候选者：销毁的时候就看有没有配置相关的destroy方法，执行就完事了

面试官：嗯，了解，但我的观众好像不太满意，总感觉少了些什么。

面试官：你看过Spring是怎么解决循环依赖的吗？

面试官：如果现在有个A对象，它的属性是B对象，而B对象的属性也是A对象

面试官：说白了就是A依赖B，而B又依赖A，Spring是怎么做的？

候选者：嗯，这块我也是看过的，其实也是在Spring的生命周期里面嘛

候选者：从上面我们可以知道，对象属性的注入在对象实例化之后的嘛。

候选者：它的大致过程是这样的：

候选者：首先A对象实例化，然后对属性进行注入，发现依赖B对象

候选者：B对象此时还没创建出来，所以转头去实例化B对象

候选者：B对象实例化之后，发现需要依赖A对象，那A对象已经实例化了嘛，所以B对象最终能完成创建

候选者：B对象返回到A对象的属性注入的方法上，A对象最终完成创建

候选者：上面就是大致的过程；

面试官：听起来你还会原理哦？

候选者：Absolutely

候选者：至于原理，其实就是用到了三级的缓存

候选者：所谓的三级缓存其实就是三个Map…首先明确一定，我对这里的三级缓存定义是这样的：

候选者：singletonObjects（一级，日常实际获取Bean的地方）；

候选者：earlySingletonObjects（二级，还没进行属性注入，由三级缓存放进来）；

候选者：singletonFactories（三级，Value是一个对象工厂）；

候选者：再回到刚才讲述的过程中，A对象实例化之后，属性注入之前，其实会把A对象放入三级缓存中

候选者：key是BeanName，Value是ObjectFactory

候选者：等到A对象属性注入时，发现依赖B，又去实例化B时

候选者：B属性注入需要去获取A对象，这里就是从三级缓存里拿出ObjectFactory，从ObjectFactory得到对应的Bean（就是对象A）

候选者：把三级缓存的A记录给干掉，然后放到二级缓存中

候选者：显然，二级缓存存储的key是BeanName，value就是Bean（这里的Bean还没做完属性注入相关的工作）

候选者：等到完全初始化之后，就会把二级缓存给remove掉，塞到一级缓存中

候选者：我们自己去getBean的时候，实际上拿到的是一级缓存的

候选者：大致的过程就是这样

面试官：那我想问一下，为什么是三级缓存？

候选者：首先从第三级缓存说起（就是key是BeanName，Value为ObjectFactory）

候选者：我们的对象是单例的，有可能A对象依赖的B对象是有AOP的（B对象需要代理）

候选者：假设没有第三级缓存，只有第二级缓存（Value存对象，而不是工厂对象）

候选者：那如果有AOP的情况下，岂不是在存入第二级缓存之前都需要先去做AOP代理？这不合适嘛

候选者：这里肯定是需要考虑代理的情况的，比如A对象是一个被AOP增量的对象，B依赖A时，得到的A肯定是代理对象的

候选者：所以，三级缓存的Value是ObjectFactory，可以从里边拿到代理对象

候选者：而二级缓存存在的必要就是为了性能，从三级缓存的工厂里创建出对象，再扔到二级缓存（这样就不用每次都要从工厂里拿）

候选者：应该很好懂吧？

面试官：确实（：

候选者：我稍微总结一下今天的内容吧

候选者：怕你的观众说不满意，那我就没有赞了，没有赞我就很难受

候选者：首先是Spring Bean的生命周期过程，Spring使用BeanDefinition来装载着我们给Bean定义的元数据

候选者：实例化Bean的时候实际上就是遍历BeanDefinitionMap

候选者：Spring的Bean实例化和属性赋值是分开两步来做的

候选者：在Spring Bean的生命周期，Spring预留了很多的hook给我们去扩展

候选者：1）：Bean实例化之前有BeanFactoryPostProcessor

候选者：2）：Bean实例化之后，初始化时，有相关的Aware接口供我们去拿到Context相关信息

候选者：3）：环绕着初始化阶段，有BeanPostProcessor（AOP的关键）

候选者：4）：在初始化阶段，有各种的init方法供我们去自定义

候选者：而循环依赖的解决主要通过三级的缓存

候选者：在实例化后，会把自己扔到三级缓存（此时的key是BeanName，Value是ObjectFactory）

候选者：在注入属性时，发现需要依赖B，也会走B的实例化过程，B属性注入依赖A，从三级缓存找到A

候选者：删掉三级缓存，放到二级缓存

面试官：嗯，你要不后面放点关键的源码吧

候选者：这你倒是提醒我了，确实有必要

面试官：这要是能听懂，是真的看过源码才行（：还好我看过

关键源码方法（强烈建议自己去撸一遍）

org.springframework.context.support.AbstractApplicationContext#refresh(入口)org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization(初始化单例对象入口)org.springframework.beans.factory.config.ConfigurableListableBeanFactory#preInstantiateSingletons(初始化单例对象入口)org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)（万恶之源，获取并创建Bean的入口）org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean（实际的获取并创建Bean的实现）org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String)（从缓存中尝试获取）org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])（实例化Bean）org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean（实例化Bean具体实现）org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance（具体实例化过程）org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonFactory（将实例化后的Bean添加到三级缓存）org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean（实例化后属性注入）org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)（初始化入口）

Java开源项目推荐

我推荐一个拥有从零开始的文档的Java开源项目，既能用于毕业设计，又可以用在面试。

该项目业务极容易理解，代码结构是比较清晰的，最可怕的是几乎每个方法和每个类都带有中文注释，并且代码完全通过阿里开发插件检查。

拥有非常全的文档，作者从零搭建的过程都有详细地记录，项目里使用了蛮多的可靠和稳定的中间件的。在使用每一个技术栈之前作者都讲述了为什么要使用，以及它的业务背景。我看过，他所说的场景是完全贴合线上环境的。

我感觉这个项目就是奔着真实互联网线上项目去设计和实现的，将项目克隆下来把中间件换成目前公司在用的，配合自身的需求完善下基础建设，它就能在线上运行了。

我跟着README文档的部署使用姿势很快就能跑起来，最少只需要依赖MySQL和Redis。作者还搞了个前端功能界面，这就让系统变得更好理解了。而且，在GitHub或者Gitee所提的Issue几乎都会有回复，看出来也非常乐于合并开发者们的pull request，会让人参与感贼强。

我相信在校、工作一年左右或常年做内网CRUD后台的同学去看看肯定会有所启发，作者也会经常在群里回答该项目相关的问题和代码设计思路。

项目里会应用到各种设计模式（我稍微看了下，应该有7~8种吧），用到了各种的好用的工具组件，动态线程池、日志切面组件之类，都是主流的技术栈...目前这个项目GitHub和Gitee加起来已经 7K stars了，我相信破万是迟早的事情。

项目介绍

核心功能：统一的接口发送各种类型消息，对消息生命周期全链路追踪。

意义：只要公司内部有发送消息的需求，都应该要有类似消息推送平台的项目。消息推送平台对各类消息进行统一发送处理，这有利于对功能的收拢，以及提高业务需求开发的效率。

技术栈

技术栈实现

编程语言Java（JDK 1.8)项目管理工具Maven 3.x集成开发工具IDEA 2022部署服务器Centos 7.6系统部署工具Docker & Docker-compose项目环境SpringBoot 2.5.6关系型数据库MySQL 5.7.X缓存数据库Redis:lastestORM框架SpringData JPA 2.5.6分布式定时任务框架XXL-JOB v2.3.0分布式配置中心Apollo & Nacos消息队列Kafka & RabbitMQ & RocketMQ分布式日志采集框架Graylog分布式计算引擎Flink 1.16.0监控采集组件Prometheus监控可视化组件Grafana数据仓库Hive 2.3.2大数据环境Hadoop 2.7.4大数据可视化Metabase:lastest前端技术Amis

使用教程

项目有预览地址，可自行体验：http://139.9.66.219:3000/

1、创建需要发送的渠道账号

2、创建消息模板

3、测试发送消息是否正常

4、查看消息下发情况

5、亦可在新建模板时选择定时任务，通过上传csv文件和指定cron表达式实现下发消息

工程模块&系统流程

了解工程模块的职责，这对看项目代码的时候会有个比较清晰的认识：

工程模块作用

austin-common项目公共包：存储着项目公共常量/枚举/Beanaustin-support项目工具包：对接中间件/组件austin-cron定时任务模块：对xxl-job封装和项目定时任务逻辑austin-web后台管理模块：提供接口给前端调用austin-service-api消息接入层接口定义模块：只有接口和必要的入参依赖austin-service-api-impl消息接入层具体实现模块：真实处理请求austin-handler消息处理逻辑层：消费MQ下发消息austin-stream实时处理模块：利用flink实时处理下发链路数据austin-data-house数据仓库模块：消费MQ数据写入hive

项目视频(免费）：

项目Gitee链接：

项目GitHub链接：

面试官：今天要不来聊聊SpringMVC吧？

候选者：我先简单说下我对SpringMVC的理解哈

候选者：SpringMVC我觉得它是对Servlet的封装，屏蔽掉Servlet很多的细节

候选者：举几个例子

候选者：可能我们刚学Servlet的时候，要获取参数需要不断的getParameter

候选者：现在只要在SpringMVC方法定义对应的JavaBean，只要属性名与参数名一致，SpringMVC就可以帮我们实现「将参数封装到JavaBean」上了

候选者：又比如，以前使用Servlet「上传文件」，需要处理各种细节，写一大堆处理的逻辑（还得导入对应的jar）

候选者：现在一个在SpringMVC的方法上定义出MultipartFile接口，又可以屏蔽掉上传文件的细节了。

候选者：例子还有很多，我就不一一赘述了。

面试官：既然你说SpringMVC是对Servlet的封装，你了解SpringMVC请求处理的流程吗？

候选者：嗯，当然了，我看过源码。总体流程大概是这样的

候选者：1):首先有个统一处理请求的入口

候选者：2):随后根据请求路径找到对应的映射器

候选者：3):找到处理请求的适配器

候选者：4):拦截器前置处理

候选者：5):真实处理请求（也就是调用真正的代码)

候选者：6): 视图解析器处理

候选者：7):拦截器后置处理

面试官：嗯，了解，可以再稍微深入点吗？

面试官：毕竟这随便在网上找张SpringMVC流程图，就可以答出来了，看不出来你看过源码啊

候选者：哦？那我就简单补充下细节吧。

候选者：统一的处理入口，对应SpringMVC下的源码是在DispatcherServlet下实现的

候选者：该对象在初始化就会把映射器、适配器、视图解析器、异常处理器、文件处理器等等给初始化掉

候选者：至于会初始化哪些具体实例，看下DispatcherServlet.properties就知道了，都配置在那了

候选者：所有的请求其实都会被doService方法处理，里边最主要就是调用doDispatch方法

候选者：通过doDispatch方法我们就可以看到整个SpringMVC处理的流程

候选者：查找映射器的时候实际就是找到「最佳匹配」的路径，具体方法实现我记得好像是在lookupHandlerMethod方法上

候选者：从源码可以看到「查找映射器」实际返回的是HandlerExecutionChain，里边有映射器Handler+拦截器List

候选者：前面提到的拦截器前置处理和后置处理就是用的HandlerExecutionChain中的拦截器List

候选者：获取得到HandlerExecutionChain后，就会去获取适配器，一般我们获取得到的就是RequestMappingHandlerAdapter

候选者：在代码里边可以看到的是，经常用到的@ResponseBody和@Requestbody的解析器

候选者：就会在初始化的时候加到参数解析器List中

候选者：得到适配器之后，就会执行拦截器前置处理

面试官：嗯

候选者：拦截器前置处理执行完后，就会调用适配器对象实例的hanlde方法执行真正的代码逻辑处理

候选者：核心的处理逻辑在invokeAndHandle方法中，会获取得到请求的参数并调用，处理返回值

候选者：参数的封装以及处理会被适配器的参数解析器进行处理，具体的处理逻辑取决于HttpMessageConverter的实例对象

面试官：嗯，了解了。要不你再压缩下关键的信息

候选者：DispatcherServlet（入口）->DispatcherServlet.properties（会初始化的对象）->HandlerMapping（映射器）->HandlerExecutionChain(映射器+拦截器List) ->HttpRequestHandlerAdapter(适配器)->HttpMessageConverter(数据转换)

面试官：最后来画张流程图吧？

候选者：没问题（上网找的比我画的还要好）

面试官：好久没见，甚是想念。今天来聊聊SpringBoot的自动配置吧？

候选者：嗯，SpringBoot的自动配置我觉得是SpringBoot很重要的“特性”了。众所周知，SpringBoot有着“约定大于配置”的理念，这一理念一定程度上可以用“SpringBoot自动配置”来解释。

候选者：SpringBoot自动配置的原理理解起来挺简单的，我们在使用SpringBoot的时候，肯定会依赖于autoconfigure这么一个包

候选者：autoconfigure这个包里会有一个spring.factories文件，该文件定义了100+个入口的配置类。比如我们经常使用的redis、kafka等等这样常见的中间件都预置了配置类

候选者：当我们在启动SpringBoot项目的时候，内部就会加载这个spring.factories文件，进而去加载“有需要”的配置类。那我们在使用相关组件的时候，就会非常的方便（因为配置类已经初始化了一大部分配置信息）。

候选者：一般我们只要在application配置文件写上对应的配置，就能通过各种template类直接操作对应的组件啦。

面试官：那是所有的配置类都会加载吗？这个“有需要”的配置类你是怎么理解的？

候选者：不是所有的配置类都会加载的，假设我们没有引入redis-starter的包，那Redis的配置类就不会被加载。具体Spring在实现的时候就是使用**@ConditionalXXX**进行判断的。比如Redis的配置类就会有@ConditionalOnClass({RedisOperations.class})的配置，说明当前环境下如果有RedisOperations.class这个字节码，才会去加载Redis的配置类

面试官：哦，这样啊，那了解了。那你知不知道Redis的配置类其实会有初始化RedisTemplate对象的操作，那假设我们没有引入redis-starter包，那他是怎么通过编译的？（当然了，其他的配置类也是有可能有一样的状况）

候选者：嗯，这个我看源码的时候我也发现了。其实就是在autoconfigure包里会定义到相关的依赖，但只是标记为optional并且只在编译环境有效。那这样是能通过编译的，只是不会将其依赖传入到我们的应用工程里。

候选者：这块还是花了我很多时间的，我最后在GitHub 的SpringBoot源码里找到的。

面试官：嗯啊，有点东西的哟。既然都聊到这块了，要不顺便聊聊你对SpringBoot starter的理解？

候选者：嗯，starter这东西就是为了方便调用方去使用相关的组件的嘛，Spring框架也给我们实现了很多好用的starter。

候选者：比如以前我们要用Mybatis框架，可能会引入各种的包才能使用。而starter就是做了一层封装，把相关要用到的jar都给包起来了，并且也写好了对应的版本。这我们使用的时候就不需要引入一堆jar包且管理版本类似的问题了。

候选者：现在很多开源的组件都会提供对应的springboot-starter包给我们去用，要做一个starter包并不难。参照Spring内置的实现就好了：1、在工程里引入 starter 打包相关的依赖。2、在我们工程内建spring.factories文件，编写我们配置类的全限类名。

面试官：嗯，大致都了解了，可以的。最后聊下你是怎么看这块源码的？

候选者：源码具体大概就不记得了，思路倒是还有的。我先从启动类开始，会有个@SpringBootApplication，后面会定位到一个自动配置的注解@EnableAutoConfiguration，那最后就能看到注解内部会去META-INF/spring.factories加载配置类

候选者：这块源码并不难，这个过程也了解到了原来maven有option和scope这俩标签，但确实是SpringBoot比较重要的概念吧。

面试官：好嘞，今天到这就结束了吧。

题外：自动配置这个问题确实被问到过几次。说实在的，对于Spring类、注解的信息我真的记不住。感觉能答出这个流程思路，也就够用了（如果面试官确实是要细究某个类名，那这种公司不去也罢）

约定大于配置：SpringBoot给我们内置了很多配置类，这些配置类也初始化了很多配置（默认值）。当我们要使用的时候，只需要覆盖这些配置项就完事了。即便我们不写，大多数情况下都不需要由我们显示配置出来，但相关组件就能正常访问了。

《对线面试官》Java面试八股文

《对线面试官》是我一字字敲出来的，是我准备跳槽时按照自己的思路撰写而成。

它不会花长的篇幅讲述基础API相关的知识，会着重讲解重点高频率面试题，又或是实际工作中如何使用这项技术的它。模拟真实的面试场景，面试者实际的回答内容可能是怎么样的。

如果有看过的人，自然就懂，跟大部分的面试题是有区别的，这个系列也使我在知乎获近万赞，至少我认为它是有价值。等我下次跳槽，我绝对会回看我自己写的对线面试官系列。

为了增添趣味性会有图片版本（在其中穿插大量表情包或者梗），为了复习效率性会有纯文版本，纯文版本还有离线PDF电子书，离线PDF电子书有明亮版和暗黑版。

对线面试官第一季共40篇已结束

对线面试官第二季会有吗？会的

最近我把时间都花在写我的个人项目（消息推送平台），在项目上用到了很多的中间件。

这些中间件都值得拉出来做成面试题（事实上，当我作为面试官的时候也很喜欢问面试者在项目中相关的技术栈问题），我一直信奉着只要写在简历上的内容，肚子就得有墨水

《对线面试官第一季》纯文版

简历【对线面试官】如何写简历Java基础【对线面试官】Java注解【对线面试官】Java泛型【对线面试官】 Java NIO【对线面试官】Java反射 && 动态代理Java并发【对线面试官】多线程基础【对线面试官】 CAS【对线面试官】synchronized【对线面试官】AQS&&ReentrantLock【对线面试官】线程池【对线面试官】ThreadLocal【对线面试官】CountDownLatch和CyclicBarrier【对线面试官】为什么需要Java内存模型？【对线面试官】深入浅出 Java 内存模型Java虚拟机【对线面试官】Java从编译到执行，发生了什么？【对线面试官】双亲委派机制【对线面试官】JVM内存结构【对线面试官】垃圾回收机制【对线面试官】CMS垃圾回收器【对线面试官】G1垃圾收集器【对线面试官】JVM调优Java集合【对线面试官】List【对线面试官】MapSpring【对线面试官】SpringMVC【对线面试官】Spring基础【对线面试官】SpringBean生命周期Redis【对线面试官】Redis基础【对线面试官】Redis持久化【对线面试官】Redis主从架构【对线面试官】Redis分片集群消息队列【对线面试官】Kafka基础【对线面试官】使用Kafka会考虑什么问题？MySQL【对线面试官】MySQL索引【对线面试官】MySQL 事务&&锁机制&&MVCC【对线面试官】MySQL调优项目场景相关【对线面试官】如何实现幂等和去重？【对线面试官】系统需求多变时，如何设计【对线面试官】设计模式计算机网络【对线面试官】TCP【对线面试官】HTTP