Http客户端工具类

已于 2024-10-10 15:02:21 修改
阅读量247 收藏 3
点赞数 7
分类专栏： Java工具代码库 文章标签： http
于 2024-10-10 13:51:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/code_nn/article/details/142819501
版权

参考文章：
https://www.baeldung.com/guide-to-okhttp
https://www.baeldung.com/rest-template

一、第三方工具类

1.1 OkHttp

OkHttp 是一个高效的 HTTP 客户端，它被广泛用于 Android 和 Java 应用程序中以发送网络请求。

添加依赖：

<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>okhttp</artifactId>
  <version>4.12.0</version>
</dependency>

1.1.1 Get 请求

import okhttp3.*;
import java.io.IOException;

public class OkHttpGetExample {
    private final OkHttpClient okHttpClient;

     // RequestHeaders 、RequestParams 就是一个Map的封装类 
     public <T> T executeGetRequest(String url, RequestHeaders headers, RequestParams params, Class<T> responseType) {
        HttpUrl.Builder urlBuilder = HttpUrl.parse(url).newBuilder();
        if (params != null) {
            for (Map.Entry<String, Object> entry : params.getParams().entrySet()) {
                urlBuilder.addQueryParameter(entry.getKey(), entry.getValue().toString());
            }
        }

        Request.Builder requestBuilder = new Request.Builder()
                .url(urlBuilder.build());

        if (headers != null) {
            requestBuilder.headers(Headers.of(headers.getHeaders()));
        }

        Request request = requestBuilder.build();

        try (Response response = okHttpClient.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new HttpClientException("请求失败: " + response.code(),null);
            }
            String responseBody = response.body().string();
            return parseResponse(responseBody, responseType);
        } catch (IOException e) {
            throw new HttpClientException("请求失败: " + e.getMessage(),e);
        }
    }

    public void get(String url, RequestHeaders headers, RequestParams params, Callback callback) {
        Request request = new Request.Builder()
                .url(buildUrlWithParams(url, params))
                .headers(Headers.of(headers.getHeaders()))
                .build();
        // 异步请求
        client.newCall(request).enqueue(callback);
    }
    
}

1.1.2 Post 请求

import okhttp3.*;

public class OkHttpPostExample {
    private final OkHttpClient okHttpClient;
    
    public <T> T executePostJsonRequest(String url, RequestHeaders headers, String requestBody, Class<T> responseType) {
        RequestBody body = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), requestBody);
        Request.Builder requestBuilder = new Request.Builder()
                .url(url)
                .post(body);

        if (headers != null) {
            requestBuilder.headers(Headers.of(headers.getHeaders()));
        }

        Request request = requestBuilder.build();

        try (Response response = okHttpClient.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new HttpClientException("请求失败: " + response.code(),null);
            }
            String responseBody = response.body().string();
            return parseResponse(responseBody, responseType);
        } catch (IOException e) {
            throw new HttpClientException("请求失败: " + e.getMessage(),e);
        }
    }


    public <T> T executePostFormRequest(String url, RequestHeaders headers, RequestParams formData, Class<T> responseType) {
        FormBody.Builder formBodyBuilder = new FormBody.Builder();
        if (formData != null) {
            for (Map.Entry<String, Object> entry : formData.getParams().entrySet()) {
                formBodyBuilder.add(entry.getKey(), entry.getValue().toString());
            }
        }
        RequestBody body = formBodyBuilder.build();
        Request.Builder requestBuilder = new Request.Builder()
                .url(url)
                .post(body);

        if (headers != null) {
            requestBuilder.headers(Headers.of(headers.getHeaders()));
        }

        Request request = requestBuilder.build();

        try (Response response = okHttpClient.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new HttpClientException("请求失败: " + response.code(),null);
            }
            String responseBody = response.body().string();
            return parseResponse(responseBody, responseType);
        } catch (IOException e) {
            throw new HttpClientException("请求失败: " + e.getMessage(),e);
        }
    }


    public void postJson(String url, RequestHeaders headers, String requestBody, Callback callback) {
        RequestBody body = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), requestBody);
        Request request = new Request.Builder()
                .url(url)
                .headers(Headers.of(headers.getHeaders()))
                .post(body)
                .build();
        // 异步
        client.newCall(request).enqueue(callback);
    }


    public void postForm(String url, RequestParams formData, Callback callback) {
        FormBody.Builder formBuilder = new FormBody.Builder();
        for (Map.Entry<String, Object> entry : formData.getParams().entrySet()) {
            formBuilder.add(entry.getKey(), entry.getValue().toString());
        }
        RequestBody body = formBuilder.build();
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();
        client.newCall(request).enqueue(callback);
    }

}

