libevent C++封装

最近在学习libevent的过程中，碰到许多问题，如接收数据不完整，如何接收并回复来自client的数据等一些问题，还有就是关于read_cb该如何写的问题，最后总结了一下，封装成一个类，下面说一下怎样使用。

源文件:libSocket.h libSocket.cpp MyEvent.h MyEvent.cpp 这4个文件是自己写的，封装的目的是为了让整个过程更清晰易懂。

以下是libSocket类，该类只有两个函数，GetFileDescriptionByListen是监听，s_ip是允许访问的IP，可以是"127.0.0.1"或"0.0.0.0", queue是listen的队列大小。函数最终返回一个正在监听的文件描述符。 GetFileDescriptionByConnect 是连接函数，s_host是要连接的服务端IP，最终也是返回一个已连接的文件描述符。

#ifndef LIBSOCKET_H_
#define LIBSOCKET_H_
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>


using namespace std;

class libSocket {
public:
	libSocket();
	virtual ~libSocket();
	/*侦听端口*/
	int GetFileDescriptionByListen(const char* s_ip, int16_t port, int queue);
	int GetFileDescriptionByConnect(const char* s_host, int16_t port);
};

#endif /* LIBSOCKET_H_ */

以下是libSocket.cpp

#include "libSocket.h"

libSocket::libSocket() {
	// TODO Auto-generated constructor stub

}

libSocket::~libSocket() {
	// TODO Auto-generated destructor stub
}

int libSocket::GetFileDescriptionByListen(const char* s_ip,int16_t port,int queue){

	int fd = 0;					/*服务端文件描述符*/
	sockaddr_in server_addr;

	bzero(&server_addr,sizeof(server_addr));			/*将结构实例清零*/
	server_addr.sin_family = AF_INET;					/*使用AF_INET网络协议族*/
	server_addr.sin_addr.s_addr = inet_addr(s_ip);	/*网络地址 ,使用的in_addr结构体，INADDR_ANY表示监听任意来源IP*/
	server_addr.sin_port = htons(port);					/*端口号，必须采用网络数据格式，网络数据格式用htons()函数转换*/

	/*生成描述符*/
	if ( !(fd = socket(AF_INET,SOCK_STREAM,0)) ){
		cerr << strerror(errno) << endl;
		return -1;
	}

	/*绑定本地服务端地址和端口*/
	if ( bind(fd,(sockaddr *)(&server_addr),sizeof(server_addr)) != 0 ){
		cerr << strerror(errno) << endl;
		return -2;
	}

	/*在本地端口上开始监听*/
	if ( listen(fd,queue) != 0 ){
		cerr << strerror(errno) << endl;
		return -3;
	}

	return fd;
}

int libSocket::GetFileDescriptionByConnect(const char *host,int16_t port){
	int fd = 0;
	/*定义了一个存储服务端信息的结构实例*/
	struct sockaddr_in server_addr;
	/*用于接收gethostbyname返回的指针*/
	hostent* p_host;

	//域名解析
	if( (p_host = gethostbyname(host)) == NULL ){
		cerr << strerror(errno) << endl;
		return -1;
	}

	//向系统申请socket
	if( ( fd = socket(AF_INET,SOCK_STREAM,0) ) < 1 ){
		cerr << strerror(errno) << endl;
		return -2;
	}

	/*设置目标服务端*/
	bzero(&server_addr,sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(port);
	server_addr.sin_addr = *((struct in_addr *)p_host->h_addr);

	/*建立TCP连接*/
	if( connect(fd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr)) != 0 ){
		cerr << strerror(errno) << endl;
		return -3;
	}
	return fd;
}

下面的才是要说的主要MyEvent.

MyEvent.h

这也是很简单的几个成员函数

先使用BindEventBase，使用前先创建好event_base.
使用CreateEventForListen创建一个网络事件，需要告诉该事件要在本地监听的IP，和端口，在这个方法的实现中，使用到了上面的libSocket.
该类是用作于父类的，使用时，应在子类中重写父类的三个方法。即CallBackOfRead,CallBackOfWrite,CallBackOfError.

#ifndef MYEVENT_H_
#define MYEVENT_H_

#include <event.h>
#include "libSocket.h"


