Spring5源码解析——第一部分

一、写在前面

        本文均为个人观点,如有错误,跪求指正,共同学习进步。此系列文章所涉及源码为spring-5.0.2.RELEASE版本。

二、梦开始的地方-spring容器启动

        无论阅读什么框架的源码,最好的方式就是从启动入口开始,逐步分析启动的阶段分别作了什么事情。对于spring,常见的启动方式为使用如下代码:

new ClassPathXmlApplicationContext("beans.xml");

        通过传入一个或者多个配置文件作为参数,来启动spring。我们不妨进入此构造方法查看查看:

public ClassPathXmlApplicationContext(String configLocation) 
throws BeansException {
		this(new String[] {configLocation}, true, null);
}

         可以发现,调用的是一个重载的构造方法,如下:

public ClassPathXmlApplicationContext(
	String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
	throws BeansException {
    //调用父类的构造函数,最终定位到AbstractApplicationContext,
    //主要是设置父context的逻辑,并且共享父context中的environment
	super(parent);
	//解析传入的资源路径
	setConfigLocations(configLocations);
	//定位到AbstractApplicationContext中的refresh()
	if (refresh) {
		refresh();
	}
}

        分为三部分:首先调用父类构造方法,处理如果有父容器的情况,其次解析传入的资源路径,最后调用刷新容器方法。

        我们一步步来看:

      1.super(parent)

                此方法我们一路追踪,最终定位到了ClassPathXmlApplicationContext继承链的AbstractApplicationContext类中,方法如下:

public AbstractApplicationContext() {
	this.resourcePatternResolver = getResourcePatternResolver();
}

/**
* Create a new AbstractApplicationContext with the given parent context.
* @param parent the parent context
*/
public AbstractApplicationContext(@Nullable ApplicationContext parent) {
	this();
	//设置父context
	setParent(parent);
}

@Override
public void setParent(@Nullable ApplicationContext parent) {
	this.parent = parent;
	//共享父context的环境信息
	if (parent != null) {
		Environment parentEnvironment = parent.getEnvironment();
		if (parentEnvironment instanceof ConfigurableEnvironment) {
			getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
		}
	}
}

可以看出,对于父容器,子容器所做的就是将父容器的环境配置信息进行合并。

2.setConfigLocations(configLocations)

紧接着便是解析启动spring容器时传入的配置文件名称,此方法是ClassPathXmlApplicationContext父类AbstractRefreshableConfigApplicationContext中定义的方法,内容如下:

public void setConfigLocation(String location){
    //String CONFIG_LOCATION_DELIMITERS = ",; \t\n";
    //按照分隔符组成一个string数组传入
    setConfigLocations(StringUtils.tokenizeToStringArray(location,
CONFIG_LOCATION_DELIMITERS));
}

public void setConfigLocations(@Nullable String... locations) {
	if (locations != null) {
		Assert.noNullElements(locations, "Config locations must not be null");
		this.configLocations = new String[locations.length];
        //循环遍历配置文件进行解析
		for (int i = 0; i < locations.length; i++) {
			this.configLocations[i] = resolvePath(locations[i]).trim();
		}
	}
	else {
		this.configLocations = null;
	}
}

protected String resolvePath(String path) {
	return getEnvironment().resolveRequiredPlaceholders(path);
}

如果传入多个配置文件,循环调用resolvePath方法进行解析,此方法中调用getEnvironment方法获取environment对象并调用解析方法,getEnvironment定义在继承链的AbstractApplicationContext类中:

@Override
public ConfigurableEnvironment getEnvironment() {
	if (this.environment == null) {
		this.environment = createEnvironment();
	}
	return this.environment;
}

protected ConfigurableEnvironment createEnvironment() {
	return new StandardEnvironment();
}

获得的其实是StandardEnvironment对象,然后调用此对象的resolveRequiredPlaceholders方法,跟踪代码可知,此方法定义在其父类AbstractEnvironment中,追踪最终调用链,锁定到PropertyPlaceholderHelper的replacePlaceholders方法:

	public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {
		//这里的placeholderResolver为AbstractPropertyResolver类调用时传入的
		//replacePlaceholders(text, this::getPropertyAsRawString);
		//而AbstractPropertyResolver的getPropertyAsRawString方法最终实现在
		//PropertySourcesPropertyResolver中
		Assert.notNull(value, "'value' must not be null");
		return parseStringValue(value, placeholderResolver, new HashSet<>());
	}

	protected String parseStringValue(
			String value, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {

		StringBuilder result = new StringBuilder(value);
		//placeholderPrefix的值为${,此类是在AbstractPropertyResolver类中创建的
		//当时传入的placeholderPrefix值为SystemPropertyUtils类中定义的前缀
		//用于解析${}表达式
		int startIndex = value.indexOf(this.placeholderPrefix);
		while (startIndex != -1) {
			int endIndex = findPlaceholderEndIndex(result, startIndex);
			if (endIndex != -1) {
				String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
				String originalPlaceholder = placeholder;
				if (!visitedPlaceholders.add(originalPlaceholder)) {
					throw new IllegalArgumentException(
							"Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
				}
				// Recursive invocation, parsing placeholders contained in the placeholder key.
				//如果有${}则将括号中的内容取出,递归调用解析
				placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
				// 此处最终调用的是PropertySourcesPropertyResolver类的getProperty方法
				String propVal = placeholderResolver.resolvePlaceholder(placeholder);
				if (propVal == null && this.valueSeparator != null) {
					//是否有:存在
					int separatorIndex = placeholder.indexOf(this.valueSeparator);
					if (separatorIndex != -1) {
						//将字符串从:分成两部分
						String actualPlaceholder = placeholder.substring(0, separatorIndex);
						String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
						//再次解析前半部分,如果也是null就赋默认值,也就是:后面跟的
						propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
						if (propVal == null) {
							propVal = defaultValue;
						}
					}
				}
				if (propVal != null) {
					// Recursive invocation, parsing placeholders contained in the
					// previously resolved placeholder value.
					//如果上面解析的${}中的内容不为空,则递归继续解析
					propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
					//最终将解析的值替换掉包括${}在内的内容
					result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
					if (logger.isTraceEnabled()) {
						logger.trace("Resolved placeholder '" + placeholder + "'");
					}
					//继续解析下一个${位置
					startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
				}
				else if (this.ignoreUnresolvablePlaceholders) {
					// Proceed with unprocessed value.
					//如果上面解析的值为null,即无法解析,此时判断是否需要忽略,如果是就继续解析下一个${位置
					startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
				}
				else {
					//如果不能忽略,就抛出异常
					throw new IllegalArgumentException("Could not resolve placeholder '" +
							placeholder + "'" + " in value \"" + value + "\"");
				}
				//将当前解析完成的占位符移除
				visitedPlaceholders.remove(originalPlaceholder);
			}
			else {
				//如果只有${而没有后半部分的},则直接取消解析,直接返回
				startIndex = -1;
			}
		}

		return result.toString();
	}

//PropertySourcesPropertyResolver类中的getProperty方法如下

@Nullable
	protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) {
		if (this.propertySources != null) {
			//此处我们并没有传入过任何的PropertySource,所以此方法最终返回null,因为我们传入的配置文件中并没有任何需要解析的内容
			for (PropertySource<?> propertySource : this.propertySources) {
				if (logger.isTraceEnabled()) {
					logger.trace("Searching for key '" + key + "' in PropertySource '" +
							propertySource.getName() + "'");
				}
				Object value = propertySource.getProperty(key);
				if (value != null) {
					if (resolveNestedPlaceholders && value instanceof String) {
						value = resolveNestedPlaceholders((String) value);
					}
					logKeyFound(key, propertySource, value);
					return convertValueIfNecessary(value, targetValueType);
				}
			}
		}
		if (logger.isDebugEnabled()) {
			logger.debug("Could not find key '" + key + "' in any property source");
		}
		return null;
	}

上面就是解析配置文件名称的代码内容,整体还是比较清晰的。

3.refresh()

refresh方法在AbstractApplicationContext类中实现,代码如下:

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
	// Prepare this context for refreshing.
	//主要是获取当前刷新时间,以及设置容器的同步标识
	prepareRefresh();

	// Tell the subclass to refresh the internal bean factory.
	//刷新beanFactory,调用子类的实现(委派模式,委派子类实现)
	ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

	// Prepare the bean factory for use in this context.
	//为beanFactory配置容器特性,如类加载器,事件处理器等
	prepareBeanFactory(beanFactory);

	    try {
		    // Allows post-processing of the bean factory in context subclasses.
		    //注册一些beanFactory的后置处理器
		    postProcessBeanFactory(beanFactory);

		    // Invoke factory processors registered as beans in the context.
		    //执行beanFactory的后置处理器回调
		    invokeBeanFactoryPostProcessors(beanFactory);

		    // Register bean processors that intercept bean creation.
		    //注册bean的后置处理器
		    registerBeanPostProcessors(beanFactory);

		    // Initialize message source for this context.
		    //初始化信息源(国际化相关)
		    initMessageSource();

		    // Initialize event multicaster for this context.
		    //初始化事件传播器
		    initApplicationEventMulticaster();

		    // Initialize other special beans in specific context subclasses.
		    //调用子类的某些特殊bean的初始化方法
		    onRefresh();

		    // Check for listener beans and register them.
		    //注册事件监听器
		    registerListeners();

		    // Instantiate all remaining (non-lazy-init) singletons.
		    //实例化其他所有的单例bean
		    finishBeanFactoryInitialization(beanFactory);

		    // Last step: publish corresponding event.
		    //发布一些事件
		    finishRefresh();
	    }

	    catch (BeansException ex) {
		    if (logger.isWarnEnabled()) {
			    logger.warn("Exception encountered during context initialization - " +
					    "cancelling refresh attempt: " + ex);
		    }

		    // Destroy already created singletons to avoid dangling resources.
		    //销毁所有的bean
		    destroyBeans();

		    // Reset 'active' flag.
		    //结束刷新方法,重置容器的同步标识
		    cancelRefresh(ex);
    
		    // Propagate exception to caller.
		    throw ex;
	    }

	    finally {
		    // Reset common introspection caches in Spring's core, since we
		    // might not ever need metadata for singleton beans anymore...
		    //重新设置公共缓存
		    resetCommonCaches();
	    }
    }
}

