Spring ioc 容器源码解析

1、Spring IOC中bean的创建是利用反射实现，因此我们举例解析实现过程：

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext();

2、剖析这个类ClassPathXmlApplicationContext 之前可以看一下这个类的继承关系：

 3、BeanFactory

 由上图的继承关系图可以看到，所有的类都包含这个接口（BeanFactory）。从下面的源码 可以看到BeanFactory定义了 IOC 容器的最基本形式，并提供了 IOC 容器应遵守的的最基本的接口，也就是Spring IOC 所遵守的最底层和最基本的编程规范。在  Spring 代码中， BeanFactory 只是个接口，并不是 IOC容器的具体实现，但是 Spring 容器给出了很多种实现，如

、DefaultListableBeanFactory 、GenericApplicationContext、 XmlBeanFactory 、ApplicationContext 等，并给bean进行定义并注册。

package org.springframework.beans.factory;

import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;

public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";
//根据bean名字获取bean
    Object getBean(String var1) throws BeansException;
//根据bean名字及class类型获取bean
    <T> T getBean(String var1, Class<T> var2) throws BeansException;

    Object getBean(String var1, Object... var2) throws BeansException;

    <T> T getBean(Class<T> var1) throws BeansException;

    <T> T getBean(Class<T> var1, Object... var2) throws BeansException;

    <T> ObjectProvider<T> getBeanProvider(Class<T> var1);

    <T> ObjectProvider<T> getBeanProvider(ResolvableType var1);
//检查IOC容器是否包含bean实例
    boolean containsBean(String var1);
//判断是否是单例bean
    boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
//判断是否是原型bean
    boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
//根据bean名字及ResolvableType是否是ResolvableType类型
    boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;
//根据bean名字及class类型是否是class类型
    boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;
//获取bean实例的class对象
    @Nullable
    Class<?> getType(String var1) throws NoSuchBeanDefinitionException;
//获取bean的别名
    String[] getAliases(String var1);
}

初始化bean

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// bean 的定义（class, scope, 初始化, 销毁）
AbstractBeanDefinition beanDefinition =
        BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();
//注册
beanFactory.registerBeanDefinition("config", beanDefinition);

 添加BeanFactory的后处理器

// 给 BeanFactory 添加一些常用的后处理器
AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

//如果只是添加后处理器不进行扩展，则无法解析@Confident和@bean注解
// BeanFactory 后处理器主要功能，补充了一些 bean 定义
// getBeansOfType 根据类型获取多个bean（bean后处理器）
beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().forEach(beanFactoryPostProcessor -> {
    beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);   //执行beanFactory 后处理器
});

@Configuration
    static class Config {
        @Bean
        public Bean1 bean1() {return new Bean1();}
        @Bean
        public Bean2 bean2() {return new Bean2();}
        @Bean
        public Bean3 bean3() {return new Bean3();}
        @Bean
        public Bean4 bean4() {return new Bean4();}
    }
    interface Inter { }
    static class Bean3 implements Inter { }
    static class Bean4 implements Inter { }
    static class Bean1 {
        private static final Logger log = LoggerFactory.getLogger(Bean1.class);
        public Bean1() {
            log.debug("构造 Bean1()");
        }
        @Autowired
        private Bean2 bean2;
        public Bean2 getBean2() {return bean2;}
        //同时添加两个注解（后处理器的顺序决定了哪个先被解析）
        @Autowired
        @Resource(name = "bean4")
        private Inter bean3;
        public Inter getInter() {return bean3;}}
    static class Bean2 {
        private static final Logger log = LoggerFactory.getLogger(Bean2.class);
        public Bean2() {
            log.debug("构造 Bean2()");
        }
    }

// Bean 后处理器, 针对 bean 的生命周期的各个阶段提供扩展, 例如 @Autowired @Resource ...
beanFactory.getBeansOfType(BeanPostProcessor.class).values().stream()
        .forEach(beanPostProcessor -> {
    beanFactory.addBeanPostProcessor(beanPostProcessor);    //建立Bean工厂和后处理器的关系
});

后处理器顺序

//默认是Common的后处理器排在前面，Autowired的排在后面
System.out.println("Common:" + (Ordered.LOWEST_PRECEDENCE - 3));
System.out.println("Autowired:" + (Ordered.LOWEST_PRECEDENCE - 2));

4、BeanDefinition类

package org.springframework.beans.factory.config;

import org.springframework.beans.BeanMetadataElement;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.core.AttributeAccessor;
import org.springframework.lang.Nullable;

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
    String SCOPE_SINGLETON = "singleton";
    String SCOPE_PROTOTYPE = "prototype";
    int ROLE_APPLICATION = 0;
    int ROLE_SUPPORT = 1;
    int ROLE_INFRASTRUCTURE = 2;

    void setParentName(@Nullable String var1);

    @Nullable
    String getParentName();

    void setBeanClassName(@Nullable String var1);

    @Nullable
    String getBeanClassName();

    void setScope(@Nullable String var1);

    @Nullable
    String getScope();

    void setLazyInit(boolean var1);

    boolean isLazyInit();

    void setDependsOn(@Nullable String... var1);

    @Nullable
    String[] getDependsOn();

    void setAutowireCandidate(boolean var1);

    boolean isAutowireCandidate();

    void setPrimary(boolean var1);

    boolean isPrimary();

    void setFactoryBeanName(@Nullable String var1);

    @Nullable
    String getFactoryBeanName();

    void setFactoryMethodName(@Nullable String var1);

    @Nullable
    String getFactoryMethodName();

    ConstructorArgumentValues getConstructorArgumentValues();

    default boolean hasConstructorArgumentValues() {
        return !this.getConstructorArgumentValues().isEmpty();
    }

    MutablePropertyValues getPropertyValues();

    default boolean hasPropertyValues() {
        return !this.getPropertyValues().isEmpty();
    }

    void setInitMethodName(@Nullable String var1);

    @Nullable
    String getInitMethodName();

    void setDestroyMethodName(@Nullable String var1);

    @Nullable
    String getDestroyMethodName();

    void setRole(int var1);

    int getRole();

    void setDescription(@Nullable String var1);

    @Nullable
    String getDescription();

    boolean isSingleton();

    boolean isPrototype();

    boolean isAbstract();

    @Nullable
    String getResourceDescription();

    @Nullable
    BeanDefinition getOriginatingBeanDefinition();
}

BeanDefinition这个接口的函数名不难看出，这个接口是对应xml中bean的解析的。这个接口可以参照spring官方给的说明进行使用,包括这个接口的实现类。

 BeanDefinitionHolder类，根据名称或者别名持有beanDefinition，它承载了beanName和BeanDefinition的映射信息

IOC源码分析

1、通过AbstractRefreshableApplicationContext类中

protected final void refreshBeanFactory() throws BeansException {
        if (this.hasBeanFactory()) {
            this.destroyBeans();
            this.closeBeanFactory();
        }

        try {
//创建容器工厂
            DefaultListableBeanFactory beanFactory = this.createBeanFactory();
            beanFactory.setSerializationId(this.getId());
            this.customizeBeanFactory(beanFactory);
//加载bean配置
            this.loadBeanDefinitions(beanFactory);
            synchronized(this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        } catch (IOException var5) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
        }
    }