模拟实现配置中心配置发生变化时秒级推送至客户端代码思路

 

 

import com.alibaba.fastjson.JSON;
import com.xuebusi.spring.study.http.BasicHttpUtil;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 模拟实现配置中心配置发生变化时秒级推送至客户端
 * 操作步骤:
 * 1.请求http://host:port/conf/add?key=&value=接口添加数据
 * 2.请求http://host:port/conf/get?key=接口查看数据
 * 3.请求http://host:port/conf/update?key=&value=接口修改数据
 * 4.观察控制台日志会看到配置变化的通知
 * <p>
 * 原理:
 * 1.项目启动时，模拟一个客户端循环调用(超时重试) /conf/monitor 接口请求数据，配置中心接受到请求之后创建DeferredResult对象，
 * 以客户端ID为key，以DeferredResult对象为value放入 deferredResultMap;
 * 2.当客户端调用修改接口时，就将修改后的数据放入 changedDataMap(这里为了测试方便仅用一个map存);
 * 3.通过另一个线程定时(间隔1s)查看 changedDataMap 中变化的数据(如果数据存在数据库A表，则每隔1s去扫一下A表);
 * 4.如果数据有变化就遍历deferredResultMap通过 deferredResult.setResult() 通知给所有的客户端，通知完的客户端以及数据要移除;
 *
 * @author syj
 */
@RestController
@RequestMapping
public class ConfController implements InitializingBean {

    private static final int TIME_OUT = 30;

    private static ExecutorService executorService = Executors.newCachedThreadPool();

    private static Map<String, ConfData> changedDataMap = new ConcurrentHashMap<>();

    private static Map<String, List<ConfDataLog>> logDataMap = new ConcurrentHashMap<>();

    private Map<String, DeferredResult> deferredResultMap = new ConcurrentHashMap();

    // 模拟数据库存储配置
    public static Map<String, ConfData> confDataMap = new ConcurrentHashMap<>();

    /**
     * 获取最新配置
     * 使用 DeferredResult 返回异步结果
     *
     * @param clientId
     * @return
     */
    @GetMapping("/conf/monitor")
    public DeferredResult<String> monitor(String clientId) {
        DeferredResult<String> result = new DeferredResult<>(TIME_OUT * 1000L, "超时啦");
        deferredResultMap.put(clientId, result);
        return result;
    }

    /**
     * 查询所有配置
     *
     * @return
     */
    @GetMapping("/conf/list")
    public Result<Map<String, ConfData>> list() {
        return new Result<>(confDataMap);
    }

    /**
     * 查询配置
     *
     * @param key
     * @return
     */
    @GetMapping("/conf/get")
    public Result<ConfData> get(String key) {
        if (!confDataMap.containsKey(key)) {
            return new Result<>(Result.FAIL_CODE, "key不存在");
        } else {
            return new Result<>(confDataMap.get(key));
        }
    }

    /**
     * 修改配置
     *
     * @param key
     * @param value
     * @return
     */
    @GetMapping("/conf/update")
    public Result<String> update(String key, String value) {
        if (!confDataMap.containsKey(key)) {
            return new Result<>(Result.FAIL_CODE, "key不存在");
        } else {
            ConfData confData = confDataMap.get(key);
            if (!confData.getValue().equals(value)) {
                confData.setValue(value);
                confDataMap.put(key, confData);
                writeLog(key, value, 2);
                // 同时放到 changedDataMap 中一份最新数据
                changedDataMap.put(key, confData);
            }
            return Result.SUCCESS;
        }
    }

    /**
     * 新增配置
     *
     * @param key
     * @param value
     * @return
     */
    @GetMapping("/conf/add")
    public Result<String> add(String key, String value) {
        if (confDataMap.containsKey(key)) {
            return new Result<>(Result.FAIL_CODE, "key已经存在了");
        }
        confDataMap.put(key, new ConfData(value));
        writeLog(key, value, 1);
        changedDataMap.put(key, new ConfData(value));
        return Result.SUCCESS;
    }

    /**
     * 移除配置
     *
     * @param key
     * @return
     */
    @GetMapping("/conf/delete")
    public Result<String> delete(String key) {
        if (!confDataMap.containsKey(key)) {
            return new Result<>(Result.FAIL_CODE, "key不存在");
        }
        update(key, "");
        return Result.SUCCESS;
    }

