spring-boot整合websocket消息推送

最新推荐文章于 2022-01-19 11:09:22 发布
最新推荐文章于 2022-01-19 11:09:22 发布
阅读量386 收藏 1
点赞数
分类专栏： websocket 文章标签： spring websocket spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/superPojo/article/details/110956467
版权

引入spring websocket 和springboot 启动 pom.xml:

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

		<dependency>
			<groupId>com.huasuhui</groupId>
			<artifactId>huasuhui-spring-boot-starter-dubbo</artifactId>
			<version>1.0.0</version>
		</dependency>
		
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>

加入websocket 配置文件:

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

/**
 * WebScoket配置处理器
 */
@Configuration
public class WebSocketConfig {
	
	 /**
     * ServerEndpointExporter 作用
     * 这个Bean会自动注册使用@ServerEndpoint注解声明的websocket endpoint
     * @return
     */
	@Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

编写websocket 服务 WebSocketServer ：

package com.huash.websocket.service;

import java.io.IOException;
import java.util.Date;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

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.lang.StringUtils;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;
import com.huash.websocket.listener.Message;

@ServerEndpoint("/webSocket/{username}")
@Component
public class WebSocketServer {
	
	//静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static AtomicInteger onlineNum = new AtomicInteger();

    //concurrent包的线程安全Set，用来存放每个客户端对应的WebSocketServer对象。
    private static ConcurrentHashMap<String, Session> sessionPools = new ConcurrentHashMap<>();

    //发送消息
    public void sendMessage(Session session, String message) throws IOException {
        if(session != null){
            synchronized (session) {
            	if (session.isOpen()) {
            	    //System.out.println("发送数据：" + message);
                    session.getBasicRemote().sendText(message);
				}
            }
        }
    }
    //给指定用户发送信息
    public void sendInfo(String userName, String message){
    	
    	if (sessionPools.size() > 0 && !StringUtils.isBlank(message)){
    		Session session = sessionPools.get(userName);
    		if (session != null && session.isOpen()){
    			try {
    		           sendMessage(session, message);
    		        }catch (Exception e){
    		        	e.printStackTrace();
    		        }
			}
		}
    }
    // 群发消息
    public void broadcast(String message){
    	if (sessionPools.size() > 0 && !StringUtils.isBlank(message)) {
    		for (Session session: sessionPools.values()) {
                try {
                	if (session != null && session.isOpen()){
                		sendMessage(session,message);
                		//session.getBasicRemote().sendText(message);
					}
                	else {
                		session.close();
					}
                } catch(Exception e){
                	e.printStackTrace();
                	System.out.println("发生错误....");
                    continue;
                }
            }
		}
    }

    //建立连接成功调用
    @OnOpen
    public void onOpen(Session session, @PathParam(value = "username") String userName){
    	// 将老的session关闭
		try {
			Session session2 = sessionPools.get(userName);
			if (session2 != null) {
				session2.close();
	    	}
		} catch (IOException e) {
		}
    	// 用户加入连接
        sessionPools.put(userName, session);
        addOnlineCount();
    }

    //关闭连接时调用
    @OnClose
    public void onClose(@PathParam(value = "username") String userName){
    	// 将老的seesion关闭
    	try {
    		Session session2 = sessionPools.get(userName);
			if (session2 != null) {
				session2.close();
	    	}
		} catch (Exception e) {
		}
    	// 去掉用户连接
        sessionPools.remove(userName);
        subOnlineCount();
    }
    
    //收到客户端信息后，根据接收人的username把消息推下去或者群发
    // to=-1群发消息
    @OnMessage
    public void onMessage(String message) throws IOException{
        //System.out.println("server get" + message);
        Message msg=JSON.parseObject(message, Message.class);
		msg.setDate(new Date());
		if (msg.getTo().equals("-1")) {
			broadcast(JSON.toJSONString(msg,true));
		} else {
			sendInfo(msg.getTo(), JSON.toJSONString(msg,true));
		}
    }

    //错误时调用
    @OnError
    public void onError(Session session, Throwable throwable){
        //System.out.println("发生错误");
        //throwable.printStackTrace();
    }

    public static void addOnlineCount(){
        onlineNum.incrementAndGet();
    }

