WebSocket 双工通信的 案例

最新推荐文章于 2025-03-26 16:23:37 发布
最新推荐文章于 2025-03-26 16:23:37 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： websocket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/liulihui1988/article/details/112008087
版权
  • 什么是WebSocket

WebSocket是一种在单个TCP连接上进行全双工通信的协议;

  • 描述

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

  • 优点

很多网站为了实现推送技术，所用的技术都是轮询。轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发出HTTP请求，然后由服务器返回最新的数据给客户端的浏览器。这种传统的模式带来很明显的缺点，即浏览器需要不断的向服务器发出请求，然而HTTP请求可能包含较长的头部，其中真正有效的数据可能只是很小的一部分，显然这样会浪费很多的带宽等资源。
而比较新的技术去做轮询的效果是Comet。这种技术虽然可以双向通信，但依然需要反复发出请求。而且在Comet中，普遍采用的长链接，也会消耗服务器资源。在这种情况下，HTML5定义了WebSocket协议，能更好的节省服务器资源和带宽，并且能够更实时地进行通讯；

::::不瞎逼逼了，以上概要来自 百度百科

  • 直接上代码 WebSocket server
package carloan.common.socket;

import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

/**
 * 
 * * @ServerEndpoint 注解是一个类层次的注解，
 *   它的功能主要是将目前的类定义成一个websocket服务器端,
 *   注解的值将被用于监听用户连接的终端访问URL地址,
 *   客户端可以通过这个URL来连接到WebSocket服务器端
 * ClassName: WebSocket
 * @date 2020年12月28日 下午6:07:43
 * @author llh
 * @version 
 * @since JDK 1.8
 */
@ServerEndpoint("/websocket/{userId}/ws")
@Component
public class WebSocket {
	
	private static Log log = LogFactory.getLog(WebSocket.class);
	// 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
	private volatile static int onlineCount = 0;
	// 客户端回话集合
	private static ConcurrentHashMap<String, UserSocket> sessions = new ConcurrentHashMap<String, UserSocket>();


	class UserSocket {
		Session session;
		String userId;

		UserSocket(String uid, Session s) {
			session = s;
			userId = uid;
		}

		public void sendMessage(String message) {
		log.error("sendMessage,Session:" + this.session.getId() + ";uid=" + this.userId);
				if (this.session.isOpen()){
					this.session.getAsyncRemote().sendText(message);
				}
		}
		
		public int sendOnLineUserCount(int userCount) {
			this.sendMessage("setOnLineUserCount," + userCount + "");// 在线人数
			return 1;
		}
		
		public int sendTodotasknumber(String todotasknumbers) {
			this.sendMessage("todotasknumbers," + todotasknumbers);// 推送代办的数量
			return 1;
		}
		
		public int sendMessagenumbers(String messagenumbers) {
			this.sendMessage("messagenumbers," + messagenumbers);// 推送代办站内信数量
			return 1;
		}

	}

	/**
	 * 连接建立成功调用的方法
	 * 
	 * @param session
	 *  可选的参数。session为与某个客户端的连接会话，需要通过它来给客户端发送数据
	 */
	@OnOpen
	public void onOpen(Session session, @PathParam("userId") String userId) {

		log.error("onOpen,Session:" + session.getId() + ";uid:" + userId );

		int userCount = 0;
		UserSocket us = new UserSocket(userId, session);
		sessions.put(session.getId(), us);
		
		synchronized (WebSocket.class) {
			userCount = ++onlineCount;
		}
		log.error("onOpen Session Count:" + userCount);
	}

	/**
	 * 连接关闭调用的方法
	 */
	@OnClose
	public void onClose(Session session, @PathParam("userId") String userId) {
		log.error("onClose,Session:" + session.getId());
		int userCount = 0;
		if (sessions.containsKey(session.getId())) {
			sessions.remove(session.getId());

			synchronized (WebSocket.class) {
				userCount = --onlineCount;
			}
		}
		log.error("onClose Session Count:" + userCount);
	}

	/**
	 * 收到客户端消息后调用的方法
	 * @param message 客户端发送过来的消息
	 * @param session 可选的参数
	 * @throws IOException 
	 */
	@OnMessage
	public void onMessage(@PathParam("userId") String userId,Session session,String message) throws IOException {
		log.error("onMessage,Session:" + session.getId() + ";MSG=" + message);
		sendMessage(message);
	}

