• 项目网页聊天室

    目录

    1.ubuntu导入sql文件

     2.用.c文件生成库文件

     3.序列化 反序列化测试

    4. 第一次用postman测试注册功能

    5.用postman测试用户登录成功后跳转页面 ---302

     6.项目网页聊天室总结

    1.ubuntu导入sql文件

    sql文件：

     使用命令mysql -uroot -p

    结果如下：

     2.用.c文件生成库文件

     3.序列化 反序列化测试

    vi util.hpp:

    1. #include
    2. #include
    3. #include
    4. #include
    5.  
    6. namespace im_sys{
    7.  
    8.   class JsonUtil{
    9.    public:
    10.        static bool Serialize(Json::Value &value,std::string *jsonstr)
    11.        {
    12.           std::stringstream ss;
    13.           Json::StreamWriterBuilder swb;
    14.           Json::StreamWriter *sw = swb.newStreamWriter();
    15.           int ret = sw->write(value,&ss);
    16.           if(ret !=0)
    17.           {
    18.            std::cout<<"json writer failed!\n";
    19.            delete sw;
    20.            return true;
    21.           }
    22.        *jsonstr = ss.str();
    23.        delete sw;
    24.        return true;
    25.       }
    26.  
    27.       
    28.       static bool UnSerialize(const std::string &jsonstr,Json::Value *value)
    29.        {
    30.          Json::CharReaderBuilder crb;
    31.          Json::CharReader *cr = crb.newCharReader();
    32.          std::string err;
    33.          bool ret = cr->parse(jsonstr.c_str(),jsonstr.c_str() + jsonstr.size(),value,&err);
    34.         if(ret == false)
    35.          {
    36.           delete cr;
    37.           std::cout<<"json parse failed!"<
    38.           return false;
    39.          }
    40.         delete cr;
    41.         return true;
    42.      }
    43.  };
    44. }
    45.

    vi json_test.cpp:

    1. #include "util.hpp"
    2.  int main()
    3.  {
    4.    std::string str = R"({"username":"wj","password":"1111"})";
    5.    Json::Value val;
    6.    im_sys::JsonUtil::UnSerialize(str,&val);
    7.    std::cout<"username"].asString()<
    8.    std::cout<"password"].asString()<
    9.  
    10.    Json::Value err;
    11.    err["result"]=false;
    12.    err["reason"] = "用户名已经被占用!";
    13.    std::string buf;
    14.    im_sys::JsonUtil::Serialize(err,&buf);
    15.    std::cout<
    16.  
    17.    return 0;
    18. }

    测试结果：

    4. 第一次用postman测试注册功能

    server.hpp  ---/register功能的相应实现

    1. #include "data.hpp"
    2. #include "mongoose.h"
    3. #include "util.hpp"
    4. namespace im_sys{
    5. #define SERVER_PORT 20000
    6.  class Server
    7.    {
    8.     private:
    9.          static struct mg_mgr *_mgr;
    10.          static UserTable *_user;
    11.    private:
    12.            static void callback(struct mg_connection *c,int ev,void *ev_data,void *fn_data)
    13.            {
    14.              if(ev == MG_EV_HTTP_MSG)
    15.              {
    16.                struct mg_http_message *hm = (struct mg_http_message *)ev_data;
    17.                if(mg_http_match_uri(hm,"/register"))
    18.                {
    19.                  // mg_http_reply(c,200,"","register success!");
    20.                  // return;
    21.                 //拿到请求信息的正文，是json格式的用户信息，进行解析
    22.                 Json::Value user_info;
    23.                 JsonUtil::UnSerialize(hm->body.ptr,&user_info);
    24.                 std::string username = user_info["username"].asString();
    25.                 std::string password = user_info["password"].asString();
    26.                  
    27.          
    28.                  //在数据库中进行查看用户名是否已经被占用
    29.                  bool ret = _user->Exists(username);
    30.                     if(ret == true)
    31.                     {
    32.                       Json::Value err;
    33.                       err["result"] = false;
    34.                       err["reason"] = "用户名已经被占用";
    35.                       std::string body;
    36.                       JsonUtil::Serialize(err,&body);
    37.                       std::string header = "Content-Type:application/json\r\n";
    38.                       mg_http_reply(c,400,header.c_str(),body.c_str());
    39.                        return; 
    40.                      }
    41.                  //返回结果--注册成功或失败
    42.                  ret = _user->Insert(username,password);
    43.                     if(ret == false)
    44.                     {
    45.                        Json::Value err;
    46.                        err["result"] = false;
    47.                        err["reason"] = "用户插入数据库失败！";
    48.                        std::string body;
    49.                        JsonUtil::Serialize(err,&body);
    50.                        std::string header = "Content-Type: application/json\r\n";
    51.                        mg_http_reply(c,200,header.c_str(),body.c_str());
    52.                        return;
    53.                     }
    54.                     Json::Value err;
    55.                     err["result"] = true;
    56.                     err["reason"] = "注册成功!";
    57.                     std::string body;
    58.                     JsonUtil::Serialize(err,&body);
    59.                     std::string header = "Content-Type:application/json\r\n";
    60.                     mg_http_reply(c,200,header.c_str(),body.c_str());
    61.                        return;
    62.            }
    63.      }
    64.   }
    65.  
    66.    
    67.     public:
    68.          Server()
    69.          {
    70.             _mgr = new struct mg_mgr();
    71.             _user = new UserTable();
    72.           }
    73.  
    74.         ~Server()
    75.         {
    76.           mg_mgr_free(_mgr);
    77.           delete _mgr;
    78.           delete _user;
    79.  
    80.         }
    81.         bool RunModule(int port = SERVER_PORT)
    82.         {
    83.           std::string addr = "0.0.0.0:";
    84.           addr += std::to_string(port);
    85.           auto res = mg_http_listen(_mgr,addr.c_str(),callback,_mgr);
    86.           if(res ==NULL)
    87.            {
    88.                 std::cout<<"init http listen failed!\n";
    89.                 return false;
    90.            }
    91.            
    92.             while(1)
    93.             {
    94.               mg_mgr_poll(_mgr,1000);
    95.             }
    96.              return true;
    97.             
    98.          }
    99.    
    100.          
    101.         
    102.    };
    103.   struct mg_mgr *Server::_mgr = NULL;
    104.   UserTable * Server::_user = NULL;
    105.  
    106.  }

    makefile:

    1. main:data.hpp main.cpp
    2. 	g++ -std=c++11 $^ -o $@ -L/usr/lib/mysql  -lmysqlclient -L./lib -lmongoose -ljsoncpp

    main.cpp:

    1. #include "data.hpp"
    2. #include "server.hpp"
    3. #define OFFLINE 0
    4. #define ONLINE 1
    5. void DataTest()
    6. {
    7.    im_sys::UserTable * _user = new im_sys::UserTable();
    8.  
    9.   //插入用户 
    10.   // _user->Insert("王五","1111");
    11.   
    12.  
    13.   //测试用户是否存在
    14.   // bool ret = _user->Exists("王五");
    15.   // std::cout<
    16.  
    17.  
    18.   // 判断用户是否在线
    19.   // int status = _user->Status("王五");
    20.   // if(status ==ONLINE)
    21.   // {
    22.   //  std::cout<<"online!\n";
    23.   // }
    24.   // else if(status == OFFLINE)
    25.   // {
    26.   // std::cout<<"offline!\n";
    27.   // }
    28.  
    29.   //修改用户状态
    30.   _user->UpdateStatus("王五",OFFLINE);
    31.   
    32.   int status = _user->Status("王五");
    33.    if(status ==ONLINE)
    34.    {
    35.      std::cout<<"online!\n";
    36.    }
    37.    else if(status == OFFLINE)
    38.    {
    39.       std::cout<<"offline!\n";
    40.    }
    41.  
    42.   //检验密码
    43.  // bool ret = _user->UserPassCheck("王五","1111");
    44.  // if(ret == false)
    45.  // {
    46.  // std::cout<<"用户名密码错误!\n";
    47.  // }
    48.  // else 
    49.  // {
    50.  // std::cout<<"login success!\n";
    51.  // }
    52.  //}
    53.  
    54.  //修改密码
    55.  // _user->UpdatePasswd("王五","1111");
    56.  // int ret =_user->UserPassCheck("王五","1111");
    57.   
    58.  // if(ret == false)
    59.  // {
    60.  //  std::cout<<"用户名密码错误!\n";
    61.  // }
    62.  //  else 
    63.  // {
    64.  //  std::cout<<"login success!\n";
    65.  // }
    66.  }
    67.  
    68.  
    69.  
    70. void ServerTest()
    71. {
    72.   im_sys::Server *server = new im_sys::Server();
    73.   server->RunModule();
    74.   return;
    75. }
    76.  
    77. int main()
    78. {
    79.  // DataTest();
    80.  ServerTest();
    81.  return 0;
    82. }

    data.hpp:

    1. #ifndef __M_IM_DATA_H__
    2. #define __M_IM_DATA_H__
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8.  
    9. namespace im_sys{
    10. #define DB_HOST "127.0.0.1"
    11. #define DB_USER "root"
    12. #define DB_PASS "1111"
    13. #define DB_NAME "db_96"
    14.   static MYSQL *MysqlInit()
    15.   {
    16.     MYSQL *mysql = mysql_init(NULL);
    17.     if(mysql == NULL)
    18.     {
    19.       std::cout<<"mysql init failed!\n";
    20.       return NULL;
    21.     }
    22.     if(mysql_real_connect(mysql,DB_HOST,DB_USER,DB_PASS,DB_NAME,0,NULL,0) == NULL)
    23.     {
    24.      std::cout<<"connect mysql server failed:"<<mysql_error(mysql)<
    25.      mysql_close(mysql);
    26.      return NULL;
    27.     }
    28.      if(mysql_set_character_set(mysql,"utf8") != 0)
    29.     {
    30.      std::cout<<"set mysql client character failed!:"<<mysql_error(mysql)<
    31.      mysql_close(mysql);
    32.      return NULL;
    33.     }
    34.   return mysql;
    35. }
    36.   static void MysqlDestory(MYSQL *mysql)
    37.   {
    38.     if(mysql)
    39.     {
    40.       mysql_close(mysql);
    41.     }
    42.     return;
    43.   }
    44.  
    45.   static bool MysqlQuery(MYSQL *mysql,const std::string &sql)
    46.   {
    47.    int ret = mysql_query(mysql,sql.c_str());
    48.    if(ret != 0)
    49.    {
    50.      std::cout<
    51.      std::cout<<"query failed:"<<mysql_error(mysql)<
    52.      return false;
    53.    }
    54.   return true;
    55.  }
    56.  
    57.   class UserTable{
    58.  
    59.     private:
    60.          MYSQL *_mysql;
    61.          std::mutex _mutex;
    62.     public:
    63.         UserTable():_mysql(NULL)
    64.         {
    65.          _mysql = MysqlInit();
    66.          if(_mysql == NULL)
    67.          {
    68.           exit(-1);
    69.          }
    70.         }
    71.  
    72.         ~UserTable()
    73.         {
    74.            MysqlDestory(_mysql);
    75.         }
    76.         bool Insert(const std::string &name,const std::string &pass)
    77.         {
    78.          #define USER_INSERT "insert im_user values(null,'%s',MD5('%s'),0,now(),now());"
    79.         char sql[4096] = {0};
    80.         sprintf(sql,USER_INSERT,name.c_str(),pass.c_str());
    81.         return MysqlQuery(_mysql,sql);
    82.  
    83.         }
    84.  
    85.      bool Exists(const std::string &name)
    86.      {
    87.        #define USER_EXISTS "select id from im_user where name='%s';"
    88.        char sql[4096] = {0};
    89.        sprintf(sql,USER_EXISTS,name.c_str());
    90.        bool ret = MysqlQuery(_mysql,sql);
    91.        if(ret == false)
    92.        {
    93.         return false;
    94.        }
    95.        MYSQL_RES *res = mysql_store_result(_mysql);
    96.        int num = mysql_num_rows(res);
    97.        if(num!=0)
    98.         {
    99.           mysql_free_result(res);
    100.           return true;
    101.         }
    102.        mysql_free_result(res);
    103.       return false;
    104.     }
    105.   
    106.       bool UserPassCheck(const std::string &name,const std::string &pass)
    107.      {
    108.          #define USER_CHECK "select id from im_user where name='%s' and pass=MD5('%s');"
    109.         char sql[4096] = {0};
    110.         sprintf(sql,USER_CHECK,name.c_str(),pass.c_str());
    111.         bool ret = MysqlQuery(_mysql,sql);
    112.         if(ret == false)
    113.          {
    114.           return false;
    115.          }
    116.           MYSQL_RES *res = mysql_store_result(_mysql);
    117.          int num = mysql_num_rows(res);
    118.          if(num!=0)
    119.           {
    120.             mysql_free_result(res);
    121.             return true;
    122.           }
    123.         mysql_free_result(res);
    124.            return false;
    125.      }
    126.       int  Status(const std::string &name)
    127.      {
    128.       #define USER_STATUS "select status from im_user where name='%s';"
    129.        char sql[4096]={0};
    130.        sprintf(sql,USER_STATUS,name.c_str());
    131.        bool ret = MysqlQuery(_mysql,sql);
    132.        if(ret == false)
    133.        {
    134.          return false;
    135.        }
    136.        MYSQL_RES *res = mysql_store_result(_mysql);
    137.        int num = mysql_num_rows(res);
    138.        if(num == 0)
    139.        {
    140.          mysql_free_result(res);
    141.           return -1;
    142.        }
    143.        MYSQL_ROW row = mysql_fetch_row(res);
    144.        int status = std::stoi(row[0]);
    145.        mysql_free_result(res);
    146.        return status;
    147.       }
    148.      bool UpdateStatus(const std::string &name,int status)
    149.      {
    150.         #define USER_UPDATE_STATUS "update im_user set status=%d,stime=now() where name='%s';"
    151.        char sql[4096] = {0};
    152.        sprintf(sql,USER_UPDATE_STATUS,status,name.c_str());
    153.        return MysqlQuery(_mysql,sql);
    154.      }
    155.     
    156.    
    157.     bool UpdatePasswd(const std::string &name,const std::string &pass)
    158.      {
    159.        #define USER_UPDATE_PASS "update im_user set pass=MD5('%s') where name='%s';"
    160.       char sql[4096] = {0};
    161.       sprintf(sql,USER_UPDATE_PASS,pass.c_str(),name.c_str());
    162.       return MysqlQuery(_mysql,sql);
    163.    }
    164.  
    165.  
    166.      };
    167.  
    168. }
    169.  
    170. #endif

    结果如下：

    5.用postman测试用户登录成功后跳转页面 ---302

    server.hpp:

    1. #include "data.hpp"
    2. #include "mongoose.h"
    3. #include "util.hpp"
    4. #include 
    5. #include 
    6. namespace im_sys{
    7. #define SERVER_PORT 20000
    8. #define OFFLINE 0
    9. #define ONLINE 1
    10. #define WWWROOT "./wwwroot/"
    11.  
    12. struct IMSession
    13. {
    14.    int status;
    15.    std::string session_id;//系统时间
    16.    std::string username;
    17.    time_t ctime;//会话创建时间
    18.    time_t ltime;//最后操作时间
    19.    struct mg_connection *conn;//当前用户对一个的mongoose连接
    20. };
    21.  
    22.  
    23.  
    24.  class Server
    25.    {
    26.     private:
    27.          static struct mg_mgr *_mgr;
    28.          static UserTable *_user;
    29.          static std::unordered_map _session;
    30.    private:
    31.          static std::string ConResp(bool res,const std::string &info)
    32.           {
    33.            Json::Value err;
    34.            err["result"] = res;
    35.            err["reason"] = info;
    36.            std::string body;
    37.            JsonUtil::Serialize(err,&body);
    38.            return body;
    39.            }
    40.  
    41.          static  std::string CreateIMSession(struct mg_connection *c,const std::string &username)
    42.            {
    43.              struct IMSession s;
    44.              s.conn = c;
    45.              s.username = username;
    46.              s.status = ONLINE;
    47.              s.ctime = time(NULL);
    48.              s.ltime = time(NULL);
    49.              s.session_id = std::to_string(time(NULL));
    50.              _session[s.session_id] = s;
    51.              return s.session_id;
    52.            }
    53.  
    54.  
    55.            static void Login(struct mg_connection *c,struct mg_http_message *hm)
    56.           {
    57.              //拿到请求正文，进行json反序列化得到用户名和密码
    58.              Json::Value user_info;
    59.              JsonUtil::UnSerialize(hm->body.ptr,&user_info);
    60.              std::string username = user_info["username"].asString();
    61.              std::string password = user_info["password"].asString();
    62.             //在数据库中验证用户名和密码
    63.              bool ret = _user->UserPassCheck(username,password);
    64.             if(ret == false)
    65.               {
    66.                 std::string body = ConResp(false,"用户名密码错误");
    67.                 std::string header = "Content-Type: application/json\r\n";
    68.                 mg_http_reply(c,400,header.c_str(),body.c_str());
    69.                 return;
    70.              }
    71.  
    72.             //判断用户是否已经在线，若已经在线，则不能重复登录
    73.                ret = _user->Status(username);
    74.                if(ret == ONLINE)
    75.               {
    76.                 std::string body = ConResp(false,"用户已登录");
    77.                 std::string header = "Content-Type: application/json\r\n";
    78.                 mg_http_reply(c,400,header.c_str(),body.c_str());
    79.                 return;
    80.                }
    81.             //没在线，则修改用户为在线状态，并且返回登录成功，设置SetCookie包括用户名、用户状态
    82.             std::string ssid =  CreateIMSession(c,username);
    83.             ret = _user->UpdateStatus(username,ONLINE);
    84.             if(ret == false)
    85.             {
    86.               std::string body = ConResp(false,"修改用户状态失败");
    87.               std::string header = "Content-Type: application/json\r\n";
    88.               mg_http_reply(c,500,header.c_str(),body.c_str());
    89.                return;
    90.             }
    91.  
    92.             //登录成功需要让客户端去请求一个聊天页面
    93.             std::stringstream headers;
    94.             headers<< "Location: /chat.html\r\n";
    95.             headers <<"Set-Cookie: SSID=" <";Path=/\r\n";
    96.            
    97.             std::string body = ConResp(true,"登录成功");
    98.             mg_http_reply(c,302,headers.str().c_str(),body.c_str());
    99.             return;
    100.       }
    101.  
    102.            static void  Register(struct mg_connection *c,struct mg_http_message *hm)
    103.           {
    104.      
    105.                 //拿到请求信息的正文，是json格式的用户信息，进行解析
    106.                 Json::Value user_info;
    107.                 JsonUtil::UnSerialize(hm->body.ptr,&user_info);
    108.                 std::string username = user_info["username"].asString();
    109.                 std::string password = user_info["password"].asString();
    110.                  
    111.          
    112.                  //在数据库中进行查看用户名是否已经被占用
    113.                  bool ret = _user->Exists(username);
    114.                     if(ret == true)
    115.                     {
    116.                       Json::Value err;
    117.                       err["result"] = false;
    118.                       err["reason"] = "用户名已经被占用";
    119.                       std::string body;
    120.                       JsonUtil::Serialize(err,&body);
    121.                       std::string header = "Content-Type:application/json\r\n";
    122.                       mg_http_reply(c,400,header.c_str(),body.c_str());
    123.                        return; 
    124.                      }
    125.                  //返回结果--注册成功或失败
    126.                  ret = _user->Insert(username,password);
    127.                     if(ret == false)
    128.                     {
    129.                        Json::Value err;
    130.                        err["result"] = false;
    131.                        err["reason"] = "用户插入数据库失败！";
    132.                        std::string body;
    133.                        JsonUtil::Serialize(err,&body);
    134.                        std::string header = "Content-Type: application/json\r\n";
    135.                        mg_http_reply(c,200,header.c_str(),body.c_str());
    136.                        return;
    137.                     }
    138.                     Json::Value err;
    139.                     err["result"] = true;
    140.                     err["reason"] = "注册成功!";
    141.                     std::string body;
    142.                     JsonUtil::Serialize(err,&body);
    143.                     std::string header = "Content-Type:application/json\r\n";
    144.                     mg_http_reply(c,200,header.c_str(),body.c_str());
    145.                        return;
    146.           }
    147.  
    148.           static bool GetSession(struct mg_connection *c,IMSession *session)
    149.            {
    150.               auto it = _session.begin();
    151.               for(;it!=_session.end();++it)
    152.               {
    153.                 if(it->second.conn == c)
    154.                   {
    155.                     *session = it->second;
    156.                      return true;
    157.                    }
    158.                }
    159.             return false;
    160.            }
    161.  
    162.            static bool DelSession(IMSession &session)
    163.            {
    164.              auto it = _session.find(session.session_id);
    165.              if(it == _session.end())
    166.              {
    167.                std::cout<<"not find session\n";
    168.                return false;
    169.              }
    170.             _session.erase(it);
    171.             return true;
    172.             }
    173.  
    174.  
    175.  
    176.             static void ConnClose(struct mg_connection *c)
    177.            {
    178.              //找到连接对应的session
    179.               IMSession session;
    180.              bool ret = GetSession(c,&session);
    181.              if(ret == false)
    182.              {
    183.                 std::cout<<"have no session info!\n";
    184.                 return;
    185.              }
    186.              //修改数据库中的用户状态
    187.               ret = _user->UpdateStatus(session.username,OFFLINE);
    188.               if(ret == false)
    189.               {
    190.                std::cout<<"update status offline failed!\n";
    191.                return;
    192.               }
    193.              //删除会话信息
    194.               DelSession(session);
    195.               } 
    196.  
    197.            static void callback(struct mg_connection *c,int ev,void *ev_data,void *fn_data)
    198.            {
    199.              if(ev == MG_EV_HTTP_MSG)
    200.              {
    201.                struct mg_http_message *hm = (struct mg_http_message *)ev_data;
    202.                  if(mg_http_match_uri(hm,"/register"))
    203.                  {
    204.                    // mg_http_reply(c,200,"","register success!");
    205.                    // return;
    206.                    Register(c,hm);
    207.                  }
    208.                  else if(mg_http_match_uri(hm,"/login"))
    209.                  {
    210.                    //登录请求
    211.                      Login(c,hm);
    212.                  }
    213.                  else if(mg_http_match_uri(hm,"/cws"))
    214.                  {
    215.                    //协议切换请求
    216.                  }
    217.                  else
    218.                  {
    219.                     //静态页面请求
    220.                       struct mg_http_serve_opts opts = {.root_dir = WWWROOT};
    221.                       mg_http_serve_dir(c,hm,&opts);
    222.                  }
    223.             }
    224.             else if(ev == MG_EV_WS_OPEN)
    225.               {
    226.                 //websocket握手成功
    227.  
    228.               }
    229.             else if(ev == MG_EV_WS_MSG)
    230.               {
    231.                 //收到聊天消息
    232.               }
    233.             else if(ev == MG_EV_CLOSE)
    234.               {
    235.                 //表示连接断开
    236.                  ConnClose(c); 
    237.               }
    238.  
    239.  
    240.  
    241.  
    242.   }
    243.  
    244.    
    245.     public:
    246.          Server()
    247.          {
    248.             _mgr = new struct mg_mgr();
    249.             _user = new UserTable();
    250.           }
    251.  
    252.         ~Server()
    253.         {
    254.           mg_mgr_free(_mgr);
    255.           delete _mgr;
    256.           delete _user;
    257.  
    258.         }
    259.         bool RunModule(int port = SERVER_PORT)
    260.         {
    261.           std::string addr = "0.0.0.0:";
    262.           addr += std::to_string(port);
    263.           auto res = mg_http_listen(_mgr,addr.c_str(),callback,_mgr);
    264.           if(res ==NULL)
    265.            {
    266.                 std::cout<<"init http listen failed!\n";
    267.                 return false;
    268.            }
    269.            
    270.             while(1)
    271.             {
    272.               mg_mgr_poll(_mgr,1000);
    273.             }
    274.              return true;
    275.             
    276.          }
    277.    
    278.          
    279.         
    280.    };
    281.   struct mg_mgr *Server::_mgr = NULL;
    282.   UserTable * Server::_user = NULL;
    283.   std::unordered_mapServer::_session;
    284.  
    285.  }

     makefile:

    1. main:data.hpp main.cpp
    2. 	g++ -std=c++11 $^ -o $@ -L/usr/lib/mysql  -lmysqlclient -L./lib -lmongoose -ljsoncpp

    结果如下：

     6.项目网页聊天室总结

    环境搭建：

     1）ubuntu安装mysql    

    https://blog.csdn.net/weixin_42209572/article/details/98983741https://blog.csdn.net/weixin_42209572/article/details/98983741

    2）ubuntu安装mongoose http库   

    链接：https://pan.baidu.com/s/1kMaSz5rduAr5Cs0a88LhrQ  提取码：1111 

          ---主要用到了mongoose.c和mongoose.h两个文件

    3）ubuntu安装jsoncpp库 

    (65条消息) Ubuntu16.04 jsoncpp 的安装_只此冒泡君的博客-CSDN博客_ubuntu安装jsoncpphttps://blog.csdn.net/qing310820/article/details/84283650

    4）打开VM虚拟机，通过ifconfig获取主机名，在项目chat.html中修改ws_init方法中的主机名，端口号不用修改。

    结果：

    登录三个会话进行聊天，测试结果如下：

  • 相关阅读:
    Error response from daemon
    设计模式-创建型模式-单例模式
    list容器（20221117）
    【路由优化】基于matlab随机搜索算法优化带有速度的路由网络【含Matlab源码 2046期】
    模拟字符串函数
    对数组进行扩容
    C++中编写没有参数和返回值的函数
    四种强大且隐秘的缓存
    【SpringBoot】配置文件分类
    CDN许可证申请
  • 原文地址：https://blog.csdn.net/weixin_46153828/article/details/126340661