Netty的简单封装-JSON

最新推荐文章于 2023-08-03 09:28:19 发布
最新推荐文章于 2023-08-03 09:28:19 发布
阅读量3.8k 收藏 3
点赞数 2
分类专栏： NETTY 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mososom/article/details/82747800
版权

基于netty通讯的简单封装

只是一个简单的demo版本测试使用

本案例只包含服务端 

netty版本：4.1

<dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.20.Final</version>
</dependency>

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
</dependency>

数据格式 JSON UTF-8

#############################关键代码##########################

1.启动入口：

/**
     * 启动server
     */
    public static Boolean startServer() {
        try {
            if (b == null) {
                Thread thread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            b = new Server().startServer(port);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                });
                //设置为守护线程
                thread.setDaemon(true);
                thread.start();
                return true;
            }

        } catch (Exception e) {

            e.printStackTrace();
        }
        return false;
    }

2.netty服务端主类：



import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import java.nio.charset.Charset;

public class Server {


    private static EventLoopGroup boss;
    private static EventLoopGroup worker;
    private static ServerBootstrap bootstrap;

    /**
     * netty服务端ServerBootstrap();
     * */
    public  ServerBootstrap startServer(Integer port) throws InterruptedException {
        try {
            //多线程模式处理
            bootstrap = new ServerBootstrap();
            boss = new NioEventLoopGroup(4); //可以根据机器核心*2设置
            worker = new NioEventLoopGroup(8);
            bootstrap.group(boss,worker);
            bootstrap.channel(NioServerSocketChannel.class);
            bootstrap.childHandler(new NettyServerFilter()); //设置过滤器
            // 服务器绑定端口监听
            ChannelFuture f = bootstrap.bind(port).sync();
            System.out.println("服务端启动成功...");
            // 监听服务器关闭监听
            f.channel().closeFuture().sync();
        } finally {
            boss.shutdownGracefully(); 关闭EventLoopGroup，释放掉所有资源包括创建的线程
        }
        return bootstrap;
    }
}

class NettyServerHandler extends SimpleChannelInboundHandler<String> {
    /*
     * 收到消息时，返回信息
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg)
            throws Exception {
        // 收到消息直接打印输出
        System.out.println("服务端接受的消息 : " + msg + System.currentTimeMillis());
        ServerControll.handData(ctx,msg);
    }

    /*
     * 建立连接时，返回消息
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("连接的客户端地址:" + ctx.channel().remoteAddress());
        ServerDataPool.setConnectionList(ctx);
        ctx.writeAndFlush("{\"data\": {\"inked\": \"ok\"},\"code\": \"000\",\"msg\": \"登录成功\",\"tsp\": 152695656465}\n");
        super.channelActive(ctx);
    }
}

class NettyServerFilter extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline ph = ch.pipeline();
        // 以("\n")为结尾分割的 解码器
        ph.addLast("framer", new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));
        // 解码和编码，应和客户端一致
        ph.addLast("decoder", new StringDecoder(Charset.forName("UTF-8")));
        ph.addLast("encoder", new StringEncoder(Charset.forName("UTF-8")));
        ph.addLast("handler", new NettyServerHandler());// 服务端业务逻辑
    }
}

3.服务总控  + 链接池


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.jfinal.weixin.sdk.utils.JsonUtils;
import io.netty.channel.ChannelHandlerContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ServerControll {

    private static final Logger LOGGER = LoggerFactory.getLogger(ServerControll.class);


    /**
     * 接收到的消息处理
     */
    public static void handData(ChannelHandlerContext ctx, String msg) throws Exception {
        try {
            jsonObject.toJavaObject(BizCodeEnum.getClassByCode(jsonObject.get("code").toString())).analysis(ctx);
        } catch (Exception e) {
            e.printStackTrace();
            //返回服务端错误信息
            ctx.writeAndFlush("{\"data\": {\"eqpNo\": \"\"},\"code\": \"999\",\"msg\": \"数据解析错误\",\"tsp\": 152695656465}\n");
        }
    }

    /***
     * 发送处理之后需要返回的信息(登录时调用)
     * */
    public static void sendData(BaseTransfer data, ChannelHandlerContext ctx) throws Exception {
        String returnStr = JSON.toJSONString(data);
        if (data.getEqpNo() != null) {
            ServerDataPool.getCtxByEqpNo(data.getEqpNo()).writeAndFlush(returnStr + "\n");
        } else {
            ctx.writeAndFlush(returnStr + "\n");
        }
        LOGGER.info(Thread.currentThread().getName() + "返回信息：【" + returnStr + "】");
    }

