package 包指定忽略，請(qǐng)自定;
 
import 忽略解密計(jì)算工具類(lèi)SystemSecurityAlgorithm，請(qǐng)自定;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.util.StringUtils;
 
/**
 * 連接Redis集群的配置類(lèi)【通過(guò)@Configuration覆蓋原Bean機(jī)制】:
 *   1、連接Redis的連接password不得出現(xiàn)明文，故需在properties配置文件中配置為加密密文（加密算法Java類(lèi)為：SystemSecurityAlgorithm），然后在啟動(dòng)時(shí)通過(guò)本類(lèi)解密
 *   2、貴金屬應(yīng)用服務(wù)采用多數(shù)據(jù)中心DataCenter部署。而每邏輯中心均有獨(dú)立的Redis集群。 應(yīng)用服務(wù)應(yīng)連接同邏輯中心內(nèi)的Redis集群，既北京的應(yīng)用服務(wù)不應(yīng)該連接合肥Redis集群
 *     既：對(duì)于同服務(wù)的不同實(shí)例，應(yīng)根據(jù)服務(wù)實(shí)例所在邏輯中心（具體見(jiàn)枚舉ServiceConstant.DataCenter定義的邏輯中心）連接相同邏輯中心下的Redis集群。
 *     因此：
 *        a).以Spring標(biāo)準(zhǔn)Redis連接配置為基礎(chǔ)，對(duì)nodes值中各個(gè)IP端口配置，在各IP前增加一個(gè)大寫(xiě)字母：該IP所在DataCenter數(shù)據(jù)中心的英文代碼
 *        b).以Spring標(biāo)準(zhǔn)Redis連接配置為基礎(chǔ)，對(duì)password值改為可配多個(gè)密碼，以逗號(hào)分隔，每個(gè)密碼前增加一個(gè)大寫(xiě)字母，該密碼是連接哪個(gè)Redis集群的DataCenter數(shù)據(jù)中心的英文代碼
 * 為支持以上，定制化開(kāi)發(fā)本類(lèi)，實(shí)現(xiàn)處理最終還原至Spring標(biāo)準(zhǔn)連接Redis的配置，以供lettuce創(chuàng)建連接池。
 *  -----------------------------------------------------------
 * 機(jī)制適用性：
 * 除了通過(guò)@Configuration覆蓋原Bean機(jī)制，還有通過(guò)實(shí)現(xiàn)EnvironmentPostProcessor接口機(jī)制。兩種機(jī)制適用性說(shuō)明如下：
 *   bootstrap.properties配置文件（bootstrap階段，還未創(chuàng)建Bean） →→適合→→ 【實(shí)現(xiàn)EnvironmentPostProcessor接口機(jī)制】
 *   本地application.properties配置文件（正常SpringBoot啟動(dòng)，通過(guò)@Configuration注解的Bean） →→適合→→ 【實(shí)現(xiàn)EnvironmentPostProcessor接口機(jī)制】和【通過(guò)@Configuration覆蓋原Bean機(jī)制】均可
 *   從Nacos等配置中心獲取得到的配置文件 →→適合→→ 【通過(guò)@Configuration覆蓋原Bean機(jī)制】
 *
 */
@Configuration
@Primary // 由于默認(rèn)RedisProperties作為配置類(lèi)會(huì)自動(dòng)創(chuàng)建Bean。 為避免存在兩個(gè)同類(lèi)型（RedisProperties）Bean，所以本類(lèi)通過(guò)注解Primary，使得只有本類(lèi)生效。相當(dāng)于替代默認(rèn)RedisProperties
public class GjsRedisProperties extends RedisProperties {
 
    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(GjsRedisProperties.class);
 