1.2 RestTemplate

RestTemplate 是 Spring 框架中用于发送 HTTP 请求的类。

1.2.1 Get 请求

public class RestTemplateGetExample {

    public void doGet() {
         RestTemplate restTemplate = new RestTemplate();

        // 设置请求头
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer token_value");
        headers.set("Custom-Header", "CustomValue");

        // 构建 HttpEntity，用于发送包含请求头的信息
        HttpEntity<String> entity = new HttpEntity<>(headers);

        // 发送 GET 请求，获取响应
        String url = "https://api.example.com/data";
        ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, entity, String.class);

        // 打印响应结果
        System.out.println(response.getBody());
    }


    public void doGetAsync() {
        WebClient webClient = WebClient.builder()
                .baseUrl("https://api.example.com")
                .defaultHeader("Authorization", "Bearer token_value")
                .build();

        // 异步 GET 请求
        Mono<String> responseMono = webClient.get()
                .uri("/data")
                .retrieve()
                .bodyToMono(String.class);

        // 处理异步响应
        responseMono.subscribe(response -> {
            System.out.println("Response: " + response);
        });

        // 阻塞调用 - 仅用于演示，如果需要同步执行结果
        String response = responseMono.block();
        System.out.println("Synchronous response: " + response);
    }

}

1.2.2 Post请求

public class RestTemplatePostExample {

    public void doPost() {
        RestTemplate restTemplate = new RestTemplate();

        // 设置请求头
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("Authorization", "Bearer token_value");

        // 创建请求体
        Map<String, String> requestBody = new HashMap<>();
        requestBody.put("username", "john");
        requestBody.put("password", "secret");

        // 构建 HttpEntity，包含请求头和请求体
        HttpEntity<Map<String, String>> entity = new HttpEntity<>(requestBody, headers);

        // 发送 POST 请求，获取响应
        String url = "https://api.example.com/login";
        ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, entity, String.class);

        // 打印响应结果
        System.out.println(response.getBody());
    }
}

1.3 Fegin

Feign 是一个声明式的 HTTP 客户端，提供了一种简洁的方式来调用 REST API，它通过注解定义接口的方法映射到远程 HTTP 请求上。Feign 的主要优点是集成了 Spring Cloud 和 Ribbon，方便实现负载均衡、自动重试等功能。

添加依赖

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

开启 Feign 客户端

@SpringBootApplication
@EnableFeignClients
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

接口定义

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "userService", url = "https://api.example.com")
public interface UserClient {

    @GetMapping("/api/users/{id}")
    User getUserById(@PathVariable("id") Long id);

    @PostMapping("/api/users")
    User createUser(@RequestBody User user);

    @GetMapping("/api/users/{id}")
    User getUserById(@PathVariable("id") Long id, @RequestHeader("Authorization") String token);
}

● @FeignClient：声明这是一个 Feign 客户端，name 是客户端的名称，url 是远程服务的 URL。可以将 url 设置为动态的配置项。
● @GetMapping：指定 HTTP 请求类型，类似于 Spring MVC 的注解。
● @PathVariable：指定路径变量。

二、自定义封装

项目开发，统一调用方式。

