@IPU_FIXBUG_2021@master分支只保留springboot1.X实例

ipu-rest-demo/pom.xml

@@ -4,7 +4,7 @@
	<parent>
		<groupId>com.ai.ipu.server</groupId>
		<artifactId>ipu-server-parent</artifactId>
		<version>3.3-SNAPSHOT</version>
		<version>3.2-SNAPSHOT</version>
	</parent>
	<artifactId>ipu-rest-demo</artifactId>
@@ -35,8 +35,8 @@
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<ipu>3.2-SNAPSHOT</ipu>
		<!-- ipu-dependencies3.3-SNAPSHOT起，不再支持springboot1.x，升级为springboot2.1.3-RELEASE -->
		<ipu-rest>3.3-SNAPSHOT</ipu-rest>
		<org.springframework.boot>2.3.1.RELEASE</org.springframework.boot>
		<ipu-rest>3.2-SNAPSHOT</ipu-rest>
		<org.springframework.boot>1.5.9.RELEASE</org.springframework.boot>
		<!-- 执行完build镜像后，是否自动push到仓库，如果是，必须配置docker-registry-server -->
		<spring-boot-docker-push>false</spring-boot-docker-push>
        <!-- 拉取镜像的策略，可选的值：ALWAYS, NEVER, IF_NOT_PRESENT -->
@@ -54,7 +54,6 @@
		<msgframe>1.9.2</msgframe>
		<jms>1.1</jms>
		<google.plugin>19.0</google.plugin>
	</properties>
	<dependencyManagement>
@@ -73,33 +72,11 @@
				<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>
	<dependencies>
		<!-- dubbo相关依赖 -->
		<dependency>
			<groupId>com.ai.ipu.test</groupId>
			<artifactId>ipu-dubbo-api</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
		<!-- msgframe相关依赖 -->
		<dependency>
			<groupId>com.ai.aif.msgframe</groupId>
@@ -118,7 +95,6 @@
        <dependency>
			<groupId>com.ai.ipu.server</groupId>
			<artifactId>ipu-restful</artifactId>
			<version>3.3-SNAPSHOT</version>
        </dependency>
        
        <!-- 使用ipu-nosql、ipu-cache 3.2-SNAPSHOT是因为配合ipu-spring-nacos自动同步配置所需 -->
@@ -130,34 +106,18 @@
		    <groupId>com.ai.ipu</groupId>
		    <artifactId>ipu-s3</artifactId>
		</dependency>
		<dependency>
			<groupId>com.ai.ipu</groupId>
			<artifactId>ipu-spring-nacos</artifactId>
		</dependency>
		<dependency>
		    <groupId>com.google.guava</groupId>
		    <artifactId>guava</artifactId>
		    <version>${google.plugin}</version>
		</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>	
	</dependencies>
	<build>

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

@@ -1,63 +0,0 @@
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

@@ -1,106 +0,0 @@
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/config/RestConsumerConfiguration.java

@@ -1,17 +0,0 @@
package com.ai.ipu.server.demo.config;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class RestConsumerConfiguration {
	@LoadBalanced
    @Bean
    public RestTemplate ipuRestTemplate() {
        return new RestTemplate();
    }
}

ipu-rest-demo/src/main/java/com/ai/ipu/server/demo/control/dubbo/DubboConsumerController.java

@@ -1,86 +0,0 @@
package com.ai.ipu.server.demo.control.dubbo;
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.basic.reflect.ReflectUtil;
import com.ai.ipu.basic.util.IpuUtility;
import com.ai.ipu.restful.spring.SpringManager;
import com.ai.ipu.test.springboot.service.IBizService;
import com.ai.ipu.test.springboot.service.IpuService;
import com.ailk.common.data.IData;
import com.alibaba.dubbo.config.annotation.Reference;
/**
 * @author huangbo@asiainfo.com
 * @team IPU
 * @date 2018年10月24日上午00:13:37
 * @desc Dubbo客户端的使用范例
 */
@Controller
@RequestMapping("/dubbo")
public class DubboConsumerController {
	private static final transient ILogger logger = IpuLoggerFactory.createLogger(DubboConsumerController.class);
	
