bufferevent_socket 客户端实现心跳和重连机制

最新推荐文章于 2024-08-06 18:45:00 发布
最新推荐文章于 2024-08-06 18:45:00 发布
阅读量870 收藏 6
点赞数
分类专栏： libevent 文章标签： 重连 心跳 libevent
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CAir2/article/details/109745240
版权

重连机制
重连可能是一开始就没链接上，也可能是被断开，也可能是网络波动，原因很多，对于一开始就没链接上的socket我们可以复用重新connect，但是对于被断开的socket是不能被复用的，必须重新创建然后connect，所以为了方便我们不管什么原因都选择重新创建并connect

void ClientSockItem::Connect()
{
	CStringA strFomat;
	strFomat.Format("[NetUtil] ClientSockItem[%I64u]::Connect\r\n", GetId());
	OutputDebugStringA(strFomat);
	CCritical lk(m_cs);
	//如果是手动关闭或者已经连接上则不重连
	if (m_bManalClose || m_bConnected)
	{
		return;
	}

	if ((GetTickCount64() - m_LastTryConnectTime) <= PER_TRY_MINITIME)
	{
		struct timeval tTimeout = { 12, 0 };
		bufferevent_set_timeouts(m_pbuf_eve, &tTimeout, nullptr);
		return;
	}

	if (m_pbuf_eve != nullptr)
	{
		bufferevent_free(m_pbuf_eve);
		m_pbuf_eve = nullptr;
	}

	int options = BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE;
	m_pbuf_eve = bufferevent_socket_new(g_event_base, -1, options);

	//启用读写事件通知，默认只有写
	if (m_pbuf_eve)
	{
		bufferevent_setcb(m_pbuf_eve, SockCallBackMgr::handle_sockitem_read_data_cb, SockCallBackMgr::handle_sockitem_write_data_cb, SockCallBackMgr::handle_sockitem_event_cb, this);
		bufferevent_enable(m_pbuf_eve, EV_READ | EV_WRITE);
	}
	
	sockaddr_in addr = { 0 };
	addr.sin_family = AF_INET;
	addr.sin_port = htons(m_port);
	addr.sin_addr.S_un.S_addr = inet_addr(m_strip.c_str());
	//inet_pton(AF_INET, m_strip.c_str(), &addr.sin_addr);
	bufferevent_socket_connect(m_pbuf_eve, (const sockaddr *)&addr, sizeof(addr));
	m_LastTryConnectTime = GetTickCount64();
}

由于连接失败的原因很多，所以为了控制重连频率我们选择使用定时器进行控制，防止过快消耗socket。

心跳机制
由于bufferevent_socket_new创建的event，本身支持设置timeoout，所以当链接上之后我们就可以设置定时器，定时发送心跳包（可以增加时间戳，记录最后一次发送数据的时间戳，更加高效的控制心跳），（timeout触发之后会取消EV_READ或者EV_WRITE读事件所以需要重启读事件）。

void ClientSockItem::OnConnectOK()
{
	CStringA strFomat;
	strFomat.Format("[NetUtil] ClientSockItem[%I64u]::OnConnectOK\r\n", GetId());
	OutputDebugStringA(strFomat);

	CCritical lk(m_cs);
	m_bConnected = true;
	m_recvData.clear();
	//心跳定时器
	struct timeval tTimeout = { 30, 0 };
	bufferevent_set_timeouts(m_pbuf_eve, &tTimeout, nullptr);
	//链接上之后立马发送数据，防止空链接被断开
	DoHeartBeat();
	DoSub();
}

void ClientSockItem::OnTimeouted(short what)
{
	CCritical lk(m_cs);
	if (m_bManalClose)
		return;

	//恢复读写
	bufferevent_enable(m_pbuf_eve, EV_READ | EV_WRITE);
	//如果没有链接上则重连否则发送心跳
	if (!m_bConnected)
	{
		bufferevent_set_timeouts(m_pbuf_eve, nullptr, nullptr);
		Connect();
	}
	else
	{
		//调试阶段取消心跳
		DoHeartBeat();
	}
	
}

完整源码：
ISocket.h

