使用libuv搭建tcp服务器与客户端通信

参考资料

http://luohaha.github.io/Chinese-uvbook/index.htmlhttps://www.cnblogs.com/sherlock-lin/p/14337912.html

基础知识

异步

什么是“异步”？

编程或者架构模型有4种:

阻塞

A调用B后，一直等着B返回结果。
这是最广泛使用，也是最简单的一种模型。普通的函数调用、传统的阻塞IO都是如此。

轮询

A调用B后，A不断去B那里查询返回结果。

这在耗时任务中经常出现。比如一种资源的创建非常耗时，服务A通知服务B创建，B返回给A一个任务id或者资源id，A不断轮询B检查任务是否完成以及完成结果。

这种也非常常见。在架构设计中，为了减少服务之间的循环依赖，常常不会让B再回去调用A。这样一来，在一个基于http的体系中，轮询是唯一解法。

阻塞回调

A调用B后，A什么都不做，直到B通知A已完成

这种模式并不是经常出现，而且它实际上是异步回调的一个子集。在(资源非常少，无法承接多个任务，或者A通知B进行的是其他任务的前提)时，可能会选择这种模型。

异步回调

A调用B后，该干啥干啥，B通知A已完成后，再继续处理该任务的后续任务。

libuv基础

libuv强制使用异步的，事件驱动的编程风格。

它的核心工作是提供一个event-loop，还有基于I/O和其它事件通知的回调函数。

libuv还提供了一些核心工具，例如定时器，非阻塞的网络支持，异步文件系统访问，子进程等。

事件驱动编程中，程序会关注每一个事件，并且对每一个事件的发生做出反应。

libuv会负责将来自操作系统的事件收集起来，或者监视其他来源的事件。

这样，用户就可以注册回调函数，回调函数会在事件发生的时候被调用。

系统编程中最经常处理的一般是输入和输出，而不是一大堆的数据处理。
问题在于传统的输入／输出函数(例如read，fprintf)都是阻塞式的。
实际上，向文件写入数据，从网络读取数据所花的时间，对比cpu的处理速度差得太多。
任务没有完成，函数是不会返回的，所以你的程序在这段时间内什么也做不了。
对于需要高性能的的程序来说，这是一个主要的障碍。

新建项目

这里我用的是vs2015，需要设置相应的路径，

如包含目录下设置头文件路径、库目录下设置lib文件路径。

重要！将lib库目录下的dll文件放到项目运行生成的Debug目录下，以防编译器执行时找不到dll文件。

#include <stdio.h>
#include <stdlib.h>
#include <uv.h>

#pragma comment(lib,"uv.lib")

int main() {

	//初始化
	uv_loop_t *loop = (uv_loop_t *)malloc(sizeof(uv_loop_t));
	uv_loop_init(loop);

	printf("Now quitting.\n");
	//执行
	uv_run(loop, UV_RUN_DEFAULT);

	//关闭，释放空间。
	uv_loop_close(loop);
	free(loop);

	getchar();
	return 0;
}

这个程序会很快就退出了，因为没有可以很处理的事件。
我们可以使用各种API函数来告诉event-loop我们要监视的事件。

网络IO

在libuv中使用网络编程接口不会像在BSD上使用socket接口那么的麻烦，因为libuv上所有的都是非阻塞的，但是原理都是一样的。
可以这么说，libuv提供了覆盖了恼人的，啰嗦的和底层的任务的抽象函数，比如使用BSD的socket结构的来设置socket，还有DNS查找，libuv还调整了一些socket的参数。

在网络I/O中会使用到uv_tcp_t和uv_udp_t。

TCP

TCP是面向连接的，字节流协议，因此基于libuv的stream实现。

server

libuv 对于 tcp 消息的处理，同样是基于 stream 的，步骤如下：

1. uv_tcp_init() 建立 tcp 句柄；
2. uv_tcp_bind() 方法绑定ip；
3. uv_listen() 方法监听，有新连接时，调用回调函数；
4. uv_accept() 方法获取客户端套接字；
5. uv_read_start() 方法读取客户端数据；
6. uv_write() 方法向客户端发送数据；
7. uv_close() 关闭套接字；

