使用HttpClient从一个接口跳转到另一个url对应的Controller控制器

最新推荐文章于 2022-12-25 09:47:30 发布
最新推荐文章于 2022-12-25 09:47:30 发布
阅读量1.9k 收藏 3
点赞数
分类专栏： HttpClient Java 编程思想
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lk142500/article/details/87926012
版权

1简介

最近在南京出差时，在对接一个平台时，根据事件类型订阅关注的事件，通过传送目标地址，平台会自动推送相关的把请求体封装成JSONObject，自己呢则是需要对这部分的事件进行简单的数据组织，然后以一种特定的形式把数据发送到上一层。由于在程序运转时使用Http协议，因此尝试使用HttpClient来实现该功能。超文本传输协议HTTP是当今互联网上最火的传输协议，因此熟练的掌握HTTP协议的类型和含义，参数传递，header的含义，在程序员的日常生活中占据着很重要的作用。

2问题介绍

HttpClient官网介绍了HttpClient的使用。
HttpClient Tutorial，基本的HttpClient相关知识均可以在此页面获取

2.1Maven jar包引入

		<dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient-win</artifactId>
            <version>4.5.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient-cache</artifactId>
            <version>4.5.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpmime -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.3</version>
        </dependency>

        <dependency>
            <groupId>commons-httpclient</groupId>
            <artifactId>commons-httpclient</artifactId>
            <version>3.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.6</version>
        </dependency>

2.2 HttpClient Quick Start

下面这部分的代码是HttpClient官网提供的demo演示，详细阐述了Get请求和Post请求的使用过程，具体代码如下：

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
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.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * @Owner:
 * @Time: 2019/2/25-21:13
 */
public class A {
    public void demo() throws IOException {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpGet httpGet = new HttpGet("http://targethost/homepage");
        CloseableHttpResponse response1 = httpclient.execute(httpGet);
    // The underlying HTTP connection is still held by the response object
    // to allow the response content to be streamed directly from the network socket.
    // In order to ensure correct deallocation of system resources
    // the user MUST call CloseableHttpResponse#close() from a finally clause.
    // Please note that if response content is not fully consumed the underlying
    // connection cannot be safely re-used and will be shut down and discarded
    // by the connection manager.
        try {
            System.out.println(response1.getStatusLine());
            HttpEntity entity1 = response1.getEntity();
            // do something useful with the response body
            // and ensure it is fully consumed
            EntityUtils.consume(entity1);
        } finally {
            response1.close();
        }

        HttpPost httpPost = new HttpPost("http://targethost/login");
        List<NameValuePair> nvps = new ArrayList<NameValuePair>();
        nvps.add(new BasicNameValuePair("username", "vip"));
        nvps.add(new BasicNameValuePair("password", "secret"));
        httpPost.setEntity(new UrlEncodedFormEntity(nvps));
        CloseableHttpResponse response2 = httpclient.execute(httpPost);

        try {
            System.out.println(response2.getStatusLine());
            HttpEntity entity2 = response2.getEntity();
            // do something useful with the response body
            // and ensure it is fully consumed
            EntityUtils.consume(entity2);
        } finally {
            response2.close();
        }
    }
}

3代码解析

3.1 代码

在项目中，自己东拼西凑最后写了如下可以运行的代码，经验证，代码可以执行预期的功能，如下所示：

package com.cechi.controller;

import com.alibaba.fastjson.JSONObject;
import com.cetc52.platform.config.ServerConfig;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
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.client.utils.URIBuilder;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
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.CharArrayBuffer;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 处理上报的事件
 *
 * @Owner:
 * @Time: 2019/1/30-10:12
 */
@Controller
@RequestMapping(value = "/eventService/api")
public class EventHandle {
    private static String HTTP = "http";
    @Autowired
    private ServerConfig serverConfig;