#pragma once
extern __int64 g_api_socket_id;
class ISock{
public:
	ISock(){ m_sock_Id = ::InterlockedIncrement64(&g_api_socket_id); }
	virtual uint64_t GetId(){ return m_sock_Id; };
	virtual int SendData(const void *pdata, unsigned __int64 date_len, uint64_t sock_id,const char *channel = nullptr) = 0;
	virtual void Close() = 0;
	virtual void SetSubChannel(std::string channel){};//以|分开
protected:
	uint64_t m_sock_Id;
};

class IServer :public ISock
{
public:
	virtual void OnAccept(evutil_socket_t fd, struct sockaddr *addr, int socklen) = 0;
	virtual void OnAcceptError() = 0;
};

class ISocketItem :public ISock{
public:
	virtual void OnRecvData(struct bufferevent *bev) = 0;
	virtual void OnError() = 0;
	virtual void OnTimeouted(short what) = 0;
	virtual void OnWriteData(struct bufferevent *bev){};
	virtual void OnConnectOK(){};
	virtual void OnDisConnected(){};//链接失败或者断开链接
	
};

SockCallBackMgr.cpp

#include "stdafx.h"
#include "SockCallBackMgr.h"
#include "BaseServer.h"

void SockCallBackMgr::handle_accept_cb(struct evconnlistener * listener, evutil_socket_t fd, struct sockaddr *addr, int socklen, void *arg)
{
	IServer *pBaseServer = (IServer *)arg;
	if (pBaseServer)
		pBaseServer->OnAccept(fd, addr, socklen);
}

void SockCallBackMgr::handle_accept_errorcb(struct evconnlistener *listener, void *arg)
{
	IServer *pBaseServer = (IServer *)arg;
	if (pBaseServer)
		pBaseServer->OnAcceptError();
}

void SockCallBackMgr::handle_sockitem_read_data_cb(struct bufferevent *bev, void *ctx)
{
	ISocketItem *pSocketItem = (ISocketItem *)ctx;
	if (pSocketItem == nullptr)
		return;

	pSocketItem->OnRecvData(bev);

}

void SockCallBackMgr::handle_sockitem_write_data_cb(struct bufferevent *bev, void *ctx)
{
	ISocketItem *pSocketItem = (ISocketItem *)ctx;
	if (pSocketItem == nullptr)
		return;

	pSocketItem->OnWriteData(bev);
}

void SockCallBackMgr::handle_sockitem_event_cb(struct bufferevent *bev, short what, void *ctx)
{
	ISocketItem *pSocketItem = (ISocketItem *)ctx;
	if (pSocketItem == nullptr)
		return;

	//如果客户端主动断开，则受到BEV_EVENT_EOF|BEV_EVENT_READING
	if (what & BEV_EVENT_CONNECTED)
	{
		pSocketItem->OnConnectOK();
	}
	//链接建立之后断开
	else if (what & BEV_EVENT_EOF)
	{
		pSocketItem->OnDisConnected();
	}
	else if (what & BEV_EVENT_TIMEOUT)
	{
		pSocketItem->OnTimeouted(what);
	}
	//链接出错
	else if (what & BEV_EVENT_ERROR)
	{
		pSocketItem->OnError();
	}
	else if (what & BEV_EVENT_READING)
	{
		int a = 0;
	}
	else if (what & BEV_EVENT_WRITING)
	{
		int a = 0;
	}
	
}

ClientSockItem.cpp

#include "stdafx.h"
#include "ClientSockItem.h"
#include "SockCallBackMgr.h"
#include <atlstr.h>

const int PER_TRY_MINITIME = 10000;//重连最小间隔时间
ClientSockItem::ClientSockItem(const char *szip, unsigned short port,SOCKET_DATA_CALL event_call, void * call_ctx)
{
	::InitializeCriticalSection(&m_cs);
	m_pDataCall = event_call;
	m_pDataCallCtx = call_ctx;
	m_bConnected = false;
	m_LastTryConnectTime = 0;
	m_bManalClose = false;
	m_strip = szip;
	m_port = port;
	int options = BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE;	
	m_pbuf_eve = nullptr;

}