	@Reference
	IBizService bizService;
	
	@Reference
    IpuService ipuService;
    
	@ResponseBody
    @RequestMapping("/index")
    public String index(String data) {
//		IpuService ipuService = (IpuService)SpringManager.takeSpringContext().getBean("ipuService"); // 获取远程服务代理
        logger.info("I am ConsumerController" + System.getProperty("user.home"));
        if(data==null||"".equals(data)){
            data="你啥都没有输入！";
        }
        logger.info("你输入的是"+data);
        ipuService.genaratePlumelog(data);
        logger.info("调用dubbo结束...........");
        return data;
    }
    /**
     * @author huangbo@asiainfo.com
     * @title: callBizService
     * @desc: Dubbo客户端调用服务范例
     */
    @ResponseBody
    @RequestMapping("/biz")
    public IData callBizService(IData params) {
//        IBizService bizService = (IBizService)SpringManager.takeSpringContext().getBean("bizService"); // 获取远程服务代理
    	IData result = bizService.queryUserInfo(params); // 执行远程方法
        result.put("rest_result", "测试biz类型服务调用");
        return result;
    }
    
    /**
     * @author huangbo@asiainfo.com
     * @title: callCommonService
     * @desc: Dubbo客户端调用通用服务范例
     */
    @ResponseBody
    @RequestMapping("/common")
    public IData callCommonService(IData params) {
//    	IBizService bizService = (IBizService)SpringManager.takeSpringContext().getBean("bizService"); // 获取远程服务代理
//        String serviceName = params.getString("service_name");
        String methodName = params.getString("method_name");
//        Object service = SpringManager.takeSpringContext().getBean(serviceName);
        IData result = null;
        try {
            result =(IData) ReflectUtil.invokeMethod(bizService, methodName, new Object[]{params}, new Class<?>[]{IData.class});
            result.put("rest_result", "测试common类型服务调用");
        }catch (Exception e) {
            // TODO Auto-generated catch block
            IpuUtility.error( methodName + "方法调用异常:" + e.toString());
        }
        return result;
    }
}

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

@@ -1,363 +0,0 @@
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;
	
	@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:" + IpuNacosConfig.getNacosServerAddr() + "同步" + nacosConfig.getIpuCacheDataid() + "成功");
			}
			else
				result.put("result", "从nacos server:" + IpuNacosConfig.getNacosServerAddr() + "同步" + nacosConfig.getIpuCacheDataid() + "失败");
	
		} catch (Exception e)
		{
			String errorMsg = "从nacos server:" + IpuNacosConfig.getNacosServerAddr() + "同步" + 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:" + IpuNacosConfig.getNacosServerAddr() + "同步" + nacosConfig.getIpuNosqlDataid() + "成功");
			}
			else
				result.put("result", "从nacos server:" + IpuNacosConfig.getNacosServerAddr() + "同步" + nacosConfig.getIpuNosqlDataid() + "失败");
	
		} catch (Exception e)
		{
			if (noSql != null)
				noSql.abortTransaction();
			String errorMsg = "从nacos server:" + IpuNacosConfig.getNacosServerAddr() + "同步" + 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:" + IpuNacosConfig.getNacosServerAddr() + "同步" + nacosConfig.getIpuDfsDataid() + "成功");
			}
			else
				result.put("result", "从nacos server:" + IpuNacosConfig.getNacosServerAddr() + "同步" + nacosConfig.getIpuDfsDataid() + "失败");
	
		} catch (Exception e)
		{
			String errorMsg = "从nacos server:" + IpuNacosConfig.getNacosServerAddr() + "同步" + 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:" + IpuNacosConfig.getNacosServerAddr() + "同步" + nacosConfig.getIpuDatabaseDataid() + "成功");
			}
			else
				result.put("result", "从nacos server:" + IpuNacosConfig.getNacosServerAddr() + "同步" + nacosConfig.getIpuDatabaseDataid() + "失败");
	
		} catch (Exception e)
		{
			String errorMsg = "从nacos server:" + IpuNacosConfig.getNacosServerAddr() + "同步" + 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", "监听配置中心:" + IpuNacosConfig.getNacosServerAddr() + "ipu-cache.xml的配置" + nacosConfig.getIpuCacheDataid() + "成功");		
		} catch (Exception e)
		{
			String errorMsg = "监听配置中心:" + IpuNacosConfig.getNacosServerAddr() + "ipu-cache.xml的配置" + nacosConfig.getIpuCacheDataid() + "错误：" + e.toString();
			LOGGER.error(errorMsg);
			result.put("result", errorMsg);
		}
		return result;
	}
}

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