代码内容很简洁,调用了n多个方法,我们一个个分析:

a.prepareRefresh()

protected void prepareRefresh() {
    //首先获取当前时间
	this.startupDate = System.currentTimeMillis();
	//设置容器状态,调整为活动状态
	this.closed.set(false);
	this.active.set(true);

	if (logger.isInfoEnabled()) {
		logger.info("Refreshing " + this);
	}

	//初始化环境中的占位符属性(${})默认什么都不做,用于子类扩展方法
	initPropertySources();

	//校验属性(验证必要的属性都是可解析的)
	getEnvironment().validateRequiredProperties();

	this.earlyApplicationEvents = new LinkedHashSet<>();
}

b.obtainFreshBeanFactory()

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	//刷新bean工厂,加载bean配置
    //(在子类AbstractRefreshableApplicationContext中实现的)
	refreshBeanFactory();
    //在子类中实现
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (logger.isDebugEnabled()) {
		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
	}
	return beanFactory;
}

其中刷新bean工厂的方法在子类AbstractRefreshableApplicationContext中实现,代码如下:

@Override
protected final void refreshBeanFactory() throws BeansException {
	//如果已经有beanFactory存在,则先进行销毁
	if (hasBeanFactory()) {
		//销毁所有创建的bean
		destroyBeans();
		//关闭beanFactory
		closeBeanFactory();
	}
	try {
		//创建beanFactory
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		//设置序列化id
		beanFactory.setSerializationId(getId());
		//对ioc容器进行定制化,如设置启动参数,开启注解的自动装配等
		customizeBeanFactory(beanFactory);
		//加载bean的定义信息(这里也是委派模式,此类中此方法为抽象方法)
		loadBeanDefinitions(beanFactory);
		//线程安全,修改beanFactory的值
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}

首先判断是否已经有beanFactory实例,此方法内容如下:

protected final boolean hasBeanFactory() {
	synchronized (this.beanFactoryMonitor) {
		return (this.beanFactory != null);
	}
}

上锁,避免方法执行过程中beanFactory属性的值发生变化。

紧接着,如果返回true,就调用destroyBeans方法,销毁其中注册的bean,而此方法最终追溯到源头是在继承链中父类DefaultSingletonBeanRegistry中的destroySingletons方法,内容如下:

public void destroySingletons() {
	if (logger.isDebugEnabled()) {
		logger.debug("Destroying singletons in " + this);
	}
    //将singletonsCurrentlyInDestruction标识设置为true,标识当前处于销毁bean状态
	synchronized (this.singletonObjects) {
		this.singletonsCurrentlyInDestruction = true;
	}

	String[] disposableBeanNames;
	synchronized (this.disposableBeans) {
		disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
	}
    //遍历销毁每个bean,调用destroySingleton方法,主要是调用bean的销毁方法(如果定义了的话)
	for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
		destroySingleton(disposableBeanNames[i]);
	}
    //清除所有与bean相关的内容
	this.containedBeanMap.clear();
	this.dependentBeanMap.clear();
	this.dependenciesForBeanMap.clear();

	synchronized (this.singletonObjects) {
		this.singletonObjects.clear();
		this.singletonFactories.clear();
		this.earlySingletonObjects.clear();
		this.registeredSingletons.clear();
		this.singletonsCurrentlyInDestruction = false;
	}
}

