网络编程基于TCP的简易聊天室实验报告.doc

网络编程
课程设计说明书

题目名称： 基于TCP/IP的网络文字聊天程序设计
专 业： 网络工程
班 级： 1201班
学 号： 1220140105
姓 名： 蒋星
指导老师： 陈利平
完成日期： 2014年12月13日

目录

一、实验基本信息概要 3
1. 题目要求 3
2. 题目内容 3
3. 开发环境 3
二、流程图 4
三、系统简介 5
1.界面 5
2. 软件功能 5
3. 系统设计 9
4. 优点与缺点 9
四、系统详细设计 11
1. ChatServer类 11
2. ChatClient 类 13
3. SocketException类 15
5. 命令协议 15
6. 消息格式 16
五、 系统测试 16
1. 服务器使用错误 16
2. 客户端使用错误 17
3. 启动服务器 17
4. 启动客户端 17
5. 关闭客户端 17
6. 启动服务器错误提示 18
7. 公开聊天 18
8. 私聊 18
9. 错误的私聊 19
10. 更名 20
11. 帮助 20
12. 非法指令 20
13. 非法的指令参数 20
14. 连接服务器失败 21
六、心得体会 21
七、完整代码 21
Charserverd.cpp 服务器main函数文件 21
ChatServer.h 服务器类头文件 22
ChatServer.cpp 服务器类 23
ClientInfo.h 客户信息类 33
Charclientd.cpp 客户端main函数 34
ChatClient.h 客户端头文件 34
ChatClient.cpp 客户端类 35
InitSock.cpp 初始化WINSOCK类 41
SockException.h 异常类 41
八、[参考文献] 42

一、实验基本信息概要
1. 题目要求
1、开发平台
Visual C++ 6.0。
2、对设计方法的要求
使用Visual C++ 6.0开发出在Windows控制台或图形界面下运行的程序。
3、对设计内容的要求
① 实现网络文字聊天程序的服务器端。
② 实现网络文字聊天程序的客户端。
③ 主程序的结构和流程。
④ 程序运行过程的截图。
⑤ 网络文字聊天程序的实现原理。
⑥ 网络文字聊天程序实现代码的分析。
4、对课程设计说明书的要求
① 设计思路与开发过程。
② 对主要代码段要有较详细的注释。
③ 对本次设计的评价、设计的收获与建议。
5、说明书为打印件
2. 题目内容
内容概要：实现网络文字聊天程序的基本功能。
3. 开发环境
操作系统：Windows 7
开发语言：C++
集成开发环境：Microsoft Visual Studio 2010

二、流程图

三、系统简介
1.界面
本软件使用DOS控制台界面，界面风格较为朴素。
服务器：

客户端：

2. 软件功能
本软件实现了聊天室基本的功能，包括公开聊天，私聊，获取在线用户，更改昵称，获得帮助等。
1） 公开聊天
在光标处直接输入消息后按回车即为发送公开聊天，如下图所示。

2） 私聊
使用命令【 /m 对方UID 消息 】即可发送私聊，私聊只有对方可以看到，如下图所示：
客户端1，密聊UID为132的用户。

发送后

客户端2，UID为132的用户收到私聊消息。

3） 获取在线用户列表
使用命令【/list】即可获得在线用户列表，用户列表会议系统消息的方式返回，如下图所示。

命令

发送后

4） 更改昵称
使用命令【/name 你的新昵称】即可立即更改昵称，成功修改后服务器会以系统消息的方式返回成功修改的提示。
命令

命令发送后

5） 帮助信息
使用命令【/help】即可查看服务器的欢迎信息，里面包含了该聊天室的使用帮助，如下图所示。
命令

命令发送后

3. 系统设计
开发本软件时，我使用了面向对象的思想，把服务器和客户端封装成对应的类，类设计将会在下一节做详细介绍。通行方面我在服务器接受客户端消息，和客户端接受服务器消息时使用了select模型，发送信息我使用的是普通的socket原语。基本原理为服务器与客户端建立TCP连接，然后服务器负责路由消息到各个客户端。

4. 优点与缺点
本软件对流程复杂的SELECT模型进行了细致的拆分与抽象，做到了逻辑流程清晰，每个函数简洁易懂，层次分明。例如服务器启动函数：
void ChatServer::Start()
{
InitListenSocket();
Bind();
Listen();
InitFDSocket();
while (true)
{
DoSelect();
}
}

