基于winsock的局域网通信系统的开发.docx

上传人:b****6 文档编号:8112623 上传时间:2023-01-28 格式:DOCX 页数:46 大小:232.52KB
下载 相关 举报
基于winsock的局域网通信系统的开发.docx_第1页
第1页 / 共46页
基于winsock的局域网通信系统的开发.docx_第2页
第2页 / 共46页
基于winsock的局域网通信系统的开发.docx_第3页
第3页 / 共46页
基于winsock的局域网通信系统的开发.docx_第4页
第4页 / 共46页
基于winsock的局域网通信系统的开发.docx_第5页
第5页 / 共46页
点击查看更多>>
下载资源
资源描述

基于winsock的局域网通信系统的开发.docx

《基于winsock的局域网通信系统的开发.docx》由会员分享,可在线阅读,更多相关《基于winsock的局域网通信系统的开发.docx(46页珍藏版)》请在冰豆网上搜索。

基于winsock的局域网通信系统的开发.docx

基于winsock的局域网通信系统的开发

重庆理工大学

课程设计

 

课程面向对象程序设计I

题目基于WinSock的局域

网通信系统的开发

 

1系统分析

1.1功能模块分析

服务器接收消息、发送消息和消息处理线程和收发消息类的封装

1.1.1模块一

服务器接收消息线程

 

 

1.1.2模块二

 

服务器发送消息线程

 

 

1.1.3模块三

服务器消息处理线程

处理登录消息

…….

1.1.4模块四

收发消息类的封装

2系统实现

2.1模块一

#ifndefRECV_PRODUCER_H

#defineRECV_PRODUCER_H

#include"Global_Define.h"

#include"Message_Queue.h"

#include"IM_Message_Block.h"

#include"Udp_Daemon.h"

externMessage_Queueg_rcv_msg_queue;

externUdp_Daemong_udp_daemon;

classRecv_Producer

{

public:

Recv_Producer(intrcv_num);

~Recv_Producer(void);

public:

boolstart();//开始线程

boolstop();//停止线程

voidstatus();//线程状态

private:

staticunsignedintserver(void*pParam);//线程函数,要求多线程安全

private:

int_recv_producer_num;//接收消息线程数量

staticint_blk_recv;//接收到的消息数

//接收消息队列

staticMessage_Queue*_msg_queue;

staticUdp_Daemon*_upd_daemon;

};

#endif//RECV_PRODUCER_H

#include

#include"Recv_Producer.h"

#include"Send_Consumer.h"

//初始化接收消息队列

Message_Queue*Recv_Producer:

:

_msg_queue=&g_rcv_msg_queue;

Udp_Daemon*Recv_Producer:

:

_upd_daemon=&g_udp_daemon;//初始化udp通信静态对象

intRecv_Producer:

:

_blk_recv=0;

Recv_Producer:

:

Recv_Producer(intrcv_num)

:

_recv_producer_num(rcv_num)

{}

Recv_Producer:

:

~Recv_Producer(void)

{}

boolRecv_Producer:

:

start()//开始线程

{

for(inti=0;i<_recv_producer_num;i++)

AfxBeginThread(Recv_Producer:

:

server,NULL);

returntrue;

}

boolRecv_Producer:

:

stop()//停止线程

{

returntrue;

}

voidRecv_Producer:

:

status()//线程状态

{

cout<<"接收线程当前状态:

"<

cout<<"已经接收到消息条数:

"<<_blk_recv<

}

unsignedintRecv_Producer:

:

server(void*pParam)//线程函数,要求多线程安全