client

1. uv_tcp_init() 建立 tcp 句柄；
2. uv_tcp_bind() 方法绑定ip；
3. uv_write() 方法向服务器发送数据；
4. uv_close() 关闭套接字；

API简介

1.uv_tcp_init

初始化 tcp 对象

uv_tcp_t server;
uv_tcp_init(loop, &server);//初始化tcp server对象

2.uv_ip4_addr

struct sockaddr_in addr;
uv_ip4_addr("0.0.0.0", DEFAULT_PORT, &addr);

将给定的ip地址和端口转换成sockaddr_in结构体，原生编程的时候，设置ip和端口需要至少五行，用这个方法可以简化操作

3.uv_tcp_bind

等同于原生API的 bind() 方法

uv_tcp_bind(&server, (const struct sockaddr *) &addr, 0);
uv_tcp_bind() 的第三个参数 flag 一般是0，如果想使用IP6，可以使用 UV_TCP_IPV6ONLY

enum uv_tcp_flags {
  /* Used with uv_tcp_bind, when an IPv6 address is used. */
  UV_TCP_IPV6ONLY = 1
};

4.uv_listen

uv_listen((uv_stream_t *) &server, 128, on_new_connection);

类似 listen() ，开始监听

第二个参数表明内核的排队数，最后指定有新连接时的回调函数

当有新的连接进来时，就会触发 on_new_connection 回调

5.uv_connection_cb

uv_connection_cb 是 uv_listen 的回调函数，其声明如下：

typedef void (*uv_connection_cb)(uv_stream_t* server, int status);

server 参数为服务器句柄

status 表示状态，小于0表示新连接有误

6.uv_accept

新连接触发回调函数之后，按照一般流程，需要使用 accept() 方法获取客户端句柄，libuv 中使用 uv_accept()，其声明如下：

int uv_accept(uv_stream_t* server, uv_stream_t* client)

在调用之前，client 参数必须被初始化

返回值 <0 表示有误

示例：

uv_tcp_t *client = (uv_tcp_t *) malloc(sizeof(uv_tcp_t));//为tcp client申请资源
uv_tcp_init(loop, client);//初始化tcp client句柄
if (uv_accept(server, (uv_stream_t *) client) == 0) {
	do_some_thind();
}

7.uv_read_start

libuv 中使用 uv_read_start() 方法从传入的 stream 中读取数据，声明如下：

int uv_read_start(uv_stream_t* stream, uv_alloc_cb alloc_cb, uv_read_cb read_cb)

read_cb 会被多次调用，直到数据读完，或者主动调用 uv_read_stop() 方法停止

该函数有两个回调函数，alloc_cb 用于为新来的数据申请空间，申请的资源需要在 read_cb 中释放

这两个回调的声明如下：

typedef void (*uv_alloc_cb)(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf);
typedef void (*uv_read_cb)(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);

示例代码：

//负责为新来的消息申请空间
void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
  buf->len = suggested_size;
  buf->base = static_cast<char *>(malloc(suggested_size));
}
/**
 * @brief: 负责处理新来的消息
 * @param: client
 * @param: nread>0表示有数据就绪，nread<0表示异常，nread是有可能为0的，但是这并不是异常或者结束
 */
void read_cb(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
	do_somt_thing();
    //释放之前申请的资源
  if (buf->base != NULL) {
    free(buf->base);
  }
}

uv_read_start((uv_stream_t *) client, alloc_buffer, read_cb);

8.uv_buf_t 和 uv_buf_init

uv_buf_t 是libuv 中的一种特殊的数据类型，和 Redis 的 SDS 有一点相似度，声明如下：

typedef struct uv_buf_t {
  char* base;
  size_t len;
} uv_buf_t;

uv_buf_t 可以使用 uv_buf_init 初始化

示例：

uv_buf_t uvBuf = uv_buf_init(buf->base, nread);//初始化write的uv_buf_t

9.uv_close

libuv 中使用 uv_close() 方法关闭句柄，声明如下：