    @Override
    public void setPassword(String orginPassword) {
        if(StringUtils.hasText(orginPassword)) {
            // 對(duì)密文解密并設(shè)置
            if (StringUtils.hasText(orginPassword) && orginPassword.length() >= 32 ) { // 如果滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求，視為密文，解密
                String padStr = SystemSecurityAlgorithm.decryptStr(orginPassword);
                log.debug("連接Redis配置項(xiàng)spring.redis.password: 解密前orginPassword=[{}], 解密后padStr=[{}]", orginPassword, padStr); //為避免密碼泄露，僅debug才輸出明文
                log.info("連接Redis配置項(xiàng)spring.redis.password: 對(duì)密文orginPassword=[{}]已完成解密", orginPassword);
                super.setPassword(padStr);
            } else { // 不滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求(視為明文,不解密)，保持不變
                log.warn("連接Redis配置項(xiàng)spring.redis.password的:orginPassword=[{}]不滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求(視為明文,不解密)，保持不變", orginPassword);
                super.setPassword(orginPassword);
            }
        }
    }
}

package 包指定忽略，請(qǐng)自定;
 
import 忽略解密計(jì)算工具類(lèi)SystemSecurityAlgorithm，請(qǐng)自定;
import org.apache.rocketmq.spring.autoconfigure.RocketMQProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MapPropertySource;
import org.springframework.util.StringUtils;
 
import java.util.HashMap;
import java.util.Map;
 
/**
 * 連接RocketMQ的配置類(lèi)【通過(guò)@Configuration覆蓋原Bean機(jī)制】:
 *   因連接RocketMQ的secret-key不得出現(xiàn)明文，故需在properties配置文件中配置為加密密文（加密算法Java類(lèi)為：SystemSecurityAlgorithm），然后在啟動(dòng)時(shí)通過(guò)本類(lèi)解密
 *  -----------------------------------------------------------
 * 機(jī)制適用性：
 * 除了通過(guò)@Configuration覆蓋原Bean機(jī)制，還有通過(guò)實(shí)現(xiàn)EnvironmentPostProcessor接口機(jī)制。兩種機(jī)制適用性說(shuō)明如下：
 *   bootstrap.properties配置文件（bootstrap階段，還未創(chuàng)建Bean） →→適合→→ 【實(shí)現(xiàn)EnvironmentPostProcessor接口機(jī)制】
 *   本地application.properties配置文件（正常SpringBoot啟動(dòng)，通過(guò)@Configuration注解的Bean） →→適合→→ 【實(shí)現(xiàn)EnvironmentPostProcessor接口機(jī)制】和【通過(guò)@Configuration覆蓋原Bean機(jī)制】均可
 *   從Nacos等配置中心獲取得到的配置文件 →→適合→→ 【通過(guò)@Configuration覆蓋原Bean機(jī)制】
 *
 */
@Configuration
@Primary // 由于默認(rèn)RocketMQProperties作為配置類(lèi)會(huì)自動(dòng)創(chuàng)建Bean。 為避免存在兩個(gè)同類(lèi)型（RocketMQProperties）Bean，所以本類(lèi)通過(guò)注解Primary，使得只有本類(lèi)生效。相當(dāng)于替代默認(rèn)RocketMQProperties
public class GjsRocketMQProperties extends RocketMQProperties {
 
    final private String KEYNAME_PRODUCER_SECRET = "rocketmq.producer.secret-key";
    final private String KEYNAME_CONSUMER_SECRET = "rocketmq.consumer.secret-key";
 
    @Autowired
    ConfigurableApplicationContext springContext;
 
    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(GjsRocketMQProperties.class);
 
