Spring 加载xml初始化bean流程分析（一）

叁歲伎倆 2022-12-07 13:52 256阅读 0赞

1、最近在复习基础，又过了一遍Spring思想，记录记录

package i.xuxie;
    
    import org.springframework.beans.factory.support.BeanDefinitionReader;
    import org.springframework.beans.factory.support.DefaultListableBeanFactory;
    import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
    import org.springframework.core.io.ClassPathResource;
    
    import java.io.IOException;
    
    /** * @author liupeng * @date 2020/9/7 11:40 * @mail xuxiejp@163.com * @desc ... * * Spring IOC 五步曲 * 1、创建资源读取配置接口 * 2、建立用于初始化类的beanFaction * 3、创建Reader,解析配置资源 * 4、Reader加载beanFaction，将解析的资源解析成bean装配到工厂 * 5、前四步将一个个配置类解析成BeanDefinition，放到DefaultListableBeanFactory.beanDefinitionMap * 6、 factory.getBean()的时候将BeanDefinition通过反射初始化，设置属性值，注入对象 */
    
    public class SpringMain { 
    
        public static void main(String[] args) throws IOException { 
    		// 1
            ClassPathResource classPathResource = new ClassPathResource("application.xml");
    		// 2
            DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    		// 3
            BeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
    		// 4
            reader.loadBeanDefinitions(classPathResource);
    		// 5
            Object student = factory.getBean("stuent");
    
        }
    }

