IoC容器初始化过程（一）：Resource定位

BeanDefinition

application.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
     <!--XML方式配置Bean-->  
    <bean id="student" class="com.springleanring.Student">
    </bean>
</beans>

Spring会把配置在XML中的bean信息转为IoC容器内部的数据结构，这个数据结构就是
BeanDefinition，也就是说在Spring的XML配置文件中存在的元素，在容器初始化时，会读取这些XML文件，从中解析，然后封装为BeanDefinition对象。

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
     
	String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
	
	String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

	int ROLE_APPLICATION = 0;

	int ROLE_SUPPORT = 1;

	int ROLE_INFRASTRUCTURE = 2;
	
	void setParentName(@Nullable String parentName);

	@Nullable
	String getParentName();
	
	void setBeanClassName(@Nullable String beanClassName);//设置bean的className

	@Nullable
	String getBeanClassName();

	void setScope(@Nullable String scope);//设置bean的scope属性

	@Nullable
	String getScope();

	void setLazyInit(boolean lazyInit);//设置lazyInit
	
	boolean isLazyInit();//

	void setDependsOn(@Nullable String... dependsOn);
	
	//省略了其他方法
}

IoC容器初始化过程

（1）Resource定位过程

Resource定位指的是BeanDefinition的资源定位，这个过程类似于容器寻找数据的过程。

以在application.xml中配置的为例:

BeanDefinition是元素在IoC容器内部的存在形式，对BeanDefinition的定位也就是对元素所在资源文件application.xml的定位，定位到资源文件的位置才能从application.xml中读取信息，因此IoC容器初始化时首先要完成对Resource的定位。

（2）BeanDefinition的载入

这个载入过程是把用户定义好的Bean表示成IoC容器的内部数据结构，这个容器内部数据结构就是BeanDefinition,也就是POJO对象在IoC容器中的抽象，通过BeanDefinition IoC容器可以方便的对Bean进行管理。

（3）向IoC容器注册这些BeanDefinition

BanDefinition注册指的是将第(2)步中得到的每一个BeanDefinition注册到一个HashMap中，IoC容器通过这个HashMap来持有这些BeanDefinition数据。

Spring IoC中的两个主要容器

IoC容器可以理解为spring管理Bean的地方。

（1）BeanFactory

是一个接口，定义了IoC容器最基本的功能规范，提供容器最基本的功能。如getBean方法，通过该方法可以从容器中获取Bean。


public interface BeanFactory {

	/**
	 * 通过name获取容器中管理的bean
	 * @param name bean的name
	 * @return bean的一个实例
	 */
	Object getBean(String name) throws BeansException;
	
	<T> T getBean(String name, @Nullable Class<T> requiredType)throws BeansException;

    Object getBean(String name, Object... args) throws BeansException;
     
    <T> T getBean(Class<T> requiredType) throws BeansException;
     
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    
    boolean containsBean(String name);//是否包含某个bean
      
    //是否是单 模式
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    //是否是原型模式
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    //省略了其他方法
}

（2）ApplicationContext

如果说BeanFactory是IoC容器的基本形式，那么ApplicationContext就是IoC容器的高级表现形式，它除了包含BeanFactory中的基本方法，还提供了一些其他的方法。

ApplicationContext同样是一个接口，它继承了ListableBeanFactory接口，ListableBeanFactory继承了BeanFacotry接口，因此ApplicationContext包含了BeanFactory接口中的所有方法。

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

	String getId();

	String getApplicationName();
	
	String getDisplayName();

	long getStartupDate();

	ApplicationContext getParent();
	
	AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

}

常用的实现ApplicationContext接口的三种容器：

FileSystemXmlApplicationContext：从文件系统载入Resource

ClassPathXmlApplicationContext：从class path载入Resource

XmlWebApplicationContext：在web容器中载入Resource

通过ApplicationContext从容器中获取一个bean:

//使用FileSystemXmlApplicationContext加载配置文件
ApplicationContext context=new FileSystemXmlApplicationContext("classpath*:/spring/applicationContext.xml");
//ClassPathXmlApplicationContext加载
//ApplicationContext context=new ClassPathXmlApplicationContext("classpath*:/spring/applicationContext.xml");
//从容器中获取bean
Student student= (Stuedent) context.getBean("student");//根据id从配置文件中获取bean
student.getName();

那么就以FileSystemXmlApplicationContext为例，分析ApplicationContext的实现过程。

1.FileSystemXmlApplicationContext

public FileSystemXmlApplicationContext {
   }

   public FileSystemXmlApplicationContext(ApplicationContext parent) {
       super(parent);
   }

   /** 
    * 构造函数：需要传入XML资源文件的路径 
    */
   public FileSystemXmlApplicationContext(String configLocation) throws BeansException {
       this(new String[]{configLocation}, true, (ApplicationContext)null);
   }
   
   /** 
    * 构造函数：传入多个资源文件 
    */
   public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
       this(configLocations, true, (ApplicationContext)null);
   }

   /** 
    * 构造函数 
    * @param configLocations 资源文件数组 
    * @param parent 双亲IoC容器 
    */
   public FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException {
       this(configLocations, true, parent);
   }
   
   /** 
    * 构造函数 
    * @param configLocations 资源文件路径 
    * @param refresh 是否调用refresh方法载入BeanDefinition 
    */ 
   public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
       this(configLocations, refresh, (ApplicationContext)null);
   }

   /** 
    * 构造函数,其他构造函数最终调用的都是该函数
    * @param configLocations 资源文件路径 
    * @param refresh 是否调用refresh方法载入BeanDefinition 
    */ 
   public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
       super(parent);
       this.setConfigLocations(configLocations);
       if(refresh) {
           this.refresh();//分析容器初始化的一个重要入口
       }

   }
   /**
    * 通过资源文件路径获取Resource对象,返回的是一个FileSystemResource对象，通过这个对象可以进行相关I/O操作，完成BeanDefinition定位 
    * @param path 资源文件路径 
    * @return Resource spring中的资源对象 
    */ 
   protected Resource getResourceByPath(String path) {
       if(path.startsWith("/")) {
           path = path.substring(1);
       }

       return new FileSystemResource(path);
   }

从第二个构造函数开始，实际上都是调用的 FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)这个构造函数。
对BeanDefinition资源定位的过程是从refresh方法开始的，refresh方法是分析容器初始化的重要入口。

2.AbstractApplicationContext

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
 public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
            // 调用obtainFreshBeanFactory()方法获取IoC容器，容器的创建和对Resource的定位就在该方法中
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if(this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }
}
/**
 * 获取BeanFactory
 */
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        //refreshBeanFactory中会创建IoC容器
        this.refreshBeanFactory();
        //获取创建的IoC容器
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if(this.logger.isDebugEnabled()) {
            this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
        }

        return beanFactory;
    }

public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;

refreshBeanFactory()方法，在AbstractApplicationContext中，该方法是一个抽象方法，具体的实现由AbstractApplicationContext的子类AbstractRefreshableApplicationContext来实现，该方法中创建了IoC容器BeanFacotry对象。
getBeanFactory()方法也是抽象方法，在AbstractRefreshableApplicationContext中实现，其实就是返回refreshBeanFactory方法中创建的BeanFacotry对象。

