如何从零实现属于自己的 API 网关？

最新推荐文章于 2024-09-18 20:48:11 发布
最新推荐文章于 2024-09-18 20:48:11 发布
阅读量364 收藏 4
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ryo1060732496/article/details/118916660
版权

序言

上一篇文章：你连对外接口签名都不会知道？有时间还是要学习学习。

有很多小伙伴反应，对外的 API 中相关的加签，验签这些工作可以统一使用网关去处理。

说到网关，大家肯定比较熟悉。市面上使用比较广泛的有：spring cloud/kong/soul。

网关

API 网关的作用

（1）对外接口中的权限校验

（2）口调用的次数限制，频率限制

（3）微服务网关中的负载均衡，缓存，路由，访问控制，服务代理，监控，日志等。

实现原理

在这里插入图片描述

一般的请求时直接通过 client 访问 server 端，我们需要在中间实现一层 api 网关，外部 client 访问 gateway，然后 gateway 进行调用的转发。

核心流程

网关听起来非常复杂，最核心的部分其实基于 Servlet 的 javax.servlet.Filter 进行实现。

我们让 client 调用网关，然后在 Filter 中统一对消息题进行解析转发，调用服务端后，再封装返回给 client。

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * @author binbin.hou
 * @since 1.0.0
 */
@WebFilter
@Component
public class GatewayFilter implements Filter {

    private static final Logger LOGGER = LoggerFactory.getLogger(GatewayFilter.class);

    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest servletRequest,
                         ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        LOGGER.info("url={}, params={}", req.getRequestURI(), JSON.toJSONString(req.getParameterMap()));

        //根据 URL 获取对应的服务名称

        // 进行具体的处理逻辑

        // TODO...

        } else {
            filterChain.doFilter(req, servletResponse);
        }
    }

    public void destroy() {

    }

}

接下来，我们只需要重点看一下如何重写 doFilter 方法即可。

具体实现

获取 appName

网关是面对公司内部所有应用的，我们可以通过每一个服务的唯一 appName 作为区分。

比如应用名称为 test，则调用网关的请求：

https://gateway.com/test/version

这个请求，对应的 appName 就是 test，实际请求的 url 是 /version。

具体实现也比较简单：

@Override
public Pair<String, String> getRequestPair(HttpServletRequest req) {
    final String url = req.getRequestURI();
    if(url.startsWith("/") && url.length() > 1) {
        String subUrl = url.substring(1);
        int nextSlash = subUrl.indexOf("/");
        if(nextSlash < 0) {
            LOGGER.warn("请求地址 {} 对应的 appName 不存在。", url);
            return Pair.of(null, null);
        }
        String appName = subUrl.substring(0, nextSlash);
        String realUrl = subUrl.substring(nextSlash);
        LOGGER.info("请求地址 {} 对应的 appName: {}, 真实请求地址：{}", url, appName, realUrl);
        return Pair.of(appName, realUrl);
    }
    LOGGER.warn("请求地址: {} 不是以 / 开头，或者长度不够 2，直接忽略。", url);
    return Pair.of(null, null);
}

请求头信息

根据 HttpServletRequest 构建出对应的请求头信息：

/**
 * 构建 map 信息
 * @param req 请求
 * @return 结果
 * @since 1.0.0
 */
private Map<String, String> buildHeaderMap(final HttpServletRequest req) {
    Map<String, String> map = new HashMap<>();
    Enumeration<String> enumeration = req.getHeaderNames();
    while (enumeration.hasMoreElements()) {
        String name = enumeration.nextElement();
        String value = req.getHeader(name);
        map.put(name, value);
    }
    return map;
}

服务发现

当我们解析出请求的应用时 appName = test 时，就可以去查询配置中心中 test 应用中对应的 ip:port 信息。

