HttpClient 讲解 (2) 项目封装

最新推荐文章于 2022-05-22 21:01:24 发布
最新推荐文章于 2022-05-22 21:01:24 发布
阅读量1.1w 收藏 1
点赞数
分类专栏： java hppts HttpClient
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014201191/article/details/49745125
版权
java 同时被 3 个专栏收录
16 篇文章 0 订阅
订阅专栏
hppts
7 篇文章 0 订阅
订阅专栏
HttpClient
4 篇文章 0 订阅
订阅专栏

maven加载

<!-- httpclient begin -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.3.4</version>
		</dependency>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpasyncclient</artifactId>
			<version>4.0.2</version>
		</dependency>
		<dependency>
			<groupId>commons-httpclient</groupId>
			<artifactId>commons-httpclient</artifactId>
			<version>3.1</version>
		</dependency>
		<!-- httpclient end -->

请求封装,自动转换https

package com.zefun.common.utils;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
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.List;
import java.util.Map;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.commons.httpclient.HttpStatus;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

/**
 * 
* @author 
* @date 2015年8月11日 下午2:13:37
 */
public class HttpClientUtil {

    /**
     * http协议
     */
    private static final String HTTPS_PROTOCOL = "https://";
    /**
     * 协议默认端口
     */
    private static final int HTTPS_PROTOCOL_DEFAULT_PORT = 443;

    /**
     * 默认编码格式
     */
    private static final String DEFAULT_CHARSET = "UTF-8";

    /**
     * 日志
     */
    private static Logger logger = Logger.getLogger(HttpClientUtil.class);

    /**
     * 
    * @author 
    * @date 2015年8月11日 下午2:16:57
    * @param url 路径
    * @return int
     */
    private static int getPort(String url) {
        int startIndex = url.indexOf("://") + "://".length();
        String host = url.substring(startIndex);
        if (host.indexOf("/") != -1) {
            host = host.substring(0, host.indexOf("/"));
        }
        int port = HTTPS_PROTOCOL_DEFAULT_PORT;
        if (host.contains(":")) {
            int i = host.indexOf(":");
            port = new Integer(host.substring(i + 1));
        }
        return port;
    }

    /**
     * 
    * @author 
    * @date 2015年8月11日 下午2:14:36
    * @param params 参数
    * @return List<NameValuePair>
     */
    private static List<NameValuePair> geneNameValPairs(Map<String, ?> params) {
        List<NameValuePair> pairs = new ArrayList<NameValuePair>();
        if (params == null) {
            return pairs;
        }
        for (String name : params.keySet()) {
            if (params.get(name) == null) {
                continue;
            }
            pairs.add(new BasicNameValuePair(name, params.get(name).toString()));
        }
        return pairs;
    }