3.AbstractRefreshableApplicationContext

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {

protected final void refreshBeanFactory() throws BeansException {
        //如果已经建立了BeanFactory,销毁并关闭BeanFactory  
        if(this.hasBeanFactory()) {
            this.destroyBeans();
            this.closeBeanFactory();
        }

        try {
           //构造了一个BeanFactory,这里使用DefaultListableBeanFactory实现  
            DefaultListableBeanFactory beanFactory = this.createBeanFactory();
            beanFactory.setSerializationId(this.getId());
            this.customizeBeanFactory(beanFactory);
            //载入BeanDefinition 
            this.loadBeanDefinitions(beanFactory);
            Object var2 = this.beanFactoryMonitor;
            synchronized(this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        } catch (IOException var5) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
        }
    }
    
    /** 
     * 创建DefaultListableBeanFactory的地方 
     * getInternalParentBeanFactory()的具体实现可以参看AbstractApplicationContext的实现 
     * 
     * @return 
     */
    protected DefaultListableBeanFactory createBeanFactory() {
        return new DefaultListableBeanFactory(this.getInternalParentBeanFactory());
    }
    
    /** 
     * 获取创建的IoC容器
     */
    public final ConfigurableListableBeanFactory getBeanFactory() {
        Object var1 = this.beanFactoryMonitor;
        synchronized(this.beanFactoryMonitor) {
            if(this.beanFactory == null) {
                throw new IllegalStateException("BeanFactory not initialized or already closed - call 'refresh' before accessing beans via the ApplicationContext");
            } else {
                return this.beanFactory;
            }
        }
    }
    
    /** 
     * 抽象方法，载入BeanDefinition,由子类AbstractXmlApplicationContext实现
     * 
     * @param beanFactory 
     * @throws BeansException 
     * @throws IOException 
     */  
    protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)  
            throws BeansException, IOException;
}

refreshBeanFactory()方法中调用了createBeanFactory()方法完成了容器的创建，使用的是DefaultListableBeanFactory类型的容器。
创建容器之后，调用了loadBeanDefinitions()方法载入BeanDefinition，该方法由子类AbstractXmlApplicationContext实现。
loadBeanDefinitions()方法中包含了Resource资源定位的过程。

4.AbstractXmlApplicationContext

public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {

    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        //创建XmlBeanDefinitionReader对象，通过回调设置到BeanFactory中 
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        //设置ResourceLoader
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
        //启动Bean定义信息载入的过程，委托给beanDefinitionReader完成  
        this.initBeanDefinitionReader(beanDefinitionReader);
        //载入BeanDefinition
        this.loadBeanDefinitions(beanDefinitionReader);
    }
    
       protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {  
           reader.setValidating(this.validating);  
       }  
  
       /** 
        * 载入BeanDefinition 
        * @param reader 
        * @throws BeansException 
        * @throws IOException 
        */  
       protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {  
           //获取Reource类型的配置文件的地址
           Resource[] configResources = getConfigResources();  
           if (configResources != null) {  
               //调用AbstractBeanDefinitionReader中的loadBeanDefinitions方法 
               reader.loadBeanDefinitions(configResources);
               }  
           //获取字符串类型的配置文件的地址
           String[] configLocations = getConfigLocations();  
           if (configLocations != null) {  
               //调用AbstractBeanDefinitionReader中的loadBeanDefinitions方法 
               reader.loadBeanDefinitions(configLocations);  
           }  
       }  
  
       protected Resource[] getConfigResources() {  
           return null;  
       }
}

loadBeanDefinitions(DefaultListableBeanFactory beanFactory)方法中首先创建了XmlBeanDefinitionReader对象，从名称上可以猜到，它可以读取XML中定义的bean信息。
loadBeanDefinitions(XmlBeanDefinitionReader reader)方法中又调用了XmlBeanDefinitionReader中的loadBeanDefinitions()方法，XmlBeanDefinitionReader是AbstractBeanDefinitionReader的子类，该方法在AbstractBeanDefinitionReader中实现。

5.AbstractBeanDefinitionReader

载入BeanDefinition时：

AbstractBeanDefinitionReader中实现的是参数类型是String的方法。
如果传入的参数是Resource类型的，先进入到loadBeanDefinitions(Resource… resources)方法中，在该方法中又会调用XmlBeanDefinitionReader中的loadBeanDefinitions方法，也就是如果参数类型是Resource，是由XmlBeanDefinitionReader实现的。

查看上面FileSystemXmlApplicationContext用法的例子，传入的参数是资源文件的地址，因此调用的是AbstractBeanDefinitionReader的loadBeanDefinitions(String… locations)方法：

1	FileSystemXmlApplicationContext("classpath*:/spring/applicationContext.xml");

AbstractBeanDefinitionReader类中实现的方法为例：

public abstract class AbstractBeanDefinitionReader implements EnvironmentCapable, BeanDefinitionReader {

