spring-gateway filters添加自定义过滤器实现流程分析(可插拔)

@component
@slf4j
public class internalvalidatorgatewayfilterfactory extends abstractgatewayfilterfactory<internalvalidatorgatewayfilterfactory.config> implements ordered {
    private final antpathmatcher antpathmatcher = new antpathmatcher();
    public internalvalidatorgatewayfilterfactory() {
        super(config.class); // 指定配置类
    }
    @override
    public gatewayfilter apply(config config) {
        return (exchange, chain) -> {
            set<string> limitedips = config.getlimitedips();
            serverhttprequest request = exchange.getrequest();
            //接口路径
            string clientip = iphelp.getclientip(request);
            if (!islimitedip(clientip, limitedips)) {
                return chain.filter(exchange);
            }
            string path = request.getpath().value();
            set<string> includespaths = config.getincludespaths();
            if (!pathmatch(path, includespaths)) {
                log.info(" --> includespaths: {}, 不包含: 请求路径：{},", includespaths, path);
                return chain.filter(exchange);
            }
            set<string> excludespaths = config.getexcludespaths();
            if (pathmatch(path, excludespaths)) {
                log.info(" --> excludespaths: {}, contains: 请求路径：{},", excludespaths, path);
                return chain.filter(exchange);
            }
            map<string, map<string, string>> pathparamvaluemap = config.getpathparamvaluemap();
            map<string, map<string, string>> bodyparamvaluemap = config.getbodyparamvaluemap();
            map<string, string> bodyparammap = getpathparamvaluemap(path, bodyparamvaluemap);
            map<string, string> queryparammap = getpathparamvaluemap(path, pathparamvaluemap);
            if ((bodyparammap == null || bodyparammap.isempty()) && (
                    queryparammap == null || queryparammap.isempty()
            )) {
                exchange.getresponse().setstatuscode(httpstatus.forbidden);
                return exchange.getresponse().setcomplete();
            }
            if (queryparammap != null && !queryparammap.isempty()) {
                multivaluemap<string, string> queryparams = request.getqueryparams();
                if (!queryparammatch(queryparammap, queryparams)) {
                    log.info(" --> path: {}, bodyparamconditions: {}, queryparammap: {},校验失败！", path, bodyparammap, queryparammap);
                    exchange.getresponse().setstatuscode(httpstatus.forbidden);
                    return exchange.getresponse().setcomplete();
                }
                if (bodyparammap == null || bodyparammap.isempty()) {
                    return chain.filter(exchange);
                }
            }
            if (bodyparammap != null && !bodyparammap.isempty()) {
                string method = request.getmethodvalue();
                if ("post".equals(method)) {
                    return databufferutils.join(exchange.getrequest().getbody())
                            .flatmap(databuffer -> {
                                byte[] bytes = new byte[databuffer.readablebytecount()];
                                databuffer.read(bytes);
                                try {
                                    string bodystring = new string(bytes, "utf-8");
                                    if (!bodyparammatch(bodyparammap, bodystring)) {
                                        exchange.getresponse().setstatuscode(httpstatus.forbidden);
                                        return exchange.getresponse().setcomplete();
                                    }
                                } catch (unsupportedencodingexception e) {
                                }
                                databufferutils.release(databuffer);
                                flux<databuffer> cachedflux = flux.defer(() -> {
                                    databuffer buffer = exchange.getresponse().bufferfactory()
                                            .wrap(bytes);
                                    return mono.just(buffer);
                                });
                                serverhttprequest mutatedrequest = new serverhttprequestdecorator(
                                        exchange.getrequest()) {
                                    @override
                                    public flux<databuffer> getbody() {
                                        return cachedflux;
                                    }
                                };
                                return chain.filter(exchange.mutate().request(mutatedrequest).build());
                            });
                }
            }
            exchange.getresponse().setstatuscode(httpstatus.forbidden);
            return exchange.getresponse().setcomplete();
        };
    }
    @override
    public int getorder() {
        return 2;
    }
    private map<string, string> getpathparamvaluemap(string path, map<string, map<string, string>> paramvaluemap) {
        if (paramvaluemap == null || paramvaluemap.isempty()) {
            return null;
        }
        map<string, string> res = new hashmap<>();
        for (map.entry<string, map<string, string>> paramvalueentry : paramvaluemap.entryset()) {
            string pathpredicate = paramvalueentry.getkey();
            if (antpathmatcher.match(pathpredicate, path)) {
                map<string, string> paramvalue = paramvalueentry.getvalue();
                if (paramvalue == null) {
                    continue;
                }
                res.putall(paramvalue);
            }
        }
        return res;
    }
    private string extractparam(string jsonstr, string key) {
        try {
            int startindex = jsonstr.indexof("\"" + key + "\"");
            if (startindex != -1) {
                int valuestart = jsonstr.indexof(':', startindex);
                int valueend = jsonstr.indexof(',', valuestart);
                if (valueend == -1) {
                    valueend = jsonstr.indexof('}', valuestart);
                }
                if (valuestart != -1 && valueend != -1) {
                    string valuepart = jsonstr.substring(valuestart + 1, valueend).trim();
                    return valuepart.replaceall("\"", "");
                }
            }
        } catch (exception e) {
            // 可以记录日志
            return null;
        }
        return null;
    }
    private boolean pathmatch(string path, set<string> predicatepaths) {
        if (predicatepaths == null || predicatepaths.isempty()) {
            return false;
        }
        return predicatepaths.stream()
                .anymatch(predicatepath -> antpathmatcher.match(predicatepath, path));
    }
    private boolean parammatch(map<string, string> bodyparammap,
                               map<string, string> queryparammap,
                               serverhttprequest request,
                               serverwebexchange exchange
    ) {
        return true;
    }
    private boolean bodyparammatch(map<string, string> bodyparamconditions, string bodystr) {
        if (bodystr == null) {
            return false;
        }
        for (map.entry<string, string> conditionmapentry : bodyparamconditions.entryset()) {
            string predicateparam = conditionmapentry.getkey();
            string predicatevalue = conditionmapentry.getvalue();
            string acvalue = extractparam(bodystr, predicateparam);
            if (!predicatevalue.equals(acvalue)) {
                log.info(" --> bodyparammatch:::predicateparam:{}, predicatevalue:{}, acvalue:{},参数校验不通过！",
                        predicateparam, predicatevalue, acvalue);
                return false;
            }
        }
        return true;
    }
    private boolean queryparammatch(map<string, string> conditionmap, multivaluemap<string, string> queryparams) {
        for (map.entry<string, string> conditionmapentry : conditionmap.entryset()) {
            string predicateparam = conditionmapentry.getkey();
            string predicatevalue = conditionmapentry.getvalue();
            string acvalue = queryparams.getfirst(predicateparam);
            if (!predicatevalue.equals(acvalue)) {
                log.info(" --> queryparammatch:::predicateparam:{}, predicatevalue:{}, acvalue:{},参数校验不通过！",
                        predicateparam, predicatevalue, acvalue);
                return false;
            }
        }
        return true;
    }
    private boolean islimitedip(string clientip, set<string> limitedips) {
        if (clientip == null || clientip.isempty()) {
            log.warn(" --> clientip:{} 为空！", clientip);
            return true;
        }
        if (limitedips == null || limitedips.isempty()) {
            log.info(" --> limitedips:{} 为空！", limitedips);
            return false;
        }
        for (string limitedip : limitedips) {
            if (clientip.contains(limitedip)) {
                return true;
            }
        }
        return false;
    }
    // 配置类
    public static class config {
        private string paths = "/**";
        private string limitedfrom;
        private list<conditionconfig> conditions = new arraylist<>();
        private string excludes;
        private set<string> includespaths;
        private set<string> limitedips = new hashset<>();
        private set<string> excludespaths = new hashset<>();
        private map<string, map<string, string>> bodyparamvaluemap = new hashmap<>();
        private map<string, map<string, string>> pathparamvaluemap = new hashmap<>();
        public void setpaths(string paths) {
            this.paths = paths;
            if (paths != null) {
                this.includespaths = new hashset<>(arrays.aslist(paths.split(",")));
            }
        }
        public void setlimitedfrom(string limitedfrom) {
            this.limitedfrom = limitedfrom;
            if (limitedfrom != null) {
                this.limitedips = new hashset<>(arrays.aslist(limitedfrom.split(",")));
            }
        }
        public void setconditions(list<conditionconfig> conditions) {
            this.conditions = conditions;
            if (conditions != null && !conditions.isempty()) {
                for (conditionconfig condition : conditions) {
                    string conditionpaths = condition.getpaths();
                    string bodyparam = condition.getbodyparam();
                    string bodyvalue = condition.getbodyvalue();
                    string pathparam = condition.getpathparam();
                    string pathvalue = condition.getpathvalue();
                    if (conditionpaths != null) {
                        if (bodyparam != null && bodyvalue != null) {
                            for (string path : conditionpaths.split(",")) {
                                map<string, string> bodyparamcondition = bodyparamvaluemap.get(path);
                                if (bodyparamcondition == null) {
                                    bodyparamcondition = new hashmap<>();
                                }
                                bodyparamcondition.put(bodyparam, bodyvalue);
                                bodyparamvaluemap.put(path, bodyparamcondition);
                            }
                        }
                        if (pathparam != null && pathvalue != null) {
                            for (string path : conditionpaths.split(",")) {
                                map<string, string> pathparamcondition = pathparamvaluemap.get(path);
                                if (pathparamcondition == null) {
                                    pathparamcondition = new hashmap<>();
                                }
                                pathparamcondition.put(pathparam, pathvalue);
                                pathparamvaluemap.put(path, pathparamcondition);
                            }
                        }
                    }
                }
            }
        }
        public void setexcludes(string excludes) {
            this.excludes = excludes;
            if (excludes != null) {
                this.excludespaths = new hashset<>(arrays.aslist(excludes.split(",")));
            }
        }
        public set<string> getincludespaths() {
            return includespaths;
        }
        public set<string> getlimitedips() {
            return limitedips;
        }
        public set<string> getexcludespaths() {
            return excludespaths;
        }
        public map<string, map<string, string>> getbodyparamvaluemap() {
            return bodyparamvaluemap;
        }
        public map<string, map<string, string>> getpathparamvaluemap() {
            return pathparamvaluemap;
        }
    }
    @data
    public static class conditionconfig {
        private string paths;
        private string bodyparam;
        private string bodyvalue;
        private string pathparam;
        private string pathvalue;
    }
}