2.1静态方法方案（不推荐）

public class HttpUtil {

     public static <T> T get(String url, Map<String, String> headers, Map<String, String> params, Class<T> responseType) throws IOException {
        //实现
     }
}

2.2 通用接口设计方案

静态方法更进一步的设计方案。面向 接口开发，隐藏实现细节，更易维护。
可以使用 Builder 模式 封装请求参数、请求头。
利用 重载 可以设计更多的接口满足业务需求。
但是维护起来还是比较麻烦的，方法太多了。

同步调用接口

package com.github.nan.http;

import com.github.nan.http.dto.RequestHeaders;
import com.github.nan.http.dto.RequestParams;

/**
 * 同步http客户端
 *
 * 如果请求没有返回结果，responseType 建议使用 Void.class
 *
 * @author NanNan Wang
 */
public interface SyncHttpClient {

    /**
     * 发起一个简单的 GET 请求。
     *
     * @param url 请求的 URL 地址
     * @param responseType 返回的结果类型
     * @param <T> 泛型类型
     * @return 请求的结果，类型为 T
     */
    <T> T get(String url, Class<T> responseType);

    /**
     * 发起一个带有参数的 GET 请求。
     *
     * @param url 请求的 URL 地址
     * @param params 请求的参数
     * @param responseType 返回的结果类型
     * @param <T> 泛型类型
     * @return 请求的结果，类型为 T
     */
    <T> T get(String url, RequestParams params, Class<T> responseType);

    /**
     * 发起一个带有头部的 GET 请求。
     * @param url 请求的 URL 地址
     * @param headers 请求的头部信息
     * @param responseType 返回的结果类型
     * @return 泛型类型
     * @param <T> 请求的结果，类型为 T
     */
    <T> T get(String url, RequestHeaders headers, Class<T> responseType);


    /**
     * 发起一个带有头部和参数的 GET 请求。
     *
     * @param url 请求的 URL 地址
     * @param headers 请求的头部信息
     * @param params 请求的参数
     * @param responseType 返回的结果类型
     * @param <T> 泛型类型
     * @return 请求的结果，类型为 T
     */
    <T> T get(String url, RequestHeaders headers,  RequestParams params, Class<T> responseType);

    /**
     * 发起一个带有 JSON 请求参数的 POST 请求。
     *
     * @param url 请求的 URL 地址
     * @param requestBody JSON 请求体
     * @param responseType 返回的结果类型
     * @param <T> 泛型类型
     * @return 请求的结果，类型为 T
     */
    <T> T postJson(String url, String requestBody, Class<T> responseType);



    /**
     * 发起一个带有 JSON 请求参数的 POST 请求。
     *
     * @param url 请求的 URL 地址
     * @param headers 请求的头部信息
     * @param requestBody JSON 请求体
     * @param responseType 返回的结果类型
     * @param <T> 泛型类型
     * @return 请求的结果，类型为 T
     */
    <T> T postJson(String url, RequestHeaders headers, String requestBody, Class<T> responseType);


    /**
     * 发起一个带有表单数据的 POST 请求。
     *
     * @param url 请求的 URL 地址
     * @param formData 表单数据
     * @param responseType 返回的结果类型
     * @param <T> 泛型类型
     * @return 请求的结果，类型为 T
     */
    <T> T postForm(String url, RequestParams formData, Class<T> responseType);

    /**
     * 发起一个带有表单数据的 POST 请求。
     *
     * @param url 请求的 URL 地址
     * @param headers 请求的头部信息
     * @param formData 表单数据
     * @param responseType 返回的结果类型
     * @param <T> 泛型类型
     * @return 请求的结果，类型为 T
     */
    <T> T postForm(String url, RequestHeaders headers, RequestParams formData, Class<T> responseType);


}

异步调用接口

/**
 * 异步http客户端
 *
 * @author NanNan Wang
 */
public interface AsyncHttpClient {

