访问URL(二)调用工具类实现访问url接口

最新推荐文章于 2024-04-29 10:54:34 发布
最新推荐文章于 2024-04-29 10:54:34 发布
阅读量618 收藏 1
点赞数
分类专栏： java基础 文章标签： 绕过https安全验证 调用接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39548700/article/details/103502819
版权

工具类代码：

import org.apache.commons.io.IOUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.*;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.security.GeneralSecurityException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * HTTP 请求工具类
 *
 * @author : chb
 * @date : 2018/7/21
 */
public class HttpUtil {
    private static PoolingHttpClientConnectionManager connMgr;
    private static RequestConfig requestConfig;
    private static final int MAX_TIMEOUT = 1200000;

    static {
        // 设置连接池
        connMgr = new PoolingHttpClientConnectionManager();
        // 设置连接池大小
        connMgr.setMaxTotal(100);
        connMgr.setDefaultMaxPerRoute(connMgr.getMaxTotal());

        RequestConfig.Builder configBuilder = RequestConfig.custom();
        // 设置连接超时
        configBuilder.setConnectTimeout(MAX_TIMEOUT);
        // 设置读取超时
        configBuilder.setSocketTimeout(MAX_TIMEOUT);
        // 设置从连接池获取连接实例的超时
        configBuilder.setConnectionRequestTimeout(MAX_TIMEOUT);
        // 在提交请求之前 测试连接是否可用
        configBuilder.setStaleConnectionCheckEnabled(true);
        requestConfig = configBuilder.build();
    }

    /**
     * 发送 GET 请求（HTTP），不带输入数据
     * @param url
     * @return
     */
    public static String doGet(String url) {
        return doGet(url, new HashMap<String, Object>());
    }

    /**
     * 发送 GET 请求（HTTP），K-V形式
     * @param url
     * @param params
     * @return
     */
    public static String doGet(String url, Map<String, Object> params) {
        String apiUrl = url;
        StringBuffer param = new StringBuffer();
        int i = 0;
        for (String key : params.keySet()) {
            if (i == 0)
                param.append("?");
            else
                param.append("&");
            param.append(key).append("=").append(params.get(key));
            i++;
        }
        apiUrl += param;
        String result = null;
        HttpClient httpclient = new DefaultHttpClient();
        try {
            HttpGet httpPost = new HttpGet(apiUrl);
            HttpResponse response = httpclient.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();

            System.out.println("执行状态码 : " + statusCode);

            HttpEntity entity = response.getEntity();
            if (entity != null) {
                InputStream instream = entity.getContent();
                result = IOUtils.toString(instream, "UTF-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 发送 POST 请求（HTTP），不带输入数据
     * @param apiUrl
     * @return
     */
    public static String doPost(String apiUrl) {
        return doPost(apiUrl, new HashMap<String, Object>());
    }

    /**
     * 发送 POST 请求（HTTP），K-V形式
     * @param apiUrl API接口URL
     * @param params 参数map
     * @return
     */
    public static String doPost(String apiUrl, Map<String, Object> params) {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        String httpStr = null;
        HttpPost httpPost = new HttpPost(apiUrl);
        CloseableHttpResponse response = null;

        try {
            httpPost.setConfig(requestConfig);
            List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
            for (Map.Entry<String, Object> entry : params.entrySet()) {
                NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry
                        .getValue().toString());
                pairList.add(pair);
            }
            httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));
            httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");
            response = httpClient.execute(httpPost);
            System.out.println(response.toString());
            HttpEntity entity = response.getEntity();
            if (null != entity) {
                httpStr = EntityUtils.toString(entity, "UTF-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return httpStr;
    }

    /**
     * 发送 POST 请求（HTTP），JSON形式
     * @param apiUrl
     * @param json json对象
     * @return
     */
    public static String doPost(String apiUrl, Object json) {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        String httpStr = null;
        HttpPost httpPost = new HttpPost(apiUrl);
        CloseableHttpResponse response = null;

        try {
            httpPost.setConfig(requestConfig);
            StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题
            stringEntity.setContentEncoding("UTF-8");
            stringEntity.setContentType("application/json");
            httpPost.setEntity(stringEntity);
            response = httpClient.execute(httpPost);
            HttpEntity entity = response.getEntity();
            System.out.println(response.getStatusLine().getStatusCode());
            httpStr = EntityUtils.toString(entity, "UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return httpStr;
    }

    /**
     * 发送 SSL POST 请求（HTTPS），K-V形式
     * @param apiUrl API接口URL
     * @param params 参数map
     * @return
     */
    public static String doPostSSL(String apiUrl, Map<String, Object> params) throws IOException {
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();
        HttpPost httpPost = new HttpPost(apiUrl);
        CloseableHttpResponse response = null;
        String httpStr = null;

        try {
            httpPost.setConfig(requestConfig);
            List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
            for (Map.Entry<String, Object> entry : params.entrySet()) {
                NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue()!=null? entry.getValue().toString():"");
                pairList.add(pair);
            }
            httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("utf-8")));
            response = httpClient.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode != HttpStatus.SC_OK) {
                return null;
            }
            HttpEntity entity = response.getEntity();
            if (entity == null) {
                return null;
            }
            httpStr = EntityUtils.toString(entity, "utf-8");
        } catch (IOException e) {
            throw  e;
        } finally {
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    throw  e;
                }
            }
        }
        return httpStr;
    }