try
{
charServer.Start();
}
catch(SockException e)
{
cout << e.GetErrorInfo () << endl;
cout << "[System Error] Error Code:" << e.GetErrorCode () << endl;

}

它其实就完成了一个简单的流程，初始化socket，绑定，监听，初始化fd_socket集合，死循环调用select。通过合理的封装底层原语和加入异常处理（异常交给顶层处理），使得代码专注于业务流程而不是繁杂的异常判断语句，在看下面这个函数DoSelect()。

void ChatServer::DoSelect ()
{
m_fdRead = m_fdSocket;
int nRet = Select();
if(nRet > 0)
{
for(int i = 0;i < m_fdRead.fd_count; i++)
{
DoFDRead(m_fdRead.fd_array[i]);
}
}
}

它也只完成一个简单的流程，调用select，然后循环处理有读事件的socket。
void ChatServer::DoRead (SOCKET sRead)
{
if (sRead == m_sListen)
{
RecvNewConnect();
}
else
{
m_sNowClient = sRead;
RecvNewConnect();
}
}

接下来的DoFDRead（）函数完成的事情也非常直接，如果有事件的socket是监听socket的话，那么就是接收到了一个新的连接，否则是接收到了新的小。

从上面这个简单的例子中可以看到，本软件最大的优点就是精心设计的类和函数。避免了使用select模型常见的反复嵌套的循环和判断，每个函数清晰明了。

本系统还存在以下不足，首先是没有对界面做更深入的优化，只是做了最基本的调整，让输入输出更加雅观，其次是底层原语的封装并没有考虑到泛用性。
四、系统详细设计
这部分的文档在编码之前已经基本完成，由于时间较为仓促，部分内容可能和实际有所出入。
1. ChatServer类
该类负责完成服务器所有操作。
1） 类图
2) 成员变量
Map m_clients 聊天者的SOCKET与昵称的映射
fd_set m_fdSocket 可用套接字集合
fd_set m_fdRead 有事件发生的套接字集合
SOCKET m_sListen 监听Socket
SOCKET m_sNowClient 当前处理的客户套接字
int m_nPort 监听端口

3) 方法设计
void Bind()
void Listen()
void Select()
int Recv()
SOCKET Accept()
封装底层原语，并加入异常机制，使得外部调用简约明了。
构造函数
传入监听端口，初始化m_nPort
Start()
1）初始化监听套接字：void InitListenSocket()
2）绑定套接字至本地机器：void Bind()
3）进入监听模式（设置为非阻塞）：void Listen()
4）初始化可用套接字集合 void InitFDSocket()
5）死循环，调用select方法 DoSelect()
6）结束
DoSelect()

1）令m_fdRead = m_fdSocket
2）调用Select()
3）循环处理Select的结果 DoFdRead(Socket sRead)
4）结束
DoFdRead(int iReadIndex)
1）判断是否为m_sListen
2）是m_sListen RecvNewConnect()
3）否则 令m_sNowClient = m_fdRead[iReadIndex]，调用RecvNewMessage()
RecvNewConnect()
1）判断是否达到套接字上线
2）调用Accept()，接收连接sClient
3）添加sCilent 至 m_fdSocket
4）添加套接字至m_clients AddClientToInfoMap(string name)
AddClientToInfoMap(string name)
1）以SOKCET为键，name为值加入MAP
RecvNewMessage()
1）调用Recv函数
2）是否为命令 IsCommand(string str)
3）是，则DoCommand(string cmd)
4）否，则DoMessage(string msg)
5）结束
IsCommand(string str)
1）判断是否以 "/" 开头
DoCommand(string cmd)
1）判断指令，并解析命令与参数（argc, argv）
2）调用指令处理函数
3）假设只有SetName命令，那么则将对应的套接字的名称设置
DoMessage(string msg)
1）拼接消息与名字 BuildMsg(string msg)
2）在服务器上输出
3）消息路由DispatchMessage(string msg)
BuildMsg(string msg)
1）从m_clients 中取出用户昵称
2）拼接字符串，形成格式如下
超人君(127.0.0.1) 23:49:48 说:
大家好!
即为：
昵称（IP地址）时间 说：
消息正文
3）返回
DispatchMessage(string msg)
1）构造迭代器
2） 遍历m_clients,若不是自身，则派送消息Send()
2. ChatClient 类
该类负责处理客户端的所有操作。
1） 类图
2） 字段设计
SOCKET m_sClient 客户端自身的socket
SOCKET m_sServer 服务器socket
string m_name 昵称
sockaddr_in m_ServerAddr; 服务器地址
3） 方法设计
构造函数
根据端口号和服务器IP初始化m_server
Connect()
void Select()
int Recv()
void Send()
int Select()
封装底层原语，加入异常处理，使得外部调用节约优雅
void Start()
1）初始化套接字 InitClientSocket()
2）连接服务器 Connect() 设置为非阻塞模式
3）获取名字并发送至服务器 InitName()
4）创建新线程并显示替他用户发言 线程函数RecvMsgThread()
5）循环 SendMsg()
6）关闭客户端 CloseClient()

