netty做服务端支持ssl协议实现websocket的wss协议（客户端为浏览器）

最新推荐文章于 2024-07-31 15:05:27 发布
最新推荐文章于 2024-07-31 15:05:27 发布
阅读量1.8w 收藏 19
点赞数 2
分类专栏： Java 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/invadersf/article/details/80337380
版权

也是在网上查的资料，整理一下相互学习下

第一步：生成SSL证书：

    因为是测试，直接使用jdk自带的keytool工具生成自签名证书（注：自签名证书是不被浏览器认可的，只能用于测试），

    --打开cmd

   --输入命令（复制啊）：keytool -genkey -keysize 2048 -validity 365 -keyalg RSA -keypass netty123 -storepass netty123 -keystore wss.jks

第二步：在ChannelPipeline添加SslHandler:

    首先写个工具类：SslUtil配置SSLContext

	public static SSLContext createSSLContext(String type ,String path ,String password) throws Exception {
	    KeyStore ks = KeyStore.getInstance(type); /// "JKS"
	    InputStream ksInputStream = new FileInputStream(path); /// 证书存放地址
	    ks.load(ksInputStream, password.toCharArray());
	 	//KeyManagerFactory充当基于密钥内容源的密钥管理器的工厂。
	    KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());//getDefaultAlgorithm:获取默认的 KeyManagerFactory 算法名称。
	    kmf.init(ks, password.toCharArray());
	    //SSLContext的实例表示安全套接字协议的实现，它充当用于安全套接字工厂或 SSLEngine 的工厂。
	    SSLContext sslContext = SSLContext.getInstance("TLS");
	    sslContext.init(kmf.getKeyManagers(), null, null);
	    return sslContext;
	}

添加SslHandler（放在第一个）

        @Override
        public void initChannel(SocketChannel ch) throws Exception {
            SSLContext sslContext = SslUtil.createSSLContext("JKS","D://wss.jks","netty123");
            //SSLEngine 此类允许使用ssl安全套接层协议进行安全通信
            SSLEngine engine = sslContext.createSSLEngine(); 
            engine.setUseClientMode(false); 
            
            ch.pipeline().addLast(new SslHandler(engine));
            ch.pipeline().addLast(new IdleStateHandler(5, 0, 0, TimeUnit.SECONDS));    
            ch.pipeline().addLast("http-codec", new HttpServerCodec());            
            ch.pipeline().addLast("aggregator", new HttpObjectAggregator(65536));  
            ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());    
            ch.pipeline().addLast(new AcceptorIdleStateTrigger());    
            ch.pipeline().addLast("handler", new WebSocketHandler());            
        }

 JS文件的URL：

var url = "wss://localhost:8000/ws";

第三步：运行

    运行服务端，在浏览器地址栏输入https://localhost:8000/  浏览器会提示这是不安全的连接（浏览器不信任自签名证书，如果有域名可以自己申请一个证书，网上有免费测试版的证书），添加例外信任，再在html页面上右键获得它的本地路径 在浏览器中运行   连接成功

补充：（因为发现一些小伙伴不清楚部分类的来源，特此补充）--2021.09.08

目录：

  

AcceptorIdleStateTrigger .java

package com.netty.wss;

import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;

@ChannelHandler.Sharable
public class AcceptorIdleStateTrigger extends ChannelInboundHandlerAdapter {
    private int unReceivedCounts=0;
   
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
    		throws Exception {
    	//有消息时归零
    	unReceivedCounts=0;
    	super.channelRead(ctx, msg);
    }
    
	@Override
	public void userEventTriggered(ChannelHandlerContext ctx, Object evt)
			throws Exception {
		if (evt instanceof IdleStateEvent) {
			//在这里并处理业务逻辑
			IdleState state = ((IdleStateEvent) evt).state();
			if (state == IdleState.READER_IDLE) {				
				unReceivedCounts++;
				System.out.println(unReceivedCounts);
				if (unReceivedCounts>10) {
					ctx.close();
					unReceivedCounts = 0;
				}				
			}
		} else {
			super.userEventTriggered(ctx, evt);
		}		
	}

}

SslUtil.java

package com.netty.wss;

import java.io.FileInputStream;
import java.io.InputStream;
import java.security.KeyStore;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;

public class SslUtil {
	
