spring企业开发扩展机制（二）

科技2022-07-12 126

一、扩展原理

1.1 BeanFactoryPostPorcessor

BeanPostPorcessor：bean后置处理器，在bean创建对象初始化前后进行拦截操作

BeanFactoryPostPorcessor：beanFactory的后置处理器

在beanFactory标准初始化之后调用，所有的bean定义已经保存加载到beanFactory中，但是bean的实例还未创建

在refresh（）方法中的invokeBeanFactoryPostPorcessors(beanFactory)

1.执行时机

ioc容器创建对象

invokeBeanFactoryPostPorcessors（beanFactory）：执行BeanFactoryPostPorcessors

如何找到所有的BeanFactoryPostPorcessor并执行他们的方法？

1. 直接在beanFactory中找到所有类型是BeanFactoryPostPorcessor的组件，并执行他们的方法 2. 在初始化创建其他组件前面执行

1.2 BeanDefinitionRegistryPostProcessor

BeanDefinitionRegistryPostProcessor extends BeanFactoryPostPorcessor

接口方法：postPorcessBeanDefinitionRegistry（BeanDefinitionRegistry registry）

BeanDefinitionRegistry：bean定义的存储中心，以后beanFactory就是按照BeanDefinitionRegistry里面保存的每一个bean定义信息创建bean实例（单例还是多例，类型是什么。。。。）

也可以注册一个新的bean

RootBeanDefinition root = new RootBeanDefinition(); registry.registerBeanDefinition("hello",root); AbstractBeanDefinition bean = BeanDefinitionBuilder.rootBeanDefinition(Blue.class).getBeanDefinition(); registry.registerBeanDefinition("hello",bean);

1. 执行时机

在所有bean定义信息将要被加载，bean实例还未创建在BeanPostPorcessor之前

IOC容器创建

调用refresh（）里面的invokeBeanFactoryPostPorcessors（beanFactroy）

先从容器中获取所有的BeanDefinitionRegistryPostPorcessor组件。

依次触发所有的postPorcessBeanDefinitionRegistry（）再触发possPorcessBeanFactroy（）

再来从容器中找到BeanFactroyPostPorcessor组件，然后依次触发postPorcessBeanFactroy（）方法

1.3 ApplicationListener

监听容器中发布的事件，完成事件驱动开发

public interface ApplicationListener{}

监听ApplicationEvent及其子事件

1. 基于事件开发

写一个监听器来监听某个事件（ApplicationEvent下面的及其子类）

将监听器加入到容器中

只有有相应类型的发布，就能监听到这个事件

ContextRefreshEvent：容器刷新完成（所有bean都已经完全创建）会发布这个事件

发布一个事件

public static void main(String[] args) { AnnotationConfigApplicationContext configApplicationContext = new AnnotationConfigApplicationContext(); //发布一个事件 configApplicationContext.publishEvent(new ApplicationEvent(new String()) { }); } @Component public class MyApplicationListener implements ApplicationListener<ApplicationEvent> { //当容器中发布此事件以后，方法会触发 public void onApplicationEvent(ApplicationEvent applicationEvent) { System.out.println("收到事件"+applicationEvent); } }

1.2 内部原理

ContextRefreshedEvent事件：

容器创建，调用refresh方法

调用finishRefresh（）：容器刷新完成执行

也可以自己发布事件，都会走下面的流程

事件发布流程：

调用pubilshEvent(new ContextRefreshedEvent（this）)

获取事件的多播器（派发器）：getApplicationEventMulticaster（）

multicasterEvent（）：派发事件

获取到所有的ApplicationListener

for（final ApplicationListener<?> listener ： getApplicationListeners(event,type)）

如果有Executor，可以支持使用Executor进行异步派发

否则使用同步方法，直接执行listener方法

拿到listener回调onApplicationEvent方法

【事件多播器（ApplicationEventMulticaster）】

ApplicationEventMulticaster

容器创建对象：refresh（）

调用initApplicationEventMulticaster（）：初始化ApplicationEventMulticaster

先去容器找有没有id="applicationEventMulticaster"的组件；

如果没有创建一个SimpleApplicationEventMulticaster（beanFactroy）

并且加入到容器中，就可以在其他组件要派发事件，自动注入这个applicationEventMultister

【容器中有哪些监听器】

refresh（）方法中

registerListener（）【check for listener beans and register them】

从容器中拿到所有的监听器，把他们注册到applicationEventMulticaster中

//获取所有类型的监听器

String [] listenerBeanNames = getBeanNamesForType(ApplicationListener.class,true,false)

//将listener注册到ApplicationEventMulticaster中

getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName)