    public static void subOnlineCount() {
        onlineNum.decrementAndGet();
    }
    
    public static AtomicInteger getOnlineNumber() {
        return onlineNum;
    }
    
    public static ConcurrentHashMap<String, Session> getSessionPools() {
        return sessionPools;
    }
}

编写一个context类 ，方便后面服务端主动向前端推送消息：

import java.util.HashMap;



import java.util.Map;

import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;



@Component
public class HuashContext implements ApplicationContextAware{
	//系统事件///
	public static final String USER_JOIN_EVENT = "userJoin" ;							// 用户加入事件
	
	public static final String TEST = "test" ;						
	
	private static int WebIMPort = 5001 ;
	private static boolean imServerRunning = false ;			// IM服务状态
	
	private static ApplicationContext applicationContext ;

	public static Map<String , Boolean> model = new HashMap<String,Boolean>();
	

	public static int getWebIMPort() {
		return WebIMPort;
	}

	public static void setWebIMPort(int webIMPort) {
		WebIMPort = webIMPort;
	}
	
	public void setApplicationContext(ApplicationContext context){
		applicationContext = context ;
	}

	public static ApplicationContext getContext(){
		return applicationContext ;
	}
	
	public static void setIMServerStatus(boolean running){
		imServerRunning = running ;
	}
	public static boolean getIMServerStatus(){
		return imServerRunning;
	}
}

编写 推送事件 SysEvent 类：

import org.springframework.context.ApplicationEvent;

/**
 *  @ClassName: SysEvent  					    		
 *  @Description: 事件 
 *  @author Administrator									
 *  @date Dec 10, 2020									
 *  @version V1.0
 */
public class SysEvent extends ApplicationEvent
{
	private static final long serialVersionUID = 1L;
	
	
	public SysEvent(Object source)
	{
		super(source);
	}
	
}

/**
 *  @ClassName: TestEvent  					    		
 *  @Description:测试   																				
 */
public class TestEvent extends SysEvent{

	    
	private static final long serialVersionUID = 1L;

	public TestEvent(Object source) {
		super(source);
	}

	private String text;

	public String getText() {
		return text;
	}

	public void setText(String text) {
		this.text = text;
	}
}

编写监听SystemEventListener 类：


import java.io.IOException;
import java.io.Serializable;

import javax.annotation.Resource;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;
import com.huash.order.websocket.context.HuashContext;
import com.huash.order.websocket.event.SysEvent;
import com.huash.order.websocket.event.TestEvent;
import com.huash.order.websocket.service.WebSocketServer;

/**
 *  @ClassName: SystemEventListener  					    		
 *  @Description: 监听事件，执行操作    								
 *  @version V1.0
 */
@Component
@SuppressWarnings("all")
public class SystemEventListener implements ApplicationListener<SysEvent>
{
	Logger logger = Logger.getLogger(SystemEventListener.class);
	
	@Autowired
	private WebSocketServer webSocketServer;
	
	@Override
	public void onApplicationEvent(SysEvent event)
	{
		logger.info(String.format("%s 监听到事件源：%s.", SystemEventListener.class.getName(), event.getSource()));
		
		String es = event.getSource().toString();				
		switch( es ){
			case HuashContext.TEST: test(event); break;			// 事件
		}
	}
	
	// test 可做详细内容....
	private void test(SysEvent event)
	{
		TestEvent e = (TestEvent)event;
		
		Message message = new Message();
		
		message.setText(e.getText());
		
		webSocketServer.broadcast(JSON.toJSONString(message));
	}
}

添加一个消息文本 Message 类：


/**
 *  @ClassName: Message  					    		
 *  @Description: 消息文本    								
 *  @version V1.0
 */
public class Message {

	//发送者name
	public String from;
	//接收者name
	public String to = "-1";
	//发送的文本
	public String text;
	//发送时间
	@JSONField(format="yyyy-MM-dd HH:mm:ss")
	public Date date;

	public String getFrom() {
		return from;
	}

	public void setFrom(String from) {
		this.from = from;
	}

	public String getTo() {
		return to;
	}

	public void setTo(String to) {
		this.to = to;
	}

	public String getText() {
		return text;
	}

	public void setText(String text) {
		this.text = text;
	}

	public Date getDate() {
		return date;
	}