    /**
     * 发起异步 GET 请求。
     *
     * @param url 请求 URL
     * @param callback 回调函数
     */
    void get(String url, Callback callback);

    /**
     * 发起一个带有头部的 GET 请求。
     *
     * @param url 请求的 URL 地址
     * @param headers 请求的头部信息
     * @param callback 回调函数
     */
    void get(String url, RequestHeaders headers, Callback callback);



    /**
     * 发起一个带有参数的 GET 请求。
     *
     * @param url 请求的 URL 地址
     * @param params 请求的参数
     * @param callback 回调函数
     */
    void get(String url, RequestParams params,  Callback callback);


    /**
     * 发起一个带有头部和参数的 GET 请求。
     *
     * @param url 请求的 URL 地址
     * @param headers 请求的头部信息
     * @param params 请求的参数
     * @param callback 回调函数
     */
    void get(String url, RequestHeaders headers, RequestParams params, Callback callback);


    /**
     * 发起一个带有 JSON 请求参数的 POST 请求。
     *
     * @param url 请求的 URL 地址
     * @param requestBody JSON 请求体
     * @param callback 回调函数
     */
    void postJson(String url, String requestBody, Callback callback);

    /**
     * 发起一个带有 JSON 请求参数和头部信息的 POST 请求。
     *
     * @param url 请求的 URL 地址
     * @param headers 请求的头部信息
     * @param requestBody JSON 请求体
     * @param callback 回调函数
     */
    void postJson(String url, RequestHeaders headers, String requestBody, Callback callback);

    /**
     * 发起一个带有表单数据的 POST 请求。
     *
     * @param url 请求的 URL 地址
     * @param formData 表单数据
     * @param callback 回调函数
     */
    void postForm(String url, RequestParams formData, Callback callback);

    /**
     * 发起一个带有表单数据和头部信息的 POST 请求。
     *
     * @param url 请求的 URL 地址
     * @param headers 请求的头部信息
     * @param formData 表单数据
     * @param callback 回调函数
     */
    void postForm(String url, RequestHeaders headers, RequestParams formData, Callback callback);

}

2.3 链式客户端

在第二个方案上进一步优化，模仿 Stream ，设计一个链式调用接口。
更易维护和使用。

public interface HttpClient {

    // 设置URL
    HttpClient url(String url);

    // 指定请求方法，为了代码可读性，建议调用时显示声明
    HttpClient method(HttpMethod method);

    // 添加请求头
    HttpClient addHeader(Map<String, String> headers);

    // 添加请求头
    HttpClient addHeader(String key, String value);

    // 设置请求参数（适用于 GET 请求）
    HttpClient queryParam(String key, String value);

    // 设置JSON请求体（适用于 POST、PUT 等请求）
    HttpClient jsonBody(String json);

    // 设置Form表单请求体
    HttpClient formBody(Map<String, String> formData);

    // 设置Form表单请求参数
    HttpClient formBody(String key, String value);

    // 执行请求
    <T> T execute(Class<T> responseType);

    // 异步请求执行，带有回调
    <T> void executeAsync(Class<T> responseType, Callback<T> callback);

    // 回调接口
    interface Callback<T> {
        void onSuccess(T response);
        void onFailure(Exception e);
    }
}

使用参考

public class Demo {
    private HttpClient client = new DefaultHttpClient();
    
    public void doGet() {
        String response = client.url("https://api.example.com/data")
                        .method(HttpMethod.GET)
                        .addHeader("Authorization", "Bearer token_value")
                        .queryParam("filter", "active")
                        .execute(String.class);

        System.out.println("Response: " + response);
    }

    public void doPost() {
        String jsonRequestBody = "{\"name\": \"John\", \"age\": 30}";
        String response = client.url("https://api.example.com/users")
                                .method(HttpMethod.POST)
                                .addHeader("Content-Type", "application/json")
                                .jsonBody(jsonRequestBody)
                                .execute(String.class);
        
        System.out.println("Response: " + response);  
    }