    /***
     * 发送处理之后需要返回的信息
     * */
    public static void sendData(BaseTransfer data) throws Exception {
        String returnStr = JsonUtils.toJson(data);
        ServerDataPool.getCtxByEqpNo(data.getEqpNo()).writeAndFlush(returnStr + "\n");
        LOGGER.info(Thread.currentThread().getName() + "返回信息：【" + returnStr + "】");
    }

    /**
     * 清理无用链接
     **/
    private static void cleanUselessConnection() {}

    /**
     * 断开链接
     */
    private static Integer breakConnection() {return null;}

    /**
     * 断开所有链接
     */
    public static Boolean breakAllConnection() {return false;}


}


import io.netty.channel.ChannelHandlerContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ServerDataPool {

    private static final Logger LOGGER = LoggerFactory.getLogger(ServerDataPool.class);

    /**
     * 存放已经登录的connection
     */
    private static final Map<String, CtxPackage> ACTIVE_POOL = new HashMap<>();

    /**
     * 存放所有链接到服务器的connection
     */
    private static final List<CtxPackage> CONNAETION_LIST = new ArrayList<>();

    /**
     * 根据eqpNo获取cx
     */
    public static ChannelHandlerContext getCtxByEqpNo(String eqpNo) {
        CtxPackage ctxPackage = ACTIVE_POOL.get(eqpNo);
        return ctxPackage.updataActiveTimeStamp().getCtx();
    }

    /**
     * 根据eqpNo获取cxpackage
     */
    public static CtxPackage getCtxPackageByEqpNo(String eqpNo) {
        CtxPackage ctxPackage = ACTIVE_POOL.get(eqpNo);
        return ctxPackage;
    }

    /**
     * 清除无用的链接
     */
    public static int removeUnuseCtx(Long intervalTimes) {
        Long now = System.currentTimeMillis();
        int count = 0;
        for (CtxPackage ctxPackage : CONNAETION_LIST) {
            if (!ctxPackage.getLogIn() && (ctxPackage.getLastActiveTimeStamp() + now) < now) {//未登录并且链接维持时间过长的的关闭
                try {
                    ctxPackage.getCtx().close();
                    CONNAETION_LIST.remove(ctxPackage);
                    LOGGER.info("【删除过期链接】:"+ CONNAETION_LIST.add(ctxPackage));
                    count++;
                } catch (Exception e) {
                    LOGGER.error("【关闭连接:%s , 异常！】", ctxPackage.getCtx().channel().id().asLongText());
                }
            }
        }
        return count;
    }

    /**
     * 向CONNAETION_LIST里面添加
     */
    public static Boolean setConnectionList(ChannelHandlerContext ctx) {
        CtxPackage ctxPackage = new CtxPackage();
        ctxPackage.setCtx(ctx);
        ctxPackage.setLastActiveTimeStamp(System.currentTimeMillis());
        ctxPackage.setLogIn(false);
        LOGGER.info("【创建新链接】:"+ CONNAETION_LIST.add(ctxPackage));
        removeUnuseCtx(60*15L);
        return true;
    }

    /**
     * 向ACTIVE_POOL里面添加对应的ctxPackage
     */
    public static Boolean setActivePool(String eqpNo, ChannelHandlerContext ctx) {
        CtxPackage ctxPackage = new CtxPackage();
        ctxPackage.setCtx(ctx);
        ctxPackage.setLastActiveTimeStamp(System.currentTimeMillis());
        ctxPackage.setLogIn(true);
        ctxPackage.setEqpNo(eqpNo);
        ACTIVE_POOL.put(eqpNo, ctxPackage);
        return true;
    }

}

4.数据包



import io.netty.channel.ChannelHandlerContext;

public class CtxPackage {
    /**
     * 机识别码
     * */
    private String eqpNo;
    /**
     * 游戏过程用户识别码
     * */
    private String token;
    /**
     * 最近一次收到客户端消息时间
     * */
    private Long lastActiveTimeStamp;
    /**
     * 是否登录
     * */
    private Boolean isLogIn;

    /**
     * netty通道
     * */
    private ChannelHandlerContext ctx;


    public String getEqpNo() {
        return eqpNo;
    }

    public void setEqpNo(String eqpNo) {
        this.eqpNo = eqpNo;
    }

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public Long getLastActiveTimeStamp() {
        return lastActiveTimeStamp;
    }