    /**
     * 发送GET请求
     * @param url 请求地址
     * @param charset 返回数据编码
     * @return 返回数据
     */
    public static String sendGetReq(final String url, String charset) {
        if (null == charset){
            charset = DEFAULT_CHARSET;
        }
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpGet get = new HttpGet(url);
        if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
            initSSL(httpClient, getPort(url));
        }
        try {
            // 提交请求并以指定编码获取返回数据
            HttpResponse httpResponse = httpClient.execute(get);
            int statuscode = httpResponse.getStatusLine().getStatusCode();
            if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY)
                    || (statuscode == HttpStatus.SC_SEE_OTHER) || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
                Header header = httpResponse.getFirstHeader("location");
                if (header != null) {
                    String newuri = header.getValue();
                    if ((newuri == null) || (newuri.equals(""))){
                        newuri = "/";
                    }
                    try {
                        httpClient.close();
                    }
                    catch (Exception e) {
                        e.printStackTrace();
                        httpClient = null;
                    }
                    logger.info("重定向地址：" + newuri);
                    return sendGetReq(newuri, null);
                }
            }
            logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
            HttpEntity entity = httpResponse.getEntity();
            return EntityUtils.toString(entity, charset);
        }
        catch (ClientProtocolException e) {
            logger.error("协议异常,堆栈信息如下", e);
        }
        catch (IOException e) {
            logger.error("网络异常,堆栈信息如下", e);
        }
        finally {
            // 关闭连接，释放资源
            try {
                httpClient.close();
            }
            catch (Exception e) {
                e.printStackTrace();
                httpClient = null;
            }
        }
        return null;
    }

    /**
     * 发送put请求
     * @param url		请求地址
     * @param params	请求参数
     * @param charset	返回数据编码
     * @return String
     */
    public static String sendPutReq(String url, Map<String, Object> params, String charset) {
        if (null == charset){
            charset = DEFAULT_CHARSET;
        }
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpPut put = new HttpPut(url);

        // 封装请求参数
        List<NameValuePair> pairs = geneNameValPairs(params);
        try {
            put.setEntity(new UrlEncodedFormEntity(pairs, charset));
            if (url.startsWith(HTTPS_PROTOCOL)) {
                initSSL(httpClient, getPort(url));
            }
            // 提交请求并以指定编码获取返回数据
            HttpResponse httpResponse = httpClient.execute(put);

            logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
            HttpEntity entity = httpResponse.getEntity();
            return EntityUtils.toString(entity, charset);
        }
        catch (ClientProtocolException e) {
            logger.error("协议异常,堆栈信息如下", e);
        }
        catch (IOException e) {
            logger.error("网络异常,堆栈信息如下", e);
        }
        finally {
            // 关闭连接，释放资源
            try {
                httpClient.close();
            }
            catch (Exception e) {
                e.printStackTrace();
                httpClient = null;
            }
        }
        return null;
    }

    /**
     * 发送delete请求
     * @param url		请求地址
     * @param charset	返回数据编码
     * @return String
     */
    public static String sendDelReq(String url, String charset) {
        if (null == charset){
            charset = DEFAULT_CHARSET;
        }
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpDelete del = new HttpDelete(url);
        if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
            initSSL(httpClient, getPort(url));
        }
        try {
            // 提交请求并以指定编码获取返回数据
            HttpResponse httpResponse = httpClient.execute(del);
            logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
            HttpEntity entity = httpResponse.getEntity();
            return EntityUtils.toString(entity, charset);
        }
        catch (ClientProtocolException e) {
            logger.error("协议异常,堆栈信息如下", e);
        }
        catch (IOException e) {
            logger.error("网络异常,堆栈信息如下", e);
        }
        finally {
            // 关闭连接，释放资源
            try {
                httpClient.close();
            }
            catch (Exception e) {
                e.printStackTrace();
                httpClient = null;
            }
        }
        return null;
    }

    /**
     * 发送POST请求，支持HTTP与HTTPS
     * @param url 请求地址
     * @param params 请求参数
     * @param charset 返回数据编码
     * @return 返回数据
     */
    public static String sendPostReq(String url, Map<String, ?> params, String charset) {
        if (null == charset){
            charset = DEFAULT_CHARSET;
        }
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        RequestConfig reqConf = RequestConfig.DEFAULT;
        HttpPost httpPost = new HttpPost(url);
        // 封装请求参数
        List<NameValuePair> pairs = geneNameValPairs(params);
        try {
            httpPost.setEntity(new UrlEncodedFormEntity(pairs, charset));
            // 对HTTPS请求进行处理
            if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
                initSSL(httpClient, getPort(url));
            }
            // 提交请求并以指定编码获取返回数据
            httpPost.setConfig(reqConf);
            HttpResponse httpResponse = httpClient.execute(httpPost);
            int statuscode = httpResponse.getStatusLine().getStatusCode();
            if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY)
                    || (statuscode == HttpStatus.SC_SEE_OTHER) || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
                Header header = httpResponse.getFirstHeader("location");
                if (header != null) {
                    String newuri = header.getValue();
                    if ((newuri == null) || (newuri.equals(""))){
                        newuri = "/";
                    }
                    try {
                        httpClient.close();
                    }
                    catch (Exception e) {
                        e.printStackTrace();
                        httpClient = null;
                    }
                    return sendGetReq(newuri, null);
                }
            }

            logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
            HttpEntity entity = httpResponse.getEntity();
            return EntityUtils.toString(entity, charset);
        }
        catch (UnsupportedEncodingException e) {
            logger.error("不支持当前参数编码格式[" + charset + "],堆栈信息如下", e);
        }
        catch (ClientProtocolException e) {
            logger.error("协议异常,堆栈信息如下", e);
        }
        catch (IOException e) {
            logger.error("网络异常,堆栈信息如下", e);
        }
        finally {
            // 关闭连接，释放资源
            try {
                httpClient.close();
            }
            catch (Exception e) {
                e.printStackTrace();
                httpClient = null;
            }
        }
        return null;
    }

    /**
     * 发送POST请求，支持HTTP与HTTPS, 参数放入请求体方式
     * @param url 请求地址
     * @param content 请求参数
     * @param charset 返回数据编码
     * @return 返回数据
     */
    public static String sendPost(String url, String content, String charset) {
        if (null == charset){
            charset = DEFAULT_CHARSET;
        }
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        RequestConfig reqConf = RequestConfig.DEFAULT;
        HttpPost httpPost = new HttpPost(url);
        try {
            httpPost.setEntity(new StringEntity(content, charset));
            // 对HTTPS请求进行处理
            if (url.toLowerCase().startsWith(HTTPS_PROTOCOL)) {
                initSSL(httpClient, getPort(url));
            }
            // 提交请求并以指定编码获取返回数据
            httpPost.setConfig(reqConf);
            HttpResponse httpResponse = httpClient.execute(httpPost);
            int statuscode = httpResponse.getStatusLine().getStatusCode();
            if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY)
                    || (statuscode == HttpStatus.SC_SEE_OTHER) || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
                Header header = httpResponse.getFirstHeader("location");
                if (header != null) {
                    String newuri = header.getValue();
                    if ((newuri == null) || (newuri.equals(""))){
                        newuri = "/";
                    }
                    try {
                        httpClient.close();
                    }
                    catch (Exception e) {
                        e.printStackTrace();
                        httpClient = null;
                    }
                    return sendGetReq(newuri, null);
                }
            }

            logger.info("请求地址：" + url + "；响应状态：" + httpResponse.getStatusLine());
            HttpEntity entity = httpResponse.getEntity();
            return EntityUtils.toString(entity, charset);
        }
        catch (UnsupportedEncodingException e) {
            logger.error("不支持当前参数编码格式[" + charset + "],堆栈信息如下", e);
        }
        catch (ClientProtocolException e) {
            logger.error("协议异常,堆栈信息如下", e);
        }
        catch (IOException e) {
            logger.error("网络异常,堆栈信息如下", e);
        }
        finally {
            // 关闭连接，释放资源
            try {
                httpClient.close();
            }
            catch (Exception e) {
                e.printStackTrace();
                httpClient = null;
            }
        }
        return null;
    }

    /**
     * 初始化HTTPS请求服务
     * @param httpClient HTTP客户端
     * @param port 端口
     */
    public static void initSSL(CloseableHttpClient httpClient, int port) {
        SSLContext sslContext = null;
        try {
            sslContext = SSLContext.getInstance("SSL");
            final X509TrustManager trustManager = new X509TrustManager() {
                public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
                }

                public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
                }

                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
            };
            // 使用TrustManager来初始化该上下文,TrustManager只是被SSL的Socket所使用
            sslContext.init(null, new TrustManager[] { trustManager }, null);
            ConnectionSocketFactory ssf = new SSLConnectionSocketFactory(sslContext);
            Registry<ConnectionSocketFactory> r = RegistryBuilder.<ConnectionSocketFactory> create().register("https", ssf).build();
            BasicHttpClientConnectionManager ccm = new BasicHttpClientConnectionManager(r);
            HttpClients.custom().setConnectionManager(ccm).build();
        }
        catch (KeyManagementException e) {
            e.printStackTrace();
        }
        catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
}

