erlang gen_tcp 聊天室（node节点）

最新推荐文章于 2023-11-20 23:43:36 发布
最新推荐文章于 2023-11-20 23:43:36 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： erlang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/simsunny22/article/details/9281711
版权

自己写的一个简单的基于gen_tcp行为的聊天室：

因为技术要求，要服务器端要实现3个节点，分别是（node，holl，chat节点）。

客户端要实现的是 和服务端的通信，注册，登陆和聊天的功能


（1）

opt_node模块:用于监听port端口（自己定义的），并且用于监听多个客户端发来的请求。

-module(opt_node).

%% ====================================================================
%% API functions
%% ====================================================================
-behaviour(gen_server). 
-export([]).
%% gen_server callbacks  
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,  
     terminate/2, code_change/3]).  
-compile(export_all).

-define(Server_Node,node).

-define(Node_Holl,holl@simsunny).
-define(Server_Holl,holl).

-define(Node_Chat,chat@simsunny).
-define(Server_Chat,chat).
%% ====================================================================
%% Internal functions
%% ====================================================================
s() -> gen_server:start_link({local,?Server_Node}, ?MODULE, [], []).  
stop()  -> gen_server:call(?Server_Node, stop).  


init([])->
	io:format("-----------------supervison------------------------\n"),
	server(),
	{ok,[]}.


handle_call(stop, _From, Tab) ->  
    {stop, normal, stopped, Tab}.  
  
handle_cast(_Msg, State) -> {noreply, State}. 

handle_info(_Info, State) -> {noreply, State}.  

terminate(_Reason, _State) -> ok.  

code_change(_OldVsn, State,_Extra) -> {ok, State}.


server()->
	io:format("----------------server------------------------\n"),
	case gen_tcp:listen(2345,[binary,{packet,4},
							  {reuseaddr,true},{active,true}] ) of
		{ok,Listen}->
			
			spawn(fun()->connect(Listen,0)end);
		{error,Reason}->
			io:format(" listen is wrong:~p~n",[Reason])
	end.

connect(Listen,Num)->

	case gen_tcp:accept(Listen) of
			{ok,Socket}->
			io:format("--------------------accpet()----------------------\n"),
			io:format("Socket is:~p~n", [Socket]),
			Server_name=list_to_atom("opt_node_server"++integer_to_list(Num)),
%% 			Server_name_super=list_to_atom("super_node_server"++integer_to_list(Num)),
			New_num=Num+1,
			{ok,Pid}=opt_node_connect:s(Server_name),
			gen_tcp:controlling_process(Socket, Pid),
			connect(Listen,New_num);
		{error,Why}->
			io:format("par_con error:~p~n",[Why])
	end.
函数解释：

gen_tcp:listen(2345,[binary,{packet,4},{reuseaddr,true},{active,true}] ) 表示监听2345的端口，

spawn(fun()->connect(Listen,0)end) 这里用spawn是应为调用 gen_tcp:listen函数，进程一直在等待连接，开一个新的进程用于处理请求

gen_tcp:controlling_process(Socket, Pid),表示将Socket交给Pid的进程来处理

（2）

opt_node_connect 模块：当客户端发来请求，就新建一个进程，该进程与客户端进行通信

-module(opt_node_connect).


%% ====================================================================
%% API functions
%% ====================================================================
-behaviour(gen_server). 
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,  
     terminate/2, code_change/3]).  
-compile(export_all).


-define(Node_Holl,holl@simsunny).
-define(Server_Holl,holl).

-define(Node_Chat,chat@simsunny).
-define(Server_Chat,chat).



%% ====================================================================
%% Internal functions
%% ====================================================================

s(Server_name) ->  
    gen_server:start_link({local,Server_name},?MODULE, [Server_name], []).  



init([Server_name])->
	
	
	{ok,Server_name}.


%% ====================================================================
%%handle_call
%% ==================================================================== 

