Spring核心——IOC功能扩展点

冷不防 2021-12-11 06:47 366阅读 0赞

[上一篇文章][Link 1]介绍了非侵入式的框架的概念以及IOC的功能扩展点之一——BeanPostProcessor，我们接下来的内容继续说明IoC更多的扩展方法。

## BeanFactoryPostProcessor ##

BeanFactoryPostProcessor是针对整个容器的后置处理器。他的使用也非常简单，只要向容器中添加一个继承BeanFactoryPostProcessor的Bean即可。

### 如何使用 ###

继承了BeanFactoryPostProcessor接口的类PostProcessors：

然后再向容器中添加这个Bean就增加了一个BeanFactoryPostProcessor。

<?xml version="1.0" encoding="UTF-8"?>
    
    <beans>
        <bean class="chkui.springcore.example.xml.beanfactorypostprocessor.PostProcessors" />
    </beans>

BeanFactoryPostProcessor主要用于处理容器相关的内容，他被触发时机是在IoC容器加载完各种配置后，还没执行Bean的初始化之前。这个时候除了PostProcessors这个Bean，其他任何Bean都没有被创建。 所以在BeanFactoryPostProcessor处理Bean是不合适的，Bean应该要到BeanPostProcessor中去处理，2者的区别就是前者面向容器，后者面向Bean。接下来将通过一个详细例子来说明BeanFactoryPostProcessor和BeanPostProcessor的区别以及使用方式。期间还会介绍BeanDefinitio相关的内容。

### BeanFactoryPostProcessor与BeanPostProcessor使用 ###

（文中仅仅是示例代码，无法运行，源码在[https://gitee.com/chkui-com/spring-core-sample][https_gitee.com_chkui-com_spring-core-sample]，如需下载请自行clone）

建造者模式

下面将会通过一个例子介绍2者的使用方式和使用场景。例子使用建造者模式模拟组装一台个人电脑，分为一下3步：

1.   容器启动之后，会将电脑的所有“配件”（Cpu、Graphics、Ram）都添加到容器中。
2.   在PostProcessorS实现BeanFactoryPostProcessor接口，它的功能是向容器添加一个Pc对象。
3.   在PostProcessor实现BeanPostProcessor接口。他的工作是组装电脑——每一个Bean都会检查域上的@Autowired注解，并注入对应的部件，部件也会标记自己所属的电脑。

下面是XML配置文件，它负责将Cpu、显卡、内存等电脑常用品牌的部件放置到容器中等待组装。此外它还添加了PostProcessorS和PostProcessor两个后置处理器用于装载电脑。欢迎加入659270626，大家一起交流技术。

下面是一个Cpu对象的结构，他标记了品牌和所属电脑。Graphics和Ram的结构和它一模一样。

package chkui.springcore.example.xml.beanfactorypostprocessor.bean;
    
    public class Cpu {
    	private String brand;
    	
    	@Autowired
    	private Pc belong;
    }

注意这里的@Autowired注解，我们的配置文件并没有开启Spring的自动装配功能，我们将在PostProcessor实现自动装配。

PostProcessorS的作用是向容器动态添加一个之前未定义的Bean——Pc。

package chkui.springcore.example.xml.beanfactorypostprocessor;
    
    public class PostProcessors implements BeanFactoryPostProcessor{
    	@Override
    	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    		//获取容器的注册接口
    		BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
    		//新建一个BeanDefinition用于动态装配Bean
    		GenericBeanDefinition defininition = new GenericBeanDefinition();
    		//设置要添加的类
    		defininition.setBeanClass(Pc.class);
    		//注册BeanDefinition
    		registry.registerBeanDefinition("postBean", defininition);
    	}
    }

如果看过 [Ioc结构介绍的这篇文章][Ioc]，你就会知道BeanFactory经过层层派生，实际上大部分接口都在一个类实现——DefaultListableBeanFactory，它除了实现ConfigurableListableBeanFactory接口，还实现了BeanDefinitionRegistry接口。BeanDefinitionRegistry提供了BeanDefinition的管理功能。

BeanDefinition与适配器模式

在上面的代码中出现了BeanDefinition接口，这里就顺道说一说这个有趣的小玩意。关于他如何使用Spring的官网并没有太详细的介绍（至少我没找到），网上倒是有各路大神的博客在解读他的源码，不过代码只是表象，要理解他的整套设计思路才能提升。