    @Override
    public void setProducer(Producer producer) {
        final String orginSecretKey = producer.getSecretKey();
        // 對(duì)密文解密并設(shè)置
        if (StringUtils.hasText(orginSecretKey) && orginSecretKey.length() >= 32) { // 如果滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求，視為密文，解密
            String padStr = SystemSecurityAlgorithm.decryptStr(orginSecretKey);
            log.debug("連接RocketMQ配置項(xiàng){}: 解密前orginSecretKey=[{}], 解密后padStr=[{}]", KEYNAME_PRODUCER_SECRET, orginSecretKey, padStr); //為避免密碼泄露，僅debug才輸出明文
            log.info("連接RocketMQ配置項(xiàng){}: 對(duì)密文orginSecretKey=[{}]已完成解密", KEYNAME_PRODUCER_SECRET, orginSecretKey);
            producer.setSecretKey(padStr);
 
            // 由于RocketMQ在構(gòu)建DefaultRocketMQListenerContainer過(guò)程中，會(huì)從Spring的Environment中獲取配置。
            // 附調(diào)用關(guān)系簡(jiǎn)要說(shuō)明如下：
            //     org.apache.rocketmq.spring.support.DefaultRocketMQListenerContainer.afterPropertiesSet()
            //       org.apache.rocketmq.spring.support.DefaultRocketMQListenerContainer.initRocketMQPushConsumer()
            //         org.apache.rocketmq.spring.support.RocketMQUtil.getRPCHookByAkSk()
            //           org.springframework.core.env.AbstractEnvironment.resolveRequiredPlaceholders()
            //             ......
            //               org.springframework.boot.context.properties.source.ConfigurationPropertySourcesPropertyResolver.findPropertyValue()
            // 因此一并修改環(huán)境中的值，使其能取得新值
            modifyEnvironmentValue(springContext.getEnvironment(), KEYNAME_PRODUCER_SECRET, padStr);
 
        } else { // 不滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求(視為明文,不解密)，保持不變
            log.warn("連接RocketMQ配置項(xiàng)rocketmq.producer.secret-key值=[{}]不滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求(視為明文,不解密)，保持不變", orginSecretKey);
        }
 
        super.setProducer(producer);
    }
 
    @Override
    public void setConsumer(PushConsumer pushConsumer) {
        final String orginSecretKey = pushConsumer.getSecretKey();
        // 對(duì)密文解密并設(shè)置
        if (StringUtils.hasText(orginSecretKey) && orginSecretKey.length() >= 32 ) { // 如果滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求，視為密文，解密
            String padStr = SystemSecurityAlgorithm.decryptStr(orginSecretKey);
            log.debug("連接RocketMQ配置項(xiàng){}: 解密前orginSecretKey=[{}], 解密后padStr=[{}]", KEYNAME_CONSUMER_SECRET, orginSecretKey, padStr); //為避免密碼泄露，僅debug才輸出明文
            log.info("連接RocketMQ配置項(xiàng){}: 對(duì)密文orginSecretKey=[{}]已完成解密", KEYNAME_CONSUMER_SECRET, orginSecretKey);
            pushConsumer.setSecretKey(padStr);
 
            // 由于RocketMQ在構(gòu)建DefaultRocketMQListenerContainer過(guò)程中，會(huì)從Spring的Environment中獲取配置。
            // 附調(diào)用關(guān)系簡(jiǎn)要說(shuō)明如下：
            //     org.apache.rocketmq.spring.support.DefaultRocketMQListenerContainer.afterPropertiesSet()
            //       org.apache.rocketmq.spring.support.DefaultRocketMQListenerContainer.initRocketMQPushConsumer()
            //         org.apache.rocketmq.spring.support.RocketMQUtil.getRPCHookByAkSk()
            //           org.springframework.core.env.AbstractEnvironment.resolveRequiredPlaceholders()
            //             ......
            //               org.springframework.boot.context.properties.source.ConfigurationPropertySourcesPropertyResolver.findPropertyValue()
            // 因此一并修改環(huán)境中的值，使其能取得新值
            modifyEnvironmentValue(springContext.getEnvironment(), KEYNAME_CONSUMER_SECRET, padStr);
 
        } else { // 不滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求(視為明文,不解密)，保持不變
            log.warn("連接RocketMQ配置項(xiàng){}的值=[{}]不滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求(視為明文,不解密)，保持不變", KEYNAME_CONSUMER_SECRET, orginSecretKey);
        }
 
        super.setConsumer(pushConsumer);
    }
 
