spring gateway 接口返回值脱敏 -凯发k8国际

package com.huatech.gateway.filter;
import cn.hutool.http.contenttype;
import cn.hutool.http.header;
import cn.hutool.json.jsonutil;
import com.alibaba.fastjson.jsonarray;
import com.alibaba.fastjson.jsonobject;
import com.alibaba.fastjson.serializer.serializerfeature;
import com.google.common.base.charsets;
import com. huatech.gateway.utils.requestutils;
import lombok.extern.slf4j.slf4j;
import org.apache.commons.lang3.stringutils;
import org.reactivestreams.publisher;
import org.springframework.beans.factory.annotation.value;
import org.springframework.core.ordered;
import org.springframework.core.io.buffer.databuffer;
import org.springframework.core.io.buffer.databufferfactory;
import org.springframework.core.io.buffer.databufferutils;
import org.springframework.core.io.buffer.defaultdatabufferfactory;
import org.springframework.http.httpmethod;
import org.springframework.http.server.reactive.serverhttprequest;
import org.springframework.http.server.reactive.serverhttpresponse;
import org.springframework.http.server.reactive.serverhttpresponsedecorator;
import org.springframework.stereotype.component;
import org.springframework.util.antpathmatcher;
import org.springframework.web.server.serverwebexchange;
import org.springframework.web.server.webfilter;
import org.springframework.web.server.webfilterchain;
import reactor.core.publisher.flux;
import reactor.core.publisher.mono;
import java.util.iterator;
import java.util.objects;
/**
 * @author lihua_java@163.com
 *
 *         

 *         返回内容脱敏过滤器，将指定的字段脱敏
 *         
 */