	public static SSLContext createSSLContext(String type ,String path ,String password) throws Exception {
	    KeyStore ks = KeyStore.getInstance(type); /// "JKS"
	    InputStream ksInputStream = new FileInputStream(path); /// 证书存放地址
	    ks.load(ksInputStream, password.toCharArray());
	 	//KeyManagerFactory充当基于密钥内容源的密钥管理器的工厂。
	    KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());//getDefaultAlgorithm:获取默认的 KeyManagerFactory 算法名称。
	    kmf.init(ks, password.toCharArray());
	    //SSLContext的实例表示安全套接字协议的实现，它充当用于安全套接字工厂或 SSLEngine 的工厂。
	    SSLContext sslContext = SSLContext.getInstance("TLS");
	    sslContext.init(kmf.getKeyManagers(), null, null);
	    return sslContext;
	}
}

WebSocketHandler.java

package com.netty.wss;


import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshakerFactory;
import io.netty.util.CharsetUtil;

/**
 * websocket 具体业务处理方法
 * 
 * */
public class WebSocketHandler extends ChannelInboundHandlerAdapter{
	private WebSocketServerHandshaker handshaker;
			
	/**
	 * 当客户端连接成功，返回个成功信息
	 * */
	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
	
	}
		
	/**
	 * 当客户端断开连接
	 * */
	@Override
	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
	}

	@Override
	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
		ctx.flush();
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		// 传统的HTTP接入
		if(msg instanceof FullHttpRequest){	
			handleHttpRequest(ctx,(FullHttpRequest)msg);						
		}else if(msg instanceof WebSocketFrame){
			handlerWebSocketFrame(ctx,(WebSocketFrame)msg);				

		}
		super.channelRead(ctx, msg);
	}
			
	public void handlerWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) throws Exception{
		//关闭请求
		if(frame instanceof CloseWebSocketFrame){		
			handshaker.close(ctx.channel(), (CloseWebSocketFrame)frame.retain());
			return;		
		}
		//只支持文本格式，不支持二进制消息
		if(!(frame instanceof TextWebSocketFrame)){			
			throw new Exception("仅支持文本格式");
		}
	}
	
	//第一次请求是http请求，请求头包括ws的信息
	public void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req){
		if(!req.decoderResult().isSuccess()){
			sendHttpResponse(ctx,req, new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
			return;
		}		
		// 构造握手响应返回
		WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws:/"+ctx.channel()+ "/ws",null,false);		
		handshaker = wsFactory.newHandshaker(req);
		// 请求头不合法, 导致handshaker没创建成功 
		if(handshaker == null){
			WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
		}else{
			handshaker.handshake(ctx.channel(), req);
		}
	}
	
	public static void sendHttpResponse(ChannelHandlerContext ctx,FullHttpRequest req,DefaultFullHttpResponse res){		
        // 返回应答给客户端
        if (res.status().code() != 200){
            ByteBuf buf = Unpooled.copiedBuffer(res.status().toString(), CharsetUtil.UTF_8);
            res.content().writeBytes(buf);
            buf.release();
        }
        // 如果是非Keep-Alive，关闭连接
        ChannelFuture f = ctx.channel().writeAndFlush(res);
        if (!isKeepAlive(req) || res.status().code() != 200){
            f.addListener(ChannelFutureListener.CLOSE);
        }		
	}	
    private static boolean isKeepAlive(FullHttpRequest req){
        return false;
    }
   
    //异常处理，netty默认是关闭channel
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
		//输出日志
		 cause.printStackTrace();
		 ctx.close();
	}
	

}

WebsocketServer.java (启动类)

package com.netty.wss;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.ssl.SslHandler;
import io.netty.handler.stream.ChunkedWriteHandler;
import io.netty.handler.timeout.IdleStateHandler;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;

public class WebsocketServer {
	public static   WebsocketServer instance;
	
	public static final WebsocketServer getInstance(){
		return instance;
	}
	
