扩展

BeanFactoryPostProcessor

BeanPostProcessor: bean后置处理器 bean创建对象初始化前后进行拦截工作的

BeanFactoryPostProcessor: beanFactory的后置处理器，在Beanfactory标准初始化之后调用；所有的Bean定义已经保存加载到beanFactory/.但是Ban实例还未创建

实现接口的Bean：

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("postProcessBeanFactory");
        int count = beanFactory.getBeanDefinitionCount();
        String[] names = beanFactory.getBeanDefinitionNames();
        System.out.println("当前BeanFactory中有"+count+"个Bean");
        System.out.println(Arrays.asList(names));
        
    }

}

config:

@Configuration
@ComponentScan("com.toov5.ExtBean")
public class ExtConfig {
    @Bean
    public Boss boss() {
        return new Boss();
    }
}

Test：

public class test {
    @Test 
    public void test01(){    
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ExtConfig.class);
        applicationContext.close();
      }  
}

结果：看到执行过程如下

步骤：

1 ioc容器创建对象

2 invokeBeanFactoryPostProcessors(beanFactory) ; 执行BeanfactoryPostProcessor；如何找到所有的BeanFactoryPostProcessor并执行他们的方法

a,直接在BeanFactory中找到所有类型是BeanfactoryPostProcessor的组件，并执行他们的方法。

b,在初始化创建其他组件前面执行

MyBeanDefinitionRegistryPostProcessor ：

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("BeanDefinitionRegistryPostProcessor..bean的数量"+beanFactory.getBeanDefinitionCount());
        
    }
   //BeanDefinitionRegistry  Bean定义信息的保存中心  以后BeanFactory就是按照BeanDefinitionRegistry里面保存的每一个Bean定义信息创建bean实例
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        System.out.println("BeanDefinitionRegistryPostProcessor..Bean的数量"+registry.getBeanDefinitionCount());
        //可以自己注册Bean
        //    RootBeanDefinition beanDefinition = new RootBeanDefinition(Car.class);
       //或者这样,与上面效果是一样的
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Car.class).getBeanDefinition();
        registry.registerBeanDefinition("helloBeanName", beanDefinition);
    }

}

执行test方法后:

可以看出优先于

BeanFactoryPostProcessor  执行

利用

BeanDefinitionRegistryPostProcessor  给容器中再额外添加一些组件

原理：

1 ioc创建对象

2 refresh() ---> invokeBeanFactoryPostProcessors(beanFactory)

3 从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件

1 一次触发所有的postProcessBeanDefinitionRegistry() 方法

2 再来触发postProcessBeanFactory() 方法

ApplicationListener：监听容器中发布的时间。时间驱动模型开发

public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {

监听ApplicationEvent 及其下面的子事件

容器刷新事件容器关闭事件

步骤：

1 写一个监听器来监听某个事件(ApplicationEvent及其子类)

2 把监听器注册到容器中

3 只要容器中有相关事件的发布，就能监听到这个事件

ContextRefreshedEvent: 容器刷新完成（所有bean都完全创建）会发布事件

ContextClosedEvent：关闭容器会发布这个事件

4 发布一个事件

监听：

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

}

test: 发布了一个事件

public class test {
    @Test 
    public void test01(){    
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ExtConfig.class);
        //发布事件
        applicationContext.publishEvent(new ApplicationEvent(new String("我发布的时间")) {
        });
        applicationContext.close();
      }  
}

结果：

原理：

ContextRefreshedEvent事件

1、容器创建对象 refresh()

2、 finishRefresh() 容器刷新完成，容器刷新完成会发布ContextRefreshedEvent事件。我们也可以自己发布事件，容器关闭会发布事件

3、publishEvent(new ContextRefreshedEvent(this) )

事件发布流程：

获取事件的多播器（派发器）: getApplicationEventMulticaster()

multicastEvent派发事件

获取到所有的ApplicationListener：如果有Executor 可以支持使用Executor进行异步派发，否则，同步的方法直接知心Listener方法 invokeListener(listener, event)

拿到listener回调onApplicationEvent方法

@EventListener 跟实现Listener接口实现的效果是一样的

service

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

config

@Configuration
@ComponentScan("com.toov5.service")
public class ExtConfig {
    @Bean
    public Boss boss() {
        return new Boss();
    }
}

test：

public class test {
    @Test 
    public void test01(){    
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ExtConfig.class);
        //发布事件
        applicationContext.publishEvent(new ApplicationEvent(new String("我发布的时间")) {
        });
        applicationContext.close();
      }  
}

结果：

监听器的实现ApplicationListener监听某个事件， ApplicationEvent及其子类

@EventListener

原理：使用EventListenerMethodProcessor处理器来解析方法上的@EcentListener

SmatInitializationSingleton原理

ioc容器创建对象并refresh()

finishBeanFactoryInitialization(beanFactory) 初始化剩下的单实例bean

先创建所有的单实例bean getBean()

获取所有创建好的单实例bean，判断是否是SmartInitatializingSingleton类型的。是就调用afterSingletonInstantiated()