WebSocket使用文档之服务器消息通知功能

最新推荐文章于 2024-06-17 19:17:20 发布
最新推荐文章于 2024-06-17 19:17:20 发布
阅读量1.3k 收藏 4
点赞数
分类专栏： # java 网络通信汇总 文章标签： WebSocket socket Java Websocket
文章为作者自己原创文章，转载请注明出处，附上文章地址。
本文链接：https://blog.csdn.net/qq_37128049/article/details/96977671
版权

WebSocket使用文档

导航

一. WebSocket简介

1.1 概述

  • WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。

  • WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

  • 在 WebSocket API 中，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。

  • 现在，很多网站为了实现推送技术，所用的技术都是 Ajax 轮询。轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发出HTTP请求，然后由服务器返回最新的数据给客户端的浏览器。这种传统的模式带来很明显的缺点，即浏览器需要不断的向服务器发出请求，然而HTTP请求可能包含较长的头部，其中真正有效的数据可能只是很小的一部分，显然这样会浪费很多的带宽等资源。

  • HTML5 定义的 WebSocket 协议，能更好的节省服务器资源和带宽，并且能够更实时地进行通讯，图示如下：
    在这里插入图片描述

1.2 WebSocket实例

  • WebSocket 协议本质上是一个基于 TCP 的协议。
  • 为了建立一个 WebSocket 连接，客户端浏览器首先要向服务器发起一个 HTTP 请求，这个请求和通常的 HTTP 请求不同，包含了一些附加头信息，其中附加头信息"Upgrade: WebSocket"表明这是一个申请协议升级的 HTTP 请求，服务器端解析这些附加的头信息然后产生应答信息返回给客户端，客户端和服务器端的 WebSocket 连接就建立起来了，双方就可以通过这个连接通道自由的传递信息，并且这个连接会持续存在直到客户端或者服务器端的某一方主动的关闭连接

二. 通用服务端向浏览器发送消息示例

2.1 原理概述：

  • 首先引入spring-websocket 的jar包，然后引入一个Config对WebSocket进行配置，然后再配置一个WebSocket的类，这个类的作用是__建立连接__,发送消息,关闭连接，异常处理，等作用；
  • 它就相当于一个__通道__，浏览器的url指向了这个类的时候，它们就建立了一个连接，这个浏览器所持有的身份Token(即username)作为一个通道中的一个用户，加入了这个用户池；
  • 连接则加入用户池，断开连接则从用户池中移除，当然我们也可以查询出这个通道内的用户池里有多少个用户保持着连接状态；当发送消息的时候，会先判断用户池里是否有此用户，如果有才进行发送；
  • 当通道内某用户与此通道建立连接发生异常时，则进入异常的方法；我们可以在每个方法节点中扩展所需要的功能；比如我们也可以通过一个Controller引入这个WebSocket，调用里面的发送消息方法，则能进行服务器对浏览器的主动消息发送；

2.2 实战代码环境描述

  • 运行环境：JDK1.8
  • 工具：SVN IDEA
  • 版本控制工具： Maven 3
  • 项目环境: SpringBoot
  • 效果图演示：
    在这里插入图片描述

2.3 pom.xml

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>

引入websocket依赖

2.4 启动类：MySpringBootApplication.java

package com.demo;

import com.demo.controller.WebSocket;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

/**
 * create by: anyu
 */
@SpringBootApplication
public class MySpringBootApplication {
    public static void main(String[] args) {
//        SpringApplication springApplication = new SpringApplication(MySpringBootApplication.class);
//        ConfigurableApplicationContext configurableApplicationContext = springApplication.run(args);
//        //解决WebSocket不能注入的问题
//        WebSocket.setApplicationContext(configurableApplicationContext);
        SpringApplication.run(MySpringBootApplication.class,args);      //如果WebSocket要引入其他的类或者变量，则使用上面的，把注释去掉；这行的则进行注释；
    }


//
//    @Bean
//    RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder) {
//        return restTemplateBuilder.build();
//    }


}

这里被注释的内容后面再讲

2.5 application.yml:

#netty-websocket:
#  host: 127.0.0.1
server:
  port: 8055

  #  path: /
#  port: 1880

配置了端口号，这里可不配置直接使用默认的也可以

2.6 配置类：WebSocketConfig

package com.demo.controller;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

/**
 * websocket的配置
 */
@Configuration
public class WebSocketConfig {

    @Bean
    public ServerEndpointExporter serverEndpointExporter(){
        return new ServerEndpointExporter();
    }
}

对WebSocket的配置类，因为WebSocket是多例，所以每次需要New 一个新的；