class MyEvent {
public:
	void CreateEventForListen(const char* SrcIPAddress,int16_t ListenPort);
	void BindEventBase(event_base* base){ this->base = base; } //绑定事件堆
	event_base* GetEventBase(void);

	/*以下三个函数在子类继承后重写父类的虚函数*/
	virtual void CallBackOfRead(bufferevent* bev,void* arg)=0;  //读取时触发事件
	virtual void CallBackOfWrite(bufferevent* bev,void* arg)=0;	//写入事件完成后触发事件
	virtual void CallBackOfError(bufferevent* bev,short event, void* arg)=0; //出现错误或对方关闭事件时触发事件

private:
	event_base* base;
};





#endif /* MYEVENT_H_ */

MyEvent.cpp

#include "MyEvent.h"

void onRead(bufferevent* bev,void* arg){	
	MyEvent* myevent = (MyEvent*)arg;
	myevent->CallBackOfRead(bev,arg);
}

void onWrite(bufferevent* bev,void* arg){	
	MyEvent* myevent = (MyEvent*)arg;
	myevent->CallBackOfWrite(bev,arg);
}

void onError(bufferevent* bev, short event, void* arg){  
	MyEvent* myevent = (MyEvent*)arg;
	myevent->CallBackOfError(bev,event,arg);
}

void onAccept( int fd ,short event, void* arg ){	
	MyEvent* myevent = (MyEvent*)arg;
	int client_fd;
	sockaddr_in client_in;
	socklen_t client_len = sizeof(client_in);
	client_fd = accept(fd,(struct sockaddr*)&client_in,&client_len);   //接受连接请求
	bufferevent* buffer_ev = bufferevent_socket_new(myevent->GetEventBase(),client_fd,BEV_OPT_CLOSE_ON_FREE);                     //创建数据I/O事件
	bufferevent_setcb(buffer_ev,onRead,onWrite,onError,arg);  //数据I/O事件的回调函数
	bufferevent_enable(buffer_ev,EV_READ | EV_PERSIST);	//启用数据IO
}


event_base* MyEvent::GetEventBase(void){
	return this->base;
}

void MyEvent::CreateEventForListen(const char* SrcIPAddress,int16_t ListenPort){ 
	libSocket* socket = new libSocket();
	int fd = socket->GetFileDescriptionByListen(SrcIPAddress,ListenPort,1024);
	if ( !this->base ){
		cout << "event_base_error" << endl;
		return ;
	}
	event* ev = event_new( this->base , fd , EV_READ | EV_PERSIST, onAccept , this );
	event_add(ev,NULL);
}

下面我们写一个子类来继承MyEvent

这里要特别注意的是：CallBackOfWrite()的重写，当有大量的数据传入缓冲区时，该函数会被多次触发，一次是接收不完那么多数据的，比如传入1000000个字节，每次触发该函数时，可能只能接收到4000个字节左右，所以不要在这里处理你所需要的最终数据，在这里你应该把所有的数据压入一个容器堆中，或者写入本地，如果写入本地，也不要在这个函数中打开文件描述符，因为是多次触发，最终得到的结果会是一小块，更不能在此关闭文件描述符，除非能够判断文件已经传输完毕。

#ifndef TEST_H_
#define TEST_H_
#include "MyEvent.h"

class test : public MyEvent {
public:
	void CallBackOfRead(bufferevent* bev,void* arg){
		evbuffer* input = bufferevent_get_input(bev);
		char buffer[1024];
		memset(buffer,'\0',sizeof(buffer));
		int r_len = 0;
		while ( ( r_len = evbuffer_remove( input, buffer, 1024  ) ) > 0 ){
			cout << buffer;
			memset(buffer,'\0',sizeof(buffer));
			
	}

	void CallBackOfWrite(bufferevent* bev,void* arg){
		cout << "write" << endl;
	}

	void CallBackOfError(bufferevent* bev,short event,void* arg){
		cout << "error" << endl;
	}
};

#endif /* TEST_H_ */

以下是主函数部分main.cpp

#include <event.h>
#include <iostream>
#include "libSocket.h"
#include "test.h"


int main(void){
	event_base* base = event_base_new();
	test* MyTest = new test();
	MyTest->BindEventBase(base);
	MyTest->CreateEventForListen("0.0.0.0",2111);
	event_base_dispatch(base);
	return 0;

}

猜你喜欢