Spring源码分析

1.运行原理

2.ClassPathXmlApplicationContext

调用refresh() 方法进行容器初始化

2.1实例化工厂

2.1.1 obtainFreshBeanFactory

创建工厂并且对Bean进行加载

//工厂初始化        
this.refreshBeanFactory();
//得到工厂DefaultListableBeanFactory
ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();

实例化Bean

            this.loadBeanDefinitions(beanFactory);

加载配置文件

    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
//用户自定义资源
        Resource[] configResources = this.getConfigResources();
        if (configResources != null) {
            reader.loadBeanDefinitions(configResources);
        }
//文件自身资源
        String[] configLocations = this.getConfigLocations();
        if (configLocations != null) {
            reader.loadBeanDefinitions(configLocations);
        }

    }

    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        if (delegate.isDefaultNamespace(root)) {
            NodeList nl = root.getChildNodes();

            for(int i = 0; i < nl.getLength(); ++i) {
                Node node = nl.item(i);
                if (node instanceof Element) {
                    Element ele = (Element)node;
                    if (delegate.isDefaultNamespace(ele)) {
                        this.parseDefaultElement(ele, delegate);
                    } else {
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        } else {  //解析用户自定义
            delegate.parseCustomElement(root);
        }

    }

    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, "import")) {
            this.importBeanDefinitionResource(ele);
        } else if (delegate.nodeNameEquals(ele, "alias")) {
            this.processAliasRegistration(ele);
        } else if (delegate.nodeNameEquals(ele, "bean")) {
            this.processBeanDefinition(ele, delegate);
        } else if (delegate.nodeNameEquals(ele, "beans")) {
            this.doRegisterBeanDefinitions(ele);
        }

    }

注册Bean

    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//根据标签解析得到一个BeanDefinitionHolder 可以执行Bean加载 到Spring容器中
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

            try {
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
            } catch (BeanDefinitionStoreException var5) {
                this.getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, var5);
            }

            this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }

    }

    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 var4) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var4);
            }
        }
		//从注册表中中先通过beanName获取
        BeanDefinition oldBeanDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
        if (oldBeanDefinition != null) {
            if (!this.allowBeanDefinitionOverriding) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + oldBeanDefinition + "] bound.");
            }

            if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Overriding user-defined bean definition for bean '" + beanName + " with a framework-generated bean definition ': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
                }
            } else if (this.logger.isInfoEnabled()) {
                this.logger.info("Overriding bean definition for bean '" + beanName + "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
            }
        } else {
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
            this.frozenBeanDefinitionNames = null;
        }
		//添加到Bean的注册表中
        this.beanDefinitionMap.put(beanName, beanDefinition);
        if (oldBeanDefinition != null || this.containsSingleton(beanName)) {
            this.resetBeanDefinition(beanName);
        }

    }

2.1.2 DefaultListableBeanFactory

spring用改工厂当默认的IOC容器使用

2.2注册到Bean缓冲池中

2.2.1finishBeanFactoryInitialization

    public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Pre-instantiating singletons in " + this);
        }

        List<String> beanNames = new ArrayList(this.beanDefinitionNames);
        Iterator var2 = beanNames.iterator();

        while(true) {
            while(true) {
                String beanName;
                RootBeanDefinition bd;
                do {
                    do {
                        do {
                            if (!var2.hasNext()) {
                                var2 = beanNames.iterator();

                                while(var2.hasNext()) {
                                    beanName = (String)var2.next();
                                    Object singletonInstance = this.getSingleton(beanName);
                                    if (singletonInstance instanceof SmartInitializingSingleton) {
                                        final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                        if (System.getSecurityManager() != null) {
                                            AccessController.doPrivileged(new PrivilegedAction<Object>() {
                                                public Object run() {
                                                    smartSingleton.afterSingletonsInstantiated();
                                                    return null;
                                                }
                                            }, this.getAccessControlContext());
                                        } else {
                                            smartSingleton.afterSingletonsInstantiated();
                                        }
                                    }
                                }

                                return;
                            }

                            beanName = (String)var2.next();
                            bd = this.getMergedLocalBeanDefinition(beanName);
                        } while(bd.isAbstract());
                    } while(!bd.isSingleton()); //不是单例
                } while(bd.isLazyInit());  //懒加载

                if (this.isFactoryBean(beanName)) {
                    final FactoryBean<?> factory = (FactoryBean)this.getBean("&" + beanName);
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = (Boolean)AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                            public Boolean run() {
                                return ((SmartFactoryBean)factory).isEagerInit();
                            }
                        }, this.getAccessControlContext());
                    } else {
                        isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
                    }

                    if (isEagerInit) {
                        this.getBean(beanName);
                    }
                } else {
                    this.getBean(beanName);
                }
            }
        }
    }

2.3GetBean

    public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {
        Assert.notNull(requiredType, "Required type must not be null");
        String[] beanNames = this.getBeanNamesForType(requiredType);
        String[] var5;
        int var6;
        int var7;
        String beanName;
        if (beanNames.length > 1) {
            ArrayList<String> autowireCandidates = new ArrayList();
            var5 = beanNames;
            var6 = beanNames.length;

            for(var7 = 0; var7 < var6; ++var7) {
                beanName = var5[var7];
                if (!this.containsBeanDefinition(beanName) || this.getBeanDefinition(beanName).isAutowireCandidate()) {
                    autowireCandidates.add(beanName);
                }
            }

            if (autowireCandidates.size() > 0) {
                beanNames = (String[])autowireCandidates.toArray(new String[autowireCandidates.size()]);
            }
        }

        if (beanNames.length == 1) {
            return this.getBean(beanNames[0], requiredType, args);
        } else if (beanNames.length <= 1) {
            if (this.getParentBeanFactory() != null) {
                return this.getParentBeanFactory().getBean(requiredType, args);
            } else {
                throw new NoSuchBeanDefinitionException(requiredType);
            }
        } else {
            Map<String, Object> candidates = new HashMap();
            var5 = beanNames;
            var6 = beanNames.length;

            for(var7 = 0; var7 < var6; ++var7) {
                beanName = var5[var7];
                candidates.put(beanName, this.getBean(beanName, requiredType, args));
            }

            String primaryCandidate = this.determinePrimaryCandidate(candidates, requiredType);
            if (primaryCandidate != null) {
                return this.getBean(primaryCandidate, requiredType, args);
            } else {
                String priorityCandidate = this.determineHighestPriorityCandidate(candidates, requiredType);
                if (priorityCandidate != null) {
                    return this.getBean(priorityCandidate, requiredType, args);
                } else {
                    throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
                }
            }
        }
    }