    @Override
    public void setPullConsumer(PullConsumer pullConsumer) {
        final String orginSecretKey = pullConsumer.getSecretKey();
        // 對(duì)密文解密并設(shè)置
        if (StringUtils.hasText(orginSecretKey) && orginSecretKey.length() >= 32 ) { // 如果滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求，視為密文，解密
            String padStr = SystemSecurityAlgorithm.decryptStr(orginSecretKey);
            log.debug("連接RocketMQ配置項(xiàng){}: 解密前orginSecretKey=[{}], 解密后padStr=[{}]", KEYNAME_CONSUMER_SECRET, orginSecretKey, padStr); //為避免密碼泄露，僅debug才輸出明文
            log.info("連接RocketMQ配置項(xiàng){}: 對(duì)密文orginSecretKey=[{}]已完成解密", KEYNAME_CONSUMER_SECRET, orginSecretKey);
            pullConsumer.setSecretKey(padStr);
 
            // 由于RocketMQ在構(gòu)建DefaultRocketMQListenerContainer過(guò)程中，會(huì)從Spring的Environment中獲取配置。
            // 附調(diào)用關(guān)系簡(jiǎn)要說(shuō)明如下：
            //     org.apache.rocketmq.spring.support.DefaultRocketMQListenerContainer.afterPropertiesSet()
            //       org.apache.rocketmq.spring.support.DefaultRocketMQListenerContainer.initRocketMQPushConsumer()
            //         org.apache.rocketmq.spring.support.RocketMQUtil.getRPCHookByAkSk()
            //           org.springframework.core.env.AbstractEnvironment.resolveRequiredPlaceholders()
            //             ......
            //               org.springframework.boot.context.properties.source.ConfigurationPropertySourcesPropertyResolver.findPropertyValue()
            // 因此一并修改環(huán)境中的值，使其能取得新值
            modifyEnvironmentValue(springContext.getEnvironment(), KEYNAME_CONSUMER_SECRET, padStr);
 
        } else { // 不滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求(視為明文,不解密)，保持不變
            log.warn("連接RocketMQ配置項(xiàng){}的值=[{}]不滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求(視為明文,不解密)，保持不變", KEYNAME_CONSUMER_SECRET, orginSecretKey);
        }
 
        super.setPullConsumer(pullConsumer);
    }
 
 
    /**
     * 對(duì)Spring的Environment的配置項(xiàng)的值修改為新值
     * @param environment Spring的Environment對(duì)象
     * @param keyName 配置項(xiàng)名
     * @param newValue 新值
     */
    private void modifyEnvironmentValue(ConfigurableEnvironment environment, final String keyName, String newValue) {
        if(!environment.containsProperty(keyName)) {
            log.warn("當(dāng)前Spring的environment中不存在名為{}的配置項(xiàng)", keyName);
            return;
        }
        if(environment.getProperty(keyName, "").equals(newValue)) {
            log.debug("當(dāng)前Spring的environment中配置項(xiàng){}的值已與新值相同，無(wú)需修改", keyName);
            return;
        }
        Map<String, Object> map = new HashMap<>(); //用于存放新值
        map.put(keyName, newValue);
        // 若有map有值，則把該map作為PropertySource加入列表中，以實(shí)現(xiàn)：把environment中對(duì)應(yīng)key的value覆蓋為新值
        // 必須加到First并且不能存在兩個(gè)相同的Name的MapPropertySource，值覆蓋才能生效
        environment.getPropertySources().addFirst(new MapPropertySource("modifyEnvironmentValue-"+keyName, map));
        log.info("已對(duì)Spring的Environment的配置項(xiàng){}的值修改為新值", keyName);
    }
}

#Nacos配置中心及注冊(cè)中心的authenticate鑒權(quán)用戶(hù)名和密碼（需Nacos服務(wù)端開(kāi)啟auth鑒權(quán)）
spring.cloud.nacos.username=nacos
spring.cloud.nacos.password=760dee29f9fc82af0cc1d6074879dc39
#Nacos配置中心服務(wù)端的地址和端口(形式ip:port,ip:port,...) 。注：nacos-client1.x會(huì)按順序選其中地址進(jìn)行連接(前個(gè)連接失敗則自動(dòng)選后一個(gè))。nacos-client2.x會(huì)隨機(jī)選其中地址進(jìn)行連接(若連接失敗則自動(dòng)另選)
spring.cloud.nacos.config.server-addr=ip1:8848,ip2:8848,ip3:8848,ip4:8848
 
