IOC容器的实现

发表于 | 分类于 | 阅读次数:

IOC容器的实现

容器的设计

什么是依赖反转？为什么需要依赖反转？

依赖对象的获得被反转了

如果这个获取过程要靠自身实现，那么这将导致代码高度耦合并且难以维护和调试。

什么是容器？什么是 BeanDefinition？他们是什么关系？

IOC容器是实现依赖反转的载体

BeanDefinition 是对依赖反转模式中管理的对象依赖关系的数据抽象，也是容器实现依赖反转功能的核心数据结构，依赖反转功能都是围绕着这个 BeanDefinition 的处理来完成的。

BeanDefinition和Bean的联系和区别？

按照 BeanDefinition 规则，对 pojo 对象进行装配，管理，并赋予生命后得到的最终的对象才是Bean

为什么要设计各种容器？

BeanFactory 定义了容器最基本的功能（获取bean），同时，为了简化使用者的使用和开发，实现了各种不同功能的子容器，这些子容器能适用于各种不同的场景。

容器的设计体系：

image-20200513111401829

  1. 路线一：

    • BeanFactory：定义了容器的基本功能（getBean）
    • HierarchivalBeanFactory：使容器具有继承管理（getParentBeanFactory）
    • ConfigurableBeanFactory：使容器具有可配置功能（setParentBeanFactory，addBeanPostProcessor）

  2. 路线二：

    • ListableBeanFactory：使容器具有枚举bean的功能，不然工厂中到底有多少bean无法得知（只能采用穷举法一个个的去尝试）

    • ApplicationContext：继承 HierarchivalBeanFactory 和 ListableBeanFactory，使其拥有容器的功能，同时扩展了很多的高级特性。

容器的初始化

如何采用线路一使用容器？

在Spring中，提供了 DefaultListableBeanFactory 类，这个类基本实现了容器所有的功能，因此委托这个类，就可以进行简单的容器开发使用。

除外我们还需要做的额外操作：将 BeanDefinition 注册到 DefaultListableBeanFactory 中（因为DefaultListableBeanFactory 实现了 BeanDefinitionRegistry 接口），这一步操作的意义是为了告诉DefaultListableBeanFactory 如何进行bean装配、管理：

1
2
3
4
5
6
7
8
//BeanDefinition 资源定位，使用 Resource 抽象，可以使用 ResourceLoader 进行 Resource 的定位
ClassPathResource res = new ClassPathResource("beans.xml");
//委托
DefaultListableBeanFactory factory = new DefultListableBeanFactory();
//BeanDefinition 资源加载器定义，入参是一个 BeanDefinitionRegistry
XmlBeanDefinitionReader reader = new XmlBeanDeifinitionReader(factory);
//BeanDefinition 资源加载，使用回调将将 BeanDefinition 注册到 DefaultListableBeanFactory 中
reader.loadBeanDefinition(res);

注意到我们这里为了使用 DefaultListableBeanFactory，其实是做了额外的三步：

  1. BeanDefinition 资源定位
  2. BeanDefinition 资源加载
  3. BeanDefinition 资源注册

ApplicationContext扩展了哪些容器的高级特性？

  • MessageSource：支持国际化，为开发多语言的程序提供支持
  • ResourceLoader：支持 Resource 多方面获取
  • ApplicationContextPublisher：支持应用事件处理
  • BeanPostProcesser管理

如何采用线路二使用容器？

spring 中 AbstractApplicationContext 为我们实现了这些扩展的高级特性的基本功能，但是为了使用它，我们还需要实现他的三个方法：

1
2
3
4
5
6
//ApplicationContext 采用委托其它容器来支持它自身的容器功能，并且完成对容器的增强
void refreshBeanFactory();
//关闭委托容器
void closeBeanFactory();
//获取委托容器
ConfigurableListableBeanFactory getBeanFactory();

spring 中 AbstractRefreshableApplicationContext 继承了 AbstractApplicationContext 类，它使用DefaultListableBeanFactory 作为委托容器，为我们做了上面的工作，但为了使用AbstractRefreshableApplicationContext，我们还需要实现它的一个方法：

