springIOC源码解析之BeanDefinition的注册

ApplicationContext类结构

context是一个存储上下文结构的东西，里面会引用BeanFactory

BeanFactory类结构

我们从这句代码开始分析，(本文spring采用的是4.2.4的版本)

ApplicationContext con = new FileSystemXmlApplicationContext("src/test/java/com//spring/test/beans-factorybean.xml");

public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {

        this(configLocations, true, null);

    }

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)

            throws BeansException {

        super(parent);

        setConfigLocations(configLocations);

        if (refresh) {

            refresh();

        }

    }

Spring IoC容器对Bean定义资源的载入是从refresh()函数开始的，refresh()是一个模板方法，refresh()方法的作用是：在创建IoC容器前，如果已经有容器存在，则需要把已有的容器销毁和关闭，以保证在refresh之后使用的是新建立起来的IoC容器。refresh的作用类似于对IoC容器的重启，在新建立好的容器中对容器进行初始化，对Bean定义资源进行载入

FileSystemXmlApplicationContext通过调用其父类AbstractApplicationContext的refresh()函数启动整个IoC容器对Bean定义的载入过程：

public void refresh() throws BeansException, IllegalStateException {

    synchronized (this.startupShutdownMonitor) {

    	// Prepare this context for refreshing.

    	prepareRefresh();

    	// 获取bean工厂

    	ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

    	// Prepare the bean factory for use in this context.

    	prepareBeanFactory(beanFactory);

    	try {

    		// Allows post-processing of the bean factory in context subclasses.

    		postProcessBeanFactory(beanFactory);

    		// Invoke factory processors registered as beans in the context.

    		invokeBeanFactoryPostProcessors(beanFactory);

    		// Register bean processors that intercept bean creation.

    		registerBeanPostProcessors(beanFactory);

    		// Initialize message source for this context.

    		initMessageSource();

    		// Initialize event multicaster for this context.

    		initApplicationEventMulticaster();

    		// Initialize other special beans in specific context subclasses.

    		onRefresh();

    		// Check for listener beans and register them.

    		registerListeners();

    		// Instantiate all remaining (non-lazy-init) singletons.

    		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.

    		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();

    	}

    }

}

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

    //这里使用了委派设计模式，父类定义了抽象的refreshBeanFactory()方法，具体实现调用子类容器的refreshBeanFactory()方法

    refreshBeanFactory();

    ConfigurableListableBeanFactory beanFactory = getBeanFactory();

    if (logger.isDebugEnabled()) {

        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

    }

    return beanFactory;

}

AbstractApplicationContext子类的refreshBeanFactory()方法：

AbstractApplicationContext类中只抽象定义了refreshBeanFactory()方法，容器真正调用的是其子类AbstractRefreshableApplicationContext实现的 refreshBeanFactory()方法

protected final void refreshBeanFactory() throws BeansException {

		if (hasBeanFactory()) {

			destroyBeans();

			closeBeanFactory();

		}

		try {

			DefaultListableBeanFactory beanFactory = createBeanFactory();//这里创建了一个默认的工厂

			beanFactory.setSerializationId(getId());

			customizeBeanFactory(beanFactory);

			loadBeanDefinitions(beanFactory); //此处进行加载

			synchronized (this.beanFactoryMonitor) {

				this.beanFactory = beanFactory;

			}

		}

		catch (IOException ex) {

			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);

		}

	}

AbstractRefreshableApplicationContext子类的loadBeanDefinitions方法：

AbstractRefreshableApplicationContext中只定义了抽象的loadBeanDefinitions方法，容器真正调用的是其子类AbstractXmlApplicationContext对该方法的实现，AbstractXmlApplicationContext的主要源码如下：

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {

		// 通过这个XmlBeanDefinitionReader关联beanFactory，在解析的时候就注册到beanFactory里了

		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// Configure the bean definition reader with this context's

		// resource loading environment.

		beanDefinitionReader.setEnvironment(this.getEnvironment());

		beanDefinitionReader.setResourceLoader(this);

		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// Allow a subclass to provide custom initialization of the reader,

		// then proceed with actually loading the bean definitions.

		initBeanDefinitionReader(beanDefinitionReader);

		loadBeanDefinitions(beanDefinitionReader);  //进行初始化

	}

}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {

		Resource[] configResources = getConfigResources();

		if (configResources != null) {

			reader.loadBeanDefinitions(configResources);

		}

		String[] configLocations = getConfigLocations();

		if (configLocations != null) {

			reader.loadBeanDefinitions(configLocations);  //通过reader来读取配置

		}

	}