销毁bean的逻辑就到此,紧接着调用关闭beanFactory方法:closeBeanFactory,内容如下:

@Override
protected final void closeBeanFactory() {
    //内容比较简单,清空beanFactory属性值
	synchronized (this.beanFactoryMonitor) {
		if (this.beanFactory != null) {
			this.beanFactory.setSerializationId(null);
			this.beanFactory = null;
		}
	}
}

销毁结束后,紧接着就是创建新BeanFactory的逻辑,我们依次分析:

try {
		//创建beanFactory
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		//设置序列化id
		beanFactory.setSerializationId(getId());
		//对ioc容器进行定制化,如设置启动参数,开启注解的自动装配等
		customizeBeanFactory(beanFactory);
		//加载bean的定义信息(这里也是委派模式,此类中此方法为抽象方法)
		loadBeanDefinitions(beanFactory);
		//线程安全,修改beanFactory的值
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
1)createBeanFactory()
protected DefaultListableBeanFactory createBeanFactory() {
    //创建一个新的DefaultListableBeanFactory
    //如果有父容器,则将父容器的beanFactory作为参数传入
	return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

//DefaultListableBeanFactory构造方法
public DefaultListableBeanFactory(@Nullable BeanFactory parentBeanFactory) {
	//调用父类的构造函数
    super(parentBeanFactory);
}

//父类构造函数内容
public AbstractAutowireCapableBeanFactory() {
	super();
    //设置三种接口类型为依赖注入忽略类型,目的是在bean初始化时,手动将依赖注入
	ignoreDependencyInterface(BeanNameAware.class);
	ignoreDependencyInterface(BeanFactoryAware.class);
	ignoreDependencyInterface(BeanClassLoaderAware.class);
}

public AbstractAutowireCapableBeanFactory(@Nullable BeanFactory parentBeanFactory) {
	this();
	setParentBeanFactory(parentBeanFactory);
}

以上便是创建BeanFactory方法的内容,紧接着,调用beanFactory.setSerializationId,为bean工厂设置序列化id,然后是customizeBeanFactory方法,设置beanFactory参数,内容如下:

2)customizeBeanFactory()
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
	//设置是否允许bean定义覆盖
    if (this.allowBeanDefinitionOverriding != null) {
		beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
	}
    //设置是否允许循环依赖
	if (this.allowCircularReferences != null) {
		beanFactory.setAllowCircularReferences(this.allowCircularReferences);
	}
}
3)loadBeanDefinitions(beanFactory)

        beanFactory初始化完成后,就可以开始加载bean定义信息了,loadBeanDefinitions方法采用委派模式,交给子类实现,追溯一番,发现是在子类AbstractXmlApplicationContext中实现的,如下:

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// Create a new XmlBeanDefinitionReader for the given BeanFactory.
	// 创建XML的bean定义读取器,并设置到容器中,后续通过此读取器读取bean定义
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

	// Configure the bean definition reader with this context's
	// resource loading environment.
	//为bean定义读取器设置此context的环境信息
	beanDefinitionReader.setEnvironment(this.getEnvironment());
	//applicationcontext本身也属于ResourceLoader,所以直接设置进去
	beanDefinitionReader.setResourceLoader(this);
	//设置XML解析器
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

	// Allow a subclass to provide custom initialization of the reader,
	// then proceed with actually loading the bean definitions.
	//此方法中将bean定义读取器的XML校验机制打开
	initBeanDefinitionReader(beanDefinitionReader);
	//真正加载定义的方法
	loadBeanDefinitions(beanDefinitionReader);
}

        首先创建XmlBeanDefinitionReader,调用构造方法,将beanFactory传入,而构造方法中只有一句:super(beanFactory),所以最终追溯到了XmlBeanDefinitionReader的父类,也就是AbstractBeanDefinitionReader。初始化了一些属性。

protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	this.registry = registry;

	// Determine ResourceLoader to use.
    // 这两个if都走的else,因为传入的beanFactory并不实现这两个接口
	if (this.registry instanceof ResourceLoader) {
		this.resourceLoader = (ResourceLoader) this.registry;
	}
	else {
		this.resourceLoader = new PathMatchingResourcePatternResolver();
	}
	
    // Inherit Environment if possible
	if (this.registry instanceof EnvironmentCapable) {
		this.environment = ((EnvironmentCapable) this.registry).getEnvironment();
	}
	else {
		this.environment = new StandardEnvironment();
	}
}

创建完XmlBeanDefinitionReader类以后,进行一些属性设置,最后调用loadBeanDefinitions方法真正的去读取bean定义信息:

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
	//获取配置定位,并解析,此方法也是委派模式,本类中并没有实现
	Resource[] configResources = getConfigResources();
	if (configResources != null) {
        //此方法内部是循环,循环解析每个配置文件
		reader.loadBeanDefinitions(configResources);
	}
	//获取资源位置,并解析
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		//loadBeanDefinitions方法其实是调用reader的父类AbstractBeanDefinitionReader的方法
        //最终将String的资源转换为Resource类型,调用loadBeanDefinitions(Resource resource)
		reader.loadBeanDefinitions(configLocations);
	}
}

