Spring源码分析——Bean的注册

末蓝、 2023-01-20 04:00 324阅读 0赞

## 背景 ##

Spring版本：5.1.14.RELEASE

仔细阅读[依赖注入(Dependency Injection)框架是如何实现的][Dependency Injection]这篇博文后，我们大致知道了一个DI容器是如何管理bean的。总体来，bean的创建流程分为如下三步：  
![20210510135933368.png][]

定义化：从xml文件中解析bean的定义(获得BeanDefinition实例)，之后创建bean都是通过bean的定义去创建。  
实例化：实例化的过程是一个创建Bean的过程，即调用Bean的构造函数，单例的Bean放入单例池中。  
初始化：初始化的过程是一个赋值的过程，即调用Bean的setter，设置Bean的属性。

在[依赖注入(Dependency Injection)框架是如何实现的][Dependency Injection]这篇博文中已经实现了一个DI容器的最小原型，**将bean注册到容器中的第一步就是配置解析。可以定义一个BeanConfigParser接口，接口定义行为，实现类XmlBeanConfigParser负责将XML配置文件解析为BeanDefinition结构。如果有其他格式的配置文件，例如JSON和注解，还可以再写JsonBeanConfigParser实现类和AnnotationBeanConfigParser实现类**。

基于以上基础知识，我们发现，其实在Spring框架中bean注册到容器的过程其实就是通过配置文件或注解来获取BeanDefinition实例的过程，即bean注册到窗口主要有两种方式：

*  使用xml配置文件进行注册
 *  使用注解的方式进行注册

接下来将通过源码解读分别看下这两种方式的bean注册过程。

## 使用xml配置文件作bean注册的过程 ##

先从一个简单的例子开始，基本上在最开始学习Spring的时候都会从xml配置开始，把你需要交给Spring管理的类配置到xml文件中，你就可以不用管对象的创建了，下面来看一下代码。

@Data
    public class User { 
        private String name;
        private String age;
    }

这是一个很简单的一个JavaBean，为它增加一个xml配置文件

<?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">
        <bean id="userBean" class="org.kxg.springDemo.User">
            <property name="name" value="KevinDurant" />
            <property name="age" value="22" />
        </bean>
    
    </beans>

读取配置文件并运行：

public class XmlBeanTest { 
        public static void main(String[] args){ 
            ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("userBean.xml");
            User user = (User) applicationContext.getBean("userBean");
            System.out.println(user.getName());
        }
    }

这个例子堪称Spring入门的HelloWorld。从上面几行代码可以看出，首先读取bean.xml中的配置，然后就可以从applicationContext中获取到User对象，那么肯定会有User类的BeanDefinition实例注册到IOC容器中这个步骤。

从ClassPathXmlApplicationContext类的构造函数入手。

public ClassPathXmlApplicationContext(String configLocation) throws BeansException { 
    	this(new String[] { configLocation}, true, null);
    }
    
    public ClassPathXmlApplicationContext(
    		String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
    		throws BeansException { 
    
    	super(parent);
    	//将传入的xml配置位置信息设置到configLocations
    	setConfigLocations(configLocations);
    	if (refresh) { 
    		//核心方法
    		refresh();
    	}
    }

这里看到，我们传入的配置文件设置到configLocations，然后调用了一个Spring最核心的方法refresh()，追踪发现这里调用的refresh()方法是从AbstractApplicationContext继承而来的，具体实现在AbstractApplicationContext中，这个方法包括了容器启动的所有内容，是学习Spring源码的一个入口，下面我们来看看这个方法里面有些什么。

//AbstractApplicationContext.java
    @Override
    public void refresh() throws BeansException, IllegalStateException { 
    	synchronized (this.startupShutdownMonitor) { 
    		// Prepare this context for refreshing.
    		prepareRefresh();
    
    		// 告知子类刷新内部bean工厂
    		// Tell the subclass to refresh the internal bean factory.
    		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();
    		}
    	}
    }

其中的关键在于调用了obtainFreshBeanFactory()函数，返回一个bean的factory，在这里面进行Bean的注册逻辑。

//AbstractApplicationContext.java
    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { 
    	refreshBeanFactory();
    	return getBeanFactory();
    }

这里调用的是AbstractRefreshableApplicationContext类的refreshBeanFactory()方法。

//AbstractRefreshableApplicationContext.java
    @Override
    protected final void refreshBeanFactory() throws BeansException { 
    	if (hasBeanFactory()) { 
    		destroyBeans();
    		closeBeanFactory();
    	}
    	try { 
    		//创建一个BeanFactory
    		DefaultListableBeanFactory beanFactory = createBeanFactory();
    		beanFactory.setSerializationId(getId());
    		customizeBeanFactory(beanFactory);
    		//这里进行Bean的加载
    		loadBeanDefinitions(beanFactory);
    		synchronized (this.beanFactoryMonitor) { 
    			this.beanFactory = beanFactory;
    		}
    	}
    	catch (IOException ex) { 
    		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    	}
    }

因为我们使用的是xml的配置，所以loadBeanDefinitions()函数这里调用的是AbstractXmlApplicationContext这个抽象类中的loadBeanDefinitions()方法实现。

