Spring 注入Bean

AbstractApplicationContext.java

public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh(); //准备工作(setEnvironment initProperties等)
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();//创建BeanFactory
            this.prepareBeanFactory(beanFactory);//设置一些BeanFactory属性值

            try {
                this.postProcessBeanFactory(beanFactory);//也就是BeanFactoryPostProcessor里的模板空方法,子类实现，springboot用到
                this.invokeBeanFactoryPostProcessors(beanFactory);//实例化和调用所有的BeanFactoryPostProcessor
                this.registerBeanPostProcessors(beanFactory);//实例化和注册所有的BeanPostProcessor
                this.initMessageSource();//国际化处理
                this.initApplicationEventMulticaster();//初始化多播器
                this.onRefresh();
                this.registerListeners();//初始化监听器
                this.finishBeanFactoryInitialization(beanFactory);//实例化所有非懒加载对象
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }
	
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        /**代码已简化**/
		//实例化所有单例非懒加载对象
        beanFactory.preInstantiateSingletons();
    }

DefaultListableBeanFactory.java

public void preInstantiateSingletons() throws BeansException {
	List<String> beanNames = new ArrayList(this.beanDefinitionNames);
    Iterator var2 = beanNames.iterator();
	//循环代码省略
	this.getBean(beanName);
		
}

AbstractBeanFactory.java

public Object getBean(String name) throws BeansException {
        return this.doGetBean(name, (Class)null, (Object[])null, false);
    }
	

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
	String beanName = this.transformedBeanName(name);
	Object sharedInstance = this.getSingleton(beanName);//去单例池或者缓存中查看是否有对象
	Object bean;
	//只看单例
	if (mbd.isSingleton()) {
		sharedInstance = this.getSingleton(beanName, () -> {
			try {
				return this.createBean(beanName, mbd, args);
			} catch (BeansException var5) {
				this.destroySingleton(beanName);
				throw var5;
			}
		});
		bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
	}
	}

AbstractAutowireCapableBeanFactory.java

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        
        RootBeanDefinition mbdToUse = mbd;
        Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        Object beanInstance;
        /**....**/
		beanInstance = this.doCreateBean(beanName, mbdToUse, args);//创建对象
		
		return beanInstance;

    }
	
	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) 
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);        
        if (instanceWrapper == null) 
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);//创建对象
        
        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();        
        Object var7 = mbd.postProcessingLock;
        synchronized(mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable var17) {
                    
                }
                mbd.postProcessed = true;
            }
        }

        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);//判断是否循环引用
        if (earlySingletonExposure) {
			//加入正在创建的对象到缓存中
            this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
            });
        }
        Object exposedObject = bean;
        try {
            this.populateBean(beanName, mbd, instanceWrapper);//属性注入与填充
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);//调用后置处理器beafore 初始化Bean,调用后置处理器after
        } catch (Throwable var18) {
            
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = this.getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                    String[] dependentBeans = this.getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                    String[] var12 = dependentBeans;
                    int var13 = dependentBeans.length;

                    for(int var14 = 0; var14 < var13; ++var14) {
                        String dependentBean = var12[var14];
                        if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                }
            }
        }
        try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
        }
    }
	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        //........
		Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);//构造器
		if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
			ctors = mbd.getPreferredConstructors();
			return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);//反射实例化
		} else {
			return this.autowireConstructor(beanName, mbd, ctors, args);
		}
        
    }
	protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {//调用后置处理器beafore 初始化Bean,调用后置处理器after
        try {
            Object beanInstance;
            if (System.getSecurityManager() != null) {
                beanInstance = AccessController.doPrivileged(() -> {
                    return thisx.getInstantiationStrategy().instantiate(mbd, beanName, this);
                }, this.getAccessControlContext());
            } else {
                beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
            }

            BeanWrapper bw = new BeanWrapperImpl(beanInstance);
            this.initBeanWrapper(bw);
            return bw;
        } catch (Throwable var6) {
            
        }
    }
	
	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(() -> {
                this.invokeAwareMethods(beanName, bean);
                return null;
            }, this.getAccessControlContext());
        } else {
            this.invokeAwareMethods(beanName, bean);//调用Aware
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);//applyBeanPostProcessorsBeforeInitialization
        }

        try {
            this.invokeInitMethods(beanName, wrappedBean, mbd);//init
        } catch (Throwable var6) {
            
        }

        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);//applyBeanPostProcessorsBeforeInitialization
        }

        return wrappedBean;
    }

SimpleInstantiationStrategy.java

//反射实例化代码
	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
        if (!bd.hasMethodOverrides()) {
            Object var5 = bd.constructorArgumentLock;
            Constructor constructorToUse;
            synchronized(bd.constructorArgumentLock) {
                constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse == null) {
                    Class<?> clazz = bd.getBeanClass();
                    if (clazz.isInterface()) {
                        throw new BeanInstantiationException(clazz, "Specified class is an interface");
                    }

                    try {
                        if (System.getSecurityManager() != null) {
                            clazz.getClass();
                            constructorToUse = (Constructor)AccessController.doPrivileged(() -> {
                                return clazz.getDeclaredConstructor();
                            });
                        } else {
                            constructorToUse = clazz.getDeclaredConstructor();
                        }

                        bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                    } catch (Throwable var9) {
                        throw new BeanInstantiationException(clazz, "No default constructor found", var9);
                    }
                }
            }

            return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
        } else {
            return this.instantiateWithMethodInjection(bd, beanName, owner);
        }
    }
	

DefaultSingletonBeanRegistry.java

@Nullable
public Object getSingleton(String beanName) {
    return this.getSingleton(beanName, true);
}

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

    return singletonObject;
}


protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    Map var3 = this.singletonObjects;
    synchronized(this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }

    }
}

IndexService construct.....
IndexService call aware callback
postProcessBeforeInitialization indexService
IndexService init....
postProcessAfterInitialization indexService