	private int port;
	public WebsocketServer(int port) {
		if(instance!=null){
			return;
		}
		
		this.port = port;
		try {
			this.start();
			instance=this;			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	private void start() throws Exception{
		EventLoopGroup bossGroup = new NioEventLoopGroup();
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			ServerBootstrap b = new ServerBootstrap();
			b.group(bossGroup, workerGroup);
			b.channel(NioServerSocketChannel.class); 
			b.childHandler(new myChannelInitializer());
			b.option(ChannelOption.SO_BACKLOG, 128);
			b.childOption(ChannelOption.SO_KEEPALIVE, true);
			ChannelFuture f = b.bind(port); 
			System.out.println("Netty Websocket is start .........");
			f.channel().closeFuture().sync();
		} finally {
			workerGroup.shutdownGracefully();
			bossGroup.shutdownGracefully();
		}
	}
	
	private class  myChannelInitializer extends  ChannelInitializer<SocketChannel>{
		@Override
		public void initChannel(SocketChannel ch) throws Exception {
			SSLContext sslContext = SslUtil.createSSLContext("JKS","D://wss.jks","netty123");
			//SSLEngine 此类允许使用ssl安全套接层协议进行安全通信
			SSLEngine engine = sslContext.createSSLEngine(); 
			engine.setUseClientMode(false); 
			
			ch.pipeline().addLast(new SslHandler(engine));
			ch.pipeline().addLast(new IdleStateHandler(5, 0, 0, TimeUnit.SECONDS));	
			ch.pipeline().addLast("http-codec", new HttpServerCodec());			
			ch.pipeline().addLast("aggregator", new HttpObjectAggregator(65536));  
			ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());	
			ch.pipeline().addLast(new AcceptorIdleStateTrigger());	
			ch.pipeline().addLast("handler", new WebSocketHandler());			
		}
	}
	
	public static void main(String[] args) throws Exception {
		try {
			new WebsocketServer(8000);	
		} catch (Exception e) {
			// TODO: handle exception
		}

	}
}

源码地址：点击打开链接

参考：http://www.360doc.com/content/17/1228/16/51390869_717156716.shtml；

           https://www.cnblogs.com/guogangj/p/5209330.html