%%quite
handle_call(stop, _From,Server_name) ->  
    {stop, normal, stopped, Server_name}.  

%% ====================================================================
%%handle_cast
%% ==================================================================== 


%%register
handle_cast({reigister,user_is_already,{socket,Socket}},Tab)->
	io:format("------------------receive node-------------------------------\n"),
	io:format("register is error (user is already)\n"),
	gen_tcp:send(Socket,term_to_binary({register,n,user_is_already})),
	{noreply, Tab}; 

handle_cast({reigister,register_success,{{user,Name},{psw,Psw},{socket,Socket}}},Tab)->
	io:format("------------------receive node-------------------------------\n"),
	io:format("register is ok \n"),
	gen_tcp:send(Socket,term_to_binary({register,y,{{user,Name},{psw,Psw}}})),
	{noreply, Tab}; 
%%login	
handle_cast({login,no_urers,{socket,Socket}},Tab)->
	io:format("------------------receive node-------------------------------\n"),
	io:format("log is error (no users)\n"),
	gen_tcp:send(Socket,term_to_binary({login,n,no_urers})),
	{noreply, Tab}; 

handle_cast({login,psw_wrong,{socket,Socket}},Tab)->
	io:format("------------------receive node-------------------------------\n"),
	io:format("log is error (psw wrong)\n"),
	gen_tcp:send(Socket,term_to_binary({login,n,psw_wrong})),
	{noreply, Tab}; 

handle_cast({login,success,{{user,Name},{psw,Psw},{socket,Socket}}},Tab)->
	io:format("------------------receive node-------------------------------\n"),
	io:format("log is ok\n"),
	gen_tcp:send(Socket,term_to_binary({login,y,{{user,Name},{psw,Psw}}})),
%% 	ets:insert(?Ets_Tab_Users, {Name,Socket}),
	{noreply, Tab};  

%%get online
handle_cast({get_all_users,List_name,{socket,Socket}},Tab)->
	io:format("------------------receive node-------------------------------\n"),
	io:format("get_all_users\n"),
	gen_tcp:send(Socket,term_to_binary({get_all_users,List_name})),
	{noreply, Tab};



%%chat in room
handle_cast({chat,{name,Name},{content,Msg},List},Tab)->
	io:format("------------------receive node-------------------------------\n"),
	io:format("chat\n"),
	send(Name, List, Msg),
	{noreply, Tab};

%%chat in group
handle_cast({chat_gr,{name,Name},{content,Content},List_node},Tab)->
	io:format("------------------receive node-------------------------------\n"),
	io:format("chat_gr\n"),
	send(Name, List_node, Content),
	{noreply, Tab};

handle_cast({no}, State) -> {noreply, State}. 

%% ====================================================================
%%handle_info
%% ==================================================================== 
handle_info({tcp, Socket, Bin}, Server_name)->  
	
	Msg=binary_to_term(Bin),
	io:format("------------------receive client-------------------------------\n"),
	io:format("msg:~p~n", [Msg]),
	
	case Msg of 
			
		{register,{user,Name},{psw,Psw}}->
			Request={register,{user,Name},{psw,Psw},{socket,Socket},{server_Name,Server_name}},
			gen_server:call({?Server_Holl,?Node_Holl}, Request);
		
		{login,{user,Name},{psw,Psw}}->
			Request={login,{user,Name},{psw,Psw},{socket,Socket},{server_Name,Server_name}},
			gen_server:call({?Server_Holl,?Node_Holl}, Request);
	
		{get_all_users,{name,_Name}}->
			Request={get_all_users,{socket,Socket},{server_Name,Server_name}},
			gen_server:call({?Server_Chat,?Node_Chat}, Request);
		
		{chat,{name,Name},{content,Content}}->
			Request={chat,{name,Name},{content,Content},{server_Name,Server_name}},
			gen_server:call({?Server_Chat,?Node_Chat}, Request);
		
		{chat_group,{name,Name},{list,List},{msg,Content}}->
			Request={chat_group,{name,Name},{list,List},{msg,Content},{server_Name,Server_name}},
			gen_server:call({?Server_Chat,?Node_Chat}, Request);
	
		_->
			io:format("not reg \n")
			
	end,
		
    {noreply, Server_name};  