    public void doGetAsync() {
        client.url("https://api.example.com/users")
              .method(HttpMethod.GET)
              .addHeader("Authorization", "Bearer token_value")
              .executeAsync(String.class, new HttpClient.Callback<String>() {
                  @Override
                  public void onSuccess(String response) {
                      System.out.println("Async Response: " + response);
                  }
        
                  @Override
                  public void onFailure(Exception e) {
                      System.err.println("Request failed: " + e.getMessage());
                  }
              });
    }
}

具体实现类可以参考：
https://github.com/BJ-wnn/nanHub

South_BJ
关注
专栏目录
http客户端工具类 - 含完整代码及内部解析
.
12-04 1万+
文章目录Http客户端工具用途及分析完整的代码段结束 Http客户端工具 文章目录 Maven打包Jar + Http向Url发送Get请求_lijiamin-的CSDN博客 前段时间，我写了一个非常简陋的Get请求的代码用于刷CSDN的访客量，但是那个玩意并不能用于实际工作中，因为它里面并没有包含什么其他的参数，只是简简单单的发起请求，但是在这几天的工作中，我有幸接触到了这篇代码，现将它刨析一番并分享给大家 用途及分析 顾名思义，是一个HTTP客户端工具，能通过代码方式发起get、po
Hutool Http客户端工具类-HttpUtil使用
热门推荐
旭东怪的博客
02-18 3万+
HttpUtil是应对简单场景下Http请求的工具类封装，这个工具类可以保证在一个方法之内完成Http请求。 1HttpUtil.get() 用于请求普通页面，然后返回页面内容的字符串，同时提供一些重载方法用于指定请求参数。 // 最简单的HTTP请求，可以自动通过header等信息判断编码，不区分HTTP和HTTPS String result1= HttpUtil.get("https://www.baidu.com"); // 当无法识别页面编码的时候，可以自定义请求页面的编码 Strin.
Hutool简介及http客户端工具类
zhang2312600_a的博客
10-27 1726
Hutool简介及http客户端工具类
Http客户端工具类-HttpUtil
Hningning的博客
11-27 5432
Http客户端工具类-HttpUtil 概述 HttpUtil是应对简单场景下Http请求的工具类封装，此工具封装了HttpRequest对象常用操作，可以保证在一个方法之内完成Http请求。 此模块基于JDK的HttpUrlConnection封装完成，完整支持https、代理和文件上传。 使用 请求普通页面 针对最为常用的GET和POST请求，HttpUtil封装了两个方法， H...
Java中的HTTP客户端工具——RestTemplate
意识流的博客
09-27 5237
Java中的HTTP客户端工具——RestTemplate
HTTP客户端工具该选哪个？进来看
javajavajava
12-27 975
HTTP（超文本传输协议）是一种应用层协议，用于客户端和服务端进行通信，按照标准格式如JSON、XML等进行网络数据的传输，通常也作为应用程序之间以RESTAPI形式进行通信的常用协议。在Java应用中需要调用其他应用提供的HTTP服务API时，通常需要使用一些HTTP客户端组件。而可选择的HTTP客户端有很多，本期内容主要介绍在Java应用程序中可以使用的HTTP客户端工具。Java 11+版本中提供的HttpClientApache HttpComponents项目中的HttpClient。
java 获取客户端真实IP工具类
rocky的编程随记
06-19 1085
随着nginx等工具兴起，单纯采用 HttpServletRequest.getRemoteHost()已经不能获取客户端的真实IP。以下是一个Java获取客户端真实IP工具类。 import javax.servlet.http.HttpServletRequest; public class RequestUtil { public static String getRealIp(...
【工具类】Elasticsearch的HTTP客户端（Java）
dreambyday
12-27 838
Java基于Http请求操作ES，与Kibana上的操作一致。如图该DSL可转化为HTTP请求。
Qt项目实战4：http客户端工具
Charles的博客
03-21 4316
文章目录qhttpc功能实现http请求http回复http同步接收数据http用户认证界面设计 qhttpc功能实现 支持通过URL访问http服务器 支持选择GET、POST、PUT、DELETE、HEAD等请求方式 支持在URL后追加query字段 支持追加PUT/POST body数据 支持显示接收回复body数据 支持显示接收回复头数据 http请求 在.pro文件中增加网络组件支持...
java http 客户端_HTTP 客户端性能大比拼
weixin_30413679的博客
02-12 1224
Http客户端调用目前应用很普遍，无论是分布式系统，或安卓等移动手机或开放API调用等，哪种客户端调用性能最快呢？该文比较了目前大部分如下客户端库包：1. Apache httpcomponents-client4.2.5Java IOJava语言2. Apache commons-httpclient (discontinued)3.1Java IOJava语言3. Apache HttpAsy...
Http客户端工具类.txt
07-05
Http客户端工具类中包含了多种请求方式、多种参数类型的客户端请求方式的方法实现
HTTP请求客户端工具类RestTemplateUtil.java
06-09
org.springframework.web.client.AsyncRestTemplate org.springframework.web.client.RestTemplate HTTP请求工具类，基于以上两个Rest请求工具模板完成封装HTTP请求，包括同步和异步请求的实现。
http请求工具类及相关jar包
05-29
4. **HttpClient类**：Apache HttpClient是一个强大的HTTP客户端库，提供了更高级的功能，如重试策略、连接池管理、多线程请求等。它是许多Java应用处理HTTP请求的首选工具。 5. **工具类的设计**：这个“http请求...
模仿postman自研的HTTP Client Chrome插件，可绕过浏览器同源政策发起跨域请求
学无止境！
10-06 805
带着半信半疑的心态，首先我找到官方文档仔细阅读后，然后按照官方文档上的教程写了一个demo，运行后发现果然可以绕过浏览器同源政策发起跨域请求并自动携带cookie，基于这一核心能力自己也实现了一个模仿postman的HTTP Client chrome插件，既可以满足工作需要，又能提升自己的技术。综上所述，目前还没有一个十全十美的方法，于是我又调研了一下chrome插件（chrome扩展）是否有发起跨域请求的能力。第二步，打开扩展主窗口，输入框中填写请求信息，发起请求。对应的就是该窗口的html文件，
（接口测试）day01接口测试理论 http理论 接口测试流程 接口文档解析
最新发布
2301_79144798的博客
10-09 429
接口：相当于开了一个通道 当服务器要给客户端响应数据的时候，还是会利用这个通道，将数据传递回去。上面的接口：提供数据的流入和流出。USB（文件通信协议）
网络协议 TCP、UDP 和 HTTP
m0_68570169的博客
09-27 2123
特性TCPUDP连接方式面向连接（三次握手）无连接可靠性可靠（确认、重传、校验、排序）不可靠（不确认、不重传、不排序）传输顺序保证顺序到达不保证顺序流量控制有无拥塞控制有无头部开销较大较小速度较慢（但可靠）较快（但不可靠）典型应用场景DNS、视频会议、在线游戏TCP和UDP各有优劣，选择使用哪种协议取决于具体的应用需求。如果需要数据可靠性和顺序性，TCP是更好的选择；如果对传输速度和实时性要求高，且能容忍部分数据丢失，则UDP更为适合。特性。
详情说明HTTP/2和HTTP/3两者间的区别
Licky13的博客
10-09 635
HTTP/3与HTTP/2是互联网协议的两个重要版本，它们在性能和设计上存在显著区别。 HTTP/3在传输方式、多路复用、首部压缩、连接管理以及性能与安全性方面相比HTTP/2都有显著的提升
考虑P2G和碳捕集设备的热电联供综合能源系统优化调度模型（Matlab代码实现）.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
可提高超声成像系统在时间延迟多普勒参数方面的分辨率 matlab代码.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值