关于BeanDefinition的使用模式，官网将其称呼为*configuration metadata*，直译过来叫“配置元数据”。 他的作用有点类似于[Context分层应用的效果（见Spring核心——上下文与IoC 关于 ApplicationContext的说明）][Ioc]，目的就是将Bean的配置和初始化工作分成2个互不干扰的部分。

我们知道 Spring现在支持各种各样的方式来添加Bean，比如在XML配置文件中使用<bean>标签、使用@Component以及他的派生类注解、可以在@Configuration类中生成、甚至还可以通过RMI实现远程配置等等。如果所有的这些配置来源直接和IoC容器产生关系生成Bean，那么耦合度、代码复杂度会越来越高，而且以后指不定什么时候又会加入什么新的配置方式。

为了解决这个问题Spring的大神们引入了适配器模式——IoC容器只接受BeanDefinition接口，IoC如何初始化一个Bean是仅仅是看BeanDefinition里的信息。而各种配置方式都有自己的适配器，所有的适配器都会根据他所需要处理的内容来生成一个BeanDefinition的实现类。这样，如果新增一个新的配置方式，增加一个适配器就可以搞定。

![Spring核心——IOC功能扩展点][Spring_IOC]

所以，我们也可以利用BeanDefinitionRegistry接口向容器添加一个BeanDefinition，进而在随后的执行过程中IoC容器会根据 这个BeanDefinition创建一个对应的Bean。

BeanPostProcessor

前面已经提到，BeanFactoryPostProcessor用于处理容器级别的问题，而BeanPostProcessor用来处理每一个Bean。我们前面已经用BeanFactoryPostProcessor向容器添加了一个Pc对象的Bean，接下来我们在BeanPostProcessor中处理每一个Bean的自动注入注解。

package chkui.springcore.example.xml.beanfactorypostprocessor;
    
    public class PostProcessor implements BeanPostProcessor, BeanFactoryAware {
    	private ConfigurableListableBeanFactory beanFactory;
    	public Object postProcessBeforeInitialization(Object bean, String beanName) {
            return autowiredImplement(bean);
        }
    	public Object postProcessAfterInitialization(Object bean, String beanName) {
            return bean;
        }
    	
    	//自定义实现autowired功能
    	private Object autowiredImplement(final Object bean) {
    		for(Field field : bean.getClass().getDeclaredFields()) {
    			Autowired value = field.getAnnotation(Autowired.class);
    			if(null != value) {
    				Object obj = beanFactory.getBean(field.getType());
    				field.setAccessible(true);
    				field.set(bean, obj);
    			}
    		}
    		return bean;
    	}
    	@Override
    	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    		this.beanFactory = (ConfigurableListableBeanFactory)beanFactory;
    	}
    }

这里的PostProcessor实现BeanFactoryAware接口来获取 BeanFactory。自动注入的处理逻辑都在autowiredImplement方法中，它会扫描Bean的每一个域检查是否有@Autowired注解，如果有则根据这个域的Class类型到BeanFactory去获取对应的Bean，然后反射注入。

最后我们创建一个ApplicationContext来运行他们：

public class SampleApp {
        public static void main(String[] args) {
        	ApplicationContext context = new ClassPathXmlApplicationContext("xml/beanfactorypostprocessor/config.xml");
        	Pc pc = context.getBean(Pc.class);
            /**
            Pc Info: Graphics=Nvdia, Cpu=Amd, Ram=Kingston]
            */
            System.out.println(pc);
        }
    }

本文介绍了BeanFactoryPostProcessor和BeanPostProcessor的使用方式，以及IoC容易是如何通过BeanDefinition装载各种配置的。后续还会持续介绍Spring IoC容器的各种功能扩展点。

[Link 1]: https://www.chkui.com/article/spring/spring_core_bean_post_processors
[https_gitee.com_chkui-com_spring-core-sample]: https://gitee.com/chkui-com/spring-core-sample
[Ioc]: https://www.chkui.com/article/spring/spring_core_context_and_ioc
[Spring_IOC]: https://file.mahoooo.com/res/file/spring_core_ioc_extension_points.png