Aaron_涛

2019-07-24 17:51 已编辑字节跳动_商业化技术_研发工程师

关注

【2】Ioc容器的初始化过程 --- BeanDefinition的Resource定位

1. 准备

编程式Ioc启动

ClassPathResource res = new ClassPathResource("beans.xml"); //定位资源

DefaultListableBeanFactory factory = new DefaultListableBeanFactory(); //创造个ioc容器

XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory); //创造个读取xml的BeanDefinition读取器

reader.loadBeanDefinitions(res);//用这个读取器去读取resource

这是手动启动ioc的流程，这是简单ioc容器，而ApplicationContext为我们提供里一系列加载不同Resources读取器的实现。但是换句话来说，ApplicationContext也是需要上述的流程，只不过它帮我们实现了，其实启动流程就在这里，和这个一样，不过是一个手动，一个自动的区别

2. 开始分析

以FileSystemXmlApplicationContext为例子

启动代码

public class FileSystemXmlApplicationContextStartProcess {

public static void main(String[] args){

FileSystemXmlApplicationContext cxt = new FileSystemXmlApplicationContext("bean.xml");

}

在FileSystemXmlApplicationContext中无论那个构造方法，都均调用这个构造构造方法

FileSystemXmlApplicationContext构造方法

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

//设置双亲容器

super(parent);

//存放入参

this.setConfigLocations(configLocations);

if (refresh) {

//ioc容器启动

this.refresh();

}

AbstractApplicationContext.refresh方法

public void refresh() throws BeansException, IllegalStateException {

Object var1 = this.startupShutdownMonitor;

synchronized(this.startupShutdownMonitor) {

this.prepareRefresh();

//定位资源流程主要在这里，得到一个beanFactory，也就是Ioc容器，这也上述手动编程式开启ioc一样需要个ioc容器

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 var5) {

this.destroyBeans();

this.cancelRefresh(var5);

throw var5;

}

AbstractApplicationContext.obtainFreshBeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

//进入这里，这里是构造BeanFactory的地方

this.refreshBeanFactory();

ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();

if (this.logger.isDebugEnabled()) {

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

}

return beanFactory;

}

AbstractRefreshableApplicationContext.refreshBeanFactory

protected final void refreshBeanFactory() throws BeansException {

//如果存在就先销毁这个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);

}

AbstractXmlApplicationContext.loadBeanDefinitions

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

//构造一个xml的BeanDfinition读取器这里也和上述编程式开启ioc一样，需要个读取器

XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

beanDefinitionReader.setEnvironment(this.getEnvironment());

beanDefinitionReader.setResourceLoader(this);

beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

this.initBeanDefinitionReader(beanDefinitionReader);

//加载BeanDefinition

this.loadBeanDefinitions(beanDefinitionReader);

}

AbstractXmlApplicationContext.loadBeanDefinitions

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

//如果资源已经定位，那么就走这里

Resource[] configResources = this.getConfigResources();

if (configResources != null) {

reader.loadBeanDefinitions(configResources);

}

//资源还没定位，那么就还是字符串形式的上面例子就是bean.xml

String[] configLocations = this.getConfigLocations();

if (configLocations != null) {

reader.loadBeanDefinitions(configLocations);

}

AbstractBeanDefinitionReader.loadBeanDefinitions

public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {

Assert.notNull(locations, "Location array must not be null");

int counter = 0;

String[] var3 = locations;

int var4 = locations.length;

//如果是资源文件很多，那么一个一个的加载

for(int var5 = 0; var5 < var4; ++var5) {

String location = var3[var5];

//加载BeanDefinition

counter += this.loadBeanDefinitions(location);

}

return counter;

}

AbstractBeanDefinitionReader.loadBeanDefinitions

public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {

//这个获取的是FileSystemXmlApplicationContext本身，因为这个ApplicationContext是扩展了ResourceLoader这个接口的

ResourceLoader resourceLoader = this.getResourceLoader();

if (resourceLoader == null) {

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

} else {

int loadCount;

if (!(resourceLoader instanceof ResourcePatternResolver)) {

//调用getResource完成资源定位

Resource resource = resourceLoader.getResource(location);

loadCount = this.loadBeanDefinitions((Resource)resource);

if (actualResources != null) {

actualResources.add(resource);

}

if (this.logger.isDebugEnabled()) {

this.logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");

}

return loadCount;

} else {

try {

//调用getResource完成资源定位,这里实际上调用的是PathMatchingResourcePatternResolver这个类这里是ioc初始化的第一部分

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

//定位好Resource就开始拿到Resources开始loadBeanDefinition 这是ioc初始化的第二部分和上述编程式开启ioc一样，找到资源后用读取器读取资源

loadCount = this.loadBeanDefinitions(resources);

if (actualResources != null) {

Resource[] var6 = resources;

int var7 = resources.length;

for(int var8 = 0; var8 < var7; ++var8) {

Resource resource = var6[var8];

actualResources.add(resource);

}

if (this.logger.isDebugEnabled()) {

this.logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");

}

return loadCount;

} catch (IOException var10) {

throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", var10);

}

PathMatchingResourcePatternResolver.getResources

//这个方法主要是就是把资源的String类型表示，变成Resource

public Resource[] getResources(String locationPattern) throws IOException {

Assert.notNull(locationPattern, "Location pattern must not be null");

if (locationPattern.startsWith("classpath*:")) {

return this.getPathMatcher().isPattern(locationPattern.substring("classpath*:".length())) ? this.findPathMatchingResources(locationPattern) : this.findAllClassPathResources(locationPattern.substring("classpath*:".length()));

} else {

//因为是文件资源bean.xml 所以最后执行到这步

int prefixEnd = locationPattern.indexOf(":") + 1;

return this.getPathMatcher().isPattern(locationPattern.substring(prefixEnd)) ? this.findPathMatchingResources(locationPattern) : new Resource[]{this.getResourceLoader().getResource(locationPattern)};

}

DefaultResourceLoader.getResource

public Resource getResource(String location) {

Assert.notNull(location, "Location must not be null");

if (location.startsWith("/")) {

return this.getResourceByPath(location);

} else if (location.startsWith("classpath:")) {

return new ClassPathResource(location.substring("classpath:".length()), this.getClassLoader());

} else {

try {

URL url = new URL(location);

return new UrlResource(url);