@@ -1,53 +0,0 @@
package com.ai.ipu.server.demo.control.nacos;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import com.ai.ipu.server.demo.config.NacosConfig;
import com.alibaba.nacos.api.exception.NacosException;
import com.google.common.collect.Maps;
@RestController
@RefreshScope
@RequestMapping("/nacos/discovery/restConsumer")
public class SpringCloudConsumerController {
	private static final Logger logger = LoggerFactory.getLogger(SpringCloudConsumerController.class);
    @Autowired
    private RestTemplate restTemplate;
    
    @Value("${spring.application.name}")
    private String appName;
    
    @Autowired
	NacosConfig config;
    
	@ResponseBody
    @GetMapping(value = "/service002")
    public String service002() throws NacosException {
		
		try {
			/*用于ipu-spring-plumlog
			Map<String, Object> variables = Maps.newHashMap();
			variables.put("message", appName);*/
			return restTemplate.getForObject("http://ipu-nacos-cloud-provider" + config.getService002Url() + "?message=" + appName , String.class);
		} catch (Exception e) {
			logger.error(e.getMessage());
		}
		
        return null;
    }
}

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

@@ -1,40 +0,0 @@
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 05 16 12 9 ? 2021", config.getIpuCacheDataid(), configInfo);
			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

@@ -1,44 +0,0 @@
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

@@ -1,77 +0,0 @@
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

@@ -9,11 +9,11 @@ spring.mvc.static-path-pattern=/**
spring.resources.static-locations=classpath:/${web.root}
#1.x默认/
#server.context-path=/ipu
server.context-path=/ipu
#默认/。注册DispatcherServlet对应path，亦可通过dispatcherRegistration方法配置
#server.servlet-path=/
#2.x
server.servlet.context-path=/ipu
#server.servlet.context-path=/ipu
#使用maven中的变量替换
logging.file=target/logs/${project.artifactId}.log
spring.application.name=${project.artifactId}
@@ -49,20 +49,6 @@ management.security.enabled=false
#spring.devtools.restart.additional-paths=src/main/java
#spring.devtools.restart.exclude=WEB-INF/**
#使用zookeeper当注册中心
spring.main.allow-bean-definition-overriding=true
#dubbo.application.name=dubbo_consumer
#dubbo.protocol.name=dubbo
dubbo.protocol.port=-1
dubbo.consumer.check=false
dubbo.registry.check=false
#dubbo.registry.address=zookeeper://47.105.160.21:2108
#dubbo.registry.client=curator
#使用nacos当注册中心
dubbo.application.name=dubbo_consumer
dubbo.registry.address=nacos://47.105.160.21:8849
dubbo.protocol.name=dubbo
#spring-data-es配置
spring.elasticsearch.rest.uris=http://47.105.160.21:10020

ipu-rest-demo/src/main/resources/dev/dubbo-consumer-simple.xml

@@ -1,22 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://code.alibabatech.com/schema/dubbo 
	http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
	<!-- 全局配置 start=========================== -->
	<dubbo:application name="ipu-rest-demo" />
	<!-- 关闭重试，延长超时 -->
	<dubbo:consumer retries="0" timeout="2000"/>	<!-- client="netty4" -->
	<!-- 换成实际地址可以解决无法注册的异常 -->
	<dubbo:registry address="127.0.0.1:20880" />
	<!-- 全局配置 end=========================== -->
	<!-- 服务注册配置 start=========================== -->
	<dubbo:reference id="bizService"
		interface="com.ai.ipu.test.springboot.service.IBizService" />
		<dubbo:reference id="ipuService"
		interface="com.ai.ipu.test.springboot.service.IpuService" />
	<!-- 服务注册配置 end =========================== -->
</beans>