InitName()
1）提示输入昵称
2）获取昵称
3）合法性判断 判断重复
4）添加命令格式
5）发送至服务器

SendMsg()
1）读取一行消息
2）判断是否为命令 IsCommand(string str)
3）命令：处理命令 DoCommand(string cmd)
4）消息：处理消息 DoMessage(string msg)

DoMessage(string msg)
1）发送消息 Send()
2）本地回显

RecvMsgThread()
1） 初始化fdSocket,将m_sClient加入
2）创建fdRead
3）死循环,将m_sClient拷贝至fdRead
4）调用Select
5）循环，并输出收到的消息 Recv()

3. SocketException类
该类负责记录SOKCET错误的代码以及错误信息。
5. 命令协议
命令格式为 /命令 参数1 参数2

1. 退出: /exit
2. 获取在线用户列表：/getuser
3. 私聊： /m UID 信息
4. 清屏：/clear
5. 帮助：/help

处理方式
IsCommand(string str) 负责解析是否为命令
判断首字母是否为斜杠"/" str.at(0) == '/'

ResoveCommand(string cmd, int& argc, string argv[]) 若是命令将命令解析为argc,argv

DoCommand(string cmd) 处理命令，调用具体的XXX命令处理函数DoCmdXXXX()。
6. 消息格式
1） 公共消息
超人君(127.0.0.1) UID:100 说:
大家好!
李四(127.0.0.1) UID:101 说：
你好！！

2） 私聊
你悄悄地对 ABC UID：100 说：
你好
CDF UID:101 悄悄地对你说：
你好

3） 服务器消息
【系统消息】XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX。

4） 程序内部提示
[System Info]xxxxxxxxxxxxxxxxxxxxxxxxx
五、 系统测试
1. 服务器使用错误

2. 客户端使用错误

3. 启动服务器

4. 启动客户端
客户端出现欢迎信息以及昵称输入提示。

服务器出现连接提示

5. 关闭客户端
服务器出现断开连接提示

6. 启动服务器错误提示
给出错误提示信息和提示代码

7. 公开聊天
所有客户端以及服务器都会显示。

8. 私聊
只有私聊的二人才能看到聊天信息，其他用户和服务器无法看到。

9. 错误的私聊
私聊自己会得到一个错误提示

私聊不存在的用户也会得到一个错误提示

10. 更名

11. 帮助

12. 非法指令
非法指令会给出错误提示。

13. 非法的指令参数

14. 连接服务器失败

六、心得体会
这次实现我深入研究了select模型的使用，完成了一个简易的聊天室。这次试验也使我在编程技巧方面也有了很大的提高。

七、完整代码
Charserverd.cpp 服务器main函数文件
#include "ChatServer.h"
#include "SockException.h"
#include "InitSock.h"
#include
using namespace std;

InitSock initSock;

int main(int argc, char* argv[])
{
if (argc < 2)
{
cout << "Usage:" << argv[0] << " Port " << endl;
return 1;
}
ChatServer charServer(atoi(argv[1]));
try
{
charServer.Start();
}
catch (SockException& e)
{
cout << e.GetErrorInfo() << endl;
cout << "[System Error]Error Code:" << e.GetErrorCode() << endl;
}
}
ChatServer.h 服务器类头文件
#ifndef CHAT_SERVER_H
#define CHAT_SERVER_H

