springcloud gateway api实现全信道加解密

已于 2023-08-17 18:02:59 修改
阅读量196 收藏 3
点赞数 1
文章标签： spring cloud gateway java
于 2023-08-17 18:02:01 首次发布
原文链接：https://juejin.cn/post/7108878027458609188
版权

1. 接口的使用范围

get 请求 post请求 put请求 delete请求
白名单除外

2注意事项

请求头增加一个加密版本字段，标识当前的加密算法版本：crypto-version: 1.0.0

3.加密算法

考虑到全局加密，使用AES加密方式性能更高

加密字符串：原始数据 > AES加密后的字节数组 > Base64编码处理

解密字符串：Base64密文 > AES密文 -> 原始字符串

4.报文格式

GET
url：/app/xx/xx?xx=1
加密处理
秘钥：xxxxxxxxxxxxxxxx
加密文本：{“xx”:1}
密文：xq4YR89LgUs4V5N5juKgW5hIsiOsCxBOwzX632S8NV4=
加密后的请求
/app/xx/xx?data=xq4YR89LgUs4V5N5juKgW5hIsiOsCxBOwzX632S8NV4=
POST
url：/app/xx/xx/xxx
json body:
{“xxx1”:“111”,“xxx2”:“huawei”,“xxx3”:“789”,“xxx4”:101,“xxx5”:2}
加密处理
秘钥：xxxxxxxxxxxxxxxx
加密文本：
{“xxx1”:“111”,“xxx2”:“huawei”,“xxx3”:“789”,“xxx4”:101,“xxx5”:2}
密文：1oUTYvWfyaeTJ5/wJTVBqUv0Dz0IAUQTZtxSKY9WLZZl8pILP2Sozk5yOYg9I1WTvzgbbGRDGcWV1ASpYykyS1Fq5cT8s3aLXQ6NMo0AaMOC9L0aVpR863qWso5O8aG3
加密后的请求*
json body:
{
“data”: “1oUTYvWfyaeTJ5/wJTVBqUv0Dz0IAUQTZtxSKY9WLZZl8pILP2Sozk5yOYg9I1WTvzgbbGRDGcWV1ASpYykyS1Fq5cT8s3aLXQ6NMo0AaMOjt4G9dK0WwhMGZofYuBKmdF27R8Qkr3VtZvjadtvBazJurITyE7hFcr43nlHSL5E=”
}
POST url传参 和GET格式一致

5.直接上代码

import cn.hutool.crypto.CryptoException;
import cn.iocoder.yudao.gateway.util.AesUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import io.netty.buffer.ByteBufAllocator;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringEscapeUtils;
import org.reactivestreams.Publisher;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.NettyWriteResponseFilter;
import org.springframework.cloud.gateway.filter.ReactiveLoadBalancerClientFilter;
import org.springframework.context.annotation.Configuration;
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.NettyDataBufferFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.http.server.reactive.ServerHttpResponseDecorator;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.net.URISyntaxException;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.*;


@Slf4j
@RequiredArgsConstructor
@Configuration
@ConditionalOnProperty(value = "gateway.crypto.enabled", havingValue = "true", matchIfMissing = true)
public class CryptoFilter implements GlobalFilter, Ordered {
    private final AntPathMatcher antPathMatcher = new AntPathMatcher();
    private final DataBufferFactory dataBufferFactory = new NettyDataBufferFactory(ByteBufAllocator.DEFAULT);

    private final CryptoProperties cryptoProperties;

    @Override  //1001
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("来了老弟");
        if (!cryptoProperties.isEnabled()) {
            return chain.filter(exchange);
        }
        ServerHttpRequest request = exchange.getRequest();
        //校验请求路径跳过加密
//        String originalRequestUrl = RequestProvider.getOriginalRequestUrl(exchange);
        String path = exchange.getRequest().getURI().getPath();
        if (isSkip(path)) {
            return chain.filter(exchange);
        }