2.7 消息载体：Message类

package com.demo.controller;

import lombok.Data;
import lombok.ToString;

import java.io.Serializable;

/**
 * @create_by: zhanglei
 * @craete_time 2019/7/18
 */
@Data
@ToString
public class Message implements Serializable {

    private String message;

    private String to;
}

这是一个实体类，它作为消息的载体使用； message ：消息内容， to： 发送给谁

2.8 核心类：WebSocket(类名和路径可变)

package com.demo.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * author:zhanglei
 * ServerEndpoint的java类，能够接受客户端发送过来的信息和发送给客户端信息
 */

@Component
@ServerEndpoint("/websocket/{username}")
public class WebSocket {

    private Logger logger = LoggerFactory.getLogger(this.getClass());
    /**
     * 在线人数
     */
    public static int onlineNumber = 0;
    /**
     * 以用户的姓名为key，WebSocket为对象保存起来
     */
    private static Map<String, WebSocket> clients = new ConcurrentHashMap<String, WebSocket>();
    /**
     * 会话
     */
    private Session session;
    /**
     * 用户名称
     */
    private String username;

    /* 注入@Value 的示例：*/
//    private static String port;
//
//    @Value("${server.port}")
//    public void getPort(String port) {
//        WebSocket.port = port;
//    }

    /* 注入@Autowired的示例：*/
//    //此处是解决无法注入的关键
//    private static ApplicationContext applicationContext;
//    //你要注入的service或者dao
//    private RestTemplate restTemplate;
//
//    public static void setApplicationContext(ApplicationContext applicationContext) {
//        WebSocket.applicationContext = applicationContext;
//    }
/**
 * 注意：
 *      1.  在@OnOpen注解下的这个open方法中  直接使用@Value和@Autowired是无法注入的，需要像上面一样注入才能注入配置的port或者下面的restTemplate
 *      2. 被注释的代码只是作为扩展参考，可以无需使用，直接删除即可；
 *      3. 原理介绍： 当前端浏览器连接的时候，使用 ws://...连接，会直接进入@Onpen方法内；
 *      4. 浏览器监听服务器返回的消息，是在@onMessage定义消息内容，通过引入此类，然后调用@OnMessage方法即可发送消息
 */


