Springboot整合Netty

最新推荐文章于 2024-07-22 15:37:32 发布
最新推荐文章于 2024-07-22 15:37:32 发布
阅读量367 收藏 1
点赞数
分类专栏： Linux Windows 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Just1like_this/article/details/114024225
版权
该博客介绍了如何配置Netty服务端和客户端，包括创建NioEventLoopGroup线程组，设置编码解码器，初始化ChannelInitializer，以及处理类NettyServerHandler。服务端通过NettyServer启动并监听指定端口，客户端使用Bootstrap连接服务端，并实现心跳检测和断线重连机制。
摘要由CSDN通过智能技术生成

配置Netty服务端

package com.chalk.netty.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.net.InetSocketAddress;

/**
 * Netty配置类
 */
@Component
@Order(100)
public class NettyServer {

    private static final Logger logger = LoggerFactory.getLogger(NettyServer.class);

    public void start(InetSocketAddress address) {
        /* 配置服务端的NIO线程组 */
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap()
                    .group(bossGroup, workerGroup)//绑定线程池
                    .channel(NioServerSocketChannel.class)
                    .localAddress(address)
                    .childHandler(new NettyServerChannelInitializer())//编码解码
                    .option(ChannelOption.SO_BACKLOG, 128)//服务端接受连接的队列长度，如果队列已满，客户端连接将被拒绝
                    .childOption(ChannelOption.SO_KEEPALIVE, true);//保持长连接，2小时无数据激活心跳机制

            // 绑定端口，开始接收进来的连接 / 绑定对应ip和端口，同步等待成功
            ChannelFuture future = bootstrap.bind(address).sync();
            logger.info("Server start listen at " + address.getPort());

            //关闭channel和块，直到它被关闭 / 等待服务端监听端口关闭
            future.channel().closeFuture().sync();

            System.out.println("--------------------"+Thread.currentThread().getName()+"--------------------------");

        } catch (Exception e) {
            e.printStackTrace();
//            bossGroup.shutdownGracefully();
//            workerGroup.shutdownGracefully();
//            logger.info("Server Closed:{}", e.getMessage());
        }
        finally {
            //优雅退出，释放 NIO 线程组
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

配置Netty从客户端获取、发送数据的编码格式

package com.chalk.netty.server;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

/**
 *
 * 配置Netty从客户端获取、发送数据的编码格式
 *
 */
public class NettyServerChannelInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel channel) throws Exception {
        //获取客户端数据的编码格式
        channel.pipeline().addLast("decoder",new StringDecoder(CharsetUtil.UTF_8));
        //发送给客户端数据的编码格式
        channel.pipeline().addLast("encoder",new StringEncoder(CharsetUtil.UTF_8));
        //添加Netty处理类
        channel.pipeline().addLast(new NettyServerHandler());
    }
}

添加Netty处理类

package com.chalk.netty.server;

import io.netty.channel.*;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.util.concurrent.GlobalEventExecutor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import java.net.InetSocketAddress;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Netty处理类
 */