	/**
	 * 发生错误时调用
	 * 
	 * @param session
	 * @param error
	 */
	@OnError
	public void onError(Session session, Throwable error) {
		log.error("onError,Session:" + session.getId() + ";MSG=" + error.toString());
		
	}
	
	
	int sendcount=0;
	@Scheduled(cron = "0/2 * * * * ?")
	public void sendCount(){
		if (sendcount!=onlineCount){
			sendcount=onlineCount;
			setOnLineUserCount(sendcount);
		}
	}


	/**
	 * 发给指定用户
	 * @param userId 用户id
	 * @param message
	 * @throws IOException
	 */
	public static void sendMessageByUserId(String userId, String message) throws IOException {
		
		Iterator<Map.Entry<String, UserSocket>> entries = sessions.entrySet().iterator();  
		while (entries.hasNext()) {  
		  
		    Map.Entry<String, UserSocket> entry = entries.next();  
		  
		    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  
		    
		    if (entry.getValue().userId != null && entry.getValue().userId.equalsIgnoreCase(userId)) {
		    	entry.getValue().sendMessage(message);
			}
		}  
	}
	
	
	/**
	 * 发给所有用户
	 * @param message
	 * @throws IOException
	 */
	public static void sendMessage(String message) throws IOException {

		Iterator<Map.Entry<String, UserSocket>> entries = sessions.entrySet().iterator();
		while (entries.hasNext()) {

			Map.Entry<String, UserSocket> entry = entries.next();

			System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());

			if (null != entry.getValue().userId) {

				entry.getValue().sendMessage(message);

			}
			
		}
		
	}

	/**
	 * 描述：得到在线人数
	 * @param:
	 */
	public static int getOnLineUserCount() {
			return WebSocket.onlineCount;
	}


	
	static boolean  isSending=false;

	/**
	 * 描述：设置在线人数
	 * @param:
	 */
	public static void setOnLineUserCount(int userCount) {

		try{
			Iterator<Map.Entry<String, UserSocket>> entries = sessions.entrySet().iterator();  
			int i=0;
			log.error("开始发送:"+i);
			while (entries.hasNext()) {  
			  
			    Map.Entry<String, UserSocket> entry = entries.next();  
			    entry.getValue().sendOnLineUserCount(userCount);
			    i++;
			} 
			log.error("发送数量:"+i);
		}catch(Exception e){
			e.printStackTrace();
		}finally {
			isSending=false;
		}
	}

	

	public static void sendWebSocketTodotasknumber(String userId, String todotasknumbers) throws IOException {
			
			Iterator<Map.Entry<String, UserSocket>> entries = sessions.entrySet().iterator();  
			int i=0;
			log.error("开始发送:"+i);
			while (entries.hasNext()) {  
			  
			    Map.Entry<String, UserSocket> entry = entries.next();  
			    if (entry.getValue().userId != null && entry.getValue().userId.equalsIgnoreCase(userId)) {
			    	entry.getValue().sendTodotasknumber(todotasknumbers);
				}
			    i++;
			}  
			log.error("开始数量:"+i);
	}


	/**
	 * 
	 * 描述：代办站内数量推送
	 * @param:
	 */
	public static void sendWebSocketMessagenumbers(String userId, String messagenumbers) throws IOException {
			
			Iterator<Map.Entry<String, UserSocket>> entries = sessions.entrySet().iterator();  
			while (entries.hasNext()) {  
			  
			    Map.Entry<String, UserSocket> entry = entries.next();  
			    if (entry.getValue().userId != null && entry.getValue().userId.equalsIgnoreCase(userId)) {
			    	entry.getValue().sendMessagenumbers(messagenumbers);
				}
			}  
	}

	/**
	 * 根据用户id发送消息（通用）
	 * @param userId 用户ID
	 * @param businessType 业务类型
	 * @param message 消息
	 */
	public static void sendMessageCommon(String userId, String businessType, String message){

		for (Map.Entry<String, UserSocket> entry : sessions.entrySet()) {

			UserSocket userSocket = entry.getValue();

			if (null != userSocket.userId && userSocket.userId.equals(userId)){
				userSocket.sendMessage(businessType + "," + message);
			}
		}
	}

}
  • 前端 jsp页面代码
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<body>
    Welcome：<span>index</span><br/>
    <input id="userId" type="hidden"  value="${userId}"/>
    <input id="host" type="hidden"  value="${host}"/>
    <input id="text" type="text" />
    <button onclick="send()">Send</button>
    <button onclick="closeWebSocket()">Close</button>
    <div id="message"></div>
