spring扩展

BeanDefinitionRegistryPostProcessor

这个类需要与@Import和@Configuration共同配合使用。
一般来说@Import可以导入三种bean

• 普通的bean class
• ImportSelector 这个类可以通过自定义一些条件来控制classpath中需要导入的class
• ImportBeanDefinitionRegistrar
  这个类可以通过代码来动态加载bean，这些bean可以是普通的定义好的class也可以是动态代理。

通过查看代码我们可以知道，spring cloud中的一些常用的注解，包括@EnableFeignClients,@EnableDubboConfig等都是通过ImportBeanDefinitionRegistrar来动态注入的服务调用类到spring容器里面。

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor{
 
  @Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
     // TODO Auto-generated method stub
     System.out.println("MyBeanDefinitionRegistryPostProcessor...bean的数量："+beanFactory.getBeanDefinitionCount());
  }
 
  //BeanDefinitionRegistry Bean定义信息的保存中心，以后BeanFactory就是按照BeanDefinitionRegistry里面保存的每一个bean定义信息创建bean实例；
  @Override
  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
     // TODO Auto-generated method stub
     System.out.println("postProcessBeanDefinitionRegistry...bean的数量："+registry.getBeanDefinitionCount());
     //RootBeanDefinition beanDefinition = new RootBeanDefinition(Blue.class);
     AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Blue.class).getBeanDefinition();
     registry.registerBeanDefinition("hello", beanDefinition);
  }
 
}

BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor

postProcessBeanDefinitionRegistry(); 在所有bean定义信息将要被加载，bean实例还未创建的；
优先于BeanFactoryPostProcessor执行；
利用BeanDefinitionRegistryPostProcessor给容器中再额外添加一些组件；

/* 
 * 
 *   原理：
 *     1）、ioc创建对象
 *     2）、refresh()-》invokeBeanFactoryPostProcessors(beanFactory);
 *     3）、从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件。
 *        1、依次触发所有的postProcessBeanDefinitionRegistry()方法
 *        2、再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor；
 *     4）、再来从容器中找到BeanFactoryPostProcessor组件；然后依次触发postProcessBeanFactory()方法
 */
@ComponentScan("com.atguigu.ext")
@Configuration
public class ExtConfig {
  @Bean
  public Blue blue(){
     return new Blue();
  }
}

BeanFactoryPostProcessor

按spring core文档的描述

BeanFactoryPostProcessor operates on the bean configuration metadata.That is, the Spring IoC container lets a BeanFactoryPostProcessor read the configuration metadata and potentially change it before the container instantiates any beans other than BeanFactoryPostProcessor instances.

这个描述比较清楚了，BeanFactoryPostProcessor可以在容器初始化创建bean之前读他们的元数据信息并能够修改它。在spring framework中，一个比较典型的例子就是PropertySourcesPlaceholderConfigurer，它能通过阅读bean的元信息并结合配置属性源来修改bean definition来完成配置属性注入的功能。
如下需要进行占位符填充的类

@Component
@PropertySource("classpath:application.properties")
public class User {

    @Value("${suser.name}")
    private String name;

    @Value("${suser.age}")
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

PropertySourcesPlaceholderConfigurer 加载时序图

BeanFactoryPostProcessor代码示例

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

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  @Override
  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");
     System.out.println(Arrays.asList(names));
  }
}
 

/*
 * BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作的
 * 
 * 1、BeanFactoryPostProcessor：beanFactory的后置处理器；
 *     在BeanFactory标准初始化之后调用，来定制和修改BeanFactory的内容；
 *     所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建
 * 
 * BeanFactoryPostProcessor原理:
 * 1)、ioc容器创建对象
 * 2)、invokeBeanFactoryPostProcessors(beanFactory);
 *     如何找到所有的BeanFactoryPostProcessor并执行他们的方法；
 *        1）、直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法
 *        2）、在初始化创建其他组件前面执行
 */
@ComponentScan("com.atguigu.ext")
@Configuration
public class ExtConfig {
  @Bean
  public Blue blue(){
     return new Blue();
  }
}

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

ApplicationListener

ApplicationListener：监听容器中发布的事件。事件驱动模型开发；
public interface ApplicationListener监听 ApplicationEvent 及其下面的子事件；
步骤：

1. 写一个监听器（ApplicationListener实现类）来监听某个事件（ApplicationEvent及其子类）
   @EventListener;
   原理：使用EventListenerMethodProcessor处理器来解析方法上的@EventListener；

2. 把监听器加入到容器；

3. 只要容器中有相关事件的发布，我们就能监听到这个事件；
   ContextRefreshedEvent：容器刷新完成（所有bean都完全创建）会发布这个事件；

   1.容器创建对象：refresh()；
   2. finishRefresh();容器刷新完成会发布ContextRefreshedEvent事件

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

4. 发布一个事件：
   applicationContext.publishEvent()；

  【事件发布流程】：
   3）、publishEvent(new ContextRefreshedEvent(this));
        1）、获取事件的多播器（派发器）：getApplicationEventMulticaster()
        2）、multicastEvent派发事件：
        3）、获取到所有的ApplicationListener；
          for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
          1）、如果有Executor，可以支持使用Executor进行异步派发；
             Executor executor = getTaskExecutor();
          2）、否则，同步的方式直接执行listener方法；invokeListener(listener, event);
           拿到listener回调onApplicationEvent方法；
  
  【事件多播器（派发器）】
   1）、容器创建对象：refresh();
   2）、initApplicationEventMulticaster();初始化ApplicationEventMulticaster；
     1）、先去容器中找有没有id=“applicationEventMulticaster”的组件；
     2）、如果没有this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        并且加入到容器中，我们就可以在其他组件要派发事件，自动注入这个applicationEventMulticaster；
  
  【容器中有哪些监听器】
   1）、容器创建对象：refresh();
   2）、registerListeners();
     从容器中拿到所有的监听器，把他们注册到applicationEventMulticaster中；
     String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
     //将listener注册到ApplicationEventMulticaster中
     getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

系统日志派发事件示例

/**
 * 系统日志事件
 */
public class LogEvent extends ApplicationEvent {

	public LogEvent(Map<String, Object> source) {
		super(source);
	}

}

异步监听日志事件

/**
 * 异步监听日志事件
 */
@Slf4j
@AllArgsConstructor
public class UsualLogListener {

	@Async
	@Order
	@EventListener(LogEvent.class)
	public void saveUsualLog(LogEvent event) {
		Map<String, Object> source = (Map<String, Object>) event.getSource();
		LogUsual logUsual = (LogUsual) source.get(EventConstant.EVENT_LOG);
		//...获取到logUsual进行相关操作处理 
	}

}

/**
 * 日志信息事件发送
 */
public class LogPublisher {

	public static void publishEvent(String level, String id, String data) {
		LogUsual logUsual = new LogUsual();
		//...logUsual 属性设置
		Map<String, Object> event = new HashMap<>(16);
		event.put(EventConstant.EVENT_LOG, logUsual);
		//运用封装的工具类进行事件发布 等同于ApplicationContext context.publishEvent(event);
		SpringUtil.publishEvent(new LogEvent(event));
	}

}

参考链接：
PropertySourcesPlaceholderConfigurer工作原理
spring常用扩展点小记