        HttpHeaders headers = request.getHeaders();
        MediaType contentType = headers.getContentType();

        //后期算法升级扩展,暂时只判断是否相等
        if (!cryptoProperties.getCryptoVersion().equals(headers.getFirst(cryptoProperties.getCryptoVersionHeader()))) {
            return Mono.error(new CryptoException("加密版本不支持"));
        }

        if (request.getMethod() == HttpMethod.GET || request.getMethod() == HttpMethod.DELETE ) {
            return this.handleGetReq(exchange, chain);
        } else if (request.getMethod() == HttpMethod.POST &&
                (contentType == null ||
                        MediaType.APPLICATION_JSON.equals(contentType) ||
                        MediaType.APPLICATION_JSON_UTF8.equals(contentType))) {
            return this.handlePostReq(exchange, chain);
        } else if (request.getMethod() == HttpMethod.PUT &&
                (contentType == null ||
                        MediaType.APPLICATION_JSON.equals(contentType) ||
                        MediaType.APPLICATION_JSON_UTF8.equals(contentType))) {
            return this.handlePostReq(exchange, chain);
        } else {
            return chain.filter(exchange);
        }
    }

    class CryptoServerHttpResponseDecorator extends ServerHttpResponseDecorator {
        final DataBufferFactory bufferFactory;
        boolean isPass = false;
        public CryptoServerHttpResponseDecorator(ServerHttpResponse delegate) {
            super(delegate);
            bufferFactory = delegate.bufferFactory();
        }


        @Override
        public HttpHeaders getHeaders() {
            HttpHeaders headers = super.getHeaders();
            log.info("同一个请求此处有可能调用多次,先重置为false");
            //同一个请求此处有可能调用多次,先重置为false
            isPass = false;
            if (headers.getContentType() != null &&
                    !MediaType.APPLICATION_JSON.equals(headers.getContentType()) &&
                    !MediaType.APPLICATION_JSON_UTF8.equals(headers.getContentType())) {
                //相应体ContentType只处理json
                isPass = true;
            } else if (!headers.containsKey(cryptoProperties.getCryptoVersionHeader())) {
                //添加version响应头
                headers.add(cryptoProperties.getCryptoVersionHeader(), cryptoProperties.getCryptoVersion());
            }
            return headers;
        }

        //调用 writeWith 和 writeAndFlushWith 判断: NettyWriteResponseFilter

        // application/json;charset=UTF-8 走这里
        @Override
        public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
            if (body instanceof Flux && !isPass) {
                Flux<? extends DataBuffer> fluxBody = (Flux<? extends DataBuffer>) body;
                return super.writeWith(fluxBody.buffer().map(dataBuffer -> {
                    DataBuffer joinDataBuffer = bufferFactory.join(dataBuffer);
                    byte[] content = new byte[joinDataBuffer.readableByteCount()];
                    joinDataBuffer.read(content);
                    DataBufferUtils.release(joinDataBuffer);
                    Map<String, String> data = new HashMap<>(1);
                    data.put(cryptoProperties.getParamName(), AesUtil.encryptToBase64(content, cryptoProperties.getAesKey()));
                    return bufferFactory.wrap(JSON.toJSONString(data).getBytes(StandardCharsets.UTF_8));
                }));
            }
            return super.writeWith(body);
        }

        // StreamingMediaType类型:application/stream 和 application/stream+json 走这里
        @Override
        public Mono<Void> writeAndFlushWith(Publisher<? extends Publisher<? extends DataBuffer>> body) {
            return super.writeAndFlushWith(body);
        }
    }

    @SneakyThrows
    private Mono<Void> handlePostReq(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String paramData = request.getQueryParams().getFirst(cryptoProperties.getParamName());
        MultiValueMap<String, String> queryParamMap = new LinkedMultiValueMap<>();
        final boolean queryParamsDecrypt = !StringUtils.isEmpty(paramData);
        if (queryParamsDecrypt) {
            String dataJson;
            try {
                //AES解密
                dataJson = AesUtil.decryptFormBase64ToString(paramData, cryptoProperties.getAesKey());
            } catch (Exception e) {
                log.error("请求参数解密异常: ", e);
                return cryptoError(exchange.getResponse(), "请求参数解密异常");
            }
            //构造查询参数Map
            queryParamMap = buildMultiValueMap(dataJson);
            //新的解密后的uri request
            request = this.buildNewServerHttpRequest(request, queryParamMap);
        }

        //构造一个请求包装
        final MultiValueMap<String, String> finalQueryParamMap = new LinkedMultiValueMap<>(queryParamMap);
        ServerHttpRequestDecorator decorator = new ServerHttpRequestDecorator(request) {

            @Override
            public HttpHeaders getHeaders() {
                HttpHeaders httpHeaders = new HttpHeaders();
                httpHeaders.putAll(super.getHeaders());
                httpHeaders.remove(HttpHeaders.CONTENT_LENGTH);
                httpHeaders.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
                return httpHeaders;
            }

            @Override
            public MultiValueMap<String, String> getQueryParams() {
                if (queryParamsDecrypt) {
                    return finalQueryParamMap;
                }
                return super.getQueryParams();
            }

            @Override
            public Flux<DataBuffer> getBody() {
                //注意: 这里需要buffer,拿到完整报文后再map解密
                return super.getBody().buffer().map(buffer -> {
                    DataBuffer joinDataBuffer = dataBufferFactory.join(buffer);
                    byte[] content = new byte[joinDataBuffer.readableByteCount()];
                    joinDataBuffer.read(content);
                    DataBufferUtils.release(joinDataBuffer);
                    String decryptData = new String(content, StandardCharsets.UTF_8);
                    log.info("post decryptData: {}", decryptData);
                    if (!queryParamsDecrypt && StringUtils.isEmpty(decryptData)) {
                        throw new CryptoException("参数格式错误");
                    } else {

                        JSONObject dataJsonObj = JSON.parseObject(decryptData);
                        if (!queryParamsDecrypt && !dataJsonObj.containsKey(cryptoProperties.getParamName())) {
                            throw new CryptoException("参数格式错误");
                        }
                        byte[] bytes = AesUtil.decryptFormBase64(dataJsonObj.getString(cryptoProperties.getParamName()), cryptoProperties.getAesKey());
                        return dataBufferFactory.wrap(Objects.requireNonNull(bytes));
                    }
                });
            }
        };
        return chain.filter(exchange.mutate()
                .request(decorator)
                .response(new CryptoServerHttpResponseDecorator(exchange.getResponse()))
                .build());
    }
    @SneakyThrows
    private Mono<Void> handleGetReq(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        if (request.getQueryParams().isEmpty()) {
            // get无参数 不走参数解密
            return chain.filter(exchange.mutate()
                    .request(request)
                    .response(new CryptoServerHttpResponseDecorator(exchange.getResponse()))
                    .build());
        }
        String paramData = request.getQueryParams().getFirst(cryptoProperties.getParamName());

        if (StringUtils.isEmpty(paramData)) {
            //有参数但是密文字段不存在
            throw new CryptoException("参数格式错误");
        }

        String dataJson;
        String s;
        try {
            //AES解密
             dataJson = AesUtil.decryptFormBase64ToString(paramData, cryptoProperties.getAesKey());
            JSONObject jsonObject = JSON.parseObject(dataJson);
            System.out.println("jsonObject = " + jsonObject);
            Iterator<Map.Entry<String, Object>> iterator = jsonObject.entrySet().iterator();
            Map.Entry<String, Object> entry;
            while (iterator.hasNext()) {
                entry = iterator.next();
                if (entry.getValue()==null){
                    iterator.remove();
                    continue;
                }
                if (entry.getValue().equals("")){
                    iterator.remove();
                }

                System.out.println("key值是："+entry.getKey());
                System.out.println("value是："+entry.getValue());
            }

            System.out.println("jsonObject = " + jsonObject);
            s = JSON.toJSONString(jsonObject);
            System.out.println("s = " + s);
        } catch (Exception e) {
            log.error("请求参数解密异常: ", e);
            return cryptoError(exchange.getResponse(), "请求参数解密异常");
        }
        //构造查询参数Map
        MultiValueMap<String, String> map = buildMultiValueMap(s);
        //新的解密后的uri
        ServerHttpRequest newHttpRequest = this.buildNewServerHttpRequest(request, map);
        //新的解密后的uri request
        ServerHttpRequestDecorator decorator = new ServerHttpRequestDecorator(newHttpRequest) {
            @Override
            public MultiValueMap<String, String> getQueryParams() {
                return map;
            }

        };
        return chain.filter(exchange.mutate()
                .request(decorator)
                .response(new CryptoServerHttpResponseDecorator(exchange.getResponse()))
                .build());
    }

    private MultiValueMap<String, String> buildMultiValueMap(String dataJson) {
        JSONObject jsonObject = JSON.parseObject(dataJson);
        MultiValueMap<String, String> map = new LinkedMultiValueMap<>(jsonObject.size());
        for (String key : jsonObject.keySet()) {
            Object o = jsonObject.get(key);
            if(o instanceof List){
                List li= (List) o;
                map.put(key, li);
            }else {
                map.put(key, Lists.newArrayList(jsonObject.getString(key)));
            }

        }
        return map;
    }

    private ServerHttpRequest buildNewServerHttpRequest(ServerHttpRequest request, MultiValueMap<String, String> params) throws Exception {
        StringBuilder queryBuilder = new StringBuilder();
        for (String key : params.keySet()) {


            List<String> strings = params.get(key);
            if(strings.size()==1){
                queryBuilder.append(key);
                queryBuilder.append(StringPool.EQUALS);
                queryBuilder.append(params.getFirst(key));
                queryBuilder.append(StringPool.AMPERSAND);
            }else {
                for (int i = 0; i < strings.size(); i++) {
                    queryBuilder.append(key);
                    queryBuilder.append(StringPool.EQUALS);
                    queryBuilder.append(strings.get(i));
                    queryBuilder.append(StringPool.AMPERSAND);
                }
            }

        }
        queryBuilder.deleteCharAt(queryBuilder.length() - 1);

        //经过测试只覆盖 ServerHttpRequest的getQueryParams路由分发之后,无法携带过去新的参数,所以这里需要构造一个新的解密后的uri
        URI uri = request.getURI();
        URI newUri = new URI(uri.getScheme(),
                uri.getUserInfo(),
                uri.getHost(),
                uri.getPort(),
                uri.getPath(),
                queryBuilder.toString(),
                uri.getFragment());
        //构造一个新的ServerHttpRequest
        return request.mutate().uri(newUri).build();
    }

    private boolean isSkip(String path) {
        for (int i = 0; i < cryptoProperties.getSkipPathPattern().size(); i++) {
            String skipPathPattern = cryptoProperties.getSkipPathPattern().get(i);
            if (antPathMatcher.match(skipPathPattern,path)){
                return true;
            }
        }
        return false;
    }

    private Mono<Void> cryptoError(ServerHttpResponse resp, String msg) {
        resp.setStatusCode(HttpStatus.UNAUTHORIZED);
        resp.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        String result = JSON.toJSONString(ResponseProvider.unAuth(msg));
        DataBuffer buffer = resp.bufferFactory().wrap(result.getBytes(StandardCharsets.UTF_8));
        return resp.writeWith(Flux.just(buffer));
    }

    @Override
    public int getOrder() {
        return -200;
    }

    public static void main(String[] args) {


        System.out.println(UUID.randomUUID().toString());
    }
}