#Data ID的前綴（如果不設(shè)置，則默認(rèn)取 ${spring.application.name}）
#spring.cloud.nacos.config.prefix=
#默認(rèn)指定為開(kāi)發(fā)環(huán)境
#spring.profiles.active=
#Nacos命名空間，此處不設(shè)置，保持默認(rèn)
#spring.cloud.nacos.config.namespace=
#配置組（如果不設(shè)置，則默認(rèn)為DEFAULT_GROUP）
spring.cloud.nacos.config.group=G_CONFIG_GJS_SERVICE
#指定文件后綴（如果不設(shè)置，則默認(rèn)為properties）
spring.cloud.nacos.config.file-extension=properties
 
#以下為全局Data ID
spring.cloud.nacos.config.shared-configs[0].data-id=NacosRegDiscoveryInfo.properties
spring.cloud.nacos.config.shared-configs[0].group=G_CONFIG_GJS_GLOBALSHARED
spring.cloud.nacos.config.shared-configs[0].refresh=true
 
spring.cloud.nacos.config.shared-configs[1].data-id=XXXXX.properties
spring.cloud.nacos.config.shared-configs[1].group=G_CONFIG_GJS_GLOBALSHARED
spring.cloud.nacos.config.shared-configs[1].refresh=true
 
spring.cloud.nacos.config.shared-configs[2].data-id=YYYYY.properties
spring.cloud.nacos.config.shared-configs[2].group=G_CONFIG_GJS_GLOBALSHARED
spring.cloud.nacos.config.shared-configs[2].refresh=true

package 包指定忽略，請(qǐng)自定;
 
import 忽略解密計(jì)算工具類(lèi)SystemSecurityAlgorithm，請(qǐng)自定;
import org.apache.commons.logging.Log;
import org.springframework.boot.ConfigurableBootstrapContext;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.env.EnvironmentPostProcessor;
import org.springframework.boot.logging.DeferredLogFactory;
import org.springframework.core.Ordered;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MapPropertySource;
import org.springframework.util.StringUtils;
 
import java.util.HashMap;
import java.util.Map;
 
/**
 * 本類(lèi)通過(guò)實(shí)現(xiàn)EnvironmentPostProcessor接口，實(shí)現(xiàn)在Spring啟動(dòng)過(guò)程中從environment中讀取指定的key值，處理后，然后把environment中對(duì)應(yīng)key的value覆蓋為新值。
 * 通過(guò)本類(lèi)已經(jīng)實(shí)現(xiàn)對(duì)bootstrap階段的配置文件處理：
 *   因連接Nacos的password不得出現(xiàn)明文，故bootstrap配置文件中為加密密文（加密算法Java類(lèi)為：SystemSecurityAlgorithm），然后在啟動(dòng)時(shí)通過(guò)本類(lèi)解密
 * -----------------------------------------------------------
 * 注意：
 *   a) 需要在META-INF下的spring.factories文件中配置本類(lèi)后，本類(lèi)才會(huì)生效(才被Spring掃描識(shí)別到)
 *   b) 因?yàn)楸绢?lèi)是通過(guò)實(shí)現(xiàn)EnvironmentPostProcessor接口方式，所以本類(lèi)在SpringCloud啟動(dòng)過(guò)程中會(huì)被調(diào)用兩次：
 *         首先是在bootstrap配置文件加載后（SpringCloud為支持配置中心的bootstrap階段）
 *         其次是在application配置文件加載后（SpringBoot的正常啟動(dòng)時(shí)加載配置文件階段）
 * 機(jī)制適用性：
 * 除了通過(guò)實(shí)現(xiàn)EnvironmentPostProcessor接口機(jī)制，還有通過(guò)@Configuration覆蓋原Bean機(jī)制。兩種機(jī)制適用性說(shuō)明如下：
 *   bootstrap.properties配置文件（bootstrap階段，還未創(chuàng)建Bean） →→適合→→ 【實(shí)現(xiàn)EnvironmentPostProcessor接口機(jī)制】
 *   本地application.properties配置文件（正常SpringBoot啟動(dòng)，通過(guò)@Configuration注解的Bean） →→適合→→ 【實(shí)現(xiàn)EnvironmentPostProcessor接口機(jī)制】和【通過(guò)@Configuration覆蓋原Bean機(jī)制】均可
 *   從Nacos等配置中心獲取得到的配置文件 →→適合→→ 【通過(guò)@Configuration覆蓋原Bean機(jī)制】
 *
 */
