@IPU_REQ_2022@添加nacos使用示例，添加nacos配置发生变化后，定时任务让新配置在第二天0点0分1秒生效的示例。

ipu-rest-demo/pom.xml

				<type>pom</type>
				<scope>import</scope>
			</dependency>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<!-- <version>Greenwich.RELEASE</version>  -->
				<version>Hoxton.SR8</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
			<dependency>
				<groupId>com.alibaba.cloud</groupId>
				<artifactId>spring-cloud-alibaba-dependencies</artifactId>
				<version>2.2.1.RELEASE</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>
			<groupId>com.ai.ipu.server</groupId>
			<artifactId>ipu-restful</artifactId>
        </dependency>
        
    	<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
            <exclusions>
				<exclusion>
					<groupId>org.apache.logging.log4j</groupId>
					<artifactId>log4j-core</artifactId>
				</exclusion>
				<exclusion>
					<groupId>org.apache.logging.log4j</groupId>
					<artifactId>log4j-api</artifactId>
				</exclusion>
				<exclusion>
					<groupId>org.apache.logging.log4j</groupId>
					<artifactId>log4j-slf4j-impl</artifactId>
				</exclusion>
			</exclusions>
        </dependency>
    	<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-slf4j-impl</artifactId>
		</dependency>
		<!--log4j2核心包-->
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-api</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-core</artifactId>
		</dependency>        
        <!-- 使用ipu-nosql、ipu-cache 3.2-SNAPSHOT是因为配合ipu-spring-nacos自动同步配置所需 -->
		<dependency>
            <groupId>com.ai.ipu</groupId>
		</dependency>
		<dependency>
			<groupId>com.ai.ipu</groupId>
			<artifactId>ipu-spring-nacos</artifactId>
		</dependency>
		<dependency>
		    <groupId>com.google.guava</groupId>
		    <artifactId>guava</artifactId>
		</dependency>
    	<!--  -->
		<!-- nacos -->
		<dependency>
			<groupId>com.alibaba.cloud</groupId>
			<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
		</dependency>
		<dependency>
			<groupId>com.alibaba.cloud</groupId>
			<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
		</dependency>
		<!-- nacos定时任务 -->
		<dependency>  
        	<groupId>org.quartz-scheduler</groupId>  
        	<artifactId>quartz</artifactId>   
    	</dependency>  
    	<dependency>  
        	<groupId>org.quartz-scheduler</groupId>  
        	<artifactId>quartz-jobs</artifactId>  
    	</dependency>
    	<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<scope>test</scope>
		</dependency>	
		</dependency>
	</dependencies>
	<build>

ipu-rest-demo/src/main/java/com/ai/ipu/server/demo/IpuRestDemoStart.java

 * @desc 启动的时候需要指定参数--server.port=8080
 */
public class IpuRestDemoStart {
    public final static String DUBBO_CONSUMER_CONFIG = "dubbo-consumer-nacos.xml";
//    public final static String DUBBO_CONSUMER_CONFIG = "dubbo-consumer-nacos.xml";
    public final static String EXCEPTION_MESSAGES_CONFIG = "exception_messages";
    