</body>

<script type="text/JavaScript">
      var websocket = null;
      var userId = document.getElementById('userId').value;
      var host = document.getElementById('host').value;
      //判断当前浏览器是否支持WebSocket
      if('WebSocket' in window){
          websocket = new WebSocket("ws://"+host+"/websocket/"+userId+"/ws?userId="+userId);
      }else{
          alert('Not support websocket');
      }    
      //连接发生错误的回调方法
      websocket.onerror = function(){
    	  console.log("websocket error");
          //setMessageInnerHTML("error");
      };     
      //连接成功建立的回调方法
      websocket.onopen = function(event){
    	  console.log("websocket open");
          //setMessageInnerHTML("websocket open");
      };      
      //接收到消息的回调方法
      websocket.onmessage = function(){
    	  console.log(event.data);
          var note=event.data;
          if(note.split(',')[0]=='setOnLineUserCount'){//在线人数
 			 //$("#usernumber").html(note.split(',')[1]);
 			setMessageInnerHTML("在线人数:"+note.split(',')[1]);
 		 }else if(note.split(',')[0]=='todotasknumbers'){//代办数量
 			 $("#todotasknumbers").html(note.split(',')[1]);
 		 }else if(note.split(',')[0]=='bidBusiessPolicyOrderUpdate'){//核保审核结果
 			 //$("#todotasknumbers").html(note.split(',')[1]);
 			setMessageInnerHTML("核保审核结果:"+note.split(',')[1]);
 		 }else{
        	  setMessageInnerHTML(event.data);
 		 }
          
          
      };     
      //连接关闭的回调方法
      websocket.onclose = function(){
    	  console.log("websocket close");
          //setMessageInnerHTML("websocket close");
      };       
      //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
      window.onbeforeunload = function(){
          websocket.close();
      };       
      //将消息显示在网页上
      function setMessageInnerHTML(innerHTML){
          document.getElementById('message').innerHTML += innerHTML + '<br/>';
      } 
      //关闭连接
      function closeWebSocket(){
          websocket.close();
      }  
      //发送消息
      function send(){
          var message = document.getElementById('text').value;
          websocket.send(message);
      }
  </script>

</html>
  • ws.jsp页面跳转 Controller
@Controller
@RequestMapping("/webSocket")
public class WebSocketController {
    @Value("${server.host}")
    private String serverUrl;
	
    @EscapeLogin
    @RequestMapping("/socket")
    public String index(HttpSession session,Model mode){
    	mode.addAttribute("userId", 114540);
    	mode.addAttribute("host", serverUrl);
        return"websocket/ws";
    }

}
  • Socket 安全认证

非spring boot 项目架构 这里集成已过滤器Filter ,没做token 校验，就以userId有效性判断;

package carloan.core.filter;

import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.context.support.SpringBeanAutowiringSupport;

import com.alibaba.fastjson.JSON;

import carloan.common.param.ApiResponse;
import carloan.permission.domain.PmsUser;
import carloan.permission.mapper.PmsUserMapper;

/**
 * 
 *
 * ClassName: SessionSocketFilter
 * @Description:WebSocket 过滤认证
 * @date 2020年12月29日 下午4:44:04
 * @author llh
 * @version 
 * @since JDK 1.8
 */
public class SessionWebSocketFilter extends SpringBeanAutowiringSupport implements Filter {

    private static final Logger logger = LoggerFactory.getLogger(SessionWebSocketFilter.class);
    @Autowired
	private PmsUserMapper pmsUserMapper;

    public void init(FilterConfig filterConfig) throws ServletException {
    	logger.error("服务器启动>>>>>>>>>");
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
            ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        logger.error("request url={}",httpRequest.getRequestURI());
        String userId = (String)httpRequest.getParameter("userId");
        if(StringUtils.isEmpty(userId)){
        	handleFailure(httpResponse, ApiResponse.AUTHENTICATION_FAILURE);
        	return;
        }
        PmsUser userInfo = pmsUserMapper.selectByPrimaryKey(Integer.parseInt(userId));
        String phone = pmsUserMapper.selectDepositUserByuserId(Integer.parseInt(userId));
        if(!(null!=userInfo || null!=phone)){
        	handleFailure(httpResponse, ApiResponse.AUTHENTICATION_FAILURE);
        	return;
        }
        chain.doFilter(request, response);
    }
    