首先是getConfigResources方法,同样是委派给子类实现,追溯一番,发现是老朋友ClassPathXmlApplicationContext中实现的,而内容很简单,直接返回this.configResources,此属性是在spring启动的构造方法中根据入参解析而成的,内容嘛,就是一些配置文件的路径,如果忘记具体过程,可以返回文章开头看看哦。

如果判断配置资源不为空,则调用读取器的加载bean定义方法进行解析。最终调用如下方法:   

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	Assert.notNull(encodedResource, "EncodedResource must not be null");
	if (logger.isInfoEnabled()) {
		logger.info("Loading XML bean definitions from "+ encodedResource.getResource());
	}
    //将当前需要加载的配置资源添加到集合中
	Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
	if (currentResources == null) {
		currentResources = new HashSet<>(4);
		this.resourcesCurrentlyBeingLoaded.set(currentResources);
	}
    //利用set元素的不重复性,判断是否多次加载
	if (!currentResources.add(encodedResource)) {
		throw new BeanDefinitionStoreException(
				"Detected cyclic loading of " + encodedResource + " - check your import         definitions!");
	}
	try {
		//获取配置文件的流
		InputStream inputStream = encodedResource.getResource().getInputStream();
		try {
			InputSource inputSource = new InputSource(inputStream);
			//如果需要设置编码,设置编码
			if (encodedResource.getEncoding() != null) {
				inputSource.setEncoding(encodedResource.getEncoding());
			}
			//真正解析bean定义的位置
			return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
		}
		finally {
			inputStream.close();
		}
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException(
				"IOException parsing XML document from " + encodedResource.getResource(), ex);
	}
	finally {
		currentResources.remove(encodedResource);
		if (currentResources.isEmpty()) {
			this.resourcesCurrentlyBeingLoaded.remove();
		}
	}
}

  逻辑清晰,最终调用的是doLoadBeanDefinitions方法,内容如下:

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
	try {
		//将配置文件解析为Dom对象
		Document doc = doLoadDocument(inputSource, resource);
		//解析bean定义的方法
		return registerBeanDefinitions(doc, resource);
	}
	catch (BeanDefinitionStoreException ex) {
		throw ex;
	}
	catch (SAXParseException ex) {
		throw new XmlBeanDefinitionStoreException(resource.getDescription(),
				"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
	}
	catch (SAXException ex) {
		throw new XmlBeanDefinitionStoreException(resource.getDescription(),
				"XML document from " + resource + " is invalid", ex);
	}
	catch (ParserConfigurationException ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"Parser configuration exception parsing XML from " + resource, ex);
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"IOException parsing XML document from " + resource, ex);
	}
	catch (Throwable ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"Unexpected exception parsing XML document from " + resource, ex);
	}
}

//其中,doLoadDocument方法内容如下
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
    //调用了documentLoader(DefaultDocumentLoader)的loadDocument方法
	return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
			getValidationModeForResource(resource), isNamespaceAware());
}

@Override
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
		ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
    //主要完成工厂的创建以及属性的设置,比如XSD校验属性等,不展开细说
	DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
	if (logger.isDebugEnabled()) {
		logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
	}
    //最终返回的为DocumentBuilderImpl实例
	DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
    //调用解析方法,最终调用的是XML11Configuration的parse方法解析文件,再通过AbstractDOMParser类的getDocument返回解析好的Document对象,具体内容不做解析
	return builder.parse(inputSource);
}

