静态工具类读取springboot配置文件:通过ConfigurableEnvironment和SpringApplicationRunListener

文章来源：原创   作者：临窗旋墨   发布时间：2024-04-19   阅读：113   标签：源码,springboot 分类：springboot 专题：springboot

静态工具类读取springboot配置文件:通过ConfigurableEnvironment和SpringApplicationRunListener

springboot版本：2.7.3

  1. 有的时候需要在静态工具方法中访问到系统配置的springboot参数：包括application.preperties以及不同的环境或者其他方式import到spring的参数。

  2. springboot的配置文件位置可能是不确定的，有可能在jar中，jar的config中，或者jar的同目录下，或者jar的同目录下的config文件夹中

  3. 所以读取springboot配置文件的工具类无法写死配置文件的目录。
  4. 因此，需要借助springboot去读取这些配置参数。

一 、借助Environment读取参数配置项

Spring Boot 中 Environment 中的配置源于多个配置源，有的来自系统环境变量，有的来自命令行参数，有的来自用户配置。Environment 屏蔽了各个配置源间不同的配置获取方式，对外提供统一的调用接口。并且相关配置的优先级已经处理好，我们只需要从Environment中获取最终的数据即可。

所以，只需要在工具类中SpringBootApplicationPropertiesUtil获取到Environment就能获取到相关配置项。

  1. public class SpringBootApplicationPropertiesUtil  {
  3.     private static ConfigurableEnvironment environment;
  4. }

获取的方式有很多，比如 实现ApplicationContextAware接口，重写setApplicationContext， 通过ApplicationContext获取Environment。然后把工具类注册到spring。或者把setEnvironment置为static,在spring启动的合适的时候调用，以注入ConfigurableEnvironment。

二、借助SpringApplicationRunListener提前注入Environment到工具类

  • 我希望Environment的注入时机能更早，在它准备完毕的时候就能注入到工具类中，这些在其他Bean初始化的时候就能可以使用SpringBootApplicationPropertiesUtil，而无法担心Environment尚未注入。

  • 所以这里通过SpringApplicationRunListener#environmentPrepared回调注入Environment

三、springboot(2.7.3)run部分源码

  1.     public ConfigurableApplicationContext run(String... args) {
  2.         ....
  3.         //获取 SpringApplicationRunListener  监听器
  4.         SpringApplicationRunListeners listeners = getRunListeners(args);
  5.         listeners.starting(bootstrapContext, this.mainApplicationClass);
  7.             ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  8.             //在prepareEnvironment方法中会调用listeners.environmentPrepared(bootstrapContext, environment);
  9.             ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
  10.             configureIgnoreBeanInfo(environment);
  11.             ......
  12.             prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
  13.             refreshContext(context);
  14.             afterRefresh(context, applicationArguments);
  15.         .....
  16.         return context;
  17.     }
  20. private ConfigurableEnvironment prepareEnvironment(...) {
  21.         // Create and configure the environment
  22.         ConfigurableEnvironment environment = getOrCreateEnvironment();
  23.         configureEnvironment(environment, applicationArguments.getSourceArgs());
  24.         ConfigurationPropertySources.attach(environment);
  25.         // 通知监听器，环境准备好，  (也是我们需要把environment注入到工具类的时机)  
  26.         listeners.environmentPrepared(bootstrapContext, environment);
  27.         ......
  28.         return environment;
  29.     }

如上文代码，springboot在启动的时候，会先准备好ConfigurableEnvironment,然后调用监听器的environmentPrepared方法，做一些回调，这里就是通过这个回调初始化我们的静态工具类。

SpringBootApplicationPropertiesUtil代码

这里直接用工具类本身实现SpringApplicationRunListener，而不再额外的写一个监听器。

使用方式：在resources/META-INFO/spring.factories中配置此监听器：

org.springframework.boot.SpringApplicationRunListener=cn.xuqiudong.common.util.SpringBootApplicationPropertiesUtil

