springboot Okhttp3.0 http请求调用

最新推荐文章于 2025-09-11 21:30:00 发布
原创 最新推荐文章于 2025-09-11 21:30:00 发布 · 5k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了一个基于OkHttp的实用工具类，涵盖SSL配置、连接池管理、多种HTTP请求方式及文件上传功能，同时提供了丰富的示例代码，帮助开发者快速掌握OkHttp的高级应用。 
package com.lenovo.nb.platform.api.utils;


import com.lenovo.nb.platform.api.config.NbTokenInterceptor;
import com.lenovo.nb.platform.api.huawei.DefaultHostnameVerifier;
import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ResourceUtils;

import javax.net.ssl.*;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.KeyStore;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class OkHttpClientUtil {

    private static final MediaType MEDIA_TYPE_JSON = MediaType.parse("application/json; charset=utf-8");
    private static  String SELFCERTPATH = null;
    @Value("${nb.secret.selfcertpath}")
    public void setSelfcertpath(String selfcertpath) {
        SELFCERTPATH = selfcertpath;
    }
    private static  String TRUSTCAPATH = null;
    @Value("${nb.secret.trustcapath}")
    public void setTrustcapath(String trustcapath) {
        TRUSTCAPATH = trustcapath;
    }
    private static  String SELFCERTPWD = null;
    @Value("${nb.secret.selfcertpwd}")
    public void setSelfcertpwd(String selfcertpwd) {
        SELFCERTPWD = selfcertpwd;
    }
    private static  String TRUSTCAPWD = null;
    @Value("${nb.secret.trustcapwd}")
    public void setTrustcapwd(String trustcapwd) {
        TRUSTCAPWD = trustcapwd;
    }



    /**
     * 获取okHttpClient
     *
     * @return
     */
    private static OkHttpClient getOkHttpClient(){
        return new OkHttpClient.Builder()
                .sslSocketFactory(getSslSocketFactory(), getX509TrustManager())
                .hostnameVerifier(new DefaultHostnameVerifier())
                .retryOnConnectionFailure(false)//是否开启缓存
                .connectionPool(getConnectionPool())
                .connectTimeout(5000, TimeUnit.MILLISECONDS)
                .readTimeout(5000, TimeUnit.MILLISECONDS)
                .writeTimeout(5000, TimeUnit.MILLISECONDS)
                .addInterceptor(new NbTokenInterceptor())//拦截器
                .build();
    }

    private static X509TrustManager getX509TrustManager() {
        return new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
            }
            @Override
            public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
            }
            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[0];
            }
        };
    }

    private static SSLSocketFactory getSslSocketFactory() {
        SSLSocketFactory ssl = null;
        try {
            System.out.println(ResourceUtils.getURL("classpath:").getPath());


            ClassPathResource selfcertPath = new ClassPathResource(SELFCERTPATH);
            ClassPathResource trustcaPath = new ClassPathResource(TRUSTCAPATH);
            KeyStore selfCert = KeyStore.getInstance("pkcs12");
            selfCert.load(selfcertPath.getInputStream(), SELFCERTPWD.toCharArray());
            KeyManagerFactory kmf = KeyManagerFactory.getInstance("sunx509");
            kmf.init(selfCert, SELFCERTPWD.toCharArray());

            // 导入CA证书
            KeyStore caCert = KeyStore.getInstance("jks");
            caCert.load(trustcaPath.getInputStream(), TRUSTCAPWD.toCharArray());
            TrustManagerFactory tmf = TrustManagerFactory.getInstance("sunx509");
            tmf.init(caCert);

            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
            ssl = sc.getSocketFactory();

        }catch (Exception e){
            e.printStackTrace();
        }

        return ssl;
    }

    private static ConnectionPool getConnectionPool() {
        /**
         * maxIdleConnections 连接池中整体的空闲连接的最大数量
         * keepAliveDuration 连接空闲时间最多为五分钟
         */
        return new ConnectionPool(500, 5, TimeUnit.MINUTES);
    }

    /**
     * 执行同步Get请求
     */
    public static Response executeGet(String url, Map<String, String> headers) throws IOException {
        //构建请求
        Request.Builder requestBuilder = new Request.Builder().url(url);
        //构造请求头
        if(!CollectionUtils.isEmpty(headers)){
            for (Map.Entry<String, String> mapEntry : headers.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBuilder.addHeader(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //构建请求
        Request request = requestBuilder.build();
        //获取client
        OkHttpClient okHttpClient = getOkHttpClient();
        //执行
        Response response = okHttpClient.newCall(request).execute();

        return response;
    }

    /**
     * 执行异步Get请求
     *
     * @param url  请求路径
     * @param headers  请求头
     * @param callback  回调方法
     * @throws IOException
     */
    public static void enqueueGet(String url, Map<String, String> headers, Callback callback) throws IOException {
        //构建请求
        Request.Builder requestBuilder = new Request.Builder().url(url);
        //构造请求头
        if(!CollectionUtils.isEmpty(headers)){
            for (Map.Entry<String, String> mapEntry : headers.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBuilder.addHeader(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //构建请求
        Request request = requestBuilder.build();
        //获取client
        OkHttpClient okHttpClient = getOkHttpClient();
        //执行
        okHttpClient.newCall(request).enqueue(callback);
    }

    /**
     * 执行同步PostForm请求
     * @param url
     * @param params
     * @param headers
     * @return
     * @throws IOException
     */
    public static Response executePostForm(String url, Map<String, String> params, Map<String, String> headers) throws IOException {
        //构造请求体
        FormBody.Builder formBodyBuilder = new FormBody.Builder();
        if(!CollectionUtils.isEmpty(params)){
            for (Map.Entry<String, String> mapEntry : params.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    formBodyBuilder.add(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //创建requestBody
        RequestBody requestBody = formBodyBuilder.build();
        Request.Builder requestBuilder = new Request.Builder().url(url).post(requestBody);
        //构造请求头
        if(!CollectionUtils.isEmpty(headers)){
            for (Map.Entry<String, String> mapEntry : headers.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBuilder.addHeader(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //构建请求
        Request request = requestBuilder.build();
        //获取client
        OkHttpClient okHttpClient = getOkHttpClient();
        //执行
        Response response = okHttpClient.newCall(request).execute();

        log.info(url + " postForm response-->" + response.code());
        return response;
    }

    /**
     * 执行同步PostJSON请求
     * @param url
     * @param jsonStr
     * @param headers
     * @return
     * @throws IOException
     */
    public static Response executePostJSON(String url, String jsonStr, Map<String, String> headers) throws IOException {
        //构造请求体
        RequestBody requestBody = RequestBody.create(MEDIA_TYPE_JSON, jsonStr);
        //创建requestBody
        Request.Builder requestBuilder = new Request.Builder().url(url).post(requestBody);
        //构造请求头
        if(!CollectionUtils.isEmpty(headers)){
            for (Map.Entry<String, String> mapEntry : headers.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBuilder.addHeader(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //构建请求
        Request request = requestBuilder.build();
        //获取client
        OkHttpClient okHttpClient = getOkHttpClient();
        //执行
        Response response = okHttpClient.newCall(request).execute();

        log.info(url + " postJSON response-->" + response.code());
        return response;
    }

    /**
     * 执行同步PutJSON请求
     * @param url
     * @param jsonStr
     * @param headers
     * @return
     * @throws IOException
     */
    public static Response executePutJSON(String url, String jsonStr, Map<String, String> headers) throws IOException {
        //构造请求体
        RequestBody requestBody = RequestBody.create(MEDIA_TYPE_JSON, jsonStr);
        //创建requestBody
        Request.Builder requestBuilder = new Request.Builder().url(url).put(requestBody);
        //构造请求头
        if(!CollectionUtils.isEmpty(headers)){
            for (Map.Entry<String, String> mapEntry : headers.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBuilder.addHeader(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //构建请求
        Request request = requestBuilder.build();
        //获取client
        OkHttpClient okHttpClient = getOkHttpClient();
        //执行
        Response response = okHttpClient.newCall(request).execute();

        log.info(url + " putJSON response-->" + response.code());
        return response;
    }

    /**
     * 执行同步PutForm请求
     * @param url
     * @param params
     * @param headers
     * @return
     * @throws IOException
     */
    public static Response executePutForm(String url, Map<String, Object> params, Map<String, String> headers) throws IOException {
        //构造请求体
        FormBody.Builder formBodyBuilder = new FormBody.Builder();
        if(!CollectionUtils.isEmpty(params)){
            for (Map.Entry<String, Object> mapEntry : params.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    formBodyBuilder.add(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //创建requestBody
        RequestBody requestBody = formBodyBuilder.build();
        Request.Builder requestBuilder = new Request.Builder().url(url).put(requestBody);
        //构造请求头
        if(!CollectionUtils.isEmpty(headers)){
            for (Map.Entry<String, String> mapEntry : headers.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBuilder.addHeader(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //构建请求
        Request request = requestBuilder.build();
        //获取client
        OkHttpClient okHttpClient = getOkHttpClient();
        //执行
        Response response = okHttpClient.newCall(request).execute();

        log.info(url + " putForm response-->" + response.code());
        return response;
    }

    /**
     * 执行同步DeleteJSON请求
     * @param url
     * @param jsonStr
     * @param headers
     * @return
     * @throws IOException
     */
    public static Response executeDeleteJSON(String url, String jsonStr, Map<String, String> headers) throws IOException {
        if(StringUtils.isEmpty(jsonStr)){
            return executeDelete(url, headers);
        }
        //构造请求体
        RequestBody requestBody = RequestBody.create(MEDIA_TYPE_JSON, jsonStr);
        //创建requestBody
        Request.Builder requestBuilder = new Request.Builder().url(url).delete(requestBody);
        //构造请求头
        if(!CollectionUtils.isEmpty(headers)){
            for (Map.Entry<String, String> mapEntry : headers.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBuilder.addHeader(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //构建请求
        Request request = requestBuilder.build();
        //获取client
        OkHttpClient okHttpClient = getOkHttpClient();
        //执行
        Response response = okHttpClient.newCall(request).execute();

        log.info(url + " deleteJSON response-->" + response.code());
        return response;
    }

    /**
     * 执行同步DeleteForm请求
     * @param url
     * @param params
     * @param headers
     * @return
     * @throws IOException
     */
    public static Response executeDeleteForm(String url, Map<String, String> params, Map<String, String> headers) throws IOException {
        //构造请求体
        FormBody.Builder formBodyBuilder = new FormBody.Builder();
        if(!CollectionUtils.isEmpty(params)){
            for (Map.Entry<String, String> mapEntry : params.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    formBodyBuilder.add(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //创建requestBody
        RequestBody requestBody = formBodyBuilder.build();
        Request.Builder requestBuilder = new Request.Builder().url(url).delete(requestBody);
        //构造请求头
        if(!CollectionUtils.isEmpty(headers)){
            for (Map.Entry<String, String> mapEntry : headers.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBuilder.addHeader(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //构建请求
        Request request = requestBuilder.build();
        //获取client
        OkHttpClient okHttpClient = getOkHttpClient();
        //执行
        Response response = okHttpClient.newCall(request).execute();

        log.info(url + " deleteForm response-->" + response.code());
        return response;
    }

    /**
     * 执行同步Delete请求
     * @param url
     * @param headers
     * @return
     * @throws IOException
     */
    public static Response executeDelete(String url, Map<String, String> headers) throws IOException {
        //创建requestBody
        Request.Builder requestBuilder = new Request.Builder().url(url).delete();
        //构造请求头
        if(!CollectionUtils.isEmpty(headers)){
            for (Map.Entry<String, String> mapEntry : headers.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBuilder.addHeader(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //构建请求
        Request request = requestBuilder.build();
        //获取client
        OkHttpClient okHttpClient = getOkHttpClient();
        //执行
        Response response = okHttpClient.newCall(request).execute();

        log.info(url + " delete response-->" + response.code());
        return response;
    }

    /**
     * 获取response code
     * @param response
     * @return
     */
    public static int getResponseCode(Response response){
        return response.code();
    }

    /**
     * 获取resoponse body
     * @param response
     * @return
     * @throws IOException
     */
    public static String getResponseBody(Response response) throws IOException {
        if(response.isSuccessful() && response.code() == 200){
            return response.body().string();
        }

        return null;
    }

    /**
     * 获取resoponse body
     * @param response
     * @param code
     * @return
     * @throws IOException
     */
    public static String getResponseBody(Response response, int code) throws IOException {
        if(response.isSuccessful() && response.code() == code){
            return response.body().string();
        }

        return null;
    }

    /**
     * 上传单个文件
     * @param url
     * @param params
     * @param headers
     * @return
     */
    public static Response executeMultipart(String url, Map<String, Object> params, Map<String, Object> headers, File file){

        //构建请求
        MultipartBody.Builder requestBodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);

        if (file != null) {
            // MediaType.parse() 里面是上传的文件类型。
            RequestBody body = RequestBody.create(MediaType.parse("multipart/form-data; charset=utf-8"), file);
            String filename = file.getName();
            // 参数分别为， 请求key ，文件名称 ， RequestBody
            requestBodyBuilder.addFormDataPart("file", file.getName(), body);
        }
        //请求参数
        if(params != null && !params.isEmpty()){
            for (Map.Entry<String, Object> mapEntry : params.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBodyBuilder.addFormDataPart(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //创建requestBody
        RequestBody requestBody = requestBodyBuilder.build();

        Request.Builder requestBuilder = new Request.Builder().url(url).post(requestBody);
        //构造请求头
        if(headers != null && !headers.isEmpty()){
            for (Map.Entry<String, Object> mapEntry : headers.entrySet()) {
                // value不为空
                if(!Objects.isNull(mapEntry.getValue())){
                    requestBuilder.addHeader(mapEntry.getKey(), String.valueOf(mapEntry.getValue()));
                }
            }
        }
        //构建请求
        Request request = requestBuilder.build();
        //获取client,上传文件设置超时时间300s
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .writeTimeout(300, TimeUnit.SECONDS)
                .build();
        //执行
        Response response = null;
        try {
            response = okHttpClient.newCall(request).execute();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return response;
    }
}
SpringBoot-okhttp3-keytool自签名-https单向认证和双向认证
10-25 683
一、前言 HTTPS （全称：Hyper Text Transfer Protocol over SecureSocket Layer），是以安全为目标的 HTTP 通道，在HTTP的基础上通过传输加密和身份认证保证了传输过程的安全性 [1] 。HTTPS 在HTTP 的基础下加入SSL 层，HTTPS 的安全基础是 SSL，因此加密的详细内容就需要 SSL。 HTTPS 存在不同于 HTTP 的默认端口及一个加密/身份验证层（在 HTTP与 TCP 之间）。这个系统提供了身份验证与加密通讯方法。 .
springboot整合okhttp
WangYuChen优快云的博客
11-21 1521
springboot整合okhttp
java 调用okHttp3进行代码测试（SpringBoot项目)）
02-21
SpringBoot OkHttp3,里面包含了各种测试代码，其中包含了get，post，文件上传等测试
在springboot中使用okhttp3
最新发布
zpflwy1314的博客
09-11 416
在 Spring Boot 项目中使用OkHttp3进行 HTTP 请求是一个高效且流行的方式。OkHttp3是一个 Java HTTP 客户端，可以处理各种请求类型，比如 GET、POST、PUT 等，并且支持高效的 HTTP 连接池、请求和响应缓存、以及异步请求处理等。
SpringBoot 使用OKhttp
m0_67402970的博客
04-25 5287
SpringBoot 使用OKhttp pom <!-- Okhttp --> <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.6.0</version>
Spring Boot 中的 RestTemplate不好用？试试 Retrofit ！
emprere的博客
09-16 299
作者 |六点半起床来源|juejin.im/post/6854573211426750472大家都知道okhttp是一款由square公司开源的java版本http客户端工具。...
okhttp3.0忽略https证书
空中的晨曦博客
06-13 3738
okhttp的基本使用网上很多，可以自己找到很多例子。 最近有个项目需要https 进行验证发送请求回来error 提示 host not vertify，琢磨了半天，最后是需要将证书认证忽略，那就开始构建一个SSL来信任所有的证书，忽略证书其实就是如此。 最原始的使用如下 String url = "https://wwww.baidu.com"; OkHttpClient okHttp...
还在用HttpUtil？SpringBoot 3.0全新HTTP客户端工具来了，用起来够优雅~
macrozheng的专栏
12-13 3165
我们平时开发项目的时候，经常会需要远程调用下其他服务提供的接口，于是我们会使用一些HTTP工具类比如Hutool提供的HttpUtil。前不久SpringBoot 3.0发布了，出了一个Http Interface的新特性，它允许我们使用声明式服务调用的方式来调用远程接口，今天我们就来聊聊它的使用！
CountDownLatch和okhttp3 实现多线程异步http调用
fajing_feiyue的博客
10-02 1619
一、在工作中需要多次调用第三方接口，或者其他耗时任务，这个时候为了提高返回结果的速度，可以利用countDownLatch来实现多线程调用，提高返回结果的时间。 （1） 由于代码较多，这里先将实现逻辑由伪代码，先行演示一遍。 //先定义需要异步调用的次数，每次调用 CountDownLatch.countDown(); //等最慢的一次完成调用，封装在list对象里面,这个时候 CountDown...
springboot学习(五十二) springboot中使用retrofit实现调用本地接口访问远程服务
文若书生的专栏
08-09 2297
文章目录前言一、retrofit是什么？二、使用步骤1.引入库2.编写远程测试接口3.编写本地接口和测试接口3.1. retrofit的配置信息3.2. 本地和测试接口3.3. 测试4.编写拦截器5.自定义注解拦截器总结 前言 上一篇文章我们学习了使用openfeign来调用本地接口访问远程服务，这篇文章我们来学习另一种方式retrofit,这个工具在安卓中用的比较多，不过在springboot中使用也是一样啦。 一、retrofit是什么？ okhttp是一款由square公司开源的java版本h
springboot集成Feign
m0_67266585的博客
12-07 1013
使用 Feign 的核心是通过接口来声明远程服务的调用。Feign 将根据该接口生成具体的 HTTP 请求。例如，假设我们有一个用户服务@FeignClient(name = "user-service", url = "http://localhost:8081") // 定义 Feign 客户端：定义 Feign 客户端，name指定客户端的名称，url是服务的基础 URL。如果与 Eureka 等服务发现系统集成，url可以省略。：指定 HTTP 方法为 GET，并定义请求路径。
SpringBoot 配置 okhttp3
热门推荐
Jaemon
06-29 2万+
SpringBoot 配置 okhttp3
spring boot3.0新特性Http客户端远程调用,http客户端调用接口
weixin_41463944的博客
04-14 1731
spring boot3.0新特性Http客户端远程调用,http客户端调用接口
SpringBoot中使用OkHttp
XuanRan的博客
11-20 3364
在Springboot中使用Okhttp
Spring boot 整合 Okhttp3 并封装请求工具
枫
08-30 1万+
OkHttp是一个高效、灵活、易于使用的HTTP客户端库，具有高性能，功能强大，使用简单，兼容性好，应用广泛等特点
SpringBoot发送http请求--OkHttps
qq_34471241的博客
01-12 2322
最近做项目有一个需求，需要与其他公司对接，后端访问对方的接口，调通对方的资源。 经过多方考量，觉决定项目中引入OkHttps,来发起http请求。 OkHttps 是近期开源的对 OkHttp3 轻量封装的框架，它独创的异步预处理器，特色的标签，灵活的上传下载进度监听与过程控制功能，在轻松解决很多原本另人头疼问题的同时，设计上也力求纯粹与优雅。 链式调用，一点到底 BaseURL、URL占位符、JSON自动封装与解析 同步拦截器、异步预处理器、回调执行器、全局监听、回调阻断 文件上传下载（过程控
配置Springboot支持https和http协议
xiaolong_java的博客
05-11 3909
记录一下关于springboot 同时支持https和http协议的问题 在网上看了关于微信小程序的教程，要发布小程序的后端必须要支持https服务的，所以在后端springboot项目中添加了支持https服务的相关配置 在网上查了一下资料，又在我本地实践了一把，it works 1.用jdk自带的keytool生成一个.keystore的文件 设置秘钥口令 key-store-password 我在此设置的是: gexiaolong -genkey 生成key -validity 3600 有效期限3
springboot RestTemplate整合okhttp
Yweir的博客
08-24 2640
springboot okhttp整合
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值