上文，我们看了IOC设计要点和设计结构；紧接着这篇，我们可以看下源码的实现了：Spring如何实现将资源配置（以xml配置为例）通过加载，解析，生成BeanDefination并注册到IoC容器中的。@pdai
引入
上文，我们看了IOC设计要点和设计结构；紧接着这篇，我们可以看下源码的实现了：Spring如何实现将资源配置（以xml配置为例）通过加载，解析，生成BeanDefination并注册到IoC容器中的（就是我们圈出来的部分）
如何将Bean从XML配置中解析后放到IoC容器中的？
本文的目标就是分析Spring如何实现将资源配置（以xml配置为例）通过加载，解析，生成BeanDefination并注册到IoC容器中的。
初始化的入口
对于xml配置的Spring应用，在main()方法中实例化ClasspathXmlApplicationContext即可创建一个IoC容器。我们可以从这个构造方法开始，探究一下IoC容器的初始化过程。
// create and configure beans
ApplicationContext context = ClassPathXmlApplicationContext("aspects.xml", "daos.xml", "services.xml");(String... configLocations) BeansException {
(configLocations, , (ApplicationContext));
}
(String[] configLocations, refresh, @Nullable ApplicationContext parent) BeansException {
// 设置Bean资源加载器
(parent);
// 设置配置路径
.setConfigLocations(configLocations);
// 初始化容器
(refresh) {
.refresh();
}
}设置资源解析器和环境
调用父类容器AbstractApplicationContext的构造方法(super(parent)方法)为容器设置好Bean资源加载器
(@Nullable ApplicationContext parent) {
// 默认构造函数初始化容器id, name, 状态 以及 资源解析器
();
// 将父容器的Environment合并到当前容器
.setParent(parent);
}通过AbstractApplicationContext默认构造函数初始化容器id, name, 状态 以及 资源解析器
() {
.logger = LogFactory.getLog(.getClass());
.id = ObjectUtils.identityToString();
.displayName = ObjectUtils.identityToString();
.beanFactoryPostProcessors = ArrayList();
.active = AtomicBoolean();
.closed = AtomicBoolean();
.startupShutdownMonitor = Object();
.applicationStartup = ApplicationStartup.DEFAULT;
.applicationListeners = LinkedHashSet();
.resourcePatternResolver = .getResourcePatternResolver();
}
// Spring资源加载器
ResourcePatternResolver () {
PathMatchingResourcePatternResolver();
}通过AbstractApplicationContext的setParent(parent)方法将父容器的Environment合并到当前容器
(@Nullable ApplicationContext parent) {
.parent = parent;
(parent != ) {
Environment parentEnvironment = parent.getEnvironment();
(parentEnvironment ConfigurableEnvironment) {
.getEnvironment().merge((ConfigurableEnvironment)parentEnvironment);
}
}
}设置配置路径
在设置容器的资源加载器之后，接下来FileSystemXmlApplicationContet执行setConfigLocations方法通过调用其父类AbstractRefreshableConfigApplicationContext的方法进行对Bean定义资源文件的定位
(@Nullable String... locations) {
(locations != ) {
Assert.noNullElements(locations, "Config locations must not be null");
.configLocations = String[locations.length];
( i = 0; i < locations.length; ++i) {
// 解析配置路径
.configLocations[i] = .resolvePath(locations[i]).trim();
}
} {
.configLocations = ;
}
}
String (String path) {
// 从上一步Environment中解析
.getEnvironment().resolveRequiredPlaceholders(path);
}初始化的主体流程
Spring IoC容器对Bean定义资源的载入是从refresh()函数开始的，refresh()是一个模板方法，refresh()方法的作用是：在创建IoC容器前，如果已经有容器存在，则需要把已有的容器销毁和关闭，以保证在refresh之后使用的是新建立起来的IoC容器。refresh的作用类似于对IoC容器的重启，在新建立好的容器中对容器进行初始化，对Bean定义资源进行载入。
@Override
() BeansException, IllegalStateException {
(.startupShutdownMonitor) {
StartupStep contextRefresh = .applicationStartup.start("spring.context.refresh");
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
{
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
StartupStep beanPostProcess = .applicationStartup.start("spring.context.beans.post-process");
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
beanPostProcess.end();
// 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();
}
(BeansException ex) {
(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.
ex;
}
{
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
contextRefresh.end();
}
}
}这里的设计上是一个非常典型的资源类加载处理型的思路，头脑中需要形成如下图的顶层思路（而不是只停留在流水式的方法上面）：
- 模板方法设计模式，模板方法中使用典型的钩子方法
- 将具体的初始化加载方法插入到钩子方法之间
- 将初始化的阶段封装，用来记录当前初始化到什么阶段；常见的设计是xxxPhase/xxxStage；
- 资源加载初始化有失败等处理，必然是try/catch/finally...
初始化BeanFactory之obtainFreshBeanFactory
AbstractApplicationContext的obtainFreshBeanFactory()方法调用子类容器的refreshBeanFactory()方法，启动容器载入Bean定义资源文件的过程，代码如下：
ConfigurableListableBeanFactory () {
// 这里使用了委派设计模式，父类定义了抽象的refreshBeanFactory()方法，具体实现调用子类容器的refreshBeanFactory()方法
refreshBeanFactory();
getBeanFactory();
}AbstractApplicationContext类中只抽象定义了refreshBeanFactory()方法，容器真正调用的是其子类AbstractRefreshableApplicationContext实现的refreshBeanFactory()方法; 在创建IoC容器前，如果已经有容器存在，则需要把已有的容器销毁和关闭，以保证在refresh之后使用的是新建立起来的IoC容器。方法的源码如下：
() BeansException {
// 如果已经有容器存在，则需要把已有的容器销毁和关闭，以保证在refresh之后使用的是新建立起来的IoC容器
(hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
{
// 创建DefaultListableBeanFactory，并调用loadBeanDefinitions(beanFactory)装载bean定义
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory); // 对IoC容器进行定制化，如设置启动参数，开启注解的自动装配等
loadBeanDefinitions(beanFactory); // 调用载入Bean定义的方法，主要这里又使用了一个委派模式，在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器
.beanFactory = beanFactory;
}
(IOException ex) {
ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}初始化BeanFactory之loadBeanDefinitions
AbstractRefreshableApplicationContext中只定义了抽象的loadBeanDefinitions方法，容器真正调用的是其子类AbstractXmlApplicationContext对该方法的实现，AbstractXmlApplicationContext的主要源码如下：
(DefaultListableBeanFactory beanFactory) BeansException, IOException {
// 创建XmlBeanDefinitionReader，即创建Bean读取器，并通过回调设置到容器中去，容器使用该读取器读取Bean定义资源
XmlBeanDefinitionReader beanDefinitionReader = XmlBeanDefinitionReader(beanFactory);
// 配置上下文的环境，资源加载器、解析器
beanDefinitionReader.setEnvironment(.getEnvironment());
beanDefinitionReader.setResourceLoader();
beanDefinitionReader.setEntityResolver( ResourceEntityResolver()); // 为Bean读取器设置SAX xml解析器
// 允许子类自行初始化（比如校验机制），并提供真正的加载方法
initBeanDefinitionReader(beanDefinitionReader); // 当Bean读取器读取Bean定义的Xml资源文件时，启用Xml的校验机制
loadBeanDefinitions(beanDefinitionReader);
}
(XmlBeanDefinitionReader reader) BeansException, IOException {
// 加载XML配置方式里的Bean定义的资源
Resource[] configResources = getConfigResources();
(configResources != ) {
reader.loadBeanDefinitions(configResources);
}
// 加载构造函数里配置的Bean配置文件，即{"aspects.xml", "daos.xml", "services.xml"}
String[] configLocations = getConfigLocations();
(configLocations != ) {
reader.loadBeanDefinitions(configLocations);
}
}Xml Bean读取器(XmlBeanDefinitionReader)调用其父类AbstractBeanDefinitionReader的 reader.loadBeanDefinitions方法读取Bean定义资源。
由于我们使用ClassPathXmlApplicationContext作为例子分析，因此getConfigResources的返回值为null，因此程序执行reader.loadBeanDefinitions(configLocations)分支。
AbstractBeanDefinitionReader读取Bean定义资源
AbstractBeanDefinitionReader的loadBeanDefinitions方法源码如下：
@Override
(String location) BeanDefinitionStoreException {
loadBeanDefinitions(location, );
}
(String location, @Nullable Set<Resource> actualResources) BeanDefinitionStoreException {
ResourceLoader resourceLoader = getResourceLoader();
(resourceLoader == ) {
BeanDefinitionStoreException(
"Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
}
// 模式匹配类型的解析器，这种方式是加载多个满足匹配条件的资源
(resourceLoader ResourcePatternResolver) {
{
// 获取到要加载的资源
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
count = loadBeanDefinitions(resources); // 委派调用其子类XmlBeanDefinitionReader的方法，实现加载功能
(actualResources != ) {
Collections.addAll(actualResources, resources);
}
(logger.isTraceEnabled()) {
logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
}
count;
}
(IOException ex) {
BeanDefinitionStoreException(
"Could not resolve bean definition resource pattern [" + location + "]", ex);
}
}
{
// 只能通过绝对路径URL加载单个资源.
Resource resource = resourceLoader.getResource(location);
count = loadBeanDefinitions(resource);
(actualResources != ) {
actualResources.add(resource);
}
(logger.isTraceEnabled()) {
logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
}
count;
}
}从对AbstractBeanDefinitionReader的loadBeanDefinitions方法源码分析可以看出该方法做了以下两件事：
- 首先，调用资源加载器的获取资源方法resourceLoader.getResource(location)，获取到要加载的资源。
- 其次，真正执行加载功能是其子类XmlBeanDefinitionReader的loadBeanDefinitions方法。
XmlBeanDefinitionReader加载Bean定义资源
继续看子类XmlBeanDefinitionReader的loadBeanDefinitions(Resource …)方法看到代表bean文件的资源定义以后的载入过程。
/**
* 本质上是加载XML配置的Bean。
* @param inputSource the SAX InputSource to read from
* @param resource the resource descriptor for the XML file
*/
(InputSource inputSource, Resource resource)
BeanDefinitionStoreException {
{
Document doc = doLoadDocument(inputSource, resource); // 将Bean定义资源转换成Document对象
count = registerBeanDefinitions(doc, resource);
(logger.isDebugEnabled()) {
logger.debug("Loaded " + count + " bean definitions from " + resource);
}
count;
}
(BeanDefinitionStoreException ex) {
ex;
}
(SAXParseException ex) {
XmlBeanDefinitionStoreException(resource.getDescription(),
"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
}
(SAXException ex) {
XmlBeanDefinitionStoreException(resource.getDescription(),
"XML document from " + resource + " is invalid", ex);
}
(ParserConfigurationException ex) {
BeanDefinitionStoreException(resource.getDescription(),
"Parser configuration exception parsing XML from " + resource, ex);
}
(IOException ex) {
BeanDefinitionStoreException(resource.getDescription(),
"IOException parsing XML document from " + resource, ex);
}
(Throwable ex) {
BeanDefinitionStoreException(resource.getDescription(),
"Unexpected exception parsing XML document from " + resource, ex);
}
}
// 使用配置的DocumentLoader加载XML定义文件为Document.
Document (InputSource inputSource, Resource resource) Exception {
.documentLoader.loadDocument(inputSource, getEntityResolver(), .errorHandler,
getValidationModeForResource(resource), isNamespaceAware());
}通过源码分析，载入Bean定义资源文件的最后一步是将Bean定义资源转换为Document对象，该过程由documentLoader实现
DocumentLoader将Bean定义资源转换为Document对象
DocumentLoader将Bean定义资源转换成Document对象的源码如下：
// 使用标准的JAXP将载入的Bean定义资源转换成document对象
@Override
Document (InputSource inputSource, EntityResolver entityResolver,
ErrorHandler errorHandler, validationMode, namespaceAware) Exception {
// 创建文件解析器工厂
DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
(logger.isTraceEnabled()) {
logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
}
// 创建文档解析器
DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
builder.parse(inputSource); // 解析
}
DocumentBuilderFactory ( validationMode, namespaceAware)
ParserConfigurationException {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(namespaceAware);
// 设置解析XML的校验
(validationMode != XmlValidationModeDetector.VALIDATION_NONE) {
factory.setValidating();
(validationMode == XmlValidationModeDetector.VALIDATION_XSD) {
// Enforce namespace aware for XSD...
factory.setNamespaceAware();
{
factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE);
}
(IllegalArgumentException ex) {
ParserConfigurationException pcex = ParserConfigurationException(
"Unable to validate using XSD: Your JAXP provider [" + factory +
"] does not support XML Schema. Are you running on Java 1.4 with Apache Crimson? " +
"Upgrade to Apache Xerces (or Java 1.5) for full XSD support.");
pcex.initCause(ex);
pcex;
}
}
}
factory;
}该解析过程调用JavaEE标准的JAXP标准进行处理。
至此Spring IoC容器根据定位的Bean定义资源文件，将其加载读入并转换成为Document对象过程完成。
接下来我们要继续分析Spring IoC容器将载入的Bean定义资源文件转换为Document对象之后，是如何将其解析为Spring IoC管理的Bean对象并将其注册到容器中的。
XmlBeanDefinitionReader解析载入的Bean定义资源文件
XmlBeanDefinitionReader类中的doLoadBeanDefinitions方法是从特定XML文件中实际载入Bean定义资源的方法，该方法在载入Bean定义资源之后将其转换为Document对象，接下来调用registerBeanDefinitions启动Spring IoC容器对Bean定义的解析过程，registerBeanDefinitions方法源码如下：
// 按照Spring的Bean语义要求将Bean定义资源解析并转换为容器内部数据结构
(Document doc, Resource resource) BeanDefinitionStoreException {
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
countBefore = getRegistry().getBeanDefinitionCount();
// 解析过程入口，这里使用了委派模式，具体的解析实现过程有实现类DefaultBeanDefinitionDocumentReader完成
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
getRegistry().getBeanDefinitionCount() - countBefore; // 返回此次解析了多少个对象
}
// 创建BeanDefinitionDocumentReader对象，解析Document对象
BeanDefinitionDocumentReader () {
BeanUtils.instantiateClass(.documentReaderClass);
}
/**
* Create the {@link XmlReaderContext} to pass over to the document reader.
*/
XmlReaderContext (Resource resource) {
XmlReaderContext(resource, .problemReporter, .eventListener,
.sourceExtractor, , getNamespaceHandlerResolver());
}Bean定义资源的载入解析分为以下两个过程：
- 首先，通过调用XML解析器将Bean定义资源文件转换得到Document对象，但是这些Document对象并没有按照Spring的Bean规则进行解析。这一步是载入的过程
- 其次，在完成通用的XML解析之后，按照Spring的Bean规则对Document对象进行解析。
按照Spring的Bean规则对Document对象解析的过程是在接口BeanDefinitionDocumentReader的实现类DefaultBeanDefinitionDocumentReader中实现的。
DefaultBeanDefinitionDocumentReader对Bean定义的Document对象解析
BeanDefinitionDocumentReader接口通过registerBeanDefinitions方法调用其实现类DefaultBeanDefinitionDocumentReader对Document对象进行解析，解析的代码如下：
@Override
(Document doc, XmlReaderContext readerContext) {
.readerContext = readerContext;
doRegisterBeanDefinitions(doc.getDocumentElement());
}
// 注册<beans/>配置的Beans
@SuppressWarnings("deprecation") // for Environment.acceptsProfiles(String...)
(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 = .delegate;
.delegate = createDelegate(getReaderContext(), root, parent);
(.delegate.isDefaultNamespace(root)) {
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
(StringUtils.hasText(profileSpec)) {
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
// We cannot use Profiles.of(...) since profile expressions are not supported
// in XML config. See SPR-12458 for details.
(!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
(logger.isDebugEnabled()) {
logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
"] not matching: " + getReaderContext().getResource());
}
;
}
}
}
preProcessXml(root);
parseBeanDefinitions(root, .delegate); // 从Document的根元素开始进行Bean定义的Document对象
postProcessXml(root);
.delegate = parent;
}BeanDefinitionParserDelegate解析Bean定义资源文件生成BeanDefinition
/**
* Parse the elements at the root level in the document:
* "import", "alias", "bean".
* @param root the DOM root element of the document
*/
(Element root, BeanDefinitionParserDelegate delegate) {
(delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
( i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
(node Element) {
Element ele = (Element) node;
(delegate.isDefaultNamespace(ele)) {
parseDefaultElement(ele, delegate);
}
{
delegate.parseCustomElement(ele);
}
}
}
}
{
delegate.parseCustomElement(root);
}
}
(Element ele, BeanDefinitionParserDelegate delegate) {
// 如果元素节点是<Import>导入元素，进行导入解析
(delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
// 如果元素节点是<Alias>别名元素，进行别名解析
(delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
// 如果元素节点<Bean>元素, 按照Spring的Bean规则解析元素
(delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
// 如果元素节点<Beans>元素，即它是嵌套类型的
(delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// 递归解析
doRegisterBeanDefinitions(ele);
}
}解析Bean生成BeanDefinitionHolder的方法
/**
* Process the given bean element, parsing the bean definition
* and registering it with the registry.
*/
(Element ele, BeanDefinitionParserDelegate delegate) {
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
(bdHolder != ) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
{
// 注册最终的装饰实例
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
(BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered( BeanComponentDefinition(bdHolder));
}
}（这里就不展开了，无非就是解析XML各种元素，来生成BeanDefinition）
解析过后的BeanDefinition在IoC容器中的注册
Document对象的解析后得到封装BeanDefinition的BeanDefinitionHold对象，然后调用BeanDefinitionReaderUtils的registerBeanDefinition方法向IoC容器注册解析的Bean，BeanDefinitionReaderUtils的注册的源码如下：
// 通过BeanDefinitionRegistry将BeanDefinitionHolder注册到BeanFactory
(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
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();
(aliases != ) {
(String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}当调用BeanDefinitionReaderUtils向IoC容器注册解析的BeanDefinition时，真正完成注册功能的是DefaultListableBeanFactory。
DefaultListableBeanFactory向IoC容器注册解析后的BeanDefinition
IOC容器本质上就是一个beanDefinitionMap， 注册即将BeanDefinition put到map中
/** Map of bean definition objects, keyed by bean name. */
Map<String, BeanDefinition> beanDefinitionMap = ConcurrentHashMap<>(256);
/** Map from bean name to merged BeanDefinitionHolder. */
Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = ConcurrentHashMap<>(256);
@Override
(String beanName, BeanDefinition beanDefinition)
BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
(beanDefinition AbstractBeanDefinition) {
{
((AbstractBeanDefinition) beanDefinition).validate();
}
(BeanDefinitionValidationException ex) {
BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition existingDefinition = .beanDefinitionMap.get(beanName);
// 如果已经注册
(existingDefinition != ) {
// 检查是否可以覆盖
(!isAllowBeanDefinitionOverriding()) {
BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
(existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
(logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
(!beanDefinition.equals(existingDefinition)) {
(logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
{
(logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
// 覆盖
.beanDefinitionMap.put(beanName, beanDefinition);
}
{
(hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
(.beanDefinitionMap) {
.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = ArrayList<>(.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(.beanDefinitionNames);
updatedDefinitions.add(beanName);
.beanDefinitionNames = updatedDefinitions;
removeManualSingletonName(beanName);
}
}
{
// Still in startup registration phase
.beanDefinitionMap.put(beanName, beanDefinition);
.beanDefinitionNames.add(beanName);
removeManualSingletonName(beanName);
}
//重置所有已经注册过的BeanDefinition的缓存
.frozenBeanDefinitionNames = ;
}
(existingDefinition != || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
(isConfigurationFrozen()) {
clearByTypeCache();
}
}至此，Bean定义资源文件中配置的Bean被解析过后，已经注册到IoC容器中，被容器管理起来，真正完成了IoC容器初始化所做的全部工作。现 在IoC容器中已经建立了整个Bean的配置信息，这些BeanDefinition信息已经可以使用，并且可以被检索，IoC容器的作用就是对这些注册的Bean定义信息进行处理和维护。这些的注册的Bean定义信息是IoC容器控制反转的基础，正是有了这些注册的数据，容器才可以进行依赖注入。
总结
现在通过上面的代码，总结一下IOC容器初始化的基本步骤：
- 初始化的入口在容器实现中的 refresh()调用来完成
- 对 bean 定义载入 IOC 容器使用的方法是 loadBeanDefinition,其中的大致过程如下：
- 通过 ResourceLoader 来完成资源文件位置的定位，DefaultResourceLoader 是默认的实现，同时上下文本身就给出了 ResourceLoader 的实现，可以从类路径，文件系统, URL 等方式来定为资源位置。如果是 XmlBeanFactory作为 IOC 容器，那么需要为它指定 bean 定义的资源，也就是说 bean 定义文件时通过抽象成 Resource 来被 IOC 容器处理的
- 通过 BeanDefinitionReader来完成定义信息的解析和 Bean 信息的注册, 往往使用的是XmlBeanDefinitionReader 来解析 bean 的 xml 定义文件 - 实际的处理过程是委托给 BeanDefinitionParserDelegate 来完成的，从而得到 bean 的定义信息，这些信息在 Spring 中使用 BeanDefinition 对象来表示 - 这个名字可以让我们想到loadBeanDefinition,RegisterBeanDefinition 这些相关的方法 - 他们都是为处理 BeanDefinitin 服务的
- 容器解析得到 BeanDefinition 以后，需要把它在 IOC 容器中注册，这由 IOC 实现 BeanDefinitionRegistry 接口来实现。注册过程就是在 IOC 容器内部维护的一个HashMap 来保存得到的 BeanDefinition 的过程。这个 HashMap 是 IoC 容器持有 bean 信息的场所，以后对 bean 的操作都是围绕这个HashMap 来实现的.
- 然后我们就可以通过 BeanFactory 和 ApplicationContext 来享受到 Spring IOC 的服务了,在使用 IOC 容器的时候，我们注意到除了少量粘合代码，绝大多数以正确 IoC 风格编写的应用程序代码完全不用关心如何到达工厂，因为容器将把这些对象与容器管理的其他对象钩在一起。基本的策略是把工厂放到已知的地方，最好是放在对预期使用的上下文有意义的地方，以及代码将实际需要访问工厂的地方。 Spring 本身提供了对声明式载入 web 应用程序用法的应用程序上下文,并将其存储在ServletContext 中的框架实现。
参考文章
https://juejin.cn/post/6973884466171215908
https://juejin.cn/post/6844903838743265294
https://blog.csdn.net/hjing123/article/details/104867343
https://www.cnblogs.com/wl20200316/p/12522993.html
更多文章
首先， 从Spring框架的整体架构和组成对整体框架有个认知。
- Spring基础 - Spring和Spring框架组成
- Spring是什么？它是怎么诞生的？有哪些主要的组件和核心功能呢? 本文通过这几个问题帮助你构筑Spring和Spring Framework的整体认知。
其次，通过案例引出Spring的核心（IoC和AOP），同时对IoC和AOP进行案例使用分析。
- Spring基础 - Spring简单例子引入Spring的核心
- 上文中我们简单介绍了Spring和Spring Framework的组件，那么这些Spring Framework组件是如何配合工作的呢？本文主要承接上文，向你展示Spring Framework组件的典型应用场景和基于这个场景设计出的简单案例，并以此引出Spring的核心要点，比如IOC和AOP等；在此基础上还引入了不同的配置方式， 如XML，Java配置和注解方式的差异。
- Spring基础 - Spring核心之控制反转(IOC)
- 在Spring基础 - Spring简单例子引入Spring的核心中向你展示了IoC的基础含义，同时以此发散了一些IoC相关知识点; 本节将在此基础上进一步解读IOC的含义以及IOC的使用方式
- Spring基础 - Spring核心之面向切面编程(AOP)
- 在Spring基础 - Spring简单例子引入Spring的核心中向你展示了AOP的基础含义，同时以此发散了一些AOP相关知识点; 本节将在此基础上进一步解读AOP的含义以及AOP的使用方式。
基于Spring框架和IOC，AOP的基础，为构建上层web应用，需要进一步学习SpringMVC。
- Spring基础 - SpringMVC请求流程和案例
- 前文我们介绍了Spring框架和Spring框架中最为重要的两个技术点（IOC和AOP），那我们如何更好的构建上层的应用呢（比如web 应用），这便是SpringMVC；Spring MVC是Spring在Spring Container Core和AOP等技术基础上，遵循上述Web MVC的规范推出的web开发框架，目的是为了简化Java栈的web开发。 本文主要介绍SpringMVC的请求流程和基础案例的编写和运行。
Spring进阶 - IoC，AOP以及SpringMVC的源码分析
- Spring进阶 - Spring IOC实现原理详解之IOC体系结构设计
- 在对IoC有了初步的认知后，我们开始对IOC的实现原理进行深入理解。本文将帮助你站在设计者的角度去看IOC最顶层的结构设计
- Spring进阶 - Spring IOC实现原理详解之IOC初始化流程
- 上文，我们看了IOC设计要点和设计结构；紧接着这篇，我们可以看下源码的实现了：Spring如何实现将资源配置（以xml配置为例）通过加载，解析，生成BeanDefination并注册到IoC容器中的
- Spring进阶 - Spring IOC实现原理详解之Bean实例化(生命周期,循环依赖等)
- 上文，我们看了IOC设计要点和设计结构；以及Spring如何实现将资源配置（以xml配置为例）通过加载，解析，生成BeanDefination并注册到IoC容器中的；容器中存放的是Bean的定义即BeanDefinition放到beanDefinitionMap中，本质上是一个
ConcurrentHashMap<String, Object>；并且BeanDefinition接口中包含了这个类的Class信息以及是否是单例等。那么如何从BeanDefinition中实例化Bean对象呢，这是本文主要研究的内容？
- Spring进阶 - Spring AOP实现原理详解之切面实现
- 前文，我们分析了Spring IOC的初始化过程和Bean的生命周期等，而Spring AOP也是基于IOC的Bean加载来实现的。本文主要介绍Spring AOP原理解析的切面实现过程(将切面类的所有切面方法根据使用的注解生成对应Advice，并将Advice连同切入点匹配器和切面类等信息一并封装到Advisor，为后续交给代理增强实现做准备的过程)。
- Spring进阶 - Spring AOP实现原理详解之AOP代理
- 上文我们介绍了Spring AOP原理解析的切面实现过程(将切面类的所有切面方法根据使用的注解生成对应Advice，并将Advice连同切入点匹配器和切面类等信息一并封装到Advisor)。本文在此基础上继续介绍，代理（cglib代理和JDK代理）的实现过程。
- Spring进阶 - Spring AOP实现原理详解之Cglib代理实现
- 我们在前文中已经介绍了SpringAOP的切面实现和创建动态代理的过程，那么动态代理是如何工作的呢？本文主要介绍Cglib动态代理的案例和SpringAOP实现的原理。
- Spring进阶 - Spring AOP实现原理详解之JDK代理实现
- 上文我们学习了SpringAOP Cglib动态代理的实现，本文主要是SpringAOP JDK动态代理的案例和实现部分。
- Spring进阶 - SpringMVC实现原理之DispatcherServlet初始化的过程
- 前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第一篇：DispatcherServlet的初始化过程的源码解析。
- Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程
- 前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇：DispatcherServlet处理请求的过程的源码解析。