    public void destroy() {
    	logger.error("服务器关闭>>>>>>>>>");
    }

    private void handleFailure(HttpServletResponse response, ApiResponse apiResponse) throws IOException {
        response.setStatus(HttpServletResponse.SC_OK);
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        response.setCharacterEncoding(StandardCharsets.UTF_8.name());
        PrintWriter out = response.getWriter();
        out.println(JSON.toJSONString(apiResponse));
        out.flush();
    }

}
  • web.xml 配置过滤器
    <!-- start 过滤 WebSocket 认证 -->
    <filter>
        <filter-name>sessionWebSocketFilter</filter-name>
        <filter-class>carloan.core.filter.SessionWebSocketFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>sessionWebSocketFilter</filter-name>
        <url-pattern>/websocket/*</url-pattern>
    </filter-mapping>
    <!-- end -->

启动服务 浏览器甩 http://127.0.0.1:7081/webSocket/socket

在这里插入图片描述

前端领域：掌握WebSocket实现全双工通信
前端视界的博客
05-30 782
在当今的互联网世界里，实时交互变得越来越重要。比如聊天软件要能即时收到对方的消息，在线游戏要能让玩家实时看到其他玩家的动作。我们这篇文章的目的就是教大家在前端领域使用WebSocket技术来实现全双工通信，让网页也能像这些软件一样实现实时交互。范围主要集中在前端，会详细介绍WebSocket的使用方法、相关原理以及实际应用案例。接下来的内容，我们会先解释WebSocket和全双工通信的核心概念，让你明白它们是什么；然后讲这些概念之间的关系，以及它们的原理和架构；再通过代码详细介绍实现全双工通信的具体步骤；
ESP8266开发之旅 网络篇⑲ WebSocket Server——全双工通信
单片机菜鸟哥的博客
02-21 2902
文章目录1.前言2. WebSocket协议2.1 客户端发起WS请求2.2 服务器响应WS请求2.3 WS数据交互协议3. arduinoWebSockets —— ESP8266 WebSocket库3.1 arduinoWebSockets 源码地址3.2 arduinoWebSockets 是什么3.3 支持的硬件平台3.4 安装 arduinoWebSockets 库3.5 如何引入 a...
webSocket通讯实例，长连接
12-15
android webSocket 实时通讯长连接 ，使用autobahn框架，完整代码下载
分布式-- WebSocket 全双工通讯
mazaiting的博客
05-14 800
1. WebSocket 1). 背景 B/S结构的软件项目中有时客户端需要实时的获得服务器消息，但默认HTTP协议只支持请求响应模式，这样做可以简化Web服务器，减少服务器的负担，加快响应速度，因为服务器不需要与客户端长时间建立一个通信链接，但不容易直接完成实时的消息推送功能，如聊天室、后台信息提示、实时更新数据等功能，但通过polling、Long ...
双工通信：WebSocket服务
最新发布
qq_52241267的博客
03-26 1355
（一）WebSocket概述WebSocket是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工通信——浏览器和服务器只需要完成一次握手，两者之间就可以创建持久性的连接， 并进行双向数据传输。
双工通信
weixin_33895016的博客
06-08 174
所谓单双工通信是指信息始终是一个方向的通信。听广播和看电视就是单双工通信的典型例子。  所谓半双工通信是指信息流可以在两个方向传输，但同一时刻只限于一个方向的传输。对讲机记得通信就是半双工通信 所谓全双工通信是指同时可以作双向的通信，即通信的一方在发送信息的同时也能接受信息.打电话就是全双工通信的例子。双工通信是指在同一时刻信息可以进行双向传输，和打电话一样，说的同时也...
websocket双工通信
wangshang1320的博客
05-08 310
后端：node socketServer.js let server = require('ws').Server; let ws = new server({ port: 8003 },function (e) { if(!e){ console.log('ws服务器开启，监听8003端口'); }else{ console.log...
计算机实际应用的例子,作业二:单工通信;半双工通信; 双工通信;有哪些实际应用的例子...
weixin_29944883的博客
06-27 2959
单工通信：所谓单工通信，是指消息只能单方向传输的工作方式。例如遥控、遥测，就是单工通信方式单工通信信道是单向信道，发送端和接收端的身份是固定的，发送端只能发送信息，不能接收信息；接收端只能接收信息，不能发送信息，数据信号仅从一端传送到另一端，即信息流是单方向的。通信双方采用“按——讲”(Push ToTalk,PTT)单工通信属于点到点的通信。根据收发频率的异同，单工通信可分为同频通信和异频通信...
使用websocket实现全双工通信
qq_40603125的博客
10-15 732
一次握手长双向。
Java WebSocket实现全双工通信案例解析
1. **全双工通信**：服务器与客户端可以同时发送或接收数据。 2. **持久连接**：相较于HTTP的请求-响应模式，WebSocket连接建立后可以持续存在，不会因为数据交换结束而断开。 3. **减少开销**：使用现有的HTTP端口...
Java WebSocket全双工通信原理及实现
WebSocket是一种网络协议，它提供了在单个TCP连接上进行全双工通信的方法。这意味着服务器和客户端可以同时进行数据交换。WebSocket协议在2011年被互联网工程任务组（IETF）标准化为RFC 6455。 #### WebSocket的...
java实现实时通信之webSocket使用案例
02-21
在数据实效性要求更高的今天，实时通讯成为必然，webSocket为浏览器提供了解决方案，而现在基本所有浏览器都对其进行了支持,其也就成为实时通信首选方案。本案例针对webSocket的使用提供了完整案例，下载后便可以直接运行使用，为入门提供便利
webSocket实现例子
01-19
JAVA语言开发。完整的实例，部署环境tomcat7，jdk1.8，实现webscoket的一个例子。内有相关的jar包和说明(包括项目运行后的页面访问地址)。请放心下载，如有问题，请留言
WebScoket通信简单小例子
老猫的博客
07-28 2151
WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。一开始的握手需要借助HTTP请求完成。 下面简单小例子实现WebSocket通信1、编写实体类Content.java/** * @author XJ * 实体类 */ public class Content { //单聊时 信息发送的目标 privat
WCF操作模式-双向操作(双工通信)示例演示
我的地盘
07-22 6693
转载自：http://www.lmwlove.com/ac/ID1035 在单向操作模式中，客户端向服务器发送请求，然后服务器回应。但服务器却不能主动向客户端发送信息。但在双向操作模式中，不但客户端可以向服务器发送请求，服务器也可以主动向客户端广播消息(也就是回调客户端中的方法)。在WCF中，不是所有的绑定都可以实现双向操作模式的，比如http协议，它本身就是基于请求-回复的传输模式，所以本质上
Java Websocket实例【服务端与客户端实现全双工通讯】
热门推荐
当幸福来敲门的专栏
07-27 1万+
Java Websocket实例【服务端与客户端实现全双工通讯】 现很多网站为了实现即时通讯，所用的技术都是轮询(polling)。轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发 出HTTP request，然后由服务器返回最新的数据给客服端的浏览器。这种传统的HTTP request 的模式带来很明显的缺点 – 浏 览器需要不断的向服务器发出请求，然而
[老老实实学WCF] 第十篇 消息通信模式(下) 双工
宋业飞的专栏
03-30 1万+
老老实实学WCF 第十篇 消息通信模式(下) 双工   在前一篇的学习中，我们了解了单向和请求/应答这两种消息通信模式。我们知道可以通过配置操作协定的IsOneWay属性来改变模式。在这一篇中我们来研究双工这种消息通信模式。   在一定程度上说，双工模式并不是与前面两种模式相提并论的模式，双工模式的配置方法同前两者不同，而且双工模式也是基于前面两种模式之上的。   在双工模式下，服务
WebSocket 详解：全双工通信的实现与应用
Future_yzx的博客
01-25 1933
WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议。它使得客户端和服务器之间的数据交换变得更加简单，允许服务器主动向客户端推送数据。通过 WebSocket API，浏览器和服务器只需完成一次握手，即可建立持久性连接，开始双向数据传输。
全双工通信的 WebSocket
油墨香^-^的博客
07-04 1064
一. WebSocket 是什么？ WebSocket 是一种网络通信协议。在 2009 年诞生，于 2011 年被 IETF 定为标准 RFC 6455 通信标准。并由 RFC7936 补充规范。WebSocket API 也被 W3C 定为标准。WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工(full-duplex)通讯的协议。没有了 Request 和 Response 的概念，两者地位完全平等，连接一旦建立，就建立了真•持久性连接，双方可以随时向对方发送数据。(H
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值