//AbstractXmlApplicationContext.java
    @Override
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { 
    	// 为指定的beanFactory构造一个XmlBeanDefinitionReader,用于读到xml中配置的bean
    	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    
    	// 配置XmlBeanDefinitionReader
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    	beanDefinitionReader.setResourceLoader(this);
    	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    
    	//初始化XmlBeanDefinitionReader,允许子类添加一些特定逻辑
    	initBeanDefinitionReader(beanDefinitionReader);
    	//加载bean
    	loadBeanDefinitions(beanDefinitionReader);
    }

该函数先构造一个reader，即beanDefinitionReader，用于读取beanFactory的东西，先对这个reader配置好环境等，再初始化一下，最后调用同名的loadBeanDefinitions(beanDefinitionReader)函数。

这个同名函数的实现如下：

//AbstractXmlApplicationContext.java
    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);
    	}
    }

这个函数里针对两种不同方式的加载，调用的是不同的方法，我们传入的是configLocations，会走分支二。至此经过一番操作，容器已经获得了配置文件的位置configLocations，接下来将根据configLocations来讲对象解析成DOM对象，最终目的是要将对象注册成BeanDefinition。

观察上一步中，reader.loadBeanDefinitions(configLocations)函数，一路追踪最终会进入XmlBeanDefinitionReader类的loadBeanDefinitions()方法。

//XmlBeanDefinitionReader.java
    public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { 
    	Assert.notNull(encodedResource, "EncodedResource must not be null");
    	if (logger.isTraceEnabled()) { 
    		logger.trace("Loading XML bean definitions from " + encodedResource);
    	}
    
    	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();
    		}
    	}
    }

把传入的resource，调用getResource函数+getInputStream函数，变成一个InputStream 类型的变量inputStream，再用InputSource方法把inputStream变成InputSource 类型的变量inputSource  
最后返回：doLoadBeanDefinitions(inputSource, encodedResource. getResource())的结果。

doLoadBeanDefinitions()函数的实现如下。

//XmlBeanDefinitionReader.java
    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    		throws BeanDefinitionStoreException { 
    
    	try { 
    		Document doc = doLoadDocument(inputSource, resource);
    		int count = registerBeanDefinitions(doc, resource);
    		if (logger.isDebugEnabled()) { 
    			logger.debug("Loaded " + count + " bean definitions from " + resource);
    		}
    		return count;
    	}
    	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函数，传入inputSource和resource，返回Document类型的变量doc，再调用registerBeanDefinitions函数。至此，已经将配置文件解析转换成DOM对象了，接下来要正式进行注册了，将DOM实例转换成BeanDefinition实例，就会涉及到对标签的解析。xml中默认的标签元素包括import、alias、bean、beans这些，还有一些自定义标签。

//XmlBeanDefinitionReader.java
    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;
    }

它构造了一个BeanDefinitionDocumentReader类型的变量，调用registerBeanDefinitions函数注册BeanDefinition，并且返回了本次注册Bean的数量。

省略DOM解析的繁琐过程，直接看到最后。调用的processBeanDefinition用于对bean元素加工处理，如下：

//DefaultBeanDefinitionDocumentReader.java
    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));
    	}
    }

BeanDefinitionReaderUtils.registerBeanDefinition()这个函数最终会调用到DefaultListableBeanFactory的同名方法。

//DefaultListableBeanFactory.java
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    		throws BeanDefinitionStoreException { 
    
    	Assert.hasText(beanName, "Bean name must not be empty");
    	Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    
    	if (beanDefinition instanceof AbstractBeanDefinition) { 
    		try { 
    			((AbstractBeanDefinition) beanDefinition).validate();
    		}
    		catch (BeanDefinitionValidationException ex) { 
    			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    					"Validation of bean definition failed", ex);
    		}
    	}
    
    	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    	if (existingDefinition != null) { 
    		if (!isAllowBeanDefinitionOverriding()) { 
    			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
    		}
    		else if (existingDefinition.getRole() < beanDefinition.getRole()) { 
    			// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
    			if (logger.isInfoEnabled()) { 
    				logger.info("Overriding user-defined bean definition for bean '" + beanName +
    						"' with a framework-generated bean definition: replacing [" +
    						existingDefinition + "] with [" + beanDefinition + "]");
    			}
    		}
    		else if (!beanDefinition.equals(existingDefinition)) { 
    			if (logger.isDebugEnabled()) { 
    				logger.debug("Overriding bean definition for bean '" + beanName +
    						"' with a different definition: replacing [" + existingDefinition +
    						"] with [" + beanDefinition + "]");
    			}
    		}
    		else { 
    			if (logger.isTraceEnabled()) { 
    				logger.trace("Overriding bean definition for bean '" + beanName +
    						"' with an equivalent definition: replacing [" + existingDefinition +
    						"] with [" + beanDefinition + "]");
    			}
    		}
    		this.beanDefinitionMap.put(beanName, beanDefinition);
    	}
    	else { 
    		if (hasBeanCreationStarted()) { 
    			// Cannot modify startup-time collection elements anymore (for stable iteration)
    			synchronized (this.beanDefinitionMap) { 
    				this.beanDefinitionMap.put(beanName, beanDefinition);
    				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
    				updatedDefinitions.addAll(this.beanDefinitionNames);
    				updatedDefinitions.add(beanName);
    				this.beanDefinitionNames = updatedDefinitions;
    				removeManualSingletonName(beanName);
    			}
    		}
    		else { 
    			// Still in startup registration phase
    			this.beanDefinitionMap.put(beanName, beanDefinition);
    			this.beanDefinitionNames.add(beanName);
    			removeManualSingletonName(beanName);
    		}
    		this.frozenBeanDefinitionNames = null;
    	}
    
    	if (existingDefinition != null || containsSingleton(beanName)) { 
    		resetBeanDefinition(beanName);
    	}
    }