@Override
public String buildRequestUrl(Pair<String, String> pair) {
    String appName = pair.getValueOne();
    String appUrl = pair.getValueTwo();
    String ipPort = "127.0.0.1:8081";
    //TODO: 根据数据库配置查询
    // 根据是否启用 HTTPS 访问不同的地址
    if (appName.equals("test")) {
        // 这里需要涉及到负载均衡
        ipPort = "127.0.0.1:8081";
    } else {
        throw new GatewayServerException(GatewayServerRespCode.APP_NAME_NOT_FOUND_IP);
    }
    String format = "http://%s/%s";
    return String.format(format, ipPort, appUrl);
}

这里暂时固定写死，最后返回实际服务端的请求地址。

这里也可以结合具体的负载均衡/路由策略，做进一步的服务端选择。

不同 Method

HTTP 支持的方式是多样的，我们暂时支持一下 GET/POST 请求。

本质上就是针对 GET/POST 请求，构建形式的请求调用服务端。

这里的实现方式可以非常多样，此处以 ok-http 客户端为例作为实现。

接口定义

为了便于后期拓展，所有的 Method 调用，实现相同的接口：

public interface IMethodType {

    /**
     * 处理
     * @param context 上下文
     * @return 结果
     */
    IMethodTypeResult handle(final IMethodTypeContext context);

}

GET

GET 请求。

@Service
@MethodTypeRoute("GET")
public class GetMethodType implements IMethodType {

    @Override
    public IMethodTypeResult handle(IMethodTypeContext context) {
        String respBody = OkHttpUtil.get(context.url(), context.headerMap());
        return MethodTypeResult.newInstance().respJson(respBody);
    }

}

POST

POST 请求。

@Service
@MethodTypeRoute("POST")
public class PostMethodType implements IMethodType {

    @Override
    public IMethodTypeResult handle(IMethodTypeContext context) {
        HttpServletRequest req = (HttpServletRequest) context.servletRequest();
        String postJson = HttpUtil.getPostBody(req);
        String respBody = OkHttpUtil.post(context.url(), postJson, context.headerMap());

        return MethodTypeResult.newInstance().respJson(respBody);
    }

}

OkHttpUtil 实现

OkHttpUtil 是基于 ok-http 封装的 http 调用工具类。

import com.github.houbb.gateway.server.util.exception.GatewayServerException;
import com.github.houbb.heaven.util.util.MapUtil;
import okhttp3.*;

import java.io.IOException;
import java.util.Map;

/**
 * @author binbin.hou
 * @since 1.0.0
 */
public class OkHttpUtil {

    private static final MediaType JSON
            = MediaType.parse("application/json; charset=utf-8");

    /**
     * get 请求
     * @param url 地址
     * @return 结果
     * @since 1.0.0
     */
    public static String get(final String url) {
        return get(url, null);
    }

    /**
     * get 请求
     * @param url 地址
     * @param headerMap 请求头
     * @return 结果
     * @since 1.0.0
     */
    public static String get(final String url,
                             final Map<String, String> headerMap) {
        try {
            OkHttpClient client = new OkHttpClient();
            Request.Builder builder = new Request.Builder();
            builder.url(url);

            if(MapUtil.isNotEmpty(headerMap)) {
                for(Map.Entry<String, String> entry : headerMap.entrySet()) {
                    builder.header(entry.getKey(), entry.getValue());
                }
            }

            Request request = builder
                    .build();

            Response response = client.newCall(request).execute();
            return response.body().string();
        } catch (IOException e) {
            throw new GatewayServerException(e);
        }
    }

    /**
     * get 请求
     * @param url 地址
     * @param body 请求体
     * @param headerMap 请求头
     * @return 结果
     * @since 1.0.0
     */
    public static String post(final String url,
                              final RequestBody body,
                             final Map<String, String> headerMap) {
        try {
            OkHttpClient client = new OkHttpClient();
            Request.Builder builder = new Request.Builder();
            builder.post(body);
            builder.url(url);

            if(MapUtil.isNotEmpty(headerMap)) {
                for(Map.Entry<String, String> entry : headerMap.entrySet()) {
                    builder.header(entry.getKey(), entry.getValue());
                }
            }

            Request request = builder.build();
            Response response = client.newCall(request).execute();
            return response.body().string();
        } catch (IOException e) {
            throw new GatewayServerException(e);
        }
    }