	public void setDate(Date date) {
		this.date = date;
	}

}

封装返回数据类：

import java.io.Serializable;

import org.apache.commons.lang3.StringUtils;

public class ResultJson implements Serializable
{

    private static final long serialVersionUID = 7646800798370648252L;

    private Object data;

    private String mess;

    private String result = SUCCESS_DESC;

    private int code = SUCCESS_CODE;

    private Long timeStamp = System.currentTimeMillis();

    private static final int SUCCESS_CODE = 200;
    private static final String SUCCESS_DESC = "操作成功";

    private static final int FAILURE_CODE = 10001;
    private static final String FAILURE_DESC = "操作异常";

    private static final int PARAMETER_EXCEPTION_CODE = 10002;
    private static final String PARAMETER_EXCEPTION_DESC = "传参异常";

    private static final int STATUS_EXCEPTION_CODE = 10009;
    private static final String STATUS_EXCEPTION_DESC = "订单状态异常";

    public static ResultJson success(Object data, String mess, String result) {
        ResultJson resultJson = new ResultJson();
        resultJson.setData(data);
        resultJson.setMess(mess);
        resultJson.setResult(result);
        return resultJson;
    }

    public static ResultJson success() {
        return new ResultJson();
    }

    public static ResultJson success(Object data, String mess) {
        ResultJson responseJson = new ResultJson();
        responseJson.setData(data);
        responseJson.setMess(mess);
        responseJson.setCode(SUCCESS_CODE);
        return responseJson;
    }

    public static ResultJson success(Object data) {
        return success(data, SUCCESS_DESC);
    }

    public static ResultJson success(String mess)
    {
    	ResultJson responseJson = new ResultJson();
        responseJson.setMess(StringUtils.isEmpty(mess) ? SUCCESS_DESC : mess);
        responseJson.setCode(SUCCESS_CODE);
        return responseJson;
    }

    public static ResultJson failure(String mess) {
        return error(FAILURE_CODE, FAILURE_DESC, mess);
    }

    public static ResultJson statusFailure(String mess) {
        return error(STATUS_EXCEPTION_CODE, STATUS_EXCEPTION_DESC, mess);
    }

    public static ResultJson parameterException(String msg)
    {
    	return error(PARAMETER_EXCEPTION_CODE, PARAMETER_EXCEPTION_DESC, msg);
    }

    public static ResultJson error(Integer code, String result, String msg) {
        ResultJson responseJson = new ResultJson();
        responseJson.setMess(msg);
        responseJson.setResult(result);
        responseJson.setCode(code);
        return responseJson;
    }