invadersf
关注
专栏目录
Netty通过Nginx配置 wss 协议访问（实践可行）
Java海洋
11-12 4523
先写个比较简单的，后面再写一篇Vue + springboot +netty Netty在互联网以及物联网公司用的很多，底层走的还是 websocket协议，好处很多，就不一一列了，相关的文章很多，大家可以搜下； 在实际开发应用中，基本上都是采用前后端分离，前端部署需要借助 nginx, 所以一般在nginx 配置 https, wss即可，代码中不需要另外配置，下面是nginx 配置文件详情: server { #listen 80; #我这里把http和https两种请求分.
netty做服务端支持ssl协议实现websocket的wss协议（java）
05-16
在网上查的资料，整理了一下 实现了wss协议的连接 和websocket的心跳,,在网上查的资料，整理了一下 实现了wss协议的连接 和websocket的心跳
基于Netty实现安全认证的WebSocket（wss）服务端
u013771019的专栏
05-27 1830
4.1生成mystore.jks后，不导入证书，直接启动服务端使用；选择证书存储为【受信任的根证书颁发机构】，完成即可。】中基本一样，只是把服务端地址的协议头修改为wss。或者导入证书后不手动信任，客户端进行连接时候，会报错。启动服务端，然后启动客户端，连接和接发数据都正常。双机上面生成的证书文件mystore.cer，4.2 客户端连接服务端的地中，协议头还是ws。可以看到证书此时不受信任，点击【安装证书】JavaScript客户端代码，也是和 【再次双击原证书，可以看到证书已经受信任了。
SpringBoot中使用Netty开发WebSocket服务-netty-websocket-spring-boot-starter开源项目使用与改造多线程群发消息
最新发布
BADAO_LIUMANG_QIZHI的博客
07-31 609
在上面的基础上，使用websocket仍有不足，比如可能出现如下问题另外如果业务场景中需要高频定时任务通过websocket给多个客户端发动消息，则短时间内需要使用多线程/自定义线程池实现群发消息功能。
基于Netty实现安全认证的WebSocket（wss）客户端
u013771019的专栏
05-27 731
服务端地址的协议头调整为wss。1.Netty服务端。2.Netty客户端。
netty服务端及客户端，支持HTTP和WEBSOCKET和SSL
06-02
自己基于netty开发的服务端，支持spring配置服务器启动模式：http，websocket,ssl等，并支持NIO和OIO方式，项目已应用于生产，可以通过jar形式加入其它项目，业务类实现业务service，启动不依赖于其他应用服务器，内附启动脚本。 已在生产使用，压力未测试，欢迎反馈。 个人原创，部分代码参考网上其他文献。
netty-websocket服务器配置阿里云SSL证书安全访问配置，亲测有效
qq_53058639的博客
03-01 1298
背景：java 微服务包括https访问和websocket访问，当https接口访问ws请求时报错,因为https能访问wss。申请阿里云免费证书后，搜索各种教程比如nginx配置方式、netty访问证书等。走了不少弯路，终于走通一种。关键点：1、因为使用了netty，nginx配置wss的方式没有走通。需要将证书放到netty启动的方式启动才可以。2、网上教程大多数是pkcs12的证书生成方式。但是netty仅仅支持pkcs8 的版本，所以需要生成pkcs12之后再转pkcs8.
java实现websocket的wss协议，netty做服务端支持ssl协议
04-27
基于netty的websocket服务，配置阿里云ssl证书，实现正式服务器的wss访问；适用于JAVA服务器部署访问；对应生成博客地址https://mp.csdn.net/mp_blog/creation/editor/130410613
java netty wss_netty实现websocket客户端（支持wss安全连接）
weixin_30524205的博客
02-27 1370
1，客户端启动类packagetest3;importio.netty.bootstrap.Bootstrap;importio.netty.buffer.Unpooled;importio.netty.channel.Channel;importio.netty.channel.ChannelHandlerContext;importio.netty.channel.ChannelI...
netty学习：基于WebSocket协议开发服务端及客户端，实现双向通信
psy_ing的博客
09-05 430
学习过程中有参考Redisson和RocketMq对于netty的使用 一、服务端 1、启动类 @Autowired private WebsocketProperties properties; @Autowired private WebSocketChannelInitializer webSocketChannelInitializer; NioEventLoopGroup bossGroup = new NioEventLoopGroup();
netty 搭建 ssl websocket 服务器,使用 protobuf 通信
weixin_34125592的博客
09-08 617
被 Apple_Sa 的栗子坑的不行，决定自己写个教程以供未来的自己参考 证书 从阿里云申请证书得到如下几个文件 需要先用 openssl 将.pfx 转成 .key openssl pkcs12 -in server.pfx -nocerts -nodes -out server.key 提示需要输入密码，密码在 pfx-passw...
netty服务端及客户端，支持HTTP和WEBSOCKET和SSL 最新版
05-06
本人基于netty开发的服务端，支持spring配置服务器启动模式：http，websocket,ssl等，并支持NIO和OIO方式，项目已应用于生产，可以通过jar形式加入其它项目，业务类实现业务service，启动不依赖于其他应用服务器，内附启动脚本。 已在生产使用，压力已测试，欢迎反馈。 个人原创，部分代码参考网上其他文献。最新版的
java netty wss_netty中websocket, wss
weixin_36076151的博客
02-27 716
websocket直接使用SpringBoot+Netty来支持WebSocket，并且需要支持wss，其需要注意事项有以下：wss支持websocket请求路径中带参数针对第一个问题：wss支持比较简单；生成证书ChannelPipeline中添加ssl Handler，并且放在First即可。生成证书keytool -genkey -alias demo -keypass 123456 -ke...
netty/websocket服务器配置阿里云SSL证书安全访问配置，亲测有效
yaya_jn的博客
04-27 3646
配置完了，发现ws不能使用了，还在研究，各位大神有办法，可以留言，互相学习。下面是下载的别人的案例，然后改了下我的案例，可以做下参考。3、因为netty仅仅支持pkcs8，所以将server.key 通过OpenSSl 生成pkcs8的版本。2、下载类型Tomcat的pfx 证书，在jdk的路径下cmd命令生成server.key文件。将证书放到外面，方便后期更换，毕竟免费的证书是一年一申请的，用InputStream读取。1、启动的start方法，增加server8.key和pem文件的读取。
Netty websocket配置wss
Boxzhang的博客
04-24 582
打开cmd 执行openssl pkcs8 -topk8 -nocrypt -in 你的.key文件 -out pkcs8.key。配置openssl环境变量，win path 后面加安装目录 D:\zhang\OpenSSL-Win64\bin。https 和wss用的是同一个域名证书(企鹅)，Java 配置WSS ssl处理器，启动程序发现报错。下载openssl转 ssl文件中.key 到pkcs8格式。备注：ssl证书给的.key文件就是pkcs1格式文件。录音配置https 导致ws连不上。
netty websocket配置wss
tiandao321的专栏
06-10 5481
测试的时候使用netty websocket正常在正事环境报错 The page at 'https://xxxxxx/h5/#/chatIM' was loaded over HTTPS, but attempted to connect to the insecure WebSocket endpoint 'ws://192.168.0.50:9090//websocket'. This re...
springboot + netty + websocket client ws wss客户端
夏虫不可语寒的博客
04-02 2776
直接上代码 1.WebSocketClientHandler.class /* * Copyright 2012 The Netty Project * * The Netty Project licenses this file to you under the Apache License, * version 2.0 (the "License"); you may not use this file except in compliance * with the License. You
netty-写websocket从ws到wss升级
weixin_38689747的博客
04-02 1278
本文描述将使用netty搭建的websokcet服务升级为支持https的wss协议 本文通过2种方式实现 1依赖jdk提供的jks 2依赖签名证书.crt，.key文件实现 JKS 1生成秘钥 keytool -genkey -keysize 2048 -validity 365 -keyalg RSA -keypass netty123 -storepass netty123 -keystore wss.jks 2写一个工具类 构造SSLContext 对象 package com.iptv.rtc.s
基于Netty 的webSocket开发
丽卓
09-13 875
http弊端： 1  半双工 2 消息冗长，复杂，如消息头，换行符等 3黑客可以利用长时间轮训攻击   webSocket  一种浏览器与服务器端进行全双工通信的网络技术 优点  单一tcp连接，全双工 对代理防火墙透明 无头部消息，cookie,身份验证 无安全开销 通过ping/pong帧保持链路激活 服务器端可以主动传递消息给客户端 步骤t 1
netty实现websocket服务端主动向客户端推送消息
07-16
要在 Netty 中实现 WebSocket 服务端主动向客户端推送消息，可以使用 `ChannelGroup` 来管理连接到服务器的 WebSocket 客户端的 `Channel`，然后通过遍历 `ChannelGroup` 并将消息写入每个 `Channel` 来实现消息的推送。 下面是一个示例代码，演示了如何在 Netty 中实现 WebSocket 服务端主动向客户端推送消息： ```java public class WebSocketServerHandler extends SimpleChannelInboundHandler<WebSocketFrame> { private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE); @Override protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) throws Exception { // 处理 WebSocket 请求 if (frame instanceof TextWebSocketFrame) { // 处理文本消息 String text = ((TextWebSocketFrame) frame).text(); System.out.println("Received message: " + text); // 推送消息给所有连接的客户端 channelGroup.writeAndFlush(new TextWebSocketFrame("Server: " + text)); } else { // 其他类型的消息，如二进制消息、Ping/Pong 消息等 // ... } } @Override public void handlerAdded(ChannelHandlerContext ctx) throws Exception { // 当有客户端连接时，将其添加到 ChannelGroup 中 Channel channel = ctx.channel(); channelGroup.add(channel); } @Override public void handlerRemoved(ChannelHandlerContext ctx) throws Exception { // 当有客户端断开连接时，将其从 ChannelGroup 中移除 Channel channel = ctx.channel(); channelGroup.remove(channel); } // 主动向客户端推送消息的方法 public void pushMessageToClients(String message) { channelGroup.writeAndFlush(new TextWebSocketFrame("Server: " + message)); } } ``` 在上述示例中，我们创建了一个静态的 `ChannelGroup` 对象 `channelGroup`，用于存储连接到服务器的 WebSocket 客户端的 `Channel`。当有客户端连接时，将其添加到 `channelGroup` 中；当客户端断开连接时，将其从 `channelGroup` 中移除。 在处理 WebSocket 请求时，如果收到文本消息，我们可以通过调用 `channelGroup.writeAndFlush()` 方法将消息写入每个客户端的 `Channel` 中，实现消息的推送。 此外，我们还添加了一个名为 `pushMessageToClients()` 的方法，用于在服务端主动向所有客户端推送消息。 你可以在适当的时候调用 `pushMessageToClients()` 方法来推送消息给所有连接的客户端。例如，可以在定时任务或其他事件触发的地方调用该方法来主动向客户端推送消息。 希望对你有所帮助！如果还有其他问题，请继续提问。
评论 42
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值