Spring源码分析(二)(IoC容器的实现)(2)

扫码关注公众号:Java 技术驿站

发送:vip
将链接复制到本浏览器,永久解锁本站全部文章

【公众号:Java 技术驿站】 【加作者微信交流技术,拉技术群】
免费领取10G资料包与项目实战视频资料

IoC容器的初始化过程

简单来说IoC容器的初始化是由refresh()方法启动的,这个方法标志着IoC容器的正式启动。这个启动包括BeanDefinition的Resouce定位、载入和注册三个基本过程。

第一个过程是Resource定位过程。这个Resource定位指的是BeanDefinition的资源定位,它由ResourceLoader通过统一的Resource 接口来完成,这个Resource对各种形式的BeanDefinition的使用都提供了统一接口。这个定位过程类似于容器寻找数据的过程,就像用水桶装水先要把水找到一样。
第二个过程是BeanDefinition的载入。这个载入过程是把用户定义好的Bean表示成IoC容器内部的数据结构,而这个容器内部的数据结构就是BeanDefinition。具体来说,这个BeanDefinition实际上就是POJO对象在IoC容器中的抽象,通过这个BeanDefinition定义的数据结构,使loC容器能够方便地对POJO对象也就是Bean进行管理。
第三个过程是向IoC 容器注册这些BeanDefinition 的过程。这个过程是通过调用BeanDefinitionRegistry接口的实现来完成的。这个注册过程把载入过程中解析得到的BeanDefinition 向IoC容器进行注册。通过分析,我们可以看到,在IoC容器内部将BeanDefinition注入到一个HashMap 中去, IoC容器就是通过这个HashMap来持有这些BeanDefinition数据的。
这里谈的是IoC容器初始化过程,在这个过程中,一般不包含Bean依赖注入的实现。在Spring IoC的设计中, Bean定义的载入和依赖注入是两个独立的过程。依赖注入一般发生在应用第一次通过getBean向容器索取Bean的时候.但有一个例外值得注意,在使用IoC容器时有一个预实例化的配置,通过这个预实例化的配置(通过为Bean定义信息中的lazyinit属性),用户可以对容器初始化过程作一个微小的控制,从而改变这个被设置了lazyinit属性的Bean的依赖注入过程。

BeanDefinition的Resource定位

            ClassPathResource res=new ClassPathResource("beans.xml");
            DefaultListableBeanFactory factory=new DefaultListableBeanFactory();
            XmlBeanDefinitionReader reader=new XmlBeanDefinitionReader(factory);
            reader.loadBeanDefinitions(res);

以编程的方式使用DefaultListableBeanFactory时,首先定义一个Resource来定位容器使用的BeanDefinition。 这时使用的是ClassPathResource ,这意味着Spring会在类路径中去寻找以文件形式存在的BeanDefinition信息。这里定义的Resource并不能由DefaultListableBeanFactory直接使用, Spring通过BeanDefinitionReader来对这些信息进行处理。

这里也可以看到使用ApplicationContext相对于直接使用DefaultListableBeanFactory的好处。因为在ApplicationContext 中,Spring已经为我们提供了一系列加载不同Resource 的读取器的实现,而DefaultListableBeanFactory只是一个纯粹的IoC容器, 需要为它配置特定的读取器才能完成这些功能。当然,有利就有弊, 使用DefaultListableBeanFactory这种更底层的容器,能提高定制IoC容器的灵活性。

下面通过源码看下FileSystemXmlApplicationcontext的继承体系:(Ctrl+Shift+Alt+U)

20191017100393\_1.png