    public void setLastActiveTimeStamp(Long lastActiveTimeStamp) {
        this.lastActiveTimeStamp = lastActiveTimeStamp;
    }

    public Boolean getLogIn() {
        return isLogIn;
    }

    public void setLogIn(Boolean logIn) {
        isLogIn = logIn;
    }

    public ChannelHandlerContext getCtx() {
        return ctx;
    }

    public void setCtx(ChannelHandlerContext ctx) {
        this.ctx = ctx;
    }
    
    public CtxPackage updataActiveTimeStamp(){
        this.setLastActiveTimeStamp(System.currentTimeMillis());
        return this;
    }
}

5.具体识别码

public enum  BizCodeEnum {

    /**
     *正常业务代码
     * */
    BIZ_SUCCESS("000","成功",null),
    BIZ_TO_LOGIN("101","登录", LoginDataTs.class),
    BIZ_SEND_TIP("102","心跳包", TipDataTs.class),
    BIZ_SEND_TIP_BACK("103","在线",null),
//
    BIZ_START_GAME("201","启动游戏",null),
//    BIZ_START_OVER("202","游戏已启动"),
    BIZ_GAME_DATA("203","游戏数据上报",GameDataTs.class),

    ERROR_USERNAME("901","机器用户名不存在",null),
    ERROR_PASSWORD("902","机器登录密码错误",null),
    ERROR_CONNECTION("903","机器用户名不存在",null),
    ERROR_START("904","游戏启动失败",null),
    ERROR_DATA("905","游戏数据异常",null),
    ERROR_DATA_FORMAT("906","游戏数据不完整",null),
    ERROR_STATISTIC("907","游戏统计数据失败",null),
    ERROR_EQP("908","客户端暂不可用",null),
    ERROR_SERVER("909","服务器异常",null),
    ERROR_CODE("910","CODE无效",null);

    private String code;
    private String msg;
    private Class<BaseTransfer> clazz;

    BizCodeEnum(String code,String msg,Class clazz){
        this.code = code;
        this.msg = msg;
        this.clazz =clazz;
    }


    public String getCode() {
        return code;
    }

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

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Class getClazz() {
        return clazz;
    }

    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }

    
}

6.数据包具体处理父类 

package com.skyfly.up.server.dataModle;


import com.skyfly.up.server.BizCodeEnum;
import com.skyfly.up.server.ServerControll;
import io.netty.channel.ChannelHandlerContext;

import java.io.Serializable;

public abstract class BaseTransfer implements Serializable{

    /**
     * 业务代码
     * */
    private String code;

    /**
     * 时间
     * */
    private Long tsp = System.currentTimeMillis();

    /**
     * 返回的消息
     * */
    private String msg;

    /**
     *token
     * 用户登录之后才会有
     * */
    private String token;

    /**
     * 识别码
     * */
    private String eqpNo;

    public BaseTransfer(String code,String msg){
        this.code = code;
        this.msg = msg;
    }

    public BaseTransfer(){}

    public abstract void analysis(ChannelHandlerContext ctx) throws Exception;

    /**
     * @param baseTransfer
     * @param eqpNo
     * @param ctx
     * @throws Exception
     */
    public void finalHandle(BaseTransfer baseTransfer,String eqpNo,ChannelHandlerContext ctx) throws Exception{
        if(baseTransfer == null){
            baseTransfer.setCode(BizCodeEnum.BIZ_SUCCESS.getCode());
            baseTransfer.setMsg(BizCodeEnum.BIZ_SUCCESS.getMsg());
        }
        baseTransfer.setEqpNo(eqpNo);
        ServerControll.sendData(baseTransfer,ctx);
    }


    public void finalHandle(BaseTransfer baseTransfer,String eqpNo) throws Exception{
        if(baseTransfer == null){
            baseTransfer.setCode(BizCodeEnum.BIZ_SUCCESS.getCode());
            baseTransfer.setMsg(BizCodeEnum.BIZ_SUCCESS.getMsg());
        }
        baseTransfer.setEqpNo(eqpNo);
        ServerControll.sendData(baseTransfer);
    }


    public String getCode() {
        return code;
    }

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

    public Long getTsp() {
        return tsp;
    }

    public void setTsp(Long tsp) {
        this.tsp = tsp;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public String getEqpNo() {
        return eqpNo;
    }

    public void setEqpNo(String eqpNo) {
        this.eqpNo = eqpNo;
    }


}

7.具体实现

import io.netty.channel.ChannelHandlerContext;

public class LoginDataTs extends BaseTransfer {