    /**
     * get 请求
     * @param url 地址
     * @param bodyJson 请求体 JSON
     * @param headerMap 请求头
     * @return 结果
     * @since 1.0.0
     */
    public static String post(final String url,
                              final String bodyJson,
                              final Map<String, String> headerMap) {
        RequestBody body = RequestBody.create(JSON, bodyJson);
        return post(url, body, headerMap);
    }

}

调用结果处理

请求完服务端之后，我们需要对结果进行处理。

第一版的实现非常粗暴：

/**
 * 处理最后的结果
 * @param methodTypeResult 结果
 * @param servletResponse 响应
 * @since 1.0.0
 */
private void methodTypeResultHandle(final IMethodTypeResult methodTypeResult,
                                    final ServletResponse servletResponse) {
    try {
        final String respBody = methodTypeResult.respJson();
        // 重定向（因为网络安全等原因，这个方案应该被废弃。）
        // 这里可以重新定向，也可以通过 http client 进行请求。
        // GET/POST
        //获取字符输出流对象
        servletResponse.setCharacterEncoding("UTF-8");
        servletResponse.setContentType("text/html;charset=utf-8");
        servletResponse.getWriter().write(respBody);
    } catch (IOException e) {
        throw new GatewayServerException(e);
    }
}

完整实现

我们把上面的主要流程放在一起，完整的实现如下：

import com.alibaba.fastjson.JSON;
import com.github.houbb.gateway.server.util.exception.GatewayServerException;
import com.github.houbb.gateway.server.web.biz.IRequestAppBiz;
import com.github.houbb.gateway.server.web.method.IMethodType;
import com.github.houbb.gateway.server.web.method.IMethodTypeContext;
import com.github.houbb.gateway.server.web.method.IMethodTypeResult;
import com.github.houbb.gateway.server.web.method.impl.MethodHandlerContainer;
import com.github.houbb.gateway.server.web.method.impl.MethodTypeContext;
import com.github.houbb.heaven.support.tuple.impl.Pair;
import com.github.houbb.heaven.util.lang.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * 网关过滤器
 *
 * @author binbin.hou
 * @since 1.0.0
 */
@WebFilter
@Component
public class GatewayFilter implements Filter {

    private static final Logger LOGGER = LoggerFactory.getLogger(GatewayFilter.class);

    @Autowired
    private IRequestAppBiz requestAppBiz;

    @Autowired
    private MethodHandlerContainer methodHandlerContainer;

    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest servletRequest,
                         ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        LOGGER.info("url={}, params={}", req.getRequestURI(), JSON.toJSONString(req.getParameterMap()));

        //根据 URL 获取对应的服务名称
        Pair<String, String> pair = requestAppBiz.getRequestPair(req);
        Map<String, String> headerMap = buildHeaderMap(req);
        String appName = pair.getValueOne();
        if(StringUtil.isNotEmptyTrim(appName)) {
            String method = req.getMethod();

            String respBody = null;
            String url = requestAppBiz.buildRequestUrl(pair);

            //TODO: 其他方法的支持
            IMethodType methodType = methodHandlerContainer.getMethodType(method);

            IMethodTypeContext typeContext = MethodTypeContext.newInstance()
                    .methodType(method)
                    .url(url)
                    .servletRequest(servletRequest)
                    .servletResponse(servletResponse)
                    .headerMap(headerMap);

            // 执行前

            // 执行
            IMethodTypeResult methodTypeResult = methodType.handle(typeContext);

            // 执行后


            // 结果的处理
            this.methodTypeResultHandle(methodTypeResult, servletResponse);
        } else {
            filterChain.doFilter(req, servletResponse);
        }
    }

    public void destroy() {

    }


    /**
     * 处理最后的结果
     * @param methodTypeResult 结果
     * @param servletResponse 响应
     * @since 1.0.0
     */
    private void methodTypeResultHandle(final IMethodTypeResult methodTypeResult,
                                        final ServletResponse servletResponse) {
        try {
            final String respBody = methodTypeResult.respJson();

            // 重定向（因为网络安全等原因，这个方案应该被废弃。）
            // 这里可以重新定向，也可以通过 http client 进行请求。
            // GET/POST
            //获取字符输出流对象
            servletResponse.setCharacterEncoding("UTF-8");
            servletResponse.setContentType("text/html;charset=utf-8");
            servletResponse.getWriter().write(respBody);
        } catch (IOException e) {
            throw new GatewayServerException(e);
        }
    }

    /**
     * 构建 map 信息
     * @param req 请求
     * @return 结果
     * @since 1.0.0
     */
    private Map<String, String> buildHeaderMap(final HttpServletRequest req) {
        Map<String, String> map = new HashMap<>();

        Enumeration<String> enumeration = req.getHeaderNames();
        while (enumeration.hasMoreElements()) {
            String name = enumeration.nextElement();

            String value = req.getHeader(name);
            map.put(name, value);
        }
        return map;
    }

}