1
2
//之前说过，这里就是为了告诉DefaultListableBeanFactory如何进行bean装配、管理
void loadBeanDefinitions(DefaultListableBeanFactory beanFactory);

线路二案例：

这里使用 AbstractRefreshableConfigApplicationContext 的一个子类 AbstractXmlApplicationContext 来说明：

  1. BeanDefinition 资源定位

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    @Override
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory){
            //BeanDefinition资源加载器定义，入参是一个BeanDefinitionRegistry，这里表明是一个XML
            //BeanDefinition资源可以是很多其他的形式
            XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

            //配置beanDefinitionReader，关键是配置ResourceLoader
            //ResourceLoader的功能是可以定位BeanDefinition
            beanDefinitionReader.setEnvironment(this.getEnvironment());
            beanDefinitionReader.setResourceLoader(this);
            beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

            //加载BeanDefinition资源
            initBeanDefinitionReader(beanDefinitionReader);
            loadBeanDefinitions(beanDefinitionReader);
    }
        /**
        * getConfigResources() 和 getConfigLocations() 用于定位资源
        * 后者在reader中需要调用loader对stringPath的进行定位
        * @see DefaultResourceLoader#getResourceByPath(String path)
        */
        protected void loadBeanDefinitions(XmlBeanDefinitionReader reader){
            Resource[] configResources = getConfigResources();
            if (configResources != null) {
                reader.(configResources);
            }
            String[] configLocations = getConfigLocations();
            if (configLocations != null) {
                reader.loadBeanDefinitions(configLocations);
            }
        }

  2. BeanDefinition载入

    image-20200514181150727

    哪个类主要用来实现BeanDefinition载入细节？里面主要的方法是什么？

    在 DefaultBeanDefinitionDocumentReader.processBeanDefinition 中解析 Document

    委托 BeanDefinitionParserDelegate.parseBeanDefinitionElement 来实现载入

    BeanDefinitionParserDelegate 的作用是什么？

    实现 BeanDefinition 嵌套载入

  3. BeanDefinition注册

    解析完成后回调 BeanDefinitionRegistry.registerBeanDefinition() 进行注册（DefaultListableBeanFactory 实现了BeanDefinitionRegistry）

    image-20200514183640908

依赖注入

依赖注入发生的时机？

发生在第一次向容器索要 Bean 的时候，也就是调用 getBean 的时候

AbstractBeanFactory 实现了 getBean 的功能，因此下面着重分析 AbstractBeanFactory

AbstractBeanFactory源码分析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
doGetBean(...){
	//先从单例缓存中获取	
    Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null && args == null) {
		//处理FactoryBean
		bean = getObjectForBeanInstance(...);
	}else{
        //如果拿不到BeanDefinition，则从父容器中找
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)){
            //从父容器中获取
            parentBeanFactory.getBean(...);
        }
    }
    try{
        //获取BeanDefinition
        RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
		checkMergedBeanDefinition(mbd, beanName, args);
        
        //获取依赖的bean，触发递归
        String[] dependsOn = mbd.getDependsOn();
        if (dependsOn != null) {
            for (String dep : dependsOn){
                registerDependentBean(dep, beanName);
                getBean(dep);
            }
        }
       
		if (mbd.isSingleton()){
            //创建单例bean
            sharedInstance = getSingleton(...createBean(...)...)
            bean = getObjectForBeanInstance(sharedInstance,...);
        }else if(if (mbd.isPrototype())){
            //创建原型bean
            prototypeInstance = createBean(...);
            bean = getObjectForBeanInstance(prototypeInstance,...);
        }else{
            //其他作用域
            String scopeName = mbd.getScope();
            Scope scope = this.scopes.get(scopeName);
            scopedInstance = scope.get(...createBean(...)...)
            bean = getObjectForBeanInstance(scopedInstance,...);
        }
        
    }
}

从上诉代码可以看到，关键的方法是 createBean，该方法由子类实现。

正好，spring 中 AbstractAutowireCapableBeanFactory 帮我们准备了上述方法的实现

下面将对这个类进行分析：

