• 基于TCP的网络聊天系统

    目录

    一、前言

    二、产品的介绍

    1.产品具有的功能

    2.产品的各个模块

     3.使用的开发工具以及应用的技术

    三、产品的设计

    1.服务端

    1.1服务端总流程图

    1.2数据库及其管理模块设计

    1.3用户管理模块设计

    1.4业务模块设计

    1.5消息的操作

    1.6消息队列

    2.客户端

    2.1登录及注册消息流转图

    2.2注册界面

    2.3聊天界面及消息流转图

    2.4添加好友界面及消息流转

    四、产品的测试（视频演示）

    一、前言

    QQ和微信是现代人们生活中必不可少的一部分，身边几乎很难找到人不使用QQ或者微信等聊天工具吧！那么你想要亲手打造一款属于自己的聊天系统吗？那么让我们一起打造出一款自己专属的应用吧。

    二、产品的介绍

    1.产品具有的功能

    该聊天系统具有，登录，注册，添加好友，发送消息，四大功能。

    2.产品的各个模块

    3.使用的开发工具以及应用的技术

    a.开发工具：VS2019，MFC

    b.使用的技术：Socket编程，TCP网络通信，多线程，数据库，Json数据格式

    三、产品的设计

    1.服务端

    1.1服务端总流程图

    1.2数据库及其管理模块设计

    数据库表：因为我们需要保存用户以及用户好友的信息，所以我们至少需要维护两个数据库表

    friendInfo：保存用户好友信息的数据库表

    user：保存用户信息的数据库表

    管理数据库模块设计：

    • a.数据库表的初始化：bool MysqlInit()
    • b.获取所有用户的信息：bool GetAllUser(Json::Value* all_user)
    • c.获取用户好友信息：bool GetFriend(int userid, std::vector* f_id)
    • d.用户注册时向数据库插入用户的信息：bool InsertUser(int userid, const std::string& nickname
    • e.添加好友：bool InsertFriend(int userid1, int userid2)
    1. class DataBaseSvr{
    2.     public:
    3.         DataBaseSvr(){
    4.             mysql_ = NULL;
    5.         }
    6.  
    7.         ~DataBaseSvr(){
    8.             if(mysql_ != NULL){
    9.                 mysql_close(mysql_);
    10.             }
    11.         }
    12.  
    13.         /*
    14.          * 初始化mysql操作句柄， 并且连接后台mysql服务端， 设置字符集
    15.          * */
    16.         bool MysqlInit(){
    17.             mysql_ = mysql_init(NULL);
    18.             if(mysql_ == NULL){
    19.                 std::cout << "mysql init failed" << std::endl;
    20.                 return false;
    21.             }
    22.  
    23.             if(mysql_real_connect(mysql_, HOST, USER, PASSWD, DB, DBPORT,NULL, 0) == NULL){
    24.                 std::cout << "msyql connect failed" << std::endl;
    25.                 mysql_close(mysql_);
    26.                 return false;
    27.             }
    28.  
    29.             mysql_set_character_set(mysql_, "utf8");
    30.             return true;
    31.         }
    32.  
    33.         /*
    34.          * 获取 all user info, to usermanager model
    35.          *    参数为Json对象， 是一个出参
    36.          * */
    37.         bool GetAllUser(Json::Value* all_user){
    38. #define GETALLUSER "select * from user;"
    39.             lock_.lock();
    40.             //1.数据库查询
    41.             if(MysqlQuery(GETALLUSER) == false){
    42.                 lock_.unlock();
    43.                 return false;
    44.             }
    45.  
    46.             //2.获取结果集
    47.             MYSQL_RES* res = mysql_store_result(mysql_);
    48.             if(res == NULL){
    49.                 lock_.unlock();
    50.                 return false;
    51.             }
    52.             lock_.unlock();
    53.             //3.获取单行数据
    54.             int row_nums = mysql_num_rows(res);
    55.             for(int i = 0; i < row_nums; i++){
    56.                 MYSQL_ROW row = mysql_fetch_row(res);
    57.                 //4.将单行数据按照格式， 组织起来。 传递给调用者
    58.                 Json::Value tmp;
    59.                 tmp["userid"] = atoi(row[0]);
    60.                 tmp["nickname"] = row[1];
    61.                 tmp["school"] = row[2];
    62.                 tmp["telnum"] = row[3];
    63.                 tmp["passwd"] = row[4];
    64.                 all_user->append(tmp);
    65.             }
    66.  
    67.             mysql_free_result(res);
    68.             return true;
    69.         }
    70.  
    71.         /*
    72.          * 获取单个用户的好友信息， 在程序初始化阶段， 让用户管理模块维护起来
    73.          *    userid : 用户的id
    74.          *    f_id : 该用户的所有好友id
    75.          * */
    76.         bool GetFriend(int userid, std::vector<int>* f_id){
    77. #define GETFRIEND "select friend from friendinfo where userid='%d';"
    78.  
    79.             //1.格式化sql语句
    80.             char sql[1204] = {0};
    81.             sprintf(sql, GETFRIEND, userid);
    82.  
    83.             lock_.lock();
    84.             //2.查询
    85.             if(MysqlQuery(sql) == false){
    86.                 lock_.unlock();
    87.                 return false;
    88.             }
    89.  
    90.             //3.获取结果集
    91.             MYSQL_RES* res = mysql_store_result(mysql_);
    92.             if(res == NULL){
    93.                 lock_.unlock();
    94.                 return false;
    95.             }
    96.             lock_.unlock();
    97.             //4.获取单行数据
    98.             int row_nums = mysql_num_rows(res);
    99.             for(int i = 0; i < row_nums; i++){
    100.                 MYSQL_ROW row = mysql_fetch_row(res);
    101.                 f_id->push_back(atoi(row[0]));
    102.             }
    103.  
    104.             mysql_free_result(res);
    105.             return true;
    106.         }
    107.  
    108.         /*
    109.          *  当用户注册的时候， 进行插入使用的函数
    110.          * */
    111.         bool InsertUser(int userid, const std::string& nickname
    112.                 , const std::string& school, const std::string& telnum
    113.                 , const std::string& passwd){
    114. #define INSERTUSER "insert into user(userid, nickname, school, telnum, passwd) values('%d', '%s', '%s', '%s', '%s');"
    115.  
    116.             char sql[1024] = {0};
    117.             sprintf(sql, INSERTUSER, userid, nickname.c_str(), school.c_str(), telnum.c_str(), passwd.c_str());
    118.             std::cout << "Insert User: " << sql << std::endl;
    119.  
    120.             //2.查询
    121.             if(MysqlQuery(sql) == false){
    122.                 return false;
    123.             }
    124.             return true;
    125.         }
    126.  
    127.         /*
    128.          * 添加好友
    129.          * */
    130.         bool InsertFriend(int userid1, int userid2){
    131. #define INSERTFRIEND "insert into friendinfo values('%d', '%d');"
    132.             char sql[1024] = {0};
    133.             sprintf(sql, INSERTFRIEND, userid1, userid2);
    134.  
    135.             //2.查询
    136.             if(MysqlQuery(sql) == false){
    137.                 return false;
    138.             }
    139.             return true;
    140.         }
    141.  
    142.     private:
    143.         bool MysqlQuery(const std::string& sql){
    144.             if(mysql_query(mysql_, sql.c_str()) != 0){
    145.                 std::cout << "exec failed sql: " << sql << std::endl;
    146.                 return false;
    147.             }
    148.             return true;
    149.         }
    150.  
    151.  
    152.     private:
    153.         MYSQL* mysql_;
    154.         std::mutex lock_;
    155. };

    1.3用户管理模块设计

    用户信息类

    • 1.用户注册时的相关信息，nickname_，school_，telnum_,passwd_,userid_
    • 2.用户状态：user_status_
    • 3.登录的客户端对应的套接字描述符
    1. enum UserStatus{
    2.     OFFLINE, //0
    3.     ONLINE //1
    4. };
    5.  
    6. /*
    7.  * 用户信息类
    8.  * */
    9. class UserInfo{
    10.     public:
    11.         //注册的时候，
    12.         UserInfo(const std::string& nickname, const std::string& school, const std::string& telnum, const std::string& passwd, int userid){
    13.             nickname_ = nickname;
    14.             school_ = school;
    15.             telnum_ = telnum;
    16.             passwd_ = passwd;
    17.             userid_ = userid;
    18.             user_status_ = OFFLINE;
    19.             tcp_socket_ = -1;
    20.             friend_id_.clear();
    21.         }
    22.  
    23.         UserInfo(){
    24.  
    25.         }
    26.  
    27.         ~UserInfo(){
    28.  
    29.         }
    30.  
    31.     public:
    32.         std::string nickname_;
    33.         std::string school_;
    34.         std::string telnum_;
    35.         std::string passwd_;
    36.  
    37.         int userid_;
    38.         //用户状态 //OFFLINE ONLINE
    39.         int user_status_;
    40.         //登录的客户端对应的套接字描述符
    41.         int tcp_socket_;
    42.  
    43.         std::vector<int> friend_id_;
    44. };

    用户信息管理模块

    • a.初始化管理模块：bool InitUserMana()，调用数据库模块GetAllUser函数获取数据库中用户信息，并使用unordered_map管理起来
    • b.处理注册请求：int DealRegister(const std::string& nickname, const std::string& school, const std::string& tel, const std::string& passwd, int* userid)，组织用户信息，并插入到user_map_ 和数据库中。
    • c.处理用户登录请求：int DealLogin(const std::string& tel, const std::string& passwd, int sockfd)
    • d.判断当前用户的在线情况：int IsLogin(int userid)/int IsLogin(const std::string& telnum, UserInfo* ui)发送消息的时候需要判断对方在线与否
    • e.获取用户信息：bool GetUserInfo(int userid, UserInfo* ui)，通过出参带出
    • f.获取用户好友信息：bool GetFriends(int userid, std::vector* fri)，通过出参带出
    • g.添加好友：void SetFriend(int userid1, int userid2)
    • h.转变用户状态为下线： void SetUserOffLine(int sockfd)，客户端下线时使用
    1. class UserManager{
    2.     public:
    3.         UserManager(){
    4.             user_map_.clear();
    5.             pthread_mutex_init(&map_lock_, NULL);
    6.             //如果一开始就从0进行分配， 一定是不对的
    7.             //   因为用户管理类还会从数据库当中将已经存在的用户信息读回来
    8.             prepare_id_ = -1;
    9.             db_ = NULL;
    10.         }
    11.  
    12.         ~UserManager(){
    13.             pthread_mutex_destroy(&map_lock_);
    14.  
    15.             if(db_){
    16.                 delete db_;
    17.                 db_ = NULL;
    18.             }
    19.         }
    20.  
    21.         bool InitUserMana(){
    22.             //1.连接数据库
    23.             db_ = new DataBaseSvr();
    24.             if(db_ == NULL){
    25.                 printf("create db case failed\n");
    26.                 return false;
    27.             }
    28.  
    29.             if(db_->MysqlInit() == false){
    30.                 return false;
    31.             }
    32.             //2.查询所有用户信息， 维护起来
    33.             Json::Value all_user;
    34.             if(db_->GetAllUser(&all_user) == false){
    35.                 return false;
    36.             }
    37.  
    38.             for(int i = 0; i < (int)all_user.size(); i++){
    39.                 //个人信息
    40.                 UserInfo ui;
    41.                 ui.nickname_ = all_user[i]["nickname"].asString();
    42.                 ui.school_ = all_user[i]["school"].asString();
    43.                 ui.telnum_ = all_user[i]["telnum"].asString();
    44.                 ui.passwd_ = all_user[i]["passwd"].asString();
    45.                 ui.userid_ = all_user[i]["userid"].asInt();
    46.                 ui.user_status_ = OFFLINE;
    47.  
    48.                 //个人好友信息
    49.                 db_->GetFriend(ui.userid_, &ui.friend_id_);
    50.  
    51.                 pthread_mutex_lock(&map_lock_);
    52.                 user_map_[ui.userid_] = ui;
    53.                 if(ui.userid_ > prepare_id_){
    54.                     prepare_id_ = ui.userid_ + 1;
    55.                 }
    56.                 pthread_mutex_unlock(&map_lock_);
    57.             }
    58.  
    59.             return true;
    60.         }
    61.  
    62.         /*
    63.          * 处理用户注册
    64.          *     userid : 如果注册成功， 通过userid，告诉注册的客户端，他的id是什么
    65.          * */
    66.         int DealRegister(const std::string& nickname, const std::string& school, const std::string& tel, const std::string& passwd, int* userid){
    67.             //1.判断注册信息是否为空
    68.             if(nickname.size() == 0 || school.size() == 0 || tel.size() == 0 || passwd.size() == 0){
    69.                 *userid = -2;
    70.                 return -1;
    71.             }
    72.             //2.判断用户是否已经注册过了
    73.             pthread_mutex_lock(&map_lock_);
    74.             auto iter = user_map_.begin();
    75.             while(iter != user_map_.end()){
    76.                 if(iter->second.telnum_ == tel){
    77.                     *userid = -2;
    78.                     pthread_mutex_unlock(&map_lock_);
    79.                     return -1;
    80.                 }
    81.                 iter++;
    82.             }
    83.             //3.创建UserInfo， 分配userid, 保存用户信息
    84.             UserInfo ui(nickname, school, tel, passwd, prepare_id_);
    85.             *userid = prepare_id_;
    86.  
    87.             user_map_[prepare_id_] = ui;
    88.             prepare_id_++;
    89.             pthread_mutex_unlock(&map_lock_);
    90.             //4.插入到数据库当中
    91.             db_->InsertUser(ui.userid_, nickname, school, tel, passwd);
    92.             return 0;
    93.         }
    94.  
    95.         /*
    96.          * 处理登录请求
    97.          *    sockfd 是 服务端为登录客户端创建的新连接套接字
    98.          * */
    99.         int DealLogin(const std::string& tel, const std::string& passwd, int sockfd){
    100.             //1.判断字段是否为空
    101.             if(tel.size() == 0 || passwd.size() == 0){
    102.                 return -1;
    103.             }
    104.             //2.判断用户是否合法
    105.             pthread_mutex_lock(&map_lock_);
    106.             auto iter = user_map_.begin();
    107.             while(iter != user_map_.end()){
    108.                 if(iter->second.telnum_ == tel){
    109.                     break;
    110.                 }
    111.                 iter++;
    112.             }
    113.             if(iter == user_map_.end()){
    114.                 pthread_mutex_unlock(&map_lock_);
    115.                 return -1;
    116.             }
    117.             //3.校验密码是否正确
    118.             if(iter->second.passwd_ != passwd){
    119.                 pthread_mutex_unlock(&map_lock_);
    120.                 return -1;
    121.             }
    122.  
    123.             //4.更改用户的状态信息为ONLINE
    124.             iter->second.user_status_ = ONLINE;
    125.             int userid = iter->second.userid_;
    126.             iter->second.tcp_socket_ = sockfd;
    127.             pthread_mutex_unlock(&map_lock_);
    128.             return userid;
    129.         }
    130.  
    131.         int IsLogin(int userid){
    132.             pthread_mutex_lock(&map_lock_);
    133.             auto iter = user_map_.find(userid);
    134.             if(iter == user_map_.end()){
    135.                 //这个用户都不存在
    136.                 pthread_mutex_unlock(&map_lock_);
    137.                 return -1;
    138.             }
    139.  
    140.             if(iter->second.user_status_ == OFFLINE){
    141.                 pthread_mutex_unlock(&map_lock_);
    142.                 return OFFLINE;
    143.             }
    144.             pthread_mutex_unlock(&map_lock_);
    145.             return ONLINE;
    146.         }
    147.  
    148.  
    149.         int IsLogin(const std::string& telnum, UserInfo* ui){
    150.             pthread_mutex_lock(&map_lock_);
    151.             auto iter = user_map_.begin();
    152.             while(iter != user_map_.end()){
    153.                 if(iter->second.telnum_ == telnum){
    154.                     break;
    155.                 }
    156.                 iter++;
    157.             }
    158.  
    159.             if(iter == user_map_.end()){
    160.                 pthread_mutex_unlock(&map_lock_);
    161.                 return -1;
    162.             }
    163.  
    164.             *ui = iter->second;
    165.             if(iter->second.user_status_ == OFFLINE){
    166.                 pthread_mutex_unlock(&map_lock_);
    167.                 return OFFLINE;
    168.             }
    169.             pthread_mutex_unlock(&map_lock_);
    170.             return ONLINE;
    171.         }
    172.  
    173.  
    174.         bool GetUserInfo(int userid, UserInfo* ui){
    175.             pthread_mutex_lock(&map_lock_);
    176.             auto iter = user_map_.find(userid);
    177.             if(iter == user_map_.end()){
    178.                 //这个用户都不存在
    179.                 pthread_mutex_unlock(&map_lock_);
    180.                 return false;
    181.             }
    182.  
    183.             *ui = iter->second;
    184.             pthread_mutex_unlock(&map_lock_);
    185.             return true;
    186.         }
    187.  
    188.         bool GetFriends(int userid, std::vector<int>* fri){
    189.             pthread_mutex_lock(&map_lock_);
    190.             auto iter = user_map_.find(userid);
    191.             if(iter == user_map_.end()){
    192.                 //这个用户都不存在
    193.                 pthread_mutex_unlock(&map_lock_);
    194.                 return false;
    195.             }
    196.  
    197.             *fri = iter->second.friend_id_;
    198.             pthread_mutex_unlock(&map_lock_);
    199.             return true;
    200.  
    201.         }
    202.  
    203.         void SetFriend(int userid1, int userid2){
    204.             //1.找userid1, 将userid2放到userid1的好友列表当中
    205.             pthread_mutex_lock(&map_lock_);
    206.             auto iter = user_map_.find(userid1);
    207.             if(iter == user_map_.end()){
    208.                 //这个用户都不存在
    209.                 pthread_mutex_unlock(&map_lock_);
    210.                 return;
    211.             }
    212.             iter->second.friend_id_.push_back(userid2);
    213.             
    214.             //2.找userid2, 将userid1放到userid2的好友列表当中
    215.             iter = user_map_.find(userid2);
    216.             if(iter == user_map_.end()){
    217.                 //这个用户都不存在
    218.                 pthread_mutex_unlock(&map_lock_);
    219.                 return;
    220.             }
    221.             iter->second.friend_id_.push_back(userid1);
    222.             pthread_mutex_unlock(&map_lock_);
    223.             //3.插入到数据库当中
    224.             db_->InsertFriend(userid1, userid2);
    225.             db_->InsertFriend(userid2, userid1);
    226.         }
    227.  
    228.         void SetUserOffLine(int sockfd){
    229.             pthread_mutex_lock(&map_lock_);
    230.             auto iter = user_map_.begin();
    231.             while(iter != user_map_.end()){
    232.                 if(iter->second.tcp_socket_ == sockfd){
    233.                     iter->second.user_status_ = OFFLINE;
    234.                 }
    235.                 iter++;
    236.             }
    237.             pthread_mutex_unlock(&map_lock_);
    238.         }
    239.  
    240.  
    241.     private:
    242.         std::unordered_map<int, UserInfo> user_map_;
    243.         pthread_mutex_t map_lock_;
    244.  
    245.         //针对注册用户分配的ID
    246.         int prepare_id_;
    247.  
    248.         //数据库管理模块的实例化指针
    249.         DataBaseSvr* db_;
    250. };

    1.4业务模块设计

    • a.初始化资源：int InitChatServer(uint16_t tcp_port = TCP_PORT, int thread_count=THREAD_COUNT)，tcpSOCK初始化，客户端进行监听
    • b.启动各类线程函数：StartChatServer()，epoll等待线程，接收线程，发送线程，工作线程的创建
    • epoll等待线程：主线程循环的接收， 将接收回来的数据放到接收线程的队列当中， 等到工作线程从队列当中获取消息， 进而进行处理
    • 发送线程：从消息队列中拿消息进行发送
    • 工作线程：从接收队列中拿消息，并根据消息的类型进行处理（注册，登录，添加好友，添加好友应答，获取好友信息）
    1. struct Msg{
    2.     Msg(){
    3.         sockfd_ = -1;
    4.         memset(buf, '\0', 1024);
    5.     }
    6.     int sockfd_;
    7.     char buf[1024];
    8. };
    9.  
    10. class ChatServer{
    11.     public:
    12.         ChatServer(){
    13.             tcp_sock_ = -1;
    14.             tcp_port_ = TCP_PORT;
    15.             user_mana_ = NULL;
    16.             epoll_fd_ = -1;
    17.             thread_count_ = THREAD_COUNT;
    18.  
    19.             send_que_ = NULL;
    20.             ready_sockfd_que_ = NULL;
    21.             recv_que_ = NULL;
    22.         }
    23.  
    24.         ~ChatServer(){
    25.  
    26.         }
    27.  
    28.         //初始化资源的函数
    29.         int InitChatServer(uint16_t tcp_port = TCP_PORT, int thread_count=THREAD_COUNT){
    30.             tcp_port_ = tcp_port;
    31.             thread_count_ = thread_count;
    32.  
    33.             //tcp初始化
    34.             tcp_sock_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    35.             if(tcp_sock_ < 0){
    36.                 perror("socket");
    37.                 return -1;
    38.             }
    39.  
    40.             //端口重用
    41.             int opt = 1;
    42.             setsockopt(tcp_sock_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    43.  
    44.             struct sockaddr_in addr;
    45.             addr.sin_family = AF_INET;
    46.             addr.sin_port = htons(tcp_port_);
    47.             addr.sin_addr.s_addr = inet_addr("0.0.0.0");
    48.             int ret = bind(tcp_sock_, (struct sockaddr*)&addr, sizeof(addr));
    49.             if(ret < 0){
    50.                 perror("bind");
    51.                 return -1;
    52.             }
    53.  
    54.             ret = listen(tcp_sock_, 1024);
    55.             if(ret < 0){
    56.                 perror("listen");
    57.                 return -1;
    58.             }
    59.  
    60.             //epoll 初始化
    61.             epoll_fd_ = epoll_create(5);
    62.             if(epoll_fd_ < 0){
    63.                 return -1;
    64.             }
    65.  
    66.             //用户管理模块
    67.             user_mana_ = new UserManager();
    68.             if(user_mana_ == NULL){
    69.                 return -1;
    70.             }
    71.  
    72.             if(user_mana_->InitUserMana() == false){
    73.                 return -1;
    74.             }
    75.  
    76.  
    77.             recv_que_ = new MsgQueue();
    78.             if(recv_que_ == NULL){
    79.                 return -1;
    80.             }
    81.  
    82.             send_que_ = new MsgQueue();
    83.             if(send_que_ == NULL){
    84.                 return -1;
    85.             }
    86.  
    87.             ready_sockfd_que_ = new MsgQueue<int>();
    88.             if(ready_sockfd_que_ == NULL){
    89.                 return -1;
    90.             }
    91.  
    92.             return 0;
    93.         }
    94.  
    95.         //启动各类线程的函数 - 主线程调用的
    96.         int StartChatServer(){
    97.             //1.创建epoll等待线程
    98.             pthread_t tid;
    99.             int ret  = pthread_create(&tid, NULL, epoll_wait_start, (void*)this);
    100.             if(ret < 0){
    101.                 perror("pthread_create");
    102.                 return -1;
    103.             }
    104.             //2.创建接收线程
    105.             ret  = pthread_create(&tid, NULL, recv_msg_start, (void*)this);
    106.             if(ret < 0){
    107.                 perror("pthread_create");
    108.                 return -1;
    109.             }
    110.             //3.创建发送线程
    111.             ret  = pthread_create(&tid, NULL, send_msg_start, (void*)this);
    112.             if(ret < 0){
    113.                 perror("pthread_create");
    114.                 return -1;
    115.             }
    116.             //4.创建工作线程
    117.             for(int i = 0; i < thread_count_; i++){
    118.                 ret = pthread_create(&tid, NULL, deal_start, (void*)this);
    119.                 if(ret < 0){
    120.                     thread_count_--;
    121.                 }
    122.             }
    123.  
    124.             if(thread_count_ <= 0){
    125.                 return -1;
    126.             }
    127.             
    128.             //5.主线程循环接收新连接 & 将新连接的套接字放到epoll当中
    129.             struct sockaddr_in cli_addr;
    130.             socklen_t cli_addr_len = sizeof(cli_addr);
    131.             while(1){
    132.                 int newsockfd = accept(tcp_sock_,(struct sockaddr*)&cli_addr, &cli_addr_len);
    133.                 if(newsockfd < 0){
    134.                     continue;
    135.                 }
    136.  
    137.                 //接收上了， 添加到epoll当中进行监控
    138.                 struct epoll_event ee;
    139.                 ee.events = EPOLLIN;
    140.                 ee.data.fd = newsockfd;
    141.                 epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, newsockfd, &ee);
    142.             }
    143.  
    144.             return 0;
    145.         }
    146.  
    147.         static void* epoll_wait_start(void* arg){
    148.             pthread_detach(pthread_self());
    149.             ChatServer* cs = (ChatServer*)arg;
    150.             while(1){
    151.                 struct epoll_event arr[10];
    152.                 int ret = epoll_wait(cs->epoll_fd_, arr, sizeof(arr)/sizeof(arr[0]), -1);
    153.                 if(ret < 0){
    154.                     continue;
    155.                 }
    156.  
    157.                 //正常获取了就绪的事件结构, 一定全部都是新连接套接字
    158.                 for(int i = 0; i < ret; i++){
    159.                     char buf[TCP_DATA_MAX_LEN] = {0};
    160.                     //隐藏的问题： TCP粘包
    161.                     ssize_t recv_size = recv(arr[i].data.fd, buf, sizeof(buf) - 1, 0);
    162.                     if(recv_size < 0){
    163.                         //接收失败了
    164.                         std::cout << "recv failed : sockfd is " << arr[i].data.fd << std::endl;
    165.                         continue;
    166.                     }else if(recv_size == 0){
    167.                         //对端关闭连接了
    168.                         epoll_ctl(cs->epoll_fd_, EPOLL_CTL_DEL,arr[i].data.fd, NULL);
    169.                         close(arr[i].data.fd);
    170.                         //组织一个更改用户状态的消息 , 鸡贼做法（客户端退出的时候， 发送下线通知）
    171.                         cs->user_mana_->SetUserOffLine(arr[i].data.fd);
    172.                         continue;
    173.                     }
    174.  
    175.                     printf("epoll_wait_start recv msg : %s  from sockfd is %d\n", buf, arr[i].data.fd);
    176.                     //正常接收回来了, 将接收回来的数据放到接收线程的队列当中， 等到工作线程从队列当中获取消息， 进而进行处理
    177.                     //3.将接收到的数据放到接收队列当当中
    178.                     std::string msg;
    179.                     msg.assign(buf, strlen(buf));
    180.  
    181.                     ChatMsg cm;
    182.                     cm.PraseChatMsg(arr[i].data.fd, msg);
    183.  
    184.                     cs->recv_que_->Push(cm);
    185.                 }
    186.             }
    187.             return NULL;
    188.         }
    189.  
    190.         static void* recv_msg_start(void* arg){
    191.             pthread_detach(pthread_self());
    192.             ChatServer* cs = (ChatServer*)arg;
    193.  
    194.             while(1){
    195.             }
    196.  
    197.  
    198.             return NULL;
    199.         }
    200.  
    201.         static void* send_msg_start(void* arg){
    202.             pthread_detach(pthread_self());
    203.             ChatServer* cs = (ChatServer*)arg;
    204.  
    205.             while(1){
    206.                 //1.从队列拿出数据
    207.                 ChatMsg cm;
    208.                 cs->send_que_->Pop(&cm);
    209.  
    210.                 std::string msg;
    211.                 cm.GetMsg(&msg);
    212.                 std::cout << "send thread: " << msg << std::endl;
    213.  
    214.                 //2.发送数据
    215.                 send(cm.sockfd_, msg.c_str(), msg.size(), 0);
    216.             }
    217.  
    218.             return NULL;
    219.         }
    220.  
    221.         static void* deal_start(void* arg){
    222.             pthread_detach(pthread_self());
    223.             ChatServer* cs = (ChatServer*)arg;
    224.  
    225.             while(1){
    226.                 //1. 从接收队列当中获取消息
    227.                 ChatMsg cm;
    228.                 cs->recv_que_->Pop(&cm);
    229.                 //2. 通过消息类型分业务处理
    230.                 int msg_type = cm.msg_type_;
    231.                 switch(msg_type){
    232.                     case Register:{
    233.                        cs->DealRegister(cm); 
    234.                         break;
    235.                     }
    236.                     case Login:{
    237.                         cs->DealLogin(cm);
    238.                         break;
    239.                     }
    240.                     case AddFriend:{
    241.                         cs->DealAddFriend(cm);
    242.                         break;
    243.                     }
    244.                     case PushAddFriendMsg_Resp:{
    245.                         cs->DealAddFriendResp(cm);
    246.                         break;
    247.                     }
    248.                     case SendMsg: {
    249.                         cs->DealSendMsg(cm);
    250.                         break;
    251.                     }
    252.                     case GetFriendMsg:{
    253.                         cs->GetAllFriendInfo(cm);
    254.                         break;
    255.                     }
    256.                     default:{
    257.                         break;
    258.                     }
    259.                 }
    260.  
    261.                 //3. 组织应答
    262.             }
    263.             return NULL;
    264.         }
    265.         void DealRegister(ChatMsg& cm){
    266.             //1.获取注册信息
    267.             std::string nickname = cm.GetValue("nickname");
    268.             std::string school = cm.GetValue("school");
    269.             std::string telnum = cm.GetValue("telnum");
    270.             std::string passwd = cm.GetValue("passwd");
    271.             //2.调用用户管理系统当中的注册接口
    272.             int userid = -1;
    273.             int ret = user_mana_->DealRegister(nickname, school, telnum, passwd, &userid);
    274.             //3.回复应答
    275.             cm.Clear();
    276.             cm.msg_type_ = Register_Resp;
    277.             if(ret < 0){
    278.                 cm.reply_status_ = REGISTER_FAILED;
    279.             }else{
    280.                 cm.reply_status_ = REGISTER_SUCCESS;
    281.             }
    282.             cm.user_id_ = userid;
    283.  
    284.             send_que_->Push(cm);
    285.         }
    286.  
    287.         void DealLogin(ChatMsg& cm){
    288.             //1.获取数据
    289.             std::string telnum = cm.GetValue("telnum");
    290.             std::string passwd = cm.GetValue("passwd");
    291.             //2.调用用户管理模块的代码
    292.             int ret = user_mana_->DealLogin(telnum, passwd, cm.sockfd_);
    293.             //3.回复应答
    294.             cm.Clear();
    295.             cm.msg_type_ = Login_Resp;
    296.             if(ret < 0){
    297.                 cm.reply_status_ = LOGIN_FAILED;
    298.             }else{
    299.                 cm.reply_status_ = LOGIN_SUCESSS;
    300.             }
    301.             cm.user_id_ = ret;
    302.  
    303.             send_que_->Push(cm);
    304.         }
    305.  
    306.         void DealAddFriend(ChatMsg& cm){
    307.             //1.获取被添加方的电话号码
    308.             std::string tel = cm.GetValue("telnum");
    309.             //添加方的userid
    310.             int add_userid = cm.user_id_;
    311.  
    312.             cm.Clear();
    313.             //2.查询被添加方是否是登录状态
    314.             UserInfo be_add_ui;
    315.             int ret = user_mana_->IsLogin(tel, &be_add_ui);
    316.             if(ret == -1){
    317.                 //用户不存在
    318.                 cm.json_msg_ = AddFriend_Resp;
    319.                 cm.reply_status_ = ADDFRIEND_FAILED;
    320.                 cm.SetValue("content", "user not exist, please check friend tel num.");
    321.                 send_que_->Push(cm);
    322.                 return;
    323.             }else if(ret == OFFLINE){
    324.                 std::cout << be_add_ui.nickname_ + " status is OFFLINE" << std::endl;
    325.                 //将消息先缓存下来， 择机发送
    326.                 return;
    327.             }
    328.             //ONLINE状态的
    329.             //3.给被添加方推送添加好友请求
    330.             UserInfo add_ui;
    331.             user_mana_->GetUserInfo(add_userid, &add_ui);
    332.  
    333.             cm.sockfd_ = be_add_ui.tcp_socket_;
    334.             cm.msg_type_ = PushAddFriendMsg;
    335.             cm.SetValue("adder_nickname", add_ui.nickname_);
    336.             cm.SetValue("adder_school", add_ui.school_);
    337.             cm.SetValue("adder_userid", add_ui.userid_);
    338.             
    339.             send_que_->Push(cm);
    340.         }
    341.  
    342.         void DealAddFriendResp(ChatMsg& cm){
    343.             //1.获取双方的用户信息
    344.             int reply_status = cm.reply_status_;
    345.             //获取被添加方的用户信息
    346.             int be_add_user = cm.user_id_;
    347.             UserInfo be_userinfo;
    348.             user_mana_->GetUserInfo(be_add_user, &be_userinfo);
    349.  
    350.             //获取添加方的用户信息-通过应答， 获取添加方的UserId
    351.             int addr_user_id = atoi(cm.GetValue("userid").c_str());
    352.             UserInfo ui;
    353.             user_mana_->GetUserInfo(addr_user_id ,&ui);
    354.  
    355.             //2.判断响应状态
    356.             cm.Clear();
    357.             cm.sockfd_ = ui.tcp_socket_;
    358.             cm.msg_type_ = AddFriend_Resp;
    359.             if(reply_status == ADDFRIEND_FAILED){
    360.                 cm.reply_status_ = ADDFRIEND_FAILED;
    361.                 std::string content = "add user " + be_userinfo.nickname_ + " failed";
    362.                 cm.SetValue("content", content);
    363.             }else if(reply_status == ADDFRIEND_SUCCESS){
    364.                 cm.reply_status_ = ADDFRIEND_SUCCESS;
    365.                 std::string content = "add user " + be_userinfo.nickname_ + " success";
    366.                 cm.SetValue("content", content);
    367.                 cm.SetValue("peer_nick_name", be_userinfo.nickname_);
    368.                 cm.SetValue("peer_school", be_userinfo.school_);
    369.                 cm.SetValue("peer_userid", be_userinfo.userid_);
    370.  
    371.                 //用户管理模块当中要维护好友信息
    372.                 user_mana_->SetFriend(addr_user_id, be_add_user);
    373.             }
    374.  
    375.             //TODO
    376.             if(ui.user_status_ == OFFLINE){
    377.                 //消息就放到缓存队列当中， 择机发送
    378.             }
    379.  
    380.             //3.给添加方回复响应
    381.             send_que_->Push(cm);
    382.         }
    383.  
    384.  
    385.         void GetAllFriendInfo(ChatMsg& cm){
    386.             //1. 好友信息的数据从用户管理模块当中获取到
    387.             int user_id = cm.user_id_;
    388.  
    389.             cm.Clear();
    390.             std::vector<int> fri;
    391.             bool ret = user_mana_->GetFriends(user_id, &fri);
    392.             if(ret == false){
    393.                 cm.reply_status_ = GETFRIEND_FAILED;
    394.             }else{
    395.                 cm.reply_status_ = GETFRIEND_SUCCESS;
    396.             }
    397.             cm.msg_type_ = GetFriendMsg_Resp;
    398.  
    399.             for(size_t i = 0; i < fri.size(); i++){
    400.                 UserInfo tmp;
    401.                 user_mana_->GetUserInfo(fri[i], &tmp);
    402.  
    403.                 Json::Value val;
    404.                 val["nickname"] = tmp.nickname_;
    405.                 val["school"] = tmp.school_;
    406.                 val["userid"] = tmp.userid_;
    407.  
    408.                 cm.json_msg_.append(val);
    409.             }
    410.  
    411.             send_que_->Push(cm);
    412.         }
    413.  
    414.         void DealSendMsg(ChatMsg& cm){
    415.             int send_id = cm.user_id_;
    416.             int recv_id = cm.json_msg_["recvmsgid"].asInt();
    417.             std::string send_msg = cm.json_msg_["msg"].asString();
    418.  
    419.             cm.Clear();
    420.  
    421.             UserInfo recv_ui;
    422.             bool ret = user_mana_->GetUserInfo(recv_id, &recv_ui);
    423.             //区分用户不存在和不在线两种状态
    424.             //   用户不存在 ： 消息发送失败
    425.             //   用户不在线： 发送方发送的消息缓存下来， 择机发送
    426.             if(ret == false || recv_ui.user_status_ == OFFLINE){
    427.                 cm.msg_type_ = SendMsg_Resp;
    428.                 cm.reply_status_ = SENDMSG_FAILED;
    429.                 send_que_->Push(cm);
    430.                 return;
    431.             }
    432.  
    433.             //代码能走到这里， 说明要给接收方推送消息了
    434.             cm.Clear();
    435.             cm.msg_type_ = SendMsg_Resp;
    436.             cm.reply_status_ = SENDMSG_SUCCESS;
    437.             send_que_->Push(cm);
    438.  
    439.  
    440.             //获取发送方的用户信息
    441.             UserInfo send_ui;
    442.             user_mana_->GetUserInfo(send_id, &send_ui);
    443.  
    444.             cm.Clear();
    445.             cm.msg_type_ = PushMsg;
    446.             cm.sockfd_ = recv_ui.tcp_socket_;
    447.             cm.SetValue("peer_nickname", send_ui.nickname_);
    448.             cm.SetValue("peer_school", send_ui.school_);
    449.             cm.json_msg_["peer_userid"] = send_ui.userid_;
    450.             cm.SetValue("peer_msg", send_msg);
    451.             send_que_->Push(cm);
    452.         }
    453.  
    454.     private:
    455.         //侦听套接字
    456.         int tcp_sock_;
    457.         int tcp_port_;
    458.  
    459.         //用户管理模块的实例化指针
    460.         UserManager* user_mana_;
    461.  
    462.         //epoll操作句柄
    463.         int epoll_fd_;
    464.  
    465.         //工作线程的数量
    466.         int thread_count_;
    467.  
    468.         //就绪的文件描述符队列
    469.         MsgQueue<int>* ready_sockfd_que_;
    470.  
    471.         //接收线程的队列
    472.         MsgQueue* recv_que_;
    473.  
    474.         //发送线程的队列
    475.         MsgQueue* send_que_;
    476. };

    1.5消息的操作

    消息类型和响应类型

    1. enum chat_msg_type{
    2.     Register = 0, //0， 注册请求
    3.     Register_Resp, //1， 注册应答
    4.     Login,   //2. 登录请求
    5.     Login_Resp, //3， 登录应答
    6.     AddFriend, //4， 添加好友请求
    7.     AddFriend_Resp, //5， 添加好友请求应答
    8.     SendMsg, //6， 发送消息
    9.     SendMsg_Resp, //7， 发送消息应答
    10.     PushMsg, //8， 推送消息
    11.     PushMsg_Resp, //9， 推送消息应答
    12.     PushAddFriendMsg, //10， 推送添加好友请求
    13.     PushAddFriendMsg_Resp, //11， 推送添加好友请求的应答 
    14.     GetFriendMsg, //12， 获取全部好友信息
    15.     GetFriendMsg_Resp, //13， 获取全部好友信息应答
    16.     SetUserOffLine //14
    17.     //后续如果要增加业务， 可以在后面增加其他的消息类型
    18. };
    19.  
    20. enum reply_status{
    21.     REGISTER_SUCCESS = 0, //0, 注册成功
    22.     REGISTER_FAILED, //1，注册失败
    23.     LOGIN_SUCESSS, //2， 登录成功
    24.     LOGIN_FAILED,  //3， 登陆失败
    25.     ADDFRIEND_SUCCESS, //4， 添加好友成功
    26.     ADDFRIEND_FAILED, //5， 添加好友失败
    27.     SENDMSG_SUCCESS, //6， 发送消息成功
    28.     SENDMSG_FAILED, //7， 发送给消息失败
    29.     GETFRIEND_SUCCESS, //8，获取好友列表成功
    30.     GETFRIEND_FAILED  //9， 获取好友列表失败
    31. };

    消息类型的格式

    1. /*
    2.  * 注册请求的消息格式
    3.  *   sockfd_ (消息达到服务端之后， 由服务端接收之后， 打上sockfd_)
    4.  *   msg_type_ : Register
    5.  *   json_msg: {
    6.  *      nickname : 'xxx'
    7.  *      school : "xxx"
    8.  *      telnum : "xxxx"
    9.  *      passwd : "xxxx"
    10.  *   }
    11.  *
    12.  * 注册的应答：
    13.  *   msg_type_ : Register_Resp
    14.  *   reply_status_ = REGISTER_SUCCESS / REGISTER_FAILED
    15.  *      如果是REGISTER_SUCCESS : [user_id_]
    16.  *
    17.  *
    18.  *
    19.  * 登录的请求消息格式
    20.  *   sockfd_ (消息达到服务端之后， 由服务端接收之后， 打上sockfd_)
    21.  *   msg_type_ : Login
    22.  *   json_msg_ : {
    23.  *      telnum : xxx
    24.  *      passwd : xxx
    25.  *   }
    26.  *
    27.  *   登录的应答：
    28.  *   msg_type : Login_Resp;
    29.  *   reply_status_ : LOGIN_SUCCESS/LOGIN_FAILED
    30.  *       如果是LOGIN_SUCCESS : [user_id_]
    31.  *
    32.  *
    33.  *
    34.  * 添加好友请求：
    35.  *    msg_type_ : AddFriend
    36.  *    json_msg_ :{
    37.  *      fri_tel_num : xxxx
    38.  *    }
    39.  *
    40.  *
    41.  *  推送添加好友的请求
    42.  *      msg_type : PushAddFriendMsg
    43.  *      sockfd_ : 被添加方的套接字描述符
    44.  *      json_msg_: {
    45.  *          adder_nickname : xxx
    46.  *          adder_school : xxx
    47.  *          adder_userid : xxx
    48.  *      }
    49.  *
    50.  * 推送添加好友的应答（被添加方发送给服务端的）
    51.  *     msg_type : PushAddFriendMsg_Resp
    52.  *     user_id : 被添加方的id
    53.  *     reply_status : ADDFRIEND_SUCCESS / ADDFRIEND_FAILED
    54.  *         如果说是ADDFRIEND_SUCCESS
    55.  *             json_msg_ : 添加方的id
    56.  *
    57.  *  添加好友的应答：
    58.  *      msg_type: AddFriend_Resp
    59.  *      reply_status : ADDFRIEND_FAILED / ADDFRIEND_SUCCESS
    60.  *          如果是成功：ADDFRIEND_SUCCESS
    61.  *             json_msg_ : 
    62.  *                 BeAdd_nickname : 被添加方的名字
    63.  *                 BeAdd_school ： 被添加方的学校
    64.  *                 BeAdd_userid : 被添加方的id
    65.  * */

    消息的序列化和反序列化

    原因：面向对象语言设计的程序是通过各种类的使用实现的，而在信息传输的过程中我们传输的是二进制的文件，因此我们不能直接来进行传输，需要先对消息进行序列化，同样的拿到消息后也需要先做反序列化处理

    1. class JsonUtil{
    2.     public:
    3.         static bool Serialize(const Json::Value& value, std::string* body) {
    4.             Json::StreamWriterBuilder swb;
    5.             std::unique_ptr sw(swb.newStreamWriter());
    6.         
    7.             std::stringstream ss;
    8.             int ret = sw->write(value, &ss);
    9.             if (ret != 0) {
    10.                 return false;
    11.             }
    12.             *body = ss.str();
    13.             return true;
    14.         }
    15.         
    16.         static bool UnSerialize(const std::string& body, Json::Value* value) {
    17.             Json::CharReaderBuilder crb;
    18.             std::unique_ptr cr(crb.newCharReader());
    19.         
    20.             std::string err;
    21.             bool ret = cr->parse(body.c_str(), body.c_str() + body.size(), value, &err);
    22.             if (ret == false) {                                                                                                                                                                  
    23.                 return false;
    24.             }
    25.             return true;
    26.         }
    27. };
    28.

    Json消息的操作

    • a.获取json_msg_当中的value值,string GetValue(const std::string& key)
    • b. 设置json_msg_当中的kv键值对,string GetValue(const std::string& key)/SetValue(const std::string& key, const std::string& value)
    1.         /*
    2.          * 提供序列化的接口 - 回复应答的时候使用
    3.          *     msg ： 出参， 用于获取序列化完毕的字符串
    4.          * */
    5.         bool GetMsg(std::string* msg){
    6.             Json::Value tmp;
    7.             tmp["msg_type"] = msg_type_;
    8.             tmp["user_id"] = user_id_;
    9.             tmp["reply_status"] = reply_status_;
    10.             tmp["json_msg"] = json_msg_;
    11.  
    12.             return JsonUtil::Serialize(tmp, msg);
    13.         }
    14.  
    15.         /*
    16.          * 获取json_msg_当中的value值
    17.          * */
    18.         std::string GetValue(const std::string& key){
    19.             if(!json_msg_.isMember(key)){
    20.                 return "";
    21.             }
    22.             return json_msg_[key].asString();
    23.         }
    24.  
    25.         /*
    26.          * 设置json_msg_当中的kv键值对
    27.          * */
    28.  
    29.         void SetValue(const std::string& key, const std::string& value){
    30.             json_msg_[key] = value;
    31.         }
    32.  
    33.         void SetValue(const std::string& key, int value){
    34.             json_msg_[key] = value;
    35.         }
    36.         void Clear(){
    37.             msg_type_ = -1;
    38.             user_id_ = -1;
    39.             reply_status_ = -1;
    40.             json_msg_.clear();
    41.         }
    42.     public:
    43.         //存放的客户端文件名描述符， 方便发送线程， 通过该字段将数据发送给对应的客户端
    44.         int sockfd_;
    45.  
    46.         int msg_type_;
    47.  
    48.         //用户id
    49.         int user_id_;
    50.  
    51.         //应答的状态
    52.         int reply_status_;
    53.  
    54.         /*
    55.          * Json消息
    56.          *   json消息的内容会随着消息类型的不同， 字段不一样
    57.          * */
    58.         Json::Value json_msg_;
    59. };

    1.6消息队列

    • a.向队列中放消息：void Push(const T& msg)
    • b.从队列中拿消息：void Pop(T* msg)
    1. #define CAPACITY 10000
    2.  
    3. template <class T>
    4. class MsgQueue{
    5.     public:
    6.         MsgQueue(){
    7.             capacity_ = CAPACITY;
    8.             pthread_mutex_init(&lock_vec_, NULL);
    9.             pthread_cond_init(&cons_cond_, NULL);
    10.             pthread_cond_init(&prod_cond_, NULL);
    11.         }
    12.  
    13.         ~MsgQueue(){
    14.             pthread_mutex_destroy(&lock_vec_);
    15.             pthread_cond_destroy(&cons_cond_);
    16.             pthread_cond_destroy(&prod_cond_);
    17.         }
    18.  
    19.  
    20.         void Push(const T& msg){
    21.             pthread_mutex_lock(&lock_vec_);
    22.             while(vec_.size() >= capacity_){
    23.                 pthread_cond_wait(&prod_cond_, &lock_vec_);
    24.             }
    25.             vec_.push(msg);
    26.             pthread_mutex_unlock(&lock_vec_);
    27.  
    28.             pthread_cond_signal(&cons_cond_);
    29.         }
    30.  
    31.         void Pop(T* msg){
    32.             pthread_mutex_lock(&lock_vec_);
    33.             while(vec_.empty()){
    34.                 pthread_cond_wait(&cons_cond_, &lock_vec_);
    35.             }
    36.             *msg = vec_.front();
    37.             vec_.pop();
    38.             pthread_mutex_unlock(&lock_vec_);
    39.  
    40.             pthread_cond_signal(&prod_cond_);
    41.         }
    42.     private:
    43.         std::queue vec_;
    44.         size_t capacity_;
    45.  
    46.         pthread_mutex_t lock_vec_;
    47.         pthread_cond_t cons_cond_;
    48.         pthread_cond_t prod_cond_;
    49. };

    2.客户端

    客户端使用VS2019的MFC功能创建的

    2.1登录及注册消息流转图

     代码实现：

    1.  
    2. // ChatSystemLd.cpp: 定义应用程序的类行为。
    3. //
    4.  
    5. #include "pch.h"
    6. #include "framework.h"
    7. #include "ChatSystemLd.h"
    8. #include "ChatSystemLdDlg.h"
    9.  
    10. #include "TcpSvr.h"
    11. #include "MsgQueue.h"
    12. #include 
    13.  
    14.  
    15. #ifdef _DEBUG
    16. #define new DEBUG_NEW
    17. #endif
    18.  
    19.  
    20. void RecvMsgStart() {
    21. 	TcpSvr* ts = TcpSvr::getInstance();
    22. 	if (ts == NULL) {
    23. 		return;
    24. 	}
    25.  
    26. 	MsgQueue* mq = MsgQueue::GetInstance();
    27. 	if (mq == NULL) {
    28. 		return;
    29. 	}
    30. 	while (1) {
    31. 		std::string msg;
    32. 		int ret = ts->Recv(&msg);
    33. 		if (ret <= 0) {
    34. 			continue;
    35. 		}
    36.  
    37. 		ChatMsg cm;
    38. 		cm.PraseChatMsg(-1, msg);
    39.  
    40. 		mq->Push(cm.msg_type_, msg);
    41. 	}
    42. }
    43.  
    44.  
    45.  
    46. // CChatSystemLdApp
    47.  
    48. BEGIN_MESSAGE_MAP(CChatSystemLdApp, CWinApp)
    49. 	ON_COMMAND(ID_HELP, &CWinApp::OnHelp)
    50. END_MESSAGE_MAP()
    51.  
    52.  
    53. // CChatSystemLdApp 构造
    54.  
    55. CChatSystemLdApp::CChatSystemLdApp()
    56. {
    57. 	// 支持重新启动管理器
    58. 	m_dwRestartManagerSupportFlags = AFX_RESTART_MANAGER_SUPPORT_RESTART;
    59.  
    60. 	// TODO: 在此处添加构造代码，
    61. 	// 将所有重要的初始化放置在 InitInstance 中
    62. }
    63.  
    64.  
    65. // 唯一的 CChatSystemLdApp 对象
    66.  
    67. CChatSystemLdApp theApp;
    68.  
    69.  
    70. // CChatSystemLdApp 初始化
    71.  
    72. BOOL CChatSystemLdApp::InitInstance()
    73. {
    74. 	// 如果一个运行在 Windows XP 上的应用程序清单指定要
    75. 	// 使用 ComCtl32.dll 版本 6 或更高版本来启用可视化方式，
    76. 	//则需要 InitCommonControlsEx()。  否则，将无法创建窗口。
    77. 	INITCOMMONCONTROLSEX InitCtrls;
    78. 	InitCtrls.dwSize = sizeof(InitCtrls);
    79. 	// 将它设置为包括所有要在应用程序中使用的
    80. 	// 公共控件类。
    81. 	InitCtrls.dwICC = ICC_WIN95_CLASSES;
    82. 	InitCommonControlsEx(&InitCtrls);
    83.  
    84. 	/*
    85. 	创建接收线程， 让接收线程， 去接收应答
    86. */
    87.  
    88. 	std::thread recv_thread(RecvMsgStart);
    89. 	recv_thread.detach();
    90.  
    91.  
    92. 	CWinApp::InitInstance();
    93.  
    94.  
    95. 	AfxEnableControlContainer();
    96.  
    97. 	// 创建 shell 管理器，以防对话框包含
    98. 	// 任何 shell 树视图控件或 shell 列表视图控件。
    99. 	CShellManager *pShellManager = new CShellManager;
    100.  
    101. 	// 激活“Windows Native”视觉管理器，以便在 MFC 控件中启用主题
    102. 	CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));
    103.  
    104. 	// 标准初始化
    105. 	// 如果未使用这些功能并希望减小
    106. 	// 最终可执行文件的大小，则应移除下列
    107. 	// 不需要的特定初始化例程
    108. 	// 更改用于存储设置的注册表项
    109. 	// TODO: 应适当修改该字符串，
    110. 	// 例如修改为公司或组织名
    111. 	SetRegistryKey(_T("应用程序向导生成的本地应用程序"));
    112.  
    113. 	CChatSystemLdDlg dlg;
    114. 	m_pMainWnd = &dlg;
    115. 	INT_PTR nResponse = dlg.DoModal();
    116. 	if (nResponse == IDOK)
    117. 	{
    118. 		// TODO: 在此放置处理何时用
    119. 		//  “确定”来关闭对话框的代码
    120. 	}
    121. 	else if (nResponse == IDCANCEL)
    122. 	{
    123. 		// TODO: 在此放置处理何时用
    124. 		//  “取消”来关闭对话框的代码
    125. 	}
    126. 	else if (nResponse == -1)
    127. 	{
    128. 		TRACE(traceAppMsg, 0, "警告: 对话框创建失败，应用程序将意外终止。\n");
    129. 		TRACE(traceAppMsg, 0, "警告: 如果您在对话框上使用 MFC 控件，则无法 #define _AFX_NO_MFC_CONTROLS_IN_DIALOGS。\n");
    130. 	}
    131.  
    132. 	// 删除上面创建的 shell 管理器。
    133. 	if (pShellManager != nullptr)
    134. 	{
    135. 		delete pShellManager;
    136. 	}
    137.  
    138. #if !defined(_AFXDLL) && !defined(_AFX_NO_MFC_CONTROLS_IN_DIALOGS)
    139. 	ControlBarCleanUp();
    140. #endif
    141.  
    142. 	// 由于对话框已关闭，所以将返回 FALSE 以便退出应用程序，
    143. 	//  而不是启动应用程序的消息泵。
    144. 	return FALSE;
    145. }
    146.

    2.2注册界面

    代码实现：

    1. // CDialogRegister.cpp: 实现文件
    2. //
    3.  
    4. #include "pch.h"
    5. #include "ChatSystemLd.h"
    6. #include "CDialogRegister.h"
    7. #include "afxdialogex.h"
    8.  
    9. #include "ChatMsg.h"
    10. #include "TcpSvr.h"
    11. #include "MsgQueue.h"
    12.  
    13. // CDialogRegister 对话框
    14.  
    15. IMPLEMENT_DYNAMIC(CDialogRegister, CDialogEx)
    16.  
    17. CDialogRegister::CDialogRegister(CWnd* pParent /*=nullptr*/)
    18. 	: CDialogEx(IDD_DIALOGREGISTER, pParent)
    19. 	, m_nickname_(_T(""))
    20. 	, m_school_(_T(""))
    21. 	, m_telnum_(_T(""))
    22. 	, m_passwd_(_T(""))
    23. {
    24.  
    25. }
    26.  
    27. CDialogRegister::~CDialogRegister()
    28. {
    29. }
    30.  
    31. void CDialogRegister::DoDataExchange(CDataExchange* pDX)
    32. {
    33. 	CDialogEx::DoDataExchange(pDX);
    34. 	DDX_Text(pDX, IDC_EDIT1, m_nickname_);
    35. 	DDX_Text(pDX, IDC_EDIT2, m_school_);
    36. 	DDX_Text(pDX, IDC_EDIT3, m_telnum_);
    37. 	DDX_Text(pDX, IDC_EDIT4, m_passwd_);
    38. }
    39.  
    40.  
    41. BEGIN_MESSAGE_MAP(CDialogRegister, CDialogEx)
    42. 	ON_BN_CLICKED(IDC_BUTTONCOMMIT, &CDialogRegister::OnBnClickedButtoncommit)
    43. END_MESSAGE_MAP()
    44.  
    45.  
    46. // CDialogRegister 消息处理程序
    47.  
    48.  
    49. void CDialogRegister::OnBnClickedButtoncommit()
    50. {
    51. 	// TODO: 在此添加控件通知处理程序代码
    52. 		// TODO: 在此添加控件通知处理程序代码
    53. 		//1.获取用户的输入
    54. 	//获取输入控件当中最新的值
    55. 	UpdateData(TRUE);
    56. 	if (m_nickname_.IsEmpty() ||
    57. 		m_school_.IsEmpty() ||
    58. 		m_telnum_.IsEmpty() ||
    59. 		m_passwd_.IsEmpty()) {
    60. 		MessageBox(TEXT("输入内容不能为空"));
    61. 		return;
    62. 	}
    63. 	//2.组织登录消息（ChatMsg）
    64. 	ChatMsg cm;
    65. 	cm.msg_type_ = Register;
    66. 	cm.json_msg_["nickname"] = m_nickname_.GetString();
    67. 	cm.json_msg_["school"] = m_school_.GetString();
    68. 	cm.json_msg_["telnum"] = m_telnum_.GetString();
    69. 	cm.json_msg_["passwd"] = m_passwd_.GetString();
    70. 	//cm.SetValue("telnum", m_telnum_.GetString());
    71. 	//cm.SetValue("passwd", m_passwd_.GetString());
    72. 	std::string msg;
    73. 	cm.GetMsg(&msg);
    74. 	//3.获取TCP服务实例化指针
    75. 	TcpSvr* ts = TcpSvr::getInstance();
    76. 	if (ts == NULL) {
    77. 		MessageBox("获取tcp服务失败， 请重试..");
    78. 		return;
    79. 	}
    80. 	//4.发送登录消息
    81. 	ts->Send(msg);
    82. 	//5.获取消息队列的实例化指针
    83. 	MsgQueue* mq = MsgQueue::GetInstance();
    84. 	if (mq == NULL) {
    85. 		MessageBox("获取消息队列失败， 请联系开发人员...");
    86. 		return;
    87. 	}
    88.  
    89. 	msg.clear();
    90. 	mq->Pop(Register_Resp, &msg);
    91. 	//6.获取登录应答
    92. 	cm.Clear();
    93. 	cm.PraseChatMsg(-1, msg);
    94. 	//7.判断登录应答当中的应答状态（LOGIN_SUCCESS/LOGIN_FAILED）
    95. 	if (cm.reply_status_ == REGISTER_SUCCESS) {
    96. 		MessageBox("register success");
    97. 		//退出当前的注册界面， 相当于回到了登录界面
    98. 		CDialog::OnCancel();
    99. 	}
    100. 	else {
    101. 		MessageBox("register failed, please retry...");
    102. 	}
    103. }

    2.3聊天界面及消息流转图

    代码实现

    1. // CDialogChatWin.cpp: 实现文件
    2. //
    3.  
    4. #include "pch.h"
    5. #include "ChatSystemLd.h"
    6. #include "CDialogChatWin.h"
    7. #include "afxdialogex.h"
    8. #include "CDialogAddFriend.h"
    9.  
    10. #include "TcpSvr.h"
    11. #include "MsgQueue.h"
    12. #include "ChatMsg.h"
    13.  
    14.  
    15.  
    16. // CDialogChatWin 对话框
    17.  
    18. IMPLEMENT_DYNAMIC(CDialogChatWin, CDialogEx)
    19.  
    20. CDialogChatWin::CDialogChatWin(int  userid,CWnd* pParent /*=nullptr*/)
    21. 	: CDialogEx(IDD_DIALOGCHATWIN, pParent)
    22. 	, m_sendmsg_(_T(""))
    23. 	, user_id_(userid)
    24. {
    25.  
    26. }
    27.  
    28. CDialogChatWin::~CDialogChatWin()
    29. {
    30. }
    31.  
    32. void CDialogChatWin::DoDataExchange(CDataExchange* pDX)
    33. {
    34. 	CDialogEx::DoDataExchange(pDX);
    35. 	//DDX_Text(pDX, IDC_EDIT1, m_sendmsg_);
    36. 	DDX_Text(pDX, IDC_EDITSENDMSG, m_sendmsg_);
    37. 	DDX_Control(pDX, IDC_LISTFRIENDLIST, m_userlist_);
    38. 	DDX_Control(pDX, IDC_LISTHISTORYMSG, m_output_);
    39. 	DDX_Control(pDX, IDC_EDITSENDMSG, m_sendmsg_edit_);
    40. 	//DDX_Control(pDX, IDC_BUTTONSENDMSG, user_id_);
    41. }
    42.  
    43.  
    44. BEGIN_MESSAGE_MAP(CDialogChatWin, CDialogEx)
    45. 	//ON_BN_CLICKED(IDC_BUTTON2, &CDialogChatWin::OnBnClickedButton2)
    46. 	ON_BN_CLICKED(IDC_BUTTONADDFRIEND, &CDialogChatWin::OnBnClickedButtonaddfriend)
    47. 	ON_BN_CLICKED(IDC_BUTTONSENDMSG, &CDialogChatWin::OnBnClickedButtonsendmsg)
    48. 	ON_LBN_SELCHANGE(IDC_LISTFRIENDLIST, &CDialogChatWin::OnLbnSelchangeListfriendlist)
    49. END_MESSAGE_MAP()
    50.  
    51.  
    52. // CDialogChatWin 消息处理程序
    53.  
    54.  
    55. void DealPushMsg(CDialogChatWin* cc) {
    56. 	MsgQueue* mq = MsgQueue::GetInstance();
    57. 	if (mq == NULL) {
    58. 		return;
    59. 	}
    60.  
    61. 	while (1) {
    62. 		std::string msg;
    63. 		mq->Pop(PushMsg, &msg);
    64.  
    65. 		ChatMsg cm;
    66. 		cm.PraseChatMsg(-1, msg);
    67. 		std::string peer_nickname = cm.json_msg_["peer_nickname"].asString();
    68. 		std::string peer_school = cm.json_msg_["peer_school"].asString();
    69. 		std::string peer_msg = cm.json_msg_["peer_msg"].asString();
    70. 		int peer_id = cm.json_msg_["peer_userid"].asInt();
    71.  
    72. 		for (size_t i = 0; i < cc->fri_vec_.size(); i++) {
    73. 			if (peer_id == cc->fri_vec_[i].user_id_) {
    74. 				std::string tmp = peer_nickname + "-" + peer_school + ": " + peer_msg;
    75. 				cc->fri_vec_[i].history_msg_.push_back(tmp);
    76. 				if (peer_id == cc->send_user_id_) {
    77. 					//cc->m_output_.AddString(tmp.c_str());
    78. 					cc->m_output_.InsertString(cc->m_output_.GetCount(), tmp.c_str());
    79. 				}
    80. 				else {
    81. 					cc->fri_vec_[i].msg_cnt_++;
    82. 				}
    83. 			}
    84. 		}
    85. 		cc->RefreshUserList();
    86. 	}
    87. }
    88.  
    89. //能够调用到这个线程函数， 说明当前客户端作为被添加方
    90. void DealPushAddFriendMsg(CDialogChatWin* cc) {
    91. 	//1.获取消息队列实例化指针 & tcp的实例化指针
    92. 	MsgQueue* mq = MsgQueue::GetInstance();
    93. 	if (mq == NULL) {
    94. 		MessageBox(cc->m_hWnd, "获取消息队列失败， 请联系开发人员...", "error", MB_YESNO);
    95. 		return;
    96. 	}
    97. 	//2.循环获取 PushAddFriendMsg 消息类型的消息
    98. 	while (1) {
    99. 		std::string msg;
    100. 		mq->Pop(PushAddFriendMsg, &msg);
    101.  
    102. 		ChatMsg cm;
    103. 		cm.PraseChatMsg(-1, msg);
    104. 		std::string adder_nickname = cm.json_msg_["adder_nickname"].asString();
    105. 		std::string adder_school = cm.json_msg_["adder_school"].asString();
    106. 		int adder_userid = cm.json_msg_["adder_userid"].asInt();
    107. 		//3.通过获取的消息内容， 展示是那个用户想要添加自己
    108. 		std::string show_msg = adder_nickname + ":" + adder_school + " want add you as friend.";
    109.  
    110. 		cm.Clear();
    111. 		int i = MessageBox(cc->m_hWnd, show_msg.c_str(), "添加好友", MB_YESNO);
    112. 		if (i == IDYES) {
    113. 			//同意添加
    114. 			//a. 将新好友信息维护起来
    115. 			struct UserInfo ui;
    116. 			ui.nickname_ = adder_nickname;
    117. 			ui.school_ = adder_school;
    118. 			ui.user_id_ = adder_userid;
    119. 			ui.msg_cnt_ = 0;
    120. 			cc->fri_vec_.push_back(ui);
    121. 			//b. 刷新用户列表
    122. 			cc->RefreshUserList();
    123. 			//c. 组织应答
    124. 			cm.msg_type_ = PushAddFriendMsg_Resp;
    125. 			cm.reply_status_ = ADDFRIEND_SUCCESS;
    126. 			cm.user_id_ = cc->user_id_; // 被添加方的id、
    127. 			cm.json_msg_["userid"] = adder_userid;
    128. 		}
    129. 		else {
    130. 			//不同意添加
    131. 			//a. 组织应答
    132. 			cm.msg_type_ = PushAddFriendMsg_Resp;
    133. 			cm.reply_status_ = ADDFRIEND_FAILED;
    134. 			cm.user_id_ = cc->user_id_; // 被添加方的id、
    135. 			cm.json_msg_["userid"] = adder_userid;
    136. 		}
    137. 		msg.clear();
    138. 		cm.GetMsg(&msg);
    139. 		//4.根据不同结果返回应答
    140. 		TcpSvr* ts = TcpSvr::getInstance();
    141. 		if (ts == NULL) {
    142. 			continue;
    143. 		}
    144. 		ts->Send(msg);
    145. 	}
    146.  
    147.  
    148. }
    149.  
    150. //能够调用到这个线程函数， 说明当前客户端作为添加方
    151. void DealAddFriendResp(CDialogChatWin* cc) {
    152. 	//1.获取消息队列实例化指针 & tcp的实例化指针
    153. 	MsgQueue* mq = MsgQueue::GetInstance();
    154. 	if (mq == NULL) {
    155. 		MessageBox(cc->m_hWnd, "获取消息队列失败， 请联系开发人员...", "error", MB_YESNO);
    156. 		return;
    157. 	}
    158. 	//2.循环获取 PushAddFriendMsg 消息类型的消息
    159. 	while (1) {
    160. 		std::string msg;
    161. 		mq->Pop(AddFriend_Resp, &msg);
    162.  
    163. 		ChatMsg cm;
    164. 		cm.PraseChatMsg(-1, msg);
    165. 		std::string content = cm.GetValue("content");
    166. 		MessageBox(cc->m_hWnd, content.c_str(), "添加好友应答", MB_OK);
    167. 		if (cm.reply_status_ == ADDFRIEND_FAILED) {
    168. 			continue;
    169. 		}
    170. 		std::string be_adder_nickname = cm.json_msg_["peer_nick_name"].asString();
    171. 		std::string be_adder_school = cm.json_msg_["peer_school"].asString();
    172. 		int be_adder_userid = cm.json_msg_["peer_userid"].asInt();
    173.  
    174. 		//a. 将新好友信息维护起来
    175. 		struct UserInfo ui;
    176. 		ui.nickname_ = be_adder_nickname;
    177. 		ui.school_ = be_adder_school;
    178. 		ui.user_id_ = be_adder_userid;
    179. 		ui.msg_cnt_ = 0;
    180. 		cc->fri_vec_.push_back(ui);
    181. 		//b. 刷新用户列表
    182. 		cc->RefreshUserList();
    183.  
    184. 	}
    185. }
    186.  
    187.  
    188.  
    189. BOOL CDialogChatWin::OnInitDialog()
    190. {
    191. 	CDialogEx::OnInitDialog();
    192.  
    193. 	// TODO:  在此添加额外的初始化
    194. 	std::thread recv_msg(DealPushMsg, this);
    195. 	recv_msg.detach();
    196.  
    197. 	std::thread recv_addfriendmsg(DealPushAddFriendMsg, this);
    198. 	recv_addfriendmsg.detach();
    199.  
    200. 	std::thread recv_addfriendrespmsg(DealAddFriendResp, this);
    201. 	recv_addfriendrespmsg.detach();
    202. 	// TODO:  在此添加额外的初始化
    203. 	//1. 获取TCP实例化指针
    204. 	TcpSvr* ts = TcpSvr::getInstance();
    205. 	if (ts == NULL) {
    206. 		MessageBox("获取tcp服务失败， 请重试..");
    207. 		return false;
    208. 	}
    209. 	//2. 组织获取好友信息的数据
    210. 	ChatMsg cm;
    211. 	cm.msg_type_ = GetFriendMsg;
    212. 	cm.user_id_ = user_id_;
    213. 	std::string msg;
    214. 	cm.GetMsg(&msg);
    215. 	ts->Send(msg);
    216. 	//3. 解析应答
    217. 	MsgQueue* mq = MsgQueue::GetInstance();
    218. 	if (mq == NULL) {
    219. 		MessageBox("获取消息队列失败， 请联系开发人员...");
    220. 		return false;
    221. 	}
    222. 	msg.clear();
    223. 	mq->Pop(GetFriendMsg_Resp, &msg);
    224. 	//4. 展示好友信息到userlist（展示？ 要不要保存呢？）
    225. 	cm.Clear();
    226.  
    227. 	cm.PraseChatMsg(-1, msg);
    228. 	for (int i = 0; i < (int)cm.json_msg_.size(); i++) {
    229.  
    230. 		struct UserInfo ui;
    231. 		ui.nickname_ = cm.json_msg_[i]["nickname"].asString();
    232. 		ui.school_ = cm.json_msg_[i]["school"].asString();
    233. 		ui.user_id_ = cm.json_msg_[i]["userid"].asInt();
    234. 		ui.msg_cnt_ = 0;
    235.  
    236. 		if (i == 0) {
    237. 			send_user_id_ = ui.user_id_;
    238. 		}
    239.  
    240. 		fri_vec_.push_back(ui);
    241. 	}
    242.  
    243. 	//5.刷新userlist
    244. 	RefreshUserList();
    245.  
    246. 	return TRUE;  // return TRUE unless you set the focus to a control
    247. 				  // 异常: OCX 属性页应返回 FALSE
    248. }
    249.  
    250.  
    251.  
    252. BOOL CDialogChatWin::PreTranslateMessage(MSG* pMsg)
    253. {
    254. 	// TODO: 在此添加专用代码和/或调用基类
    255. 	if (pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_RETURN) {
    256. 		OnBnClickedButtonsendmsg();
    257. 		return TRUE;
    258. 	}
    259.  
    260. 	if (pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_ESCAPE) {
    261. 		return TRUE;
    262. 	}
    263.  
    264. 	return CDialogEx::PreTranslateMessage(pMsg);
    265. }
    266.  
    267. void CDialogChatWin::OnBnClickedButtonsendmsg()
    268. {
    269. 	// TODO: 在此添加控件通知处理程序代码
    270. 		//1. 获取输入框的内容
    271. 	UpdateData(TRUE);
    272. 	if (m_sendmsg_.IsEmpty()) {
    273. 		MessageBox(TEXT("输入内容不能为空"));
    274. 		return;
    275. 	}
    276. 	//2. 组织发送消息
    277. 	ChatMsg cm;
    278. 	cm.msg_type_ = SendMsg;
    279. 	//消息是谁发的
    280. 	cm.user_id_ = user_id_;
    281. 	//消息发给谁
    282. 	cm.json_msg_["recvmsgid"] = send_user_id_;
    283. 	//消息内容
    284. 	cm.json_msg_["msg"] = m_sendmsg_.GetString();
    285.  
    286. 	std::string msg;
    287. 	cm.GetMsg(&msg);
    288. 	TcpSvr* ts = TcpSvr::getInstance();
    289. 	if (ts == NULL) {
    290. 		MessageBox("获取tcp服务失败， 请重试..");
    291. 		return;
    292. 	}
    293. 	//3. 将这个消息发送出去
    294. 	ts->Send(msg);
    295. 	//4. 接收应答， 判断消息是否发送成功了
    296. 	MsgQueue* mq = MsgQueue::GetInstance();
    297. 	if (mq == NULL) {
    298. 		MessageBox("获取消息队列失败， 请联系开发人员...");
    299. 		return;
    300. 	}
    301. 	msg.clear();
    302. 	mq->Pop(SendMsg_Resp, &msg);
    303. 	cm.Clear();
    304. 	cm.PraseChatMsg(-1, msg);
    305. 	//5. 添加到该好友的历史消息当中， 并且展示到输出框
    306. 	for (size_t i = 0; i < fri_vec_.size(); i++) {
    307. 		if (send_user_id_ == fri_vec_[i].user_id_) {
    308. 			std::string tmp = "我: ";
    309. 			tmp += m_sendmsg_.GetString();
    310. 			if (cm.reply_status_ == SENDMSG_SUCCESS) {
    311. 				tmp += " (send success)";
    312. 			}
    313. 			else {
    314. 				tmp += " (send failed)";
    315. 			}
    316. 			fri_vec_[i].history_msg_.push_back(tmp);
    317. 			m_output_.InsertString(m_output_.GetCount(), tmp.c_str());
    318. 			//m_output_.AddString(tmp.c_str());
    319. 		}
    320. 	}
    321.  
    322. 	//6. 清空编辑框
    323. 	m_sendmsg_.Empty();
    324. 	m_sendmsg_edit_.SetWindowTextA(0);
    325. }
    326.  
    327.  
    328.  
    329.  
    330. void CDialogChatWin::OnLbnSelchangeListfriendlist()
    331. {
    332. 	// TODO: 在此添加控件通知处理程序代码
    333. 		//1. 获取点击的文本内容
    334. 	CString strText;
    335. 	int cur = m_userlist_.GetCurSel();
    336. 	m_userlist_.GetText(cur, strText);
    337. 	//2. 判断当前点击的是哪一个用户， 更改发送id
    338. 	for (size_t i = 0; i < fri_vec_.size(); i++) {
    339. 		if (strstr(strText, fri_vec_[i].nickname_.c_str()) != NULL) {
    340. 			send_user_id_ = fri_vec_[i].user_id_;
    341. 		}
    342. 	}
    343. 	//3. 清空output区域
    344. 	for (int i = m_output_.GetCount(); i >= 0; i--) {
    345. 		m_output_.DeleteString(i);
    346. 	}
    347. 	//4. 展示该用户的历史消息
    348. 	for (size_t i = 0; i < fri_vec_.size(); i++) {
    349. 		if (send_user_id_ == fri_vec_[i].user_id_) {
    350. 			//把历史消息展示再output区域
    351. 			for (size_t j = 0; j < fri_vec_[i].history_msg_.size(); j++) {
    352. 				m_output_.AddString(fri_vec_[i].history_msg_[j].c_str());
    353. 			}
    354.  
    355. 			fri_vec_[i].msg_cnt_ = 0;
    356. 		}
    357. 	}
    358. 	//5. 刷新userlist
    359. 	RefreshUserList();
    360. }
    361.  
    362. void CDialogChatWin::RefreshUserList() {
    363. 	int Count = m_userlist_.GetCount();
    364. 	//先清空
    365. 	for (int i = Count; i >= 0; i--) {
    366. 		m_userlist_.DeleteString(i);
    367. 	}
    368. 	//再展示
    369. 	for (int i = 0; i < (int)fri_vec_.size(); i++) {
    370. 		std::string tmp = fri_vec_[i].nickname_;
    371. 		//当该好友的未读消息个数是大于0 的时候， 展示未读消息个数
    372. 		if (fri_vec_[i].msg_cnt_ > 0) {
    373. 			tmp += " : ";
    374. 			tmp += std::to_string(fri_vec_[i].msg_cnt_);
    375. 		}
    376. 		m_userlist_.AddString(tmp.c_str());
    377. 	}
    378. }
    379.  
    380.  
    381. void CDialogChatWin::OnBnClickedButtonaddfriend()
    382. {
    383. 	// TODO: 在此添加控件通知处理程序代码
    384. 		//1.获取消息队列实例化指针 & tcp的实例化指针
    385. 	CDialogAddFriend caf(user_id_);
    386. 	caf.DoModal();
    387. }
    388.  
    389.  
    390.  
    391.  
    392.

    2.4添加好友界面及消息流转

    1. // CDialogAddFriend.cpp: 实现文件
    2. //
    3.  
    4. #include "pch.h"
    5. #include "ChatSystemLd.h"
    6. #include "CDialogAddFriend.h"
    7. #include "afxdialogex.h"
    8.  
    9.  
    10. #include 
    11. #include "ChatMsg.h"
    12. #include "MsgQueue.h"
    13. #include "TcpSvr.h"
    14.  
    15. // CDialogAddFriend 对话框
    16.  
    17. IMPLEMENT_DYNAMIC(CDialogAddFriend, CDialogEx)
    18.  
    19. CDialogAddFriend::CDialogAddFriend(int user_id,CWnd* pParent /*=nullptr*/)
    20. 	: CDialogEx(IDD_DIALOGADDFRIEND, pParent)
    21. 	, m_fri_telnum_(_T(""))
    22. 	,user_id_(user_id)
    23. {
    24.  
    25. }
    26.  
    27. CDialogAddFriend::~CDialogAddFriend()
    28. {
    29. }
    30.  
    31. void CDialogAddFriend::DoDataExchange(CDataExchange* pDX)
    32. {
    33. 	CDialogEx::DoDataExchange(pDX);
    34. 	DDX_Text(pDX, IDC_EDITTELNUM, m_fri_telnum_);
    35. }
    36.  
    37.  
    38. BEGIN_MESSAGE_MAP(CDialogAddFriend, CDialogEx)
    39. 	ON_BN_CLICKED(IDC_BUTTONADD, &CDialogAddFriend::OnBnClickedButtonadd)
    40. END_MESSAGE_MAP()
    41.  
    42.  
    43. // CDialogAddFriend 消息处理程序
    44.  
    45.  
    46. void CDialogAddFriend::OnBnClickedButtonadd()
    47. {
    48. 	// TODO: 在此添加控件通知处理程序代码
    49. 		//1.获取用户的输入
    50. 	UpdateData(TRUE);//获取输入控件当中最新的值
    51. 	if (m_fri_telnum_.IsEmpty())
    52. 	{
    53. 		MessageBox("输入内容不能为空");
    54. 		return;
    55. 	}
    56. 	//2.组织登录消息ChatMsg
    57. 	ChatMsg cm;
    58. 	cm.msg_type_ = AddFriend;
    59. 	//消息是谁发的
    60. 	cm.user_id_ = user_id_;
    61. 	//消息内容
    62. 	cm.json_msg_["telnum"] = m_fri_telnum_.GetString();
    63. 	std::string msg;
    64. 	cm.GetMsg(&msg);
    65.  
    66. 	//3.获取TCP服务的指针
    67. 	TcpSvr* ts = TcpSvr::getInstance();
    68. 	if (ts == nullptr)
    69. 	{
    70. 		MessageBox("获取tcp服务失败");
    71. 		return;
    72. 	}
    73. 	//4.发送登录消息
    74. 	ts->Send(msg);
    75. 	CDialog::OnCancel();//取消添加好友界面
    76. 	//线程等待接收应答,因为添加好友的应答不会立即到
    77. }

    四、产品的测试（视频演示）

    TCP聊天系统测试

  • 相关阅读:
    【2023集创赛】加速科技杯三等奖作品：私密性高精度刷手身份认证系统
    Python笔记二之多线程
    简易机器学习笔记（十一）opencv 简易使用-人脸识别、分类任务
    不断完成新项目才能升职？前首席工程师“怒喷”谷歌晋升机制
    手机通过WiFi连接调试UR机器人
    最新版SpringBoot整合Mybatis，实现增删改查（CRUD）
    centos中nacos设置开机自启动
    【漏洞复现】typecho_v1.0-14.10.10_unserialize
    从 DevOps 到平台工程：软件开发的新范式
    一款带数字传输信号的OVP芯片
  • 原文地址：https://blog.csdn.net/qq_57822158/article/details/126170184