ClientSockItem::~ClientSockItem()
{
	m_bManalClose = true;
	if (m_pbuf_eve)
		bufferevent_free(m_pbuf_eve);
	m_pbuf_eve = nullptr;
	DeleteCriticalSection(&m_cs);
}

void ClientSockItem::Connect()
{
	CStringA strFomat;
	strFomat.Format("[NetUtil] ClientSockItem[%I64u]::Connect\r\n", GetId());
	OutputDebugStringA(strFomat);
	CCritical lk(m_cs);
	//如果是手动关闭或者已经连接上则不重连
	if (m_bManalClose || m_bConnected)
	{
		return;
	}

	if ((GetTickCount64() - m_LastTryConnectTime) <= PER_TRY_MINITIME)
	{
		struct timeval tTimeout = { 12, 0 };
		bufferevent_set_timeouts(m_pbuf_eve, &tTimeout, nullptr);
		return;
	}

	if (m_pbuf_eve != nullptr)
	{
		bufferevent_free(m_pbuf_eve);
		m_pbuf_eve = nullptr;
	}

	int options = BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE;
	m_pbuf_eve = bufferevent_socket_new(g_event_base, -1, options);

	//启用读写事件通知，默认只有写
	if (m_pbuf_eve)
	{
		bufferevent_setcb(m_pbuf_eve, SockCallBackMgr::handle_sockitem_read_data_cb, SockCallBackMgr::handle_sockitem_write_data_cb, SockCallBackMgr::handle_sockitem_event_cb, this);
		bufferevent_enable(m_pbuf_eve, EV_READ | EV_WRITE);
	}
	
	sockaddr_in addr = { 0 };
	addr.sin_family = AF_INET;
	addr.sin_port = htons(m_port);
	addr.sin_addr.S_un.S_addr = inet_addr(m_strip.c_str());
	//inet_pton(AF_INET, m_strip.c_str(), &addr.sin_addr);
	bufferevent_socket_connect(m_pbuf_eve, (const sockaddr *)&addr, sizeof(addr));
	m_LastTryConnectTime = GetTickCount64();
}

void ClientSockItem::OnRecvData(struct bufferevent *bev)
{
	CCritical lk(m_cs);

	CStringA strFomat;
	
	char szBuf[RECV_BUF_LEN] = "";
	size_t iread = 0;
	do
	{
		iread = bufferevent_read(bev, szBuf, RECV_BUF_LEN);
		strFomat.Format("[NetUtil] ClientSockItem[%I64u]::OnRecvData[%d]\r\n", GetId(), iread);
		OutputDebugStringA(strFomat);
		
		if (iread > 0)
		{
			m_recvData.append(szBuf, iread);
		}
		
		while (m_recvData.size() >= COM_HEAD_LEN)
		{
			ComHead *pComHead = (ComHead *)m_recvData.data();
			//如果当前版本不匹配，则关闭socket
			if (pComHead->Version != NOW_COM_VERSION)
			{
				CStringA strFomat;
				strFomat.Format("[NetUtil] ClientSockItem[%I64u]::Version[%d] Not Match()\r\n", GetId(), pComHead->Version);
				OutputDebugStringA(strFomat);

				Close();
				OnDisConnected();
				m_recvData.clear();
				return;
			}

			if(pComHead->iPackLength <= m_recvData.size())
			{
				//心跳和订阅指令内部截留
				if (pComHead->bizType == BIZ_HEARTBEAT)
				{
					OnHeartBeat();
				}
				else if (m_pDataCall)
					m_pDataCall(0, GetId(), pComHead,m_pDataCallCtx);
				//清楚该部分数据
				m_recvData.erase(m_recvData.begin(), m_recvData.begin() + pComHead->iPackLength);
				continue;
			}
			break;
		}
		

	} while (iread == RECV_BUF_LEN);
}