    public ResultJson() {
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public String getMess() {
        return mess;
    }

    public void setMess(String mess) {
        this.mess = mess;
    }

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    public Long getTimeStamp() {
        return timeStamp;
    }

    public void setTimeStamp(Long timeStamp) {
        this.timeStamp = timeStamp;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    @Override
    public String toString() {
        return "ResultJson{" +
                "data=" + data +
                ", mess='" + mess + '\'' +
                ", result='" + result + '\'' +
                ", code=" + code +
                ", timeStamp=" + timeStamp +
                '}';
    }
}

前端html 代码：

<!DOCTYPE HTML>
<html>
<head>
<base href="localhost://localhost:8080/">
<title>My WebSocket</title>
</head>
 
<body>
	Welcome
	<br />
	<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 user = '111';
	//判断当前浏览器是否支持WebSocket  
	if ('WebSocket' in window) {
		websocket = new WebSocket("ws://localhost:8080/webSocket/" + user);
	} else {
		alert('Not support websocket')
	}
 
	//连接发生错误的回调方法  
	websocket.onerror = function() {
		setMessageInnerHTML("error");
	};
 
	//连接成功建立的回调方法  
	websocket.onopen = function(event) {
		setMessageInnerHTML("open");
	}
 
	//接收到消息的回调方法  
	websocket.onmessage = function(event) {
		setMessageInnerHTML(event.data);
	}
 
	//连接关闭的回调方法  
	websocket.onclose = function() {
		setMessageInnerHTML("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;
		
		var text = {"text":message,"to":"-1"};
		
		websocket.send(JSON.stringify(text));
	}
</script>
</html>

然后服务端推送测试demo：

@Controller
public class TestController {

	
	@RequestMapping(value ="test", method = RequestMethod.GET,
			produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
	@ResponseBody
	public ResultJson test() 
	{
		TestEvent testEvent = new TestEvent(HuashContext.TEST);
		
		testEvent.setText("测试");
		
		HuashContext.getContext().publishEvent(testEvent);
		
		return ResultJson.success("成功");
	}
	
	
}

用spring 事件去推送消息内容，每一个事件继承Event并编写事件消息内容，然后通过监听listener监听事件，编写对应方法然后执行。

前端页面接收：

前端发送，后端接收：

整体项目结构：

All In丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot实现websocket功能
qq_35651224的博客
08-29 432
1.引入pom依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 2.websocket配置类 /** * websocket配置 * @Date: 2020-08-22 */ @Configuration /** *
SpringBoot集成websocket（4）|（使用okhttp3实现websocket）
最新发布
Oaklkm的博客
09-04 1890
HTTP是现代应用常用的一种交换数据和媒体的网络方式，高效地使用HTTP能让资源加载更快，节省带宽。OkHttp是一个高效的HTTP客户端，它有以下默认特性：支持HTTP/2，允许所有同一个主机地址的请求共享同一个socket连接连接池减少请求延时透明的GZIP压缩减少响应数据的大小缓存响应内容，避免一些完全重复的请求请求失败时自动重试主机的其他 IP，自动重定向当握手失败时会回退到TLS 1.0。
SpringBoot中的WebSocket搭建详解 通俗易懂
Snapeee_的博客
08-21 5424
SpringBoot中的WebSocket搭建详解 通俗易懂（demo） SpringBoot中已经集成了websocket，搭建起来很简单，容易上手，废话少说，开始。 一、基础搭建 导入依赖 （首先需要一个SpringBoot的环境，此文章不再赘述） <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-b
[ Spring Boot ] 整合 Websocket 实现消息推送框架的设计笔记
架构探险之道
12-14 2432
前段时间，项目中用Websocket实现了一套后台向前端推送的Service层搭建，感兴趣的童鞋可以了解下^_^Maven pom&lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-websocket&lt;/...
使用Websocket实现消息推送（心跳）
qq_25330791的博客
03-24 1512
0x00 心跳 本来以为写完了，结果最近和一个同事在讨论心跳的事情，这里再做一个补充。先说我的结论： WebSocket协议已经设计了心跳，这个功能可以到达检测链接是否可用 心跳是用来检测链接是否可用的，不一定支持携带数据，可要看具体实现 如果非要心跳中带上复杂数据，那这个可作为应用层的一个功能自己去实现。 心跳逻辑 0x01 WebSocket协议的控制帧 上一篇的最后简单提到了心跳，下面是对websocket协议控制帧的描述： 5.5. Control Frames ...
spring-boot-starter-websocket.zip
08-24
通过以上步骤，我们可以利用“spring-boot-starter-websocket.zip”中的内容搭建起一个完整的站内信系统，实现实时的消息推送功能。这个压缩包提供的起步依赖简化了WebSocket在Spring Boot中的集成工作，让开发者...
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
6. **实时推送数据**：当接收到RabbitMQ的消息时，通过WebSocket端点将数据推送到已连接的客户端页面上。 在"springboot-rabbitMQ-websocket-master"这个项目中，开发者已经完成了上述所有整合工作。你可以通过克隆...
spring-boot-websocket-netty-server代码整合
08-03
在本文中，我们将深入探讨如何将`Spring Boot`、`WebSocket`和`Netty`整合构建一个高效且灵活的Web服务器。`Spring Boot`简化了Java应用的开发过程，而`WebSocket`则提供了双向通信的能力，`Netty`作为高性能的网络...
spring-boot-websocket.rar
04-29
WebSocket则是一种在单个TCP连接上进行全双工通信的协议，它允许服务器主动向客户端推送数据，常用于实现实时通信功能。 描述中的两个URL似乎指向了一个运行在本地的Spring Boot应用。第一个URL ...
Spring Boot 整合 Netty + WebSocket 实时消息推送
03-14
在"Spring Boot 整合 Netty + WebSocket 实时消息推送"项目中，我们主要关注以下几个核心知识点： 1. **Spring Boot集成WebSocket**：Spring Boot提供了Spring WebSocket模块，可以方便地集成WebSocket功能。通过...
Websocket 基于spring的配置和使用（二）
口袋里的小龙的专栏
01-17 1133
websocket 基于spring的使用
分布式springboot+websocket 发送消息
zhangshng的博客
05-28 926
集群版本的websocket，不能单独使用，需要和redis来做消息分发。至于原因，我觉得大家都懂了，bb再多，不如代码一行。 <!--websocket--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency&g
tomcat websocket 并发问题解决（一）
詹Sir的博客
01-19 2706
问题起源 公司应用内有一个基于websocket的聊天室功能，一直有用户反应高峰时段聊天信息延迟的厉害，终于找时间抽空解决了一下。 首先通过日志发现，聊天室/直播间内用户稍微多一点的情况下（30-50人），广播一条消息就会非常耗时，常常达到 10-20s 检查代码发现 SessionUtil 的 sendMessage 方法内，有如下一段代码(精简)： <spanclass="hljs-selector-tag">if</span>(session.isOpen())...
SpringBoot整合WebSocket，及注入Bean的方式
NeilNiu
02-28 4266
最近用到WebSocket协议，所以需要SpringBoot整合WebSocket。首先说下WebSocket协议，它是双向的，在客户端-服务器通信的场景中使用的全双协议，与HTTP不同，它以ws://开头，它是一个有状态协议，意味着客户端和服务器之间的连接保持活动状态，直到被任何一方终止。在客户端和服务器中的任何一方关闭连接后，连接将两端终止。 SpringBoot整合WebSocket 1、添加maven依赖 <dependency> <groupId>
java websocket 推送消息_Java中websocket消息推送的实现代码
weixin_36040777的博客
02-12 619
一.服务层package com.demo.websocket;import java.io.IOException;import java.util.Iterator;import java.util.concurrent.ConcurrentLinkedQueue;import javax.servlet.ServletContextEvent;import javax.servlet.Ser...
2021-05-21
zibingyu的专栏
05-21 384
sprintboot的websocket demo,网上都是写的啥玩意,整理一下,来个简洁版本的,而且相当稳定的说,记录一下 WebSocketServer类: package com.bigboy.wechatkits.web.api.websocket; import com.bigboy.wechatkits.core.utils.RequestUtil; import org.springframework.stereotype.Component; import javax.webso
okhttp中websocket的使用
Welsh_summer的博客
05-15 2006
okhttp中websocket使用及实现websocket是什么websocket能做什么WebSocket之OkHttpWebSocket 保活 参考链接：https://www.cnblogs.com/plokmju/p/okhttp_weisocket.html websocket是什么 一种客户端与服务器进行全双工通讯的网络技术，属于应用层协议。它基于TCP传输协议，并复用HTTP的握手通道。 websocket能做什么 WebSocket 与 HTTP/2 一样，其实都是为了解决 HTTP/1
websocket存储session(适合聊天，转发，广播，服务器主动发送消息)
热门推荐
zero_rui.zhang的博客
02-08 3万+
此篇文章主要分享的是websocket存储session信息，在网上经常看到有websocket的例子，此篇文章只是将websocket中的session提取并存储起来，便于用户之间的互动与查找，其实就是解耦合此实现采用的是springboot的spring封装的websocket框架，原有的tomcat其实也可以完成首先，spring框架封装的websocket有几种对应onopen对应afte...
6：Springboot WebSocket使用及json格式传输
肉抖的摇摆小胖子_博客
08-08 6240
由于项目需求管理员这边发通知需要主动通知到用户，所以决定采用websocket方式进行前后端数据交换，后来便决定一个页面的所有请求全部用websocket，因此需要json格式来包装键值对的请求名和请求内容。 奉上springboot内置tomcat的websocket配置及使用。 1：Config配置，目前看到说是内置springboot需要注入beanServerEndpointExporte...
netty-websocket-spring-boot-starter使用案例
06-01
使用该框架可以快速构建实时通信、消息推送等功能。 下面是一个使用netty-websocket-spring-boot-starter的简单案例： 1. 在pom.xml中添加依赖： ```xml <groupId>com.github.wujiuye</groupId> <artifactId>...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值