@Slf4j
@Component
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /**
     * 管理一个全局map，保存连接进服务端的通道数量
     */
    private static final ConcurrentHashMap<ChannelId, ChannelHandlerContext> CHANNEL_MAP = new ConcurrentHashMap<>();

    /**
     * 所有的channel
     */
    private static ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    /**
     * 存储设备号与channel的Map
     */
    private static Map<String, Channel> channelMap = new ConcurrentHashMap<>();

    /**
     * 存储channel与设备号的Map
     */
    private static Map<Channel, String> channelReverseMap = new ConcurrentHashMap<>();

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        channels.add(incoming);
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        channels.remove(incoming);
    }

    /**
     * 服务端监听到客户端活动 / 只要有客户端连接就进行这个方法
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel incoming = ctx.channel();
        log.info("ChatClient:{},在线", incoming.remoteAddress());

        /* ------ */
        InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = insocket.getAddress().getHostAddress();
        int clientPort = insocket.getPort();
        //获取连接通道唯一标识
        ChannelId channelId = ctx.channel().id();
        //如果map中不包含此连接，就保存连接
        if (CHANNEL_MAP.containsKey(channelId)) {
            log.info("客户端【" + channelId + "】是连接状态，连接通道数量: " + CHANNEL_MAP.size());
        } else {
            //保存连接
            CHANNEL_MAP.put(channelId, ctx);
            log.info("客户端【" + channelId + "】连接netty服务器[IP:" + clientIp + "--->PORT:" + clientPort + "]");
            log.info("连接通道数量: " + CHANNEL_MAP.size());
        }
        /* ------ */
    }

    /**
     * 服务端监听到客户端不活动 / 客户端终止连接就进入
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        /* ------ */
        InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = insocket.getAddress().getHostAddress();
       //获取终止连接的客户端ID
        ChannelId channelId = ctx.channel().id();
        //包含此客户端才去删除
        if (CHANNEL_MAP.containsKey(channelId)) {
            //删除连接
            CHANNEL_MAP.remove(channelId);
            System.out.println();
            log.info("客户端【" + channelId + "】退出netty服务器[IP:" + clientIp + "--->PORT:" + insocket.getPort() + "]");
            log.info("连接通道数量: " + CHANNEL_MAP.size());
        }
        /* ------ */
//        Channel incoming = ctx.channel();
//        channels.remove(incoming);
//        String key = channelReverseMap.get(incoming);
//        if (StringUtils.isNotBlank(key)) {
//            channelMap.remove(key);
//        }
//        channelReverseMap.remove(incoming);
//        log.info("ChatClient:{},掉线", incoming.remoteAddress());
    }

    /**
     * @param ctx
     * @DESCRIPTION: 有客户端发消息会触发此函数
     * @return: void
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

        log.info("加载客户端报文......");
        log.info("【" + ctx.channel().id() + "】" + " :" + msg);
        Channel incoming = ctx.channel();
        log.info("From Client:{}, msg:{}", incoming.remoteAddress(), msg.toString());

        //以下可以做获取客户端数据后返回
        //响应客户端
        this.channelWrite(ctx.channel().id(), msg);

        // 消息处理
//        messageManage(incoming, msg.toString());
    }

    /**
     * @param msg  需要发送的消息内容
     * @param channelId 连接通道唯一id
     * @DESCRIPTION: 服务端给客户端发送消息
     * @return: void
     */
    public void channelWrite(ChannelId channelId, Object msg) throws Exception {

        ChannelHandlerContext ctx = CHANNEL_MAP.get(channelId);

        if (ctx == null) {
            log.info("通道【" + channelId + "】不存在");
            return;
        }
        if (msg == null && msg == "") {
            log.info("服务端响应空的消息");
            return;
        }
        log.info("服务端响应------------------------------------------");
        //将客户端的信息直接返回写入ctx
        ctx.write(msg);
        //刷新缓存区
        ctx.flush();
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        String socketString = ctx.channel().remoteAddress().toString();
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state() == IdleState.READER_IDLE) {
                log.info("Client: " + socketString + " READER_IDLE 读超时");
                ctx.disconnect();
            } else if (event.state() == IdleState.WRITER_IDLE) {
                log.info("Client: " + socketString + " WRITER_IDLE 写超时");
                ctx.disconnect();
            } else if (event.state() == IdleState.ALL_IDLE) {
                log.info("Client: " + socketString + " ALL_IDLE 总超时");
                ctx.disconnect();
            }
        }
    }

    /**
     * 连接错误时调用
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        Channel incoming = ctx.channel();
        log.info("ChatClient:{},异常", incoming.remoteAddress());
        // 当出现异常就关闭连接
        cause.printStackTrace();
        ctx.close();
        log.info(ctx.channel().id() + " 发生了错误,此连接被关闭" + "此时连通数量: " + CHANNEL_MAP.size());
    }

}

配置Netty客户端

package com.chalk.netty.client;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName: NettyClinet
 * @Author: gluoh
 * @Date: 2021/02/24 15:29
 * @Description:
 */