int ClientSockItem::SendData(const void *pdata, unsigned __int64 date_len, uint64_t sock_id, const char *channel)
{
	CStringA strFomat;
	CCritical lk(m_cs);
	int nret = -1;
	if (m_pbuf_eve && m_bConnected){
		nret = bufferevent_write(m_pbuf_eve, pdata, date_len);
		//失败，重连
		if (nret == -1){
			strFomat.Format("[NetUtil] ClientSockItem[%I64u]::SendData[%I64u] failed,ret=-1\r\n", GetId(), date_len);
			OutputDebugStringA(strFomat);
			m_bConnected = false;
			Connect();
		}
		else
		{
			strFomat.Format("[NetUtil] ClientSockItem[%I64u]::SendData[%I64u]\r\n", GetId(), date_len);
			OutputDebugStringA(strFomat);
		}
	}
	else
	{
		strFomat.Format("[NetUtil] ClientSockItem[%I64u]::SendData[%I64u] failed,m_pbuf_eve[%d] m_bConnected[%s]\r\n", GetId(), date_len, m_pbuf_eve, (m_bConnected ? "true":"false"));
		OutputDebugStringA(strFomat);
	}
		
	return nret;
}

void ClientSockItem::OnConnectOK()
{
	CStringA strFomat;
	strFomat.Format("[NetUtil] ClientSockItem[%I64u]::OnConnectOK\r\n", GetId());
	OutputDebugStringA(strFomat);

	CCritical lk(m_cs);
	m_bConnected = true;
	m_recvData.clear();
	//心跳定时器
	struct timeval tTimeout = { 30, 0 };
	bufferevent_set_timeouts(m_pbuf_eve, &tTimeout, nullptr);
	//链接上之后立马发送数据，防止空链接被断开
	DoHeartBeat();
	DoSub();
}

void ClientSockItem::OnDisConnected()
{
	OutputDebugStringA("[NetUtil] ClientSockItem::OnDisConnected\r\n");
	CCritical lk(m_cs);
	m_bConnected = false;
	Connect();
}

void ClientSockItem::OnError()
{
	CStringA strFomat;
	strFomat.Format("[NetUtil] ClientSockItem[%I64u]::OnError\r\n", GetId());
	OutputDebugStringA(strFomat);

	CCritical lk(m_cs);
	m_bConnected = false;
	Connect();
}

void ClientSockItem::OnTimeouted(short what)
{
	CCritical lk(m_cs);
	if (m_bManalClose)
		return;

	//恢复读写
	bufferevent_enable(m_pbuf_eve, EV_READ | EV_WRITE);
	//如果没有链接上则重连否则发送心跳
	if (!m_bConnected)
	{
		bufferevent_set_timeouts(m_pbuf_eve, nullptr, nullptr);
		Connect();
	}
	else
	{
		//调试阶段取消心跳
		DoHeartBeat();
	}
	
}

void ClientSockItem::Close()
{
	CStringA strFomat;
	strFomat.Format("[NetUtil] ClientSockItem[%I64u]::Close\r\n", GetId());
	OutputDebugStringA(strFomat);
	CCritical lk(m_cs);
	m_bManalClose = true;
	if (m_pbuf_eve)
		bufferevent_free(m_pbuf_eve);
	m_pbuf_eve = nullptr;
}

void ClientSockItem::SetSubChannel(std::string channel)
{
	CCritical lk(m_cs);
	m_strchannel = channel;
	m_set_channel.clear();
	ExtractChannel(channel, m_set_channel);
	DoSub();
}

void ClientSockItem::DoHeartBeat()
{
	CStringA strFomat;
	strFomat.Format("[NetUtil] ClientSockItem[%I64u]::DoHeartBeat\r\n", GetId());
	OutputDebugStringA(strFomat);

	ComHead comHead;
	comHead.bizType = BIZ_HEARTBEAT;
	comHead.iPackLength = sizeof(ComHead);
	SendData(&comHead, comHead.iPackLength, GetId());
}

void ClientSockItem::DoSub()
{
	if (m_set_channel.empty())
		return;

	CStringA strFomat;
	strFomat.Format("[NetUtil] ClientSockItem[%I64u]::DoSub\r\n", GetId());
	OutputDebugStringA(strFomat);

	

	std::string strSendData(sizeof(ComHead) + m_strchannel.size(),0);
	ComHead *pComHead = (ComHead *)strSendData.data();
	pComHead->bizType = BIZ_TYPE_SUB;
	pComHead->Version = NOW_COM_VERSION;
	pComHead->iPackLength = strSendData.size();
	pComHead->nExtraDataLen = m_strchannel.size();
	memcpy(pComHead + 1, m_strchannel.data(), m_strchannel.size());
	SendData(pComHead, pComHead->iPackLength, GetId());
}