1
2
3
4
5
6
7
8
9
10
11
12
13
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args){
    //判断需要创建的Bean是否可以实例化
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);      
    
    //给BeanPostProcessors处理成一个代理类的机会
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    if (bean != null) {
		return bean;
	}
    
    //创建实例
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args){
    //实例持有
    BeanWrapper instanceWrapper = null;
    
    //？
    if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
    
    //实例化
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    
    //初始化，完成依赖注入，exposedObject是完成后的对象
    Object exposedObject = bean;
	try {
		populateBean(beanName, mbd, instanceWrapper);
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
    
    ...
}

主要的两个方法是 createBeanInstance 和 populateBean ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    //确认bean可以实例化
    Class<?> beanClass = resolveBeanClass(mbd, beanName);
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
	throw new BeanCreationException(mbd.getResourceDescription(), beanName,
			"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    }
    
    //？
    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}
    
    //从工厂方法中获取实例
    if (mbd.getFactoryMethodName() != null)  {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}
   
    //...
        
   	//调用构造函数获取实例
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null ||
        mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
        mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }
    
    //最后采用默认构造函数
    return instantiateBean(beanName, mbd);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
	try {
        //实例化策略：默认的实例化测试是CglibSubclassingInstantiationStrategy，也就Cglib
		Object beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
		BeanWrapper bw = new BeanWrapperImpl(beanInstance);
		initBeanWrapper(bw);
		return bw;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
	}
}
1
2
3
4
5
6
7
8
9
10
11
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
	if (!bd.hasMethodOverrides()) {
		//...
        //JAVA反射
		return BeanUtils.instantiateClass(constructorToUse);
	}else{
        //cglib
        return instantiateWithMethodInjection(bd, beanName, owner);
    }
    
}

再看依赖注入 populateBean：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw){
	//...
	
	//获取Property值
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
	
    //处理autowire
	if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
	mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
   
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }

        pvs = newPvs;
	}

    //BeanPostProcessors处理
    
    //注入
	if (pvs != null) {
		applyPropertyValues(beanName, mbd, bw, pvs);
	}  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    if (pvs.isEmpty()) {
        return;
    }

    MutablePropertyValues mpvs = null;
    List<PropertyValue> original;

	//...

    if (pvs instanceof MutablePropertyValues) {
        mpvs = (MutablePropertyValues) pvs;
        if (mpvs.isConverted()) {
            //1. 已作过转换处理 直接走捷径
            try {
                bw.setPropertyValues(mpvs);
                return;
            } catch (BeansException ex) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Error setting property values", ex);
            }
        }
        original = mpvs.getPropertyValueList();
    } else {
        original = Arrays.asList(pvs.getPropertyValues()); 
    }

    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }
    BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

    //2. 类型转换，结果保存到新列表deepCopy中
    List<PropertyValue> deepCopy = new ArrayList<>(original.size());
    boolean resolveNecessary = false;
    for (PropertyValue pv : original) {
        if (pv.isConverted()) {
            //已转换
            deepCopy.add(pv);
        } else {
            //未转换
            String propertyName = pv.getName();
            Object originalValue = pv.getValue();
            //类型转换：如将 TypedStringValue 解析成 Resource
            Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
            Object convertedValue = resolvedValue;
            
           	/*
           	* 判断是否可转换：
           	* 1. 属性是否可写
           	* 2. 属性是否嵌套或者有索引
           	*/
            boolean convertible = bw.isWritableProperty(propertyName) &&
                    !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
            if (convertible) {
                convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
            }
            //3. 保存转换后的值
            if (resolvedValue == originalValue) {
                if (convertible) {
                    pv.setConvertedValue(convertedValue);
                }
                deepCopy.add(pv);
            } else if (convertible && originalValue instanceof TypedStringValue &&
                    !((TypedStringValue) originalValue).isDynamic() &&
                    !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
                pv.setConvertedValue(convertedValue);
                deepCopy.add(pv);
            } else {
                resolveNecessary = true;
                deepCopy.add(new PropertyValue(pv, convertedValue));
            }
        }
    }
    if (mpvs != null && !resolveNecessary) {
        mpvs.setConverted();
    }

    //4. 赋值
    try {
        bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    } catch (BeansException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    }
}

