自己写一个tcp 通用服务器

我们想写这样一个tcp server，其绑定本地某个端口，用户可以接入实现特定的业务，比如一个傻傻的echo server，一个帮助服务器等等。。毫无疑问这个tcp的框架是相同的，想想我们一直以来怎么写tcp server：
创建socket -> 绑定端口 -> listen监听 -> accept tcp 连接 -> 处理业务 -> 关闭连接。中间可能会有多线程或者线程池等等不同的实现方式。

在erlang的世界，我们还是需要绑定端口，接受连接，处理业务，关闭连接，但是我们没有什么线程，锁的烦恼。我们为每个连接建立一个process，处理业务。因为erlang的process轻量，高效，成千上万。

我们用gen_sever behaviour来实现这个通用的tcp server，gen_server其实内部包含一个大循环，如果我们的tcp server再gen_server的循环中调用gen_tcp:accept/1，那么我们会阻塞gen_server,这肯定行不通。那么只有将 gen_tcp:accept放到一个独立的process中了。

我们的generic_server中定义了一个record：

-record(server_state, {
			port,			% 监听的端口
			loop,			% 具体的逻辑处理循环
			ip=any,			% 绑定的ip
			lsocket=null,	       % 监听socket
			conn=0,			% 当前的连接数
			maxconn			% 最大的连接数
			}).

这个record用来记录服务器的相关信息，注释已经相当清楚。
接下来让我们实现gen_server的init/1函数（如果对gen_server不熟悉，请参看以前文章，或者erlang官方文档)，这个部分非常关键：

%% gen_server初始化，创建监听socket
init(State = #server_state{port=Port}) ->
    case gen_tcp:listen(Port, ?TCP_OPTIONS) of
	{ok, LSocket} ->
	    {ok, accept(State#server_state{lsocket=LSocket})};
	{error, Reason} ->
	    {stop, {create_listen_socket, Reason}}
   end.

创建listen 端口成功时，我们调用accept/1函数：

%% 生成一个新的process，用来accept tcp接入，同时返回初始化State
accept(State =#server_state{lsocket=LSocket, loop=Loop, conn=Conn, maxconn=Max}) ->
    proc_lib:spawn(generic_server, accept_loop, [self(), LSocket, Loop, Conn, Max]),
    State.

accept_loop照此实现：

%% 接收新的tcp连接
accept_loop(Server, LSocket, {M, F}, Conn, Max) ->
    {ok, Sock} = gen_tcp:accept(LSocket),
    if
	Conn + 1 > Max ->
	    io:format("reach the max connection~n"),
		gen_tcp:close(Sock);
	    true ->
		gen_server:cast(Server, {accept_new, self()}),
		M:F(Sock)
    end.

看明白了么？
我们就是在accept里生成一个新的process，其执行accept_loop函数，在accept_loop中调用 gen_tcp:accpet/1接收新的tcp连接，从而达到不阻塞gen_server主循环的目的！看看accept_loop，我们收到一个连接时，判断是否达到最大连接数，如果达到我们则发送给client一个消息，随后关闭这个sock；正常情况下，我们首先同志gen_server一个新的连接加入，这样gen_server就通过accept创建一个新的process，来处理gen_tcp:accept/1函数，接收用户请求。而当前的process来处理具体的业务逻辑，比如一个echo server。
为什么这么做呢？因为通过调用gen_tcp:accept/1创建的Socket所在的process成为此Socket的controlling process，如果其关闭我们的socket也会关闭！所以我们便把这个process留给这个连接，让他处理具体的逻辑：M:F(Sock)，注意这里相当于一个会调的函数，具体的我们要实现什么server，就需要实现什么逻辑。

还有一个情况，我们要限定并发总数，因此在gen_tcp:accept/1中，我们通过判断是否达到最大连接数而决定是否关闭这个新接入的socket，这样就可以限定连接总数。

好的，让我们看看，我实现的一个echo_server:

-module(echo_server).
-export([start/2, loop/1]).

%% @spec start(Port::integer(), Max::integer()) -> ServerRet
%% @doc 启动echo server
start(Port, Max) ->
    generic_server:start(echo_server, Port, Max, {?MODULE, loop}).

%% @spec loop(Sock::port())
%% @doc 处理echo_server中用户的请求
loop(Sock) ->
    case gen_tcp:recv(Sock, 0) of
	{ok, Data} ->
	    gen_tcp:send(Sock, Data),
	    loop(Sock);
	{error, closed} ->
    	    io:format("client sock close~n"),
	    gen_server:cast(echo_server, {connect_close, self()})
    end.

十几行代码就解决了问题！首先调用generic_server:start启动我们的tcp server，我们将其命名为echo_server，我们还指定了绑定端口，最大连接数，逻辑处理回调函数。

以后只要有用户连接成功server，就会进入我们的loop循环，我们在这里可以做的逻辑，我们这里只是接收用户的数据，然后将数据原封不动的返回给client，这就实现了一个echo server。需要说明的是，我们的tcp server在创建的时候指定了{active, false}选项，需要手动调用gen_tcp:recv/2接收数据，如果收到{error, closed}，表明socket已经被client关闭，我们调用gen_server:cast通知并发数减一。

最后写一个测试的tcp client，其连接我们的echo server，发送数据。

-module(tcp_client).
-export([start/1, send_data/2, close/1]).

start(Port) ->
    {ok, Socket} = gen_tcp:connect("127.0.0.1", Port, [binary, {packet, raw}, {active, true}, {reuseaddr, true}]),
    Socket.

send_data(Socket, Data) when is_list(Data) orelse is_binary(Data) ->
    gen_tcp:send(Socket, Data),
    receive
	{tcp, Socket, Bin} ->
	    io:format("recv ~p~n", [Bin]);
	    {tcp_closed, Socket} ->
	    io:format("remote server closed!~n")
    end.

close(Socket) when is_port(Socket) ->
    gen_tcp:close(Socket).

下面编译所有的模块，实验一下吧：

> c(generic_server).
{ok, generic_server}
> c(echo_server).
{ok, echo_server}
> c(tcp_client).
{ok, tcp_client}

启动两个erl控制台：A server；B client
在A erl控制台启动server：

1> echo_server:start(1234, 4).
max connection is 4
{ok,<0.31.0>}

B erl控制台运行：

1>Sock = tcp_client:start(1234).
#Port<0.140>

A 控制台显示：

current connect:1

继续...
B:

2>Sock2 = tcp_client:start(1234).
#Port<0.141>
3> Sock3 = tcp_client:start(1234).
#Port<0.142>
4> Sock4 = tcp_client:start(1234).
#Port<0.143>
4> Sock5 = tcp_client:start(1234).
#Port<0.144>

A：

current connect:2
current connect:3
current connect:4
reach the max connection

关闭某个socket:
B:

> tcp_client:close(Sock4).
ok

A:

> client sock close
current connect:3