spring源码-扩展点

/**
 * @Author quan
 * @Date 2020/11/13
 * 扩展原理
 * BeanPostProcessor bean后置处理器，bean创建对象初始化前后进行拦截工作
 *
 *
 * BeanFactoryPostProcessor BeanFactory后置处理器
 * 在BeanFactory标准初始化之后调用，所有的Bean定义已经保存加载到BeanFactory，可以修改订制BeanFactory的内容
 * 但是BeanFactory还没帮我们实例化
 *
 * 1ioc容器创建对象
 * 2invokeBeanFactoryPostProcessors(beanFactory)执行BeanFactoryPostProcessor
 * 如何拿到所有BeanFactoryPostProcessors 在这个类PostProcessorRegistrationDelegate（invoker入口AbstractApplicationContext）
 *      String[] postProcessorNames =
 *                 beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
 *             这里取获取所有后置bean的name,然后进行排序
 *         1.直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法
 *         2.在初始化创建其他组件前执行
 *
 *
 * BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
 *      void postProcessBeanDefinitionRegistry
 *      指定世纪：看源码注解iiu知道了。在所有Bean定义信息将要被加载的时候，bean实例还未创建的时候
 *      比BeanFactoryPostProcessor还要前,
 *      利用BeanDefinitionRegistryPostProcessor给容器中添加额外添加一些组件
 *
 *      原理：
 *      1ioc容器创建
 *      2refresh()->invokeBeanFactoryPostProcessors(beanFactory);
 *      3从容器中获取到所有的BeanDefinitionRegistryPostProcessor AbstractApplicationContext#invokeBeanFactoryPostProcessors实际上执行：PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors
 *      4依次触发所有的postProcessBeanDefinitionRegistry invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
 *      5再触发：postProcessBeanFactory实际上是再BeanFactoryPostProcessor
 *      6再从容器中找到BeanFactoryPostProcessor组件，返回一次触发postProcessBeanFactory。
 *
 *
 * ApplicationListener:监听容器中发布的时间，事件驱动模型开发
 *      public interface ApplicationListener<E extends ApplicationEvent> extends EventListener
 *          都要监听ApplicationEvent及其下面的子事件：
 *  步骤：
 *      1下一个监听器来监听某个事件（ApplicationEvent及其子类）
 *      2监听器加入到容器
 *      3只要容器中有相关事件的发布，我们九年监听到这个事件。
 *          Spring发布的事件 ContextRefreshedEvent 容器刷新完成（所有Bean都被完全创建），会发布这个事件
 *                          ContextClosedEvent 关闭容器会发布这个事件
 *      4发布一个事件：
 *          applicationContext.publishEvent();
 *
 *   原理：
 *      第一个事件：ContextRefreshedEvent
 *          1容器创建 refresh()
 *          2finishRefresh容器刷新完成
 *              这个方法里面调用了    publishEvent(new ContextRefreshedEvent(this))
 *                  里面发布流程：
 *                      1-获取事件的多播器()getApplicationEventMulticaster()
 *                      2-multicastEvent派发事件
 *                      3-获取所有的ApplicationListener
 *                          for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
 *                              1-如果有Executor 可以支持使用Executor进行异步派发
 *                                  Executor executor = getTaskExecutor();
 *                              2-否则同步执行invokeListener(listener, event);
 *                              3-拿到Listener回调onApplicationEvent方法listener.onApplicationEvent(event)
 *      最后一个事件：ContextCloseEvent
 *          AbstractApplicationContext#doClose();
 *
 *
 *    {事件多播器怎么获取的呢}：
 *      1.容器创建对象Refresh:
 *      2.AbstractApplicationContext#initApplicationEventMulticaster();初始化事件多播器
 *          1-先去BeanFactory里面有没有id=applicationEventMulticaster的Bean
 *          2-如果没有就新建一个new SimpleApplicationEventMulticaster(beanFactory)，并注册进去：
 *              beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
 *              那就可以再其他组件要派发事件，则自动注入即可
 *
 *     {容器有那些监听器}
 *       1.容器创建对象Refresh:
 *       2.registerListeners();
 *           从容器中拿到所有的监听器，
 *           String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
 *           把他们注册到ApplicationEventMulticaster中
 *           getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
 *
 *      #另一种是心啊监听器的方法@EventListener
 *      原理：
 *          1-点进注解里面，看注释可以直到主要工作的市EventListenerMethodProcessor来解析注解
 *
 *      SmartInitializingSingleton原理：---》执行时机afterSingletonsInstantiated
 *          1-ioc容器创建对象并refresh
 *          2-finishBeanFactoryInitialization 初始化剩下的单实例bean
 *              1-其实执行的市DefaultListableBeanFactory#preInstantiateSingletons
 *              2-先创建所有的单实例bean,getBean
 *              3-获取所有创建好的单实例bean,判断是否是SmartInitializingSingleton类型
 *                  并执行smartSingleton.afterSingletonsInstantiated();
 */

/**
 * @Author quan
 * @Date 2020/11/13
 * 扩展点=-BeanFactoryPostProcessor
 * <p>
 * <p>
 * * Modify the application context's internal bean factory after its standard
 * * initialization. All bean definitions will have been loaded, but no beans
 * * will have been instantiated yet. This allows for overriding or adding
 * * properties even to eager-initializing beans.
 * * @param beanFactory the bean factory used by the application context
 * * @throws org.springframework.beans.BeansException in case of errors
 */

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
//        System.out.println(" MyBeanFactoryPostProcessor");
        int count = beanFactory.getBeanDefinitionCount();
        System.out.println("MyBeanFactoryPostProcessor"+count);
        String[] names = beanFactory.getBeanDefinitionNames();
        System.out.println(Arrays.asList(names));
    }
}

/**
 * @Author quan
 * @Date 2020/11/13
 */
@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    //BeanDefinitionRegistry Bean定义信息的保存中心
    //BeanFactory都是按照BeanDefinitionRegistry里面保存的每一个Bean定义信息创建Bean的实例
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        System.out.println("MyBeanDefinitionRegistryPostProcessor-postProcessBeanDefinitionRegistry数量" +registry.getBeanDefinitionCount());
//        RootBeanDefinition beanDefinition = new RootBeanDefinition(Quan.class);
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Quan.class).getBeanDefinition();
        registry.registerBeanDefinition("quan",beanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanDefinitionRegistryPostProcessor-postProcessBeanFactory数量" +beanFactory.getBeanDefinitionCount());
    }
}

/**
 * @Author quan
 * @Date 2020/11/20
 */
@Service
public class MyServiceEventListener {

    @EventListener(classes = {ApplicationEvent.class})
    public void listen(ApplicationEvent event){
        System.out.println("EventListener"+event);
    }
}

/**
 * @Author quan
 * @Date 2020/11/18
 */
@Component//需要加载到容器中去
public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {
    //当容器发布此事件的时候，方法会得到促发
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println("事件-----"+event);
    }
}