    /**
     * 发送 SSL POST 请求（HTTPS），JSON形式
     * @param apiUrl API接口URL
     * @param json JSON对象
     * @return
     */
    public static String doPostSSL(String apiUrl, Object json) {
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();
        HttpPost httpPost = new HttpPost(apiUrl);
        CloseableHttpResponse response = null;
        String httpStr = null;

        try {
            httpPost.setConfig(requestConfig);
            StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题
            stringEntity.setContentEncoding("UTF-8");
            stringEntity.setContentType("application/json");
            httpPost.setEntity(stringEntity);
            response = httpClient.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode != HttpStatus.SC_OK) {
                return null;
            }
            HttpEntity entity = response.getEntity();
            if (entity == null) {
                return null;
            }
            httpStr = EntityUtils.toString(entity, "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return httpStr;
    }

    /**
     * 发送 GET 请求（HTTPS），K-V形式
     * @param url
     * @param params
     * @return
     */
    public static String doGetIgnoreVerifySSL(String url, Map<String, Object> params) throws KeyManagementException, NoSuchAlgorithmException {
        String apiUrl = url;
        StringBuffer param = new StringBuffer();
        int i = 0;
        for (String key : params.keySet()) {
            if (i == 0)
                param.append("?");
            else
                param.append("&");
            param.append(key).append("=").append(params.get(key));
            i++;
        }
        apiUrl += param;
        String result = null;
        //采用绕过验证的方式处理https请求
        SSLContext sslcontext = createIgnoreVerifySSL();

        //设置协议http和https对应的处理socket链接工厂的对象
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.INSTANCE)
                .register("https", new SSLConnectionSocketFactory(sslcontext))
                .build();
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        HttpClients.custom().setConnectionManager(connManager);

        //创建自定义的httpclient对象
        CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(connManager).build();

        try {
            HttpGet httpPost = new HttpGet(apiUrl);
            HttpResponse response = httpclient.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();

            System.out.println("执行状态码 : " + statusCode);

            HttpEntity entity = response.getEntity();
            if (entity != null) {
                InputStream instream = entity.getContent();
                result = IOUtils.toString(instream, "UTF-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 发送 SSL POST 请求（HTTPS），K-V形式
     * @param apiUrl API接口URL
     * @param params 参数map
     * @return
     */
    public static String doPostIgnoreVerifySSL(String apiUrl, Map<String, Object> params) throws KeyManagementException, NoSuchAlgorithmException {
        //采用绕过验证的方式处理https请求
        SSLContext sslcontext = createIgnoreVerifySSL();
        //设置协议http和https对应的处理socket链接工厂的对象
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.INSTANCE)
                .register("https", new SSLConnectionSocketFactory(sslcontext))
                .build();
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        HttpClients.custom().setConnectionManager(connManager);

        //创建自定义的httpclient对象
        CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(connManager).build();

        String httpStr = null;
        HttpPost httpPost = new HttpPost(apiUrl);
        CloseableHttpResponse response = null;

        try {
            httpPost.setConfig(requestConfig);
            List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
            for (Map.Entry<String, Object> entry : params.entrySet()) {
                NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry
                        .getValue().toString());
                pairList.add(pair);
            }
            httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));
            httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");
            response = httpClient.execute(httpPost);
            System.out.println(response.toString());
            HttpEntity entity = response.getEntity();
            if (null != entity) {
                httpStr = EntityUtils.toString(entity, "UTF-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return httpStr;
    }

    /**
     * 绕过验证
     *
     * @return
     * @throws NoSuchAlgorithmException
     * @throws KeyManagementException
     */
    public static SSLContext createIgnoreVerifySSL() throws NoSuchAlgorithmException, KeyManagementException {
        SSLContext sc = SSLContext.getInstance("SSLv3");

        // 实现一个X509TrustManager接口，用于绕过验证，不用修改里面的方法
        X509TrustManager trustManager = new X509TrustManager() {
            @Override
            public void checkClientTrusted(
                    java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
                    String paramString) throws CertificateException {
            }

            @Override
            public void checkServerTrusted(
                    java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
                    String paramString) throws CertificateException {
            }

            @Override
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        };

        sc.init(null, new TrustManager[] { trustManager }, null);
        return sc;
    }

    /**
     * 创建SSL安全连接
     *
     * @return
     */
    private static SSLConnectionSocketFactory createSSLConnSocketFactory() {
        SSLConnectionSocketFactory sslsf = null;
        try {
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {

                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                    return true;
                }
            }).build();
            sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {

                @Override
                public boolean verify(String arg0, SSLSession arg1) {
                    return true;
                }

                @Override
                public void verify(String host, SSLSocket ssl) throws IOException {
                }

                @Override
                public void verify(String host, X509Certificate cert) throws SSLException {
                }

                @Override
                public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
                }
            });
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }
        return sslsf;
    }


    /**
     * 测试方法
     * @param args
     */
    public static void main(String[] args) throws Exception {
        Map<String, Object> tokenParamMap = new HashMap<String, Object>();
        tokenParamMap.put("wd","马登凌");
        String result = doGetIgnoreVerifySSL("https://www.baidu.com/s",tokenParamMap);
        System.out.println(result);
    }
}