随后进入AbstractBeanDefinitionReader

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, Set<Resource> actualResources) throws BeanDefinitionStoreException {

		ResourceLoader resourceLoader = getResourceLoader();

		if (resourceLoader == null) {

			throw new BeanDefinitionStoreException(

					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");

		}

		if (resourceLoader instanceof ResourcePatternResolver) {

			// Resource pattern matching available.

			try {

				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);

				int loadCount = loadBeanDefinitions(resources); //加载了多少个BeanDefinition

				...

				return loadCount;

			}

			catch (IOException ex) {

				throw new BeanDefinitionStoreException(

						"Could not resolve bean definition resource pattern [" + location + "]", ex);

			}

		}

		...

	}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {

     ...

	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();

		}

	}

      ...

}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

			throws BeanDefinitionStoreException {

	try {

		Document doc = doLoadDocument(inputSource, resource);

		return registerBeanDefinitions(doc, resource); //解析成doc后开始注册beanDefinition

	}

           ...

}

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {

	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

	int countBefore = getRegistry().getBeanDefinitionCount(); //registry就是开始创建的那个beanFactory

	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

	return getRegistry().getBeanDefinitionCount() - countBefore;

}

进入子类DefaultBeanDefinitionDocumentReader执行registerBeanDefinitions方法



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);

	...

	preProcessXml(root);

	parseBeanDefinitions(root, this.delegate); //对document进行解析

	postProcessXml(root);

	this.delegate = parent;

}

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {

		//使用Spring默认的XML命名空间

		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;

					if (delegate.isDefaultNamespace(ele)) {

						parseDefaultElement(ele, delegate); //使用Spring的Bean规则解析元素节点

					}

					else {

						delegate.parseCustomElement(ele); //没有使用Spring默认的XML命名空间，则使用用户自定义的解析规则解析元素节点

					}

				}

			}

		}

		else {

			delegate.parseCustomElement(root);

		}

	}

	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {

		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);  //是bean的话就会进入处理,其他的不需要delegate帮忙

		}

		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {

			// recurse

			doRegisterBeanDefinitions(ele);

		}

	}

	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);  //用bdHolder封装了BeanDefinition

		if (bdHolder != null) {

			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); //有些自定义的schema再解析一遍，添加到beanDefinition里的propertyValue里

			try {

				// 注册到最开始创建的beanFactory里

				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));

		}

	}

BeanDefinitionParserDelegate继续进行进行解析

//参数containingBean标识<Bean>元素中是否包含子<Bean>元素

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {

		String id = ele.getAttribute(ID_ATTRIBUTE);

		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		...

		String beanName = id;

		...

		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);

						String beanClassName = beanDefinition.getBeanClassName();

						if (beanClassName != null &&

								beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&

								!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {

							aliases.add(beanClassName);//把class的全路径添加到别名里了

						}

					}

					...

				}

				catch (Exception ex) {

					error(ex.getMessage(), ele);

					return null;

				}

			}

			String[] aliasesArray = StringUtils.toStringArray(aliases);

			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray); //beanDefinition并没有beanId，所以连同beanName和别名数组一起放进bdHolder

		}

		return null;

	}

    public AbstractBeanDefinition parseBeanDefinitionElement(

			Element ele, String beanName, BeanDefinition containingBean) {

		this.parseState.push(new BeanEntry(beanName));

		String className = null;

		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {

			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();

		}

		try {

			String parent = null;

			if (ele.hasAttribute(PARENT_ATTRIBUTE)) {

				parent = ele.getAttribute(PARENT_ATTRIBUTE);

			}

			AbstractBeanDefinition bd = createBeanDefinition(className, parent); //创建beanDefinition

			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); //解析bean里定义的属性值

			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			parseMetaElements(ele, bd);

			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

			parseConstructorArgElements(ele, bd);

			parsePropertyElements(ele, bd);  //设置属性值

			parseQualifierElements(ele, bd);

			bd.setResource(this.readerContext.getResource());

			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;

	}

	protected AbstractBeanDefinition createBeanDefinition(String className, String parentName)

			throws ClassNotFoundException {

		return BeanDefinitionReaderUtils.createBeanDefinition(

				parentName, className, this.readerContext.getBeanClassLoader());

	}

	public static AbstractBeanDefinition createBeanDefinition(

			String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {

		GenericBeanDefinition bd = new GenericBeanDefinition();//一个通用的beanDefition

		bd.setParentName(parentName);

		if (className != null) {

			if (classLoader != null) {

				bd.setBeanClass(ClassUtils.forName(className, classLoader));

			}

			else {

				bd.setBeanClassName(className);

			}

		}

		return bd;

	}

解析好后生成的BeanDefinition，通过下面代码进行注册到beanFactoty中

BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

public static void registerBeanDefinition(

			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)

			throws BeanDefinitionStoreException {

		String beanName = definitionHolder.getBeanName();

		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); //注册到beanFactoty中

		String[] aliases = definitionHolder.getAliases();

		if (aliases != null) {

			for (String alias : aliases) {

				registry.registerAlias(beanName, alias); //注册别名，放入aliasMap

			}

		}

	}