@Slf4j
public class NettyClient {


    @Value("${printer.server.host}")
    private String host;
    @Value("${printer.server.port}")
    private int port;

    private static Channel channel;

    public NettyClient(){

    }

    public NettyClient(String host, int port) {
        this.host = host;
        this.port = port;
    }



    public  void start()  {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
                    .option(ChannelOption.SO_KEEPALIVE,true)
                    .channel(NioSocketChannel.class)
                    .handler(new NettyClientChannelInitializer(host,port));

            ChannelFuture f = b.connect(host,port).sync();

            //断线重连
            f.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture channelFuture) throws Exception {
                    if (!channelFuture.isSuccess()) {
                        final EventLoop loop = channelFuture.channel().eventLoop();
                        loop.schedule(new Runnable() {
                            @Override
                            public void run() {
                                log.error("服务端链接不上，开始重连操作...");
                                System.err.println("服务端链接不上，开始重连操作...");
                                start();
                            }
                        }, 1L, TimeUnit.SECONDS);
                    } else {
                        channel = channelFuture.channel();
                        log.info("服务端链接成功...");
                        System.err.println("服务端链接成功...");
                    }
                }
            });

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new NettyClient("127.0.0.1",7005).start();
    }
}

package com.chalk.netty.client;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName: ClientChannelInitializer
 * @Author: gluoh
 * @Date: 2021/02/24 15:29
 * @Description:
 */
public class NettyClientChannelInitializer extends ChannelInitializer<SocketChannel> {

    private String host;
    private int port;

    public NettyClientChannelInitializer(String host, int port) {
        this.host = host;
        this.port = port;
    }

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        pipeline.addLast("decoder", new ObjectDecoder(Integer.MAX_VALUE, ClassResolvers
                .weakCachingConcurrentResolver(this.getClass().getClassLoader())));
        pipeline.addLast("encoder", new ObjectEncoder());
        //心跳检测
        pipeline.addLast(new IdleStateHandler(0,5,0,TimeUnit.SECONDS));
        //客户端的逻辑
        pipeline.addLast("handler", new NettyClientHandler(host,port));

    }
}

package com.chalk.netty.client;


import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.EventLoop;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName: NettyClientHandler
 * @Author: gluoh
 * @Date: 2021/02/24 15:29
 * @Description:
 */
@Slf4j
public class NettyClientHandler extends SimpleChannelInboundHandler {

    private String host;
    private int port;
    private NettyClient nettyClient;


    public NettyClientHandler(String host, int port) {
        this.host = host;
        this.port = port;
        nettyClient = new NettyClient(host,port);
    }


    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, Object o)
            throws Exception {
        String response = "{\"data_id\":\"123\",\"message\":\"已接收请求\",\"gatename\":\"入口\",\"gateid\":\"1\",\"service\":\"setopenstrobe\",\"result_code\":0}";
        System.out.println(response);
        if (o.toString().startsWith("<")){
            log.info("response:{}", response);
            channelHandlerContext.writeAndFlush(response);
        }
        System.out.println("Server say : " + o.toString());;
    }


    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("通道已连接！！");
        String login = "{\"service\":\"checkKey\",\"parkid\":\"301019120373\",\"parkkey\":\"C80FB9B8-73E8-4C03-B300-2037F14F42C6\"}";
        log.info("login:{}", login);
        ctx.channel().writeAndFlush(login);
        super.channelActive(ctx);
    }

    /**
     * @param ctx
     * @DESCRIPTION: 有服务端端终止连接服务器会触发此函数
     * @return: void
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("断线了。。。。。。");
        //使用过程中断线重连
        final EventLoop eventLoop = ctx.channel().eventLoop();
        eventLoop.schedule(new Runnable() {
            @Override
            public void run() {
                nettyClient.start();
            }
        }, 1, TimeUnit.SECONDS);

        ctx.fireChannelInactive();
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt)
            throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state().equals(IdleState.READER_IDLE)) {
                System.out.println("READER_IDLE");

            } else if (event.state().equals(IdleState.WRITER_IDLE)) {
                /**发送心跳,保持长连接*/
                String heart =  new String("{\"service\":\"heartbeat\",\"parkid\":\"301019120373\",\"time\":\"2020-03-30 16:26:18\"}");
                log.info("heart:{}", heart);
                ctx.channel().writeAndFlush(heart);
                log.debug("心跳发送成功!");
                System.out.println("心跳发送成功!");
            } else if (event.state().equals(IdleState.ALL_IDLE)) {
                System.out.println("ALL_IDLE");
            }
        }
        super.userEventTriggered(ctx, evt);
    }

}

