网站透明导航代码,wordpress开头空两格,莱州网站建设公司,六安网事前言之前分析了Spring XML和注解的解析原理#xff0c;并将其封装为BeanDefinition对象存放到IOC容器中#xff0c;而这些只是refresh方法中的其中一个步骤——obtainFreshBeanFactory#xff0c;接下来就将围绕这这些BeanDefinition对象进行一系列的处理#xff0c;如Bean…前言之前分析了Spring XML和注解的解析原理并将其封装为BeanDefinition对象存放到IOC容器中而这些只是refresh方法中的其中一个步骤——obtainFreshBeanFactory接下来就将围绕这这些BeanDefinition对象进行一系列的处理如BeanDefinitionRegistryPostProcessor对象方法的调用、BeanFactoryPostProcessor对象方法的调用以及Bean实例的创建都离不开这些BeanDefinition对象。下面就来看看Spring是如何处理这些对象的。正文环境准备首先我们先回忆下refresh方法public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {//为容器初始化做准备prepareRefresh();// 解析xml和注解ConfigurableListableBeanFactory beanFactory obtainFreshBeanFactory();// 给BeanFacory设置属性值以及添加一些处理器即准备Spring的上下文环境prepareBeanFactory(beanFactory);try {// 由子类实现对BeanFacoty的一些后置处理postProcessBeanFactory(beanFactory);/** BeanDefinitionRegistryPostProcessor* BeanFactoryPostProcessor* 完成对这两个接口的调用* */invokeBeanFactoryPostProcessors(beanFactory);/** 把实现了BeanPostProcessor接口的类实例化并且加入到BeanFactory中* */registerBeanPostProcessors(beanFactory);/** 国际化* */initMessageSource();//初始化事件管理类initApplicationEventMulticaster();//这个方法着重理解模板设计模式因为在springboot中这个方法是用来做内嵌tomcat启动的onRefresh();/** 往事件管理类中注册事件类* */registerListeners();/** 1、bean实例化过程* 2、依赖注入* 3、注解支持* 4、BeanPostProcessor的执行* 5、Aop的入口** */finishBeanFactoryInitialization(beanFactory);// Last step: publish corresponding event.finishRefresh();} finally {resetCommonCaches();}}}prepareBeanFactory和postProcessBeanFactory没什么复杂的关注一下里面设置了哪些值添加了哪些对象就行这些东西在后面的流程中会起到作用。尤其是postProcessBeanFactory这是一个模板方法在其子类AbstractRefreshableWebApplicationContext中设置了两个重要的标识protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {// 主要看着里面beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));beanFactory.ignoreDependencyInterface(ServletContextAware.class);beanFactory.ignoreDependencyInterface(ServletConfigAware.class);WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);}public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {Assert.notNull(beanPostProcessor, BeanPostProcessor must not be null);// Remove from old position, if anythis.beanPostProcessors.remove(beanPostProcessor);// Track whether it is instantiation/destruction awareif (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {this.hasInstantiationAwareBeanPostProcessors true;}if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {this.hasDestructionAwareBeanPostProcessors true;}// Add to end of listthis.beanPostProcessors.add(beanPostProcessor);}分别将hasInstantiationAwareBeanPostProcessors、hasDestructionAwareBeanPostProcessors属性都设置成了true可以猜一下它们有什么作用。两个重要的Processor在将上下文环境设置完成后就是通过invokeBeanFactoryPostProcessors方法完成对BeanDefinitionRegistry以及BeanFactory的后置处理器的处理和调用也就是依次调用BeanDefinitionRegistryPostProcessor接口和BeanFactoryPostProcessor接口的实现类。我们可以通过实现这两个接口在在BeanDefinition注册完成后对象实例化之前对容器中的BeanDefinition进行动态的增删查改比如Spring中Configuration注解的解析就是在这个过程中实现的。我们先来了解一下Spring内置的Processor实现有哪些整个体系需要有个大概的印象其中重点关注ConfigurationClassPostProcessor类该类就是完成对Configuration、Bean等注解的解析注册这一块的源码这里暂时不分析。继续开始的流程进入到invokeBeanFactoryPostProcessors方法protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {// getBeanFactoryPostProcessors方法一般是获取不到值的除非我们手动调用addBeanFactoryPostProcessor方法添加进去// 换言之我们可以通过注解Component或是手动调用addBeanFactoryPostProcessor方法来注入BeanFactoryPostProcessors对象PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());省略......}这里面 通过委托模式调用PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors方法并传入了BeanFactory和Processors对象但需要注意getBeanFactoryPostProcessors方法不是获取通过xml配置和Component注解注册到容器中的Processor对象而是获取通过调用AbstractApplicationContext.addBeanFactoryPostProcessor方法添加的类换言之我们实现了Processor接口后可以不在类上添加Component直接调用addBeanFactoryPostProcessor方法即可但需要注意这种方式并没有对应的BeanDefinition类添加的对象也不存在于IOC容器中。继续进入invokeBeanFactoryPostProcessors方法public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, ListBeanFactoryPostProcessor beanFactoryPostProcessors) {// Invoke BeanDefinitionRegistryPostProcessors first, if any.SetString processedBeans new HashSet();if (beanFactory instanceof BeanDefinitionRegistry) {BeanDefinitionRegistry registry (BeanDefinitionRegistry) beanFactory;ListBeanFactoryPostProcessor regularPostProcessors new ArrayList();ListBeanDefinitionRegistryPostProcessor registryProcessors new ArrayList();// 优先处理通过addBeanFactoryPostProcessor方法添加的BeanFactoryPostProcessorfor (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {// 优先处理BeanDefinitionRegistryPostProcessor对象if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {BeanDefinitionRegistryPostProcessor registryProcessor (BeanDefinitionRegistryPostProcessor) postProcessor;registryProcessor.postProcessBeanDefinitionRegistry(registry);registryProcessors.add(registryProcessor);}else {regularPostProcessors.add(postProcessor);}}ListBeanDefinitionRegistryPostProcessor currentRegistryProcessors new ArrayList();//获取实现了BeanDefinitionRegistryPostProcessor接口的所有类的BeanDefinition对象的beanNameString[] postProcessorNames beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {//判断是否实现了排序接口 PriorityOrderedif (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);}}//排序sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);//调用过程invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.postProcessorNames beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {//判断是否是实现的Ordered接口if (!processedBeans.contains(ppName) beanFactory.isTypeMatch(ppName, Ordered.class)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);}}sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();//没实现排序接口的调用boolean reiterate true;while (reiterate) {reiterate false;postProcessorNames beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (!processedBeans.contains(ppName)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);reiterate true;}}sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);//invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);currentRegistryProcessors.clear();}//调用postProcessBeanFactory方法invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);}else {// Invoke factory processors registered with the context instance.invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);}//获取实现了BeanFactoryPostProcessor接口的类获取beanDefinition的名称String[] postProcessorNames beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);ListBeanFactoryPostProcessor priorityOrderedPostProcessors new ArrayList();ListString orderedPostProcessorNames new ArrayList();ListString nonOrderedPostProcessorNames new ArrayList();for (String ppName : postProcessorNames) {if (processedBeans.contains(ppName)) {// skip - already processed in first phase above}//实现了PriorityOrdered接口的else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));}//实现了Ordered接口的else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}else {//没实现接口的nonOrderedPostProcessorNames.add(ppName);}}//排序// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.sortPostProcessors(priorityOrderedPostProcessors, beanFactory);//调用invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);// Next, invoke the BeanFactoryPostProcessors that implement Ordered.ListBeanFactoryPostProcessor orderedPostProcessors new ArrayList();for (String postProcessorName : orderedPostProcessorNames) {orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}sortPostProcessors(orderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);ListBeanFactoryPostProcessor nonOrderedPostProcessors new ArrayList();for (String postProcessorName : nonOrderedPostProcessorNames) {nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);beanFactory.clearMetadataCache();}这个方法很长但逻辑并不复杂。首先判断传入的BeanFactory对象是不是BeanDefinitionRegistry对象是的话则优先调用传入的Processor对象的postProcessBeanDefinitionRegistry方法之后再通过beanFactory.getBeanNamesForType拿到容器中所有BeanDefinitionRegistryPostProcessor实现类的名字然后依次实例化并调用实现了PriorityOrdered、Ordered接口前者优先级高于后者数字越小优先级越高的Processor的postProcessBeanDefinitionRegistry方法最后再实例化并调用剩余未实现排序接口的Processor的方法。当所有BeanDefinitionRegistryPostProcessor实现类调用完成后会依次调用来自于父接口BeanFactoryPostProcessor的postProcessBeanFactory方法。上述流程处理完成后又会通过beanFactory.getBeanNamesForType拿到容器中所有BeanFactoryPostProcessor实现类的名字处理流程和上面一样。注册BeanPostProcessor对象以上就是两个扩展点的调用流程完成之后又会调用registerBeanPostProcessors注册所有BeanPostProcessor的子类到容器中来这个接口也是Spring的一个重要的扩展点它包含了两个方法Nullabledefault Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {return bean;}Nullabledefault Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {return bean;}实现了该接口的对象在实例化之前和之后分别会调用这两个方法。同样我们先来了解下该接口的继承体系可以看到这个接口Spring内置的实现就比较多可见用途之广泛。另外上面画红框的是本次需要重点记忆的类后面Bean实例化时会出现。接着我们来看看registerBeanPostProcessors的实现逻辑public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {//拿到工程里面所有实现了BeanPostProcessor接口的类获取到BeanDefinition的名称String[] postProcessorNames beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);int beanProcessorTargetCount beanFactory.getBeanPostProcessorCount() 1 postProcessorNames.length;beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));ListBeanPostProcessor priorityOrderedPostProcessors new ArrayList();ListBeanPostProcessor internalPostProcessors new ArrayList();ListString orderedPostProcessorNames new ArrayList();ListString nonOrderedPostProcessorNames new ArrayList();//提前实例化BeanPostProcessor类型的bean然后bean进行排序for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {//getBean是实例化方法后面我们在讲bean实例化过程是会着重讲到BeanPostProcessor pp beanFactory.getBean(ppName, BeanPostProcessor.class);priorityOrderedPostProcessors.add(pp);//判断类型是否是MergedBeanDefinitionPostProcessor如果是则代码是内部使用的if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}else {nonOrderedPostProcessorNames.add(ppName);}}// First, register the BeanPostProcessors that implement PriorityOrdered.sortPostProcessors(priorityOrderedPostProcessors, beanFactory);//注册到BeanFactory中registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);// Next, register the BeanPostProcessors that implement Ordered.ListBeanPostProcessor orderedPostProcessors new ArrayList();for (String ppName : orderedPostProcessorNames) {BeanPostProcessor pp beanFactory.getBean(ppName, BeanPostProcessor.class);orderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}sortPostProcessors(orderedPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, orderedPostProcessors);// Now, register all regular BeanPostProcessors.ListBeanPostProcessor nonOrderedPostProcessors new ArrayList();for (String ppName : nonOrderedPostProcessorNames) {BeanPostProcessor pp beanFactory.getBean(ppName, BeanPostProcessor.class);nonOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);// Finally, re-register all internal BeanPostProcessors.sortPostProcessors(internalPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, internalPostProcessors);// Re-register post-processor for detecting inner beans as ApplicationListeners,// moving it to the end of the processor chain (for picking up proxies etc).beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));}这段代码的实现逻辑也很简单也是先区分优先级再获取Bean实例最后注册到容器中等到Bean实例化时调用。接下来在refresh方法中调用了initMessageSource、initApplicationEventMulticaster、onRefresh、registerListeners分别是初始化国际化资源、初始化时间广播器、容器刷新事件子类回调、注册监听器这几个方法都很简单自己看看就行这里就不详细阐述了。Bean对象的创建当所有的准备工作都做好后就该开始初始化Bean实例了也就是finishBeanFactoryInitialization方法所做的事。不过这里可不是根据BeanDefinition new一个对象就完了它包含了以下几个工作初始化实例解析PostConstructPreDestroyResource AutowiredValue等注解依赖注入调用BeanPostProcessor方法AOP入口本篇暂不分析下面就来详细分析Bean实例化的整个流程protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {......//重点看这个方法// Instantiate all remaining (non-lazy-init) singletons.beanFactory.preInstantiateSingletons();}public void preInstantiateSingletons() throws BeansException {if (logger.isTraceEnabled()) {logger.trace(Pre-instantiating singletons in this);}// Iterate over a copy to allow for init methods which in turn register new bean definitions.// While this may not be part of the regular factory bootstrap, it does otherwise work fine.// xml解析时讲过把所有beanName都缓存到beanDefinitionNames了ListString beanNames new ArrayList(this.beanDefinitionNames);// Trigger initialization of all non-lazy singleton beans...for (String beanName : beanNames) {// 把父BeanDefinition里面的属性拿到子BeanDefinition中RootBeanDefinition bd getMergedLocalBeanDefinition(beanName);//如果不是抽象的单例的非懒加载的就实例化if (!bd.isAbstract() bd.isSingleton() !bd.isLazyInit()) {//判断bean是否实现了FactoryBean接口这里可以不看if (isFactoryBean(beanName)) {Object bean getBean(FACTORY_BEAN_PREFIX beanName);if (bean instanceof FactoryBean) {final FactoryBean? factory (FactoryBean?) bean;boolean isEagerInit;if (System.getSecurityManager() ! null factory instanceof SmartFactoryBean) {isEagerInit AccessController.doPrivileged((PrivilegedActionBoolean)((SmartFactoryBean?) factory)::isEagerInit,getAccessControlContext());}else {isEagerInit (factory instanceof SmartFactoryBean ((SmartFactoryBean?) factory).isEagerInit());}if (isEagerInit) {getBean(beanName);}}}else {//主要从这里进入看看实例化过程getBean(beanName);}}}}在preInstantiateSingletons方法中可以看到这里有一个判断单例、非懒加载、非抽象满足这三个条件才会调用getBeanBean实例化都是通过调用该方法实现的实例化public Object getBean(String name) throws BeansException {return doGetBean(name, null, null, false);}protected T T doGetBean(final String name, Nullable final ClassT requiredType,Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {final String beanName transformedBeanName(name);System.out.println(beanNamebeanNameinstance begin);Object bean;//从缓存中拿实例Object sharedInstance getSingleton(beanName);//如果缓存里面能拿到实例if (sharedInstance ! null args null) {// 该方法是FactoryBean接口的调用入口bean getObjectForBeanInstance(sharedInstance, name, beanName, null);}else {//如果缓存里面没有则走下来//如果是scope 是Prototype的校验是否有出现循环依赖如果有则直接报错if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);}BeanFactory parentBeanFactory getParentBeanFactory();if (parentBeanFactory ! null !containsBeanDefinition(beanName)) {// Not found - check parent.String nameToLookup originalBeanName(name);if (parentBeanFactory instanceof AbstractBeanFactory) {return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);}else if (args ! null) {// Delegation to parent with explicit args.return (T) parentBeanFactory.getBean(nameToLookup, args);}else if (requiredType ! null) {// No args - delegate to standard getBean method.return parentBeanFactory.getBean(nameToLookup, requiredType);}else {return (T) parentBeanFactory.getBean(nameToLookup);}}if (!typeCheckOnly) {markBeanAsCreated(beanName);}try {// 父子BeanDefinition合并final RootBeanDefinition mbd getMergedLocalBeanDefinition(beanName);// 检验是不是抽象类是直接抛出异常checkMergedBeanDefinition(mbd, beanName, args);// 获取依赖对象属性依赖对象要先实例化// Guarantee initialization of beans that the current bean depends on.String[] dependsOn mbd.getDependsOn();if (dependsOn ! null) {for (String dep : dependsOn) {if (isDependent(beanName, dep)) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,Circular depends-on relationship between beanName and dep );}registerDependentBean(dep, beanName);try {//实例化getBean(dep);}catch (NoSuchBeanDefinitionException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, beanName depends on missing bean dep , ex);}}}//大部分是单例的情况if (mbd.isSingleton()) {sharedInstance getSingleton(beanName, () - {try {return createBean(beanName, mbd, args);}});// 该方法是FactoryBean接口的调用入口bean getObjectForBeanInstance(sharedInstance, name, beanName, mbd);}else if (mbd.isPrototype()) {// Its a prototype - create a new instance.Object prototypeInstance null;try {beforePrototypeCreation(beanName);prototypeInstance createBean(beanName, mbd, args);}finally {afterPrototypeCreation(beanName);}// 该方法是FactoryBean接口的调用入口bean getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);}else {String scopeName mbd.getScope();final Scope scope this.scopes.get(scopeName);if (scope null) {throw new IllegalStateException(No Scope registered for scope name scopeName );}try {Object scopedInstance scope.get(beanName, () - {beforePrototypeCreation(beanName);try {return createBean(beanName, mbd, args);}finally {afterPrototypeCreation(beanName);}});// 该方法是FactoryBean接口的调用入口bean getObjectForBeanInstance(scopedInstance, name, beanName, mbd);}}}}return (T) bean;}这段代码首先从缓存里面拿到单例对象如果没有则通过scope类型去创建对应的Bean实例直接创建或是通过getObjectForBeanInstance调用FactoryBean接口的方法创建。在创建对象之前如果scope是prototype类型的首先会通过isPrototypeCurrentlyInCreation检验是否存在循环依赖循环依赖这里先不讲存在直接抛出异常原型对象不允许有循环依赖出现校验完成后还会通过mbd.getDependsOn拿到DependsOn注解的值如果有则会优先实例化依赖的对象。因为大部分都是创建单例对象所以下面我以getSingleton方法来分析需要注意该方法传入了一个Lambda表达式在该表达式中调用了createBean方法观察其它scope创建bean会发现都调用了该方法所以实际创建bean对象就是该方法不过我们还是先进入getSingleton方法看看做了些什么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) {if (this.singletonsCurrentlyInDestruction) {throw new BeanCreationNotAllowedException(beanName,Singleton bean creation not allowed while singletons of this factory are in destruction (Do not request a bean from a BeanFactory in a destroy method implementation!));}if (logger.isDebugEnabled()) {logger.debug(Creating shared instance of singleton bean beanName );}// 把beanName添加到singletonsCurrentlyInCreation Set容器中在这个集合里面的bean都是正在实例化的beanbeforeSingletonCreation(beanName);boolean newSingleton false;boolean recordSuppressedExceptions (this.suppressedExceptions null);if (recordSuppressedExceptions) {this.suppressedExceptions new LinkedHashSet();}try {// 如果这里有返回值就代表这个bean已经结束创建了已经完全创建成功singletonObject singletonFactory.getObject();newSingleton true;}finally {if (recordSuppressedExceptions) {this.suppressedExceptions null;}//bean创建完成后singletonsCurrentlyInCreation要删除该beanafterSingletonCreation(beanName);}if (newSingleton) {System.out.println(beanName beanName instance end);// 创建对象成功时把对象缓存到singletonObjects缓存中,bean创建完成时放入一级缓存addSingleton(beanName, singletonObject);}}return singletonObject;}}这个方法里面首先是从缓存中获取对象如果有直接返回如果没有则将该对象的beanName加入到singletonsCurrentlyInCreation缓存中如果添加不成功说明已经有其它地方正在创建该对象当前创建直接抛出异常如果添加成功则调用singletonFactory.getObject去创建对象这个方法就是传入的Lambda表达式创建完成后删除掉singletonsCurrentlyInCreation缓存中的值并将对象添加到一级缓存后续需要该对象时都是从一级缓存中获取的。在getObject中通过createBean去创建对象而该方法又调用了doCreateBean我们直接来看这个方法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) {//创建实例,,重点看instanceWrapper createBeanInstance(beanName, mbd, args);}final Object bean instanceWrapper.getWrappedInstance();Class? beanType instanceWrapper.getWrappedClass();if (beanType ! NullBean.class) {mbd.resolvedTargetType beanType;}synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {// Bean实例化完成后收集类中的注解PostConstructPreDestroyResource AutowiredValueapplyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}catch (Throwable ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,Post-processing of merged bean definition failed, ex);}mbd.postProcessed true;}}// 单例bean提前暴露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 {// ioc di依赖注入的核心方法populateBean(beanName, mbd, instanceWrapper);// bean 实例化ioc依赖注入完以后的调用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);}}if (earlySingletonExposure) {Object earlySingletonReference getSingleton(beanName, false);if (earlySingletonReference ! null) {if (exposedObject bean) {exposedObject earlySingletonReference;}else if (!this.allowRawInjectionDespiteWrapping hasDependentBean(beanName)) {String[] dependentBeans getDependentBeans(beanName);SetString actualDependentBeans new LinkedHashSet(dependentBeans.length);for (String dependentBean : dependentBeans) {if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {actualDependentBeans.add(dependentBean);}}}}}// Register bean as disposable.try {//注册bean销毁时的类DisposableBeanAdapterregisterDisposableBeanIfNecessary(beanName, bean, mbd);}return exposedObject;}这个方法里面首先去通过createBeanInstance创建对象的实例创建完成后又通过applyMergedBeanDefinitionPostProcessors收集类中的注解Autowired、Value、PostConstructPreDestroyResource准备依赖注入或是方法调用紧接着调用addSingletonFactory添加三级缓存处理循环依赖之后通过populateBean依赖注入真正完成一个完整对象的创建最后在initializeBean中触发事件和一些方法的调用。下面逐个分析这些方法。createBeanInstanceprotected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Nullable Object[] args) {// Make sure bean class is actually resolved at this point.//反射拿到Class对象Class? beanClass resolveBeanClass(mbd, beanName);if (beanClass ! null !Modifier.isPublic(beanClass.getModifiers()) !mbd.isNonPublicAccessAllowed()) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,Bean class isnt public, and non-public access not allowed: beanClass.getName());}Supplier? instanceSupplier mbd.getInstanceSupplier();if (instanceSupplier ! null) {return obtainFromSupplier(instanceSupplier, beanName);}// 在xml配置bean时指定factory-bean属性和factory-method以及Bean注解if (mbd.getFactoryMethodName() ! null) {return instantiateUsingFactoryMethod(beanName, mbd, args);}// Candidate constructors for autowiring?//寻找当前正在实例化的bean中有Autowired注解的构造函数Constructor?[] ctors determineConstructorsFromBeanPostProcessors(beanClass, beanName);if (ctors ! null || mbd.getResolvedAutowireMode() AUTOWIRE_CONSTRUCTOR ||mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {//如果ctors不为空就说明构造函数上有Autowired注解return autowireConstructor(beanName, mbd, ctors, args);}// Preferred constructors for default construction?ctors mbd.getPreferredConstructors();if (ctors ! null) {return autowireConstructor(beanName, mbd, ctors, null);}//无参构造函数的实例化,大部分的实例是采用的无参构造函数的方式实例化// No special handling: simply use no-arg constructor.return instantiateBean(beanName, mbd);}在这个方法里面又做了很多判断首先是拿到factoryMethodName当我们在xml配置bean时指定了factory-bean属性和factory-method属性或者是使用了Bean注解时这里就会拿到值然后就会通过FactoryMethod去创建一个实例对象如果不存在factoryMethodName那么就需要通过构造函数来实例化对象但构造函数上可能存在注解Autowired因此需要通过determineConstructorsFromBeanPostProcessors获取到所有带Autowired注解的构造函数protected Constructor?[] determineConstructorsFromBeanPostProcessors(Nullable Class? beanClass, String beanName)throws BeansException {/*** 通过AutowiredAnnotationBeanPostProcessor在component-scan解析时* 通过registerComponents方法注册的然后又在refresh中调用registerBeanPostProcessors方法* 实例化的类找到标记了Autowired注解的构造函数*/if (beanClass ! null hasInstantiationAwareBeanPostProcessors()) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {SmartInstantiationAwareBeanPostProcessor ibp (SmartInstantiationAwareBeanPostProcessor) bp;Constructor?[] ctors ibp.determineCandidateConstructors(beanClass, beanName);if (ctors ! null) {return ctors;}}}}return null;}拿到所有带Autowired注解的构造函数后就是通过调用autowireConstructor来进行实例化具体则是通过委托给ConstructorResolver类进行处理包括上面通过factoryMethod创建对象也是委托给这个类。如果没有带Autowired的构造函数才会调用instantiateBean方法利用反射通过无参构造函数去创建对象并返回也是大部分对象实例化所走的流程。至此简单对象的实例化完成。addSingletonFactory这个方法就是添加三级缓存解决循环依赖问题暂时不分析。populateBeanprotected void populateBean(String beanName, RootBeanDefinition mbd, Nullable BeanWrapper bw) {boolean continueWithPropertyPopulation true;// 这里可以写接口可以让所有类都不能依赖注入没有什么实际作用if (!mbd.isSynthetic() hasInstantiationAwareBeanPostProcessors()) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp (InstantiationAwareBeanPostProcessor) bp;if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {//是否需要DI依赖注入continueWithPropertyPopulation false;break;}}}}if (!continueWithPropertyPopulation) {return;}PropertyValues pvs (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);if (mbd.getResolvedAutowireMode() AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() AUTOWIRE_BY_TYPE) {MutablePropertyValues newPvs new MutablePropertyValues(pvs);// Add property values based on autowire by name if applicable.if (mbd.getResolvedAutowireMode() AUTOWIRE_BY_NAME) {autowireByName(beanName, mbd, bw, newPvs);}// Add property values based on autowire by type if applicable.if (mbd.getResolvedAutowireMode() AUTOWIRE_BY_TYPE) {autowireByType(beanName, mbd, bw, newPvs);}pvs newPvs;}boolean hasInstAwareBpps hasInstantiationAwareBeanPostProcessors();boolean needsDepCheck (mbd.getDependencyCheck() ! AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);PropertyDescriptor[] filteredPds null;//重点看这个if代码块if (hasInstAwareBpps) {if (pvs null) {pvs mbd.getPropertyValues();}for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp (InstantiationAwareBeanPostProcessor) bp;//依赖注入过程Autowired的支持PropertyValues pvsToUse ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);if (pvsToUse null) {if (filteredPds null) {filteredPds filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}//老版本用这个完成依赖注入过程Autowired的支持pvsToUse ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);if (pvsToUse null) {return;}}pvs pvsToUse;}}}if (needsDepCheck) {if (filteredPds null) {filteredPds filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}checkDependencies(beanName, mbd, filteredPds, pvs);}// xml中property标签的依赖注入if (pvs ! null) {applyPropertyValues(beanName, mbd, bw, pvs);}}这里面主要有三个方法是完成依赖注入的postProcessProperties当前主要使用、postProcessPropertyValues老版本废弃API、applyPropertyValuesxml中property标签。所以主要看看postProcessProperties方法而这个方法又是来自于InstantiationAwareBeanPostProcessor接口希望你还记得这个接口的继承体系主要看看AutowiredAnnotationBeanPostProcessor这个就是解决Autowired依赖注入的。public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {InjectionMetadata metadata findAutowiringMetadata(beanName, bean.getClass(), pvs);try {metadata.inject(bean, beanName, pvs);}return pvs;}见名知意findAutowiringMetadata方法就是拿到Autowired注解的属性并封装为InjectionMetadata对象再调用inject进行依赖注入注意这里是包含了属性和方法的方法也不一定是setter方法才可以只要是标记了Autowired且参数类型正确都能依赖成功。这就是Autowired的注入过程另外还有Resource的注入在CommonAnnotationBeanPostProcessor类中流程和这个基本一样这里就不阐述了。initializeBean以上过程都是对Bean的实例化以及对象中属性的注入都完成过后这个Bean对象才是我们真正可以直接使用的对象所以接着就是处理一些方法的调用了包含一些事件通知。protected Object initializeBean(final String beanName, final Object bean, Nullable RootBeanDefinition mbd) {if (System.getSecurityManager() ! null) {AccessController.doPrivileged((PrivilegedActionObject) () - {invokeAwareMethods(beanName, bean);return null;}, getAccessControlContext());}else {// 调用Aware方法invokeAwareMethods(beanName, bean);}Object wrappedBean bean;if (mbd null || !mbd.isSynthetic()) {//对类中某些特殊方法的调用比如PostConstructAware接口wrappedBean applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);}try {//InitializingBean接口afterPropertiesSetinit-method属性调用,非常重要invokeInitMethods(beanName, wrappedBean, mbd);}if (mbd null || !mbd.isSynthetic()) {// 这个地方可能生出代理实例是aop的入口wrappedBean applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);}return wrappedBean;}private void invokeAwareMethods(final String beanName, final Object bean) {if (bean instanceof Aware) {// 实现该接口可以在bean实例化完成后获取到bean的名称if (bean instanceof BeanNameAware) {((BeanNameAware) bean).setBeanName(beanName);}// 实现该接口可以在bean实例化完成后获取到当前的类加载器if (bean instanceof BeanClassLoaderAware) {ClassLoader bcl getBeanClassLoader();if (bcl ! null) {((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);}}// 实现该接口可以在bean实例化完成后获取到当前的AbstractAutowireCapableBeanFactory对象if (bean instanceof BeanFactoryAware) {((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);}}}首先是Aware接口的方法调用这个很简单不多说。接着就是applyBeanPostProcessorsBeforeInitialization方法调用这个就是BeanPostProcessor接口的postProcessBeforeInitialization方法调用看到这里你是否会发现自己之前理解错了呢因为该方法是在对象实例化之前调用实际上也是实例化完成之后public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)throws BeansException {Object result existingBean;for (BeanPostProcessor processor : getBeanPostProcessors()) {Object current processor.postProcessBeforeInitialization(result, beanName);if (current null) {return result;}result current;}return result;}这里面着重看几个实现类的调用ApplicationContextAwareProcessorApplicationEventPublisherAware、ApplicationContextAware等Aware接口的调用、InitDestroyAnnotationBeanPostProcessorPostConstruct注解方法的调用、ImportAwareBeanPostProcessorImportAware类型实例setImportMetadata调用对理解SpringBoot帮助很大这里可以暂时不看。紧着着又通过invokeInitMethods方法调用InitializingBean接口的afterPropertiesSet方法以及init-method属性配置的自定义初始化方法。最后则是通过applyBeanPostProcessorsAfterInitialization方法调用BeanPostProcessor的postProcessAfterInitialization方法因为涉及到AOP知识这里不详细分析。至此Bean的整个实例化过程分析完成看到这里你应该对于Bean的生命周期函数有个基本的认识了最后放上我画的Bean实例化流程时序图总结本篇篇幅很长中间很多无关痛痒的代码我都省略掉了也有一些无关主流程但也比较重要的代码没有分析比如ConfigurationClassPostProcessor解析Configuration、Bean注解的过程FactoryMethod创建对象过程、获取Autowired注解标记的构造函数以及通过这些构造函数实例化过程我都没有分析一来是限于篇幅过长二来主要是因为对理解整个流程并没有太大作用并且代码相对更简单感兴趣的读者可在理解清楚主流程后自行分析。作者夜勿语原文链接https://blog.csdn.net/l6108003/article/details/106439525