void uv_close(uv_handle_t* handle, uv_close_cb close_cb)

close_cb 为关闭之后的回调，声明如下：

typedef void (*uv_close_cb)(uv_handle_t* handle);

代码示例：

void on_close(uv_handle_t *handle) {
  if (handle != NULL)
    free(handle);
}
uv_close((uv_handle_t *) client, on_close);

10.uv_write

libuv 中使用 uv_write() 方法发送数据，声明如下：

int uv_write(uv_write_t* req, uv_stream_t* handle, const uv_buf_t bufs[],
                       unsigned int nbufs, uv_write_cb cb);

req 是需要传递给回调函数的数据，发送需要申请资源，并在回调函数中释放

handle 是接受的客户端

bufs[] 是一个 uv_buf_t 数组，可以一次添加多组数据，最终按照顺序发送

nbufs 表示需要发送的数组元素个数，一般小于等于 bufs 的大小

11.uv_strerror

有些函数会有错误码，使用uv_strerror()方法获取错误码对应的描述

服务器和客户端的交互

服务器

服务器初始化

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <uv.h>

#pragma comment(lib,"uv.lib")

#define DEFAULT_PORT 7000
#define DEFAULT_BACKLOG -1

uv_loop_t *loop;
struct sockaddr_in addr;

void free_write_req(uv_write_t *req) {
	free(req);
}

void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
	buf->base = (char*)malloc(suggested_size);
	buf->len = suggested_size;
}

void write_client_cb(uv_write_t* req, int status) {
	if (status) {
		fprintf(stderr, "Write error %s\n", uv_strerror(status));
	}
	free_write_req(req);
}

void read_client_cb(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
	if (nread > 0) {
		printf("get message from client: %.*s\n", nread, buf->base);
		char* str = "hello client, this is server!";
		printf("write message to client: %.*s\n", nread, str);

		uv_write_t* uvreq = (uv_write_t*)malloc(sizeof(uv_write_t));

		uv_buf_t uvBuf = uv_buf_init(str, strlen(str));
		uv_write(uvreq, client, &uvBuf, 1, write_client_cb);

		return;
	}
	if (nread < 0) {
		if (nread != UV_EOF)
			fprintf(stderr, "Read error %s\n", uv_err_name(nread));
		uv_close((uv_handle_t*)client, NULL);
	}

	free(buf->base);
}

void on_new_connection(uv_stream_t *server, int status) {
	if (status < 0) {
		fprintf(stderr, "New connection error %s\n", uv_strerror(status));
		return;
	}

	uv_tcp_t *client = (uv_tcp_t*)malloc(sizeof(uv_tcp_t));
	uv_tcp_init(loop, client);

	//4.uv_accept接收链接。
	//5.使用stream处理来和客户端通信。
	if (uv_accept(server, (uv_stream_t*)client) == 0) {
		uv_read_start((uv_stream_t*)client, alloc_buffer, read_client_cb);
	}
	else {
		uv_close((uv_handle_t*)client, NULL);
	}
}

int main() {
	//1.uv_tcp_init建立tcp句柄
	loop = uv_default_loop();
	uv_tcp_t server;
	uv_tcp_init(loop, &server);

	//2.uv_tcp_bind绑定。
	uv_ip4_addr("127.0.0.1", DEFAULT_PORT, &addr);
	uv_tcp_bind(&server, (const struct sockaddr*)&addr, 0);

	//3.uv_listen建立监听，当有新的连接到来时，激活调用回调函数。
	int r = uv_listen((uv_stream_t*)&server, DEFAULT_BACKLOG, on_new_connection);
	if (r) {
		fprintf(stderr, "Listen error %s\n", uv_strerror(r));
		return 1;
	}
	uv_run(loop, UV_RUN_DEFAULT);
	return 0;
}

这部分内容相当于模板一样，基本上搭建服务器都可以使用这一套。

当uv建立监听后，每当客户端向服务器发送一条数据，都会执行一次回调函数on_new_connection，所以我们在on_new_connection这个函数中制定相应的操作。