yml配置

netty:
  port: 7005
  # 公司测试私有IP
  # url: 
  url: 127.0.0.1
再见小的时候
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合netty
congge
03-15 3万+
前面介绍了netty的基本使用以及和websocket的整合，下面就说说如何用springboot整合netty，毕竟我们是要把netty作为一个服务端的框架整合到我们的项目中去的，总不能用main函数启动吧，下面来看具体的整合过程， 项目的基本结构如图，这里为了省事，没有整合mybatis和mysql，有兴趣的同学可参考我之前的博客把相关的依赖加进去即可， 1、pom文件，springboot...
springboot整合netty过程详解
08-25
springboot整合netty过程详解 SpringBoot整合Netty是当前开发中非常流行的一种技术组合，通过将Netty的高性能网络编程能力与SpringBoot的快速开发能力相结合，可以快速构建高性能的网络应用程序。本文将详细介绍...
SpringBoot 整合 Netty 实战
02-14
SpringBoot 整合 Netty 实战，把通讯接收到的数据存储到数据库中。
使用Springboot + netty 打造聊天服务（一）
最新发布
Java 技术专栏，从入门到精通，熟悉企业级开发
07-22 4332
/ 处理收到的消息 System . out . println("Received message: " + msg);} }// 处理收到的消息 System . out . println("Received message: " + msg);} }// 处理收到的消息 System . out . println("Received message: " + msg);
Netty与Spring Boot的整合
dehongqi4717的博客
01-29 325
​ 最近有朋友向我询问一些Netty与SpringBoot整合的相关问题，这里，我就总结了一下基本整合流程，也就是说，这篇文章 ，默认大家是对netty与Spring，SpringMVC的整合是没有什么问题的。现在，就进入正题吧。 Server端： 总的来说，服务端还是比较简单的，自己一共写了三个核心类。分别是 NettyServerListener：服务启动监听器 ServerC...
Springboot集成Netty
qq_37497275的博客
10-12 1945
本章具体讲解SpringBoot中如何集成Netty 1.搭建一个Springboot项目 一，服务端 1.项目结构目录 2.导入jar包 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId...
SpringBoot整合Netty(服务端)
m0_70554089的博客
05-17 4847
Netty是由JBOSS提供的一个Java开源框架，现为Github上的独立项目。它是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络IO程序。Netty主要针对在TCP协议下，面向Clients端的高并发应用，或者Peer-to-Peer场景下的大量数据持续传输的应用。Netty提供了一套完整的API，用于处理网络IO操作，如TCP和UDP套接字。它封装了底层的网络编程细节，使得开发者可以更加专注于业务逻辑的实现。
springboot整合 netty做心跳检测
04-22
springboot整合 netty做心跳检测 springboot整合 netty做心跳检测 springboot整合 netty做心跳检测 springboot整合 netty做心跳检测 springboot整合 netty做心跳检测 springboot整合 netty做心跳检测 springboot整合...
SpringBoot整合Netty心跳机制过程详解
08-24
SpringBoot 整合 Netty 心跳机制过程详解 SpringBoot 整合 Netty 心跳机制过程详解是指通过 SpringBoot 框架整合 Netty 网络框架来实现心跳机制的过程。心跳机制是指客户端和服务端之间的连接维持机制，当客户端和...
springboot整合netty的demo
01-22
SpringBoot整合Netty的目的是将SpringBoot的便捷性与Netty的高性能网络通信能力结合，适用于需要构建高并发、低延迟网络服务的场景。下面我们将详细探讨这个整合过程涉及的知识点。 首先，理解SpringBoot的核心理念...
springboot与netty整合
07-11
将springboot于netty 4.0 进行整合。能直接启动运行。
springboot整合netty，分客户端和服务端两个项目
07-20
springboot整合netty，分客户端和服务端两个项目，springboot整合netty，分客户端和服务端两个项目，springboot整合netty，分客户端和服务端两个项目，springboot整合netty，分客户端和服务端两个项目
SpringBoot整合Netty
热门推荐
Venus's Blog
09-14 13万+
Netty是一个基于Java的开源网络应用框架，它提供了高性能、异步事件驱动的网络编程能力。Netty旨在帮助开发者构建高性能、高可靠性的网络应用程序。Netty提供了简洁的API和丰富的功能，可以轻松处理各种网络通信协议，如TCP、UDP、WebSocket等。它的设计理念是基于事件驱动和回调机制，而不是传统的线程模型，这使得它可以实现高并发、低延迟的网络通信。通过使用Netty，开发者可以方便地处理复杂的网络通信逻辑，例如请求-响应模式、长连接、心跳检测等。
SpringBoot整合netty
大屎片的博客
03-19 172
引入依赖 <!-- netty依赖 --> <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.42.Final</version> <scope>c
SpringBoot 整合 Netty
摸鱼佬的博客
07-25 6948
一、common工程 1.maven依赖 2.自定义Netty数据包类型 3.自定义Netty数据包 4.自定义Netty数据包处理事件 二、netty-server工程 1.Netty服务端 2.Netty服务端初始化配置 3.Netty服务端处理器 4.Netty服务端自定义数据包处理监听器 5.Netty服务端启动类 三、netty-client工程 1.Netty客户端 2.Netty客户端通道初始化 3.Netty客户端处理器 4.Netty客户端自定义数据包处理监听器 5.Netty客户端启动类
SpringBoot集成Netty
Lyndon的专栏
02-01 1175
SpringBoot集成netty package cn.wxt.test; import cn.wxt.test.test2.Test2Server; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.sp
SpringBoot整合使用Netty
u013071014的博客
05-27 720
SpringBoot整合使用Netty 一. Netty简介 Netty是一款基于NIO(Nonblocking I/O，非阻塞IO)开发的网络通信框架，具有并发高、传输快、封装好的特性。相比于BIO(Blocking I/O，阻塞IO)，并发性能会有很大的提高。 由此可见，NIO单线程处理的连接数量会比BIO高很多，原因是由于Selector。 在NIO中，当一个Socket建立好之后，Thread并不会阻塞去接受这个Socket，而是将这个请求交给Selector，Selector会不断遍历所有的So
springboot 整合 netty
09-19
在springboot中整合netty可以实现心跳检测功能。在实现过程中，首先需要在pom文件中添加netty依赖。然后新建一个netty服务类，该类负责处理netty的相关操作。接着，在springboot启动类中调用netty服务类的方法来启动netty服务。最后，进行测试以确保整合成功。 在整合过程中可能会遇到一些问题，比如在调用其他类时使用了new构造，这样会导致无法进行依赖注入，可能会出现空指针异常。解决这个问题的方法是将需要注入的类添加为成员变量，并使用@Autowired注解进行注入。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值