    public static void main(String[] args) {

ipu-rest-demo/src/main/java/com/ai/ipu/server/demo/config/IpuSpringNacosConfig.java

package com.ai.ipu.server.demo.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.stereotype.Component;
import lombok.Data;
@PropertySource(value = { "classpath:ipu-spring-nacos.properties" })
@Component
@Data
public class IpuSpringNacosConfig {
//	@Value("#{'${list}'.split(',')}")
//	private List<String> ipuMiddlewareList;
	@Value("${num}")
	private long ipuMiddlewareNum;
	
	@Value("${ipu.cache.dataid}")
	private String ipuCacheDataid;
	
	@Value("${ipu.nosql.dataid}")
	private String ipuNosqlDataid;
	@Value("${ipu.database.dataid}")
	private String ipuDatabaseDataid;
	
	@Value("${ipu.dfs.dataid}")
	private String ipuDfsDataid;
	@Value("${ipu.cache.group}")
	private String ipuCacheGroup;
	
	@Value("${ipu.nosql.group}")
	private String ipuNosqlGroup;
	
	@Value("${ipu.database.group}")
	private String ipuDatabaseGroup;
	
	@Value("${ipu.dfs.group}")
	private String ipuDfsGroup;
	
	@Value("${ipu.cache.timeoutms}")
	private long ipuCacheTimeoutms;
	@Value("${ipu.nosql.timeoutms}")
	private long ipuNosqlTimeoutms;
	@Value("${ipu.database.timeoutms}")
	private long ipuDatabaseTimeoutms;
	@Value("${ipu.dfs.timeoutms}")
	private long ipuDfsTimeoutms;	
	@Bean
	public static PropertySourcesPlaceholderConfigurer propertyConfigInDev() {
		return new PropertySourcesPlaceholderConfigurer();
	}
}

ipu-rest-demo/src/main/java/com/ai/ipu/server/demo/config/NacosConfig.java

package com.ai.ipu.server.demo.config;
import java.util.Properties;
import java.util.concurrent.Executor;
import javax.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import com.ai.ipu.basic.string.StringUtil;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.PropertyKeyConst;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import lombok.extern.slf4j.Slf4j;
//springcloud也支持在程序中手工注册到配置中心，此时就可以监听到配置中心推送的配置文件。
//springcloud已经不再支持@NacosConfigListener，配置了也不生效。
@Component
@Slf4j
public class NacosConfig {
	private String service002Url;
	private String service002Param;
	
	@Bean(name="getService002Url")
	public String getService002Url() {
		return service002Url;
	}
	
	@Bean(name="getService002Param")
	public String getService002Param() {
		return service002Param;
	}
	
	
	@Value("${spring.cloud.nacos.config.server-addr}")
    private String nacosConfigServer;
	@Value("${spring.cloud.nacos.namespace}")
    private String nacosNamespace;
	
	@Value("${spring.cloud.nacos.dataid}")
    private String dataId;
	@Value("${spring.cloud.nacos.group}")
    private String group;
	@Value("${spring.cloud.nacos.timeout}")
    private long timeout;
	
	@PostConstruct
	public void initConfigServer() {
		try {
	        Properties properties = new Properties();
	        if (!StringUtil.isEmpty(nacosNamespace))
	        	properties.put(PropertyKeyConst.NAMESPACE, nacosNamespace);
	        properties.put(PropertyKeyConst.SERVER_ADDR, nacosConfigServer);
	        ConfigService configService = NacosFactory.createConfigService(properties);
	        String content = configService.getConfig(dataId, group, timeout);
	        //从配置中心获取到指定配置，需要自己解析后给service002Url、service002Param赋值
	        log.debug(content);
	        dealConfigServerConfig(content);
	        configService.addListener(dataId, group, new Listener() {
	            @Override
	            public void receiveConfigInfo(String configInfo) {
	            	//从配置中心获取到推送来的更新配置信息，需要自己解析给service002Url、service002Param赋值
	            	log.debug(configInfo);
	            	dealConfigServerConfig(configInfo);
	            }
	
	            @Override
	            public Executor getExecutor() {
	                return null;
	            }
	        });
	    } catch (NacosException e) {
	        log.error(e.getMessage());
	    }
	}
	
	private void dealConfigServerConfig(String configInfo) {
		if (StringUtil.isEmpty(configInfo))
			return;
		String[] configs = configInfo.split("\n\r|\n|\r|\r\n");
		int i=0;
		for (;i<configs.length;i++) {
			if (!StringUtil.isEmpty(configs[i]))
			{
				if (configs[i].indexOf("service002Url")>=0)
				{
					String[] urls = configs[i].split("=");
					service002Url = urls[1];
				}
				if (configs[i].indexOf("service002Param")>=0)
				{
					String[] params = configs[i].split("=");
					service002Param = params[1];
				}
			}
		}
	}
	
}

ipu-rest-demo/src/main/java/com/ai/ipu/server/demo/control/nacos/IpuSpringNacosController.java

package com.ai.ipu.server.demo.control.nacos;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.cache.CacheFactory;
import com.ai.ipu.cache.ICache;
import com.ai.ipu.cache.config.IpuCacheConfig;
import com.ai.ipu.common.xml.Dom4jHelper;
import com.ai.ipu.data.JMap;
import com.ai.ipu.data.impl.JsonMap;
import com.ai.ipu.database.dao.IpuDaoManager;
import com.ai.ipu.database.dao.impl.SqlDao;
import com.ai.ipu.database.datasource.DataSourceEntity;
import com.ai.ipu.database.uitl.MybatisUtil;
import com.ai.ipu.dfs.s3.IFs;
import com.ai.ipu.dfs.s3.IpuDfsFactory;
import com.ai.ipu.dfs.s3.conf.IpuDfsConfig;
import com.ai.ipu.dfs.s3.entity.BucketEntity;
import com.ai.ipu.dfs.s3.entity.DfsEntity;
import com.ai.ipu.nacos.config.IpuNacosConfig;
import com.ai.ipu.nacos.service.IpuNacosServiceImpl;
import com.ai.ipu.nosql.INoSql;
import com.ai.ipu.nosql.config.IpuNoSQLConfig;
import com.ai.ipu.nosql.mongodb.MongoCacheFactory;
import com.ai.ipu.server.demo.config.IpuSpringNacosConfig;
import com.ai.ipu.server.demo.listener.IpuCacheListener;
import com.github.pagehelper.util.StringUtil;
/**
 * 基于ipu-spring-nacos组件对ipu-cache/ipu-nacos/ipu-s3/ipu-database动态刷新配置范例。
 * 需要在启动程序时，通过jvm参数设置nacos配置中心ip和端口，如果不配置，缺省为127.0.0.1:8848。
 * jvm格式：-Dipu.nacos.server-addr=47.105.160.21:8810
 * @author weihf@asiainfo.com
 * @team IPU
 * @date 2021年3月16日
 */
@Controller
@RequestMapping("/nacos/")
public class IpuSpringNacosController {
	private static final ILogger LOGGER = IpuLoggerFactory.createLogger(IpuSpringNacosController.class);
	
	@Autowired
	private IpuNacosServiceImpl service;
	@Autowired
	private IpuSpringNacosConfig nacosConfig;
	@Autowired
	private IpuNacosConfig config;
	@ResponseBody
    @RequestMapping("/syncIpuConfigUsingIpuCache")
    public JMap syncIpuConfigUsingIpuCache(JMap param) throws Exception {
		JMap result = new JsonMap();
		final String CACHE_KEY = "com:ai:ipu:rest-scaffold:test";
		final String DEFAULT_CONN_NAME = "ssn";
		String connName = param.getString("connName", DEFAULT_CONN_NAME);
		ICache cache = null;
		try {
			//根据本地的ipu-cache.xml配置操作redis
			cache = CacheFactory.getCache(connName);
			cache.put(CACHE_KEY, "123");
			LOGGER.debug(CACHE_KEY + " is " + cache.get(CACHE_KEY));
			
			//由于下面要连到其他redis，因此需要将连接关闭/释放
			cache.close();
			
			//从nacos配置中心获取ipu-cache.xml的配置，并加载到ipu-cache的系统配置中
			boolean status = service.pullFromServerAndSyncIpuConfig(nacosConfig.getIpuCacheDataid(), nacosConfig.getIpuCacheGroup(), nacosConfig.getIpuCacheTimeoutms(), IpuCacheConfig.getInstance());
			if (status)
			{
				//此时虽然还是ssn，但是已经连到配置中心里的redis服务器了
				cache = CacheFactory.getCache(connName);
				LOGGER.debug(CACHE_KEY + " is " + cache.get(CACHE_KEY));
				result.put("result", "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuCacheDataid() + "成功");
			}
			else
				result.put("result", "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuCacheDataid() + "失败");
	
		} catch (Exception e)
		{
			String errorMsg = "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuCacheDataid() + "错误：" + e.toString();
			LOGGER.error(errorMsg);
			result.put("result", errorMsg);
		}finally {
			cache.close();
		}
		return result;
	}
	
	@ResponseBody
    @RequestMapping("/syncIpuConfigUsingIpuNosql")
    public JMap syncIpuConfigUsingIpuNosql(JMap param) throws Exception {
		JMap result = new JsonMap();
		final String DEFAULT_CONN_NAME = "data";
		final String DATABASE_NAME = "test";
		final String TABLE_NAME = "mycol1";
		String connName = param.getString("connName", DEFAULT_CONN_NAME);
		INoSql noSql = null;
		try {
			//根据本地的ipu-nosql.xml配置操作mongodb
			noSql = MongoCacheFactory.getMongoDao(connName, DATABASE_NAME, TABLE_NAME);
			noSql.executeInsert(
					"insert into mycol1 (name, nickName, remarks, age) values ('test','this is a test','1',20)");
			System.out.println("mongodb result: "
					+ noSql.executeSelect("select * from mycol1 where name <> 'mike' order by age asc"));
			
			noSql.commitTransaction();
			
			//从nacos配置中心获取ipu-nosql.xml的配置，并加载到ipu-nosql的系统配置中
			boolean status = service.pullFromServerAndSyncIpuConfig(nacosConfig.getIpuNosqlDataid(), nacosConfig.getIpuNosqlGroup(), nacosConfig.getIpuNosqlTimeoutms(), IpuNoSQLConfig.getInstance());
			if (status)
			{
				//此时虽然还是data，但是已经连到配置中心里的mongodb服务器了
				noSql = MongoCacheFactory.getMongoDao(connName, DATABASE_NAME, TABLE_NAME);
				//ipu-nosql支持3种mongodb操作：mongodb原生操作、标准sql操作、表对象操作
				//上面示例是标准sql操作，下面是表对象操作示例
				//表对象操作的条件目前仅支持等于。
				Map<String, Object> insertData = new HashMap<String, Object>();
				insertData.put("name", "test");
				insertData.put("nickName", "test");
				insertData.put("remarks", "2");
				insertData.put("age", 18);
				noSql.insert(insertData);
				noSql.commitTransaction();
				
				//查询刚插入的数据
				Map<String, Object> selectParam = new HashMap<String, Object>();
				selectParam.put("name", "test");
				
				LOGGER.debug("result is: " + noSql.selectByCond(selectParam));
				result.put("result", "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuNosqlDataid() + "成功");
			}
			else
				result.put("result", "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuNosqlDataid() + "失败");
	
		} catch (Exception e)
		{
			if (noSql != null)
				noSql.abortTransaction();
			String errorMsg = "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuNosqlDataid() + "错误：" + e.toString();
			LOGGER.error(errorMsg);
			result.put("result", errorMsg);
		}finally {
			
		}
		return result;
	}
	
	@ResponseBody
    @RequestMapping("/syncIpuConfigUsingIpuS3")
    public JMap syncIpuConfigUsingIpuS3(JMap param) throws Exception {
		JMap result = new JsonMap();
		final String DFS_NAME = "default";
		final String DEFAULT_BUCKET_NAME = "test";
		String bucketName = param.getString("bucketName", DEFAULT_BUCKET_NAME);
		
		DfsEntity dfsEntity;
		IFs client;
		try {
			//根据本地的ipu-nosql.xml配置操作mongodb
			dfsEntity = IpuDfsFactory.getDfsEntity(DFS_NAME);
			BucketEntity bucket = new BucketEntity();
			bucket.setDfsName(dfsEntity.getDfsName());
			bucket.setBucketName(bucketName);
			bucket.setRegionName(dfsEntity.getRegionName());
			client = IpuDfsFactory.getFsClient(dfsEntity.getDfsName());
			
			//创建目录，用户需要在minio里有创建目录的权限
			client.createBucket(bucket);
			
			bucket = new BucketEntity();
			bucket.setDfsName(dfsEntity.getDfsName());
			bucket.setRegionName(dfsEntity.getRegionName());
			LOGGER.debug("bucket list: "
					+ client.getAllBuckets(bucket));
					
			//从nacos配置中心获取ipu-s3.xml的配置，并加载到ipu-s3的系统配置中
			boolean status = service.pullFromServerAndSyncIpuConfig(nacosConfig.getIpuDfsDataid(), nacosConfig.getIpuDatabaseGroup(), nacosConfig.getIpuDfsTimeoutms(), IpuDfsConfig.getInstance());
			if (status)
			{
				//注意，由于系统配置发生了变化，虽然下面的代码和上面一致，但是实际内容不同。
				//请不要注释下面的代码，并直接使用上面已经定义好的对象！
				dfsEntity = IpuDfsFactory.getDfsEntity(DFS_NAME);
				
				client = IpuDfsFactory.getFsClient(dfsEntity.getDfsName());
				
				bucket = new BucketEntity();
				bucket.setDfsName(dfsEntity.getDfsName());
				bucket.setRegionName(dfsEntity.getRegionName());
				LOGGER.debug("bucket list: "
						+ client.getAllBuckets(bucket));
				
				bucket = new BucketEntity();
				bucket.setDfsName(dfsEntity.getDfsName());
				bucket.setBucketName(bucketName);
				bucket.setRegionName(dfsEntity.getRegionName());
				
				//创建目录，用户需要在minio里有创建目录的权限
				client.createBucket(bucket);
				
				bucket = new BucketEntity();
				bucket.setDfsName(dfsEntity.getDfsName());
				bucket.setRegionName(dfsEntity.getRegionName());
				LOGGER.debug("bucket list: "
						+ client.getAllBuckets(bucket));
				
				result.put("result", "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuDfsDataid() + "成功");
			}
			else
				result.put("result", "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuDfsDataid() + "失败");
	
		} catch (Exception e)
		{
			String errorMsg = "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuDfsDataid() + "错误：" + e.toString();
			LOGGER.error(errorMsg);
			result.put("result", errorMsg);
		}finally {
			
		}
		return result;
	}
	
	@ResponseBody
    @RequestMapping("/syncIpuConfigUsingIpuDatabase")
    public JMap syncIpuConfigUsingIpuDatabase(JMap param) throws Exception {
		JMap result = new JsonMap();
		final String CONN_NAME = "test";
		final String DEFAULT_TABLE_NAME = "ipu_db_demo";
		
		String tableName = param.getString("tableName", DEFAULT_TABLE_NAME);
		
		try {
			SqlDao dao = IpuDaoManager.takeDao(SqlDao.class, CONN_NAME);
			String sql = "select * from " + tableName;
			List<Map<String, Object>> dbResult = dao.executeSelect(sql);
			LOGGER.debug("查询结果：" + dbResult);
					
			//从nacos配置中心获取ipu-database.xml的配置
			String ipuDatabaseXml = service.pullFromServer(nacosConfig.getIpuDatabaseDataid(), nacosConfig.getIpuDatabaseGroup(), nacosConfig.getIpuDatabaseTimeoutms());
			//加载到ipu-database的系统配置中
			if (!StringUtil.isEmpty(ipuDatabaseXml))
			{
				Map map = ipuDatabaseXmlToMap(ipuDatabaseXml, "utf-8");	
				LOGGER.debug("map:" + map);
				Iterator it = map.entrySet().iterator();
				while (it.hasNext()) {
					Entry entry = (Entry) it.next();
					Map<String, Object> attrs = (Map<String, Object>) entry.getValue();
					Map<String, String> properties = (Map<String, String>) attrs.get("property");
					DataSourceEntity dataSource = new DataSourceEntity();
					dataSource.setName((String) entry.getKey());
					dataSource.setUrl(properties.get("jdbcUrl"));
					dataSource.setUsername(properties.get("username"));
					dataSource.setPassword(properties.get("password"));
					MybatisUtil.registerDataSource(dataSource.getName(), dataSource);
				}
				//手工增加版本，需要修改ipu-database代码，才能实现自动为connName加版本，此时这里只需要输入test即可。
				dao = IpuDaoManager.takeDao(SqlDao.class, CONN_NAME + "1.0");
				sql = "select * from " + tableName;
				dbResult = dao.executeSelect(sql);
				LOGGER.debug("查询结果：" + dbResult);	
				
				result.put("result", "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuDatabaseDataid() + "成功");
			}
			else
				result.put("result", "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuDatabaseDataid() + "失败");
	
		} catch (Exception e)
		{
			String errorMsg = "从nacos server:" + config.getConfigServerAddr() + "同步" + nacosConfig.getIpuDatabaseDataid() + "错误：" + e.toString();
			LOGGER.error(errorMsg);
			result.put("result", errorMsg);
		}finally {
			
		}
		return result;
	}
	
    /**
     * @description 将ipu-database的xml字符串转换成map
     * @param xml
     * @return Map
     * @throws Exception 
     */
    private Map ipuDatabaseXmlToMap(String xml, String charsetName) throws Exception {
        Dom4jHelper dh = new Dom4jHelper(xml, charsetName);
        Map<String, ?> originData = dh.getAll();
        List<Map<String, Object>> configs = (List<Map<String, Object>>) originData.get("environments");
        Map dbsMap = new HashMap<String, Object>();
        Map<String, Object> dbMap;
        Map<String, String> configAttr;
        /*循环缓存实例*/
        for (Map<String, Object> config : configs) {
            dbMap = new HashMap<String, Object>();
            configAttr = new HashMap<String, String>();
            
            Map<String, String> dbAttrMap = (Map<String, String>) config.get("environment" + Dom4jHelper.SUFFIX_ATTR);
            String datdbaseName = dbAttrMap.get("id");
            List<Map<String, Object>> dbList = (List<Map<String, Object>>)config.get("environment");
            String type = "";
            String driver = "";
            for(Map<String, Object> map : dbList){
            	if(map.get("transactionManager_attr")!=null){
                    /*解析缓存实例的服务列表*/
                    Map<String, Object> serverMap = (Map<String, Object>)map.get("transactionManager_attr");
                    type = (String)serverMap.get("type");
                }
            	if(map.get("dataSource_attr")!=null){
                    /*解析缓存实例的服务列表*/
                    Map<String, Object> serverMap = (Map<String, Object>)map.get("dataSource_attr");
                    driver = (String)serverMap.get("type");
                }
            	if(map.get("dataSource")!=null){
                    /*解析缓存实例的服务列表*/
            		List<Map<String, Object>> serverList = (List<Map<String, Object>>)map.get("dataSource");
//                    List<Map<String, Object>> serverList = (List<Map<String, Object>>)serverMap.get("property_attr");
                    for(Map<String, Object> configValue : serverList){
                    	Map<String, Object> configMap = (Map<String, Object>)configValue.get("property_attr");
                    	configAttr.put((String)configMap.get("name"), (String)configMap.get("value"));
                    }
                                        
                }
                
            }            
            dbMap.put("databaseName", datdbaseName+"1.0");
            dbMap.put("type", type);
            dbMap.put("property", configAttr);
            dbMap.put("dataSource_driver", driver);
            dbsMap.put(datdbaseName+"1.0", dbMap);
        }
        return dbsMap;
    }
    
	@ResponseBody
    @RequestMapping("/scheduleIpuConfigUsingIpuCache")
    public JMap scheduleIpuConfigUsingIpuCache(JMap param) throws Exception {
		JMap result = new JsonMap();	
		try {		
			//监听配置中心里ipu-cache.xml的配置
			service.addListener(nacosConfig.getIpuCacheDataid(), nacosConfig.getIpuCacheGroup(), new IpuCacheListener());
			result.put("result", "监听配置中心:" + config.getConfigServerAddr() + "的配置" + nacosConfig.getIpuCacheDataid() + "成功");		
		} catch (Exception e)
		{
			String errorMsg = "监听配置中心:" + config.getConfigServerAddr() + "i的配置" + nacosConfig.getIpuCacheDataid() + "错误：" + e.toString();
			LOGGER.error(errorMsg);
			result.put("result", errorMsg);
		}
		return result;
	}
}

ipu-rest-demo/src/main/java/com/ai/ipu/server/demo/listener/IpuCacheListener.java

package com.ai.ipu.server.demo.listener;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.common.date.TimeUtil;
import com.ai.ipu.restful.spring.SpringBeanUtil;
import com.ai.ipu.server.demo.config.IpuSpringNacosConfig;
import com.ai.ipu.server.demo.schedule.ScheduledTask;
import com.alibaba.nacos.api.config.listener.AbstractListener;
public class IpuCacheListener extends AbstractListener {
	private static final ILogger log = IpuLoggerFactory.createLogger(IpuCacheListener.class);
	
	@Override
	public void receiveConfigInfo(String configInfo) {
		
		try {
			log.debug(">>>>>>>>>>>>>>>>>>>new config from nacos:" + configInfo);
			IpuSpringNacosConfig config = SpringBeanUtil.getBean(IpuSpringNacosConfig.class);
			ScheduledTask scheduledTask = SpringBeanUtil.getBean(ScheduledTask.class);
			//新配置第二天0点0分1秒生效
			StringBuffer cron = new StringBuffer();
			cron.append("1").append(" 0").append(" 0 ");
			String day = TimeUtil.getSysDate(1, "dd");
			String month = TimeUtil.getSysDate(1, "MM");
			cron.append(day.startsWith("0")?day.substring(1):day).append(" ");
			cron.append(month.startsWith("0")?month.substring(1):month).append(" ");
			cron.append("? ");
			cron.append(TimeUtil.getSysDate(1, "yyyy"));
//			scheduledTask.addCronJob("0 07 15 6 5 ? 2022", config.getIpuCacheDataid(), configInfo);
			log.debug("cron:" + cron.toString());
			scheduledTask.addCronJob(cron.toString(), config.getIpuCacheDataid(), configInfo);
		} catch (Exception e) {
			log.error("receiveConfigInfo error:", e);
		}
	}
}

ipu-rest-demo/src/main/java/com/ai/ipu/server/demo/schedule/ScheduleIpuCacheJob.java

package com.ai.ipu.server.demo.schedule;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.util.Map;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.restful.spring.SpringBeanUtil;
import com.ai.ipu.server.demo.config.IpuSpringNacosConfig;
import com.ai.ipu.server.demo.util.XmlUtil;
public class ScheduleIpuCacheJob implements Job {
	private static final ILogger logger = IpuLoggerFactory.createLogger(ScheduleIpuCacheJob.class);
	public void execute(JobExecutionContext context) throws JobExecutionException {
		try {
			Map xml = context.getMergedJobDataMap();
			new Thread(new Runnable() {
				@Override
				public void run() {
					try {
						IpuSpringNacosConfig config = SpringBeanUtil.getBean(IpuSpringNacosConfig.class);
						Map map = XmlUtil.ipuCacheXmlToMap((String) xml.get(config.getIpuCacheDataid()), "utf-8");
						logger.debug("map:" + map);
						logger.debug("为ipu-cache添加配置成功");
					} catch (Exception e) {
						failed(e);
					}
				}
			}).start();
		} catch (Exception e) {
			logger.error("为ipu-cache添加配置异常:" + e.toString(), e);
		}
	}
	private void failed(Exception e) {
		logger.error("error " + e.toString(), e);
	}
}

ipu-rest-demo/src/main/java/com/ai/ipu/server/demo/schedule/ScheduledTask.java

package com.ai.ipu.server.demo.schedule;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.quartz.CronScheduleBuilder;  
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;  
import org.quartz.Scheduler;
import org.quartz.SchedulerException;  
import org.quartz.Trigger;  
import org.quartz.TriggerBuilder;  
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
@Component
public class ScheduledTask{  
	private static final ILogger logger = IpuLoggerFactory.createLogger(ScheduledTask.class);
	private Map<String, Scheduler> task = new ConcurrentHashMap<String, Scheduler>();
	
	@Autowired
	SchedulerFactoryBean schedulerFactoryBean;
	
	private void clearCronJob(Scheduler sched) throws SchedulerException {
		sched.shutdown();
		sched.clear();
	}
	public void addCronJob(String cron, String dataId,String xml) 
    {	  
        Scheduler sched;
		try {
			if (task.containsKey(dataId))
			{
				sched = task.get(dataId);
				clearCronJob(sched);
			}
			else
			{	
				synchronized (this) { 
					if (task.containsKey(dataId))
					{
						sched = task.get(dataId);
						clearCronJob(sched);
					}
					else
					{
						sched = schedulerFactoryBean.getScheduler();
						task.put(dataId, sched);
					}
				}
			}
			// Define job  
			JobDataMap newJobDataMap = new JobDataMap();
			newJobDataMap.put(dataId, xml);
	        JobDetail job = JobBuilder.newJob(ScheduleIpuCacheJob.class)  
	                .withIdentity("update ipu-cache configaration", "group1")
	                .setJobData(newJobDataMap)
	                .build();  
	  
	        // Define trigger strategy  
	        Trigger trigger = TriggerBuilder.newTrigger()  
	                .withIdentity("trigger1", "group1")  
	                .withSchedule(CronScheduleBuilder.cronSchedule(cron))  
	                .build();  
	        sched.scheduleJob(job, trigger); 
	        
	        sched.start();
		} catch (SchedulerException e) {
			logger.error(e.toString(), e);
		}          
    }
}  

ipu-rest-demo/src/main/resources/dev/application.properties

#spring-data-es配置
spring.elasticsearch.rest.uris=http://47.105.160.21:10020
nacos.config.server-addr=47.105.160.21:8849