handle_info({tcp_closed,Socket}, Server_name) ->  
	
	io:format("client: is quite~p~n",[Socket]),
	Requset={quite,{socket,Socket},{server_name,Server_name}},
	gen_server:call({?Server_Chat,?Node_Chat},Requset),
	
    {noreply,Server_name}. 



terminate(_Reason, _State) -> ok.  
code_change(_OldVsn, State,_Extra) -> {ok, State}.



send(Name,[{To_Name,Socket}|T],Msg)->
	
	Msg_info={{name,Name},{msg,Msg}},
	io:format("--------------------------------------------\n"),
%% 	io:format("Name:~p~n",[Name]),
%% 	io:format("TO_Name:~p~n",[To_Name]),
	case gen_tcp:send(Socket,term_to_binary(Msg_info)) of
		ok ->io:format(" send ok-------~n form:~p~n to:~p~n msg:~p~n socket:~p~n ", 
			  [Name,To_Name,Msg,Socket]);
		_ ->io:format(" send error-------~n form:~p~n to:~p~n msg:~p~n socket:~p~n ", 
			  [Name,To_Name,Msg,Socket])
	end,
	io:format("--------------------------------------------\n"),
	send(Name,T,Msg);
send(_Name,[],_Msg)->
	over.

解释：该模块使用的是gen_server的行为模式，该模式中的handle_info用来接收系统发来的消息（具体的不太理解，哪些是系统的消息）。可以用来接收从客户端发来的消息，相当于receive .......end 的作用。

欢迎转载，请注明出处

holl节点和chat节点我会在后面写到的，客户端的代码就不贴出来了，就是很简单的，定义消息的，在源码里在给大家吧~~