@component
@slf4j
public class responsedesensitizefilter implements webfilter, ordered {
    @value("${gateway.desensitize.switch:false}")
    private boolean desensitizeswitch;
    @value("${gateway.desensitize.ignoreurls:}")
    private string[] ignoreurls;
    @value("${gateway.desensitize.fields:}")
    private string[] fields;
    private static final char desensitize_char = '*';
    /**
     * 返回值处理
     *
     * @param exchange
     * @param chain
     * @return
     */
    @override
    public mono filter(serverwebexchange exchange, webfilterchain chain) {
        serverhttprequest originalrequest = exchange.getrequest();
        log.debug("path : {}", originalrequest.geturi().getpath());
        if(!desensitizeswitch){
            return chain.filter(exchange);
        }
        if(fields == null || fields.length == 0){
            return chain.filter(exchange);
        }
        if (originalrequest.getmethod() != httpmethod.post) {
            return chain.filter(exchange);
        }
        if(requestutils.isxhr(originalrequest) || requestutils.isminiprogram(originalrequest)){
            log.debug("x-requested-with : {}", originalrequest.getheaders().getfirst(requestutils.header_key_x_request_with));
            return chain.filter(exchange);
        }
        string path = originalrequest.geturi().getpath();
        if(ignoreurlsmatch(path)){
            log.debug("ignoreuri : {}", path);
            return chain.filter(exchange);
        }
        serverhttpresponse originalresponse = exchange.getresponse();
        databufferfactory bufferfactory = originalresponse.bufferfactory();
        serverhttpresponsedecorator decoratedresponse = new serverhttpresponsedecorator(originalresponse) {
            @override
            public mono writewith(publisher body) {
                if (body instanceof flux) {
                    if (contenttype.json.tostring()
                        .equals(originalresponse.getheaders().getfirst(header.content_type.tostring()))) {
                        flux fluxbody = (flux)body;
                        return super.writewith(fluxbody.buffer().map(databuffers -> {
                            databufferfactory databufferfactory = new defaultdatabufferfactory();
                            databuffer join = databufferfactory.join(databuffers);
                            byte[] content = new byte[join.readablebytecount()];
                            join.read(content);
                            // 释放掉内存
                            databufferutils.release(join);
                            string responsestring = new string(content, charsets.utf_8);
                            if (stringutils.isnotblank(responsestring)) {
                                jsonobject respjson = jsonobject.parseobject(responsestring);
                                string data = respjson.getstring("data");
                                if(jsonutil.isjsonarray(data)){// 返回集合
                                    jsonarray items = jsonobject.parsearray(data);
                                    desensitizejsonarray(items);
                                    respjson.put("data", items);
                                }else if(jsonutil.isjsonobj(data)){// 返回单个对象
                                    jsonobject item = jsonobject.parseobject(data);
                                    if(item.containskey("records")){// 分页
                                        jsonarray items = item.getjsonarray("records");
                                        desensitizejsonarray(items);
                                    }else{
                                        desensitizejson(item);
                                    }
                                    respjson.put("data", item);
                                }
                                responsestring = jsonobject.tojsonstring(respjson, serializerfeature.mapsortfield);
                            }
                            byte[] uppedcontent = responsestring.getbytes(charsets.utf_8);
                            return bufferfactory.wrap(uppedcontent);
                        }));
                    }
                }
                return super.writewith(body);
            }
        };
        // replace response with decorator
        return chain.filter(exchange.mutate().response(decoratedresponse).build());
    }
    private void desensitizejsonarray(jsonarray items){
        if(objects.isnull(items) || items.isempty()){
            return;
        }
        iterator iterator = items.stream().iterator();
        while (iterator.hasnext()){
            jsonobject item = (jsonobject) iterator.next();
            desensitizejson(item);
        }
    }
    /**
     * 字符串脱敏
     * @param item
     */
    private void desensitizejson(jsonobject item){
        if(objects.isnull(item) || item.isempty()){
            return;
        }
        //log.debug("before desensitize, item : {}", item.tojsonstring());
        for(string fieldkey :fields){
            object field = item.get(fieldkey);
            if(objects.nonnull(field) && field instanceof string){
                string fieldval = field.tostring();
                int len = fieldval.length();
                if(len <= 1){
                    continue;
                }
                int start = (len == 2) ? 1 : (len / 3);
                int end = (len == 2) ? 1 : ((len - 1) - start);
                fieldval = replace(fieldval, start, end, desensitize_char);
                item.put(fieldkey, fieldval);
            }
        }
        //log.debug("after desensitize, item : {}", item.tojsonstring());
    }
    /**
     * 字符串替换
     * @param value
     * @param start
     * @param end
     * @param var
     * @return
     */
    private static string replace(string value, int start, int end, char var){
        if(stringutils.isblank(value)){
            return value;
        }
        if(end >= value.length()){
            end = value.length() - 1;
        }
        if(start > end || start >= value.length()){
            return value;
        }
        stringbuilder sb = new stringbuilder(value.length());
        char[] vs = value.tochararray();
        for(int i = 0, j = vs.length; i < j; i  ){
            if(i < start || i > end){
                sb.append(vs[i]);
            }else if(i >= start && i <= end){
                sb.append(var);
            }
        }
        return sb.tostring();
    }
    private antpathmatcher antpathmatcher = new antpathmatcher();
    private boolean ignoreurlsmatch(string path){
        for(string pattern : ignoreurls){
            if(antpathmatcher.match(pattern, path)){
                log.debug("path match, pattern : {}, path : {}", pattern, path);
                return true;
            }
        }
        return false;
    }
    @override
    public int getorder() {
        return 101;
    }
}

import org.springframework.http.server.reactive.serverhttprequest;
/**
 * @author lihua_java@163.com
 * @version 2.2.0
 * @date 2023/10/19
 */
public class requestutils {
    public static final string header_key_x_request_with = "x-requested-with";
    public static final string header_val_mini_program_request  = "miniprogramrequest";
    public static final string header_val_xml_http_request  = "xmlhttprequest";
    public static boolean isxhr(serverhttprequest request) {
        return header_val_xml_http_request.equalsignorecase(request.getheaders().getfirst(header_key_x_request_with));
    }
    public static boolean isminiprogram(serverhttprequest request) {
        return header_val_mini_program_request.equalsignorecase(request.getheaders().getfirst(header_key_x_request_with));
    }
}