分析案例前提所参考的例子，Spring Boot中的自定义start pom，SpringBoot学习笔记(3) Spring Boot 运行原理,自动配置

，然后我又看了下nacos的源码，发现原来也都是这做的截图如下：

当然最终的目的我是想知道@Bean  helloService实例化过程

/*** @desc 自定义自动配置加载类：* 1、编写属性配置类，读取application.properties文件初始化属性* 2、编写service类。* 3、编写自定义自动加载配置类* 4、在配置类中根据HelloServiceProperties提供的参数，并通过ConditionalOnMissingBean判断* 容器中没有bean时，注入helloService。*/
@Configuration
@EnableConfigurationProperties(HelloServiceProperties.class)
@ConditionalOnClass(HelloService.class)
@ConditionalOnProperty(prefix = "hello", value = "enabled", matchIfMissing = true)
public class HelloServiceAutoConfiguration {@Autowiredprivate HelloServiceProperties helloServiceProperties;//容器中没有指定的HelloService实例时进行初始化@Bean@ConditionalOnMissingBean(HelloService.class)public HelloService helloService() {HelloService helloService = new HelloService();helloService.setMsg(this.helloServiceProperties.getMsg());return helloService;}
}

1：首先回顾一下bean创建以及后期处理过程中的主要类的名字和作用，我觉得有两个类需要提前关注下，如下图所示（ctrl+h），

DefaultListableBeanFactory作为默认的bean注册加载的工厂类，继承了AutowireCapableBeanFacotry（提供创建、自动注入、初始化、和后置处理器的作用）

2：调用关系时序图参考 IDEA自动生成方法时序图 -- Sequence Diagram（一款超好用的Idea插件）

当然，时序图有时候也不是万能的。

      第一步：

此时启动springboot之后，相继进入AbstractApplicationContext类的refresh()方法，这里我只关注一个finishBeanFactoryInitialization方法，其他的并非本次分析的重点：

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
该refresh（）所调用的方法注释翻译：实例化所有剩余的（非延迟初始化）单例，当然到了这一步bean已经全部加载完毕，之后的过程是进行实例化的过程第二步：

点击进入finishBeanFactoryINitialization方法，此时使用beanFactory就是DefaultListableBeanFactory，准备bean的实例化

/*** Finish the initialization of this context's bean factory,* initializing all remaining singleton beans.*/protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// 省略。。。。。// Instantiate all remaining (non-lazy-init) singletons.beanFactory.preInstantiateSingletons();}

     第三步

  分析DefaultListableBeanFactory的preInstantiateSingletons方法，

Ensure that all non-lazy-init singletons are instantiated（确保所有非懒加载的bean都实例化）

@Overridepublic void preInstantiateSingletons() throws BeansException {if (logger.isTraceEnabled()) {logger.trace("Pre-instantiating singletons in " + this);}// 1:这里的beanDefinitionNames的存储方式这ArrayList//private volatile List<String> beanDefinitionNames = new ArrayList<>(256);// 在扩展看下就是	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);//volatile 保证了可见性和顺序性，便于判断逻辑的准确实时List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);// Trigger initialization of all non-lazy singleton beans...for (String beanName : beanNames) {RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {// 这里我的类并没有实现FactoryBean的接口所以进入else的getBean方法，此处的判断逻辑是这样的：beanType != null && FactoryBean.class.isAssignableFrom(beanType)// 新的知识点出来了  instanceof, isinstance,isAssignableFrom的区别// 自身实例或子类实例 instanceof 自身类 // 自身类.class.isInstance(自身实例或子类实例)  返回true // 自身类.class.isAssignableFrom(自身类或子类.class)  返回true if (isFactoryBean(beanName)) {// 省略。。。}else {getBean(beanName);}}}// 省略。。。。}

    第四步：

     查看getBean方法，当然要记住，目前操作都是在DefaultListableBeanFactory，可见，这里多么重要，是bean的存储的地方即beanDefinitionMap，还有创建bean的方法。

    之后的过程会进入DefaultListableBeanFactory的父类AbstractBeanFactory执行doGetBean，这里的方法名挺有意思的，我是这么理解的 getBean -表示想要获取bean，doGetBean-那就去获取bean，之后会看到createBean-表示想要创建bean，doCreateBean-真正的创建bean，当然前提条件是DefaultListableBeanFactory里边的三级缓存无数据，这点参考《spring源码分析》对三级缓存的理解，目的是提前暴露bean避免循环依赖，从代码方面可以看出以下缓存的数据结构

/** Cache of singleton objects: bean name to bean instance. */一级缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);/** Cache of singleton factories: bean name to ObjectFactory. */ 三级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);/** Cache of early singleton objects: bean name to bean instance. */二级缓存
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