FileSystemXmlApplicationContext 已经通过继承AbstractApplicationContext具备了ResourceLoader读入以Resource定义的BeanDefinition的能力,因为AbstractAppIiationContext 的基类是DefaultResourceLoader。

    public class FileSystemXmlApplicationContext extends AbstractXmlApplicationContext {

        public FileSystemXmlApplicationContext() {
        }

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

        //这个构造函数的configLocation包含的是BeanDefinition所在的文件路径
        public FileSystemXmlApplicationContext(String configLocation) throws BeansException {
            this(new String[]{configLocation}, true, null);
        }

        //这个构造函数允许configLocations包含多个BeanDefinition的文件路径
        public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
            this(configLocations, true, null);
        }

        //这个构造函数在运行configLocation包含多个BeanDefinition的文件路径的同时,还允许指定自己的双亲IoC容器
        public FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException {
            this(configLocations, true, parent);
        }

        public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
            this(configLocations, refresh, null);
        }

        //在对象的初始化过程中,调用refresh函数载入BeanDefinition,这个refresh启动了BeanDefinition的载入过程
        public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
                throws BeansException {

            super(parent);
            setConfigLocations(configLocations);//设置此应用程序上下文的配置位置。如果没有设置,实现可能会在适当的时候使用默认值。
            if (refresh) {
                refresh();//AbstractApplicationContext的refresh
            }
        }

        //这是应用于文件系统中Resource的实现,通过构造一个FileSystemResource来得到一个在文件系统中定位的BeanDefinition
        //这个getResourceByPath是在BeanDefinitionReader的loadBeanDefintion中被调用的
        //loadBeanDefintion采用了模板模式,具体的定位实现实际上由各个子类来完成的
        @Override
        protected Resource getResourceByPath(String path) {
            if (path != null && path.startsWith("/")) {
                path = path.substring(1);
            }
            return new FileSystemResource(path);//获取资源的定位
        }

    }

在FileSystemApplicationContext中,我们可以看到在构造函数中.实现了对configuration进行处理的功能。让所有配置在文件系统中的,以XML文件方式存在的BeanDefnition都能够得到有效的处理,比如,实现了getResourceByPath方法,这个方法是一个模板方法,是为读取Resource 服务的。对于IoC 容器功能的实现,这里没有涉及,因为它继承了AbstractXmlApplicationContext ,关于Ioc容器功能相关的实现,都是在FileSysternXmlApplicationContext中完成的,但是在构造函数中通过refresh来启动IoC容器的初始化。

对BeanDefinition资源定位的过程,最初是由refresh来触发的,这个refresh的调用是在FileSysternXmlBeanFactory的构造函数中启动的,大致的调用过程如图:

20191017100393\_2.png