    private LoginDataRe data;

    public LoginDataRe getData() {
        return data;
    }

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

    /**
     * 具体的处理方法
     * 最后调用finalHandle(BaseTransfer baseTransfer)返回对应的数据
     */
    @Override
    public void analysis(ChannelHandlerContext ctx) throws Exception{
        /**
         *1.验证用户名密码
         *2.不正确直接返回
         *3.登录后保存 返回信息 带上eqpNo
         * */
        BizEqp bizEqp = BizEqp.dao.getEqpByName(data.getEqpName());
        if (bizEqp == null) {
            //返回账号错误
            BaseTransfer baseTransfer = new NormalResult(BizCodeEnum.ERROR_USERNAME.getCode(),BizCodeEnum.ERROR_USERNAME.getMsg());
            finalHandle(baseTransfer,getEqpNo(),ctx);
            return;
        }
        String passMD5 = MD5Util.getMD5(data.getPassword());
        if (!passMD5.equals(bizEqp.getPassword())) {
            BaseTransfer baseTransfer = new NormalResult(BizCodeEnum.ERROR_PASSWORD.getCode(),BizCodeEnum.ERROR_PASSWORD.getMsg());
            finalHandle(baseTransfer,getEqpNo(),ctx);
            return;
        }
        /**
         * 1.保存登录信息
         * 2.返回数据
         * */
        this.setEqpNo(bizEqp.getEqpNo());
        ServerDataPool.setActivePool(getEqpNo(),ctx);
        BaseTransfer baseTransfer = new LoginResultData(BizCodeEnum.BIZ_SUCCESS.getCode(),BizCodeEnum.BIZ_SUCCESS.getMsg(),getEqpNo());
        finalHandle(baseTransfer, getEqpNo());

    }

}


public class LoginDataRe{

    private String eqpName;

    private String password;

    public String getEqpName() {
        return eqpName;
    }