获取到Document对象以后,随之调用registerBeanDefinitions方法对bean定义进行解析:

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	//创建Bean定义dom对象的解析器,为DefaultBeanDefinitionDocumentReader实例
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	//获取容器目前注册的bean数量
	int countBefore = getRegistry().getBeanDefinitionCount();
	//解析bean定义,documentReader为BeanDefinitionDocumentReader类型,是接口,调用registerBeanDefinitions
	//方法,最终调用的是子类DefaultBeanDefinitionDocumentReader
	//此处的createReaderContext是根据resource创建的一个上下文
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
	//返回解析了多少新的bean定义
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
	this.readerContext = readerContext;
	logger.debug("Loading bean definitions");
    //获取根节点
	Element root = doc.getDocumentElement();
    //核心方法
	doRegisterBeanDefinitions(root);
}

protected void doRegisterBeanDefinitions(Element root) {
	BeanDefinitionParserDelegate parent = this.delegate;
	this.delegate = createDelegate(getReaderContext(), root, parent);

	if (this.delegate.isDefaultNamespace(root)) {
        //些许校验
		String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
		if (StringUtils.hasText(profileSpec)) {
			String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
					profileSpec,BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles))     {
				if (logger.isInfoEnabled()) {
					logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
							"] not matching: " + getReaderContext().getResource());
				}
				return;
			}
		}
	}
	//可自定义扩展解析行为,如:预处理自定义的XML元素节点,增加灵活性
	preProcessXml(root);
	//解析bean定义
	parseBeanDefinitions(root, this.delegate);
	//可自定义扩展解析行为,如:预处理自定义的XML元素节点,增加灵活性
	postProcessXml(root);

	this.delegate = parent;
}

上述一连串方法调用,最终的目标为parseBeanDefinitions方法,内容如下:

//根据spring的bean规则解析dom
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	//xml文档使用了spring默认的名称空间
	if (delegate.isDefaultNamespace(root)) {
		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;
				//此节点使用的是spring的命名空间
				if (delegate.isDefaultNamespace(ele)) {
					//使用spring的bean规则解析
					parseDefaultElement(ele, delegate);
				}
				else {
					//否则使用用户自定义规则解析
					delegate.parseCustomElement(ele);
				}
			}
		}
	}
	else {
		//否则使用用户自定义规则解析
		delegate.parseCustomElement(root);
	}
}

关于用户自定义的名称空间,自定义的bean规则,我们不做讨论,主要来看按照spring定义的bean定义规则解析的方法:

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	//如果节点是<import>导入元素,进行导入解析
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		importBeanDefinitionResource(ele);
	}
	//如果节点是<alias>别名元素,进行别名解析
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		processAliasRegistration(ele);
	}
	//如果节点是<bean>bean元素,进行bean定义解析
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		processBeanDefinition(ele, delegate);
	}
	//如果节点是嵌套bean信息
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// recurse
		doRegisterBeanDefinitions(ele);
	}
}

可以看到,针对各类元素标签执行不同的解析方法,我们依次分析:

    //总的来说就是再次根据所提供的配置文件,再次调用XmlBeanDefinitionReader类的loadBeanDefinition方法
    protected void importBeanDefinitionResource(Element ele) {
		//获取资源路径,也就是import标签的resource属性值
		String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
		//路径为空,报错
		if (!StringUtils.hasText(location)) {
			getReaderContext().error("Resource location must not be empty", ele);
			return;
		}

		// Resolve system properties: e.g. "${user.dir}"
		//使用系统变量解析location值
        //这里的getEnvironment方法获取到的其实是AbstractApplicationContext类之前分析过的refresh准备方法:prepareRefresh中调用getEnvironment方法所创建出来的StandardEnvironment类
		location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

		Set<Resource> actualResources = new LinkedHashSet<>(4);

		// Discover whether the location is an absolute or relative URI
		//标识location是绝对URI还是相对URI
		boolean absoluteLocation = false;
		try {
			absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
		}
		catch (URISyntaxException ex) {
			//无法转为URI
			// cannot convert to an URI, considering the location relative
			// unless it is the well-known Spring prefix "classpath*:"
		}

		// Absolute or relative?
		if (absoluteLocation) {
			try {
				//如果是绝对路径
				int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
				if (logger.isDebugEnabled()) {
					logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
				}
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error(
						"Failed to import bean definitions from URL location [" + location + "]", ele, ex);
			}
		}
		else {
			//相对路径
			// No URL -> considering resource location as relative to the current file.
			try {
				int importCount;
				//封装为相对路径资源
				Resource relativeResource = getReaderContext().getResource().createRelative(location);
				if (relativeResource.exists()) {
					importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
					actualResources.add(relativeResource);
				}
				else {
					//获取ioc资源读取器的基本路径
					String baseLocation = getReaderContext().getResource().getURL().toString();
					//根据基本路径解析应用相对路径
					importCount = getReaderContext().getReader().loadBeanDefinitions(
							StringUtils.applyRelativePath(baseLocation, location), actualResources);
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
				}
			}
			catch (IOException ex) {
				getReaderContext().error("Failed to resolve current resource location", ele, ex);
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
						ele, ex);
			}
		}
		Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);
		//解析完成后,发送解析完成事件
		getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
	}

