不解释，直接贴代码。
1) socket_options.hrl
-record(socket_options,
{port=8024,
loop,
name,
ip=any,
nodelay=false,
backlog=128,
listen=null,
active_sockets=0}
).
2) test_server.erl
-module(test_server).
-export([start/0, stop/0, looper/1]).
-include("socket_options.hrl").
%开启服务
start()->
test_socket_server:start(#socket_options{loop = {?MODULE, looper}}).
%关闭服务
stop()->
test_socket_server:stop().
looper(Socket) ->
inet:setopts(Socket, [{active, once}]),
receive
{tcp, Socket, Data} ->
io:format("Got packet: ~p~n", [Data]),
gen_tcp:send(Socket, Data),
looper(Socket);
{tcp_closed, Socket}->
io:format("Socket ~p closed~n", [Socket]);
{tcp_error, Socket, Reason} ->
io:format("Error on socket ~p reason: ~p~n", [Socket, Reason])
end.
3) test_socket_server.erl
-module(test_socket_server).
-export([start/0, start/1, stop/0, stop/1]).
-export([init/1, handle_call/3, handle_cast/2, terminate/2, code_change/3,
handle_info/2]).
-include("socket_options.hrl").
-define(RECBUF_SIZE, 8192).
start() ->
gen_server:start(?MODULE, [], []).
start(InitArg = #socket_options{name = Name}) ->
case Name of
undefined ->
gen_server:start({local,?MODULE}, ?MODULE, InitArg, []);
_ ->
gen_server:start({local,Name}, ?MODULE, InitArg, [])
end.
stop() ->
gen_server:cast(?MODULE, stop).
stop(Name) when is_atom(Name) ->
gen_server:cast(Name, stop);
stop(Pid) when is_pid(Pid) ->
gen_server:cast(Pid, stop);
stop(_State = #socket_options{name = Name}) ->
stop(Name).
%回调函数
%init(State = #socket_options{ip = Ip, port = Port, backlog = Backlog, nodelay = NoDelay}) ->
init(State = #socket_options{port = Port, backlog = Backlog, nodelay = NoDelay}) ->
BaseOpts = [binary,
{reuseaddr, true},
{packet, 0},
{backlog, Backlog},
{recbuf, ?RECBUF_SIZE},
{active, false},
{nodelay, NoDelay}],
listen(Port, BaseOpts, State). %%监听
handle_call(_Msg, _Caller, State) -> {noreply, State}.
handle_info(_Msg, Library) -> {noreply, Library}.
terminate(Reason, #socket_options{listen = Listen}) ->
io:format("socket close,~p~n",[Reason]),
gen_tcp:close(Listen). %%关闭Listen
code_change(_OldVsn, State, _Extra) ->
State.
handle_cast({accepted, _Pid}, State = #socket_options{active_sockets = ActiveSockets,
listen = Listen, loop = Loop}) ->
NewState = State#socket_options{active_sockets = 1 + ActiveSockets},
test_socket_server_acceptor:start_link(self(), Listen, Loop),
{noreply, NewState};
handle_cast(stop, Name) ->
%io:format("关闭服务器！~n"),
{stop, normal , Name}.
listen(Port, Opts, State) ->
case gen_tcp:listen(Port, Opts) of
{ok, Listen} ->
test_socket_server_acceptor:start_link(self(), Listen, State#socket_options.loop),
NewState = State#socket_options{listen = Listen},
{ok, NewState};
{error, Reason} ->
{stop, Reason}
end.
4) test_socket_server_acceptor.erl
-module(test_socket_server_acceptor).
-export([start_link/3, init/3]).
start_link(Server, Listen, Loop) ->
proc_lib:spawn_link(?MODULE, init, [Server, Listen, Loop]).
init(Server, Listen, Loop) ->
case catch gen_tcp:accept(Listen) of
{ok, Socket} ->
gen_server:cast(Server, {accepted, self()}),
call_loop(Loop, Socket);
{error, closed} ->
exit(normal);
{error, timeout} ->
init(Server, Listen, Loop);
{error, esslaccept} ->
exit(normal);
_ ->
exit({error, accept_failed})
end.
call_loop({M, F}, Socket) ->
io:format("socket call_loop,~n"),
M:F(Socket);
call_loop({M, F, [A1]}, Socket) ->
M:F(Socket, A1);
call_loop({M, F, A}, Socket) ->
erlang:apply(M, F, [Socket | A]);
call_loop(Loop, Socket) ->
Loop(Socket).
下一步是想在此基础上写一个聊天室什么的，不过我目前我想先实践完OTP实战这本书。