2、一二三步没啥东西，暂看第四步，进入`XmlBeanDefinitionReader`

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { 
            Assert.notNull(encodedResource, "EncodedResource must not be null");
            if (this.logger.isTraceEnabled()) { 
                this.logger.trace("Loading XML bean definitions from " + encodedResource);
            }
    
            Set<EncodedResource> currentResources = (Set)this.resourcesCurrentlyBeingLoaded.get();
            if (currentResources == null) { 
                currentResources = new HashSet(4);
                this.resourcesCurrentlyBeingLoaded.set(currentResources);
            }
    
            if (!((Set)currentResources).add(encodedResource)) { 
                throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");
            } else { 
                int var6;
                try { 
                    InputStream inputStream = encodedResource.getResource().getInputStream();
                    Throwable var4 = null;
    
                    try { 
                        InputSource inputSource = new InputSource(inputStream);
                        if (encodedResource.getEncoding() != null) { 
                            inputSource.setEncoding(encodedResource.getEncoding());
                        }
    		//一般do开头的都是内部私有方法，下面这个见名知意 加载bean定义
                        var6 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
                    } catch (Throwable var24) { 
                        var4 = var24;
                        throw var24;
                    } finally { 
                        if (inputStream != null) { 
                            if (var4 != null) { 
                                try { 
                                    inputStream.close();
                                } catch (Throwable var23) { 
                                    var4.addSuppressed(var23);
                                }
                            } else { 
                                inputStream.close();
                            }
                        }
    
                    }
                } catch (IOException var26) { 
                    throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), var26);
                } finally { 
                    ((Set)currentResources).remove(encodedResource);
                    if (((Set)currentResources).isEmpty()) { 
                        this.resourcesCurrentlyBeingLoaded.remove();
                    }
    
                }
    
                return var6;
            }
        }

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { 
            try { 
            //将资源转化未 dom对象，方便解析
                Document doc = this.doLoadDocument(inputSource, resource);
            //解析dom对象，注册bean
                int count = this.registerBeanDefinitions(doc, resource);
                if (this.logger.isDebugEnabled()) { 
                    this.logger.debug("Loaded " + count + " bean definitions from " + resource);
                }
    
                return count;
            } catch (BeanDefinitionStoreException var5) { 
                throw var5;
            } catch (SAXParseException var6) { 
                throw new XmlBeanDefinitionStoreException(resource.getDescription(), "Line " + var6.getLineNumber() + " in XML document from " + resource + " is invalid", var6);
            } catch (SAXException var7) { 
                throw new XmlBeanDefinitionStoreException(resource.getDescription(), "XML document from " + resource + " is invalid", var7);
            } catch (ParserConfigurationException var8) { 
                throw new BeanDefinitionStoreException(resource.getDescription(), "Parser configuration exception parsing XML from " + resource, var8);
            } catch (IOException var9) { 
                throw new BeanDefinitionStoreException(resource.getDescription(), "IOException parsing XML document from " + resource, var9);
            } catch (Throwable var10) { 
                throw new BeanDefinitionStoreException(resource.getDescription(), "Unexpected exception parsing XML document from " + resource, var10);
            }

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { 
    	    //创建dom读取适配类
            BeanDefinitionDocumentReader documentReader = this.createBeanDefinitionDocumentReader();
            //加载之前工厂有多少bean
            int countBefore = this.getRegistry().getBeanDefinitionCount();
            //重头戏，见名 注册bean定义
            documentReader.registerBeanDefinitions(doc, this.createReaderContext(resource));
            //计算此次加载初始化了多少个类
            return this.getRegistry().getBeanDefinitionCount() - countBefore;
        }

protected void doRegisterBeanDefinitions(Element root) { 
            BeanDefinitionParserDelegate parent = this.delegate;
            // 委托模式。将dom委托给BeanDefinitionParserDelegate解析
            //有兴趣的可以看下这个类定义
            this.delegate = this.createDelegate(this.getReaderContext(), root, parent);
            if (this.delegate.isDefaultNamespace(root)) { 
                String profileSpec = root.getAttribute("profile");
                if (StringUtils.hasText(profileSpec)) { 
                    String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, ",; ");
                    if (!this.getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) { 
                        if (this.logger.isDebugEnabled()) { 
                            this.logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec + "] not matching: " + this.getReaderContext().getResource());
                        }
    
                        return;
                    }
                }
            }
    		//模板模式，前置处理，此处为空
            this.preProcessXml(root);
            //解析bean定义，go
            this.parseBeanDefinitions(root, this.delegate);
    		//后置处理，此处为空
            this.postProcessXml(root);
            this.delegate = parent;
        }

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { 
            if (delegate.isDefaultNamespace(root)) { 
    	        // 便利dom的每个节点
                NodeList nl = root.getChildNodes();
                for(int i = 0; i < nl.getLength(); ++i) { 
                    Node node = nl.item(i);
                    if (node instanceof Element) { 
                        Element ele = (Element)node;
                        //读取xml里面的<bean><beans><import>等标签
                        if (delegate.isDefaultNamespace(ele)) { 
                            this.parseDefaultElement(ele, delegate);
                        } else { 
                            delegate.parseCustomElement(ele);
                        }
                    }
                }
            } else { 
                delegate.parseCustomElement(root);
            }
    
        }
    
        private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { 
            if (delegate.nodeNameEquals(ele, "import")) { 
                this.importBeanDefinitionResource(ele);
            } else if (delegate.nodeNameEquals(ele, "alias")) { 
                this.processAliasRegistration(ele);
            } else if (delegate.nodeNameEquals(ele, "bean")) { 
                this.processBeanDefinition(ele, delegate);
            } else if (delegate.nodeNameEquals(ele, "beans")) { 
                this.doRegisterBeanDefinitions(ele);
            }
    
        }

**第四步结束**  
见名知 处理bean定义

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { 
        //将得到的<bean>里面的对象封装为BeanDefinitionHolder,有兴趣的可以看看
        //第四步就此完结，开始第五步
            BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
            if (bdHolder != null) { 
                bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
    
                try { 
                //注册bean定义，将holder对象注册
                    BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
                } catch (BeanDefinitionStoreException var5) { 
                    this.getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, var5);
                }
    
                this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
            }
    
        }

**第五步完结**

public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException { 
            String beanName = definitionHolder.getBeanName();
    		//将holder封装到DefaultListableBeanFactory的beanDefinitionMap
    		//第五步有说明，至此完
            registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
            String[] aliases = definitionHolder.getAliases();
            if (aliases != null) { 
                String[] var4 = aliases;
                int var5 = aliases.length;
    
                for(int var6 = 0; var6 < var5; ++var6) { 
                    String alias = var4[var6];
                    registry.registerAlias(beanName, alias);
                }
            }
    
        }

**第六步**