{

while

(1)

{

IM_Message_Block*blk=newIM_Message_Block;//申请内存块空间

if(!

blk)

{

cout<<"接收消息线程退出:

申请内存块错误。

"<

break;

}

blk->length_=MAX_PACKET_LEN;

//接收消息

intret=_upd_daemon->recv((char*)blk->get_data(),blk->length_,blk->src_ip_,blk->src_port_);

if(ret==1)//接收正确

{

//如果接收到的消息不符合要求则直接删除

if(blk->length_

{

deleteblk;

continue;

}

//否则将接收到的消息放入接收消息队列中

_blk_recv++;

_msg_queue->push_msg(blk);

}

elseif(ret==0)//socket退出

{

deleteblk;

//向发送消息队列和接收消息队列各中放入一空消息,让发送线程和处理线程退出

blk=0;

Send_Consumer:

:

_msg_queue->push_msg(blk);

_msg_queue->push_msg(blk);

cout<<"接收消息线程退出:

socket退出。

"<

break;

}

else//出现网络错误,接收失败

{

deleteblk;

//向发送消息队列和接收消息队列各中放入一空消息,让发送线程和处理线程退出

blk=0;

Send_Consumer:

:

_msg_queue->push_msg(blk);

_msg_queue->push_msg(blk);

cout<<"接收消息线程退出:

出现网络错误。

"<

return0;

}

}

return1;

}

2.2模块二

#ifndefSEND_CONSUMER_H

#defineSEND_CONSUMER_H

#include"Global_Define.h"

#include"Message_Queue.h"

#include"IM_Message_Block.h"

#include"Udp_Daemon.h"

externMessage_Queueg_send_msg_queue;

externUdp_Daemong_udp_daemon;

classSend_Consumer

{

public:

Send_Consumer(intsend_num);

~Send_Consumer(void);

public:

boolstart();//开始线程

boolstop();//停止线程

voidstatus();//线程状态

private:

staticunsignedintserver(void*pParam);//线程函数,要求多线程安全

private:

int_send_consumer_num;//发送消息线程数量

staticint_blk_send;//发送的消息数

staticUdp_Daemon*_upd_daemon;

public:

//发送消息队列,公有,接收消息线程中需要往里面放入结束线程标志消息

staticMessage_Queue*_msg_queue;

};

#endif//SEND_CONSUMER_H

#include

#include"Send_Consumer.h"

//初始化发送消息队列

Message_Queue*Send_Consumer:

:

_msg_queue=&g_send_msg_queue;

Udp_Daemon*Send_Consumer:

:

_upd_daemon=&g_udp_daemon;//初始化udp通信静态对象

intSend_Consumer:

:

_blk_send=0;

Send_Consumer:

:

Send_Consumer(intsend_num)

:

_send_consumer_num(send_num)

{}

Send_Consumer:

:

~Send_Consumer(void)

{}

boolSend_Consumer:

:

start()//开始线程

{

for(inti=0;i<_send_consumer_num;i++)

AfxBeginThread(Send_Consumer:

:

server,NULL);

returntrue;

}

boolSend_Consumer:

:

stop()//停止线程

{

returntrue;

}

voidSend_Consumer:

:

status()//线程状态

{

cout<<"消息发送线程当前状态:

"<

cout<<"已经发送的消息条数:

"<<_blk_send<

}

unsignedintSend_Consumer:

:

server(void*pParam)//线程函数,要求多线程安全

{

while

(1)

{

IM_Message_Block*blk=_msg_queue->get_msg();//从发送消息队列获取消息

if(!

blk)

{

cout<<"发送消息线程退出:

从消息队列获取到退出消息。

"<

//将这条空消息又放回去,因为有可能会有多个发送消息线程,这样才能

//保证其它发送消息线程也能退出

_msg_queue->push_msg(blk);

break;

}

if(blk->length_

{

deleteblk;

continue;

}

else

{

//将取出来的消息发送出去

intret=_upd_daemon->send((char*)blk->get_data(),blk->length_,blk->src_ip_,blk->src_port_);

if(ret==1)//发送成功

{

_blk_send++;

deleteblk;

}

elseif(ret==0)//socket关闭

{

deleteblk;

cout<<"发送消息线程退出:

socket退出。

"<

break;

}

else//出现网络错误,发送失败

{

deleteblk;

cout<<"发送消息线程退出:

出现网络错误。

"<

return0;

}

}

}

return1;

}

2.3模块三

#ifndefPROCESS_CONSUMER_H

#definePROCESS_CONSUMER_H

#include"Global_Define.h"

#include"Message_Queue.h"

#include"IM_Message_Block.h"

#include"Account_DB_Access.h"

#include"User_Manager.h"

 

externMessage_Queueg_rcv_msg_queue;

externMessage_Queueg_send_msg_queue;

externAccount_DB_Accessg_account_db;

externUser_Managerg_user_manager;

 

classProcess_Consumer

{

public:

Process_Consumer(intprocess_num);

~Process_Consumer(void);

public:

boolstart();//开始线程

boolstop();//停止线程

voidstatus();//线程状态

private:

staticunsignedintserver(void*pParam);//线程函数,要求多线程安全

staticvoidhandle_msg(IM_Message_Block*blk);//消息处理函数,要求多线程安全

staticinthandle_blk_account_register(IM_Message_Block*blk);//处理注册消息

//处理更新信息消息

staticinthandle_blk_account_set_info(IM_Message_Block*blk);

staticinthandle_blk_session_login(IM_Message_Block*blk);//处理登录消息

//处理改变状态消息

staticinthandle_blk_session_change_status(IM_Message_Block*blk);

staticinthandle_blk_session_hearbeat(IM_Message_Block*blk);//处理心跳消息

staticinthandle_blk_session_logout(IM_Message_Block*blk);//处理登出消息

//处理查找在线用户消息

staticinthandle_blk_contact_search(IM_Message_Block*blk);

staticinthandle_blk_contact_add(IM_Message_Block*blk);//处理新增好友消息

staticinthandle_blk_contact_del(IM_Message_Block*blk);//处理删除好友消息

//处理获取好友列表消息

staticinthandle_blk_contact_get_list(IM_Message_Block*blk);

//处理获取好友在线信息消息

staticinthandle_blk_get_online_info(IM_Message_Block*blk);

staticinthandle_blk_schat_msg(IM_Message_Block*blk);//处理聊天消息

staticunsignedintcreate_blk_seq();//生成消息号

staticunsignedintcreate_uid();//生成用户id

private:

int_process_consumer_num;//处理线程数量

staticint_blk_consumer;//处理的消息条数

staticunsignedint_seq_count;//消息号计数器

staticunsignedint_uid_count;//用户id计数器

staticunsignedint_uid_base;//记录每次服务器启动时数据库中最大的uid

staticAccount_DB*_account_db;//数据库操作对象

staticUser_Manager*_user_manager;//在线用户管理对象

//接收消息队列

staticMessage_Queue*_rcv_msg_queue;

//发送消息队列

staticMessage_Queue*_send_msg_queue;

staticCCriticalSection_lock;//同步全局对象的操作

};

#endif//PROCESS_CONSUMER_H

#include

#include

#include"Process_Consumer.h"

//初始化接收消息队列

Message_Queue*Process_Consumer:

:

_rcv_msg_queue=&g_rcv_msg_queue;

//初始化发送消息队列

Message_Queue*Process_Consumer:

:

_send_msg_queue=&g_send_msg_queue;

intProcess_Consumer:

:

_blk_consumer=0;//处理线程数量

unsignedintProcess_Consumer:

:

_seq_count=0;//消息号计数器

unsignedintProcess_Consumer:

:

_uid_count=0;//用户id计数器

unsignedintProcess_Consumer:

:

_uid_base=0;

Account_DB*Process_Consumer:

:

_account_db=&g_account_db;//数据库操作对象

User_Manager*Process_Consumer:

:

_user_manager=&g_user_manager;//在线用户管理对象

CCriticalSectionProcess_Consumer:

:

_lock;

Process_Consumer:

:

Process_Consumer(intprocess_num)

:

_process_consumer_num(process_num)

{

}

Process_Consumer:

:

~Process_Consumer(void)

{

}

boolProcess_Consumer:

:

start()//开始线程

{

for(inti=0;i<_process_consumer_num;i++)

AfxBeginThread(Process_Consumer:

:

server,NULL);

returntrue;

}

boolProcess_Consumer:

:

stop()//停止线程

{

returntrue;

}

voidProcess_Consumer:

:

status()//线程状态

{

cout<<"消息处理线程当前状态:

"<

cout<<"已经处理的消息条数:

"<<_blk_consumer<

cout<<"等候处理的消息条数:

"<<_rcv_msg_queue->get_size()<

cout<<"等候发送的消息条数:

"<<_send_msg_queue->get_size()<

}

unsignedintProcess_Consumer:

:

server(void*pParam)//线程函数,要求多线程安全

{

IM_Message_Block*blk=NULL;

for(;;)

{

blk=(IM_Message_Block*)_rcv_msg_queue->get_msg();

if(!

blk)

{

cout<<"消息处理线程退出:

从消息队列获取到退出消息。

"<

//将这条空消息又放回去,因为有可能会有多个处理消息线程,这样才能

//保证其它处理消息线程也能退出

_rcv_msg_queue->push_msg(blk);

break;

}

if(blk->length_

{

deleteblk;

continue;

}

handle_msg(blk);

_blk_consumer++;

}

return1;

}

voidProcess_Consumer:

:

handle_msg(IM_Message_Block*blk)//消息处理函数,要求多线程安全

{

//根据协议处理各种消息

IM_Header*header=blk->get_header();

unsignedshortcmd=ntohs(header->cmd);

switch(cmd)

{

caseIM_ACCOUNT_REGISTER:

{

handle_blk_account_register(blk);

break;

}

caseIM_ACCOUNT_SET_INFO:

{

handle_blk_account_set_info(blk);

break;

}

caseIM_SESSION_LOGIN:

{

handle_blk_session_login(blk);

break;

}

caseIM_SESSION_STATUS_CHANGE:

{

handle_blk_session_change_status(blk);

break;

}

caseIM_SESSION_HEARTBEAT:

{

handle_blk_session_hearbeat(blk);

break;

}

caseIM_SESSION_LOGOUT:

{

handle_blk_session_logout(blk);

break;

}

caseIM_CONTACT_SEARCH:

{

handle_blk_contact_search(blk);

break;

}

c

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置:首页 > 高等教育 > 工学

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1