一个App或者网站，其数据内容是需要不断地更新的，为方便日常运营，我们建立了一个内部使用的运营管理系统。通过运营管理系统，可以配置一系列的运营数据，并写入到DB中。而后台服务器则读取这些数据，做一系列处理之后传输给客户端做展示。
由于后台服务端对数据的读取是十分频繁的，因此每次都从数据库读取是不切实际的，因此需要将数据缓存在本地，并定时更新缓存。
本文将介绍一种数据缓存、更新的方案，以供学习、参考。
1. 数据库操作封装
对于C++，mysql为我们提供了最原始的接口（文件mysql.h），我们的框架对原始接口进行了更好地封装，保证SQL注入。
#include "mysql.h"
/**
* @brief Mysql数据库操作类
*
* 非线程安全，通常一个线程一个TC_Mysql对象；
*
* 对于insert/update可以有更好的函数封装，保证SQL注入；
*
* TC_Mysql::DB_INT表示组装sql语句时，不加””和转义；
*
* TC_Mysql::DB_STR表示组装sql语句时，加””并转义；
*/
class TC_Mysql
{
public:
/**
* @brief 构造函数
*/
TC_Mysql();
/**
* @brief 构造函数.
*
* @param sHost 主机IP
* @param sUser 用户
* @param sPasswd 密码
* @param sDatebase 数据库
* @param port 端口
* @param iUnixSocket socket
* @param iFlag 客户端标识
*/
TC_Mysql(const string& sHost, const string& sUser = "", const string& sPasswd = "", const string& sDatabase = "", const string &sCharSet = "", int port = 0, int iFlag = 0);
/**
* @brief 构造函数.
* @param tcDBConf 数据库配置
*/
TC_Mysql(const TC_DBConf& tcDBConf);
/**
* @brief 析构函数.
*/
~TC_Mysql();
/**
* @brief 初始化.
*
* @param sHost 主机IP
* @param sUser 用户
* @param sPasswd 密码
* @param sDatebase 数据库
* @param port 端口
* @param iUnixSocket socket
* @param iFlag 客户端标识
* @return 无
*/
void init(const string& sHost, const string& sUser = "", const string& sPasswd = "", const string& sDatabase = "", const string &sCharSet = "", int port = 0, int iFlag = 0);
/**
* @brief 初始化.
*
* @param tcDBConf 数据库配置
*/
void init(const TC_DBConf& tcDBConf);
/**
* @brief 连接数据库.
*
* @throws TC_Mysql_Exception
* @return 无
*/
void connect();
/**
* @brief 断开数据库连接.
* @return 无
*/
void disconnect();
/**
* @brief 直接获取数据库指针.
*
* @return MYSQL* 数据库指针
*/
MYSQL *getMysql();
/**
* @brief 字符转义.
*
* @param sFrom 源字符串
* @param sTo 输出字符串
* @return 输出字符串
*/
string escapeString(const string& sFrom);
/**
* @brief 更新或者插入数据.
*
* @param sSql sql语句
* @throws TC_Mysql_Exception
* @return
*/
void execute(const string& sSql);
/**
* @brief mysql的一条记录
*/
class MysqlRecord
{
public:
/**
* @brief 构造函数.
*
* @param record
*/
MysqlRecord(const map<string, string> &record);
/**
* @brief 获取数据，s一般是指数据表的某个字段名
* @param s 要获取的字段
* @return 符合查询条件的记录的s字段名
*/
const string& operator[](const string &s);
protected:
const map<string, string> &_record;
};
/**
* @brief 查询出来的mysql数据
*/
class MysqlData
{
public:
/**
* @brief 所有数据.
*
* @return vector<map<string,string>>&
*/
vector<map<string, string> >& data();
/**
* 数据的记录条数
*
* @return size_t
*/
size_t size();
/**
* @brief 获取某一条记录.
*
* @param i 要获取第几条记录
* @return MysqlRecord类型的数据，可以根据字段获取相关信息，
*/
MysqlRecord operator[](size_t i);
protected:
vector<map<string, string> > _data;
};
/**
* @brief Query Record.
*
* @param sSql sql语句
* @throws TC_Mysql_Exception
* @return MysqlData类型的数据，可以根据字段获取相关信息
*/
MysqlData queryRecord(const string& sSql);
/**
* @brief 定义字段类型，
* DB_INT:数字类型
* DB_STR:字符串类型
*/
enum FT
{
DB_INT,
DB_STR,
};
/**
* 数据记录
*/
typedef map<string, pair<FT, string> > RECORD_DATA;
/**
* @brief 更新记录.
*
* @param sTableName 表名
* @param mpColumns 列名/值对
* @param sCondition where子语句,例如:where A = B
* @throws TC_Mysql_Exception
* @return size_t 影响的行数
*/
size_t updateRecord(const string &sTableName, const map<string, pair<FT, string> > &mpColumns, const string &sCondition);
/**
* @brief 插入记录.
*
* @param sTableName 表名
* @param mpColumns 列名/值对
* @throws TC_Mysql_Exception
* @return size_t 影响的行数
*/
size_t insertRecord(const string &sTableName, const map<string, pair<FT, string> > &mpColumns);
/**
* @brief 替换记录.
*
* @param sTableName 表名
* @param mpColumns 列名/值对
* @throws TC_Mysql_Exception
* @return size_t 影响的行数
*/
size_t replaceRecord(const string &sTableName, const map<string, pair<FT, string> > &mpColumns);
/**
* @brief 删除记录.
*
* @param sTableName 表名
* @param sCondition where子语句,例如:where A = B
* @throws TC_Mysql_Exception
* @return size_t 影响的行数
*/
size_t deleteRecord(const string &sTableName, const string &sCondition = "");
/**
* @brief 获取Table查询结果的数目.
*
* @param sTableName 用于查询的表名
* @param sCondition where子语句,例如:where A = B
* @throws TC_Mysql_Exception
* @return size_t 查询的记录数目
*/
size_t getRecordCount(const string& sTableName, const string &sCondition = "");
/**
* @brief 获取Sql返回结果集的个数.
*
* @param sCondition where子语句,例如:where A = B
* @throws TC_Mysql_Exception
* @return 查询的记录数目
*/
size_t getSqlCount(const string &sCondition = "");
/**
* @brief 存在记录.
*
* @param sql sql语句
* @throws TC_Mysql_Exception
* @return 操作是否成功
*/
bool existRecord(const string& sql);
/**
* @brief 获取字段最大值.
*
* @param sTableName 用于查询的表名
* @param sFieldName 用于查询的字段
* @param sCondition where子语句,例如:where A = B
* @throws TC_Mysql_Exception
* @return 查询的记录数目
*/
int getMaxValue(const string& sTableName, const string& sFieldName, const string &sCondition = "");
/**
* @brief 获取auto_increment最后插入得ID.
*
* @return ID值
*/
long lastInsertID();
/**
* @brief 构造Insert-SQL语句.
*
* @param sTableName 表名
* @param mpColumns 列名/值对
* @return string insert-SQL语句
*/
string buildInsertSQL(const string &sTableName, const map<string, pair<FT, string> > &mpColumns);
/**
* @brief 构造Replace-SQL语句.
*
* @param sTableName 表名
* @param mpColumns 列名/值对
* @return string insert-SQL语句
*/
string buildReplaceSQL(const string &sTableName, const map<string, pair<FT, string> > &mpColumns);
/**
* @brief 构造Update-SQL语句.
*
* @param sTableName 表名
* @param mpColumns 列名/值对
* @param sCondition where子语句
* @return string Update-SQL语句
*/
string buildUpdateSQL(const string &sTableName,const map<string, pair<FT, string> > &mpColumns, const string &sCondition);
/**
* @brief 获取最后执行的SQL语句.
*
* @return SQL语句
*/
string getLastSQL() { return _sLastSql; }
/**
* @brief 获取查询影响数
* @return int
*/
size_t getAffectedRows();
protected:
/**
* @brief copy contructor，只申明,不定义,保证不被使用
*/
TC_Mysql(const TC_Mysql &tcMysql);
/**
*
* @brief 只申明,不定义,保证不被使用
*/
TC_Mysql &operator=(const TC_Mysql &tcMysql);
private:
/**
* 数据库指针
*/
MYSQL *_pstMql;
/**
* 数据库配置
*/
TC_DBConf _dbConf;
/**
* 是否已经连接
*/
bool _bConnected;
/**
* 最后执行的sql
*/
string _sLastSql;
};经过上面一层的封装，我们的数据库操作接口已经比较友好了，但是我们还可以做进一步的封装：提供一个接口，在得到查询结果MysqlData之后，将其解析成我们想要的C++对象。下面我们对TC_Mysql 做进一步封装，通过MysqlAccessor 来实现对mysql的真正访问，在调用selectVector时，传入一个CmsMysqlRecordparser解析器，即可灵活地按照我们的需求将数据库记录转换为C++对象。
//数据库model解析器接口，将record解析为c++对象
template<typename ItemType>
class CmsMysqlRecordparser{
public:
CmsMysqlRecordparser(){}
virtual ~CmsMysqlRecordparser(){}
virtual void parse(CmsMysqlRecord & record ,ItemType &item ) =0 ;
};
//mysql访问封装
class MysqlAccessor : public TC_ThreadLock
{
public:
MysqlAccessor(){};
~MysqlAccessor(){};
public:
bool Initialize(const string sHost, const string sUser, const string spwd, const string sDb, const string sChaSet, int16_t wPort);
bool Query(string sQuery, TC_Mysql::MysqlData &rdData);
bool Execute(string sExecute);
//查询数据库，获取批量数据，使用parser解析成C++对象
template<typename ItemType>
bool selectVector( const string& sql, std::vector<ItemType> & result,CmsMysqlRecordparser<ItemType>& parser )
{
bool ret=false;
TC_Mysql::MysqlData recordSet;
__TRY__;
if(this->Query(sql, recordSet))
{
if (recordSet.size() > 0)
{
for (size_t i = 0; i < recordSet.size(); i++)
{
CmsMysqlRecord record(recordSet.data()[i]);
ItemType item;
parser.parse(record,item);
result.push_back(item);
}
}
//只要无异常，就算数据为空，也算成功
ret= true;
}
__CATCH_EXCEPTION_WITH__(sql);
return ret;
}
private:
TC_Mysql _dbMysql;
};2. 数据缓存
上面我们对数据库访问进行了一系列的封装，下面我们来看看数据是如何从数据库取出来并缓存在本地的。
现假设我们数据的C++类型定义如下：
struct BlackChannelInfo
{
long id;
string channelId;
};我们提供了以下的类来存储以上的数据对象集合blackChannelList，并提供对外的访问接口getBlackChannelInfo()。
class BlackChannelInfoData
{
public:
BlackChannelInfoData()
{ }
virtual ~BlackChannelInfoData() {}
public:
bool Update();
bool getBlackChannelInfo(const string& channelId, BlackChannelInfo& info);
private:
map<string, BlackChannelInfo> blackChannelList; // key是channelId
};其中Update方法如下：
bool BlackChannelInfoData::Update()
{
string sql = string("select * from channel_black;");
vector<BlackChannelInfo> tmpVecData;
// MysqlAccessPtr指向一个MysqlAccessor对象
// BlackChannelInfoParser继承自
// CmsMysqlRecordparser<BlackChannelInfo>
// 并重写了parser函数
BlackChannelInfoParser parser;
if (MysqlAccessPtr->selectVector(sql, tmpVecData, parser))
{
for (size_t i = 0; i < tmpVecData.size(); ++i)
{
blackChannelList.insert(
make_pair(tmpVecData[i].channelId,
tmpVecData[i]));
}
return true;
}
return false;
}以上的Update操作属于所有数据缓存对象的共性，我们可以抽象出一个父类DataBase，该类包含虚成员函数Update()，这为我们后面数据更新做准备——数据更新线程只需要调用DataBase的Update()即可完成对数据的刷新，而不需要关心DataBase的子类BlackChannelInfoData。
同时，我们发现只要有一个BlackChannelInfo，就需要一个BlackChannelInfoParser 来做解析工作，我们可以把BlackChannelInfoParser 整合到类DataBase中——让DataBase继承CmsMysqlRecordparser< T >。
于是就有了如下继承关系：
BlackChannelInfoData继承自DataBase< BlackChannelInfo >；
DataBase< BlackChannelInfo >继承自CmsMysqlRecordparser< BlackChannelInfo >。
在实现BlackChannelInfoData时，重写函数parse() 和函数Update()。
并将Update()中的语句：
BlackChannelInfoParser parser;
if (MysqlAccessPtr->selectVector(sql, tmpVecData, parser))替换为：
if (MysqlAccessPtr->selectVector(sql, tmpVecData, *this))如此便不用额外地去定义类BlackChannelInfoParser 了。
template<typename T>
class DataBase:public CmsMysqlRecordparser<T>, public TC_HandleBase {
public:
DataBase() {
_sTableName = "no name";
}
virtual ~DataBase() {}
//所依赖的数据库表名
string GetTableName() {
return _sTableName;
}
public:
virtual bool needUpdate(string const& tableName) {
//表名为空则全部刷新，否则只刷新指定表
return tableName=="" || GetTableName()==tableName;
}
virtual bool Update();
virtual void Clear();
public:
string _sTableName;//该数据类型的名称，用于打日志
};数据缓存各个类的关系图如下：
有了以上良好的封装，在写业务代码的时候，我们只需要做两件事：
1. 创建一个用于缓存数据的类，该类继承自DataBase；
2. 实现Update() 和 parse()函数。
3. 数据更新
数据定时更新可以使用一个线程来做：
class NeedToUpdate {
public:
NeedToUpdate();
virtual ~NeedToUpdate();
void setNeedUpate(bool need = true);
void doUpdateNow(time_t now);
virtual std::string getCacheName() = 0;
virtual void Update() = 0;
private:
volatile time_t m_update_time; //上次更新时间
volatile bool m_need_update; //是否需要更新
};
class DataWrapUpdater: public TC_Singleton<DataWrapUpdater>, protected TC_Thread {
public:
DataWrapUpdater();
virtual ~DataWrapUpdater();
void add(NeedToUpdate * update);
protected:
void run();
private:
taf::TC_ThreadRecLock m_lock;
std::vector<NeedToUpdate *> m_updates;
time_t m_update_interval; //更新间隔 s
useconds_t m_run_interval; //运行间隔 us
};这里引入了一个新的类NeedToUpdate ，因为有多个数据缓存对象需要更新，每个对象的更新频率也可能不同，同时除了定时更新，还有主动更新，因此每个数据缓存对象对应有一个NeedToUpdate，用来管理对象的更新时机。
线程DataWrapUpdater通过add() 函数将各个NeedToUpdate 的指针添加注册进来，然后定时运行，逐个检查是否满足更新条件，如果满足则调用doUpdateNow()函数，该函数调用纯虚函数Update() 。
定时的被动更新条件：update->m_update_time + m_update_interval < now
人为的主动更新条件：update->m_need_update
（比如向服务器发一条命令，服务器收到命令之后，调用setNeedUpate设置标志m_need_update
）
以前面介绍的数据缓存类型BlackChannelInfoData为例，由于我们的数据在执行更新的时候，可能同时还被服务使用着，如果加锁则代价比较大，我们选择用一个临时对象来存放更新后的新数据，并在更新完成之后，与当前旧数据交换（只需交换指针）。为完成这个操作，我们使用类DataWrap< T >对数据缓存类型T做进一层的包裹，同时DataWrap< T >继承了上面的NeedToUpdate ，从而拥有了管理对象的更新时机的能力。
template<class T>
class DataWrap: public TC_ThreadLock, public NeedToUpdate {
public:
DataWrap()
: m_last(NULL),
m_curr(new T) {
DataWrapUpdater::getInstance()->add(this);
}
~DataWrap() {
}
public:
bool Update(string const& tableName);
// 设置主动更新标志
TC_AutoPtr<T> Get();
virtual void Update();
private:
taf::TC_AutoPtr<T> m_last;
taf::TC_AutoPtr<T> m_curr;
};
template<class T>
bool DataWrap<T>::Update(string const& tableName) {
if (m_curr->needUpdate(tableName)) {
setNeedUpate();
}
return true;
}
template<class T>
void DataWrap<T>::Update() {
TC_ThreadLock::TryLock lock(*this);
if (lock.acquired()) {
TC_AutoPtr<T> ptr = new T;
bool succ = ptr->Update();
if (succ) {
m_last = m_curr;
m_curr = ptr;
}
}
}
template<class T>
taf::TC_AutoPtr<T> DataWrap<T>:Get() {
return m_curr;
}
完成了以上工作，我们只需要一行代码，便可以完成数据的定时自动更新了：
DataWrap<BlackChannelInfoData> blackChannelInfoDataWrap;访问数据：
blackChannelInfoDataWrap.Get()->getBlackChannelInfo(channelId, info);主动更新：
blackChannelInfoDataWrap.Update(tableName);