simsunny22
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于erlang gen_server 实现的tcp通讯
weixin_42843757的博客
09-27 1098
erlang 的socket编程都是基于两个自带系统模块，分别gen_tcp和gen_udp。本文先实现erlang tcp通信实例。 编写代码前首先需要了解用到了gen_tcp的哪些方法，如何建立连接。首先
Erlang 入门——从普通tcp到OTP框架通信
夜的瞳
08-14 2016
Erlang使用tcp通信，OTP框架下gen_server的节点通信pingpong实现demo。
Erlang套接字编程（上篇）
最新发布
qq_53795917的博客
11-20 103
使用TCP。
erlang TCP/IP
weixin_48283045的博客
10-03 87
开启一个监听某个端口的套接字开启一个监听某个端口的套接字，参数 Port 为 0，那么底层操作系统将赋值一个可用的端口号。
gen_tcp:send的深度解刨和使用指南(初稿)
09-03 2668
gen_tcp:send的深度解刨和使用指南(初稿) April 5th, 2010Yu FengLeave a commentGo to comments 原创文章，转载请注明： 转载自Erlang非业余研究 本文链接地址: gen_tcp:send的深度解刨和使用指南(初稿) 在大家的印象中, gen_tcp:send是个很朴素的函数, 一调
基于Erlang的gen_tcp聊天室代码,功能完整
04-13
在这个场景中，我们讨论的是一个使用Erlang和gen_tcp编写的聊天室应用。 **gen_tcp简介** gen_tcp是Erlang OTP（开放电信平台）提供的一种行为模块，它允许程序员以面向过程的方式处理TCP连接。gen_tcp提供了创建、...
gen_tcp_server:Erlang 应用程序的通用 TCP 服务器
06-14
通用 TCP 服务器 通用 TCP 服务器( gen_tcp_server ) 是一种 Erlang 行为，提供快速简便的方法将 TCP 服务器功能添加到您的应用程序。 它被实现为管理 TCP 连接的主管，因为它是孩子。如何使用它？ 运行make来构建。...
erlang-gen_tcp手册
03-31
erlang-gen_tcp手册,详细完整，网络tcp开发好东东
erlang tcp_server
10-06
4. **gen_tcp模块**：这个模块提供了处理TCP连接的函数，如`gen_tcp:connect/3`用于建立客户端连接，`gen_tcp:recv/2,3`用于接收数据，`gen_tcp:send/2`用于发送数据，以及`gen_tcp:close/1`用于关闭连接。...
tcp_client:一个Erlang TCP客户端连接管理器
05-13
- 在Erlang中，我们可以使用`gen_tcp`模块来操作TCP连接，包括监听、连接、发送和接收数据，以及关闭连接。 2. **Erlang的并发模型**： - Erlang的进程模型使得每个TCP连接可以作为一个独立的进程运行，这样可以...
eradio:一个Erlang HTTP服务器，该服务器将数据流传输到多个客户端，并以低延迟进行了有损的时间同步
04-10
爱拉迪欧 一个Erlang HTTP服务器，该服务器将数据流传输到多个客户端，从而以低延迟进行了有损的时间同步。 HTTP / 1和HTTP / 2使用TCP作为其传输协议，这对于“实时流式传输”（即低延迟时间同步流式传输）是有问题的。 由于TCP是默认情况下通常针对高吞吐量而优化的无损协议，因此操作系统通常会维护大量未确认的传出数据缓冲区。 此缓冲可能导致不可靠的网络连接上的延迟。 此外，某些流行的浏览器HTTP媒体流实现不允许有效地查找缓冲数据的过去突发，以使回放尽可能接近最新数据。 eradio使用了几种技术来避免这种TCP引起的延迟。 首先是调整发送缓冲区的大小。 当应用程序使用普通的Socket API发送数据时，必须由OS对其进行缓冲，直到接收方确认接收到数据为止。 这被称为“发送缓冲区”，并且eradio尝试最小化其容量。 其次，由于某些操作系统（例如Linux）还在发送
Erlang之TCP入门样例
fbher的博客
06-12 301
首先创建socket_example.erl： -module(socket_example). -compile(export_all). nano_get_url() -> nano_get_url("www.baidu.com"). nano_get_url(Host) -> {ok,Socket} = gen_tcp:connect(Host, 80, [binar...
2.基础知识，Erlang gen_tcp 案例
weixin_30399155的博客
09-26 100
1.客户端和服务端互联案例，举例中客户端和服务端都是用Erlang 服务端 1 server() -> 2 LSock = listen(), %监听本机的某个端口 3 {ok, Sock} = gen_tcp:accept(LSock), %保持监听状态，程序会停在这一步，直到有客户端连接上 4 {ok, Bin} = do_recv(So...
erlang gen_tcp网络连接
牛逼！
03-19 1039
gen_tcp有false,active,once,N这些选项，active是不提供流量控制的，之前没读懂，疑惑了好久，后面仔细看了看，也许是这个意思：erlang的话每个进程都有个邮箱，消息就放在邮箱中，在active模式下会无限的从底层接收缓存中提取消息到邮箱中，邮箱满了消息就会丢失。 packet参数的意义是说在发送消息的时候会自动生成这么多字节的头部，我试了试这个选项在active、f...
Erlang简单gen_tcp例子
Lee的博客
12-10 3209
简单 client / server通信例子。 前端：flash AS3 后台：Erlang package { import flash.display.Sprite; import flash.events.Event; import flash.events.IOErrorEvent; import flash.events.ProgressEvent; import fl...
Erlang——嵌套字编程
weixin_52671611的博客
09-20 154
套接字编程能让应用程序与互联网上的其他机器交互，比只进行本地操作有更大的空间。套接字是一种通信信道，让不同的机器能用互联网协议（简称IP）在网上通信。两个核心互联网协议：传输控制协议（简称TCP）和用户数据报协议（简称UDP）。UDP能让应用程序相互发送简短的消息（称为数据报），但是并不保证这些消息能成功到达。它们也可能会不按照发送顺序到达，更快但不可靠。TCP能提供可靠的字节流，只要连接存在就会按顺序到达。用TCP发送数据的额外开销比用UDP发送数据更大，可靠但更慢。
关于gen_tcp:controlling_process函数的使用
wangyangkobe的专栏
05-10 3749
网上的文档： http://blog.csdn.net/skyman_2001/article/details/6582938 http://erlang-china.org/misc/using-gen_tcp-controlling_process.html 对于该函数的理解： 最初紧紧知道该函数是将一个Socket和一个进程的Pid绑定在一起，但是对于“发送给这个Socket
Erlang并发编程总结
小墨鱼的网络博客，不随大流的程序员世界...
04-21 840
并发编程 使用并发 spawn创建一个并行进程， send向某个进程发送消息， receive则是接收消息 Erlang的并发是基于进程（ process）的。进程是一些独立的小型虚拟机，可以执行Erlang函数 ，在Erlang里，进程隶属于编程语言，而非操作系统。 Erlang中的进程会执行某个特点方法，并且执行过程是以一个并发的形式执行的 spawn(Mod, Func, Args) -> Pid,进程标识符 ,以用Pid来给此进程发送消息 可以使用 Pid ~Message 的形式给进程Pid
Erlang--TCP学习(一)Client篇
05-23
在Erlang中，我们可以使用`gen_tcp`模块来实现TCP客户端。下面是一个简单的例子，展示如何使用`gen_tcp`模块来连接到一个服务端： ```erlang -module(tcp_client). -export([start/1]). start(Host) -> {ok, Socket} = gen_tcp:connect(Host, 80, [binary, {packet, 0}]), gen_tcp:send(Socket, "GET / HTTP/1.0\r\n\r\n"), receive_data(Socket), gen_tcp:close(Socket). receive_data(Socket) -> case gen_tcp:recv(Socket, 0) of {ok, Data} -> io:format("~s", [Data]), receive_data(Socket); {error, closed} -> ok end. ``` 在上面的例子中，`gen_tcp:connect`函数用于连接到指定的服务端。`Host`参数是服务端的IP地址或域名，`80`是服务端的端口号。`[binary, {packet, 0}]`选项说明我们要传输二进制数据，且数据包不需要打包。 一旦连接建立成功，我们就可以使用`gen_tcp:send`函数向服务端发送数据了。在这个例子中，我们发送了一个HTTP GET请求。接着，我们调用了`receive_data`函数来接收服务端返回的数据。`gen_tcp:recv`函数用于接收服务端发送的数据。`0`参数表示接收的数据包没有大小限制。如果接收到数据，我们就打印出来，并继续调用`receive_data`函数来接收更多的数据。如果服务端关闭了连接，`gen_tcp:recv`函数会返回错误信息`{error, closed}`，我们就可以关闭连接了。 在使用`gen_tcp`模块时，我们需要注意以下几点： - 为了避免阻塞，在发送和接收数据时，我们可以使用`gen_tcp:send/2`和`gen_tcp:recv/2`函数的阻塞模式，即将第二个参数设置为`0`。这样，如果没有数据可发送或接收，函数就会马上返回。 - 如果我们需要发送和接收大量的数据，应该使用`{packet, N}`选项来打包数据。这个选项会将数据分成大小为N的块，并且在每个块前面添加4个字节的头部，用于表示这个块的大小。这样可以避免粘包问题。 - 在发送和接收数据时，我们应该按照服务端和客户端的协议来组织数据包。如果协议有变化，我们也需要修改代码来适应新的协议。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值