[Erlang开发之路]十七、套接字编程(TCP&UDP)

TCP编程

1.涉及的模块和函数

%gen_tcp是TCP编程的核心模块
%包括函数如下
-spec connect(Address, Port, Options, Timeout) -> {ok, Socket} | {error, Reason} when
Address = inet:socket_address() | inet:hostname() %其实可以是字符串
Port = inet:port_number()%整形
Options = [connect_option()]%举例:[binary,{packet,0},{nodelay,true}]
Timeout = timeout()%超时时间
Socket = socket()
Reason = timeout | inet:posix()

-spec listen(Port, Options) -> {ok, ListenSocket} | {error, Reason} when
Port = inet:port_number()
Options = [listen_option()]
ListenSocket = socket()
Reason = system_limit | inet:posix()

-spec accept(ListenSocket, Timeout) -> {ok, Socket} | {error, Reason} when
ListenSocket = socket()
%Returned by listen/2.
Timeout = timeout()
Socket = socket()
Reason = closed | timeout | system_limit | inet:posix()

-spec recv(Socket, Length, Timeout) -> {ok, Packet} | {error, Reason} when
Socket = socket()
Length = integer() >= 0
Timeout = timeout()
Packet = string() | binary() | HttpPacket
Reason = closed | timeout | inet:posix()
HttpPacket = term()

-spec send(Socket, Packet) -> ok | {error, Reason} when
Packet = string() | binary() | HttpPacket
 
-spec shutdown(Socket, How) -> ok | {error, Reason} %关闭连接
Socket = socket()
How = read | write | read_write
Reason = inet:posix()
%当How==read时写的操作还是可以进行的，反之，=write时读的操作还可以进行，
%如果HOW==READ或Socket端口中没有缓冲传出数据，则立即关闭套接字并在Reason中返回遇到的任何错误。如果套接字端口中有缓冲数据，则会延迟关闭套接字的尝试，直到将数据写入内核套接字发送缓冲区。如果遇到任何错误，则关闭套接字并在下一个recv / 2或send / 2上返回 {error，closed}。
-spec close(Socket) -> ok 和shutdown差不多，但是shutdown更好,将会即刻关闭

服务端：

%来个实例吧:服务端;每进入一个客户就创建一个新进程去Accept和loopRecv
-module(tcpServer).
-export([start/0]).

start()->
    case gen_tcp:listen(6612,[binary,{packet,4},{active,false}]) of%创建一个被动服务器
        {ok,Socket}->
            io:format("Server Listen Success!~n"),
            loopAccept(Socket);
        {error,Reason}->
            io:format("Server Listen Fail! Reason~p~n",Reason)
    end.
    
loopAccept(Socket)->
    case gen_tcp:accept(Socket) of
        {ok,ClientFd}->
            spawn(tcpServer,fun()->loopAccept(ClientFd) end),
            loopRecv(ClientFd);
        {error,Reason}->
        io:format("Server Accept Fail! Reason~p~n",Reason)
    end.
    
loopRecv(ClientFd)->
    case gen_tcp:recv(ClientFd,0) of
        {ok,Bin}->
            io:format("Recv:~p~n",[binary_to_list(Bin)]),
            loopRecv(ClientFd);
        {error,closed}->
            byebye
    end.
        

客户端：

%This is a client
-module(tcpClient).
-export([start/1,loopSend/3]).
-spec start(Num)-> any() when
Num:integer().

start(Num)->
    case gen_tcp:connect({127,0,0,1},6612,[binary,{packet,4}]) of
        {ok,Socket}->
            loopSend(Socket,0,Num);
        {error,Reason}->
            Reason
    end.
loopSend(Socket,Index,Target) when Target=<Index ->
    io:format("Send Finish!~n",[]);
loopSend(Socket,Index,Target)->
    gen_tcp:send(Socket,list_to_binary(["This is a message!!"])),
    loopSend(Socket,Index+1,Target).

UDP未完待续...