调用请求

String url = "http://up.qiniu.com/putb64/-1";
            HttpPost post = new HttpPost(url);
            post.addHeader("Content-Type", "application/octet-stream");
            post.addHeader("Authorization", "UpToken " + qiniuUptoken().get("uptoken"));
            //post.setEntity(new ByteArrayEntity(src));
            post.setEntity(new StringEntity(stringBase64));
            HttpClient c = Http.getClient();
            HttpResponse res = c.execute(post);
            System.out.println(res.getStatusLine().getReasonPhrase());
            String responseBody = EntityUtils.toString(
                    res.getEntity(), Config.CHARSET);
            System.out.println(responseBody);

上传文件

基于File上传

            File file = new File("d:\\1.jpg");
            FileBody body = new FileBody(file);
            MultipartEntity entity = new MultipartEntity();
            //注意file是在后台中接受的参数File file
            entity.addPart("file", body);
            httpPost.setEntity(entity);

基于流上传

            InputStreamBody inputStreamBody = new InputStreamBody(new FileInputStream(file), file.getName());
            MultipartEntity entity = new MultipartEntity();
            //注意file是在后台中接受的参数File file
            entity.addPart("file", inputStreamBody);
            httpPost.setEntity(entity);

后台接受都是一样的 

    @RequestMapping(value = Url.Project.UPLOAD_PROJECT)
    public BaseDto uploadTest(@RequestParam(value = "file", required = false) MultipartFile file, HttpServletRequest request){
        String path = request.getSession().getServletContext().getRealPath("upload"); 
        String fileName = file.getOriginalFilename();  
        File targetFile = new File(path, fileName);  
        if (!targetFile.exists()){  
            targetFile.mkdir();
        }  
        try {  
            file.transferTo(targetFile);  
        } 
        catch (Exception e) {  
            e.printStackTrace();  
        }
        return new BaseDto(App.System.API_RESULT_CODE_FOR_SUCCEES, App.System.API_RESULT_MSG_FOR_SUCCEES);
    }