import lombok.extern.slf4j.slf4j;
import org.springframework.http.httpheaders;
import org.springframework.http.server.reactive.serverhttprequest;
import java.net.inetsocketaddress;
import java.util.arrays;
import java.util.collections;
import java.util.list;
@slf4j
public class iphelp {
    private static final list<string> ip_headers = collections.unmodifiablelist(arrays.aslist(
            "x-forwarded-for",
            "x-forwarded-for",
            "xff",
            "x-real-ip",
            "proxy-client-ip",
            "wl-proxy-client-ip",
            "http_client_ip",
            "http_x_forwarded_for"
    ));
    public static string getclientip(serverhttprequest request) {
        string resultip = null;
        httpheaders headers = request.getheaders();
        for (string head : ip_headers) {
            string ip = headers.getfirst(head);
            log.info(" --> ip_header:{}, ip_value:{}", head, ip);
            if (isvalidip(ip)) {
                resultip = ip;
                break;
            }
        }
        if (resultip == null && request.getremoteaddress() != null) {
            inetsocketaddress remoteaddress = request.getremoteaddress();
            resultip = remoteaddress.getaddress().gethostaddress();
            log.info(" --> ip_header: remoteaddress, ip_value:{}", resultip);
        }
        log.info(" --> getclientip, ip_value:{}", resultip);
        return resultip;
    }
    private static boolean isvalidip(string ip) {
        return ip != null && !ip.trim().isempty() && !"unknown".equalsignorecase(ip.trim());
    }
}