• 【项目】基于TCP的聊天系统

    目录

    1.整体思想

    2.数据库管理模块

    1. 数据库表的创建

    2.对于数据库的操作

    2.1 对数据库连接

    2.2 数据库语句执行

    2.3 获取查询数据库的结果集

    2.json数据格式

    3.具体代码实现

    3.1用户管理模块

    3.2消息队列

    3.3 数据格式

    3.4 服务端

    3.5客户端：

    码云地址：聊天室 · 月半木斤/项目 - 码云 - 开源中国 (gitee.com)

    项目演示：

    首先来演示一下我们的项目最终完工的样子：

    TCP聊天室系统功能展示

    1.整体思想

    对于聊天室这个项目的整体思想很简单就是客户端向服务端来发送消息由服务端来处理业务向另外的客户端来推送消息，那么我们为什么不能直接两个客户端之间来进行通信呢？这个原因很简单因为如果客户端之间互相发送消息那么只能支持两个用户之间通信，因为tcp通信之前要先建立连接。所以这里我们采用客户端和服务端的方式来实现tcp通信。项目整体的流程图：

    2.数据库管理模块

    数据库管理模块主要为用户管理模块提供操作数据库的接口函数。因为我们的数据库就是用来存放数据的。那么数据库管理模块只要可以将数据库中的数据进行操作，查询等等就完成了数据库管理模块的任务。所以我们先来看一些关于数据库操作的函数。

    1. 数据库表的创建

    这里创建了三张表：user，friendinfo，buf。分别用来存放用户信息，用户好友信息，服务端下线缓存信息。

    2.对于数据库的操作

    对于在代码中对于数据库的操作本有以下几个方面：首先包含头文件

    2.1 对数据库连接

    2.2 数据库语句执行

    2.3 获取查询数据库的结果集

    （简而言之就是将你刚刚对数据库操作的结果保存到一个空间中，然后我们可以对其结果进行一系列的处理，这里可以类比你在数据库中执行了当前语句，然后对于你查询的结果进行操作）

    这些就是本项目中用到的一些关于数据库的基本操作。

    2.json数据格式

    在本项目中数据的组织形式采用了json的格式。这里简单介绍一下json（真的是简单介绍，本人也只懂一个皮毛）

    这是百度百科对于json的描述：JSON（JavaScript Object Notation, JS对象简谱）是一种轻量级的数据交换格式。它基于 ECMAScript（European Computer Manufacturers Association, 欧洲计算机协会制定的js规范）的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。我对于json的理解json就是一个对象。而且这个对象中可以以键值对的方式来任意存储任何类型的数据。包括自己也就是json对象。那么这里来简单的

    json对象由'{}'包裹，数组由[]，我们来几个例子演示一下：

    添加对象：数组形式：

    这就是最基本的格式，当然json中也提供了许多成员函数，包括size等等和STL中的容器类似。这里读者可以自行实验。多种组合。本项目中我们只用到其简单的组织数据。所以掌握这些知识足以。那么接下来就是几个模块的代码

    3.具体代码实现

    3.1用户管理模块

    1.初始化数据库：主要实现对于数据库的连接和设置数据库属性

    1. 	bool MysqlInit(){
    2. 		mysql_ = mysql_init(NULL);
    3. 		if (mysql_ == NULL){
    4. 			std::cout << "mysql init failed" << std::endl;
    5. 			return false;
    6. 		}
    7.  
    8. 		if (mysql_real_connect(mysql_, HOST, USER, PASSWD, DB, DBPORT, NULL, 0) == NULL){
    9. 			std::cout << "msyql connect failed" << std::endl;
    10. 			mysql_close(mysql_);
    11. 			return false;
    12. 		}
    13.  
    14. 		mysql_set_character_set(mysql_, "utf8");
    15. 		return true;
    16. 	}

    2.获取全部用户信息：这里我们获取全部好友信息是为了给用户管理模块进行调用从而让用户管理模块将所有的用户信息管理起来，方便对于每个用户进行操作。

    1. bool GetAllUser(Json::Value* all_user){
    2. #define GETALLUSER "select * from user;"
    3.         lock_.lock();
    4.         //这里查询结果集的时候如果有多个线程同时调用不同的函数那么查询的时候结果集中可能就保存的不是我们想要的
    5. 		//1.数据库查询
    6. 		if (MysqlQuery(GETALLUSER) == false){
    7.         lock_.unlock();
    8. 			return false;
    9. 		}
    10.  
    11. 		//2.获取结果集
    12. 		MYSQL_RES* res = mysql_store_result(mysql_);
    13. 		if (res == NULL){
    14.         lock_.unlock();
    15. 			return false;
    16. 		}
    17.         lock_.unlock();
    18. 		//3.获取单行数据
    19. 		int row_nums = mysql_num_rows(res);
    20. 		for (int i = 0; i < row_nums; i++){
    21. 			MYSQL_ROW row = mysql_fetch_row(res);
    22. 			//4.将单行数据按照格式， 组织起来。 传递给调用者
    23. 			Json::Value tmp;
    24. 			tmp["userid"] = atoi(row[0]);
    25. 			tmp["nickname"] = row[1];
    26. 			tmp["school"] = row[2];
    27. 			tmp["telnum"] = row[3];
    28. 			tmp["passwd"] = row[4];
    29. 			all_user->append(tmp);
    30. 		}
    31.  
    32. 		mysql_free_result(res);
    33. 		return true;
    34. 	}

    获取一个用户的所有好友信息，这里我们获取一个用户的所有好友信息是为了在后面的客户端模块来和好友发送消息，并展示。

    1. bool GetFriend(int userid, std::vector<int>* f_id){
    2. #define GETFRIEND "select friend from friendinfo where userid='%d';"
    3.  
    4. 		//1.格式化sql语句
    5. 		char sql[1204] = { 0 };
    6. 		sprintf(sql, GETFRIEND, userid);
    7.  
    8.         lock_.lock();
    9. 		//2.查询
    10. 		if (MysqlQuery(sql) == false){
    11.         lock_.unlock();
    12. 			return false;
    13. 		}
    14.  
    15. 		//3.获取结果集
    16. 		MYSQL_RES* res = mysql_store_result(mysql_);
    17. 		if (res == NULL){
    18.         lock_.unlock();
    19. 			return false;
    20. 		}
    21.         lock_.unlock();
    22. 		//4.获取单行数据
    23. 		int row_nums = mysql_num_rows(res);
    24. 		for (int i = 0; i < row_nums; i++){
    25. 			MYSQL_ROW row = mysql_fetch_row(res);
    26. 			f_id->push_back(atoi(row[0]));
    27. 		}
    28.  
    29. 		mysql_free_result(res);
    30. 		return true;
    31. 	}

    插入用户信息：用于用户注册的时候插入用户的

    1. 	bool InsertUser(int userid, const std::string& nickname
    2. 		, const std::string& school, const std::string& telnum
    3. 		, const std::string& passwd){
    4. #define INSERTUSER "insert into user(userid, nickname, school, telnum, passwd) values('%d', '%s', '%s', '%s', '%s');"
    5.  
    6. 		char sql[1024] = { 0 };
    7. 		sprintf(sql, INSERTUSER, userid, nickname.c_str(), school.c_str(), telnum.c_str(), passwd.c_str());
    8. 		std::cout << "Insert User: " << sql << std::endl;
    9.  
    10. 		//2.这里执行插入语句
    11. 		if (MysqlQuery(sql) == false){
    12. 			return false;
    13. 		}
    14. 		return true;
    15. 	}
    • 添加好友，将当前用户和要添加的好友的用户都插入好友信息表中维护两人的好友关系。 
      1. bool InsertFriend(int userid1, int userid2){
      2. #define INSERTFRIEND "insert into friendinfo values('%d', '%d');"
      3. 		char sql[1024] = { 0 };
      4. 		sprintf(sql, INSERTFRIEND, userid1, userid2);
      5.  
      6. 		//2.插入语句
      7. 		if (MysqlQuery(sql) == false){
      8. 			return false;
      9. 		}
      10. 		return true;
      11. 	}
    • 数据库操作函数：将要执行的命令传入即可对数据库进行相应的操作。 
      1. 	bool MysqlQuery(const std::string& sql){
      2. 		if (mysql_query(mysql_, sql.c_str()) != 0){
      3. 			std::cout << "exec failed sql: " << sql << std::endl;
      4. 			return false;
      5. 		}
      6. 		return true;
      7. 	}

    • 3.2消息队列

    • 这里的消息队列很简单就是将消息要发送的或者要接收的，数据存入一个线程安全队列中，如果要获取那么就获取，如果要插入就插入。底层用STl库中的队列来实现，对于队列的入队和出队都加锁保护。 
      1. #include
      2. #include
      3. #include
      4. #define CAPACITY 10000
      5. //线程安全队列用来存放从客户端发送来的消息或是从服务端发送来的消息
      6. //
      7. using std::queue;
      8. using std::cout;
      9. using std::endl;
      10. template<class T>
      11. class MsgQueue
      12. {
      13.     public:
      14.         MsgQueue()
      15.         {
      16.             _capacity=CAPACITY;
      17.             pthread_mutex_init(&con_lock,NULL);
      18.             pthread_cond_init(&cons_cond,NULL);
      19.             pthread_cond_init(&prod_cond,NULL);
      20.         }
      21.         
      22.         ~MsgQueue()
      23.         {
      24.             pthread_mutex_destroy(&con_lock);
      25.             pthread_cond_destroy(&cons_cond);
      26.             pthread_cond_destroy(&prod_cond);
      27.         }
      28.         void Push(const T& msg)
      29.         {
      30.             pthread_mutex_lock(&con_lock);
      31.             //这里用循环而不用if判断是因为下面这种情况：当生产者线程A被唤醒后，同时生产者b也被唤醒了那么他们都要执行push语句，那么这里如果容量已经是CAPACIT-1那么生成者线程B先push那么A再往队列中进行插入那么就会导致容量越界。
      32.             while(_con.size()>=_capacity)
      33.             {
      34.                 pthread_cond_wait(&prod_cond,&con_lock);
      35.             }
      36.             
      37.             _con.push(msg);
      38.             pthread_cond_signal(&cons_cond);//唤醒消费者线程
      39.             pthread_mutex_unlock(&con_lock);//这里如果先唤醒然后在解锁会怎么样？？？？？？？？？？？？？？？？？好像不会怎么样
      40.             pthread_cond_signal(&cons_cond);//唤醒消费者线程
      41.         }
      42.         void Pop(T* msg)
      43.         {
      44.             pthread_mutex_lock(&con_lock);
      45.             while(_con.empty())
      46.             {
      47.                 pthread_cond_wait(&cons_cond,&con_lock);
      48.             }
      49.             *msg=_con.front();
      50.             _con.pop();
      51.             pthread_mutex_unlock(&con_lock);//这里如果先唤醒然后在解锁会怎么样？？？？？？？？？？？？？？？？？好像不会怎么样
      52.             pthread_cond_signal(&prod_cond);//唤醒消费者线程
      53.         }
      54.         bool Empty()
      55.         {
      56.             return _con.empty();
      57.         }
      58.     private:
      59.         queue _con;
      60.         size_t _capacity;
      61.         pthread_mutex_t con_lock;//线程锁
      62.         pthread_cond_t cons_cond;//消费者条件变量
      63.         pthread_cond_t prod_cond;//生产者条件变量
      64. };

    • 3.3 数据格式

    • 这里的数据格式是一个类，成员变量有四个，sockfd_用来保存数据要发送方的套接字，msg_type_标明了当前的消息类型，user_id_不是固定的这里需要根据场景自己来组织user_id_，reply_status_用来标明回复的状态主要用于给客户端回复消息使用。json_msg_是json对象自由度最高的一个成员变量，可以根据消息的用途来自定义消息。
      1. #pragma once
      2. #include 
      3. #include 
      4. #include 
      5. #include 
      6.  
      7. #define TCP_DATA_MAX_LEN 1024
      8. #define TCP_PORT 38989
      9. //当前文件用来实现发送消息的格式：
      10.  
      11. enum chat_msg_type{
      12. 	Register = 0, //0， 注册请求
      13. 	Register_Resp, //1， 注册应答
      14. 	Login,   //2. 登录请求
      15. 	Login_Resp, //3， 登录应答
      16. 	AddFriend, //4， 添加好友请求
      17. 	AddFriend_Resp, //5， 添加好友请求应答
      18. 	SendMsg, //6， 发送消息
      19. 	SendMsg_Resp, //7， 发送消息应答
      20. 	PushMsg, //8， 推送消息
      21. 	PushMsg_Resp, //9， 推送消息应答
      22. 	PushAddFriendMsg, //10， 推送添加好友请求
      23. 	PushAddFriendMsg_Resp, //11， 推送添加好友请求的应答 
      24. 	GetFriendMsg, //12， 获取全部好友信息
      25. 	GetFriendMsg_Resp, //13， 获取全部好友信息应答
      26. 	SetUserOffLine //14
      27. 	//后续如果要增加业务， 可以在后面增加其他的消息类型
      28. };
      29.  
      30. enum reply_status{
      31. 	REGISTER_SUCCESS = 0, //0, 注册成功
      32. 	REGISTER_FAILED, //1，注册失败
      33. 	LOGIN_SUCESSS, //2， 登录成功
      34. 	LOGIN_FAILED,  //3， 登陆失败
      35. 	ADDFRIEND_SUCCESS, //4， 添加好友成功
      36. 	ADDFRIEND_FAILED, //5， 添加好友失败
      37. 	SENDMSG_SUCCESS, //6， 发送消息成功
      38. 	SENDMSG_FAILED, //7， 发送给消息失败
      39. 	GETFRIEND_SUCCESS, //8，获取好友列表成功
      40. 	GETFRIEND_FAILED  //9， 获取好友列表失败
      41. };
      42.  
      43. /*
      44. * 注册请求的消息格式
      45. * 注册的时候我们需要将个人用户的所有信息都获取得到
      46. *   sockfd_ (消息达到服务端之后， 由服务端接收之后， 打上sockfd_)
      47. *   msg_type_ : Register
      48. *   json_msg: {
      49. *      nickname : 'xxx'
      50. *      school : "xxx"
      51. *      telnum : "xxxx"
      52. *      passwd : "xxxx"
      53. *   }
      54. *
      55. * 注册的应答：
      56. *   msg_type_ : Register_Resp
      57. *   reply_status_ = REGISTER_SUCCESS / REGISTER_FAILED
      58. *      如果是REGISTER_SUCCESS : [user_id_]
      59. *
      60. *
      61. *
      62. * 登录的请求消息格式
      63. *   sockfd_ (消息达到服务端之后， 由服务端接收之后， 打上sockfd_)
      64. *   msg_type_ : Login
      65. *   json_msg_ : {
      66. *      telnum : xxx
      67. *      passwd : xxx
      68. *   }
      69. *
      70. *   登录的应答：
      71. *   msg_type : Login_Resp;
      72. *   reply_status_ : LOGIN_SUCCESS/LOGIN_FAILED
      73. *       如果是LOGIN_SUCCESS : [user_id_]
      74. *
      75. *
      76. *
      77. * 添加好友请求：
      78. *    msg_type_ : AddFriend
      79. *    json_msg_ :{
      80. *      fri_tel_num : xxxx
      81. *    }
      82. *
      83. *
      84. *  推送添加好友的请求
      85. *      msg_type : PushAddFriendMsg
      86. *      sockfd_ : 被添加方的套接字描述符
      87. *      json_msg_: {
      88. *          adder_nickname : xxx
      89. *          adder_school : xxx
      90. *          adder_userid : xxx
      91. *      }
      92. *
      93. * 推送添加好友的应答（被添加方发送给服务端的）
      94. *     msg_type : PushAddFriendMsg_Resp
      95. *     user_id : 被添加方的id
      96. *     reply_status : ADDFRIEND_SUCCESS / ADDFRIEND_FAILED
      97. *         如果说是ADDFRIEND_SUCCESS
      98. *             json_msg_ : 添加方的id
      99. *
      100. *  添加好友的应答：
      101. *      msg_type: AddFriend_Resp
      102. *      reply_status : ADDFRIEND_FAILED / ADDFRIEND_SUCCESS
      103. *          如果是成功：ADDFRIEND_SUCCESS
      104. *             json_msg_ :
      105. *                 BeAdd_nickname : 被添加方的名字
      106. *                 BeAdd_school ： 被添加方的学校
      107. *                 BeAdd_userid : 被添加方的id
      108. * */
      109. class JsonUtil{
      110. public:
      111.     /*
      112.      * 用来序列化我们要发送的json串将其序列化为string类
      113.      * */
      114. 	static bool Serialize(const Json::Value& value, std::string* body) {
      115. 		Json::StreamWriterBuilder swb;
      116. 		std::unique_ptr sw(swb.newStreamWriter());
      117.  
      118. 		std::stringstream ss;
      119. 		int ret = sw->write(value, &ss);
      120. 		if (ret != 0) {
      121. 			return false;
      122. 		}
      123. 		*body = ss.str();
      124. 		return true;
      125. 	}
      126.     /*
      127.      * 反序列化
      128.     * */
      129. 	static bool UnSerialize(const std::string& body, Json::Value* value) {
      130. 		Json::CharReaderBuilder crb;
      131. 		std::unique_ptr cr(crb.newCharReader());
      132.  
      133. 		std::string err;
      134. 		bool ret = cr->parse(body.c_str(), body.c_str() + body.size(), value, &err);
      135. 		if (ret == false) {
      136. 			return false;
      137. 		}
      138. 		return true;
      139. 	}
      140. };
      141.  
      142.  
      143. //其中的成员变量有sockfd用来存放TCP套接字
      144. //还有消息类型msg_type用来表示消息是什么类型的
      145. //user_id_用来存放用户的id
      146. //repl_satus恢复状态
      147. class ChatMsg{
      148. public:
      149. 	ChatMsg(){
      150. 		sockfd_ = -1;
      151. 		msg_type_ = -1;
      152. 		user_id_ = -1;
      153. 		reply_status_ = -1;
      154. 		json_msg_.clear();
      155. 	}
      156.  
      157. 	~ChatMsg(){}
      158.  
      159. 	/*
      160. 	* 提供反序列化的接口, 接收完毕请求之后进行反序列化
      161.     * 这里的反序列化接口提供参数sockfd需要我们在处理各种业务的时候需要从消息队列中获取
      162. 	* */
      163. 	int PraseChatMsg(int sockfd, const std::string& msg){
      164. 		//1.调用jsoncpp的反序列化接口
      165. 		Json::Value tmp;
      166. 		bool ret = JsonUtil::UnSerialize(msg, &tmp);
      167. 		if (ret == false){
      168. 			return -1;
      169. 		}
      170. 		//2.赋值给成员变量
      171. 		sockfd_ = sockfd;
      172. 		msg_type_ = tmp["msg_type"].asInt();
      173. 		user_id_ = tmp["user_id"].asInt();
      174. 		reply_status_ = tmp["reply_status"].asInt();
      175. 		json_msg_ = tmp["json_msg"];
      176. 		return 0;
      177. 	}
      178.  
      179.  
      180. 	/*
      181. 	* 提供序列化的接口 - 回复应答的时候使用
      182. 	*     msg ： 出参， 用于获取序列化完毕的字符串
      183.     *     序列化就是我们将要发送的对象转化为json串之后通过json中的序列化函数将我们转化的json串转化为string
      184.     * */
      185.  
      186. 	bool GetMsg(std::string* msg){
      187. 		Json::Value tmp;
      188. 		tmp["msg_type"] = msg_type_;
      189. 		tmp["user_id"] = user_id_;
      190. 		tmp["reply_status"] = reply_status_;
      191. 		tmp["json_msg"] = json_msg_;
      192. 		return JsonUtil::Serialize(tmp, msg);
      193. 	}
      194.  
      195. 	/*
      196. 	* 获取json_msg_当中的value值
      197. 	* */
      198. 	std::string GetValue(const std::string& key){
      199. 		if (!json_msg_.isMember(key)){
      200. 			return "";
      201. 		}
      202. 		return json_msg_[key].asString();
      203. 	}
      204.  
      205. 	/*
      206. 	* 设置json_msg_当中的kv键值对
      207. 	* */
      208.  
      209. 	void SetValue(const std::string& key, const std::string& value){
      210. 		json_msg_[key] = value;
      211. 	}
      212.  
      213. 	void SetValue(const std::string& key, int value){
      214. 		json_msg_[key] = value;
      215. 	}
      216. 	void Clear(){
      217. 		msg_type_ = -1;
      218. 		user_id_ = -1;
      219. 		reply_status_ = -1;
      220. 		json_msg_.clear();
      221. 	}
      222. public:
      223. 	//存放的客户端文件名描述符， 方便发送线程， 通过该字段将数据发送给对应的客户端
      224. 	int sockfd_;
      225.  
      226. 	//消息类型
      227. #if 0
      228. 	enum chat_msg_type{
      229. 		Register = 0, //0， 注册请求
      230. 		Register_Resp, //1， 注册应答
      231. 		Login,   //2. 登录请求
      232. 		Login_Resp, //3， 登录应答
      233. 		AddFriend, //4， 添加好友请求
      234. 		AddFriend_Resp, //5， 添加好友请求应答
      235. 		SendMsg, //6， 发送消息
      236. 		SendMsg_Resp, //7， 发送消息应答
      237. 		PushMsg, //8， 推送消息
      238. 		PushMsg_Resp, //9， 推送消息应答
      239. 		PushAddFriendMsg, //10， 推送添加好友请求
      240. 		PushAddFriendMsg_Resp, //11， 推送添加好友请求的应答 
      241. 		GetFriendMsg, //12， 获取全部好友信息
      242. 		GetFriendMsg_Resp //13， 获取全部好友信息应答
      243. 	};
      244. #endif
      245. 	int msg_type_;
      246.  
      247. 	//用户id
      248. 	int user_id_;
      249.  
      250. 	//应答的状态
      251. #if 0
      252. 	enum reply_status{
      253. 		REGISTER_SUCCESS = 0, //0, 注册成功
      254. 		REGISTER_FAILED, //1，注册失败
      255. 		LOGIN_SUCESSS, //2， 登录成功
      256. 		LOGIN_FAILED,  //3， 登陆失败
      257. 		ADDFRIEND_SUCCESS, //4， 添加好友成功
      258. 		ADDFRIEND_FAILED, //5， 添加好友失败
      259. 		SENDMSG_SUCCESS, //6， 发送消息成功
      260. 		SENDMSG_FAILED, //7， 发送给消息失败
      261. 		GETFRIEND_SUCCESS, //8，获取好友列表成功
      262. 		GETFRIEND_FAILED  //9， 获取好友列表失败
      263. 	};
      264. #endif
      265. 	int reply_status_;
      266.  
      267. 	/*
      268. 	* Json消息
      269. 	*   json消息的内容会随着消息类型的不同， 字段不一样
      270. 	* */
      271. 	Json::Value json_msg_;
      272. };

    • 3.4 服务端

    • 服务端大致就是分为epoll监视线程，发送线程，工作线程，缓存线程。
    • 1.epoll监视线程当获取就绪事件的时候就将其存放到缓存队列中： 
      1. 	static void* epoll_wait_start(void* arg){
      2. 		pthread_detach(pthread_self());
      3. 		ChatServer* cs = (ChatServer*)arg;
      4. 		while (EXIT_SIGNALLL){
      5. 			struct epoll_event arr[10];
      6. 			int ret = epoll_wait(cs->epoll_fd_, arr, sizeof(arr) / sizeof(arr[0]), -1);
      7. 			if (ret < 0){
      8. 				continue;
      9. 			}
      10.  
      11. 			//正常获取了就绪的事件结构, 一定全部都是新连接套接字
      12. 			for (int i = 0; i < ret; i++){
      13. 				char buf[TCP_DATA_MAX_LEN] = { 0 };
      14. 				//隐藏的问题： TCP粘包
      15. 				ssize_t recv_size = recv(arr[i].data.fd, buf, sizeof(buf)-1, 0);
      16. 				if (recv_size < 0){
      17. 					//接收失败了
      18. 					std::cout << "recv failed : sockfd is " << arr[i].data.fd << std::endl;
      19. 					continue;
      20. 				}
      21. 				else if (recv_size == 0){
      22. 					//对端关闭连接了
      23. 					epoll_ctl(cs->epoll_fd_, EPOLL_CTL_DEL, arr[i].data.fd, NULL);
      24. 					close(arr[i].data.fd);
      25. 					cs->user_mana_->SetUserOffLine(arr[i].data.fd);//将用户状态改为下线OFFLINE
      26. 					continue;
      27. 				}
      28.  
      29. 				printf("epoll_wait_start recv msg : %s  from sockfd is %d\n", buf, arr[i].data.fd);
      30. 				//正常接收回来了, 将接收回来的数据放到接收线程的队列当中， 等到工作线程从队列当中获取消息， 进而进行处理
      31. 				//3.将接收到的数据放到接收队列当当中
      32. 				std::string msg;
      33. 				msg.assign(buf, strlen(buf));
      34.  
      35. 				ChatMsg cm;
      36. 			    cm.PraseChatMsg(arr[i].data.fd, msg);
      37.  
      38. 				cs->recv_que_->Push(cm);
      39. 			}
      40. 		}
      41. 		return NULL;
      42. 	}
    • 发送线程：就是从发送队列中无脑取消息然后发送即可 
      1. 	static void* send_msg_start(void* arg){
      2. 		pthread_detach(pthread_self());
      3. 		ChatServer* cs = (ChatServer*)arg;
      4.  
      5. 		while (EXIT_SIGNALLL){
      6. 			//1.从队列拿出数据
      7. 			ChatMsg cm;
      8. 			cs->send_que_->Pop(&cm);
      9.  
      10. 			std::string msg;
      11. 			cm.GetMsg(&msg);
      12. 			std::cout << "send thread: " << msg << std::endl;
      13.             
      14. 			//2.发送数据
      15. 			send(cm.sockfd_, msg.c_str(), msg.size(), 0);
      16. 		}
      17.  
      18. 		return NULL;
      19. 	}
    • 工作线程：对于客户端发送来的不同请求进行处理 
      1.  
      2. 	static void* deal_start(void* arg){
      3. 		pthread_detach(pthread_self());
      4. 		ChatServer* cs = (ChatServer*)arg;
      5.  
      6. 		while (EXIT_SIGNALLL){
      7. 			//1. 从接收队列当中获取消息
      8. 			ChatMsg cm;
      9. 			cs->recv_que_->Pop(&cm);
      10. 			//2. 通过消息类型分业务处理
      11. 			int msg_type = cm.msg_type_;
      12. 			switch (msg_type){
      13. 			case Register:{
      14. 			  cs->DealRegister(cm);
      15. 			  break;
      16. 			}
      17. 			case Login:{
      18. 			   cs->DealLogin(cm);
      19. 			   break;
      20. 			}
      21. 			case AddFriend:{
      22. 			   cs->DealAddFriend(cm);
      23. 			   break;
      24. 			}
      25. 			case PushAddFriendMsg_Resp:{
      26. 			   cs->DealAddFriendResp(cm);
      27. 			   break;
      28. 			}
      29. 			case SendMsg: {
      30. 			  cs->DealSendMsg(cm);
      31. 			  break;
      32. 			}
      33. 			case GetFriendMsg:{
      34. 			  cs->GetAllFriendInfo(cm);
      35. 			  break;
      36. 			}
      37. 			default:{
      38.      		  break;
      39. 			}
      40. 			}
      41.  
      42. 			//3. 组织应答
      43. 		}
      44. 		return NULL;
      45. 	}
    • 缓存线程：当客户端不在线的时候我们就可以将消息放入缓存队列中然后缓存线程来对其循环检测如果用户上线那么就更新套接字向其发送消息 
      1.     //缓存线程：当服务端程序跑开时我们就将数据库中存储的要发送的消息都加载到缓存队列中，然后我们的缓存线程就择机发送缓存队列中的消息
      2.     //这里会不会存在一个问题：当我们将消息从队列中拿出来但是这条消息要发送的客户端没有在线，但是这里我们还没来得及将消息重新放入缓存队列但是此时线程已经结束。导致我们无法向数据库中保存当前消息。????????????????
      3.     static void* cache_start(void* arg)
      4.     {
      5. 		pthread_detach(pthread_self());
      6. 		ChatServer* cs = (ChatServer*)arg;
      7.         while(EXIT_SIGNALLL)
      8.         {
      9.             if(cs->buf_que_->Empty())
      10.             {
      11.                 sleep(1);
      12.                 continue;
      13.             }
      14.             ChatMsg cm;
      15.             cs->buf_que_->Pop(&cm);
      16.             int user_id=-1;
      17.             if(cm.msg_type_==PushAddFriendMsg)
      18.             {
      19.                 //如果是PushAddfriendMsg类型消息那么我们这里还需要获取要发送的用户的id，从而获取它的套接字。
      20. 		        UserInfo be_add_ui;
      21. 		        cs->user_mana_->IsLogin(cm.GetValue("telnum"), &be_add_ui);
      22.                 user_id=be_add_ui.userid_;
      23.             }
      24.             else if(cm.msg_type_==AddFriend_Resp)
      25.             {
      26.                 user_id=atoi(cm.GetValue("userid").c_str());
      27.             }
      28.             else
      29.             {
      30.                 user_id=cm.user_id_;
      31.             }
      32.             if(cs->user_mana_->IsLogin(user_id)==ONLINE)
      33.             {//如果当前用户在线：更新套接字，放入发送队列发送消息//这里应该采用map的方式将一个用户id的消息按照id从前往后维护起来，发送的时候按照时间顺序发送
      34.                 sleep(1);
      35.                 int socket_fd=cs->user_mana_->getsockefd(user_id);
      36.                 if(socket_fd<0)
      37.                 {//如果返回值为-1那么就丢弃这条消息，因为用户中没有这个人
      38.                     continue;
      39.                 }
      40.                 cm.sockfd_=socket_fd;
      41.                 cs->send_que_->Push(cm);
      42.             }
      43.             else 
      44.             {//如果不在线：那么就将其在添加到缓存队列中
      45.                 cs->buf_que_->Push(cm);
      46.             }
      47.         }
      48.         return NULL;
      49.     }
    • 处理进程退出数据持久化，将数据存入数据库中。 
      1.     void dealexit()
      2.     {
      3.         //处理线程退出的时候情况：
      4.         //1.让所有的工作线程完成自己的任务
      5.         EXIT_SIGNALLL=0;//将退出信号置为0那么此时所有的工作线程都在完成自己的工作之后就退出
      6.         //将缓存队列中的消息都放到数据库中：
      7.         if(user_mana_->put_cachemsg(*buf_que_)==false)
      8.         {
      9.             std::cout<<"存入数据库失败"<//这句话用于调试
      10.         }
      11.         exit(1);
      12.     }

    3.5客户端：

    客户端这里我们用到了MFC编程：关于MFC在b站上的黑马程序员讲解的特别容易理解，这里就不多赘述了，可以去学习一下。这里给出客户端消息流转图：

     

     需要创建的窗口资源

     

     这里客户端看似复杂一点但是其实是很简单的，这里已经给了各个界面的布局和每个界面的功能，那么我们只要创建好相应的界面然后给每个界面的所有功能按键实现相应的代码，那么就可以完成我们的客户端。这里客户端向服务端组织消息的时候只要想着我们服务端完成的程序内容，按照其所需要的信息然后组织发送即可。一切都是水到渠成。还有服务端一定要从最低端写起也就是数据库管理模块到用户管理模块再到服务端管理模块，只要按照流程图细细分析一定可以写出。

    当然这里也附上整个项目的源码：

    码云地址：聊天室 · 月半木斤/项目 - 码云 - 开源中国 (gitee.com)

  • 相关阅读:
    {“Code“:“InvalidParameterValue.TemplateParameterFormatError“
    【车辆配送】基于模拟退火 (SA)求解车辆配送 （VPR） (Matlab代码实现）
    机房小探索
    学习笔记
    精选 JVM 垃圾回收机制全面分析，聊聊你眼中的 JVM
    Java配置49-nginx 反向代理 sftp 服务器
    Matlab数字图像处理 02 灰度变化（图像直方图、直方图均衡化、直方图匹配）
    最长递增子序列
    对话框管理器第八章：对话框中的自定义导航
    单片机学习笔记之点亮led 灯
  • 原文地址：https://blog.csdn.net/weixin_45897952/article/details/126250612