#include
#include
#include

#include "ClientInfo.h"
using namespace std;

class ChatServer
{
public:
void Start();
void End();

ChatServer(int nPort);
~ChatServer(void);

private:
void InitFDSocket();

void DoSelect();
void DoFDRead(SOCKET sRead);

void RecvNewConnect();
string IPAddrToString(sockaddr_in sin);
void AddClientToInfoMap(ClientInfo info);

void RecvNewMessage();

bool IsCommand(string str);
void DoCommand(string cmd);
void ResoveCommand(string cmd, int& argc, string argv[]);
void DoCmdName(int argc, string argv[]);
void DoCmdGetUsers(int argc, string argv[]);
void DoMessage(string msg);
void DoCmdPrivateMsg(int argc, string argv[]);
string BuildMessage(string str, bool bIsPublic);
string BuildSystemMsg(string str);
void DispatchMessage(string msg);

void CloseConnect();

string IntToString(int nNum);
//============简单封装底层原语============

void InitListenSocket();
void Bind();
void Listen() ;
int Select();
int Recv(char msgBuff[]);
void Send(string msg, SOCKET client);
SOCKET Accept(sockaddr_in& sin);

//==========================================

private:
map m_clients;
fd_set m_fdSocket;
fd_set m_fdRead;
SOCKET m_sListen;
SOCKET m_sNowClient;
int m_nPort;

};

#endif CHAT_SERVER_H

ChatServer.cpp 服务器类
#include
#include
#include "ChatServer.h"
#include "SockException.h"

#pragma comment(lib, "ws2_32.lib")
using namespace std;

#define MAX_BUFF_SIZE 500
typedef map::iterator map_it;

ChatServer::ChatServer(int nPort)
{
this->m_nPort = nPort;
}

void ChatServer::Start()
{
InitListenSocket();
Bind();
Listen();
InitFDSocket();
while (true)
{
DoSelect();
}
}
void ChatServer::DoSelect()
{
m_fdRead = m_fdSocket;
int nRet = Select();
if (nRet > 0)
{
for (int i = 0; i < m_fdRead.fd_count; i++)
{
DoFDRead(m_fdRead.fd_array[i]);
}
}
}

void ChatServer::DoFDRead(SOCKET sRead)
{
if (sRead == m_sListen)
{
RecvNewConnect();
}
else
{
m_sNowClient = sRead;
RecvNewMessage();
}
}

void ChatServer::RecvNewConnect()
{
if (m_fdSocket.fd_count >= FD_SETSIZE)
{
cout << "[System Info]接受连接达到上限，拒绝连接"<< endl;
return;
}
sockaddr_in clientAddr;
m_sNowClient = Accept(clientAddr);
ClientInfo clientInfo(clientAddr);
cout << "[System Info]接受来自"<< clientInfo.GetIp() << "的连接" << endl;

FD_SET(m_sNowClient, &m_fdSocket);
AddClientToInfoMap(clientInfo);
}

string ChatServer::IPAddrToString(sockaddr_in sin)
{
string str = inet_ntoa(sin.sin_addr);
str.append(":");
char szFormat[20];
strappend(ltoa( ntohs(sin.sin_port),szFormat,10));
return str;
}

void ChatServer::AddClientToInfoMap(ClientInfo info)
{
m_clients[m_sNowClient] = info;
}

void ChatServer::RecvNewMessage()
{
char msgBuff[MAX_BUFF_SIZE];
int nRet = Recv(msgBuff);
string msg(msgBuff);
if (nRet <= 0) return;

if (IsCommand(msg))
{
DoCommand(msg);
}
else
{
DoMessage(msg);
}

}

void ChatServer::DoCommand(string cmd)
{
int argc;
string argv[100];
ResoveCommand(cmd, argc, argv);
if (argv[0] == "name")
{
DoCmdName(argc, argv);
}
else if (argv[0] == "list")
{
DoCmdGetUsers(argc, argv);
}
else if(argv[0] == "m")
{
DoCmdPrivateMsg(argc, argv);
}
else
{
Send("【系统消息】命令不存在，请使用 /help 命令查看命令帮助", m_sNowClient);
}
}