注意：注入时机比一般的Bean初始化时机更早，但是在EnvironmentPostProcessor之后

  1. package cn.xuqiudong.common.util;
  3. import org.apache.commons.lang3.StringUtils;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.boot.ConfigurableBootstrapContext;
  7. import org.springframework.boot.SpringApplication;
  8. import org.springframework.boot.SpringApplicationRunListener;
  9. import org.springframework.core.env.ConfigurableEnvironment;
  10. import org.springframework.core.env.MapPropertySource;
  11. import org.springframework.core.env.PropertySource;
  13. import java.math.BigDecimal;
  14. import java.util.ArrayList;
  15. import java.util.HashMap;
  16. import java.util.List;
  17. import java.util.Map;
  18. import java.util.stream.Collectors;
  19. import java.util.stream.Stream;
  21. /**
  22.  * 描述: 通过ConfigurableEnvironment读取springboot 配置文件中的值
  23.  *    比一般的Bean初始化时机更早，但是在EnvironmentPostProcessor之后
  24.  * <p>
  25.  *     通过SpringApplicationRunListener
  26.  *    在spring上下文准备好之前，为SpringBootApplicationPropertiesUtil 工具类设置 ConfigurableEnvironment
  27.  *    在resources/META-INFO/spring.factories中配置此监听器：
  28.  *    org.springframework.boot.SpringApplicationRunListener=cn.xuqiudong.common.util.SpringBootApplicationPropertiesUtil
  29.  * </p>
  30.  * @author Vic.xu
  31.  * @since 2024-04-18 10:33
  32.  */
  33. public class SpringBootApplicationPropertiesUtil implements SpringApplicationRunListener {
  35.     private static ConfigurableEnvironment environment;
  37.     private static final String DELIMITER = ",";
  39.     private static final Logger LOGGER = LoggerFactory.getLogger(SpringBootApplicationPropertiesUtil.class);
  41.     /**
  42.      * 初始化：should declare a public constructor that accepts a {@link SpringApplication}
  43.      *  * instance and a {@code String[]} of arguments.
  44.      * @see SpringApplicationRunListener
  45.      */
  46.     public SpringBootApplicationPropertiesUtil(SpringApplication application, String[] args) {
  47.         LOGGER.info("SpringBootApplicationPropertiesUtil initialized  as  a SpringApplicationRunListener !!!");
  48.     }
  50.     /**
  51.      * 在spring上下文准备好之前，为本工具类设置 ConfigurableEnvironment
  52.      */
  53.     @Override
  54.     public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
  55.         setEnvironment(environment);
  56.     }
  58.     public static void setEnvironment(ConfigurableEnvironment environment) {
  59.         SpringBootApplicationPropertiesUtil.environment = environment;
  60.     }
  62.     /**
  63.      *  获取 String
  64.      * @param key key
  65.      */
  66.     public static String getString(String key) {
  67.         return environment.getProperty(key);
  68.     }
  71.     /**
  72.      *  获取 String
  73.      * @param key key
  74.      * @param defaultValue the default value to return if no value is found
  75.      */
  76.     public static String getString(String key, String defaultValue) {
  77.         return environment.getProperty(key, defaultValue);
  78.     }
  80.     /**
  81.      *  获取 Boolean
  82.      * @param key key
  83.      */
  84.     public static Boolean getBoolean(String key) {
  85.         return environment.getProperty(key, Boolean.class);
  86.     }
  88.     /**
  89.      *  获取 Boolean
  90.      * @param key key
  91.      * @param defaultValue the default value to return if no value is found
  92.      */
  93.     public static Boolean getBoolean(String key, Boolean defaultValue) {
  94.         return environment.getProperty(key, Boolean.class, defaultValue);
  95.     }
  97.     /**
  98.      *  获取 Integer
  99.      * @param key key
  100.      */
  101.     public static Integer getInteger(String key) {
  102.         return environment.getProperty(key, Integer.class);
  103.     }
  105.     /**
  106.      *  获取 Integer
  107.      * @param key key
  108.      * @param defaultValue the default value to return if no value is found
  109.      */
  110.     public static Integer getInteger(String key, Integer defaultValue) {
  111.         return environment.getProperty(key, Integer.class, defaultValue);
  112.     }
  114.     /**
  115.      *  获取 BigDecimal
  116.      * @param key key
  117.      */
  118.     public static BigDecimal getBigDecimal(String key) {
  119.         return environment.getProperty(key, BigDecimal.class);
  120.     }
  122.     /**
  123.      *  获取 BigDecimal
  124.      * @param key key
  125.      * @param defaultValue the default value to return if no value is found
  126.      */
  127.     public static BigDecimal getBigDecimal(String key, BigDecimal defaultValue) {
  128.         return environment.getProperty(key, BigDecimal.class, defaultValue);
  129.     }
  131.     /**
  132.      *  获取 Double
  133.      * @param key key
  134.      */
  135.     public static Double getDouble(String key) {
  136.         return environment.getProperty(key, Double.class);
  137.     }
  139.     /**
  140.      *  获取 Double
  141.      * @param key key
  142.      * @param defaultValue the default value to return if no value is found
  143.      */
  144.     public static Double getDouble(String key, Double defaultValue) {
  145.         return environment.getProperty(key, Double.class, defaultValue);
  146.     }
  148.     /**
  149.      *  获取long
  150.      * @param key key
  151.      * @param defaultValue the default value to return if no value is found
  152.      */
  153.     public static Long getLong(String key, Long defaultValue) {
  154.         return environment.getProperty(key, Long.class, defaultValue);
  155.     }
  157.     /**
  158.      *  获取long
  159.      * @param key key
  160.      */
  161.     public static Long getLong(String key) {
  162.         return environment.getProperty(key, Long.class);
  163.     }
  165.     /**
  166.      * 获取逗号分隔的字符串为List
  167.      * @param key key
  168.      */
  169.     public static List<String> getStringAsList(String key) {
  170.         String property = environment.getProperty(key);
  171.         if (StringUtils.isBlank(property)) {
  172.             return new ArrayList<>();
  173.         }
  174.         return Stream.of(property.split(DELIMITER)).collect(Collectors.toList());
  175.     }
  177.     /**
  178.      * 获取 Map
  179.      * (此处不缓存， 兼容以后动态刷新环境变量的情境)
  180.      * @param prefix key prefix
  181.      */
  182.     public static Map<String, Object> getMapConfig(String prefix) {
  183.         Map<String, Object> result = new HashMap<>();
  184.         if (StringUtils.isBlank(prefix)) {
  185.             return result;
  186.         }
  187.         for (PropertySource<?> propertySource : environment.getPropertySources()) {
  188.             if (propertySource instanceof MapPropertySource) {
  189.                 MapPropertySource mapPropertySource = (MapPropertySource) propertySource;
  190.                 Map<String, Object> sourceMap = mapPropertySource.getSource();
  191.                 for (Map.Entry<String, Object> entry : sourceMap.entrySet()) {
  192.                     String propertyName = entry.getKey();
  193.                     prefix += ".";
  194.                     if (propertyName.startsWith(prefix)) {
  195.                         String keyWithoutPrefix = propertyName.substring(prefix.length());
  196.                         result.put(keyWithoutPrefix, entry.getValue());
  197.                     }
  198.                 }
  199.             }
  200.         }
  201.         return result;
  202.     }
  203. }

2024-04-19

源码地址：lcxm-common-util

发表评论

目录