    @PostMapping("/eventSubscriptionByEventTypes")
    @ResponseBody
    public String eventUpload(@RequestBody JSONObject eventInfo) {
        System.out.println(eventInfo.toJSONString());
        CloseableHttpClient httpClient = HttpClients.createDefault();
        String url = serverConfig.getUrl()+ "/eventService/api/v1/eventHandleGet?userId=1000";
        get(url);

        String url2 = serverConfig.getUrl()+ "/eventService/api/v1/eventHandleGetMap1?a=b&b=c";
        Map<String, String> param = new HashMap<>();
        param.put("a", "b");
        param.put("b", "c");
        get(url2);

        String postUrlMap = serverConfig.getUrl()+"/eventService/api/v1/eventHandlePostMap";
        postMap(postUrlMap,param);

        String postUrlJson = serverConfig.getUrl()+"/eventService/api/v1/eventHandlePostJson";
        postJson(postUrlJson, JSONObject.toJSONString(param));
        return eventInfo.toJSONString();
    }

    @GetMapping("/v1/eventHandleGet")
    @ResponseBody
    public void eventInfoComposing(@RequestParam String userId) {
        System.out.println("eventInfoComposing begins");
        System.out.println("userId = "+ userId);
        return ;
    }

    @GetMapping("/v1/eventHandleGetMap1")
    @ResponseBody
    public void getMap1(@RequestParam String a, @RequestParam String b) {
        System.out.println("getMap1 begins");
        System.out.println(a+"&"+ b);
        return ;
    }

    @PostMapping("/v1/eventHandlePostMap")
    @ResponseBody
    public String postMapImpl(@RequestBody JSONObject param) {
        System.out.println("postMapImpl begins");
        System.out.println(param.toJSONString());
        return param.toJSONString();
    }

    @PostMapping("/v1/eventHandlePostJson")
    @ResponseBody
    public String postJsonImpl(@RequestBody JSONObject param) {
        System.out.println("postJsonImpl begins");
        System.out.println(param.toJSONString());
        return param.toJSONString();
    }

