Spring源码分析之IOC 容器

Spring启动方式：

　　启动spring容器有两种方式，分别是通过配置文件的读取启动，通过JavaConfig配置类启动。

　　在使用配置文件启动的时候，我们就需要使用ClassPathXmlApplicationContext("xx.xml")来构建容器，并初始化bean。

public class Test1 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        IndexService service = (IndexService) context.getBean("service");
        service.query();
    }
}

　　在使用JavaConfig配置类启动的时候，我们需要使用AnnotationConfigApplicationContext("xx.class")来构建容器，并初始化bean。

public class Test {
    public static void main(String[] args) {
        //把spring所有的前提环境准备好了，包括spring容器还有类的实例化都完成了。
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyAnnotation.class);
        IndexService service = (IndexService)context.getBean("service");
        service.query();
    }
}

　　进入AnnotationConfigApplicationContext类中，查看构造方法。

/**
     * 这个构造方法需要传入一个被Javaconfig注解过的配置类
     * 然后会把这个被注解了的配置类通过注解读取器读取后进行解析
     * @param annotatedClasses
     */
    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        //这里由于它有父类，故而会先调用父类的构造方法，然后才会调用自己的构造方法，
        //在自己的构造方法中初始化一个读取器和扫描器
        this();
        //注册单个bean给容器，比如有新加的类可以使用这个方法
        //但是注册之后需要手动调用refresh()方法去触发容器解析注解
        register(annotatedClasses);
        refresh();
    }

　　进入this()方法，查看自己的构造方法

public AnnotationConfigApplicationContext() {
        /**
         * 创建一个读取注解的Bean定义读取器
         * 什么是Bean定义？BeanDefinition
         * BeanDefinition这个类是描述springBean对象的类。
         */
        this.reader = new AnnotatedBeanDefinitionReader(this);
        /**
         * 创建一个扫描器，扫描所有加了注解的类
         */
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

　　进入register()方法，忽略掉封装方法，直接进入AnnotatedBeanDefinitionReader类中的doRegisterBean()方法：

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
            @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
            return;
        }

        abd.setInstanceSupplier(instanceSupplier);
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName());
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        /**
         * 对属性进行判断
         */
        if (qualifiers != null) {
            for (Class<? extends Annotation> qualifier : qualifiers) {
                if (Primary.class == qualifier) {
                    abd.setPrimary(true);
                }
                else if (Lazy.class == qualifier) {
                    abd.setLazyInit(true);
                }
                else {
                    abd.addQualifier(new AutowireCandidateQualifier(qualifier));
                }
            }
        }
        for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
            customizer.customize(abd);
        }

        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        /**
         * 把处理后的bean当做参数，进行注册
         */
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }

　　进入BeanDefinitionReaderUtils类中的registerBeanDefinition()方法：

/**
     * 向给定的bean工厂注册给定的bean定义
     * @param definitionHolder
     * @param registry
     * @throws BeanDefinitionStoreException
     */
    public static void registerBeanDefinition(
            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
            throws BeanDefinitionStoreException {

        // Register bean definition under primary name.
        // 把beanName作为主名，在bean工厂中注册
        String beanName = definitionHolder.getBeanName();
        //通过DefaultListableBeanFactory工厂进行注册
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

        // Register aliases for bean name, if any.
        // 对别名进行处理
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            for (String alias : aliases) {
                registry.registerAlias(beanName, alias);
            }
        }
    }

　　进入DefaultListableBeanFactory类的registerBeanDefinition()方法进行注册。

　　　　/** Map of bean definition objects, keyed by bean name. */

　　　　private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

　　　　/** List of bean definition names, in registration order. */

　　　　private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

@Override
    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 ex) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                        "Validation of bean definition failed", ex);
            }
        }

        BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
        if (existingDefinition != null) {
            if (!isAllowBeanDefinitionOverriding()) {
                throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
            }
            else if (existingDefinition.getRole() < beanDefinition.getRole()) {
                // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
                if (logger.isInfoEnabled()) {
                    logger.info("Overriding user-defined bean definition for bean '" + beanName +
                            "' with a framework-generated bean definition: replacing [" +
                            existingDefinition + "] with [" + beanDefinition + "]");
                }
            }
            else if (!beanDefinition.equals(existingDefinition)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Overriding bean definition for bean '" + beanName +
                            "' with a different definition: replacing [" + existingDefinition +
                            "] with [" + beanDefinition + "]");
                }
            }
            else {
                if (logger.isTraceEnabled()) {
                    logger.trace("Overriding bean definition for bean '" + beanName +
                            "' with an equivalent definition: replacing [" + existingDefinition +
                            "] with [" + beanDefinition + "]");
                }
            }
            this.beanDefinitionMap.put(beanName, beanDefinition);
        }
        else {
            if (hasBeanCreationStarted()) {
                // Cannot modify startup-time collection elements anymore (for stable iteration)
                synchronized (this.beanDefinitionMap) {
                    this.beanDefinitionMap.put(beanName, beanDefinition);
                    List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                    updatedDefinitions.addAll(this.beanDefinitionNames);
                    updatedDefinitions.add(beanName);
                    this.beanDefinitionNames = updatedDefinitions;
                    if (this.manualSingletonNames.contains(beanName)) {
                        Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                        updatedSingletons.remove(beanName);
                        this.manualSingletonNames = updatedSingletons;
                    }
                }
            }
            else {
                // Still in startup registration phase
                this.beanDefinitionMap.put(beanName, beanDefinition);
                this.beanDefinitionNames.add(beanName);
                this.manualSingletonNames.remove(beanName);
            }
            this.frozenBeanDefinitionNames = null;
        }

        if (existingDefinition != null || containsSingleton(beanName)) {
            resetBeanDefinition(beanName);
        }
    }

　　到这里，bean注册完成了，然后调用refresh()方法进行实例化。

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            // 准备工作，包括设置启动时间，是否激活标识位，
            // 初始化属性源(property source)设置
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            // 通过子类来获取之前注册了bean的容器工厂beanFactory
            // 这里我们是获得DefaultListableBeanFactory这个工厂类
            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();
            }
        }
    }