    /** 
    * 载入参数类型是Resource对象的BeanDefinition，由子类XmlBeanDefinitionReader实现
    */ 
	@Override
	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		//对载入Bean的数量进行统计
		int counter = 0;
		//遍历整个Resource集合，从每个集合中载入所有的BeanDefinition
		for (Resource resource : resources) {
		    //loadBeanDefinitions方法是一个接口方法，在XmlBeanDefinitionReader中有具体的实现  
			counter += loadBeanDefinitions(resource);
		}
		return counter;
	}
	
   /** 
    * 根据配置文件的地址，载入BeanDefinition
    */ 
	@Override
	public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(location, null);
	}

	public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
	   //获取ResourceLoader对象，实际使用的是DefaultResourceLoader  
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
		}
       //这里对Resource的路径模式进行解析，得到Resource集合，这些集合指向我们已经定义好的BeanDefinition信息
		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
			    //调用DefaultResourceLoader的getResource完成Resource定位，将传入的资源文件的地址，转为Resource对象
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				int loadCount = loadBeanDefinitions(resources);
				if (actualResources != null) {
					for (Resource resource : resources) {
						actualResources.add(resource);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
				}
				return loadCount;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		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;
		}
	}

   /** 
    * 根据配置文件的地址，载入BeanDefinition
    */ 
	@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;
	}
}

在loadBeanDefinitions(String location, @Nullable Set actualResources)方法中定义了ResourceLoader对象，由ResourceLoader完成资源的加载。ResourceLoader其实是使用了DefaultResourceLoader对象的getResource方法完成Resource对象的定位。
在loadBeanDefinitions(String location, @Nullable Set actualResources)方法中根据location资源文件地址将资源文件转为了Resource对象，然后还是调用的XmlBeanDefinitionReader中的loadBeanDefinitions(Resource resource)完成BeanDefinition的载入。

6.DefaultResourceLoader

进入DefaultResourceLoader看一下如何根据配置文件地址完成对Resource的定位:

public class DefaultResourceLoader implements ResourceLoader {  
     public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");
        Iterator var2 = this.protocolResolvers.iterator();

        Resource resource;
        do {
            if(!var2.hasNext()) {
                //处理带有/反斜杠的resource  
                if(location.startsWith("/")) {
                    return this.getResourceByPath(location);
                }
                //处理带有calsspath标识的resource  
                if(location.startsWith("classpath:")) {
                    return new ClassPathResource(location.substring("classpath:".length()), this.getClassLoader());
                }

                try {
                    //处理URL标识的resource  
                    URL url = new URL(location);
                    return (Resource)(ResourceUtils.isFileURL(url)?new FileUrlResource(url):new UrlResource(url));
                } catch (MalformedURLException var5) {
                    return this.getResourceByPath(location);
                }
            }

            ProtocolResolver protocolResolver = (ProtocolResolver)var2.next();
            resource = protocolResolver.resolve(location, this);
        } while(resource == null);

        return resource;
    }
    
    protected Resource getResourceByPath(String path) {
        return new DefaultResourceLoader.ClassPathContextResource(path, this.getClassLoader());
    }
}

到此，IoC容器对Resource的定位过程已经完成。

最后简单总结一下重点流程：

1.初始化时需要创建容器BeanFactory,默认使用的是DefaultListableBeanFactory类型的容器。
2.容器创建之后，会调用loadBeanDefinitions()方法载入BeanDefinition.
载入过程中的流程：
(1)创建XmlBeanDefinitionReader对象，为读取XML资源文件中定义的bean信息做准备。
(2)为XmlBeanDefinitionReader对象设置ResoucrLoader,用于资源文件的加载。
(3)调用XmlBeanDefinitionReader父类AbstractBeanDefinitionReader中实现的loadBeanDefinitions()方法，传入资源文件对象或文件地址，在这一步中，ResourceLoader对象实际使用的是DefaultResourceLoader。
(4)在DefaultResourceLoader中完成了对Resource的定位。

参考:

spring技术内幕:深入解析spring架构与设计原理

竹叶青1986:Spring源码阅读之IoC容初始化1 – Resource定位

Spring版本:5.0.5