    /**
     * 建立连接
     *
     * @param session
     */
    @OnOpen
    public void onOpen(@PathParam("username") String username, Session session) {

        logger.info("现在来连接的客户id：" + session.getId() + "用户名：" + username);
        onlineNumber++;
//        System.out.println(port);
//        restTemplate= applicationContext.getBean(RestTemplate.class);
//        System.out.println("--------------");
//        System.out.println("端口号"+port);
//        System.out.println("-------------");
//        HttpHeaders headers = new HttpHeaders();
//        MultiValueMap<String, String> map = new LinkedMultiValueMap<String,String>();      //map里面是请求体的内容
//        map.add("token", "eyJhbGciOiJIUzI1NiJ9.eyJ1aWQiOiJ1aWQiLCJleHAiOjE1NjM3Mzc5Nzd9._NT8EQN9xOlRA1KMflV7vl9ByyBHI7rnG7emV0_CARA");
//        HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<MultiValueMap<String, String>>(map, headers);
//        ResponseEntity<String> response = restTemplate.postForEntity("http://10.4.7.214:9071/checkToken", request, String.class);       //地址替换为自己的
//        System.out.println(response.getBody());
//        ResponseResult responseResult = JSON.parseObject(response.getBody(), ResponseResult.class);
//        System.out.println(responseResult);
//        System.out.println("------");
//        System.out.println(responseResult.getResult().getUserAccount());
        this.username = username;
        this.session = session;
        clients.put(username, this);
        try {
            sendMessageTo(JSON.toJSONString("连接已成功建立"),username);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @OnError
    public void onError(Session session, Throwable error) {
        logger.info("服务端发生了错误" + error.getMessage());
    }

    /**
     * 连接关闭
     */
    @OnClose
    public void onClose() {
        clients.remove(username);
        onlineNumber--;
    }


    /**
     * 收到客户端的消息  对单发送
     *
     * @param message 消息
     * @param session 会话
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        try {
            JSONObject jsonObject = JSON.parseObject(message);
            String textMessage = jsonObject.getString("message");
            String tousername = jsonObject.getString("to");
            sendMessageTo(JSON.toJSONString(textMessage), tousername);
        } catch (Exception e) {
            logger.info("发生了错误了");
        }
    }

    public void sendMessageTo(String message, String ToUserName) throws IOException {
        for (WebSocket item : clients.values()) {
            if (item.username.equals(ToUserName)) {
                item.session.getAsyncRemote().sendText(message);
                break;
            }
        }
    }

    public void sendMessageAll(String message, String FromUserName) throws IOException {
        for (WebSocket item : clients.values()) {
            item.session.getAsyncRemote().sendText(message);
        }
    }


}

onlineNumber: 此通道内的连接人数。 clients它是一个集合，里面保存的数据就是连接的用户身份username; username: 代表用户名称（Token等，唯一身份标志，建立连接和接收消息都是这个）；
@OnOpen 创建连接则触发此注解下的方法； @OnClose 关闭连接触发的方法 @OnError发生错误触发的方法 @OnMessage 服务器给浏览器发送消息触发的方法
注释注销的内容，是有关于WebScoekt的引入；在@OnClose中无法直接通过@Autowired直接引入其他类或者@Value直接注入其他属性。因为Spring是单例模式，而WebSocket是多例模式，每次都会重新创建一个新的连接；直接使用@Value会报空，直接使用@Autowired引入其他类并使用其方法可能会导致异常。我们可以通过启动类将configurableApplicationContext装配进入webSocket，通过注释的内容可为每个WebSocket通道 单独创建；

2.9 接口类


package com.demo.controller;

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import javax.websocket.*;


@RestController
public class QuickController {

    @Autowired
    private WebSocket webSocket;

    @RequestMapping("/sendMsg")
    @ResponseBody
    public String sendMsg() throws Exception{
        Message message=new Message();
        message.setMessage("北京交通委提醒你：道路千万条，安全第一条，行车不规范，行人两行泪");
        message.setTo("用户a");
        String s = JSON.toJSONString(message);
        webSocket.onMessage(s,null);
        return "SUCCESS";
    }

}

此接口提供了一个sendMsg方法，它将消息内容和接收消息的人封装为一个Message对象，传入WebSocket的OnMessage方法内；通过OnMessage对浏览器发送消息；

2.10 静态页面测试：

<!DOCTYPE html>
<html>
<head>
    <title>websocket</title>
    <script type="text/javascript" src="http://ajax.microsoft.com/ajax/jquery/jquery-1.4.min.js"></script>
    <script src="http://cdn.bootcss.com/stomp.js/2.3.3/stomp.min.js"></script>
    <script src="https://cdn.bootcss.com/sockjs-client/1.1.4/sockjs.min.js"></script>
</head>
 
<body>
    <div style="margin: auto;text-align: center">
        <h1>Welcome to websocket</h1>
    </div>
    <br/>
    <div style="margin: auto;text-align: center">
        <select id="onLineUser">
            <option>--所有--</option>
        </select>
        <input id="text" type="text" />
        <button onclick="send()">发送消息</button>
    </div>
    <br>
    <div style="margin-right: 10px;text-align: right">
        <button onclick="closeWebSocket()">关闭连接</button>
    </div>
    <hr/>
    <div id="message" style="text-align: center;"></div>
    <input  type="text" value="用户a" id="username" style="display: none" />
</body>
 
 
<script type="text/javascript">
    var webSocket;
    var commWebSocket;
    if ("WebSocket" in window)
    {
        webSocket = new WebSocket("ws://localhost:8055/websocket/"+document.getElementById('username').value);
 
        //连通之后的回调事件
        webSocket.onopen = function()
        {
            //webSocket.send( document.getElementById('username').value+"已经上线了");
            console.log("已经连通了websocket");
            setMessageInnerHTML("已经连通了websocket");
        };
 
        //接收后台服务端的消息
        webSocket.onmessage = function (evt)
        {
            var received_msg = evt.data;
            console.log("数据已接收:" +received_msg);
            var obj = JSON.parse(received_msg);
            console.log("可以解析成json:"+obj.messageType);
            //1代表上线 2代表下线 3代表在线名单 4代表普通消息
            if(obj.messageType==1){
                //把名称放入到selection当中供选择
                var onlineName = obj.username;
                var option = "<option>"+onlineName+"</option>";
                $("#onLineUser").append(option);
                setMessageInnerHTML(onlineName+"上线了");
            }
            else if(obj.messageType==2){
                $("#onLineUser").empty();
                var onlineName = obj.onlineUsers;
                var offlineName = obj.username;
                var option = "<option>"+"--所有--"+"</option>";
                for(var i=0;i<onlineName.length;i++){
                    if(!(onlineName[i]==document.getElementById('username').value)){
                        option+="<option>"+onlineName[i]+"</option>"
                    }
                }
                $("#onLineUser").append(option);
 
                setMessageInnerHTML(offlineName+"下线了");
            }
            else if(obj.messageType==3){
                var onlineName = obj.onlineUsers;
                var option = null;
                for(var i=0;i<onlineName.length;i++){
                    if(!(onlineName[i]==document.getElementById('username').value)){
                        option+="<option>"+onlineName[i]+"</option>"
                    }
                }
                $("#onLineUser").append(option);
                console.log("获取了在线的名单"+onlineName.toString());
            }
            else{
                setMessageInnerHTML(obj.textMessage);
            }
        };
 
        //连接关闭的回调事件
        webSocket.onclose = function()
        {
            console.log("连接已关闭...");
            setMessageInnerHTML("连接已经关闭....");
        };
    }
    else{
        // 浏览器不支持 WebSocket
        alert("您的浏览器不支持 WebSocket!");
    }
    //将消息显示在网页上
    function setMessageInnerHTML(innerHTML) {
        document.getElementById('message').innerHTML += innerHTML + '<br/>';
    }
 
    function closeWebSocket() {
        //直接关闭websocket的连接
        webSocket.close();
    }
 
    function send() {
        var selectText = $("#onLineUser").find("option:selected").text();
        if(selectText=="--所有--"){
            selectText = "All";
        }
        else{
            setMessageInnerHTML(document.getElementById('username').value+"对"+selectText+"说："+ $("#text").val());
        }
        var message = {
            "message":document.getElementById('text').value,
            "username":document.getElementById('username').value,
            "to":selectText
        };
        webSocket.send(JSON.stringify(message));
        $("#text").val("");
 
    }
</script>
 
</html>

这个HTML页面由来自网上改编，所以有些代码不适用，只作为接收测试使用。实际按需求增删改；

2.11 测试说明：

  • 对应类的代码应该全部挨个建立完毕
  • 先运行启动类，然后浏览器访问1.8 的Html页面，然后按F12 进入调试；
  • 访问Controller的接口，然后消息就会发送到浏览器页面；
  • 效果如下：
    在这里插入图片描述

三. 在SpringCloud 项目中的注意点：

  • 当我们使用websocket在SpringCloud中时，由于websocket是长连接，gateway网关无法正常转发。我们可以使用如下配置正常转发：
    在这里插入图片描述
  • 代码为：
    
    /**
     * 说明：
     *      1. 对Socket微服务的websocket的转发配置，建立通道时的转发地址需要写入下方uri然后加入Bean
     *      2. 前端指向的接口url和这里配置的转发url除了端口号(前端指向9041|GateWay|网关   ----   后端转发指向9055|Socket-service)不一致，后面部分都必须一致；
     *      3. 使用网关进行连接时，需要有UserToken登录，非登录状态不能指向websocket转发地址，若需不登录进行连接则进入AuthorizeFilter配置过滤；
     * @param builder
     * @return
     */
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route(r -> r.path("socket-service")
                        .uri("https://localhost:9055/api/msgsocket/")
                        .uri("https://localhost:9055/api/msgsocket2/")
                        .uri("https://localhost:9055/api/pushCommon/")
                        .uri("https://localhost:9055/api/msgsocket3/")
                )
                .build();
    }

    这里的 /msgsocket 这些路径是映射的访问uri；如果这些接口需要从gateway跳转，则需要在此处加上；

暗余
关注
专栏目录
ESP32网络编程实例-WebSocket服务器广播信息
视觉与物联智能
12-16 1692
在本文中，我们将介绍如何向连接到 ESP32 服务器的所有 WebSocket 客户端广播消息。
WebSocket消息实时提醒
09-19
仅供参考，项目并不完整！
websocket通知
qq_34815027的博客
09-22 955
websocket通知
WebSocket 消息通知实现
lzfaq的博客
11-01 1333
WebSocket是一种在 TCP 连接上进行全双工通信的协议，建立客户端和服务器之间的通信渠道。浏览器和服务器仅需一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。
websocket 实时推送通知公告
才这么点的博客
01-17 3740
需求: 后台新增消息通知公告,并实时推送给客户端,好像用websocket可以很方便的解决这个问题,但是websocket有个弊端不兼容IE8,9后面查阅一些大牛博客,好像可以用web-socket-js 解决兼容性问题,这里也用了web-sokcet-js具体结果还需要测试 代码: 客户端 web-socket-js <html><head> ...
WebSocket实现消息实时通知
最新发布
坚强的泡沫的博客
06-17 1191
React+WebSocket实现消息实时通知
websocket文档
08-04
文档标题“websocket文档”以及描述“websocket 中文文档，是一个websocket API开发文档，为开发人员提供帮助”表明，该文档是为开发者准备的WebSocket API指南。标签“python webso”暗示该指南与Python语言和...
springmvc(18)使用WebSocket 和 STOMP 实现消息功能1
08-03
综上所述，Spring MVC 结合 WebSocket、SockJS 和 STOMP 可以构建出强大的实时交互功能，尤其在需要服务器主动推送给客户端信息的应用场景中，如实时通知、股票行情更新等。通过理解这些技术的工作原理和集成方式，...
HTTP Websocket 服务器推送消息
Fernwehzz的博客
05-30 609
文章目录HTTPHTTP请求过程1. 无状态2. 基于TCP协议心跳包3. 长、短连接4. 单向请求短轮询 polling长轮询 long pollingWebsocketSSE Server-Sent Events 短轮询 长轮询 Websocket Server-Sent Events 通信协议 http http 握手：http --> websocket http 触发方式 Js Ajax Js Ajax 事件 事件 优点 兼容性好容错性强，实现简单 比短轮询节约资源
zmeventnotification:基于机器学习的安全Websocket和基于MQTT的ZoneMinder事件通知服务器
04-18
事件通知服务器与ZoneMinder一起安装，并提供实时通知，对推送通知的支持以及机器学习支持的识别。 截止到今天，它支持： 检测80种物体（人，汽车等） 人脸识别 深度车牌识别 随着时间的推移，我将添加更多算法。 ...
websocket消息实时推送
08-22
做的一个简单的小案例，websocket实时推送消息，当执行一个操作后可以通知页面刷新
springboot集成websocket实现消息的主动推送
12-20
springboot集成websocket实现消息的主动推送，包含一对一以及通知所有在线用户
springboot 整合 websocket实现在线聊天和消息通知
ws - 兮的博客空间
07-04 3865
一、内容一览 本文由下文改进而来:https://blog.csdn.net/qq_41463655/article/details/92410518 适合做简易聊天室，多聊天室，发送接收消息可添加分组id 适合做及时消息通知 聊天页面，比较简陋 另外提供 WebSocketController web接口 API一览 发送消息/通知接口API 代码结构 二、代码部分 1、添加maven 依赖 <!-- websocket --> <dependen
服务端(后端)主动通知前端的实现：WebSocket(springboot中使用WebSocket案例)
qq_44073614的博客
09-01 6586
SpringBoot+WebSocket案例
websocket通知_vue + webSocket 实时任务信息通知
weixin_39925098的博客
01-08 689
vue + webSocket 实时任务信息通知websocketWebSocket 协议在2008年诞生，2011年成为国际标准。所有浏览器都已经支持了。它的最大特点就是，服务器可以主动向客户端推送信息，客户端也可以主动向服务器发送信息，是真正的双向平等对话，属于服务器推送技术的一种。特点建立在TCP协议之上，服务端的实现比较容易； 与HTTP协议有着良好的兼容性。默认端口也是80和443，并且...
WEB消息提醒实现之二 实现方式-websocket实现方式
热门推荐
艺俊的博客
04-20 2万+
websocket实现方式原理websocket的原理主要是，利用websocket提供的api，客户端只需要向服务器发起一次连接即可，然后服务器就可以主动地源源不断地向客户端发送数据，只要客户端不关闭浏览器，那么这个连接就会一直保持，从而达到真正意义上的长连接和服务器推。优点：只需要建立一次连接，服务器就可以源源不断地推送数据，资源消耗少，持久连接 缺点：需要浏览器支持websocket技术we
websocket通知_WebSocket服务器和客户端的一对多通知实现
weixin_42362068的博客
01-26 369
1. 依次启动Orchestra，websocket server for KOI app和WebSocket server for Webshop，也就是总共启动三台服务器。2. 启动本地的web Shop模拟器，启动两个，模拟一个user和多个web shop实例的场景。分别点两次KOI Login按钮，得到两个不同的transaction id:3. 分别把这两个transaction id...
实时消息传送：WebSocket实现系统后台消息实时通知
『愚』的博客
10-21 5574
WebSocket是一种双向通信协议，与传统的HTTP通信不同，它支持持久连接，使得服务器能够主动向客户端推送消息。这使得WebSocket成为实时通信和消息传送的理想选择。
Springboot集成WebSocket实现通知发送
u013432938的博客
08-22 598
Springboot集合若依前后端项目整合WebSocket实现系统消息推送
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

暗余

码字来之不易，您的鼓励我的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值