高国藩
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android中HttpURLConnection与HttpClient的使用与封装
01-05
1.写在前面 ...  本文并不针对HTTP协议的具体内容，仅探讨android开发中使用HTTP协议访问网络的两种方式——HttpURLConnection和HttpClient  因为需要访问网络，需在AndroidManifest.xml中添加如下...2.HttpURLConnect
HTTPS 客户端发送请求(四)
小程序
06-23 1万+
HTTP与HTTPS灵活转换请求 前言:在工作中我们可能不一定只用到https和http,有时候可能两者都会用到,那我们发送了一个连接的时候呢,我们如何灵活的转换两者的请求呢,此时我们的一个思路就是,首先是将请求的port修改,比如讲http://修改为了https://,第二部就是要讲https设置为无证书请求方式,这个地方我们用到了apache给我们提供的类进行转换,很好用的
HttpClient使用详解
热门推荐
鹏霄万里展雄飞
02-28 88万+
Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会更加深入。 一、简介 HttpClient是Apache Jakarta Common下的子项目，用来提供高效的
java如何封装post请求,java使用httpclient封装post请求
weixin_29628635的博客
03-15 1001
我们程序员在项目开发过程中，经常用到接口，目前比较流行httpclient 技术。以下是我之前封装的httpclient的post请求 ，希望对大家有所帮助：精简代码如下：可以直接复制使用public static String postTDH(String url, String body, String mimeType,String charset, Integer connTimeout...
工作中用到的HttpClient、JSONUtils、HttpUtil封装
weixin_45607293的博客
05-22 369
@Slf4j public class HttpUtil { public static final String APPJSON = "application/json"; public static final String APPTEXT = "application/text"; public static final String APPFORM = "application/x-www-form-urlencoded"; public static final
HTTPClient 的一个封装
06-11
HttpClient的一个封装， HttpClient的一个封装
httpclient封装
04-25
封装了httpclient的get请求和post请求，包括传参数和和不传参数，以及请求头信息的设定。
spring boot封装HttpClient的示例代码
08-28
主要介绍了spring boot封装HttpClient的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
httpclient4.3 封装工具类
09-16
httpclient4.3的二次封装，解决了代理问题、多线程问题、SSL问题、通用的get、post请求
轻松把玩HttpClient之封装HttpClient工具类(一)（现有网上分享中的最强大的工具类）
崔成龙 . 勇往直前
11-19 4万+
搜了一下网络上别人封装的HttpClient，大部分特别简单，有一些看起来比较高级，但是用起来都不怎么好用。调用关系不清楚，结构有点混乱。所以也就萌生了自己封装HttpClient工具类的想法。要做就做最好的，本工具类支持插件式配置Header、插件式配置httpclient对象，这样就可以方便地自定义header信息、配置ssl、配置proxy等。是不是觉得说的有点悬乎了，那就先看看调用吧：
轻松把玩HttpClient之封装HttpClient工具类(八)，优化启用Http连接池策略
qq_19299071的博客
06-21 717
https://blog.csdn.net/xiaoxian8023/article/details/53064210/**  * HCB对象，用于创建HttpClient对象  */  private HCB hcb;    public HCB hcb() {      return hcb;  }    /**  * HCB对象，用于自动从连接池中获得HttpClient对象&lt;br&g...
HttpClient创建和封装,使用
怎么写，解决问题的博客
04-25 464
按照惯例直接上代码 import { Injectable } from '@angular/core'; import { HttpClient, HttpHeaders } from '@angular/common/http'; import { Observable, of } from 'rxjs'; import { Apis } from './Api'; /** * 封...
HttpClient5的基础封装
不专业的专业人士
03-31 3488
HttpClient5基础封装
CloseableHttpClient的用法
qq_42449963的博客
01-15 2万+
目录所用依赖Get请求方式举例POST请求方式举例例1：获取token代码结果接口文档Postman访问示例例2：获取知识图谱信息代码接口文档Postman访问示例例3：调用ES高级接口获取实体信息代码接口文档Postman访问示例拓展 所用依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version&
HttpClient详细解释
zhuwukai的博客
11-27 10万+
Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
HttpClient详细讲解
SeniorShen的博客
10-23 224
HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最...
应用HttpClient来对付各种顽固的WEB服务器
成长的天空
10-19 3299
    一般的情况下我们都是使用IE或者Navigator浏览器来访问一个WEB服务器，用来浏览页面查看信息或者提交一些数据等等。所访问的这些页面有的仅仅是一些普通的页面，有的需要用户登录后方可使用，或者需要认证以及是一些通过加密方式传输，例如HTTPS。目前我们使用的浏览器处理这些情况都不会构成问题。不过你可能在某些时候需要通过程序来访问这样的一些页面，比如从别人的网页中“偷”一些数据；利用某些
Java解析网络数（Json）运用CloseableHttpClient
qinghl的博客
09-05 5952
最近做用Java网络爬取数据的部分，发现在使用Apache的httpclient的时候，发现Idea提示DefaultHttpClient等常用的类已经不推荐使用了。现在运用 CloseableHttpClient和 CloseableHttpResponse类 Incorrect string value: '\xF0\x9F\x98\xAD",...'
HttpClient封装
最新发布
10-13
在封装HttpClient时，我们可以考虑以下几点： 1. 连接池管理：HttpClient可以通过连接池来管理HTTP连接，从而提高性能。我们可以设置最大连接数、每个路由的最大连接数等参数，以便更好地利用连接池。 2. 超时设置...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值