    public void setEqpName(String eqpName) {
        this.eqpName = eqpName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

以上只是个人写的demo测试

mososom
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Netty实现长连接通讯-连接协议为了简单json封装
09-27
Netty实现长连接通讯,连接协议为了简单json封装,如果需要协议变化可以自己封装，有问题可以联系邮箱：lmjlimj@foxmail.com
Netty:Netty基本使用封装
05-09
Netty Netty基本使用二次开发,封装Netty服务端和客户端的使用 使用说明 若格式有问题可在idea中查看 一、基本消息传输协议及编解码 1.所有传输的基本业务数据由于业务设计是通过二进制字节数组进行传输,在本工程中若客户端 与服务端都是Netty协议可封装为NettyRequest和NettyResponse进行传输和开发; 2.对于客户端与服务端的基础配置: netty: server: port: 18000 decode: request: false encode: response: false client: server: address: localhost port: 18000 encode: request: false decode: response: false 在服务端中的netty.server.decode.request与客户端中的netty
nio-Netty-字节的工具封装
wlwork66的博客
06-01 256
/** * */ package com.common.util; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.List; public class ByteUtil { private static int INT8_MASK = 0xFF; private static int I
Netty封装NIO
cjbaxb的专栏
11-18 915
基于netty-4.1.40.Final-SNAPSHOT
Netty中线程封装与管理与在游戏中的简单使用
王广帅--游戏开发技术
01-27 728
在Netty中，netty对线程模型进行了重新封装，它们分别是EventExecutorGroup和EventExecutor.每个EventExecutor是一个单独的线程，可以执行Runnable任务。EventExecutorGroup相当于一个线程组，用于管理和分配一组EventExecutor.我们知道Netty是基于事件驱动的。这样的封装给我们的开发带来了非常好的顺序。而且它还封装了定...
netty入门例子--(不是翻译官方文档)
02-26
这个“netty入门例子”旨在帮助初学者理解Netty的基本用法和特性，而不是简单地翻译官方文档，它提供了几个开发模板，以便于深入理解Netty中的消息异步通信机制和TCP通信的封装。 首先，Netty的核心是它的异步模型...
c++ netty.zip
06-22
4. **Google Protocol Buffers (protobuf)**：protobuf是一种高效的结构化数据序列化协议，类似于XML或JSON，但更小、更快、更简单。它可以将数据结构定义为.proto文件，然后生成对应的源代码，使得在不同语言之间...
Netty Demo
06-13
4. **创建JsonEncoder**：同样，你需要一个编码器将Java对象转换为JSON字符串，然后封装到ByteBuf中。 ```java public class JsonEncoder extends MessageToByteEncoder<User> { private final ObjectMapper ...
netty即时通讯程序
09-05
Netty对NIO进行了封装，提供了更加简洁易用的API，使得开发者无需深入理解NIO的底层细节就能编写出高效的网络应用。 在即时通讯系统中，Netty主要负责以下关键组件： 1. **Bootstrap**: 它是Netty中的启动类，用于...
netty网络框架，封装 http，tcp，udp的例子
01-26
netty网络框架，封装 http，tcp，udp的例子，自己整理的，关键的地方都有注释，对学习netty网络框架很有帮助，希望大家喜欢，欢迎留言评论
基于netty封装的快速分布式任务开发框架
09-16
一个基于netty封装的快速分布式任务开发框架，目标：简单，简单，再简单！ easynetty-demo是用spring-boot，spring-shell实现的示例
基于 netty 封装的超简单通俗易用 服务端客户端交互框架 《net-framework》原理，源码和使用说明,开箱即用，只需要开发业务逻辑，完全自定义无限扩充 [结尾附github源码]
峡谷电光马仔的博客
11-11 624
基于 netty 封装的超简单通俗易用 服务端客户端交互框架 《net-framework》原理，源码和使用说明,开箱即用，只需要开发业务逻辑，完全自定义无限扩充 [结尾附github源码] 1.聊天室 2.远程控制 3.分布式计算 4.文件传输 5.其他交互场景
Netty-搭建一个简单的Json协议消息接收发送服务
最新发布
yimint的博客
08-03 1011
使用Json协议搭建一个简单的消息接收发送服务，并使用LengthFieldPrepender和LengthFieldBasedFrameDecoder解决粘包问题
netty自定义封包实现
幻神舞的专栏
02-24 944
netty自定义封包
Netty服务器部署在Android设备上，接收来自PC客户端的Java Socket客户端发送的JSON数据
Zhang Phil
05-27 1749
Netty服务器部署在Android设备上，接收来自PC客户端的Java Socket客户端发送的数据 一个简单的模型，在Android手机上部署一个Netty写的服务器，绑定端口9000，等待客户端连接，连接建立后，读取来自PC客户端的发送过来的字符串。 在Android手机上安装部署的Netty服务器： package zhangphil.netttserver; import...
netty学习（5）:netty实现注册中心和发送JSON数据到指定的客户端
weixin_42774617的博客
07-09 1367
Request,Response定义Message@Data//消息来源//消息实体//序列化//反序列化。
自己基于netty封装的网络通信框架
zhrglchp的专栏
01-07 626
自己基于netty封装的网络通信框架 作者：andyhc | 2012/6/5 12:17:54 | 阅读148次 最近在做一个项目，用到了远程调用方式，开始采用的是rmi，后来经过测试，rmi可能无法达到项目的一些性能上的要求，于是采用了基于tcp/udp的netty，但是直接用netty开发，有些麻烦了，我们想把服务抽取出来部署在远程服务器上，开发的兄弟们只是在自己的项目中负责调用...
Netty-粘包，半包和使用Json方式传输数据
qq1010234991的博客
11-26 4407
文章目录JSON和ProtoBuf序列化背景详解粘包和拆包粘包和半包半包问题的实践案例运行结果半包粘包解决JSON协议通信codeJson序列化与反序列化实践案例JsonMsgJsonMsgDemoJSON传输至服务器端的实践案例code客户端实践案例 JSON和ProtoBuf序列化 背景 在开发一些远程过程调用(RPC)的程序时，通常会涉及对象的序列化/反序列化的问题， 例如一个对象从客户端...
Netty Client的简单封装
研究员的自我修养
09-06 2598
Netty Client的简单封装 Netty 基于java NIO 网络通信框架，具有高效、简单、快速的应用特点。 Netty Client NettyClient NettyClientManager public class NettyClient { public static final int Port = 8888; public static final String IP = "192.168.0.100"; private NioEventLoopGrou
Netty框架详解：高性能、易维护的NIO选择
Netty包含了对多种协议的支持，包括ProtocolBuffer和JSON等信息格式的封装，并采用了责任链模式进行编码和解码。此外，Netty还解决了Java NIO中的某些问题，如Linux上的poll/epoll bug，以减少CPU使用率。然而，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值