使用 acl 服务器框架编写监听多个地址的服务器程序

在编写服务器应用程序时，有时会有这样一种应用场景：后端的业务数据及业务逻辑相同，但希望给前端应用提供的功能范围及协议方式有些差别。如：

场景一：希望来自于外网的客户端以只读权限访问后端数据，同时希望来自于内网的客户端可以以读/写方式访问后端数据；

场景二：希望某个网段的客户端以 HTTP 协议访问后端业务，同时希望某个网段的客户端以私有协议方式访问后端业务。

为了处理上面的应用场景，当然可以写多个服务器程序，每个服务器程序处理不同的协议格式和权限范围，但这势必会造成很多冗余代码，增加额外的工作量及出错可能性。acl 的服务器框架模型允许一个服务器进程同时监听多个地址，利用这一点便可以轻松解决上面的应用场景问题，同时大大减少了程序工作量及维护成本。

下面以一个简单的例子，说明如何使用这一特性来处理不同的协议过程。

为了简单起见，本例子使用了使用 acl 生成向导快速创建服务器程序文章中介绍的服务器生成向导过程来生成一个简单的 DEMO（假设让该服务器程序监听：127.0.0.1:8088 和 192.168.166.162:8080 两个地址)。假设由服务器生成向导程序生成了服务器模板类型为 master_threads （线程池模型）的程序 echo_server。然后在 echo_server 程序目录下打开 master_service.cpp 源程序，修改函数 master_service::thread_on_accept ，master_service::thread_on_close 及 master_service::thread_on_read，内容如下：

// 当客户端连接流有数据可读/出现异常时的回调函数
bool master_service::thread_on_read(acl::socket_stream* conn)
{
	// 获得客户端连接本地的哪个监听服务地址，其中 get_local 的参数为 true 表示要求获得
	// ip:port 格式的全地址
	const char* local_addr = conn->get_local(true);
	const char* str = (const char*) conn->get_ctx();
	logger("connection from local %s on read fd %d, info: %s",
		local_addr, conn->sock_handle(), str);

	acl::string buf;
	// 从客户端读取一行数据
	if (conn->gets(buf, false) == false)
	{
		logger("get error from client %s, local addr: %s",
				conn->get_peer(true), local_addr);
		return false;  // 返回 false 通知服务器框架将连接关闭
	}

	// 回写数据
	if (conn->write(buf) == -1)
	{
		logger("write to client %s error, local addr: %s",
				conn->get_peer(true), local_addr);
		return false;
	}

	// 返回 true 通知服务器框架继续监控该客户端连接流
	return true;
}

// 当接收到一个客户端连接时的回调函数
bool master_service::thread_on_accept(acl::socket_stream* conn)
{
	// 获得客户端连接本地的哪个监听服务地址，其中 get_local 的参数为 true 表示要求获得
	// ip:port 格式的全地址
	const char* local_addr = conn->get_local(true);
	logger("connect from local addr: %s", local_addr);

	// 在此处可以根据 local_addr 的不同来区分不同的连接请求：
	if (strcmp(local_addr, "127.0.0.1:8088") == 0)
	{
		const char* str = strdup("from 127.0.0.1:8088");
		conn->set_ctx(str);
	}
	else if (strcmp(local_addr, "192.168.166.162:8080" == 0)
	{
		const char* str = strdup("from 192.168.166.162:8080");
		conn->set_ctx(str);
	}
	else
	{
		const char* str = strdup("other addr");
		conn->set_ctx(str);
	}

	// 设置客户端连接流的读写超时时间(秒)
	conn->set_rw_timeout(10);
	return true;
}

// 当客户端连接关闭前调用的回调函数
void master_service::thread_on_close(acl::socket_stream* conn)
{
	// 释放由 master_service::thread_on_accept 中分配的内存对象
	char* str = (char*) conn->get_ctx();
	if (str)
		free(str);
}

上面代码逻辑很简单地演示了 acl 服务器框架支持监听多个地址的用处。为了支持不同的业务功能分流，应用可以在 thread_on_accept 阶段通过 socket_stream::set_ctx(void*) 设置不同的功能对象，在 thread_on_read 阶段通过 socket_stream::get_ctx() 取出设置的对象，通过对对象的功能判断进行业务功能分流。

当然，还有一点不要忘记，还得需要修改该服务器的配置文件，将 master_service 的监听地址改成多个地址，如：127.0.0.1:8088, 192.168.166.162:8080 即：master_service = 127.0.0.1:8088, 192.168.166.162:8080，同时需要将 master_type 值改为 sock，即：master_type = sock。

此外，为了在独立方式下测试服务器程序，可以打开 main.cpp 文件，将其中的 addr 的值设为 "127.0.0.1:8088, 192.168.166.162:8080" 即可。

扫描二维码关注公众号，回复： 698692 查看本文章

下面写一个更加实用一点的例子，可以先设计一个虚类，里面定义一个虚方法，在接收到客户端连接 (thread_on_accept) 时，根据连接地址不同来创建该虚类的子类实例（这些子类只需实现基类中的虚方法即可），在 thread_on_read 时，通过调用子类实例的虚方法来达到协议分流的目的。如下面的例子：

class base
{
public:
	base() {}
	virtual ~base() {}
	// 纯虚方法，需要子类实现
	virtual bool run(acl::socket_stream* conn) = 0;
};

class child1 : public base
{
public:
	child1() {}
	~child1() {}

protected:
	bool run(acl::socket_stream* conn)  // 基类虚方法实现
	{
		acl::string buf;

		// 读一行数据，但第二个参数为 true 表示希望将 \r\n 自动去掉
		if (conn->gets(buf, true) == false)
			return false;
		if (conn.format("child1: %s\r\n", buf.c_str()) == -1)
			return false;
		return true;
	}	
};

class child2 : public base
{
public:
	child2() {}
	~child2() {}

protected:
	bool run(acl::socket_stream* conn)  // 基类虚方法实现
	{
		acl::string buf;

		// 读一行数据，但第二个参数为 true 表示希望将 \r\n 自动去掉
		if (conn->gets(buf, true) == false)
			return false;
		if (conn.format("child2: %s\r\n", buf.c_str()) == -1)
			return false;
		return true;
	}	
};

/////////////////////////////////////////////////////////////////////////////////

bool master_service::thread_on_read(acl::socket_stream* conn)
{
	// 将流中参数硬转化为 base 类对象
	base* obj = (base*) conn->get_ctx();

	// 调用基类中的纯虚方法，而实际上是调用了子类的方法
	// 从而实现了协议分流
	return obj->run(conn);
}

bool master_service::thread_on_accept(acl::socket_stream* conn)
{
	const char* local_addr = conn->get_local(true);
	if (strcmp(local_addr, "127.0.0.1:8088") = 0)
	{
		base* obj = new child1();
		conn->set_ctx(obj);
		return true;
	}
	else if (strcmp(local_addr, "127.0.0.1:8080") == 0)
	{
		base* obj = new child2();
		conn->set_ctx(obj);
		return true;
	}
	else
		return false;
}

void master_service::thread_on_close(acl::socket_stream* conn)
{
	base* obj = (base*) conn->get_ctx();
	if (obj)
		delete obj;
}

参考：

acl 库下载：https://sourceforge.net/projects/acl/

svn: svn://svn.code.sf.net/p/acl/code/

github 地址：https://github.com/acl-dev/acl

QQ 群：242722074

使用 acl 生成向导快速创建服务器程序

使用 acl::master_threads 类编写多进程多线程服务器程序

acl 服务器模块的部署

使用 acl 服务器框架编写监听多个地址的服务器程序

猜你喜欢