这段代码中需要注意的是

location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

这里的getEnvironment方法获取到的其实是AbstractApplicationContext类之前分析过的refresh准备方法:prepareRefresh中调用getEnvironment方法所创建出来的StandardEnvironment类,而resolveRequiredPlaceholders方法则在其父类AbstractEnvironment中定义的,追溯一番,其实最终是我们开头分析的在解析配置文件路径时候,所提到过的PropertyPlaceholderHelper类的parseStringValue方法,此方法的逻辑就是解析提供的字符串中的${}符号,并用全局属性值替换括号中的内容,如果忘记了可以返回到setConfigLocation方法的解析部分,再品一品。

由上可得,此处作用就是解析location字符串中的${}占位符。

紧接着是对alias标签的解析方法:

	//概括来说就是获取标签中的两个属性值,判断不为空,将别名注册到bean工厂的别名map中
    protected void processAliasRegistration(Element ele) {
		//获取alias元素中的name属性
		String name = ele.getAttribute(NAME_ATTRIBUTE);
		//获取alias元素中的alias属性
		String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
		//标识属性值是否有效
		boolean valid = true;
		if (!StringUtils.hasText(name)) {
			getReaderContext().error("Name must not be empty", ele);
			valid = false;
		}
		if (!StringUtils.hasText(alias)) {
			getReaderContext().error("Alias must not be empty", ele);
			valid = false;
		}
		if (valid) {
			try {
				//将别名与本名注册到bean工厂的别名map中
				getReaderContext().getRegistry().registerAlias(name, alias);
			}
			catch (Exception ex) {
				getReaderContext().error("Failed to register alias '" + alias +
						"' for bean with name '" + name + "'", ele, ex);
			}
			//发布解析完成alias节点的消息
			getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
		}
	}

然后是解析bean标签的方法:

	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//BeanDefinitionHolder是beanDefinition类的封装类
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
				//向ioc中注册解析到的bean定义
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// Send registration event.
			//发布注册信息
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

其中重点就是parseBeanDefinitionElement方法,是BeanDefinitionDelegate中定义的,内容如下:

	@Nullable
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}

	@Nullable
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		//获取id与name
		String id = ele.getAttribute(ID_ATTRIBUTE);
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		List<String> aliases = new ArrayList<>();
		//如果name 中有,;分割,则解析为name数组
		if (StringUtils.hasLength(nameAttr)) {
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}

		String beanName = id;
		//如果id为空并且别名数组不为空,则移除别名数组中的第一个别名当作beanName
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
			if (logger.isDebugEnabled()) {
				logger.debug("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}

		if (containingBean == null) {
			//检查此bean中的名称,别名是否重复
            //如果没重复,就加入到此次解析的已使用名称集合中
            //方法内容简单,不再详细解析
			checkNameUniqueness(beanName, aliases, ele);
		}

		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
                        //生成一个id(根据class名称或者parent名称或者factoryBean名称)内容不难,不展开介绍
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
                        //最终与上面生成beanName的方法调用的一样,只不过true变为false
						beanName = this.readerContext.generateBeanName(beanDefinition);

						// 给别名中添加类名
						String beanClassName = beanDefinition.getBeanClassName();
						if (beanClassName != null &&
								beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
								!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
							aliases.add(beanClassName);
						}
					}
					if (logger.isDebugEnabled()) {
						logger.debug("Neither XML 'id' nor 'name' specified - " +
								"using generated bean name [" + beanName + "]");
					}
				}
				catch (Exception ex) {
					error(ex.getMessage(), ele);
					return null;
				}
			}
			String[] aliasesArray = StringUtils.toStringArray(aliases);
            //最终返回一个BeanDefinitionHolder对象
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

