相关介绍
技术栈
- Json序列化和反序列化
- muduo网络库开发
- nginx源码编译安装和环境配置
- redis缓存服务器编程实践
- 基于发布-订阅的服务器中间件redis消息队列编程实践
- MySQL数据库编程
- CMake构建编译环境
- Github托管项目
项目需求
1. 客户端新用户注册
2. 客户端用户登录
3. 添加好友和添加群组
4. 好友聊天
5. 群组聊天
6. 离线消息
7. nginx配置tcp负载均衡
8. 集群聊天系统支持客户端跨服务器通信
项目目标
1. 掌握服务器的网络I/O模块，业务模块，数据模块分层的设计思想。
2. 掌握C++ muduo网络库的编程以及实现原理
3. 掌握Json的编程应用
4. 掌握nginx配置部署tcp负载均衡器的应用以及原理
5. 掌握服务器中间件的应用场景和基于发布-订阅的redis编程实践以及应用原理
6. 掌握CMake构建自动化编译环境
7. 掌握Github管理项目
开发环境
ubuntu+Json+boost+muduo+redis+mysql+nginx+cmake
项目内容
网络模块直接使用了moduo库基于reactor模型(基于事件驱动、IO复用，epoll加线程池的网络模型。)，有一个主reactor是IO线程，三个sub reactor是工作线程，主reactor主要负责新用户的连接，子reactor负责连接用户的读写事件的处理。
public.hpp
#ifndef PUBLIC_H
#define PUBLIC_H
/*
server和client的公共文件
*/
enum EnMsgType
{
LOGIN_MSG = 1, // 登录消息
LOGIN_MSG_ACK, // 登录响应消息
LOGINOUT_MSG, // 注销消息
REG_MSG, // 注册消息
REG_MSG_ACK, // 注册响应消息
ONE_CHAT_MSG, // 聊天消息
ADD_FRIEND_MSG, // 添加好友消息
CREATE_GROUP_MSG, // 创建群组
ADD_GROUP_MSG, // 加入群组
GROUP_CHAT_MSG, // 群聊天
};
#endif网络模块和业务模块解耦，通过绑定器和回调函数。大致思路如下
// 表示处理消息的事件回调方法类型(function表示存储函数的通用容器)
using MsgHandler = std::function<void(const TcpConnectionPtr &conn, json &js, Timestamp)>;
//用于将消息映射到对应的处理函数
unordered_map<int, MsgHandler> _msgHandlerMap;
//std::bind 是一个函数适配器，它将成员函数ChatService::login绑定到特定的对象this上，同时为这个函数预留占位符_1、_2、_3，表示这个函数可以接受三个参数。
//&ChatService::login:这是一个指向ChatService类的login成员函数的指针。login函数的签名应该是一个能够接受三个参数的成员函数。
//将ChatService类的login函数与LOGIN_MSG消息类型关联起来，并将这个关联存储在消息处理映射表_msgHandlerMap中。之后，当LOGIN_MSG类型的消息到达时，系统可以通过查找_msgHandlerMap来调用login函数并传递相应的参数。
_msgHandlerMap.insert({LOGIN_MSG, std::bind(&ChatService::login, this, _1, _2, _3)});
获取消息对应的处理器
// 获取消息对应的处理器
MsgHandler getHandler(int msgid);
MsgHandler ChatService::getHandler(int msgid)
{
// 记录错误日志，msgid没有对应的事件处理回调
auto it = _msgHandlerMap.find(msgid);
if (it == _msgHandlerMap.end())
{
//使用moduo库的日志
// 返回一个默认的处理器，空操作
return [=](const TcpConnectionPtr &conn, json &js, Timestamp) {
LOG_ERROR << "msgid:" << msgid << " can not find handler!";
};
}
else
{
return _msgHandlerMap[msgid];
}
}
//lambda表达式的捕获列表，[=]表示捕获外部作用域中的所有变量（包括msgid）并以值传递的方式在lambda表达式中使用。chatserver.hpp
#ifndef CHATSERVER_H
#define CHATSERVER_H
#include <muduo/net/TcpServer.h>
#include <muduo/net/EventLoop.h>
using namespace muduo;
using namespace muduo::net;
// 聊天服务器的主类
class ChatServer
{
public:
// 初始化聊天服务器对象
ChatServer(EventLoop *loop,
const InetAddress &listenAddr,
const string &nameArg);
// 启动服务
void start();
private:
// 上报链接相关信息的回调函数
void onConnection(const TcpConnectionPtr &);
// 上报读写事件相关信息的回调函数
void onMessage(const TcpConnectionPtr &,
Buffer *,
Timestamp);
TcpServer _server; // 组合的muduo库，实现服务器功能的类对象
EventLoop *_loop; // 指向事件循环对象的指针
};
#endifchatserver.cpp
chatservice.hpp
#ifndef CHATSERVICE_H
#define CHATSERVICE_H
#include <muduo/net/TcpConnection.h>
#include <unordered_map>
#include <functional>
#include <mutex>
using namespace std;
using namespace muduo;
using namespace muduo::net;
#include "redis.hpp"
#include "groupmodel.hpp"
#include "friendmodel.hpp"
#include "usermodel.hpp"
#include "offlinemessagemodel.hpp"
#include "json.hpp"
using json = nlohmann::json;
// 表示处理消息的事件回调方法类型
using MsgHandler = std::function<void(const TcpConnectionPtr &conn, json &js, Timestamp)>;
// 聊天服务器业务类
class ChatService
{
public:
// 获取单例对象的接口函数
static ChatService* instance();
// 处理登录业务
void login(const TcpConnectionPtr &conn, json &js, Timestamp time);
// 处理注册业务
void reg(const TcpConnectionPtr &conn, json &js, Timestamp time);
// 一对一聊天业务
void oneChat(const TcpConnectionPtr &conn, json &js, Timestamp time);
// 添加好友业务
void addFriend(const TcpConnectionPtr &conn, json &js, Timestamp time);
// 创建群组业务
void createGroup(const TcpConnectionPtr &conn, json &js, Timestamp time);
// 加入群组业务
void addGroup(const TcpConnectionPtr &conn, json &js, Timestamp time);
// 群组聊天业务
void groupChat(const TcpConnectionPtr &conn, json &js, Timestamp time);
// 处理注销业务
void loginout(const TcpConnectionPtr &conn, json &js, Timestamp time);
// 处理客户端异常退出
void clientCloseException(const TcpConnectionPtr &conn);
// 服务器异常，业务重置方法
void reset();
// 获取消息对应的处理器
MsgHandler getHandler(int msgid);
// 从redis消息队列中获取订阅的消息
void handleRedisSubscribeMessage(int, string);
private:
ChatService();
//一个消息id映射一个事件处理
// 存储消息id和其对应的业务处理方法
unordered_map<int, MsgHandler> _msgHandlerMap;
// 存储在线用户的通信连接
unordered_map<int, TcpConnectionPtr> _userConnMap;
// 定义互斥锁，保证_userConnMap的线程安全
mutex _connMutex;
// 数据操作类对象
UserModel _userModel;
OfflineMsgModel _offlineMsgModel;
FriendModel _friendModel;
GroupModel _groupModel;
// redis操作对象
Redis _redis;
};
#endifchatservice.cpp
#include "chatservice.hpp"
#include "public.hpp"
#include <muduo/base/Logging.h>//muduo库的日志
#include <vector>
using namespace std;
using namespace muduo;
// 获取单例对象的接口函数
ChatService* ChatService::instance()
{
static ChatService service;
return &service;
}
// 注册消息以及对应的Handler回调操作
ChatService::ChatService()
{
// 用户基本业务管理相关事件处理回调注册
_msgHandlerMap.insert({LOGIN_MSG, std::bind(&ChatService::login, this, _1, _2, _3)});
_msgHandlerMap.insert({LOGINOUT_MSG, std::bind(&ChatService::loginout, this, _1, _2, _3)});
_msgHandlerMap.insert({REG_MSG, std::bind(&ChatService::reg, this, _1, _2, _3)});
_msgHandlerMap.insert({ONE_CHAT_MSG, std::bind(&ChatService::oneChat, this, _1, _2, _3)});
_msgHandlerMap.insert({ADD_FRIEND_MSG, std::bind(&ChatService::addFriend, this, _1, _2, _3)});
// 群组业务管理相关事件处理回调注册
_msgHandlerMap.insert({CREATE_GROUP_MSG, std::bind(&ChatService::createGroup, this, _1, _2, _3)});
_msgHandlerMap.insert({ADD_GROUP_MSG, std::bind(&ChatService::addGroup, this, _1, _2, _3)});
_msgHandlerMap.insert({GROUP_CHAT_MSG, std::bind(&ChatService::groupChat, this, _1, _2, _3)});
// 连接redis服务器
if (_redis.connect())
{
// 设置上报消息的回调
_redis.init_notify_handler(std::bind(&ChatService::handleRedisSubscribeMessage, this, _1, _2));
}
}
// 服务器异常，业务重置方法
void ChatService::reset()
{
// 把online状态的用户，设置成offline
_userModel.resetState();
}
// 获取消息对应的处理器
MsgHandler ChatService::getHandler(int msgid)
{
// 记录错误日志，msgid没有对应的事件处理回调
auto it = _msgHandlerMap.find(msgid);
if (it == _msgHandlerMap.end())
{
//使用moduo库的日志
// 返回一个默认的处理器，空操作
return [=](const TcpConnectionPtr &conn, json &js, Timestamp) {
LOG_ERROR << "msgid:" << msgid << " can not find handler!";
};
}
else
{
return _msgHandlerMap[msgid];
}
}
// 处理登录业务 id pwd pwd
void ChatService::login(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int id = js["id"].get<int>();
string pwd = js["password"];
User user = _userModel.query(id);
if (user.getId() == id && user.getPwd() == pwd)
{
if (user.getState() == "online")
{
// 该用户已经登录，不允许重复登录
json response;
response["msgid"] = LOGIN_MSG_ACK;
response["errno"] = 2;
response["errmsg"] = "this account is using, input another!";
conn->send(response.dump());
}
else
{
// 登录成功，记录用户连接信息
{
lock_guard<mutex> lock(_connMutex);
_userConnMap.insert({id, conn});
}
// id用户登录成功后，向redis订阅channel(id)
_redis.subscribe(id);
// 登录成功，更新用户状态信息 state offline=>online
user.setState("online");
_userModel.updateState(user);
json response;
response["msgid"] = LOGIN_MSG_ACK;
response["errno"] = 0;
response["id"] = user.getId();
response["name"] = user.getName();
// 查询该用户是否有离线消息
vector<string> vec = _offlineMsgModel.query(id);
if (!vec.empty())
{
response["offlinemsg"] = vec;
// 读取该用户的离线消息后，把该用户的所有离线消息删除掉
_offlineMsgModel.remove(id);
}
// 查询该用户的好友信息并返回
vector<User> userVec = _friendModel.query(id);
if (!userVec.empty())
{
vector<string> vec2;
for (User &user : userVec)
{
json js;
js["id"] = user.getId();
js["name"] = user.getName();
js["state"] = user.getState();
vec2.push_back(js.dump());
}
response["friends"] = vec2;
}
// 查询用户的群组信息
vector<Group> groupuserVec = _groupModel.queryGroups(id);
if (!groupuserVec.empty())
{
// group:[{groupid:[xxx, xxx, xxx, xxx]}]
vector<string> groupV;
for (Group &group : groupuserVec)
{
json grpjson;
grpjson["id"] = group.getId();
grpjson["groupname"] = group.getName();
grpjson["groupdesc"] = group.getDesc();
vector<string> userV;
for (GroupUser &user : group.getUsers())
{
json js;
js["id"] = user.getId();
js["name"] = user.getName();
js["state"] = user.getState();
js["role"] = user.getRole();
userV.push_back(js.dump());
}
grpjson["users"] = userV;
groupV.push_back(grpjson.dump());
}
response["groups"] = groupV;
}
conn->send(response.dump());
}
}
else
{
// 该用户不存在，用户存在但是密码错误，登录失败
json response;
response["msgid"] = LOGIN_MSG_ACK;
response["errno"] = 1;
response["errmsg"] = "id or password is invalid!";
conn->send(response.dump());
}
}
// 处理注册业务 name password
void ChatService::reg(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
string name = js["name"];
string pwd = js["password"];
User user;
user.setName(name);
user.setPwd(pwd);
bool state = _userModel.insert(user);
if (state)
{
// 注册成功
json response;
response["msgid"] = REG_MSG_ACK;
response["errno"] = 0;
response["id"] = user.getId();
conn->send(response.dump());
}
else
{
// 注册失败
json response;
response["msgid"] = REG_MSG_ACK;
response["errno"] = 1;
conn->send(response.dump());
}
}
// 处理注销业务
void ChatService::loginout(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
{
lock_guard<mutex> lock(_connMutex);
auto it = _userConnMap.find(userid);
if (it != _userConnMap.end())
{
_userConnMap.erase(it);
}
}
// 用户注销，相当于就是下线，在redis中取消订阅通道
_redis.unsubscribe(userid);
// 更新用户的状态信息
User user(userid, "", "", "offline");
_userModel.updateState(user);
}
// 处理客户端异常退出
void ChatService::clientCloseException(const TcpConnectionPtr &conn)
{
User user;
{
lock_guard<mutex> lock(_connMutex);
for (auto it = _userConnMap.begin(); it != _userConnMap.end(); ++it)
{
if (it->second == conn)
{
// 从map表删除用户的链接信息
user.setId(it->first);
_userConnMap.erase(it);
break;
}
}
}
// 用户注销，相当于就是下线，在redis中取消订阅通道
_redis.unsubscribe(user.getId());
// 更新用户的状态信息
if (user.getId() != -1)
{
user.setState("offline");
_userModel.updateState(user);
}
}
// 一对一聊天业务
void ChatService::oneChat(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int toid = js["toid"].get<int>();
{
lock_guard<mutex> lock(_connMutex);
auto it = _userConnMap.find(toid);
if (it != _userConnMap.end())
{
// toid在线，转发消息 服务器主动推送消息给toid用户
it->second->send(js.dump());
return;
}
}
// 查询toid是否在线
User user = _userModel.query(toid);
if (user.getState() == "online")
{
_redis.publish(toid, js.dump());
return;
}
// toid不在线，存储离线消息
_offlineMsgModel.insert(toid, js.dump());
}
// 添加好友业务 msgid id friendid
void ChatService::addFriend(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
int friendid = js["friendid"].get<int>();
// 存储好友信息
_friendModel.insert(userid, friendid);
}
// 创建群组业务
void ChatService::createGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
string name = js["groupname"];
string desc = js["groupdesc"];
// 存储新创建的群组信息
Group group(-1, name, desc);
if (_groupModel.createGroup(group))
{
// 存储群组创建人信息
_groupModel.addGroup(userid, group.getId(), "creator");
}
}
// 加入群组业务
void ChatService::addGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
int groupid = js["groupid"].get<int>();
_groupModel.addGroup(userid, groupid, "normal");
}
// 群组聊天业务
void ChatService::groupChat(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
int groupid = js["groupid"].get<int>();
vector<int> useridVec = _groupModel.queryGroupUsers(userid, groupid);
lock_guard<mutex> lock(_connMutex);
for (int id : useridVec)
{
auto it = _userConnMap.find(id);
if (it != _userConnMap.end())
{
// 转发群消息
it->second->send(js.dump());//js.dump将json数据序列化位字符串形式
}
else
{
// 查询toid是否在线
User user = _userModel.query(id);
if (user.getState() == "online")
{
_redis.publish(id, js.dump());
}
else
{
// 存储离线群消息
_offlineMsgModel.insert(id, js.dump());
}
}
}
}
// 从redis消息队列中获取订阅的消息
void ChatService::handleRedisSubscribeMessage(int userid, string msg)
{
lock_guard<mutex> lock(_connMutex);
auto it = _userConnMap.find(userid);
if (it != _userConnMap.end())
{
it->second->send(msg);
return;
}
// 存储该用户的离线消息
_offlineMsgModel.insert(userid, msg);
}注意这个map的设计，会被多个线程调用，考虑线程安全问题，添加互斥锁(在chatservice(单例模式)中定义一把锁)，
unordered_map<int, TcpConnectionPtr> _userConnMap;// 存储在线用户的通信连接
mutex _connMutex;// 定义互斥锁，保证_userConnMap的线程安全
作用域{ }，锁的粒度要小。lock_guard出了右括号就释放锁了
ORM框架(object relation map)对象关系映射，帮助OOP解决了这个问题，业务层操作的都是对象，数据层封装了具体的有数据库相关的操作。把数据库操作封装成了一个类
cmakelists中添加，依赖这些so库
db.h
#ifndef DB_H
#define DB_H
#include <mysql/mysql.h>
#include <string>
using namespace std;
// 数据库操作类
class MySQL
{
public:
// 初始化数据库连接
MySQL();
// 释放数据库连接资源
~MySQL();
// 连接数据库
bool connect();
// 更新操作
bool update(string sql);
// 查询操作
MYSQL_RES *query(string sql);
// 获取连接
MYSQL* getConnection();
private:
MYSQL *_conn;
};
#endifdb.cpp
#include "db.h"
#include <muduo/base/Logging.h>
// 数据库配置信息
static string server = "127.0.0.1";
static string user = "root";
static string password = "123456";
static string dbname = "chat";
// 初始化数据库连接
MySQL::MySQL()
{
_conn = mysql_init(nullptr);
}
// 释放数据库连接资源
MySQL::~MySQL()
{
if (_conn != nullptr)
mysql_close(_conn);
}
// 连接数据库
bool MySQL::connect()
{
MYSQL *p = mysql_real_connect(_conn, server.c_str(), user.c_str(),
password.c_str(), dbname.c_str(), 3306, nullptr, 0);
if (p != nullptr)
{
// C和C++代码默认的编码字符是ASCII，如果不设置，从MySQL上拉下来的中文显示？
mysql_query(_conn, "set names gbk");
LOG_INFO << "connect mysql success!";
}
else
{
LOG_INFO << "connect mysql fail!";
}
return p;
}
// 更新操作
bool MySQL::update(string sql)
{
if (mysql_query(_conn, sql.c_str()))
{
LOG_INFO << __FILE__ << ":" << __LINE__ << ":"
<< sql << "更新失败!";
return false;
}
return true;
}
// 查询操作
MYSQL_RES *MySQL::query(string sql)
{
if (mysql_query(_conn, sql.c_str()))
{
LOG_INFO << __FILE__ << ":" << __LINE__ << ":"
<< sql << "查询失败!";
return nullptr;
}
return mysql_use_result(_conn);
}
// 获取连接
MYSQL* MySQL::getConnection()
{
return _conn;
}业务层操作对象，需要定义对象，// User表的ORM类
#ifndef USER_H
#define USER_H
#include <string>
using namespace std;
// User表的ORM类
class User
{
public:
User(int id = -1, string name = "", string pwd = "", string state = "offline")
{
this->id = id;
this->name = name;
this->password = pwd;
this->state = state;
}
void setId(int id) { this->id = id; }
void setName(string name) { this->name = name; }
void setPwd(string pwd) { this->password = pwd; }
void setState(string state) { this->state = state; }
int getId() { return this->id; }
string getName() { return this->name; }
string getPwd() { return this->password; }
string getState() { return this->state; }
protected:
int id;
string name;
string password;
string state;
};
#endifuser表的业务具体操作类，数据操作类usermodel.hpp
#ifndef USERMODEL_H
#define USERMODEL_H
#include "user.hpp"
// User表的数据操作类
class UserModel {
public:
// User表的增加方法
bool insert(User &user);
// 根据用户号码查询用户信息
User query(int id);
// 更新用户的状态信息
bool updateState(User user);
// 重置用户的状态信息
void resetState();
};
#endif数据操作类usermodel.cpp
#include "usermodel.hpp"
#include "db.h"
#include <iostream>
using namespace std;
// User表的增加方法
bool UserModel::insert(User &user)
{
// 1.组装sql语句
char sql[1024] = {0};
sprintf(sql, "insert into user(name, password, state) values('%s', '%s', '%s')",
user.getName().c_str(), user.getPwd().c_str(), user.getState().c_str());
MySQL mysql;
if (mysql.connect())
{
if (mysql.update(sql))
{
// 获取插入成功的用户数据生成的主键id
user.setId(mysql_insert_id(mysql.getConnection()));
return true;
}
}
return false;
}
// 根据用户号码查询用户信息
User UserModel::query(int id)
{
// 1.组装sql语句
char sql[1024] = {0};
sprintf(sql, "select * from user where id = %d", id);
MySQL mysql;
if (mysql.connect())
{
MYSQL_RES *res = mysql.query(sql);
if (res != nullptr)
{
MYSQL_ROW row = mysql_fetch_row(res);
if (row != nullptr)
{
User user;
user.setId(atoi(row[0]));
user.setName(row[1]);
user.setPwd(row[2]);
user.setState(row[3]);
mysql_free_result(res);
return user;
}
}
}
return User();
}
// 更新用户的状态信息
bool UserModel::updateState(User user)
{
// 1.组装sql语句
char sql[1024] = {0};
sprintf(sql, "update user set state = '%s' where id = %d", user.getState().c_str(), user.getId());
MySQL mysql;
if (mysql.connect())
{
if (mysql.update(sql))
{
return true;
}
}
return false;
}
// 重置用户的状态信息
void UserModel::resetState()
{
// 1.组装sql语句
char sql[1024] = "update user set state = 'offline' where state = 'online'";
MySQL mysql;
if (mysql.connect())
{
mysql.update(sql);
}
}使用ctrl+c退出时，用户表的在线信息并没有及时更新。使用信号捕获函数。
当程序接收到SIGINT信号时，调用resetHandler函数来处理这个信号。具体的处理逻辑由resetHandler函数实现。SIGINT: 这是一个预定义的信号常量，表示“中断信号”（Interrupt Signal）。通常当用户在终端按下Ctrl+C时，会向正在运行的前台进程发送SIGINT信号。这通常用于请求进程终止运行。
#include "chatserver.hpp"
#include "chatservice.hpp"
#include <iostream>
#include <signal.h>
using namespace std;
// 处理服务器ctrl+c结束后，重置user的状态信息
void resetHandler(int)
{
ChatService::instance()->reset();
exit(0);
}
int main(int argc, char **argv)
{
if (argc < 3)
{
cerr << "command invalid! example: ./ChatServer 127.0.0.1 6000" << endl;
exit(-1);
}
// 解析通过命令行参数传递的ip和port
char *ip = argv[1];
uint16_t port = atoi(argv[2]);
signal(SIGINT, resetHandler);
EventLoop loop;
InetAddress addr(ip, port);
ChatServer server(&loop, addr, "ChatServer");
server.start();
loop.loop();
return 0;
}客户端是一个网络程序， 但是它不需要高并发，因为又没有人去连接它，我们网络编程采用原始的基于Linux的TCP客户端编程。从业务上来说，用户刚开始执行客户端，有一个登录注册，还有一个退出，当注册的时候可以注册新用户登录，输入用户名，输入用户ID用户号和密码，发送一个登录的请求到这个服务器来验证你的ID及密码是否正确，正确的话就进入正式的聊天页面的菜单。
客户端与服务器端通信协议就是json。showCurrentUserData()显示当前登录成功用户的基本信息。包括login user、friend list、group list。
main.cpp(client)
#include "json.hpp"
#include <iostream>
#include <thread>
#include <string>
#include <vector>
#include <chrono>
#include <ctime>
#include <unordered_map>
#include <functional>
using namespace std;
using json = nlohmann::json;
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <semaphore.h>
#include <atomic>
#include "group.hpp"
#include "user.hpp"
#include "public.hpp"
// 记录当前系统登录的用户信息
User g_currentUser;
// 记录当前登录用户的好友列表信息
vector<User> g_currentUserFriendList;
// 记录当前登录用户的群组列表信息
vector<Group> g_currentUserGroupList;
// 控制主菜单页面程序
bool isMainMenuRunning = false;
// 用于读写线程之间的通信
sem_t rwsem;
// 记录登录状态
atomic_bool g_isLoginSuccess{false};
// 接收线程
void readTaskHandler(int clientfd);
// 获取系统时间（聊天信息需要添加时间信息）
string getCurrentTime();
// 主聊天页面程序
void mainMenu(int);
// 显示当前登录成功用户的基本信息
void showCurrentUserData();
// 聊天客户端程序实现，main线程用作发送线程，子线程用作接收线程
int main(int argc, char **argv)
{
if (argc < 3)
{
cerr << "command invalid! example: ./ChatClient 127.0.0.1 6000" << endl;
exit(-1);
}
// 解析通过命令行参数传递的ip和port
char *ip = argv[1];
uint16_t port = atoi(argv[2]);
// 创建client端的socket
int clientfd = socket(AF_INET, SOCK_STREAM, 0);
if (-1 == clientfd)
{
cerr << "socket create error" << endl;
exit(-1);
}
// 填写client需要连接的server信息ip+port
sockaddr_in server;
memset(&server, 0, sizeof(sockaddr_in));
server.sin_family = AF_INET;
server.sin_port = htons(port);
server.sin_addr.s_addr = inet_addr(ip);
// client和server进行连接
if (-1 == connect(clientfd, (sockaddr *)&server, sizeof(sockaddr_in)))
{
cerr << "connect server error" << endl;
close(clientfd);
exit(-1);
}
// 初始化读写线程通信用的信号量
sem_init(&rwsem, 0, 0);
// 连接服务器成功，启动接收子线程
std::thread readTask(readTaskHandler, clientfd); // pthread_create
readTask.detach(); // pthread_detach
// main线程用于接收用户输入，负责发送数据
for (;;)
{
// 显示首页面菜单 登录、注册、退出
cout << "========================" << endl;
cout << "1. login" << endl;
cout << "2. register" << endl;
cout << "3. quit" << endl;
cout << "========================" << endl;
cout << "choice:";
int choice = 0;
cin >> choice;
cin.get(); // 读掉缓冲区残留的回车
switch (choice)
{
case 1: // login业务
{
int id = 0;
char pwd[50] = {0};
cout << "userid:";
cin >> id;
cin.get(); // 读掉缓冲区残留的回车
cout << "userpassword:";
cin.getline(pwd, 50);
json js;
js["msgid"] = LOGIN_MSG;
js["id"] = id;
js["password"] = pwd;
string request = js.dump();
g_isLoginSuccess = false;
int len = send(clientfd, request.c_str(), strlen(request.c_str()) + 1, 0);
if (len == -1)
{
cerr << "send login msg error:" << request << endl;
}
sem_wait(&rwsem); // 等待信号量，由子线程处理完登录的响应消息后，通知这里
if (g_isLoginSuccess)
{
// 进入聊天主菜单页面
isMainMenuRunning = true;
mainMenu(clientfd);
}
}
break;
case 2: // register业务
{
char name[50] = {0};
char pwd[50] = {0};
cout << "username:";
cin.getline(name, 50);
cout << "userpassword:";
cin.getline(pwd, 50);
json js;
js["msgid"] = REG_MSG;
js["name"] = name;
js["password"] = pwd;
string request = js.dump();
int len = send(clientfd, request.c_str(), strlen(request.c_str()) + 1, 0);
if (len == -1)
{
cerr << "send reg msg error:" << request << endl;
}
sem_wait(&rwsem); // 等待信号量，子线程处理完注册消息会通知
}
break;
case 3: // quit业务
close(clientfd);
sem_destroy(&rwsem);
exit(0);
default:
cerr << "invalid input!" << endl;
break;
}
}
return 0;
}
// 处理注册的响应逻辑
void doRegResponse(json &responsejs)
{
if (0 != responsejs["errno"].get<int>()) // 注册失败
{
cerr << "name is already exist, register error!" << endl;
}
else // 注册成功
{
cout << "name register success, userid is " << responsejs["id"]
<< ", do not forget it!" << endl;
}
}
// 处理登录的响应逻辑
void doLoginResponse(json &responsejs)
{
if (0 != responsejs["errno"].get<int>()) // 登录失败
{
cerr << responsejs["errmsg"] << endl;
g_isLoginSuccess = false;
}
else // 登录成功
{
// 记录当前用户的id和name
g_currentUser.setId(responsejs["id"].get<int>());
g_currentUser.setName(responsejs["name"]);
// 记录当前用户的好友列表信息
if (responsejs.contains("friends"))
{
// 初始化
g_currentUserFriendList.clear();
vector<string> vec = responsejs["friends"];
for (string &str : vec)
{
json js = json::parse(str);
User user;
user.setId(js["id"].get<int>());
user.setName(js["name"]);
user.setState(js["state"]);
g_currentUserFriendList.push_back(user);
}
}
// 记录当前用户的群组列表信息
if (responsejs.contains("groups"))
{
// 初始化
g_currentUserGroupList.clear();
vector<string> vec1 = responsejs["groups"];
for (string &groupstr : vec1)
{
json grpjs = json::parse(groupstr);
Group group;
group.setId(grpjs["id"].get<int>());
group.setName(grpjs["groupname"]);
group.setDesc(grpjs["groupdesc"]);
vector<string> vec2 = grpjs["users"];
for (string &userstr : vec2)
{
GroupUser user;
json js = json::parse(userstr);
user.setId(js["id"].get<int>());
user.setName(js["name"]);
user.setState(js["state"]);
user.setRole(js["role"]);
group.getUsers().push_back(user);
}
g_currentUserGroupList.push_back(group);
}
}
// 显示登录用户的基本信息
showCurrentUserData();
// 显示当前用户的离线消息 个人聊天信息或者群组消息
if (responsejs.contains("offlinemsg"))
{
vector<string> vec = responsejs["offlinemsg"];
for (string &str : vec)
{
json js = json::parse(str);
// time + [id] + name + " said: " + xxx
if (ONE_CHAT_MSG == js["msgid"].get<int>())
{
cout << js["time"].get<string>() << " [" << js["id"] << "]" << js["name"].get<string>()
<< " said: " << js["msg"].get<string>() << endl;
}
else
{
cout << "群消息[" << js["groupid"] << "]:" << js["time"].get<string>() << " [" << js["id"] << "]" << js["name"].get<string>()
<< " said: " << js["msg"].get<string>() << endl;
}
}
}
g_isLoginSuccess = true;
}
}
// 子线程 - 接收线程
void readTaskHandler(int clientfd)
{
for (;;)
{
char buffer[1024] = {0};
int len = recv(clientfd, buffer, 1024, 0); // 阻塞了
if (-1 == len || 0 == len)
{
close(clientfd);
exit(-1);
}
// 接收ChatServer转发的数据，反序列化生成json数据对象
json js = json::parse(buffer);
int msgtype = js["msgid"].get<int>();
if (ONE_CHAT_MSG == msgtype)
{
cout << js["time"].get<string>() << " [" << js["id"] << "]" << js["name"].get<string>()
<< " said: " << js["msg"].get<string>() << endl;
continue;
}
if (GROUP_CHAT_MSG == msgtype)
{
cout << "群消息[" << js["groupid"] << "]:" << js["time"].get<string>() << " [" << js["id"] << "]" << js["name"].get<string>()
<< " said: " << js["msg"].get<string>() << endl;
continue;
}
if (LOGIN_MSG_ACK == msgtype)
{
doLoginResponse(js); // 处理登录响应的业务逻辑
sem_post(&rwsem); // 通知主线程，登录结果处理完成
continue;
}
if (REG_MSG_ACK == msgtype)
{
doRegResponse(js);
sem_post(&rwsem); // 通知主线程，注册结果处理完成
continue;
}
}
}
// 显示当前登录成功用户的基本信息
void showCurrentUserData()
{
cout << "======================login user======================" << endl;
cout << "current login user => id:" << g_currentUser.getId() << " name:" << g_currentUser.getName() << endl;
cout << "----------------------friend list---------------------" << endl;
if (!g_currentUserFriendList.empty())
{
for (User &user : g_currentUserFriendList)
{
cout << user.getId() << " " << user.getName() << " " << user.getState() << endl;
}
}
cout << "----------------------group list----------------------" << endl;
if (!g_currentUserGroupList.empty())
{
for (Group &group : g_currentUserGroupList)
{
cout << group.getId() << " " << group.getName() << " " << group.getDesc() << endl;
for (GroupUser &user : group.getUsers())
{
cout << user.getId() << " " << user.getName() << " " << user.getState()
<< " " << user.getRole() << endl;
}
}
}
cout << "======================================================" << endl;
}
// "help" command handler
void help(int fd = 0, string str = "");
// "chat" command handler
void chat(int, string);
// "addfriend" command handler
void addfriend(int, string);
// "creategroup" command handler
void creategroup(int, string);
// "addgroup" command handler
void addgroup(int, string);
// "groupchat" command handler
void groupchat(int, string);
// "loginout" command handler
void loginout(int, string);
// 系统支持的客户端命令列表
unordered_map<string, string> commandMap = {
{"help", "显示所有支持的命令，格式help"},
{"chat", "一对一聊天，格式chat:friendid:message"},
{"addfriend", "添加好友，格式addfriend:friendid"},
{"creategroup", "创建群组，格式creategroup:groupname:groupdesc"},
{"addgroup", "加入群组，格式addgroup:groupid"},
{"groupchat", "群聊，格式groupchat:groupid:message"},
{"loginout", "注销，格式loginout"}};
// 注册系统支持的客户端命令处理
unordered_map<string, function<void(int, string)>> commandHandlerMap = {
{"help", help},
{"chat", chat},
{"addfriend", addfriend},
{"creategroup", creategroup},
{"addgroup", addgroup},
{"groupchat", groupchat},
{"loginout", loginout}};
// 主聊天页面程序
void mainMenu(int clientfd)
{
help();
char buffer[1024] = {0};
while (isMainMenuRunning)
{
cin.getline(buffer, 1024);
string commandbuf(buffer);
string command; // 存储命令
int idx = commandbuf.find(":");
if (-1 == idx)
{
command = commandbuf;
}
else
{
command = commandbuf.substr(0, idx);
}
auto it = commandHandlerMap.find(command);
if (it == commandHandlerMap.end())
{
cerr << "invalid input command!" << endl;
continue;
}
// 调用相应命令的事件处理回调，mainMenu对修改封闭，添加新功能不需要修改该函数
it->second(clientfd, commandbuf.substr(idx + 1, commandbuf.size() - idx)); // 调用命令处理方法
}
}
// "help" command handler
void help(int, string)
{
cout << "show command list >>> " << endl;
for (auto &p : commandMap)
{
cout << p.first << " : " << p.second << endl;
}
cout << endl;
}
// "addfriend" command handler
void addfriend(int clientfd, string str)
{
int friendid = atoi(str.c_str());
json js;
js["msgid"] = ADD_FRIEND_MSG;
js["id"] = g_currentUser.getId();
js["friendid"] = friendid;
string buffer = js.dump();
int len = send(clientfd, buffer.c_str(), strlen(buffer.c_str()) + 1, 0);
if (-1 == len)
{
cerr << "send addfriend msg error -> " << buffer << endl;
}
}
// "chat" command handler
void chat(int clientfd, string str)
{
int idx = str.find(":"); // friendid:message
if (-1 == idx)
{
cerr << "chat command invalid!" << endl;
return;
}
int friendid = atoi(str.substr(0, idx).c_str());
string message = str.substr(idx + 1, str.size() - idx);
json js;
js["msgid"] = ONE_CHAT_MSG;
js["id"] = g_currentUser.getId();
js["name"] = g_currentUser.getName();
js["toid"] = friendid;
js["msg"] = message;
js["time"] = getCurrentTime();
string buffer = js.dump();
int len = send(clientfd, buffer.c_str(), strlen(buffer.c_str()) + 1, 0);
if (-1 == len)
{
cerr << "send chat msg error -> " << buffer << endl;
}
}
// "creategroup" command handler groupname:groupdesc
void creategroup(int clientfd, string str)
{
int idx = str.find(":");
if (-1 == idx)
{
cerr << "creategroup command invalid!" << endl;
return;
}
string groupname = str.substr(0, idx);
string groupdesc = str.substr(idx + 1, str.size() - idx);
json js;
js["msgid"] = CREATE_GROUP_MSG;
js["id"] = g_currentUser.getId();
js["groupname"] = groupname;
js["groupdesc"] = groupdesc;
string buffer = js.dump();
int len = send(clientfd, buffer.c_str(), strlen(buffer.c_str()) + 1, 0);
if (-1 == len)
{
cerr << "send creategroup msg error -> " << buffer << endl;
}
}
// "addgroup" command handler
void addgroup(int clientfd, string str)
{
int groupid = atoi(str.c_str());
json js;
js["msgid"] = ADD_GROUP_MSG;
js["id"] = g_currentUser.getId();
js["groupid"] = groupid;
string buffer = js.dump();
int len = send(clientfd, buffer.c_str(), strlen(buffer.c_str()) + 1, 0);
if (-1 == len)
{
cerr << "send addgroup msg error -> " << buffer << endl;
}
}
// "groupchat" command handler groupid:message
void groupchat(int clientfd, string str)
{
int idx = str.find(":");
if (-1 == idx)
{
cerr << "groupchat command invalid!" << endl;
return;
}
int groupid = atoi(str.substr(0, idx).c_str());
string message = str.substr(idx + 1, str.size() - idx);
json js;
js["msgid"] = GROUP_CHAT_MSG;
js["id"] = g_currentUser.getId();
js["name"] = g_currentUser.getName();
js["groupid"] = groupid;
js["msg"] = message;
js["time"] = getCurrentTime();
string buffer = js.dump();
int len = send(clientfd, buffer.c_str(), strlen(buffer.c_str()) + 1, 0);
if (-1 == len)
{
cerr << "send groupchat msg error -> " << buffer << endl;
}
}
// "loginout" command handler
void loginout(int clientfd, string)
{
json js;
js["msgid"] = LOGINOUT_MSG;
js["id"] = g_currentUser.getId();
string buffer = js.dump();
int len = send(clientfd, buffer.c_str(), strlen(buffer.c_str()) + 1, 0);
if (-1 == len)
{
cerr << "send loginout msg error -> " << buffer << endl;
}
else
{
isMainMenuRunning = false;
}
}
// 获取系统时间（聊天信息需要添加时间信息）
string getCurrentTime()
{
auto tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
struct tm *ptm = localtime(&tt);
char date[60] = {0};
sprintf(date, "%d-%02d-%02d %02d:%02d:%02d",
(int)ptm->tm_year + 1900, (int)ptm->tm_mon + 1, (int)ptm->tm_mday,
(int)ptm->tm_hour, (int)ptm->tm_min, (int)ptm->tm_sec);
return std::string(date);
}项目问题
- 负载均衡在聊天服务器的意义
1.负载均衡器涉及到一个高性能的网络设备
2.可配置的多种负载算法
3.可以和后台服务器保持心跳，动态监测chat server的故障
- 如何解决跨服务器通信问题
引入第三方的消息队列，通过向消息队列发布消息、订阅消息、接收到消息队列推送来的消息解决跨服务器聊天通信问题。
- 为什么使用Redis作为中间件消息队列
使用基于发布订阅的redis作为中间件消息队列，相对Kafka等更轻量级一点，因为这个聊天业务场景最多也就是有单台的两万的用户扩展到三台的支持五六万的用户。kafka处理大型应用场景几十万的的并发场景。基于发布-订阅的消息队列，publish、subscribe、notify(类似于观察者模式),消息队列相当于观察者，观察事件发生。
- 如何配置nginx的tcp负载均衡？
nginx在1.9版本之前，只支持http协议web服务器的负载均衡，从1.9版本开始以后，nginx开始支持tcp的长连接负载均衡，但是 nginx默认并没有编译tcp负载均衡模块，编写它时，需要加入--with-stream参数来激活这个模块。编译：./configure->make->make install
关闭使用./nginx stop。不能使用kill直接杀掉nginx的进程号，因为它有容错机制，会自动重启。
可能问题
-
静态库和动态库的区别
静态库：代码在编译时已经链接到应用程序中的库。.a(Linux).lib(windows)
动态库：在程序运行时动态加载的库。.so(Linux).dll(windows)
区别：
链接时间：
静态库在编译时链接到可执行文件中，生成的可执行文件包含了所有库的代码。
动态库在运行时由操作系统加载，不会在编译时将库的代码直接包含到可执行文件中。
运行时依赖：
静态库：可执行文件独立，不依赖外部库文件，可以在目标系统上直接运行。
动态库：可执行文件依赖外部动态库，必须在运行时能够找到并加载这些库。
文件大小：
静态库：生成的可执行文件较大，因为包含了所有必要的库代码。
动态库：生成的可执行文件较小，实际的库代码保存在外部库文件中。
更新和维护：
静态库：更新库后，需要重新编译应用程序。
动态库：库可以独立更新，应用程序无需重新编译，只需在运行时加载更新后的库。
内存和资源使用：
静态库：每个使用静态库的可执行文件都有一份库的代码，占用更多的内存和磁盘空间。
动态库：多个应用程序可以共享一个动态库文件，节省内存和磁盘空间。
gcc -o main.cpp main.o -L/path/to/library -lmylibraycmake中链接库文件：
target_link_libraries(ChatServer muduo_net muduo_base mysqlclient hiredis pthread)-
如何使用 Muduo 网络库来提高并发网络 IO 服务吗？
muduo 是主从 Reactor 模型，有 mainReactor 和 subReactor。mainReactor通过 Acceptor 接收新连接，然后将新连接派发到 subReactor 上进行连接的维护。这样 mainReactor 可以只专注于监听新连接的到来，而从维护旧连接的业务中得到解放。同时多个 Reactor 可以并行运行在多核 CPU 中，增加服务效率。因此我们可以通过 muduo 快速完成网络模块。
-
如何将网络模块与业务模块解耦的？
使用 muduo 注册消息事件到来的回调函数，并根据得到的 MSGID 定位到不同的处理函数中。以此实现业务模块和网络模块的解耦。
// 表示处理消息的事件回调方法类型
using MsgHandler = std::function<void(const TcpConnectionPtr &conn, json &js, Timestamp)>; //一个消息id映射一个事件处理
// 存储消息id和其对应的业务处理方法
unordered_map<int, MsgHandler> _msgHandlerMap;
// 存储在线用户的通信连接
unordered_map<int, TcpConnectionPtr> _userConnMap;
// 定义互斥锁，保证_userConnMap的线程安全
mutex _connMutex;enum EnMsgType
{
LOGIN_MSG = 1, // 登录消息
LOGIN_MSG_ACK, // 登录响应消息
LOGINOUT_MSG, // 注销消息
REG_MSG, // 注册消息
REG_MSG_ACK, // 注册响应消息
ONE_CHAT_MSG, // 聊天消息
ADD_FRIEND_MSG, // 添加好友消息
CREATE_GROUP_MSG, // 创建群组
ADD_GROUP_MSG, // 加入群组
GROUP_CHAT_MSG, // 群聊天
};// 用户基本业务管理相关事件处理回调注册
_msgHandlerMap.insert({LOGIN_MSG, std::bind(&ChatService::login, this, _1, _2, _3)});
_msgHandlerMap.insert({LOGINOUT_MSG, std::bind(&ChatService::loginout, this, _1, _2, _3)});
_msgHandlerMap.insert({REG_MSG, std::bind(&ChatService::reg, this, _1, _2, _3)});
_msgHandlerMap.insert({ONE_CHAT_MSG, std::bind(&ChatService::oneChat, this, _1, _2, _3)});
_msgHandlerMap.insert({ADD_FRIEND_MSG, std::bind(&ChatService::addFriend, this, _1, _2, _3)});
// 群组业务管理相关事件处理回调注册
_msgHandlerMap.insert({CREATE_GROUP_MSG, std::bind(&ChatService::createGroup, this, _1, _2, _3)});
_msgHandlerMap.insert({ADD_GROUP_MSG, std::bind(&ChatService::addGroup, this, _1, _2, _3)});
_msgHandlerMap.insert({GROUP_CHAT_MSG, std::bind(&ChatService::groupChat, this, _1, _2, _3)});// 上报读写事件相关信息的回调函数
void ChatServer::onMessage(const TcpConnectionPtr &conn,
Buffer *buffer,
Timestamp time)
{
string buf = buffer->retrieveAllAsString();
// 测试，添加json打印代码
cout << buf << endl;
// 数据的反序列化
json js = json::parse(buf);
// 达到的目的：完全解耦网络模块的代码和业务模块的代码
//在OOP语言，解耦两种模块之间的方法，一种是面向接口编程，C++中没有所谓接口，
//C++中有抽象类，基于回调函数做到这一点
// 通过js["msgid"] 获取=》业务handler=》conn js time
auto msgHandler = ChatService::instance()->getHandler(js["msgid"].get<int>());
// 回调消息绑定好的事件处理器，来执行相应的业务处理
msgHandler(conn, js, time);
}业务模块是如何设计的
注册模块：
我们从网络模块接收数据，根据 MSGID 定位到注册模块。从传递过来的 json 对象中获取用户 ID 和用户密码。并以此生成 User 对象，调用 model 层方法将新生成的 User 插入到数据库中。
void ChatService::reg(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
string name = js["name"];
string pwd = js["password"];
User user;
user.setName(name);
user.setPwd(pwd);
bool state = _userModel.insert(user);
if (state)
{
// 注册成功
json response;
response["msgid"] = REG_MSG_ACK;
response["errno"] = 0;
response["id"] = user.getId();
conn->send(response.dump());
}
else
{
// 注册失败
json response;
response["msgid"] = REG_MSG_ACK;
response["errno"] = 1;
conn->send(response.dump());
}
}bool UserModel::insert(User &user)
{
// 1.组装sql语句
char sql[1024] = {0};
sprintf(sql, "insert into user(name, password, state) values('%s', '%s', '%s')",
user.getName().c_str(), user.getPwd().c_str(), user.getState().c_str());
MySQL mysql;
if (mysql.connect())
{
if (mysql.update(sql))
{
// 获取插入成功的用户数据生成的主键id
user.setId(mysql_insert_id(mysql.getConnection()));
return true;
}
}
return false;
}
登录模块：
从 json 对象中获取用户ID和密码，并在数据库中查询获取用户信息是否匹配。如果用户已经登录过，即 state == "online"，则返回错误信息。登录成功后需要在修改服务端的user表中记录登录用户，并显示该用户的好友列表和收到的离线消息。
void ChatService::login(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int id = js["id"].get<int>();
string pwd = js["password"];
User user = _userModel.query(id);
if (user.getId() == id && user.getPwd() == pwd)
{
if (user.getState() == "online")
{
// 该用户已经登录，不允许重复登录
json response;
response["msgid"] = LOGIN_MSG_ACK;
response["errno"] = 2;
response["errmsg"] = "this account is using, input another!";
conn->send(response.dump());
}
else
{
// 登录成功，记录用户连接信息
{
lock_guard<mutex> lock(_connMutex);
_userConnMap.insert({id, conn});
}
// id用户登录成功后，向redis订阅channel(id)
_redis.subscribe(id);
// 登录成功，更新用户状态信息 state offline=>online
user.setState("online");
_userModel.updateState(user);
json response;
response["msgid"] = LOGIN_MSG_ACK;
response["errno"] = 0;
response["id"] = user.getId();
response["name"] = user.getName();
// 查询该用户是否有离线消息
vector<string> vec = _offlineMsgModel.query(id);
if (!vec.empty())
{
response["offlinemsg"] = vec;
// 读取该用户的离线消息后，把该用户的所有离线消息删除掉
_offlineMsgModel.remove(id);
}
// 查询该用户的好友信息并返回
vector<User> userVec = _friendModel.query(id);
if (!userVec.empty())
{
vector<string> vec2;
for (User &user : userVec)
{
json js;
js["id"] = user.getId();
js["name"] = user.getName();
js["state"] = user.getState();
vec2.push_back(js.dump());
}
response["friends"] = vec2;
}
// 查询用户的群组信息
vector<Group> groupuserVec = _groupModel.queryGroups(id);
if (!groupuserVec.empty())
{
// group:[{groupid:[xxx, xxx, xxx, xxx]}]
vector<string> groupV;
for (Group &group : groupuserVec)
{
json grpjson;
grpjson["id"] = group.getId();
grpjson["groupname"] = group.getName();
grpjson["groupdesc"] = group.getDesc();
vector<string> userV;
for (GroupUser &user : group.getUsers())
{
json js;
js["id"] = user.getId();
js["name"] = user.getName();
js["state"] = user.getState();
js["role"] = user.getRole();
userV.push_back(js.dump());
}
grpjson["users"] = userV;
groupV.push_back(grpjson.dump());
}
response["groups"] = groupV;
}
conn->send(response.dump());
}
}
else
{
// 该用户不存在，用户存在但是密码错误，登录失败
json response;
response["msgid"] = LOGIN_MSG_ACK;
response["errno"] = 1;
response["errmsg"] = "id or password is invalid!";
conn->send(response.dump());
}
}
客户端异常退出模块：
如果客户端异常退出了，我们会从服务端记录用户连接的表中找到该用户，如果它断连了就从此表中删除，并设置其状态为 offline。
void ChatService::clientCloseException(const TcpConnectionPtr &conn)
{
User user;
{
lock_guard<mutex> lock(_connMutex);
for (auto it = _userConnMap.begin(); it != _userConnMap.end(); ++it)
{
if (it->second == conn)
{
// 从map表删除用户的链接信息
user.setId(it->first);
_userConnMap.erase(it);
break;
}
}
}
// 用户注销，相当于就是下线，在redis中取消订阅通道
_redis.unsubscribe(user.getId());
// 更新用户的状态信息
if (user.getId() != -1)
{
user.setState("offline");
_userModel.updateState(user);
}
}服务端异常退出模块：
如果服务端异常退出，它会将所有在线的客户的状态都设置为 offline。即，让所有用户都下线。异常退出一般是 CTRL + C 时，我们需要捕捉信号。这里使用了 Linux 的信号处理函数，我们向信号注册回调函数，然后在函数内将所有用户置为下线状态。
#include "chatserver.hpp"
#include "chatservice.hpp"
#include <iostream>
#include <signal.h>
using namespace std;
// 处理服务器ctrl+c结束后，重置user的状态信息
void resetHandler(int)
{
ChatService::instance()->reset();
exit(0);
}
int main(int argc, char **argv)
{
if (argc < 3)
{
cerr << "command invalid! example: ./ChatServer 127.0.0.1 6000" << endl;
exit(-1);
}
// 解析通过命令行参数传递的ip和port
char *ip = argv[1];
uint16_t port = atoi(argv[2]);
signal(SIGINT, resetHandler);
EventLoop loop;
InetAddress addr(ip, port);
ChatServer server(&loop, addr, "ChatServer");
server.start();
loop.loop();
return 0;
}// 服务器异常，业务重置方法
void ChatService::reset()
{
// 把online状态的用户，设置成offline
_userModel.resetState();
}void UserModel::resetState()
{
// 1.组装sql语句
char sql[1024] = "update user set state = 'offline' where state = 'online'";
MySQL mysql;
if (mysql.connect())
{
mysql.update(sql);
}
}点对点聊天模块
通过传递的 json 查找对话用户 ID：
- 用户处于登录状态：直接向该用户发送信息
- 用户处于离线状态：需存储离线消息
void ChatService::oneChat(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int toid = js["toid"].get<int>();
{
lock_guard<mutex> lock(_connMutex);
auto it = _userConnMap.find(toid);
if (it != _userConnMap.end())
{
// toid在线，转发消息 服务器主动推送消息给toid用户
it->second->send(js.dump());//js.dump将json数据序列化位字符串形式
return;
}
}
// 查询toid是否在线
User user = _userModel.query(toid);
if (user.getState() == "online")
{
_redis.publish(toid, js.dump());
return;
}
// toid不在线，存储离线消息
_offlineMsgModel.insert(toid, js.dump());
}
// 存储用户的离线消息
void OfflineMsgModel::insert(int userid, string msg)
{
// 1.组装sql语句
char sql[1024] = {0};
sprintf(sql, "insert into offlinemessage values(%d, '%s')", userid, msg.c_str());
MySQL mysql;
if (mysql.connect())
{
mysql.update(sql);
}
}添加好友模块
从 json 对象中获取添加登录用户 ID 和其想添加的好友的 ID，调用 model 层代码在 friend 表中插入好友信息。
void ChatService::addFriend(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
int friendid = js["friendid"].get<int>();
// 存储好友信息
_friendModel.insert(userid, friended);
}
void FriendModel::insert(int userid, int friendid)
{
// 1.组装sql语句
char sql[1024] = {0};
sprintf(sql, "insert into friend values(%d, %d)", userid, friendid);
MySQL mysql;
if (mysql.connect())
{
mysql.update(sql);
}
}
群组模块
创建群组需要描述群组名称，群组的描述，然后调用 model 层方法在数据库中记录新群组信息。
加入群组需要给出用户 ID 和想要加入群组的 ID，其中会显示该用户是群组的普通成员还是创建者。群组聊天给出群组 ID 和聊天信息，群内成员在线会直接接收到。
// 创建群组业务
void ChatService::createGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
string name = js["groupname"];
string desc = js["groupdesc"];
// 存储新创建的群组信息
Group group(-1, name, desc);
if (_groupModel.createGroup(group))
{
// 存储群组创建人信息
_groupModel.addGroup(userid, group.getId(), "creator");
}
}
// 加入群组业务
void ChatService::addGroup(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
int groupid = js["groupid"].get<int>();
_groupModel.addGroup(userid, groupid, "normal");
}// 群组聊天业务
void ChatService::groupChat(const TcpConnectionPtr &conn, json &js, Timestamp time)
{
int userid = js["id"].get<int>();
int groupid = js["groupid"].get<int>();
vector<int> useridVec = _groupModel.queryGroupUsers(userid, groupid);
lock_guard<mutex> lock(_connMutex);
for (int id : useridVec)
{
auto it = _userConnMap.find(id);
if (it != _userConnMap.end())
{
// 转发群消息
it->second->send(js.dump());
}
else
{
// 查询toid是否在线
User user = _userModel.query(id);
if (user.getState() == "online")
{
_redis.publish(id, js.dump());
}
else
{
// 存储离线群消息
_offlineMsgModel.insert(id, js.dump());
}
}
}
}-
什么是负载均衡？
假设现在有一台机器支持2w的并发量，但是我们需要保证8w的并发量,可以通过提高服务器的配置来解决这个问题，但是单台服务器的性能是有限的，这时候我们就可以通过增加服务器的数量，将用户请求分发到不同的服务器上分担压力，这就是负载均衡。这时候就要选择一个第三方组件充当负载均衡器，由它负责将不同的请求分发到不同的服务器上。本项目选择Nginx负载均衡功能。
选择 Nginx 的 tcp 负载均衡模块的原因：
- 把
client的请求按照负载算法分发到具体的业务服务器ChatServer上 - 能够
ChantServer保持心跳机制，检测ChatServer故障 - 能够发现新添加的
ChatServer设备，方便扩展服务器数量
redis发布-订阅功能解决跨服务器通信问题？
之前的ChatServer是维护了一个连接的用户表，每次向别的用户发消息都会从用户表中查看对端用户是否在线。然后再判断是直接发送，还是转为离线消息。集群服务器，有多个服务器维护用户。我们的ChatServerA要聊天的对象在ChatServerB，ChatServerA在自己服务器的用户表中找不到。那么可能对端用户在线，它却给对端用户发送了离线消息。因此，我们需要保证跨服务器间的通信！各个ChatServer服务器互相之间直接建立TCP连接进行通信，相当于在服务器网络之间进行广播。这样的设计使得各个服务器之间耦合度太高，不利于系统扩展，并且会占用系统大量的socket资源，各服务器之间的带宽压力很大，不能够节省资源给更多的客户端提供服务，因此绝对不是一个好的设计。
集群部署的服务器之间进行通信，最好的方式就是引入中间件消息队列，解耦各个服务器，使整个系统松耦合，提高服务器的响应能力，节省服务器的带宽资源
- 在使用 Muduo 网络库的过程中遇到了哪些挑战？你是如何解决的？
在使用 Muduo 网络库的过程中，我们遇到了一些多线程并发的问题，比如线程安全和资源竞争。我们通过引入锁机制和使用原子操作来解决这些问题。此外，我们还使用了数据库连接池提高数据库的存取性能。
- 你是如何使用 JSON 进行数据序列化和反序列化的？
我们使用 JSON 作为通信协议来序列化和反序列化数据。具体实现中，我们使用了第三方 JSON 库（如 nlohmann/json）来处理 JSON 数据。将数据结构序列化为 JSON 字符串进行传输，接收到数据后再将 JSON 字符串反序列化为数据结构。
- 为什么选择 JSON 作为私有通信协议？
我们选择 JSON 作为通信协议是因为它具有良好的可读性和易于解析的特点。JSON 是一种轻量级的数据交换格式，支持多种数据类型，且在各大编程语言中都有成熟的库支持。
- 如何处理 JSON 数据的解析和生成，以确保通信的高效性？
为了确保通信的高效性，我们对 JSON 数据的解析和生成进行了优化。例如，在传输过程中，我们会尽量减少嵌套层级和数据冗余。此外，我们还对 JSON 字符串进行了压缩，以减少传输的数据量。
- 请解释一下你是如何配置 Nginx 来实现基于 TCP 的负载均衡的？
为了实现基于 TCP 的负载均衡，我们在 Nginx 的配置文件中使用了 stream 模块。通过定义 upstream 模块来列出所有后端服务器，并配置负载均衡策略，如轮询（round-robin）、最少连接（least_conn）等。然后在 server 块中指定监听的端口和转发的上游服务器。
- 在实现聊天服务器集群时，如何确保各节点之间的数据一致性？
在实现聊天服务器集群时，我们使用 Redis 的发布-订阅功能来确保各节点之间的数据一致性。每当有新的消息到达时，消息会被发布到 Redis 中，集群中的其他节点会订阅并接收到该消息，从而保持数据的一致性。
- 请描述一下你是如何使用 Redis 的发布-订阅功能来实现跨服务器消息通信的？
我们使用 Redis 的发布-订阅功能来实现跨服务器的消息通信。在每个服务器节点上，我们都配置了 Redis 客户端来订阅特定的频道（channel）。当某个节点有新消息时，它会将消息发布到 Redis 中，所有订阅该频道的节点都会接收到该消息，从而实现消息的广播和同步。
- Redis 发布-订阅模式有哪些优缺点？
Redis 发布-订阅模式的优点是实现简单、实时性强，适合广播类型的消息传递。缺点是当订阅者数量较多时，可能会导致性能瓶颈，并且消息是一次性传递的，订阅者在离线时会错过消息。
- 你是如何处理 Redis 消息丢失和延迟问题的？
为了解决消息丢失和延迟问题，我们引入了 Redis 的持久化功能，将重要消息存储到 Redis 中。对于离线订阅者，我们在其重新上线时进行消息重放。此外，我们还设置了消息重试机制，以确保消息能够成功传递到所有订阅者。
- 你在项目中是如何设计 MySQL 数据库表结构的？
在设计 MySQL 数据库表结构时，我们遵循了范式化的原则，将数据分解到多个表中以减少冗余。此外，我们使用了适当的索引来加速查询操作，并设计了外键约束来确保数据的一致性和完整性。
- 如何优化 MySQL 数据库的性能？
为了优化 MySQL 数据库的性能，我们进行了多方面的优化。首先，使用了适当的索引和查询优化策略，以减少查询时间。其次，配置了数据库的缓存和缓冲池，提高数据读取速度。最后，我们进行了数据库分区和分片，以处理大规模数据。
- 你是如何确保 MySQL 数据库的高可用性和数据安全性的？
为了确保 MySQL 数据库的高可用性和数据安全性，我们配置了主从复制和读写分离，保证数据的实时备份和负载均衡。此外，我们还定期进行数据备份，并使用了权限管理和加密技术来保护数据安全。
- 你是如何使用连接池来提高数据库访问性能的？
我们使用了数据库连接池（如 HikariCP）来管理数据库连接。通过预先创建和维护一定数量的数据库连接，连接池能够在需要时快速提供连接，从而减少频繁创建和销毁连接的开销，提高数据库访问性能。
- 连接池的配置有哪些关键参数？如何进行调整？
连接池的关键配置参数包括最大连接数、最小连接数、连接空闲时间和连接超时时间等。我们根据系统的并发量和数据库的性能进行合理的参数设置。例如，在高并发场景下，我们适当增大最大连接数，以确保有足够的连接可用。同时，我们根据数据库的响应时间设置合理的连接超时时间，避免长时间等待。
- 在使用连接池时，遇到过哪些问题？是如何解决的？
在使用连接池时，我们曾遇到过连接泄漏和连接过期的问题。为了解决这些问题，我们定期检查和清理无效连接，并配置了连接池的自动回收机制。此外，我们还优化了应用程序的数据库访问代码，确保每次使用后及时释放连接。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