public class GjsEnvironmentPostProcessor implements EnvironmentPostProcessor, Ordered {
 
    /**
     * The default order for the processor.  值越小，優(yōu)先級(jí)越高
     * 因bootstrap配置文件是通過(guò){@link org.springframework.boot.context.config.ConfigDataEnvironmentPostProcessor}完成加載處理
     * 由于本EnvironmentPostProcessor類(lèi)需等待SpringCloud對(duì)bootstrap配置文件后才能執(zhí)行，所以本EnvironmentPostProcessor類(lèi)優(yōu)先級(jí)需更低
     */
    public static final int ORDER = Ordered.HIGHEST_PRECEDENCE + 50;
 
    private final DeferredLogFactory logFactory;
 
    private final Log logger;
 
    public GjsEnvironmentPostProcessor(DeferredLogFactory logFactory,
                                       ConfigurableBootstrapContext bootstrapContext) {
        this.logFactory = logFactory;
        this.logger = logFactory.getLog(getClass());
    }
 
 
    @Override
    public int getOrder() {
        return ORDER;
    }
 
 
    /**
     * 從environment中讀取指定的key，并進(jìn)行解密，解密后的結(jié)果放入map對(duì)象中
     * @param environment 已經(jīng)有的Spring環(huán)境
     * @param keyName 指定的key名
     * @param map 若完成解密，則將解密后的結(jié)果放入map對(duì)象
     */
    private void decodePwd(ConfigurableEnvironment environment, String keyName, Map<String, Object> map ) {
        if(!environment.containsProperty(keyName)) {
            this.logger.debug("EnvironmentPostProcessor 當(dāng)前Spring的environment中不存在名為"+keyName+"的配置項(xiàng)");
            return;
        }
 
        final String origalValue = environment.getProperty(keyName);
        // 對(duì)密文解密并設(shè)置
        if (StringUtils.hasText(origalValue) && origalValue.length() >= 32) { // 如果滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求，視為密文，解密
            String padStr = SystemSecurityAlgorithm.decryptStr(origalValue);
            this.logger.debug("EnvironmentPostProcessor 配置項(xiàng)"+keyName+"原值=["+origalValue+"], 解密后值=["+padStr+"]"); //為避免在日志中密碼泄露，僅debug才輸出明文
            this.logger.info("EnvironmentPostProcessor 配置項(xiàng)"+keyName+"原值=["+origalValue+"]已完成解密");
            map.put(keyName, padStr);
        }else {
            this.logger.warn("EnvironmentPostProcessor 配置項(xiàng)"+keyName+"值=["+origalValue+"]不滿(mǎn)足密碼密文的長(zhǎng)度及大小寫(xiě)要求(視為明文,不解密)，保持不變");
        }
    }
 
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        this.logger.debug("EnvironmentPostProcessor before PropertySources size=" + environment.getPropertySources().size());
        this.logger.debug("EnvironmentPostProcessor before PropertySources : " + environment.getPropertySources());
        Map<String, Object> map = new HashMap<>(); //用于存放新值
 
        decodePwd(environment, "spring.cloud.nacos.password", map);
 
        if(!map.isEmpty()) {
            // 若有map有值，則把該map作為PropertySource加入列表中，以實(shí)現(xiàn)：把environment中對(duì)應(yīng)key的value覆蓋為新值
            // 必須加到First并且不能存在兩個(gè)相同的Name的MapPropertySource，值覆蓋才能生效
            environment.getPropertySources().addFirst(new MapPropertySource("afterDecodePassword", map));
        }
        this.logger.debug("EnvironmentPostProcessor after PropertySources size=" + environment.getPropertySources().size());
        this.logger.debug("EnvironmentPostProcessor after PropertySources : " + environment.getPropertySources());
    }
 
}