其中的parseBeanDefinitionElement方法内容如下:

	@Nullable
	public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {
        //将当前解析的bean定义加入到缓存中,解析完成再移除
        //此处的BeanEntity类只有一个属性,就是bean名称
		this.parseState.push(new BeanEntry(beanName));
        
        //解析bean标签的class属性
		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
        //解析bean标签的parent属性
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
            //创建beanDefinition对象
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
            //解析bean标签中的各种属性
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            //设置bean描述
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			//解析bean的元属性meta标签
			parseMetaElements(ele, bd);
			//解析bean的lookup-method标签
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			//解析bean的replaced-method标签
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
			//解析bean的constructor-arg标签
			parseConstructorArgElements(ele, bd);
			//解析bean的property标签
			parsePropertyElements(ele, bd);
			//解析bean的qualifier标签
			parseQualifierElements(ele, bd);
			//设置bean定义的来源
			bd.setResource(this.readerContext.getResource());
			//此处的最终调用为NullSourceExtractor类的extractSource方法,返回的是null
			bd.setSource(extractSource(ele));

			return bd;
		}
		catch (ClassNotFoundException ex) {
			error("Bean class [" + className + "] not found", ele, ex);
		}
		catch (NoClassDefFoundError err) {
			error("Class that bean class [" + className + "] depends on not found", ele, err);
		}
		catch (Throwable ex) {
			error("Unexpected failure during bean definition parsing", ele, ex);
		}
		finally {
			this.parseState.pop();
		}

		return null;
	}
//=========================创建bean定义的方法
	protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)
			throws ClassNotFoundException {

		return BeanDefinitionReaderUtils.createBeanDefinition(
				parentName, className, this.readerContext.getBeanClassLoader());
	}

	public static AbstractBeanDefinition createBeanDefinition(
			@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {

		GenericBeanDefinition bd = new GenericBeanDefinition();
		bd.setParentName(parentName);
		if (className != null) {
			if (classLoader != null) {
				bd.setBeanClass(ClassUtils.forName(className, classLoader));
			}
			else {
				bd.setBeanClassName(className);
			}
		}
		return bd;
	}
//================================解析bean标签属性的方法
	public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
		//检查bean标签是否有旧版本的属性singleton,因为新版本已经替换为scope
		if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
			error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
		}
		//解析scope属性的值
		else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
			bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
		}
		//如果有包含的bean定义,则取包含bean定义的scope值
		else if (containingBean != null) {
			// Take default from containing bean in case of an inner bean definition.
			bd.setScope(containingBean.getScope());
		}
		//解析abstract属性值
		if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
			bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
		}
		//解析lazy-init属性值值
		String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
		if (DEFAULT_VALUE.equals(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
		bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
		//解析autowire模式
		String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
		bd.setAutowireMode(getAutowireMode(autowire));
		//解析bean依赖
		if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
			String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
			bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
		}
		
		//解析此bean是否配置了首要匹配,如果配置了,容器中存在同类型的bean,优先选此bean
		String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
		if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
			String candidatePattern = this.defaults.getAutowireCandidates();
			//一般是空
			if (candidatePattern != null) {
				String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
				bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
			}
		}
		else {
			bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
		}
		
		//解析primary属性
		if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
			bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
		}
		//解析init-method方法
		if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
			String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
			bd.setInitMethodName(initMethodName);
		}
		//如果有指定默认的init方法名,则使用默认的init方法名
		else if (this.defaults.getInitMethod() != null) {
			bd.setInitMethodName(this.defaults.getInitMethod());
			bd.setEnforceInitMethod(false);
		}
		//解析destroy-method属性值
		if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
			String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
			bd.setDestroyMethodName(destroyMethodName);
		}
		//如果有指定默认的destroy方法名,则使用默认的destroy方法名
		else if (this.defaults.getDestroyMethod() != null) {
			bd.setDestroyMethodName(this.defaults.getDestroyMethod());
			bd.setEnforceDestroyMethod(false);
		}
		//解析factory-method属性
		if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
			bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
		}
		//解析factory-bean属性
		if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
			bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
		}

		return bd;
	}

至此,整个bean工厂刷新以及解析配置文件的过程就分析完成了,这一部分就到这里,马上编写下一部分。具体内容为refresh后续的逻辑。

        结语:长路漫漫,各位最好能够跟着文章,打开源码,手动追一下逻辑,能够加深对源码的理解,碰到逻辑复杂的部分,拆分成一行一行的读,莫要因为长篇大论的源码而胆怯,加油! 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值