org.springframework.beans.factory.support.AbstractBeanFactory
    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;
           	略；
           	略；
          	try { 
    		      //从第五步的beanDefinitionMap中获取holder
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                  this.checkMergedBeanDefinition(mbd, beanName, args);
                  String[] dependsOn = mbd.getDependsOn();
                  String[] var11;
                  if (dependsOn != null) { 
                      var11 = dependsOn;
                      int var12 = dependsOn.length;
    
                      for(int var13 = 0; var13 < var12; ++var13) { 
                          String dep = var11[var13];
                          if (this.isDependent(beanName, dep)) { 
                              throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                          }
    
                          this.registerDependentBean(dep, beanName);
    
                          try { 
                              this.getBean(dep);
                          } catch (NoSuchBeanDefinitionException var24) { 
                              throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                          }
                      }
                  }
    			//如果是单例的就进，那肯定要进了
    			  if (mbd.isSingleton()) { 
    	                 sharedInstance = this.getSingleton(beanName, () -> { 
                         try { 
                         // 将holder创建成bean
                              return this.createBean(beanName, mbd, args);
                          } catch (BeansException var5) { 
                              this.destroySingleton(beanName);
                              throw var5;
                          }
                      });
                      // 特殊类处理 ，判断这个类是否是factionBean
                      //**锚点一**
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                    } else if{ 
    
    						略；
    
    				}

见名知 将创建bean

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { 
            if (this.logger.isTraceEnabled()) { 
                this.logger.trace("Creating instance of bean '" + beanName + "'");
            }
    
            RootBeanDefinition mbdToUse = mbd;
    		//将beanDefinition转class（最终落实ClassUtils.forName(className, classLoader);）
            Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
            if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 
                mbdToUse = new RootBeanDefinition(mbd);
                mbdToUse.setBeanClass(resolvedClass);
            }
    
            try { 
    	        //处理重载的方法
                mbdToUse.prepareMethodOverrides();
            } catch (BeanDefinitionValidationException var9) { 
                throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
            }
    
            Object beanInstance;
            try { 
            //处理bean的实例化前置处理
                beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
                if (beanInstance != null) { 
                    return beanInstance;
                }
            } catch (Throwable var10) { 
                throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
            }
    
            try { 
            //创建bean
                beanInstance = this.doCreateBean(beanName, mbdToUse, args);
                if (this.logger.isTraceEnabled()) { 
                    this.logger.trace("Finished creating instance of bean '" + beanName + "'");
                }
    
                return beanInstance;
            } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) { 
                throw var7;
            } catch (Throwable var8) { 
                throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
            }
        }

**org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory\#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) { 
    		//bean 初始化
    			instanceWrapper = createBeanInstance(beanName, mbd, args);
    		}
    				略；
    				
    		**锚点二**
    
    }

**org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory\#createBeanInstance**

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { 
    		// Make sure bean class is actually resolved at this point.
    		Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
    		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { 
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    		}
    
    		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    		if (instanceSupplier != null) { 
    			return obtainFromSupplier(instanceSupplier, beanName);
    		}
    		//判断是否是由@Bean方式初始化的类。注解加载的时候旧的这个方法
    		if (mbd.getFactoryMethodName() != null) { 
    			return instantiateUsingFactoryMethod(beanName, mbd, args);
    		}
    
    		// Shortcut when re-creating the same bean...
    		boolean resolved = false;
    		boolean autowireNecessary = false;
    		if (args == null) { 
    			synchronized (mbd.constructorArgumentLock) { 
    				if (mbd.resolvedConstructorOrFactoryMethod != null) { 
    					resolved = true;
    					autowireNecessary = mbd.constructorArgumentsResolved;
    				}
    			}
    		}
    		if (resolved) { 
    			if (autowireNecessary) { 
    				return autowireConstructor(beanName, mbd, null, null);
    			}
    			else { 
    				return instantiateBean(beanName, mbd);
    			}
    		}
    
    		// Candidate constructors for autowiring?
    		//判断由什么构造方法进行初始化
    		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
    				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { 
    			return autowireConstructor(beanName, mbd, ctors, args);
    		}
    
    		// Preferred constructors for default construction?
    	
    		ctors = mbd.getPreferredConstructors();
    		if (ctors != null) { 
    		//如果重写了构造器，就此进去
    			return autowireConstructor(beanName, mbd, ctors, null);
    		}
    
    		// 使用无参构造器，本文go here
    		return instantiateBean(beanName, mbd);
    	}