    private String entityToString(HttpEntity entity) throws IOException {
        String result = null;
        if(entity != null)
        {
            long lenth = entity.getContentLength();
            if(lenth != -1 && lenth < 2048)
            {
                result = EntityUtils.toString(entity,"UTF-8");
            }else {
                InputStreamReader reader1 = new InputStreamReader(entity.getContent(), "UTF-8");
                CharArrayBuffer buffer = new CharArrayBuffer(2048);
                char[] tmp = new char[1024];
                int l;
                while((l = reader1.read(tmp)) != -1) {
                    buffer.append(tmp, 0, l);
                }
                result = buffer.toString();
            }
        }
        return result;
    }
    /**
     * get请求，参数拼接在地址上
     * @param url 请求地址加参数
     * @return 响应
     */
    public String get(String url)
    {
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpGet get = new HttpGet(url);
        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(get);
            if(response != null && response.getStatusLine().getStatusCode() == 200)
            {
                HttpEntity entity = response.getEntity();
                result = entityToString(entity);
            }
            return result;
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                httpClient.close();
                if(response != null)
                {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * get请求，参数放在map里
     * @param url 请求地址
     * @param map 参数map
     * @return 响应
     */
    public String getMap(String url,Map<String,String> map)
    {
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        List<NameValuePair> pairs = new ArrayList<NameValuePair>();
        for(Map.Entry<String,String> entry : map.entrySet())
        {
            pairs.add(new BasicNameValuePair(entry.getKey(),entry.getValue()));
        }
        CloseableHttpResponse response = null;
        try {
            URIBuilder builder = new URIBuilder(url);
            builder.setParameters(pairs);
            HttpGet get = new HttpGet(builder.build());
            response = httpClient.execute(get);
            if(response != null && response.getStatusLine().getStatusCode() == 200)
            {
                HttpEntity entity = response.getEntity();
                result = entityToString(entity);
            }
            return result;
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                httpClient.close();
                if(response != null)
                {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return null;
    }

    /**
     * 发送post请求，参数用map接收
     * @param url 地址
     * @param map 参数
     * @return 返回值
     */
    public String postMap(String url,Map<String,String> map) {
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost post = new HttpPost(url);

        List<NameValuePair> pairs = new ArrayList<NameValuePair>();
        for(Map.Entry<String,String> entry : map.entrySet())
        {
            pairs.add(new BasicNameValuePair(entry.getKey(),entry.getValue()));
        }
        CloseableHttpResponse response = null;
        try {
            post.setHeader("Content-Type", "application/json;charset=UTF-8");
            StringEntity stringEntity = new StringEntity(JSONObject.toJSONString(map), "utf-8");
            stringEntity.setContentEncoding("utf-8");
            stringEntity.setContentType("application/json");
            post.setEntity(stringEntity);
            response = httpClient.execute(post);
            if(response != null && response.getStatusLine().getStatusCode() == 200)
            {
                HttpEntity entity = response.getEntity();
                result = entityToString(entity);
            }
            return result;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                httpClient.close();
                if(response != null)
                {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        return null;
    }

    /**
     * post请求，参数为json字符串
     * @param url 请求地址
     * @param jsonString json字符串
     * @return 响应
     */
    public String postJson(String url,String jsonString)
    {
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost post = new HttpPost(url);

        CloseableHttpResponse response = null;
        try {
            post.setEntity(new ByteArrayEntity(jsonString.getBytes("UTF-8")));
            post.setHeader("Content-Type","application/json" );
            response = httpClient.execute(post);
            if(response != null && response.getStatusLine().getStatusCode() == 200)
            {
                HttpEntity entity = response.getEntity();
                result = entityToString(entity);
            }
            return result;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                httpClient.close();
                if(response != null)
                {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

3.2 使用IDEA自带的Test Restful Web Service调试

Tools - > Http Client - > Test Restful Web Service

@PostMapping("/eventSubscriptionByEventTypes")

对应的接口为平台上报事件的接口，与事件相关的信息会保存在eventInfo参数中，在该接口中，预期要对eventInfo进行重新的事件信息整理，并通过HttpClient发送到对应的4个接口，其中两个get请求，两个Post请求，一个get请求不带参数，一个带参数，而两个Post请求一个参数的形式为map，一个参数的形式为JsonString。
在这里插入图片描述

3.2 Console结果

{"a":"b","b":"c"}
eventInfoComposing begins
userId = 1000
getMap1 begins
b&c
postMapImpl begins
{"a":"b","b":"c"}
postJsonImpl begins
{"a":"b","b":"c"}

可以看到通过调用

postMap(postUrlMap,param);

的请求，函数执行确实走到了四个对应的接口。

3.3 postMap和postJson函数分析

3.3.1postMap

public String postMap(String url,Map<String,String> map) {
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost post = new HttpPost(url);

        List<NameValuePair> pairs = new ArrayList<NameValuePair>();
        for(Map.Entry<String,String> entry : map.entrySet())
        {
            pairs.add(new BasicNameValuePair(entry.getKey(),entry.getValue()));
        }
        CloseableHttpResponse response = null;
        try {
            post.setHeader("Content-Type", "application/json;charset=UTF-8");
            StringEntity stringEntity = new StringEntity(JSONObject.toJSONString(map), "utf-8");
            stringEntity.setContentEncoding("utf-8");
            stringEntity.setContentType("application/json");
            post.setEntity(stringEntity);
            response = httpClient.execute(post);
            if(response != null && response.getStatusLine().getStatusCode() == 200)
            {
                HttpEntity entity = response.getEntity();
                result = entityToString(entity);
            }
            return result;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                httpClient.close();
                if(response != null)
                {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        return null;
    }

重点关注post请求header的设置以及Map参数的设置的过程。

3.3.2 postJson

public String postJson(String url,String jsonString)
    {
        String result = null;
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost post = new HttpPost(url);

        CloseableHttpResponse response = null;
        try {
            post.setEntity(new ByteArrayEntity(jsonString.getBytes("UTF-8")));
            post.setHeader("Content-Type","application/json" );
            response = httpClient.execute(post);
            if(response != null && response.getStatusLine().getStatusCode() == 200)
            {
                HttpEntity entity = response.getEntity();
                result = entityToString(entity);
            }
            return result;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                httpClient.close();
                if(response != null)
                {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

关注的重点也是在header的设置以及参数的设置。

注意：http://host:port/anno/obj?id=1&name=xx

整体才对应于url，而get请求的参数并非写在url的后main而是写入了Entity中。

3.4 HttpClient使用流程总结

  1. 创建HttpClient对象。
  2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。
  3. 如果需要发送请求参数，可调用HttpGetsetParams方法来添加请求参数；对于HttpPost对象而言，可调用setEntity(HttpEntity entity)方法来设置请求参数。
  4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse对象。
  5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。
  6. 释放连接。无论执行方法是否成功，都必须释放连接

4 总结

HttpClient是一个非常重要的知识点积累，对于程序员来说，自己也购买了图解HTTP这本经典书，弄清楚HTTP超文本协议的具体使用过程和header含义、工作原理对于程序员来说非常重要，值得认真的研究。

5参考

HttpClient学习研究总结
HttpClient工具类
关于重定向

思影影思
关注
专栏目录
controller接收httpclient请求
AiNiBuLiBuQi的博客
12-21 1657
如果controller放在现有的项目中， 要绕过登录验证 要responseBody返回xml需要配置applicationContext-mvc配置文件增加<mvc:annotation-driven/> 实体类加xml注解 @Controller @RequestMapping("appTestVpn") public class AppTestVpnController extends B
十、HTTP 缓存——HTTP 缓存与HttpClient客户端缓存
最新发布
流楚丶格念的博客
08-25 590
在日常开发中，浏览器缓存是一个非常常见但又容易被忽视的优化手段。许多开发者在面对浏览器缓存相关问题时可能会感到困惑，因此本章内容专门用来解答这些常见问题，并帮助你更好地理解如何在 Java 应用中控制浏览器缓存。浏览器缓存是指在用户使用浏览器访问网站页面或 HTTP 服务时，根据服务器端返回的缓存控制响应头，将响应内容缓存到本地浏览器。这样，下次访问相同资源时，浏览器可以直接使用缓存内容，或者仅与服务器验证内容是否过期，从而减少网络传输的数据量，提升网站性能。public。
HttpClient 实现跳转请求
cl1771066100的专栏
07-30 1070
实现servlet的跳转，以输入流的形式来传输数据 测试UnionPayServlet的httpClient测试类：   package com.abin.lee.https; import java.io.IOException; import java.io.OutputStream; import java.io.OutputStreamWriter;
httpclient自动跳转的问题
yinkai1205的专栏
06-21 7080
httpclient4.0版本中，使用get请求时，遇到302会自动跳转，如果需要得到302中location的信息， 可以用post方法去请求或者把get自动处理重定向禁掉。  要禁用get方法自动处理重定向，需要设一下参数：  Java代码   HttpClient httpclient = new DefaultHttpClient();   Htt
httpclient处理页面跳转
weixin_33912246的博客
10-01 172
在JSP/Servlet编程中response.sendRedirect方法就是使用HTTP协议中的重定向机制。它与JSP中的&lt;jsp:forward …&gt;的区别在于后者是在服务器中实现页面的跳转，也就是说应用容器加载了所要跳转的页面的内容并返回给客户端；而前者是返回一个状态码，这些状态码的可能值见下表，然后客户端读取需要跳转到的页面的URL并重新加载新的页面。就是这样一个过程，所...
面试官：项目中如何解决跨域问题（HttpClient、注解、网关）
m0_71777195的博客
12-25 198
因为浏览器的同源政策，就会产生跨域。比如说发送的异步请求是不同的两个源，就比如是不同的的两个端口或者不同的两个协议或者不同的域名。由于浏览器为了安全考虑，就会产生一个同源政策，不是同一个地方出来的是不允许进行交互的。在控制层加入允许跨域的注解使用httpclient，不依赖浏览器使用网关Gateway。
razor页面跳转_如何在Blazor中使用Razor页面创建单页应用程序
cumi6497的博客
07-23 2862
razor页面跳转In this article, we are going to create a Single Page Application (SPA) using Razor pages in Blazor, with the help of the Entity Framework Core database first approach. 在本文中，我们将借助Entity Frame...
一个基本的spring mvc项目搭建（入门）
凤歌
12-09 1976
一个简单的spring mvc项目搭建
Spring Cloud Alibaba从入门到精通！
程序媛小琬的博客
09-29 4466
前台 一. 课程介绍 1.1 课程导学 什么是SpringCloudAlibaba? 阿里巴巴结合自身微服务实践，开源的微服务全家桶 在Spring Cloud项目中孵化，很可能成为Spring Cloud第二代标准的实现 在业界广泛使用，已有很多成功案例 Spring Cloud Alibaba真实应用场景 大型复杂的系统，例如大型电商系统 高并发系统，例如大型门户，秒杀系统 需求不明确，且变更很快的系统，例如初创公司业务系统 Spring Cloud Alibaba与Spring C
HttpClient页面跳转处理
Humn_chou
05-15 259
[size=medium]本文来源 http://yefeng.iteye.com/blog/112565 在JSP/Servlet编程中response.sendRedirect方法就是使用HTTP协议中的重定向机制。它与JSP中的的区别在于后者是在服务器中实现页面的跳转，也就是说应用容器加载了所要跳转的页面的内容并返回给客户端；而前者是返回一个状态码，这些状态码的可能值见下表，然后客户端...
AE接口跳转(QI)
qq_40098572的博客
12-03 1461
对于所有了解AE开发的人，都知道AE是基于接口编程的，AE中所有的类（Class）都是通过接口实现的，我个人认为这是一个极好的架构，对于扩张程序是非常方便的。比如说， 当我自定义一个地图操作类时，我就可以使用AE中定义好的接口，实现这些接口的属性和方法。但是当我们不用接口，而是将它全部都写成为类，这在后期要实现更改类的方法或是属性时，后期的维护工作可想而知有多大了。但对于接口来说，就不一样了，我们可以在接口中定义属性和方法，再让这些类实现这些属性和方法便可，不需要对类做大手术，既节省时间，又节...
使用HTTPCLIENT进行带参数跨域跳转
johennes的专栏
12-27 3599
1. 首先在工程中加入commons-httpclient-3.0.jar 2. 应用方法实例： public ModelAndView dispatchPage(HttpServletRequest request, HttpServletResponse response) throws IOException, ClassNotFoundException{
三种跳转方式
wuhuagu_wuhuaguo的博客
04-25 1955
原生的 Header(“location:网址”);   Yii或ThinkPHP框架下的php $this->redirect(“网址”);   Js Window.location.href=”网址”;
spring MVC 管理HttpClient---实现在java中直接向Controller发送请求
小兵qwer的专栏
01-18 2520
在spring MVC中，大多数时候是由客户端的页面通过ajax等方式向controller发送请求，但有时候需要在Java代码中直接向controller发送请求，这时可以使用HttpCilent实现。 首先用到的包是httpclient-4.3.5.jar和httpcore-4.3.2.jar  先看下面代码： [java] view plain copy
httpclient登录接口出参的token怎么放到下一个接口的请求头啊
01-13
在使用 HttpClient 登录接口后，获取到登录接口的出参中的 token，可以通过以下步骤将 token 放到下一个接口的请求头中。 1. 首先，使用 HttpClient 发送登录请求并获取到登录接口的出参。可以通过 HttpClient 发送...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值