BeanWapper分析：

image-20200528160704541

  1. PropertyAccessor：提供通过属性名访问属性功能（是否可读，是否可写，get，set），支持普通的java对象和spring的Bean对象

  2. TypeConverter：提供类型转换的功能（convertIfNecessary），比如注入的属性值是String型，而属性类型是对象类型，则提供转换的功能

    TypeConverterSupport 继承了 PropertyEditorRegistrySupport，持有各种类型的 PropertyEditor，

    TypeConverterSupport 委托 PropertyEditor 或者 ConversionService 来处理实际的值转换

  3. ConfigurablePropertyAccessor：提供 PropertyAccessor 的相关配置(setConversionService)

    1. AbstractPropertyAccessor：实现 ConfigurablePropertyAccessor
      1. 实现了各种可重构的方法，把关键的方法（如何访问属性）留给子类实现
      2. 继承 TypeConverterSupport，具有类型转换功能
    2. AbstractNestablePropertyAccessor：拓展了嵌套属性的访问功能，同样“如何访问”需要子类实现
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    public class MyBeanPropertyAccessor extends AbstractNestablePropertyAccessor {
        @Override
        protected PropertyHandler getLocalPropertyHandler(String propertyName) {
            //如何访问属性，并且抽象成PropertyHandler
            return MyProxyHandler;
        }

        @Override
        protected AbstractNestablePropertyAccessor newNestedPropertyAccessor(Object object, String nestedPath) {
            //提供子属性访问器
            return null;
        }

        @Override
        protected NotWritablePropertyException createNotWritablePropertyException(String propertyName) {
            //定义异常，附加额外的异常处理
            return null;
        }
        
        class MyProxyHandler extends PropertyHandler{

            public MyProxyHandler(Class<?> propertyType, boolean readable, boolean writable) {
                super(propertyType, readable, writable);
            }

            @Override
            public TypeDescriptor toTypeDescriptor() {
                return null;
            }

            @Override
            public ResolvableType getResolvableType() {
                return null;
            }

            @Override
            public TypeDescriptor nested(int level) {
                return null;
            }

            @Override
            public Object getValue() throws Exception {
                return null;
            }

            @Override
            public void setValue(Object value) throws Exception {

            }
        }
    }

  4. BeanWrapper：提供分析和操作JavaBean的方法

  5. BeanWrapperImpl：

    1. 使用JavaBean的内省机制实现属性的访问
    2. 具有类型转换功能
    3. 具有通过属性名嵌套访问属性的功能

其他特性实现

容器的准备

image-20200528163841436

容器的准备发生在 AbstractApplicationContext#prepareBeanFactory() 中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public abstract class AbstractApplicationContext{
	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		/*
		* 1. 类加载器设置
		* 2. 新增PropertyEditorRegistrar
		*/
		beanFactory.setBeanClassLoader(getClassLoader());
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		/*
		* 1. 配置BeanPostProcessor
		* 2. 配置DependencyInterface
		* DependencyInterface 用于 依赖检查 和 autowire 时指定忽略的接口
		* 详情可查看 (https://www.jianshu.com/p/3c7e0608ff1f)
		*/
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// Register early post-processor for detecting inner beans as ApplicationListeners.
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// 注册默认环境bean
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}
}

容器的销毁

发生在 AbstractApplicationContext#doClose() 中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public abstract class AbstractApplicationContext{
		protected void doClose() {
		if (this.active.get() && this.closed.compareAndSet(false, true)) {
			if (logger.isInfoEnabled()) {
				logger.info("Closing " + this);
			}

			LiveBeansView.unregisterApplicationContext(this);

			try {
				// 发布关闭事件
				publishEvent(new ContextClosedEvent(this));
			}
			catch (Throwable ex) {
				logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
			}

			// Stop all Lifecycle beans, to avoid delays during individual destruction.
			if (this.lifecycleProcessor != null) {
				try {
					this.lifecycleProcessor.onClose();
				}
				catch (Throwable ex) {
					logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
				}
			}

			// Destroy all cached singletons in the context's BeanFactory.
			destroyBeans();

			// Close the state of this context itself.
			closeBeanFactory();

			// Let subclasses do some final clean-up if they wish...
			onClose();

			this.active.set(false);
		}
	}

}