**org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory\#instantiateBean**

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) { 
    		try { 
    			Object beanInstance;
    			final BeanFactory parent = this;
    			if (System.getSecurityManager() != null) { 
    				beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
    						getInstantiationStrategy().instantiate(mbd, beanName, parent),
    						getAccessControlContext());
    			}
    			else { 
    			//初始化 （BeanUtils.instantiateClass(mbd.getBeanClass().getDeclaredConstructor())）
    				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
    			}
    			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    			initBeanWrapper(bw);
    			return bw;
    		}
    		catch (Throwable ex) { 
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    		}
    	}

**org.springframework.beans.factory.support.SimpleInstantiationStrategy\#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory)**

@Override
    	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) { 
    		// Don't override the class with CGLIB if no overrides.
    		//如果方法没有被重写，则反射生成，如果重写，则用cjlib方式，service就是cglib代理
    		if (!bd.hasMethodOverrides()) { 
    			Constructor<?> constructorToUse;
    			synchronized (bd.constructorArgumentLock) { 
    				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
    				if (constructorToUse == null) { 
    					final Class<?> clazz = bd.getBeanClass();
    					if (clazz.isInterface()) { 
    						throw new BeanInstantiationException(clazz, "Specified class is an interface");
    					}
    					try { 
    						if (System.getSecurityManager() != null) { 
    							constructorToUse = AccessController.doPrivileged(
    									(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
    						}
    						else { 
    							constructorToUse = clazz.getDeclaredConstructor();
    						}
    						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
    					}
    					catch (Throwable ex) { 
    						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
    					}
    				}
    			}
    			//constructorToUse.newInstance(argsWithDefaultValues)
    			return BeanUtils.instantiateClass(constructorToUse);
    		}
    		else { 
    			// Must generate CGLIB subclass.
    			return instantiateWithMethodInjection(bd, beanName, owner);
    		}
    	}

**至此，一个实例就算是生成，只是属性各方面还没赋值,返回数据到上文锚点二**

**锚点二**
    
    
    		// 处理类实例化之后的后置处理
    		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;
    			}
    		}
    		略；
    		Object exposedObject = bean;
    		try { 
    			//封装属性值，类属性赋值，自行查看
    			populateBean(beanName, mbd, instanceWrapper);
    			//初始化bean里面的方法（
    			//1、前置处理器（applyBeanPostProcessorsBeforeInitialization）
    			//2、初始化类方法（继承了InitializingBean）
    			//3、后置处理器（applyBeanPostProcessorsAfterInitialization）
    			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);
    			}
    		}
    		略；

**锚点一**

protected Object getObjectForBeanInstance(
    			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { 
    
    		// Don't let calling code try to dereference the factory if the bean isn't a factory.
    		//如果名字以&开头
    		if (BeanFactoryUtils.isFactoryDereference(name)) { 
    			if (beanInstance instanceof NullBean) { 
    				return beanInstance;
    			}
    			if (!(beanInstance instanceof FactoryBean)) { 
    				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
    			}
    			if (mbd != null) { 
    				mbd.isFactoryBean = true;
    			}
    			return beanInstance;
    		}
    
    		// Now we have the bean instance, which may be a normal bean or a FactoryBean.
    		// If it's a FactoryBean, we use it to create a bean instance, unless the
    		// caller actually wants a reference to the factory.
    		//如果bean不是FactoryBean实列
    		if (!(beanInstance instanceof FactoryBean)) { 
    			return beanInstance;
    		}
    		//比如该bean是TaskExecutorFactoryBean 实例，则入下面方法
    		Object object = null;
    		if (mbd != null) { 
    			mbd.isFactoryBean = true;
    		}
    		else { 
    			object = getCachedObjectForFactoryBean(beanName);
    		}
    		if (object == null) { 
    			// Return bean instance from factory.
    			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
    			// Caches object obtained from FactoryBean if it is a singleton.
    			if (mbd == null && containsBeanDefinition(beanName)) { 
    				mbd = getMergedLocalBeanDefinition(beanName);
    			}
    			boolean synthetic = (mbd != null && mbd.isSynthetic());
    			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    		}
    		return object;
    	}

至此一个bean 从xml解析到Faction，然后装配属性，初始化参数，整个过程都在这里面。下一篇将写SpringBoot 注解形式的bean加载