Spring Cloud 自定义ConfigServer

公司需要将系统配置信息中的敏感信息独立存放。

现有系统采用Spring Cloud Config提供配置信息，其中敏感信息主要是Db配置，分解本次需求：

（1）数据库配置信息分离（主要是Db信息）。

（2）原有Config Server功能继续可用。

（3）对特定环境（这里是仿真环境-Demo、生产环境）可以定制配置信息。

思路有如下几种：

（1）Spring Aop 拦截Config Server中配置返回方法，改写方法返回值。

（2）Spring Aop 拦截Config Server中读取配置方法，读取更多文件源。

（3）Filter拦截Config Server中数据返回方法，改写方法返回值。

其中：

方法1与方法3都是对返回结果进行处理，可以兼容Spring Cloud Config的版本升级，因方法1需要绑定到特定方法，而方法3无需考虑具体方法，耦合性更低。

方法2需要改写Config Server的代码，或覆盖Config Server的Bean，较1和2复杂，且无法随这主版本升级，直接pass。

综合考虑采用方法3，以下是处理与代码：

公司统一标准，将Db配置信息存储到Json文件中，因此需要一个解析Json文件的Service：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.MapPropertySource;
import org.springframework.stereotype.Component;
 
import java.io.File;
import java.io.IOException;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
 
@Component
public class JsonSourcePropertiesLoader {
    @Value("${Config.Json.FileLocation}")
    String FileLocation;
 
    public MapPropertySource load() throws IOException {
        File jsonFile = new File(FileLocation);
        final Map<String, Object> source = process(jsonFile);
        System.out.println(new Date().getTime());
        return new MapPropertySource("dbConfigMap",source);
    }
 
    private Map<String, Object> process(final File resourceFile){
        Map<String, Object> map = null;
        try{
            map = new ObjectMapper().readValue(resourceFile, LinkedHashMap.class);
        }catch (IOException e){
            e.printStackTrace();
        }
        return map;
    }
}

需要一个类拦截并获取Config Server在正常处理请求后返回的内容，以便接下来的改写：

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
 
public class MyResponseWrapper extends HttpServletResponseWrapper {
    private ByteArrayOutputStream byteArrayOutputStream;
    private ServletOutputStream servletOutputStream;
    private PrintWriter printWriter;
 
    public MyResponseWrapper(HttpServletResponse response) {
        super(response);
        byteArrayOutputStream = new ByteArrayOutputStream(4096);
        printWriter = new PrintWriter(byteArrayOutputStream);
        servletOutputStream = new MyServletOutputStream(byteArrayOutputStream);
    }
 
    @Override
    public PrintWriter getWriter() throws IOException{
        return printWriter;
    }
 
    @Override
    public ServletOutputStream getOutputStream() throws IOException{
        return servletOutputStream;
    }
 
    @Override
    public void flushBuffer() throws IOException{
        if(printWriter!=null){
            printWriter.flush();
        }
        if(servletOutputStream !=null){
            servletOutputStream.flush();
        }
    }
 
    @Override
    public void reset(){
        byteArrayOutputStream.reset();
    }
 
    public byte[] getResult(){
        try{
            flushBuffer();
        }catch (IOException e){
 
        }
        return byteArrayOutputStream.toByteArray();
    }
}

对ServletOutputStream的封装类：

import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
 
public class MyServletOutputStream extends ServletOutputStream {
    ByteArrayOutputStream output;
 
    public MyServletOutputStream(ByteArrayOutputStream output) {
        this.output = output;
    }
 
    @Override
    public void write(int b) throws IOException {
        output.write(b);
    }
 
    public void write(byte[] data, int offset, int length) {
        output.write(data, offset, length);
    }
 
    @Override
    public boolean isReady() {
        return false;
    }
 
    @Override
    public void setWriteListener(WriteListener listener) {
 
    }
}

有了拦截与处理的方法，最后就是把功能组合到拦截器中：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fang.microservice.cloud.Loader.JsonSourcePropertiesLoader;
import com.fang.microservice.cloud.Wrapper.MyResponseWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.core.env.MapPropertySource;
import org.springframework.stereotype.Component;
 
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
 
@Component
@ServletComponentScan
@WebFilter(urlPatterns = "/{name}/{profiles:.*[^-].*}", filterName = "ConfigServletFilter")
public class ConfigAspectFilter implements Filter {
    @Autowired
    JsonSourcePropertiesLoader jsonConfig;
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
 
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        MyResponseWrapper wrapper = new MyResponseWrapper((HttpServletResponse) response);
        chain.doFilter(request, wrapper);
        byte[] respBytes = wrapper.getResult();
        String result = Byte2String(respBytes);
        if (response.getContentType().toLowerCase().contains("application/json")) {
            if (!result.toLowerCase().contains("datasource.mysql.")) {
                JSONObject configObj = (JSONObject) JSON.parse(result);
                JSONArray propertySourcesObjs = configObj.getJSONArray("propertySources");
                if (propertySourcesObjs.size() > 0) {
                    JSONObject propertySourcesObj = (JSONObject) propertySourcesObjs.get(0);
                    JSONObject sourceObj = propertySourcesObj.getJSONObject("source");
                    MapPropertySource mps = jsonConfig.load();
                    for (String key : mps.getPropertyNames()) {
                        sourceObj.put(key, mps.getProperty(key));
                    }
                    result = JSON.toJSONString(configObj);
                }
            }
        }
 
        response.setContentLength(-1);
        PrintWriter out = response.getWriter();
        out.write(result);
        out.flush();
        out.close();
    }
 
    public static String Byte2String(byte[] buff) {
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        int length;
        try {
                result.write(buff, 0, buff.length);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            return result.toString("UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return "";
    }
 
    @Override
    public void destroy() {
 
    }
}

作为敏感数据存储的文件内容：

{ "testDbName":"testDb","userName":"userName","password":"pass"}

测试效果如下：

最后不能忘记特定敏感文件的路径，需要配置在配置文件中：

Config.Json.FileLocation=/xx/test/test.json

这样，一个既可以规避敏感文件，又能不失Config Server方便性的简单处理方案就这样可以投入使用了。