Spring的扩展原理

  • Z时代
  • 2024-01-10
  • 分类：综合

编程

MainConfigOfExt.class

/**
 * 扩展原理：
 * 1. BeanPostProcessor：bean后置处理器；bean创建对象初始化前后进行拦截工作
 *      BeanFactoryPostProcessor:beanFactory的后置处理器
 *          在BeanFactory标准初始化之后调用，所有的bean定义已经保存加载到BeanFactory,但是Bean的实例还未创建
 *      1. ioc容器创建对象
 *      2. invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor；
 *      如何找到所有的BeanFactoryPostProcessor并执行它们的方法
 *          1. 直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法
 *          2. 在创建其他组件之前执行
 *
 * 2. BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
 *      postProcessBeanDefinitionRegistry
 *      在所有bean定义信息将要被加载，bean实例还未创建的时候执行；
 *      优先于BeanFactoryPostProcessor执行；
 *      利用BeanDefinitionRegistryPostProcessor给容器中额外添加一些组件
 *      原理：
 *          1. IOC容器创建
 *          2. refresh()->invokeBeanFactoryPostProcessors(BeanFactory)
 *          3. 从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件，
 *              1. 依次触发所有的postProcessBeanDefinitionRegistry
 *              2. 再来触发postProcessorBeanFactory()方法，BeanFactoryPostProcessor
 *          4. 再从容器中找到BeanFactoryPostProcessor组件，然后义次触发postProcessBeanFactory
 *
 * 3. ApplicationListener,监听容器中发布的事件，事件驱动模型开发
 *      ApplicationListener<E extends ApplicationEvent> extends EventListener
 *      监听ApplicationListener
 *      1. 写一个监听器监听某个事件（ApplicationEvent及其子类）
 *          @EventListener
 *          原理：使用EventListenerMethodProcessor处理器来解析方法上的 @EventListener
 *
 *      2. 把监听器放在容器中
 *      3. 只要容器有相应类型的事件发布，就能监听到该事件
 *          ContextRefreshedEvent：容器完成创建（所有Bean都创建完成）会发布该事件
 *          ContextClosedEvent：容器关闭会发布该事件
 *      4. 发布一个事件：applicationContext.publishEvent(ApplicationEvent)
 *    原理：
 *      1. 容器创建对象：refresh()
 *      2. finishRefresh();容器刷新完成会发布ContextRefreshedEvent
 *      3. publishEvent(new ContextRefreshedEvent(this))
 *          事件发布流程：
 *              1. 获取事件的派发器：getApplicationEventMulticaster
 *              2. multicastEvent(applicationEvent, eventType)：派发事件
 *              3. 获取到所有的ApplicationListener
 *                  for (final ApplicationListener<?> listener : getApplicationListeners(event, type))
 *                      1. 如果有Executor，可以支持使用Executor进行异步派发；Executor executor = getTaskExecutor();
 *                      2. 否则：执行同步发放方法：invokeListener(listener, event);
 *                      拿到listener执行
 *      【事件派发器】:
 *          1. 容器创建对象：refresh()
 *          2. initApplicationEventMulticaster();初始化ApplicationEventMulticaster
 *              1. 先去容器中找有没有id="applicationEventMulticaster"的组件
 *              2. 如果没有则 利用this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
 *              beanFactory.registerSingleton(applicationEventMulticaster),就可以在其他组件要派发事件时，自动注入这个applicationEventMulticaster
 *      【容器中有哪些监听器】
 *          1. 容器创建对象：refresh()
 *          2. registerListeners()
 *              String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
 *
 *              getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName)
 *
 * 4. SmartInitializingSingleton原理：->afterSingletonsInstantiated()
 *          1. IOC容器创建对象并用refresh刷新容器
 *          2. finishBeanFactoryInitialization(beanFactory)；初始化剩下的单实例bean
 *              1. 先创建所有的单实例bean：getBean
 *              2. 获取所有创建好的单实例bean,判断是否是SmartInitializingSingleton类型的
 *                  如果是调用afterSingletonsInstantiated()
 *
 *
 */
@ComponentScan("com.lun.ext")
@Configuration
public class MainConfigOfExt {
    @Bean
    public Blue blue() {
        return new Blue();
    }
}

MyApplicationListener.class

@Component
public class MyApplicationListener implements ApplicationListener {
    /**
     * 当容器中发布此事件以后，方法触发
     */
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println("收到事件：" + event);
    }
}

MyBeanDefinitionRegistryPostProcessor.class

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    /**
     * BeanDefinitionRegistry 保存了所有Bean定义信息保存中心，
     * 以后BeanFactory就是按照BeanDefinitionRegistry里保存的每一个bean的定义信息创建bean实例
     */
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        System.out.println("MyBeanDefinitionRegistryPostProcessor....postProcessBeanDefinitionRegistry....");
//        RootBeanDefinition beanDefinition = new RootBeanDefinition(Blue.class);
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Blue.class).getBeanDefinition();
        registry.registerBeanDefinition("hello", beanDefinition);
    }
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanDefinitionRegistryPostProcessor....postProcessBeanFactory....");
    }
}

MyBeanFactoryPostProcessor.class

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor..........postProcessBeanFactory.....");
        int count = beanFactory.getBeanDefinitionCount();
        String[] names = beanFactory.getBeanDefinitionNames();
        System.out.println("当前BeanFactory中有" + count + "个Bean定义");
        for (String name : names) {
            System.out.println(name);
        }
    }
}

UserService.class

@Service
public class UserService {
    @EventListener(classes = {ApplicationEvent.class})
    public void listen(ApplicationEvent event) {
        System.out.println("userService..........监听到事件：" + event);
    }
}

Blue.class

public class Blue {
    public Blue() {
        System.out.println("constructor...........");
    }
    public void init() {
        System.out.println("blue......init......");
    }
    public void destroy() {
        System.out.println("blue......destroy......");
    }
}

以上是 Spring的扩展原理 的全部内容， 来源链接： utcz.com/z/516923.html

回到顶部