void on_new_connection(uv_stream_t *server, int status) {
	if (status < 0) {
		fprintf(stderr, "New connection error %s\n", uv_strerror(status));
		return;
	}

	uv_tcp_t *client = (uv_tcp_t*)malloc(sizeof(uv_tcp_t));
	uv_tcp_init(loop, client);

	//4.uv_accept接收链接。
	//5.使用stream处理来和客户端通信。
	if (uv_accept(server, (uv_stream_t*)client) == 0) {
		uv_read_start((uv_stream_t*)client, alloc_buffer, read_client_cb);
	}
	else {
		uv_close((uv_handle_t*)client, NULL);
	}
}

这部分也可以称之为一个模板，每当有一个客户端与服务器建立连接，就开始读取数据流，并执行回调函数，alloc_buffer用于开辟缓存空间，read_client_cb用于执行读取操作的回调函数。

void read_client_cb(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
	if (nread > 0) {
		printf("get message from client: %.*s\n", nread, buf->base);
		char* str = "hello client, this is server!";
		printf("write message to client: %.*s\n", nread, str);

		uv_write_t* uvreq = (uv_write_t*)malloc(sizeof(uv_write_t));

		uv_buf_t uvBuf = uv_buf_init(str, strlen(str));
		uv_write(uvreq, client, &uvBuf, 1, write_client_cb);

		return;
	}
	if (nread < 0) {
		if (nread != UV_EOF)
			fprintf(stderr, "Read error %s\n", uv_err_name(nread));
		uv_close((uv_handle_t*)client, NULL);
	}

	free(buf->base);
}

这个回调函数我制定的是先打印接受到的数据，再给客户端发一条数据。

客户端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <uv.h>

#pragma comment(lib,"uv.lib")

#define DEFAULT_PORT 7000
#define DEFAULT_BACKLOG -1

uv_loop_t *loop;
struct sockaddr_in addr;
uv_tcp_t client;

typedef struct {
	uv_write_t req;
	uv_buf_t buf;
} write_req_t;

void free_write_req(uv_write_t *req) {
	write_req_t *wr = (write_req_t*)req;
	free(wr);
}

void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
	buf->base = (char*)malloc(suggested_size);
	buf->len = suggested_size;
}

void echo_write(uv_write_t* req, int status) {
	if (status) {
		fprintf(stderr, "Write error %s\n", uv_strerror(status));
	}
	free_write_req(req);
}

void read_client_cb(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
	if (nread > 0) {
		printf("get message from server: %.*s\n", nread, buf->base);
		return;
	}
	if (nread < 0) {
		if (nread != UV_EOF)
			fprintf(stderr, "Read error %s\n", uv_err_name(nread));
		uv_close((uv_handle_t*)client, NULL);
	}

	free(buf->base);
}


void on_connect(uv_connect_t* req, int status)
{

	if (status < 0)
	{
		fprintf(stderr, "Connection error %s\n", uv_strerror(status));
		return;
	}

	uv_read_start((uv_stream_t*)req->handle, alloc_buffer, read_client_cb);

	uv_write_t* uvreq = (uv_write_t*)malloc(sizeof(uv_write_t));

	char* str = "hello server, this is client!";

	uv_buf_t uvBuf = uv_buf_init(str, strlen(str));

	uv_write(uvreq, req->handle, &uvBuf, 1, echo_write);

	uv_tcp_t *client = (uv_tcp_t*)malloc(sizeof(uv_tcp_t));
	uv_tcp_init(loop, client);

	fprintf(stdout, "Connect ok\n");

}

int main() {

	loop = uv_default_loop();

	uv_tcp_init(loop, &client);

	uv_connect_t* connect = (uv_connect_t*)malloc(sizeof(uv_connect_t));

	uv_ip4_addr("127.0.0.1", DEFAULT_PORT, &addr);

	int r = uv_tcp_connect(connect, &client, (const struct sockaddr*)&addr, on_connect);

	if (r)
	{
		fprintf(stderr, "connect error %s\n", uv_strerror(r));
		return 1;
	}

	uv_run(loop, UV_RUN_DEFAULT);

	return 0;
}

效果图