Bean初始化

发生在 AbstractAutowireCapableBeanFactory#initializeBean 中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public abstract class AbstractAutowireCapableBeanFactory{
	protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {

		//anything else...

		//1. 执行BeanNameAware、BeanClassLoaderAware、BeanFactoryAware方法
		invokeAwareMethods(beanName, bean);

		//2. 执行BeanPostProcessor.postProcessBeforeInitialization()
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		//3. 执行InitializingBean.afterPropertiesSet()
		//	 执行<init-method>
		invokeInitMethods(beanName, wrappedBean, mbd);

		//4. 执行BeanPostProcessor.postProcessAfterInitialization()
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}
}

Bean销毁

最终会走到 DisposableBeanAdapter#destroy 中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class DisposableBeanAdapter {
	@Override
	public void destroy() {
        //1. 执行 DestructionAwareBeanPostProcessor#postProcessBeforeDestruction
		if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
			for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
				processor.postProcessBeforeDestruction(this.bean, this.beanName);
			}
		}
		
        //2. 执行DisposableBean#destroy()
		if (this.invokeDisposableBean) {
			((DisposableBean) bean).destroy();
		}

        //3. 执行<destory-method>
		if (this.destroyMethod != null) {
			invokeCustomDestroyMethod(this.destroyMethod);
		}
		else if (this.destroyMethodName != null) {
			Method methodToCall = determineDestroyMethod(this.destroyMethodName);
			if (methodToCall != null) {
				invokeCustomDestroyMethod(methodToCall);
			}
		}
	}

}

lazy-init属性和预实例化

lazy-init属性有何用？

决定执行bean的实例化：是在容器初始化完成时还是第一个请求获取bean时

相关逻辑在 DefaultListableBeanFactory#preInstantiateSingletons 中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class DefaultListableBeanFactory{
	public void preInstantiateSingletons() throws BeansException {

		//忽略无关代码...

		// 执行 non-lazy 单例的初始化
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				getBean(beanName);
			}
		}
	}
}

FactoryBean

FactoryBean的相关逻辑在 AbstractBeanFactory#getObjectForBeanInstance中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class AbstractBeanFactory{
	protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
        
        // beanInstance 是工厂Bean 已经经历了 依赖注入 和 初始化
        // 忽略无关代码...
        
        // 非 FactoryBean 直接返回
        // 获取 FactoryBean 本身 beanName以&开头
        if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
            return beanInstance;
        }

        // 执行 FactoryBean#getObject();
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        Object object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        return object;
    }
}

autowiring自动装配

相关逻辑在 AbstractAutowireCapableBeanFactory#populateBean 中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class AbstractAutowireCapableBeanFactory {
    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

        //忽略无关代码...
        
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

            // by name
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }

            // by type
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }

            pvs = newPvs;

        }
    }
}

Bean对IOC容器的感知

image-20200529170459629

通过 ApplicationContextAwareProcessor 来实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
class ApplicationContextAwareProcessor implements BeanPostProcessor {

    private final ConfigurableApplicationContext applicationContext;
    private final StringValueResolver embeddedValueResolver;

    public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
        this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
    }

    @Override
    @Nullable
    public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
        
        //忽略无关代码...
        
        invokeAwareInterfaces(bean);
        return bean;
    }

    private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof EnvironmentAware) {
                ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
            }
            if (bean instanceof EmbeddedValueResolverAware) {
                ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
            }
            if (bean instanceof ResourceLoaderAware) {
                ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
            }
            if (bean instanceof ApplicationEventPublisherAware) {
                ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
            }
            if (bean instanceof MessageSourceAware) {
                ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
            }
            if (bean instanceof ApplicationContextAware) {
                ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
            }
        }
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }

}

本文标题:IOC容器的实现

文章作者:Sun

发布时间:2020年05月12日 - 20:05

最后更新:2020年06月23日 - 16:06

原始链接:https://sunyi720.github.io/2020/05/12/Spring/IOC容器的实现/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。