1.4 @EventListener和SmartInitalizingSingleton

@EventListener：可以将业务层进行监听事件的发生

@Service public class UserService{ //定义一个监听方法，用来监听事件的发生 @EventListener(classes = {ApplicationEvent.class}) public void listener(ApplicationEvent event){ sout(event); } }

注解原理：利用EventListenerMethodProcessor来进行处理

SmartInitalizingSingleton：接口

方法：afterSingletonsInstantiated

会在单实例bean创建阶段完成之后

EventListenerMethodPorcessor处理器来解析@EventListener

1. 执行流程

ioc容器创建对象并refresh容器

finishBeanFactroyInitialzation(beanFactroy)：初始化剩下单实例bean

先创建所有的单实例bean；getBean（）

获取所有创建好的单实例bean，判断是否是SmartInitalizingSingleton类型的

如果是就调用afterSingletonsInstantiated（）

二、spring容器源码

1.1 BeanFactroy预处理

prepareRefresh（）刷新预处理

initPropertySources（）：初始化一些属性设置；此方法是一个空实现。留给子类自定义属性个性化的属性设置getEnviroment().validateRequiredProperties()：校验属性的合法等earlyApplicationEvents = new LinkedHashSet：保存容器中早期的事件

obtainFreshBeanFactory()：获取beanFactroy

refreshBeanFactroy：刷新beanFactroy。核心是创建了一个beanFactroy对象

创建了一个this.beanFactroy = new DefaultListableBeanFactory()

getBeanFactory：返回刚才GenericApplicationContext创建的BeanFactory对象

将创建的BeanFactory返回【默认DefaultListableBeanFactory】

prepareBeanFactory(beanFactory)：对BeanFactory的预准备工作（BeanFactroy进行一些设置）

设置BeanFactroy的类加载器、支持表达式…

添加部分BeanPostPorcessor【ApplicationContextAwareProcessor】

设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxxx

注册可以解析的自动装配；可以在任何组件中自动注入:BeanFactroy、ResourceLoader、ApplicationEventPublisher、ApplicationContext

添加BeanPostPorcessor【ApplicationListenerDetector】

添加编译时的AspectJ支持

给BeanFactroy中注册一些能用的组件；

environment【ConfigurationEnvironment】

systemProperties【Map<String,Object>】

systemEnvironment【Map<String,Object>】

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // Tell the internal bean factory to use the context's class loader etc. beanFactory.setBeanClassLoader(getClassLoader()); beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); // Configure the bean factory with context callbacks. 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())); } // Register default environment beans. 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()); } }

postProcessBeanFactory(beanFactroy)：BeanFactroy准备工作完成后进行的后置处理工作

子类通过重写这个方法来在BeanFactroy创建并预准备完成以后做进一步的设置

1.2执行BeanFactoryPostPorcessor

invokeBeanFactroyPostProcessors(beanFactory)：执行beanFactroyPostPorcessor的方法

beanFactroyPostPorcessor：BeanFactroy的后置处理器；在beanFactroy标准初始化之后执行的

两个子接口：BeanFactroyProcessor、BeanDefinitionRegistryPostPorcessor

执行顺序：

PostProcessorRegistrationDelegate.invokeBeanFactoryPostPorcessors:执行BeanFactroyPorcessor方法

先执行BeanDefinitionRegistryPostProcessor

获取所有的BeanDefinitionRegistryPostProcessor；

先执行实现了 PriorityOrdered优先级接口的BeanDefinitionRegistryPostPorcessor