void ClientSockItem::OnHeartBeat()
{
	CStringA strFomat;
	strFomat.Format("[NetUtil] ClientSockItem[%I64u]::OnHeartBeat\r\n", GetId());
	OutputDebugStringA(strFomat);
}
CAir2
关注
专栏目录
Android socket实现Tcp长连接，断开自动重连
02-16
手写简化版tcp长链接的socket实现，主要功能有断开重连，以及收发读取解码解析，适用于需要用到长链接的原生开发。
socket心跳检测和重连小demo
u011791526的博客
12-09 1万+
有时候我们的程序要求socket一直保持连接，并且希望在socket断开以后能够重新连接，这个时候就需要用到心跳机制，所谓心跳机制，最简单的做法就是客户端每隔一段时间向服务端发送数据包，为了节约资源我们很多时候发送空数据就好，如果数据不能发送成功说明socket已经断开，这个时候就需要根据具体需求释放资源和重新连接了。         下面给出一个简单的小demo           /*
linux入门到精通-第二十章-bufferevent（开源高性能事件通知库）
Blueeyedboy521的博客
08-06 1004
一般通过libevent进行网络编程，都是将一个socket的fd与一个event进行绑定，并自行维护一个buffer用于存储从socket上接收的数据，同时可能也用于待发送数据的缓存。然后通过可读可写事件从socket上收取数据写入缓存并进行相应处理，或者将缓存中的数据通过socket发送。libevent为这种带缓存的IO模式提供了一种通用的机制，那就是bufferevent。
libevent--bufferevent的使用与实现
zxh2075的专栏
06-04 5887
bufferevent简单介绍一般通过libevent进行网络编程，都是将一个socket的fd与一个event进行绑定，并自行维护一个buffer用于存储从socket上接收的数据，同时可能也用于待发送数据的缓存。然后通过可读可写事件从socket上收取数据写入缓存并进行相应处理，或者将缓存中的数据通过socket发送。libevent为这种带缓存的IO模式提供了一种通用的机制，那就是buf...
重复使用bufferevent的一些体会
weixin_30667649的博客
01-12 107
　　看了一些网上使用bufferevent的例子，一般都是一个连接对应一个bufferevent，连接accept的时候，给bufferevent设置上fd和对应的回调，在连接断开或者发生错误的时候，将bufferevent释放掉。 昨天在使用bufferevent的时候，突发奇想，准备了一个connection对象池，每个connection关联一个bufferevent，然后多线程处理con...
Socket Client 长连接及心跳检测
qq_22074337的博客
04-29 4122
说明: springBoot下socket一对一建立长连接通讯，包括客户端心跳检测、掉线重连、收发信息等
SocketClient1_Socket客户端实现代码_
09-30
同时，为了确保连接的安全性和稳定性，还需要处理异常、心跳机制、重连策略等高级话题。 总之，Socket客户端在C#中的实现涉及了网络编程的基础知识，包括网络协议、地址解析、连接管理以及数据收发。通过理解并实践...
TCP_socket.rar_TCP socket客户端_TCP_Socket_socket_socket 客户端
09-21
TCP通过建立三次握手来确保连接的建立，并且在数据传输过程中通过确认、重传等机制保证数据的完整性。当通信完成后，双方会通过四次挥手断开连接。TCP套接字就是实现TCP协议的接口，允许应用程序进行网络通信。 在...
例10.05 Socket客户端程序.rar_java socket _socket_socket 客户端_socket
09-22
在Java中，`java.net.Socket`类和`java.net.ServerSocket`类是实现客户端和服务器通信的核心。 标题中的"例10.05 Socket客户端程序"很可能是一个示例项目，旨在展示如何创建一个基本的Java Socket客户端。这个...
tcp.zip_socket客户端
09-24
Python的`socket`模块提供了创建和操作网络套接字的功能，使我们能够轻松实现TCP客户端和服务器的编程。 在"tcp.zip_socket客户端"中，两个程序可能分别代表了TCP客户端和服务器端的实现。客户端通常负责发起连接...
C# SOCKET 客户端 主机断开自动重连
01-09
文档内有客户端和服务端socket，实际项目中只用到了客户端，会比较详细，支持断开重连
android 心跳 简书,Android Socket保持心跳长连接，断线重连
weixin_34204530的博客
05-31 2169
昨天三点钟才睡觉的，现在胸口感觉闷闷的，兄弟们，我是不是要GG了？如果我G了，求大佬们给我烧个女朋友，ss.gif1.在使用Socket连接客户端和服务器端的时候，如果服务端断开了连接，我们客户端是收不到任何回调消息的，只是在你发送消息给服务器的时候，会走异常，表示发送失败。2.所以要判断服务器是否在线，就需要客户端不停的发送心跳消息给服务器，服务器收到心跳消息，就立马回复给你消息，这样就 ...
android8锁屏 socket断链,Android Socket保持心跳长连接，断线重连
weixin_32155269的博客
05-28 1263
昨天三点钟才睡觉的，现在胸口感觉闷闷的，兄弟们，我是不是要GG了？如果我G了，求大佬们给我烧个女朋友，ss.gif1.在使用Socket连接客户端和服务器端的时候，如果服务端断开了连接，我们客户端是收不到任何回调消息的，只是在你发送消息给服务器的时候，会走异常，表示发送失败。2.所以要判断服务器是否在线，就需要客户端不停的发送心跳消息给服务器，服务器收到心跳消息，就立马回复给你消息，这样就 ...
socket框架netty-socket android客户端方式，内含心跳重连等
weixin_39165470的博客
06-04 301
原文地址：https://www.jianshu.com/p/7367bd27bb50 阅读测试后，个人认为NettyClient 主要分为几个部分： 1，异步端口连接 Bootstrap 2，NettyClient的解码方式等 pipeline 3，配套的HandlerAdapter ： ChannelInboundHandlerAdapter等。 4，计算断开后重新调用连接。 使用的时候下载个jar包就可以了https://download.csdn.net/download/binbinxiaoz
长连接、心跳和断线重连
天涯遍地是小草的博客
06-22 1万+
一、概述         目前IM软件有一个基本的功能就是长在线，即只要有网络就保持登录，然而，网络状态是无法预测的，所以IM软件经常会有”离线“状态，尤其是手机客户端。长在线这个功能依赖断线重连完成。         通常，网络不稳定是造成不能长时间在线的主要原因，还有比如：服务器强制注销客户端、次客户端被主客户端踢。目前的qq和飞信都有断线重连机制。有时候IM软件自动完成登录，有时
Android Socket连接（模拟心跳包，断线重连，发送数据等）
热门推荐
喻志强的博客
09-26 3万+
android socket连接 socket心跳包，断线重连，发送数据
Android P实现Tcp socket心跳包机制 保证socket断开重连
Sunxiaolin2016的博客
06-28 1537
本文的例子是客户端的例子，只有客户端的代码。 服务器端作为数据接收方，客户端作为数据发送方。 客户端在SocketService中实现。 public class SocketService extends Service { private static final String TAG = "SocketService"; private static Socket mSoc...
BufferEvent
我喜欢雨天的清新的博客
08-13 3103
bufferevent   由于我们在网络通信中有很多输入输出的场景，所以Libevent也提供了相应的bufferevent。这些bufferevent由一个底层的传输对象(socket)，一个ReadBuufer，一个WriteBuffer构成。   与之前普通的event不同的是bufferevent只有当它的传输对象(fd)读取到了足够多的数据后才会调用它的回调函数。   buffe...
C#socket完整的服务端客户端包含心跳机制和客户端断线重连
最新发布
09-15
在C#中，构建一个完整的服务器客户端系统，包括心跳机制和客户端断线重连功能，通常涉及以下几个步骤： **服务端（Server）：** 1. **创建服务器端Socket实例：**首先创建一个TcpListener对象监听特定的IP地址和...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值