还缺少相应的工具类 下期继续
HY_____YH
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Spring Cloud Gateway 网关 SM2 加解密
tte_w的专栏
11-16 451
Spring Cloud Gateway 网关 sm2 全报文加密
SpringCloud
weixin_51633670的博客
05-08 1769
笔记参考来源 尚硅谷 SpringCloud 第二季学习笔记【已完结】_yfstart的博客-CSDN博客_尚硅谷springcloud笔记 SpringCloud cloud和boot版本要对应才能使用。可上官网查看 一、介绍 服务注册中心 Eureka(停更) Zookeeper Consul Nacos(推荐) 服务调用 Ribbon LoadBalancer 服务调用2 OpenFeign 服务降级 resilience4j(国外推荐) sentinel(国内) 服务网关 gat
spring gateway 实现全信道加解密
天行健，君子以自强不息；地势坤，君子以厚德载物。
08-21 489
前言：近期在项目中需要对指定请求整个信道进行加解密（防篡改，反拦截），实现整个信道通讯安全，由于不确定后期那些接口可能需要类似处理，最后决定放在网关实现该功能（虽然稍微占用网关的性能，但是能够全局统一处理十分方便，性能方面可以增加配置来解决）。此过程中也踩了些坑，在此记录下来，以便后来人参考；首先我们采用的是GlobalFilter，GlobalFilter是应用于所有路由的特殊过滤器。Globa...
后端Gateway对接口参数统一加解密基于过滤器
weixin_46196153的博客
10-11 478
首先准备工具类：需要加解密的接口预热工具准备就绪开始编写gateway的全局拦截器：2. 接口入参body数据解密3.因为body只能读取一次，所以需要再写个全局过滤器 解决body流重复获取。
SpringCloud-Gateway网关实现入参统一解密
RHHcainiao的博客
09-14 944
SpringCloud-Gateway网关统一解密参数
[Spring Cloud] (6)gateway整体加解密
最新发布
一个喜欢什么都研究一下的小小后端程序员
05-05 1720
Spring Cloud Gateway的加解密功能为分布式系统提供了一个安全、高效、灵活的数据传输解决方案，有助于提升系统的安全性和开发效率。像数据接口，发送的参数是加密数据，接收到的都是是加密数据。但是经过前后端的拦截器处理之后，显示出的依然是正常数据。在经历前面6章的铺垫下，终于进入到了最重要的环节——拦截器功能实现，此时我们需要看的东西就比较集中而且简单了。本文网关gateway，微服务，vue已开源到gitee。像不需要加密的接口，请求参数与响应数据都是未加密的。
gateway对参数解密，返回值解密统一处理方法，实际验证可用
qq_30983505的博客
05-21 4539
Gateway全局参数解密返回值加密： 项目中前端传入参数是解密的，所以在网关处要统一对加密参数解密，在转发到对应的微服务 请求参数解密统一处理： Req拦截器中处理方法： 把这个方法里处理解密的Util类改成你自己的，我这里contentType约定是Json，你如果用其他的类型，自己改下MediaType.APPLICATION_JSON.： @Component @Slf4j public class ReqFilter implements GlobalFilter, Ordered {
Spring Cloud 学习笔记（2 3）
m0_67392811的博客
07-28 396
大神结论MartinFowler的相关论文熔断类型熔断打开请求不再进行调用当前服务，内部设置时钟一般为MTTR(平均故障处理时间)，当打开时长达到所设时钟则进入半熔断状态。熔断关闭熔断关闭不会对服务进行熔断。熔断半开部分请求根据规则调用当前服务，如果请求成功且符合规则则认为当前服务恢复正常，关闭熔断。官网断路器流程图官网步骤link断路器在什么情况下开始起作用//=====服务熔断快照时间窗请求总数阀值在快照时间窗内，必须满足请求总数阀值才有资格熔断。错误百分比阀值1。...
商城-文档
weixin_46925850的博客
07-28 7835
谷粒商城学习笔记
2022年Java 工程师面试题
weixin_42572320的博客
03-03 2443
第 1 页 共 485 页 目录 1、什么是 Mybatis？............................................................................... 33 2、Mybaits 的优点：............................................................................... 33 3、MyBatis 框架的缺点：.............................
Java复习面试题
weixin_51788883的博客
06-04 790
Java基础 1. 面向对象的三个基本特征? 面向对象的三个基本特征是:封装、继承、多态 继承:让某个类型的对象获得另一个类型的对象的属性的方法;继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例和方法,或子类从父类继承方法,使得子类具有父类相同的行为 封装:隐藏部分对象的属性和实现细节,对数据的访问只能通过对外公开的接口,通过这种方式,对象对内部数据提供了不同级别的保护,以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分 多态:对于同一个行为,不同的子类对象具有不同的表现
SpringCloud Gateway API接口安全设计（加密 、签名）
qq_34125999的博客
10-27 1万+
1 防止数据抓包窃取 1.1 风险简述 简述：当用户登录时，恶意攻击者可以用抓包工具可以拿到用户提交的表单信息，可以获取用户的账号密码，进而可以恶意访问网站。 1.2 RSA 非对称加密 1.2.1 RSA简介 RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开
SpringCloud Gateway API接口加解密
small_to_large的博客
06-02 4180
SpringCloud Gateway API接口报文加解密 GET POST AES/DES/对称/非对称加解密
超详细！完整版！基于spring对外开放接口的签名认证方案(拦截器方式)
Coldmood的博客
06-26 6111
由于项目需要开发第三方接口给多个供应商，为保证Api接口的安全性，遂采用Api接口签名验证。
gateway网关对请求参数解密/加密
zrj00711的博客
06-28 2426
首先我们要知道服务端和客服端交互的时候，数据是尤为重要的。我们要对数据进行加密的处理。利用的spring clould 网关服务来处理该项业务。
简单例子gateway网关加密解密子服务分发请求
qq_19342829的博客
01-17 1014
简单例子gateway网关加密解密子服务分发请求，子服务参数校验，以及业务简单分发功能
spring cloud gateway 网关路由转发及request、response的加解密处理
热门推荐
K_Men的博客
09-23 1万+
sygateway的介绍和使用原理请自行查阅和学习，本章内容需在对spring cloud gateway的基本的了解和一定的知识基础上进行的。附上一个可供学习的博文：SpringCloud gateway （史上最全） - 疯狂创客圈 - 博客园 需求场景： 前端对post请求的数据进行加密（主流的加密方式），后端需要解密，将接口的响应数据进行加密返回，前端解密并展示或其他操作等。出于安全性的考虑和可扩展性故使用了网关来做。 涉及到的问题： 1、request的body数据流读取只能读取一次，co
SpringCloud-Gateway实现RSA加解密
孟孟的博客
04-08 3606
RSA主要使用大整数分解这个数学难题进行设计，巧妙地利用了数论的概念。给了RSA公钥，首先想到的攻击就是分解模数，给了的因子攻击者可以计算得到，从而也可以计算得到解密指数，我们称这种分解模数的方法为针对RSA的暴力攻击。虽然分解算法已经稳步改进，但是在正确使用RSA情况下，当前的技术水平仍远未对RSA的安全性构成威胁。RSA的公钥和私钥到底哪个才是用来加密和哪个用来解密？- 知乎。
Spring Cloud Gateway 2.1 实战指南：API路由与管理
"Spring Cloud Gateway 2.1 使用手册中文版详细介绍了如何在Spring生态系统上构建API网关，重点在于其作为API路由的功能以及提供的横切关注点，如安全、监控和弹性。该版本基于Spring Framework 5、Spring Boot 2和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值