网关验证

网关应用

我们把拦截器加好以后，定义对应的 Application 如下：

@SpringBootApplication
@ServletComponentScan
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

然后把网关启动起来，启动端口号为 8080

服务端应用

然后启动服务端对应的服务，端口号为 8081。

查看版本号的控制器实现：

@RestController
public class MonitorController {

    @RequestMapping(value = "version", method = RequestMethod.GET)
    public String version() {
        return "1.0-demo";
    }

}

请求

我们在浏览器上直接访问 api 网关：

http://localhost:8080/test/version

页面返回：

1.0-demo

小结

API 网关实现的原理并不难，就是基于 servlet 对请求进行转发。

虽然看起来简单，但是可以在这个基础上实现更多强大的特性，比如限流，日志，监控等等。

如果你对 API 网关感兴趣的话，不妨关注一波，后续内容，更加精彩。

备注：涉及的代码较多，文中做了简化。如果你对全部源码感兴趣，可以關註【老马啸西风】，後臺回復【网关】即可获得。

我是老马，期待与你的下次重逢。
在这里插入图片描述

老马啸西风
关注
基于SpringCloud Gateway的API网关设计与实现
AI天才研究院
08-02 1344
随着互联网技术的飞速发展、软件架构的演进，越来越多的人开始意识到“边界服务”的重要性。越来越多的公司面临“如何快速响应用户需求”、“保证系统稳定运行”等诸多问题，为了应对这些挑战，微服务架构已经成为一个热门话题。但微服务架构带来的问题也很明显，不仅需要考虑分布式事务、服务治理、弹性伸缩、限流降级等诸多问题，还面临新旧服务版本兼容、服务拆分重组、跨域调用等复杂的技术难题，使得传统的SOA架构方案无法满足要求。
关于阿里终极面试问题：如何设计一个高性能网关？
Newerwu的专栏
02-01 387
一、前言 二、设计 2.1技术选型 2.2需求清单 2.3架构设计 2.4表结构设计 三、编码 四、测试 4.1动态路由测试 4.2性能压测 五、总结 一、前言 最近在github上看了soul网关的设计，突然就来了兴趣准备自己从零开始写一个高性能的网关。经过两周时间的开发，我的网关ship-gate核心功能基本都已完成，最大的缺陷就是前端功底太差没有管理后台..
第12期实录：从零开始实现一个API网关——得到网关实践经验
weixin_45189747的博客
08-28 631
“大家好，我是得到API网关的负责人闫勃，我是15年毕业加入的罗辑思维，当时是在我们的生活作风团队，主要是做电商业务和商城异步任务调度系统。后来，经过两年的工作可能是觉得更喜欢研究底层技术吧，所以当网关项目启动的时候就申请调到了网关这面。今天我给大家分享的就是如何从零研发一款高性能的API网关。 我今天分享的内容主要分为两部分，第一部分就是给大家介绍下我们的网关，从起源到实现。第二部分就是分享一些...
构建游戏 API 网关：从设计到实现
最新发布
m0_57836225的博客
09-18 781
通过以上的步骤，我们成功地构建了一个游戏 API 网关。这个 API 网关具有统一接口、可扩展性、安全性和性能优化等特点，可以为游戏项目提供高效、稳定的服务。同时，我们还使用了 OpenAPI 规范和相关工具来生成代码，提高了开发效率和代码质量。在实际项目中，我们可以根据具体需求进一步扩展和优化这个 API 网关，例如添加更多的功能和服务、优化性能、提高安全性等。同时，我们也可以使用其他工具和技术来进一步提高开发效率和代码质量，例如使用持续集成和持续部署（CI/CD）工具来自动化构建、测试和部署过程。
微服务 API 网关如何建设
weixin_57763462的博客
07-12 133
随着这些年微服务的流行，API网关已经成为微服务架构中不可或缺的一环。一方面它承担着服务对外的唯一门户，一方面它提取了许多应用的共性功能。 整体架构我们的Api网关目前的架构如上所示，可以看到Api网关处于一个什么位置，往上承接所有的南北流量，往下会分发流量到微服务应用或者BFF聚合应用，在BFF规范化之前我们仍然将其视为一个普通微服务应用。目前Api网关实现的功能包括请求分发、条件路由、Api管理、限流隔离、熔断降级、安全策略、监控报警以及调用链追踪等。图片我们的Api网关基于RxNetty开发，整个流程
API 网关
AlbenXie的博客
05-08 454
前言 假设你正在开发一个电商网站，那么这里会涉及到很多后端的微服务，比如会员、商品、推荐服务等等。 那么这里就会遇到一个问题，APP/Browser 怎么去访问这些后端的服务？如果业务比较简单的话，可以给每个业务都分配一个独立的域名(https://service.api.company.com)，但这种方式会有几个问题： 每个业务都会需要鉴权、限流、权限校验等逻辑，如果每个业务都各自为战，自己造轮子实现一遍，会很蛋疼，完全可以抽出来，放到一个统一的地方去做。 如果业务量比较简单的话，这种方式前期不会
业务基础环境搭建及api网关
taojin12的博客
05-31 337
API网关 在微服务架构中，通常会有多个服务提供者。设想一个电商系统，可能会有商品、订单、支付、用户等多个类型的服务，而每个类型的服务也会随着整个系统体量的增大也会随之增长和变更。作为UI端，在展示页面时，可能需要从多个微服务中聚合数据，而且服务的划分位置结构可能会有所改变。网关就可以对外暴露聚合API， 屏蔽内部微服务的微小变动，保持整个系统的稳定性。 api网关有点类似于设计模式中的facade（外观）模式。 api网关一般都是微服务系统中的门面。 api网关是微服务中的重要组成部门。 API网关的
从零开始，设计一个高性能 API 网关
Java搜索工程技术栈
05-26 1375
一、前言 最近在 github 上看了 soul 网关的设计，突然就来了兴趣准备自己从零开始写一个高性能的网关。经过两周时间的开发，我的网关 ship-gate 核心功能基本都已完成，最大的缺陷就是前端功底太差没有管理后台 😤。 二、设计 2.1 技术选型 网关是所有请求的入口，所以要求有很高的吞吐量，为了实现这点可以使用请求异步化来解决。目前一般有以下两种方案： Tomcat/Jetty+NIO+Servlet3 Servlet3 已经支持异步，这种方案使用比较多，京东，有赞和 Zuul
为什么说 Apache APISIX 是最好的 API 网关？
ApacheAPISIX的博客
09-16 2173
本文从工程师、开源协议、性能评测、技术、生态系统等多个角度分析和比较了一些 API 网关产品，可以看出 Apache APISIX 是其中的佼佼者，引领了 API 网关领域的创新。Apache APISIX 不仅是一个可以处理南北向流量的 API 网关，同时也有 APISIX Ingress Controller、Service Mesh 等开源产品。预计在本月底，APISIX 也将发布 3.0 预览版，带来全新功能与全方位产品提升，敬请期待！
python 微服务 网关_微服务中的 API 网关（API Gateway）
weixin_31119449的博客
01-13 1694
我们知道在微服务架构风格中，一个大应用被拆分成为了多个小的服务系统提供出来，这些小的系统他们可以自成体系，也就是说这些小系统可以拥有自己的数据库，框架甚至语言等，这些小系统通常以提供 Rest Api 风格的接口来被 H5, Android, IOS 以及第三方应用程序调用。但是在UI上进行展示的时候，我们通常需要在一个界面上展示很多数据，这些数据可能来自于不同的微服务中，举个例子。在一个电商系统...
架构设计（4）--API网关
热门推荐
黄规速博客:学如逆水行舟，不进则退
01-24 2万+
1、前言 所在公司目前接入层是阿里云的SLB，然后经过Nginx+Lua转发到后端服务（Lua主要是限流）。 随着业务的发展，发现nginx配置越来越复杂，但又没有统一的管理，于是把Nginx这层改造成基于OpenResty的Nginx应用的API Gateway。于是上网总结和梳理网关相关知识。 问题: 由于我们使用的服务系统架构，所以没办法像传统单体应用一
自建API网关-架构设计篇
wayne_sulong的专栏
03-28 9013
阅读对象传统企业正在做微服务架构转型的开发人员或者架构师，希望本文对您能起到一定的引导作用。API网关介绍网关一词较早出现在网络设备里面，比如两个相互独立的局域网段之间通过路由器或者桥接设备进行通信，这中间的路由或者桥接设备我们称之为网关。相应的API网关将各系统对外暴露的服务聚合起来，所有要调用这些服务的系统都需要通过API网关进行访问，基于这种方式网关可以对API进行统一管控，例如：认证、鉴权...
AS400 API 从零到一的整个历程
weixin_41447442的博客
06-29 1427
简单的分享，如果有不一样的见解可以一起讨论1）AS400上安装对应的577ODG1 这个软件如果你不知道有没有装，你可以通过GO LICPGM 这个命令，10 去看到哪些安装的软件怎么安装具体如下：1. To install the libraries, run the command 2. Select option 11 to install a Licensed Program and install option 39如果发现有IBM HTTP Server For I2）启动 HTTP 服务，这是
使用API网关构建微服务
weixin_33859504的博客
09-27 189
使用传统的异步回调方法编写API组合代码会让你迅速坠入回调地狱。代码会变得混乱、难以理解且容易出错。一个更好的方法是使用响应式方法以一种声明式样式编写API网关代码。响应式抽象概念的例子有Scala中的Future、Java 8中的CompletableFuture和JavaScript中的Promise，还有最初是微软为.NET平台开发的Reactive Extensions（RX）。Ne...
浅析如何设计一个亿级网关
lizhao007
10-31 1006
1.背景1.1 什么是API网关API网关可以看做系统与外界联通的入口，我们可以在网关进行处理一些非业务逻辑的逻辑，比如权限验证，监控，缓存，请求路由等等。1.2 为什么...
自研API网关实践之路
gaoliang1719的专栏
09-03 753
一业务背景老网关使用 Spring Cloud Gateway （下称SCG）技术框架搭建，SCG基于webflux 编程范式，webflux是一种响应式编程理念，响应式编程对于提升系统吞吐率和性能有很大帮助; webflux 的底层构建在netty之上性能表现优秀；SCG属于spring生态的产物，具备开箱即用的特点，以较低的使用成本助力得物早期的业务快速发展；但是随着公司业务的快速发展，流量...
如何手撕一个API 网关（API Gateway）？
勿忘初心
05-15 1万+
一、什么是API Gateway 一个比较普遍的定义如下： API网关是一个服务器，是系统的唯一入口。从面向对象设计的角度看，它与外观模式类似。API网关封装了系统内部架构，为每个客户端提供一个定制的API。 API网关方式的核心要点是，所有的客户端和消费端都通过统一的网关接入微服务，在网关层处理所有的非业务功能。通常，网关也是提供REST/HTTP的访问API。服务端通过API-GW注册和管理...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值