AbstractAppllicationContext类的refresh方法:

        public void refresh() throws BeansException, IllegalStateException {
            synchronized (this.startupShutdownMonitor) {
                // 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);

                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();
            ConfigurableListableBeanFactory beanFactory = getBeanFactory();
            if (logger.isDebugEnabled()) {
                logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
            }
            return beanFactory;
        }

重点看看AbstractRefreshableApplicationContext的refreshBeanFactory方住的实现,这个refreshBeanFactory被FileSystemXmlApplicationContext构造函数中的refresh调用。在这个方法中,通过createBeanFactroy构建了一个IoC容器供ApplicationContext使用。这个IoC容器就是前面提到过的DefaultListableBeanFactory ,同时,它启动了loadBeanDefinitions来载入BeanDefinition ,这个过程和前面以编程式的方法来使用IoC容器( XmIBeanFactory)的过程非常类似。

在初始化FileSystmXmlApplicationContext的过程中,通过IoC容器的初始化的refresh来启动整个调用,使用的IoC容器是DefultListableBeanFactory.。具体的资源载入在XmIBeanDefinitionReader 读入BeanDefinition 时完成,在
XmlBeanDefinitionReader的基类AbstractBeanDefinitionReader中可以看到这个载入过程的具体实现。对载入过程的启动,可以在AbstractRefreshableApplicationContext 的loadBeanDefinitions方法中看到:

        protected final void refreshBeanFactory() throws BeansException {
                    //这里判断,如果已经建立BeanFactory,则销毁并关闭该BeanFactory
            if (hasBeanFactory()) {
                destroyBeans();
                closeBeanFactory();
            }
                    //这里是创建并设置持有的DefaultListableBeanFactory的地方同时调用
                    //loadBeanDefinitions在载入BeanDefinition的信息
            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);
            }
        }

            //这就是在上下文中创建DefaultListableBeanFactory 的地方,getInternalParentBeanFactory的具体实现可以看AbstractApplicationContext中的实现,会根据容器已有的双亲IoC容器的信息来生成DefaultListableBeanFactory 的双亲IoC容器
        protected DefaultListableBeanFactory createBeanFactory() {
            return new DefaultListableBeanFactory(getInternalParentBeanFactory());
        }

        protected BeanFactory getInternalParentBeanFactory() {
            return (getParent() instanceof ConfigurableApplicationContext) ?
                    ((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent();
        }

然后看下loadBeanDefinitions方法:

    //这是BeanDefinitionReader载入Bean定义的地方,因为有多种载入方式,虽然用xml定义方式较多,这里通过抽象函数把具体的实现委托给子类完成
    protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
                throws BeansException, IOException;

    //通过类图可以看到AbstractXmlApplicationContext会将其实现:
        protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
            // 为给定的BeanFactory创建一个新的XmlBeanDefinitionReader
            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);
            }
        }

    //最后他会调用这个loadBeanDefinitions方法:
    public int loadBeanDefinitions(String location, 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的路径模式进行解析,比如我们设定的各种Ant格式的路径定义,得到
    //需要的Resource集合,这些resource集合指向我们已经定义好的BeanDefinition信息,可以是多个文件
            if (resourceLoader instanceof ResourcePatternResolver) {
                // Resource pattern matching available.
                try {
    //调用DefaultResourceLoader的getResource完成具体的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.
                            //调用DefaultResourceLoader的getResource完成具体的Resource定位
                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;
            }
        }

对于取得Resource的具体过程可以看看DefaultResourceLoader:

        public Resource getResource(String location) {
            Assert.notNull(location, "Location must not be null");

            for (ProtocolResolver protocolResolver : this.protocolResolvers) {
                Resource resource = protocolResolver.resolve(location, this);
                if (resource != null) {
                    return resource;
                }
            }

            if (location.startsWith("/")) {
                return getResourceByPath(location);
            } //这里处理带有classpath标示的Resource
            else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
                return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
            }
            else {
                try {
                    //这里处理URL标示的Resource定位
                    URL url = new URL(location);
                    return new UrlResource(url);
                }
                catch (MalformedURLException ex) {
                    // No URL -> resolve as resource path.
                    //如果既不是classpath也不是URL标示的Resource定位,则把getResource的实现交给getResourceByPath
                    //这个方法是一个protected方法,默认实现是得到一个ClassPathContextResource,这个方法常常用子类实现
                    return getResourceByPath(location);
                }
            }
        }

        protected Resource getResourceByPath(String path) {
            return new ClassPathContextResource(path, getClassLoader());
        }

前面我们看到的getResourceByPath会被子类FileSystemXmlApplicationContext实现,这个方法返回的是一个FileSystemResource对象,通过这个对象, Spring可以进行相关的I/O操作,完成BeanDefinition的定位。它实现的就是对path进行解析,然后生成一个FileSystemResource对象并返回:

        protected Resource getResourceByPath(String path) {
            if (path != null && path.startsWith("/")) {
                path = path.substring(1);
            }
            return new FileSystemResource(path);//获取资源的定位
        }

我们以FileSystemXmlApplicationContext的实现原理为例子, 了解了Resource定位问题的解决方案,即以FileSystem方式存在的Resource的定位实现。在BeanDefinition定位完成的基础上,就可以通过返回的Resource对象来进行BeanDefinition的载入了。在定位过程完成以后,为BeanDefinition的载入创造了I/O操作的条件,但是具体的数据还没有开始读人。这些数据的读人将在下面介绍的BeanDefinition的载入和解析中来完成。

参考:《SPRING技术内幕》


来源:[]()

赞(0) 打赏
版权归原创作者所有,任何形式的转载请联系博主:daming_90:Java 技术驿站 » Spring源码分析(二)(IoC容器的实现)(2)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