该函数把注册的BeanDefinition存到一个键为beanName，值为beanDefinition对象的Map集合中。

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

beanDefinitionMap是一个ConcurrentHashMap，所以本质上Bean最终是被注册到一个Map中。至此，正式完成xml配置文件方式的bean注册。完成存储以后，当需要使用的时候，再从容器（Map）中取出根据beanDefinition对bean进行实例化与初始化。

来总结下整个流程：

*  注册xml配置文件到configLocations
 *  调用refresh()进行整个Context的刷新，实际上就是整个Context的启动
 *  Bean的加载会读到配置文件，解析成DOM对象
 *  将DOM对象转换成beanDefinition
 *  将beanDefinition存入beanDefinitionMap，完成整个Bean的注册

![2021051217385829.png][]

## 使用注解作bean注册的过程 ##

前面是xml配置文件进行Bean的注册，xml配置是Spring早期常用的配置方式，现在基本上大部分场景上都推荐使用注解的方式，尤其是SpringBoot时代的来临，进一步推动了注解方式的全面使用，下面来看看注解方式下的Bean注册，从一个例子入手：

@Component
    public class AnnotionConfig { 
        @Bean(name = "userBean")
        public User getUserBean(){ 
            User user = new User();
            user.setName("KevinDurant");
            return user;
        }
    }
    public class AnnotionBeanTest { 
        public static void main(String[] args){ 
            AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext("com.abc.test.spring");
            User user = (User) applicationContext.getBean("userBean");
            System.out.println(user.getName());
        }
    }

这里用到AnnotationConfigApplicationContext，是另外一种容器的实现，传入一个包名，会自动扫描包下面的Spring注解，然后将其注册到容器中。

AnnotationConfigApplicationContext的构造函数如下：

public AnnotationConfigApplicationContext(String... basePackages) { 
    	this();
    	//主要是scan方法完成bean的注册
    	scan(basePackages);
    	//又到了这个方法
    	refresh();
    }

重点追踪一下scan(basePackages)的全过程。它调用了doScan函数，这个函数会扫描包下所有打了注解的类，进行BeanDefinition注册(也是调用registerBeanDefinition函数)，并将其转换成BeanDefinition。最后返回一个名为beanDefinitions的集合Set<BeanDefinitionHolder>。

//ClassPathBeanDefinitionScanner.java
    public int scan(String... basePackages) { 
    	int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
        //扫描包，进行Bean注册
    	doScan(basePackages);
    
    	// Register annotation config processors, if necessary.
    	if (this.includeAnnotationConfig) { 
    		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    	}
    
    	return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
    }
    
    //ClassPathBeanDefinitionScanner.java
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) { 
    	Assert.notEmpty(basePackages, "At least one base package must be specified");
    	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
    	for (String basePackage : basePackages) { 
    	    //扫描包下打了注解的类，并将其转换成BeanDefinition
    		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
    		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);
    				//进行BeanDefinition注册
    				registerBeanDefinition(definitionHolder, this.registry);
    			}
    		}
    	}
    	return beanDefinitions;
    }
    
    //ClassPathBeanDefinitionScanner.java
    protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) { 
    	BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
    }
    
    //BeanDefinitionReaderUtils#registerBeanDefinition
    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);
    		}
    	}
    }

看到BeanDefinitionReaderUtils\#registerBeanDefinition这个方法，就很眼熟了，上面xml方式进行Bean注册也调用到这个方法了，所以后面的流程都是一样的，注解方式和xml配置方式从本质上来讲，并没有什么不同，只是Bean的描述不同而已，最终都会被解析BeanDefinition，注册到容器中。

来总结下整个流程：

*  根据包名，扫描包下面带注解的类
 *  将带了bean注解的类都用registerBeanDefinition进行注册，转换成BeanDefinition
 *  将BeanDefinition都存储到set中

![20210512173936257.png][]

[Dependency Injection]: https://blog.csdn.net/fuzhongmin05/article/details/109572151
[20210510135933368.png]: /images/20221021/1e02eaae470446e3831cb53236a50576.png
[2021051217385829.png]: /images/20221021/0eba4a6afbac4319b99cdf88c2df53e1.png
[20210512173936257.png]: /images/20221021/94f3f7287dce4cd68e8e98e72cc08ee8.png