工具类中使用到的jar包有：commons-io-2.5.jar、httpclient-4.5.3.jar、httpcore-4.4.6.jar
项目中亲测使用过的是doPostIgnoreVerifySSL、doGetIgnoreVerifySSL方法，访问https协议的接口跳过安全验证。同时也了解了Java jre中加安全证书的方式，在此以作记录。
一、证书的下载
打开浏览器输入https://的网站，如果没有相关证书，可以根据提示从浏览器中下载下来，一般保存为*.cer文件。
点击URL前边的锁标志，点击证书
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
二、证书的安装
将下载好的证书拷贝到%JAVA_HOME%\jre\lib\security\cacerts路径下，cmd或者powershell打开命令框
keytool -import -trustcacerts -alias afpc.hangzhou.gov.cn -file cert.cer -keystore cacerts -storepass changeit#新增
三、证书的查看
keytool -list -keystore cacerts#查看
补充：keytool -delete -alias afpc.hangzhou.gov.cn -keystore cacerts#删除
删除时需要用到密码，默认密钥库口令为changeit

小科比000
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HttpClient接口调用工具类(附带demo)
11-28
总之，这个HttpClient工具类提供了一个简洁易用的接口，帮助开发者快速、方便地进行HTTP请求，无论是在进行API调用还是数据交互，都能大大简化工作流程。通过这个工具类，你无需深入了解HttpClient的底层实现，只需...
批量访问URL是否可以访问脚本
jinniankeke的博客
04-03 261
读取txt文件中所有URL。# 创建工作簿并添加工作表。# 保存工作簿为xls文件。# 遍历每个URL并测试。
Java调用三方接口进行URL请求
长臂人猿的博客
05-18 3412
前言 对于url的请求两种需求，一种是程序调用接口后返回数据； 二是调用第三方openApi接口。 基于URLConnection的返回值获取 使用java.net包下面原生的URLConnection对象，使用IO流进行数据提交和请求获取，比如说：获取返回结果。 若只是向服务器请求数据，则为HTTP请求方法为GET。 若需要向服务器提交数据，必须在先调用setDoOutput(true)。当doOutput属性为true时，请求方法将由GET变为POST。 使用getInputStream()方法输出
java项目中调用外部接口工具类-HttpUtils
最新发布
weixin_42917261的博客
04-29 284
项目中调用外部接口工具类-HttpUtils.java
浏览器的url和请求接口有什么区别？
青椒
12-06 2433
url是获取页面资源接口是获取服务器资源浏览器的url是可以请求当前url下所有的资源，包括静态资源、图片资源、接口请求接口是页面某一个按钮触发的请求入口页面url：domain.com.cn --请求服务器这个路径下所有资源浏览器接口请求：domain.com.cn --登录接口
https方式访问URL接口
moonicly的博客
09-24 5653
HTTPS访问调用接口 总体思路 通过发送 https 请求，使用 GET 或者 POST 的方式，访问 url https 请求与 http请求的区别 比起http 请求，https 请求多了一个信任管理器（X509TrustManager），可以通过这个信任管理器来过滤掉不需要的 url，从而保证了访问的安全性。 代码实现 信任管理器 首先定义一个信任管理器MyX509TrustManager（implements X509TrustManager） package util; import java
java远程调用接口、URL的方式
suiyishiguang的博客
06-02 5976
java远程调用接口、URL的方式
Feign 调用其他微服务接口时，url地址匹配错误
01-20
然而，当使用 Feign 调用其他微服务接口时，可能会遇到URL地址匹配错误的问题。这个问题通常与接口的路径、请求方法以及内容类型配置不匹配有关。 首先，我们来看一下问题所在的代码片段。在 Feign 客户端定义的...
HttpClient实现调用外部项目接口工具类的示例
08-29
HttpClient实现调用外部项目接口工具类的示例 HttpClient是Apache Jakarta Commons子项目中的一种开源的Http客户端实现，它提供了一个实现了Http/1.1和Http/2.0协议的客户端工具库，用于发送Http请求和接收Http...
C# webservice 服务调用工具类，源码
04-08
C# webservice 服务调用工具类。 此工具 对 post get 请求进行了封装，只需要传递对应的URL以及参数即可返回JSON 或者XML 的字符串。 是非常有用的调用远程接口的服务类。 webservice
Java调用第三方接口示范的实现
08-25
在示例代码中，直接使用了`HttpClientUtil`工具类，该类包含调用接口的相关方法。 2. **创建HttpClient对象**：使用`HttpClients.createDefault()`创建一个默认的HttpClient实例，用于发送HTTP请求。 3. **构建...
java通过url调用接口
09-13
java通过url调用外部接口，返回字符串，再讲字符串解析成json格式。包含源码和jar包，直接运行即可，带注释。
URL调用http接口
weixin_47120348的博客
03-20 5280
java在代码中调用接口 public static void main(String[] args) { try { //创建接口地址对象 URL url = new URL("http://localhost:8888/menu"); //根据url对象来生成一个打开连接http请求 HttpURLConnection connection = (HttpURLConnection)url.
调用URL 接口服务
weixin_30545285的博客
08-21 256
1.Net调用URL 接口服务 using System; using System.Collections; using System.Configuration; using System.Data; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.H...
【JS】URL 接口
qq_45677671的博客
01-06 2045
URL 接口用于解析，构造，规范化和编码 URL。 它通过提供允许您轻松阅读和修改 URL 组件的属性来工作。 通常，通过在调用 URL 的构造函数时将 URL 指定为字符串或提供相对 URL 和基本 URL 来创建新的 URL 对象。 然后，您可以轻松读取 URL 的已解析组成部分或对 URL 进行更改。
URL地址请求过程
Kar29的博客
09-15 1558
URL地址请求过程 1. DNS 解析：将域名地址解析成 IP 地址 按照以下顺序进行 DNS 解析： Browser DNS cache（浏览器 DNS 缓存） OS DNS cache（系统 DNS 缓存） Router DNS cache（路由器DNS 缓存） ISP DNS cache（网络运营商DNS 缓存） Recursive search（递归搜索）（若以上 4 种都为找到，则会进行 Recursive search） 2. TCP 连接：TCP 三次握手 详情请见： ...
Feign的Url接口调用工具配置
u010928061的博客
04-19 1915
1、java项目中实现url接口调用的方法 1.1、HttpClient HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 Http 协议的客户端编程工具包，并且它支持 HTTP 协议最新版本和建议。HttpClient 相比传统 JDK 自带的 URLConnection，提升了易用性和灵活性，使客户端发送 HTTP 请求变得容易，提高了开发的效率。 1.2、Okhttp 一个处理网络请求的开源项目，是安卓端最火的轻量级框架，
JAVA后端——调用第三方URL接口
wch0001的博客
05-13 7670
文章目录前言内容添加依赖get请求post请求http协议问题总结 前言 在项目里有时候需要在后端引用别人的url，java用来调用的方法也有好几种，比如HttpURLConnection，还有apache的HttpClient，简单封装了一下HttpClient的get和post的方法。一般情况下应该是够用了 内容 添加依赖 <dependency> <groupId>org.apache.httpcomponents</groupId> <artifac
java 实现根据http 接口调用工具类
06-08
Java实现根据HTTP接口调用工具类的基本思路如下： 1. 引入HTTP客户端库，例如Apache HttpClient或OkHttp。 2. 封装HTTP请求和响应的工具类，例如： ``` public class HttpUtils { // 发送HTTP GET请求 public...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值