代码角度分析doGetBean的过程：

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {final String beanName = transformedBeanName(name);Object bean;// 缓存检测实例是否提前被暴露，接下来看看里边的缓存是如何处理的Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {//省略。。。}else {//原型模式的bean检测是否存在循环依赖，有的话直接报异常，因为会造成死循环，最终导致程序崩溃if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);}// 省略。。。try {// 省略。。。// Create bean instance.if (mbd.isSingleton()) {// 此处对于单例bean的创建，参数是beanNane和接口实现方法// 最终调用createBean，当然还没完之后还有个doCreate真正去创建bean的方法sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);}catch (BeansException ex) {// Explicitly remove instance from singleton cache: It might have been put there// eagerly by the creation process, to allow for circular reference resolution.// Also remove any beans that received a temporary reference to the bean.destroySingleton(beanName);throw ex;}});bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);}// 省略。。。}catch (BeansException ex) {cleanupAfterBeanCreationFailure(beanName);throw ex;}}// 省略。。。return (T) bean;}

分析下第一个获取bean的方法--getSingleton，挺有意思的，对照前面提到的三级缓存结构，大致逻辑是查找一级缓存是否存在实例对象，不存在找二级缓存是否存在实例对象，不存在就再次查找三级缓存是否存在ObjectFactory，如果没有返回空，否则通过beanFactory.getBean获取实例对象，存入二级缓存，同时移除三级缓存对象。同理之后的处理逻辑会从二级缓存提取放入以及缓存，移除二级缓存对象，但是我没搞懂为啥有个二级缓存，可能为了更好的解耦合，见代码：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {synchronized (this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject;}

第五步：

现在分析下第二个getSingleton方法，当然我们看到了第二个入参，是个匿名类，一定会调用匿名类的createBean方法，代码如下：

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(beanName, "Bean name must not be null");synchronized (this.singletonObjects) {Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {// 省略。。。// 前置BeanCurrentlyInCreationException判断beforeSingletonCreation(beanName);try {// 匿名类参数的调用，实际上是调用createBean方法，之后会分析createBean方法singletonObject = singletonFactory.getObject();newSingleton = true;}// 省略。。。finally {if (recordSuppressedExceptions) {this.suppressedExceptions = null;}// 后置BeanCurrentlyInCreationException判断afterSingletonCreation(beanName);}if (newSingleton) {// 这块提前看下，就是把bean实例放入一级缓存，之后的调用// 直接从一级缓存获取// synchronized (this.singletonObjects) {// this.singletonObjects.put(beanName, singletonObject);// this.singletonFactories.remove(beanName);// this.earlySingletonObjects.remove(beanName);// this.registeredSingletons.add(beanName);// }addSingleton(beanName, singletonObject);}}return singletonObject;}}

第六步：crreateBean方法，主要做了三个主要的灵魂级别的事情1：创建一个bean实例 ，2：填充bean实例 ，3：执行后置处理器

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)throws BeanCreationException {// Instantiate the bean.BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) {// 这里是创建beanInstance的过程，继续跟代码instanceWrapper = createBeanInstance(beanName, mbd, args);}final Object bean = instanceWrapper.getWrappedInstance();Class<?> beanType = instanceWrapper.getWrappedClass();if (beanType != NullBean.class) {mbd.resolvedTargetType = beanType;}// Allow post-processors to modify the merged bean definition.synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}catch (Throwable ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);}mbd.postProcessed = true;}}// Eagerly cache singletons to be able to resolve circular references// even when triggered by lifecycle interfaces like BeanFactoryAware.boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// Initialize the bean instance.Object exposedObject = bean;try {// 这里是丰富化实例，执行属性注入，这里会获取beanPostProcess（getBeanPostProcessors）// 循环调用得到AutowiredAnnotationBeanPostProcessor，去处理@Autowired注入// 当然这里又会持续doGetBean的过程populateBean(beanName, mbd, instanceWrapper);// 这里执行后置处理器的过程exposedObject = initializeBean(beanName, exposedObject, mbd);}catch (Throwable ex) {if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {throw (BeanCreationException) ex;}else {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);}}// 省略。。。return exposedObject;}

当然代码继续调用的是doCreateBean方法实现这些过程的。需要额外说明的是spring保证每个bean都要执行beanPostProcess方法，内置了大概是个process方法，也可以自定义，自定义之后，启动refresh的时候，会执行registerBeanPostProcessors方法，大概过程如下：前提已经加载了左右的bean class到beanDefinitionMap容器，之后执行doGetBeanNamesForType方法

private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {List<String> result = new ArrayList<>();// Check all bean definitions.for (String beanName : this.beanDefinitionNames) {省略。。。。}

获取所有实现BeanPostProcessor接口的实现类，提取存放到beanPostProcessors里

private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();

最后在populateBean、exposedObject 时候会执行processor方法，给予实例化的更改实际的机会，大致代码过程

for (BeanPostProcessor processor : getBeanPostProcessors()) {Object current = processor.postProcessBeforeInitialization(result, beanName);if (current == null) {return result;}result = current;
}

当然当执行到ConfigurationBeanBindingPostProcessor的postProcessBeforeInitialization时候会进行@ConfigurationProperties的值反射绑定（bind-->bindDataObject），其绑定的定义值也都是从PropertySource类中获取，说的有点远了，看下PropertySource的结构

public abstract class PropertySource<T> {protected final Log logger = LogFactory.getLog(getClass());protected final String name;protected final T source;/*** Create a new {@code PropertySource} with the given name and source object.*/public PropertySource(String name, T source) {Assert.hasText(name, "Property source name must contain at least one character");Assert.notNull(source, "Property source must not be null");this.name = name;this.source = source;}

          其实这个结构存储额所有springboot配置文件的key vale值，可以通过Environment  注入的形式获取，源头都是PropertySource，找到源头是一件非常好玩的一件事情。

 第七步：分析createBeanInstance方法，这里挺有意思的，普通方法例如使用@Component，直接进行构造函数实例化，但是本例中使用的是@Configuration @Bean进行实例化的，如下图，所以我猜测spring会给mdb set一个特殊实例化工厂方法，然后执行具体的策略，有兴趣的自己可以在setFacory断点查看，

如我所愿，果真如此，可以看下图，这里边的信息表明@Configuration 真的是将工厂方法策略的元数据信息set到了mdb里边，方便之后的执行操作，具体操作大家应该都能猜到，就是使用的@Bean里边自定义的实例化方法

特殊工厂方法策略实例化代码

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {// 省略。。。if (mbd.getFactoryMethodName() != null) {return instantiateUsingFactoryMethod(beanName, mbd, args);}// 省略。。。// 无特殊处理：只需使用无参数构造函数。return instantiateBean(beanName, mbd);}

第八步：

	protected BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);}

继续跟代码，可以看到最终的猜想是否正确，到底使用工厂方法做了什么特殊处理呢？

public BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {// 省略。。。。// 获取工厂factoryClass = factoryBean.getClass();// uniqueCandidate是具体@Bean注解的方法Method，之后利用反射执行实例化bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));return bw;

利用工厂方法（helloService）进行反射实例化Bean的过程如下

@Overridepublic Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,@Nullable Object factoryBean, final Method factoryMethod, Object... args) {try {if (System.getSecurityManager() != null) {AccessController.doPrivileged((PrivilegedAction<Object>) () -> {ReflectionUtils.makeAccessible(factoryMethod);return null;});}else {ReflectionUtils.makeAccessible(factoryMethod);}Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();try {currentlyInvokedFactoryMethod.set(factoryMethod);Object result = factoryMethod.invoke(factoryBean, args);if (result == null) {result = new NullBean();}return result;}// 省略。。。。}// 省略。。。。}