Spring源碼分析(1)--Spring初始化(註冊)

Note：spring源碼版本5.0.2Release

基於ClassPathXmlApplicationContext的BeanDefinition註冊過程

	ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

學習Spring時我相信大部分人的第一個實例就是這樣的，那就看看在實例化ClassPathXmlApplication時 spring都幹了些什麼事情吧。

public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {
	super(parent);
	setConfigLocations(configLocations);
	if (refresh) {
		refresh();
	}
}

跟蹤進去之後，發現了有這麼一處關鍵的代碼，那就一個方法一個方法看看他們究竟幹了什麼。

首先是super(parent)，看看它幹了些什麼事情

//org.springframework.context.support.AbstractApplicationContext
public AbstractApplicationContext(@Nullable ApplicationContext parent) {
		this();
		setParent(parent);
}	


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

protected ResourcePatternResolver getResourcePatternResolver() {
		return new PathMatchingResourcePatternResolver(this);
}	

可以看到，這個方法主要是將AbstractApplicationContext中的屬性resourcePatternResolver 設置爲PathMatchingResourcePatternResolver

@Override
public void setParent(@Nullable ApplicationContext parent) {
	this.parent = parent;
	if (parent != null) {
		Environment parentEnvironment = parent.getEnvironment();
		if (parentEnvironment instanceof ConfigurableEnvironment) {
			getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
		}
	}
}

由於parent傳遞爲空值，因此這個方法什麼也沒幹。

好，繼續看ClassPathXmlApplicationContext中的setConfigLocations方法

org.springframework.context.support.AbstractRefreshableConfigApplicationContext
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;
	}
}

他其實調的是超類AbstractRefreshableConfigApplicationContext的方法，而這個方法最重要的一步就是resolvePath，可以看看它幹了什麼事情

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

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

可以看到，resolvePath其實就是創建了一個Environment對象，並調用該對象的resolveRequiredPlaceholders，而這個方法就是將所傳入的string(如果有${key})解析爲對應的value(獲取環境變量中的值)。爲了驗證這個方法，來一個demo

@Test
public void test(){
	Environment environment = new StandardEnvironment();
	String javaHome1 = environment.resolveRequiredPlaceholders("${java.home}");
	String javaHome2 = environment.resolveRequiredPlaceholders("java.home");
	System.out.println(javaHome1);
	System.out.println(javaHome2);
}

以下爲輸出結果

C:\software\Java\jdk1.8.0_191\jre
java.home

因此不難明白setConfigLocations方法的左右了，具體就是將類AbstractRefreshableConfigApplicationContext的字段configLocations設置爲輸入的值，如果有佔位符，則進行解析

接下來就是最重要的方法了org.springframework.context.support.AbstractApplicationContext#refresh()

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		prepareRefresh();
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
		//以下省略
		...
}

首先觀察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<>();
}

這個主要記錄spring初始化的開始時間，closed、active標誌位狀態。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	//刷新beanFactory，如果已存在BeanFactory則銷燬，不存在則創建，並且掃描配置文件，註冊BeanDefinition
	//BeanDefinition就在這一步生成並註冊到BeanFactory中
	refreshBeanFactory();
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (logger.isDebugEnabled()) {
		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
	}
	return beanFactory;
}
//refreshBeanFactory是一個抽象方法，調用的爲子類 AbstractRefreshableApplicationContext的實現
@Override
protected final void refreshBeanFactory() throws BeansException {
	//if代碼段不影響整體流程，具體可以先跳過
	if (hasBeanFactory()) {
		//清空beanFactory中緩存的數據
		destroyBeans();
		//beanFactroy 置空
		closeBeanFactory();
	}
	try {
		//實例化beanFactory對象
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		beanFactory.setSerializationId(getId());
		//設置BeanFactory的屬性：BeanDefinition是否可以被覆蓋，是否可以循環引用(將applicationContext中的對應屬性設置上去)
		customizeBeanFactory(beanFactory);
		//這一步進行BeanDefinition的註冊
		loadBeanDefinitions(beanFactory);
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}

org.springframework.context.support.AbstractRefreshableApplicationContext
protected DefaultListableBeanFactory createBeanFactory() {
	return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

接下來看loadBeanDefinitions(beanFactory)方法，而它是一個抽象方法，具體有4個實現

而ClassPathXmlApplicationContext的繼承體系爲

因此具體看org.springframework.context.support.AbstractXmlApplicationContext中的方法

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// Create a new XmlBeanDefinitionReader for the given BeanFactory.
	//爲BeanFactory創建一個XmlBeanDefinitionReader，讀取xml文件，讀取xml文件，生成Document對象
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
	//beanDefinitionReader對象的初始化過程
	beanDefinitionReader.setEnvironment(this.getEnvironment());
	beanDefinitionReader.setResourceLoader(this);
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
	initBeanDefinitionReader(beanDefinitionReader);
	//加載xml配置文件中的bean定義
	loadBeanDefinitions(beanDefinitionReader);
}

注意方法beanDefinitionReader.setResourceLoader(this)，this代表的是ClassPathXmlApplicationContext對象，而ClassPathXmlApplicationContext集成了DefaultResourceLoader類，之後會用到這個ResourceLoader

接着看代碼

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
	//根據給定的配置文件，循環配置文件，進行BeanDefinition的解析、加載
	Resource[] configResources = getConfigResources();
	if (configResources != null) {
		reader.loadBeanDefinitions(configResources);
	}
	//configLocations 爲加載spring xml配置文件時輸入的文件路徑
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		reader.loadBeanDefinitions(configLocations);
	}
}