void ChatServer::ResoveCommand(string cmd, int& argc, string argv[])
{
int count = 0;
for(int i = 1; i < cmd.size(); i++)
{
char c = cmd.at(i);
if (c != ' ')
{
argv[count] += c;
}
else
{
count ++;
}
}
argc = ++count;
}
void ChatServer::DoCmdGetUsers(int argc, string argv[])
{
if (argc != 1)
{
return;
}
string msg;
string online = IntToString(m_clientssize());
msg.append("【系统消息】在线人数共" + online + "人:");
msg.append( "\n\r");
map_it begin = m_clients.begin();
map_it end = m_clients.end();
for (; begin != end; ++begin)
{
msg.append("\t" + begin->second.GetName() + " " + begin->second.GetIp());
msg.append(" UID:" + IntToString((int)begin->first));
msg.append("\n\r");
}
Send(msg, m_sNowClient);
}

void ChatServer::DoCmdName(int argc, string argv[])
{
if (argc != 2)
{
Send("【系统消息】命令格式错误 USAGE: /name 你的昵称", m_sNowClient);
return;
}
string name = argv[1];
m_clients[m_sNowClient].SetName(name);
Send"【系统消息】昵称已修改为:" + name, m_sNowClient);

}

void ChatServer::DoMessage(string str)
{
string msg = BuildMessage(str, true);
cout << msg << endl;
DispatchMessage(msg);
}
/*
string ChatServer::BuildMssage(string str)
{
ClientInfo info = m_clients[m_sNowClient];
string name = info.GetName();
string ip = info.GetIp();
string msg = name;
if (name != ip)
{
msg.append("(" + ip + ")");
}
char buff[10];
string id(itoa((int)m_sNowClient, buff, 10));
msg.append(" UID:" + id);
msg.append(" 说：");
msg.append("\n\r ");
msg.append(str);
return msg;
}
*/
string ChatServer::BuildSystemMsg(string str)
{
string msg("【系统消息】");
msg.append(str);
return msg;
}
string ChatServer::BuildMessage(string str, bool bIsPublic)
{
ClientInfo info = m_clients[m_sNowClient];
string name = info.GetName();
string ip = info.GetIp();
string uid = IntToString(int)m_sNowClient);
string msg(name);
if (ip != name && bIsPublic == true)
{
msg.append("(" + ip + ")");
}
msg.append(" ");
msg.append("UID:" + uid);
msg.append(" ");
bIsPublic ? msg.append("说：") : msg.append("悄悄地对你说：");
msg.append("\n\r");
msg.append(" ");
msg.append(str);
return msg;
}

void ChatServer::DoCmdPrivateMsg(int argc, string argv[])
{
if (argc < 3)
{
Send("【系统消息】命令格式错误 USAGE: /m 目标UID 私聊内容", m_sNowClient);
return;
}

SOCKET s = (SOCKET)atoi(argv[1].c_str());
map_it it = m_clients.find(s);
if (it == m_clients.end())
{
Send("系统消息】该用户不存在", m_sNowClient);
return;
}
if (it->first == m_sNowClient)
{
Send("【系统消息】您不能和自己私聊", m_sNowClient);
return;
}
string name = it->second.GetName();
string uid = IntToString(s);
string toDest = BuildMessage("", false);
string toSrc = string("你悄悄地对 " + name + " UID:" uid + " 说:\n\r ");
string other;
for (int i = 2; i < argc; i++)
{
other.append(argv[i]);
other.append(" ");
}
Send(toDest + other, s);
Send(toSrc + other, m_sNowClient);
}

void ChatServer::DispatchMessage(string msg)
{
map_it begin = m_clients.begin();
map_it end = m_clients.end();
for (; begin != end; ++begin)
{
Send(msg, begin->first);
}
}
bool ChatServer::IsCommand(string str)
{
if (str.at(0) == '/')
{
return true;
}
else
{
return false;
}
}

void ChatServer::CloseConnect()
{
cout << "[System Info]来自" << m_clients[m_sNowClient].GetIp() << "的连接已断开" << endl;
closesocket(m_sNowClient);
FD_CLR(m_sNowClient,&m_fdSocket);
}

void ChatServer::InitFDSocket()
{
FD_ZERO(&m_fdSocket);
FD_SET(m_sListen, &m_fdSocket);
}

void ChatServer::InitListenSocket()
{
m_sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)