进入到DefaultListableBeanFactory，进行注册

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

			throws BeanDefinitionStoreException {

		...

		BeanDefinition oldBeanDefinition;

		oldBeanDefinition = this.beanDefinitionMap.get(beanName);

		if (oldBeanDefinition != null) {

			if (!isAllowBeanDefinitionOverriding()) {  //是否允许覆盖bean,变量allowBeanDefinitionOverriding默认是true

				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,

						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +

						"': There is already [" + oldBeanDefinition + "] bound.");

			}

			...

			this.beanDefinitionMap.put(beanName, beanDefinition);

		}

		else {

			if (hasBeanCreationStarted()) {

			...

			}

			else {

				// 存入了map中

				this.beanDefinitionMap.put(beanName, beanDefinition);

				this.beanDefinitionNames.add(beanName);

				this.manualSingletonNames.remove(beanName);

			}

			this.frozenBeanDefinitionNames = null;

		}

		if (oldBeanDefinition != null || containsSingleton(beanName)) {

			resetBeanDefinition(beanName); //清除map里的缓存

		}

	}

在前面DefaultBeanDefinitionDocumentReader执行registerBeanDefinitions方法时有，delegate.parseCustomElement(root);这段代码会解析自定义标签比如：component-scan，开启自动包扫描

    public BeanDefinition parseCustomElement(Element ele) {

		return parseCustomElement(ele, null);

	}

	public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {

		String namespaceUri = getNamespaceURI(ele);

		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);

		if (handler == null) {

			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);

			return null;

		}

		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));

	}

	//handler会帮忙找一个解析器来帮助解析

	public BeanDefinition parse(Element element, ParserContext parserContext) {

		return findParserForElement(element, parserContext).parse(element, parserContext);

	}

	public BeanDefinition parse(Element element, ParserContext parserContext) {

		String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);

		basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);

		String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,

				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);//获得要扫描的路径

		// Actually scan for bean definitions and register them.

		ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);

		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages); //scanner进行扫描

		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

		return null;

	}

	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {

		Assert.notEmpty(basePackages, "At least one base package must be specified");

		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();

		for (String basePackage : basePackages) {

			Set<BeanDefinition> candidates = findCandidateComponents(basePackage); //扫描指定包下的BD

			for (BeanDefinition candidate : candidates) {

				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);

				candidate.setScope(scopeMetadata.getScopeName());//默认单例

				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);

				if (candidate instanceof AbstractBeanDefinition) {

					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);

				}

				if (candidate instanceof AnnotatedBeanDefinition) {

					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);

				}

				if (checkCandidate(beanName, candidate)) {

					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);

					definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

					beanDefinitions.add(definitionHolder);

					registerBeanDefinition(definitionHolder, this.registry); //注册到beanFactory

				}

			}

		}

		return beanDefinitions;

	}

	public Set<BeanDefinition> findCandidateComponents(String basePackage) {

		Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();

		try {

			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +

					resolveBasePackage(basePackage) + "/" + this.resourcePattern;

			Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);

			...

			for (Resource resource : resources) {

			...

				if (resource.isReadable()) {

					try {

						MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);

						if (isCandidateComponent(metadataReader)) {

							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader); //新的BD类型

							...

			}

		}

		catch (IOException ex) {

			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);

		}

		return candidates;

	}

//新的BD

public class ScannedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition {

...

}

巴特西