    /**
     * 查询所有配置修改日志
     *
     * @return
     */
    @GetMapping("/conf/log")
    public Result<Collection<List<ConfDataLog>>> history() {
        return new Result<>(logDataMap.values());
    }

    /**
     * 查询指定配置修改日志
     *
     * @param key
     * @return
     */
    @GetMapping("/conf/log/{key}")
    public Result<List<ConfDataLog>> logByKey(@PathVariable("key") String key) {
        if (logDataMap.containsKey(key)) {
            return new Result<>(logDataMap.get(key));
        } else {
            return new Result<>(null);
        }
    }

    @Override
    public void afterPropertiesSet() throws Exception {

        // 模拟客户端 http请求最新配置
        executorService.execute(() -> {
            String clientId = UUID.randomUUID().toString().replace("-", "");
            while (true) {
                String url = "http://localhost:8888/conf/monitor?clientId=" + clientId;
                String result = BasicHttpUtil.get(url, TIME_OUT + 30);
                System.out.println(Thread.currentThread().getName() + "----http调用结果:" + result);
            }
        });

        // 配置中心启动线程监控配置变化
        executorService.execute(() -> {
            while (true) {
                Collection<ConfData> values = changedDataMap.values();
                if (values != null && values.size() > 0) {
                    for (String key : changedDataMap.keySet()) {
                        for (String clientId : deferredResultMap.keySet()) {
                            DeferredResult deferredResult = deferredResultMap.get(clientId);
                            String msg = "通知客户端" + clientId + "配置" + key + "发生变化:" + JSON.toJSONString(changedDataMap.get(key));
                            deferredResult.setResult(msg);
                            // 移除已经通知过的客户端
                            deferredResultMap.remove(clientId);
                        }
                        // 移除已经通知过的数据
                        changedDataMap.remove(key);
                    }
                }
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * 记录修改日志
     *
     * @param key
     * @param value
     * @param optType 操作类型 1添加 2修改
     */
    private void writeLog(String key, String value, int optType) {
        if (logDataMap.containsKey(key)) {
            logDataMap.get(key).add(new ConfDataLog(key, value, optType, new Date()));
        } else {
            List<ConfDataLog> list = new ArrayList<>();
            list.add(new ConfDataLog(key, value, optType, new Date()));
            logDataMap.put(key, list);
        }
    }

    /**
     * 返回结果
     *
     * @param <T>
     */
    public static class Result<T> {

        public static int SUCCESS_CODE = 200;
        public static int FAIL_CODE = 500;
        public static final Result<String> SUCCESS = new Result<>(SUCCESS_CODE, "操作成功");
        public static final Result<String> FAIL = new Result<>(FAIL_CODE, "操作失败");

        private int code;
        private String msg;
        private T data;

        public Result(T data) {
            this.code = SUCCESS_CODE;
            this.msg = "操作成功";
            this.data = data;
        }

        public Result(int code, String msg) {
            this.code = code;
            this.msg = msg;
        }

        public Result(int code, String msg, T data) {
            this.code = code;
            this.msg = msg;
            this.data = data;
        }

        public int getCode() {
            return code;
        }

        public void setCode(int code) {
            this.code = code;
        }

        public String getMsg() {
            return msg;
        }

        public void setMsg(String msg) {
            this.msg = msg;
        }

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }
    }

    /**
     * 配置
     */
    public class ConfData {

        private String value;

        public ConfData(String value) {
            this.value = value;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }
    }

    /**
     * 配置修改日志
     */
    public class ConfDataLog {

        private String key;
        private String value;
        private int optType;// 1添加,2修改
        private Date updateTime;

        public ConfDataLog() {
        }

        public ConfDataLog(String key, String value, int optType, Date updateTime) {
            this.key = key;
            this.value = value;
            this.optType = optType;
            this.updateTime = updateTime;
        }

        public String getKey() {
            return key;
        }

        public void setKey(String key) {
            this.key = key;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }

        public int getOptType() {
            return optType;
        }

        public void setOptType(int optType) {
            this.optType = optType;
        }

        public Date getUpdateTime() {
            return updateTime;
        }

        public void setUpdateTime(Date updateTime) {
            this.updateTime = updateTime;
        }
    }
}