org.springframework.beans.factory.support.AbstractBeanDefinitionReader
@Override
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
	Assert.notNull(locations, "Location array must not be null");
	int counter = 0;
	for (String location : locations) {
		counter += loadBeanDefinitions(location);
	}
	return counter;
}

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws 		                             BeanDefinitionStoreException {
	//由於resourceLoader = DefaultResourceLoder，因此走下面的流程
	ResourceLoader resourceLoader = getResourceLoader();
	...省略
	if (resourceLoader instanceof ResourcePatternResolver) {
		...省略
	}
	else {
		// Can only load single resources by absolute URL.
		Resource resource = resourceLoader.getResource(location);
		int loadCount = loadBeanDefinitions(resource);
		if (actualResources != null) {
			actualResources.add(resource);
		}
		if (logger.isDebugEnabled()) {
			logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
		}
		return loadCount;
	}
}

org.springframework.beans.factory.xml.XmlBeanDefinitionReader
@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
	return loadBeanDefinitions(new EncodedResource(resource));
}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
	...省略
	Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
	if (currentResources == null) {
		currentResources = new HashSet<>(4);
		this.resourcesCurrentlyBeingLoaded.set(currentResources);
	}
	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());
			}
			//主要看這個方法
			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();
		}
	}
}


protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
	try {
		Document doc = doLoadDocument(inputSource, resource);
		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使用java自帶的xml解析器，將xml文件解析爲Document對象；

org.springframework.beans.factory.xml.XmlBeanDefinitionReader
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	int countBefore = getRegistry().getBeanDefinitionCount();
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
	return getRegistry().getBeanDefinitionCount() - countBefore;
}

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader
@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) {
		// Any nested <beans> elements will cause recursion in this method. In
		// order to propagate and preserve <beans> default-* attributes correctly,
		// keep track of the current (parent) delegate, which may be null. Create
		// the new (child) delegate with a reference to the parent for fallback purposes,
		// then ultimately reset this.delegate back to its original (parent) reference.
		// this behavior emulates a stack of delegates without actually necessitating one.
	BeanDefinitionParserDelegate parent = this.delegate;
	this.delegate = createDelegate(getReaderContext(), root, parent);

	//此處針對文件的profile屬性起作用  如果當前環境爲profile=default，則解析xml文件時不再解析非default profile的文件
	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;
			}
		}
	}

	preProcessXml(root);
	parseBeanDefinitions(root, this.delegate);
	postProcessXml(root);

	this.delegate = parent;
}

此方法中的if代碼段實現的功能是profile切換。如果配置文件如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
	<beans profile="default" >
		<bean class="test.User" id="user">
			<property name="name" value="profile_default"/>
			<property name="javaHome" value="${java.home}"/>
		</bean>
	</beans>
	<beans profile="test">
		<bean class="test.User" id="user">
			<property name="name" value="profile_test"/>
			<property name="javaHome" value="${user.name}"/>
		</bean>
	</beans>
</beans>

噹噹前的profile爲default時，則會解析<bean profile="default">中的內容，而跳過<bean profile="test">中的內容。具體spring的profile怎麼使用，請點擊查看
而doRegisterBeanDefinitions中調用的 preProcessXml(root)、postProcessXml(root) 是2個空方法，接着繼續往下看

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	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;
				//當獲得的element標籤爲bean下的命名空間時，進入此代碼段
				if (delegate.isDefaultNamespace(ele)) {
					parseDefaultElement(ele, delegate);
				}
				else {
					delegate.parseCustomElement(ele);
				}
			}
		}
	}
	else {
		delegate.parseCustomElement(root);
	}
}

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	//ji
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		importBeanDefinitionResource(ele);
	}
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		processAliasRegistration(ele);
	}
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		processBeanDefinition(ele, delegate);
	}
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// recurse
		doRegisterBeanDefinitions(ele);
	}
}

這裏我們着重看當元素標籤爲bean時，spring時如何解析的

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// Register the final decorated instance.
			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));
	}
}
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
	return parseBeanDefinitionElement(ele, null);
}

@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
	String id = ele.getAttribute(ID_ATTRIBUTE);
	String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
	List<String> aliases = new ArrayList<>();
	if (StringUtils.hasLength(nameAttr)) {
		String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
		aliases.addAll(Arrays.asList(nameArr));
	}
	String beanName = id;
	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) {
		checkNameUniqueness(beanName, aliases, ele);
	}
	//
	AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
	if (beanDefinition != null) {
		if (!StringUtils.hasText(beanName)) {
			try {
				if (containingBean != null) {
					beanName = BeanDefinitionReaderUtils.generateBeanName(
							beanDefinition, this.readerContext.getRegistry(), true);
				}
				else {
					beanName = this.readerContext.generateBeanName(beanDefinition);
					// Register an alias for the plain bean class name, if still possible,
					// if the generator returned the class name plus a suffix.
					// This is expected for Spring 1.2/2.0 backwards compatibility.
					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);
		return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
	}

	return null;
}

可以看到，這個方法主要就是根據xml配置文件中<bean>標籤的內容生成對應的BeanDefinition對象，返回BeanDefinition、beanName、aliasersArray的封裝對象 BeanDefinitionHolder，之後代碼會走到BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry())

public static void registerBeanDefinition(
		BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
		throws BeanDefinitionStoreException {

	// Register bean definition under primary name.
	String beanName = definitionHolder.getBeanName();
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

	// Register aliases for bean name, if any.
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			registry.registerAlias(beanName, alias);
		}
	}
}

spring的beanDefinition註冊流程完畢 ~