EnvironmentPostProcessor自定义配置

我们想着这块把spring相关的有用的接口都过一下，相当于二次消化吧。其实仔细反思我们这一路的学习，我们发现java这块还是有很多要学的，就日常开发的spring来说，就咋写的那些笔记呀，只是毛毛雨。而spring也仅仅是开发的一部分，你想想还有各种中间件技术，是不是感觉头都要大了，没有一定的深度的学习，恐怕很难有质的改变吧。

这块我们学习一下接口EnvironmentPostProcessor，这块我们可以理解为环境变量的处理器。那么这个接口我们在项目中应该如何使用呐？首先我们需要明白的是一个接口的使用必然要涉及其入参和返回值。一般来说java都是引用传值，因此spring的接口都是void的。这样呐，我们就更注重对入参的修改。在解决了功能性质的思考之后呐，我们想着如何让spring识别我们这样一个自定义类。一般来说对于一般的bean，可以通过注解来搞定，为啥是注解呐？因为spring在实例化之前对进行类级别注解的扫描，在最后才进行实例化的。显然如果我们的这里的EnvironmentPostProcessor接口肯定是在其他bean实例化之前实例化的，故此呐，也就只有一种姿势了，那就是spring.factories文件了。基于上述的理解呐，我们写一个demo吧！

//自定义一个配置处理器
public class MyProcessEnvironment implements EnvironmentPostProcessor {




    /**
     * 因为java是引用传值，因此我们这里可以对配置类进行各种定制化操作，除此之外，我们可以懂启动类application的参数进行修改
     * @param environment 配置类
     * @param application 启动类
     */
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        System.out.println("配置处理...");
        System.out.println("现有的配置"+environment.toString());




        //添加一个配置
        Properties properties=new Properties();
        properties.put("tian","tianjingle");
        properties.put("server.port","9999");
        PropertiesPropertySource propertiesPropertySource=new PropertiesPropertySource("a",properties);
        environment.getPropertySources().addLast(propertiesPropertySource);
        //设置spring使用a的配置
        environment.setActiveProfiles("a");
        System.out.println(application.toString());
        
        
        //修改application的对象
        //直接修改
        application.setBannerMode(Banner.Mode.OFF);
    }
}

按照上边的理解，我们在项目中创建spring.factories文件，并指定我们的EnvironmentPostProcessor

org.springframework.boot.env.EnvironmentPostProcessor=\
  com.example.demo.MyProcessEnvironment

通过上述改造，我们就可以自己定义配置文件了，不仅如此，我们还可以在spring启动之前对springapplication的属性进行直接改变。

知道怎么干很简单，我们要知道为什么，这也是咋写文章的原因。挖掘深刻的背后是我们应该干的事。所以我们debug源码看看。这块我们大概的讲解一下源码，因为全量的话太多了。

如图所示的黄色标记为我们重点要看的代码，作者通过debug发现，spring的配置处理器方法的执行是由springapplication监听器触发的，之前分析说springapplicationlistener伴随着springapplication的生命周期。

在获取springapplication监听器的时候
    private SpringApplicationRunListeners getRunListeners(String[] args) {
        Class[] types = new Class[]{SpringApplication.class, String[].class};
//注意这里的getSpringFactoriesInstances方法，该方法就是从spring.factories文件中读取SpringApplicationRunListener.class对应的类，也就是等号之后的类。获取之后肯定是需要实例化的，但是实例化的过程需要参数，注意这里传入了this，也就是监听器中包含了springApplication这个类
        return new SpringApplicationRunListeners(logger,
this.getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args), this.applicationStartup);
    }

通过上述获取springApplicationRunListenner的方法之后，spring运行监听器就加载好了。加载好listenners之后，springApplication逐个走starting方法。之后就开始执行我们标记的2方法。

//这里逐个监听器的执行environmentPrepared方法。   

void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
        this.doWithListeners("spring.boot.application.environment-prepared", (listener) -> {
            listener.environmentPrepared(bootstrapContext, environment);
        });
    }

    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
//广播ApplicationEnvironmentPreparedEvent
        this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(bootstrapContext, this.application, this.args, environment));
    }

注意这里的事件为ApplicationEnvironmentPreparedEvent，我们继续跟踪。

//处理配置的事件   
private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
        ConfigurableEnvironment environment = event.getEnvironment();
        SpringApplication application = event.getSpringApplication();
//获取配置处理器，也就是我们自定义的配置处理器
        Iterator var4 = this.getEnvironmentPostProcessors(event.getBootstrapContext()).iterator();




        while(var4.hasNext()) {
            EnvironmentPostProcessor postProcessor = (EnvironmentPostProcessor)var4.next();
            postProcessor.postProcessEnvironment(environment, application);
        }




    }

这块我们的问题是我们的processenviromment何时初始化的，作者不断的debug，终于找到了两。

我们万万没想到的是这块使用的是EnvironmentPostProcessorApplicationListener，它本质上是一个监听器，所以在处理广播事件的时候，它是会接受消息的。

我们看一下这个监听器的初始化方法。

 public EnvironmentPostProcessorApplicationListener() {
        this(EnvironmentPostProcessorsFactory.fromSpringFactories(EnvironmentPostProcessorApplicationListener.class.getClassLoader()));
    }
//实例化一个配置处理器的工厂，这个工厂的处理器均来自spring.factories文件。
    static EnvironmentPostProcessorsFactory fromSpringFactories(ClassLoader classLoader) {
        return new ReflectionEnvironmentPostProcessorsFactory(SpringFactoriesLoader.loadFactoryNames(EnvironmentPostProcessor.class, classLoader));
    }

所以在接受到消息的时候，配置的工厂将所有的配置后置处理器返回来。然后逐个去执行。

而在消费消息的时候，也做了判断，如下所示：

 public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ApplicationEnvironmentPreparedEvent) {
            this.onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent)event);
        }
        if (event instanceof ApplicationPreparedEvent) {
            this.onApplicationPreparedEvent();
        }
        if (event instanceof ApplicationFailedEvent) {
            this.onApplicationFailedEvent();
        }
    }

小节：springapplicaton启动的时候将各种listener实例化并保存，配置监听器的实例化的同时通过读取spring.factories文件加载我们的配置处理器。在springboot对配置信息进行处理调用时候，通过springboot监听器进行广播，我们的EnvironmentPostProcessorApplicationListener监听到消息之后，进行判断，然后通过配置后置处理器工厂获取所有的配置后置处理器，然后逐个去调用，然后对配置和springapplication启动类的属性进行修改。

今天学的有点猛了~都凌晨了~