数据库(1):配置数据的缓存建立方法,独立数据表模型

描述:分表建模，用于管理少量表，表多了建模型繁琐。

例子：

基础模型及表模型实例 (行数据对象)

---

// 基类接口 (主要提供要处理的接口)

template <typename T>
 struct EntityBase
 {
  virtual string getTableName()=0;
  virtual string getDBName()=0;
  virtual string getPrimary()=0;
  virtual string readDB()=0;
  virtual void fromDB(MusicDbRow &aRow)=0;
  virtual string toDB(list<T> &aDataSet)=0;
  virtual string dump()=0;
  virtual ~EntityBase(){}
 };

 

 // 例子

 //公会名称数据 
 struct GonghuiInfo: public EntityBase<GonghuiInfo>
 {

    // 表模型
    uint32_t contractid;  //公会签约ID（主键）
    string name; //公会名称
    uint32_t createtime;//更新时间

  //实现虚函数，声明相关配置操作
  virtual string getTableName()
  {
   return "gonghui_table";        // 对应数据库的表名
  }

  virtual string getDBName()
  {
   return "activity_one";  // 数据库名字 (一个数据库可以直接写入基类)
  }

  virtual string getPrimary()
  {
   return toString(contractid); // 唯一键 (经常对应的是数据库里面的主键，如果是组合键这个地方就是组合键，用于map的key识别)
  }

  virtual string readDB()
  {
   string sql="SELECT contractid, name, createtime FROM ";    // 从数据库读表的select语句
   sql.append(TABLE_SD2015_GH);
   sql.append(" ORDER BY createtime DESC");
   return sql;
  }

  virtual void fromDB(MusicDbRow &aRow)  // 获取数据行键入到模型
  {
   contractid=aRow[0].asUInt();
   name=aRow[1].str;
   createtime=aRow[2].asUInt();
  }

  virtual string toDB(list<GonghuiInfo> &aDataSet)  // 从模型到数据表
  {
   string tSql="REPLACE INTO ";
   tSql.append(TABLE_SD2015_GH);
   tSql.append("(contractid, name, createtime) VALUES ");
   for(list<GonghuiInfo>::iterator it=aDataSet.begin(); it!=aDataSet.end();)
   {
    GonghuiInfo &tInfo=(*it);
    tSql+="("+yymusic::toString(tInfo.contractid)+", "
        +"\""+tInfo.name+"\", "
        +yymusic::toString(tInfo.createtime)+") "
        ;
     ++it;
     if(it!=aDataSet.end()) tSql.append(", ");
   }
   return tSql;
  }

  virtual string dump()             // 打印值
  {
   stringstream ss;
   ss << "contractid:" << contractid
      << ",name:" << name
      << ",createtime:" << createtime
      ;
   return ss.str();
  }

 };

 

---

模型数据组合器 (表数据对象)

---

template <typename T>
 struct EntityTable
 {
  EntityTable(){}

  // 从数据库中获取数据

  bool load()
  {
   MusicDBContext dbContext(entity.getDBName(), HASH_ALL_DB_KEY, false);  // 获取数据库连接对象
   string ssql=entity.readDB();
   if(!ssql.empty())
   {
    //执行失败才false
    if(!dbContext.commonSqlExe(ssql.c_str())) return false;      // 执行查找语句
    MusicDbRow tRow;
    map<string, T> tDataMap;
    T tEntity;
    while(dbContext.fetchRow(tRow))
    {
     tEntity.fromDB(tRow);       // 将数据插入模型
     tDataMap[tEntity.getPrimary()]=tEntity;  // 将模型插入表对象 
    }
    boost::mutex::scoped_lock lock(_mutex);
    data.swap(tDataMap);
   }
   return true;
  }

 

  //更新表数据，允许部分更新，会立即更新本地缓存，同时通知其他进程从数据库加载全量。
  bool set(list<T> &aDataSet)
  {
   if(!aDataSet.empty())
   {
    MusicDBContext dbContext(entity.getDBName(), HASH_ALL_DB_KEY, false);
    string ssql;
    ssql=entity.toDB(aDataSet);   // 产生插入语句
    if(!ssql.empty())
    {
     //执行失败才false
     if(!dbContext.commonSqlExe(ssql.c_str())) return false;  // 执行更改到数据库
      boost::mutex::scoped_lock lock(_mutex);
     for(typename list<T>::iterator it=aDataSet.begin(); it!=aDataSet.end(); ++it)
     {
      data[(*it).getPrimary()]=*it;   // 更改缓存
     }
    }
   }
   return true;
  }

 

  void getData(map<string, T> &aDataMap)
  {
   boost::mutex::scoped_lock lock(_mutex);
   aDataMap=data;
  }

 

  // 获取一个对象

  void getOne(const string &aPrimary, T& aEntity)
  {
   boost::mutex::scoped_lock lock(_mutex);
   if(data.find(aPrimary)==data.end()) return;
   aEntity=data[aPrimary];
  }

  private:
  boost::mutex _mutex;
  map<string, T> data;  // 表数据列表
  T entity;  // 模型对象
 };

---

表管理器 （整合所有的表）

---

struct EntityManager
 {
  static EntityManager& getInstance()
  {
   static EntityManager oIns;
   return oIns;
  }

  // 初始化数据表

  template <typename T>
  void initTable()
  {
   T tEtt;
   EntityTable<T> *tTableMgr=new EntityTable<T>();
   string tKey=tEtt.getDBName()+"_"+tEtt.getTableName(); // 数据库名+表名组合成表唯一key
   boost::mutex::scoped_lock lock(_mutex);
   data[tKey]=new EntityTable<T>();
  }

  // load数据到缓存

  template <typename T>
  bool loadTable(uint32_t aRetry=3, uint32_t aRetryInterval=500000)
  {
   T tEtt;
   EntityTable<T> *tTableMgr;
   {
    string tKey=tEtt.getDBName()+"_"+tEtt.getTableName();
    boost::mutex::scoped_lock lock(_mutex);
    if(data.find(tKey)==data.end()) return false;
    tTableMgr=(EntityTable<T>*)data[tKey];
   }
   if(tTableMgr->load()) return true;

   // 容错重处理
   for(uint32_t i=0; i<3; i++)
   {
    logth(Info, "EntityManager::loadTable retrying at %u time %u", i, aRetryInterval)
    usleep(aRetryInterval);
    if(tTableMgr->load()) return true;
   }
   return false;
  }

 

  //更新表数据，允许部分更新，会立即更新本地缓存，同时通知其他进程从数据库加载全量。
  template <typename T>
  bool setTable(list<T> &aDataSet, uint32_t aRetry=3, uint32_t aRetryInterval=500000)
  {
   T tEtt;
   EntityTable<T> *tTableMgr;
   {
    string tKey=tEtt.getDBName()+"_"+tEtt.getTableName();
    boost::mutex::scoped_lock lock(_mutex);
    if(data.find(tKey)==data.end()) return false;
    tTableMgr=(EntityTable<T>*)data[tKey];
   }
   if(tTableMgr->set(aDataSet)) return true;

   // 容错重处理
   for(uint32_t i=0; i<3; i++)
   {
    logth(Info, "EntityManager::setTable retrying at %u time %u", i, aRetryInterval)
    usleep(aRetryInterval);
    if(tTableMgr->set(aDataSet)) return true;
   }
   return false;
  }

 

 // 获取整个表数据

  template <typename T>
  void getTable(map<string, T> &aDataMap)
  {
   T tEtt;
   EntityTable<T> *tTableMgr;
   {
    string tKey=tEtt.getDBName()+"_"+tEtt.getTableName();
    boost::mutex::scoped_lock lock(_mutex);
    if(data.find(tKey)==data.end()) return;
    tTableMgr=(EntityTable<T>*)data[tKey];
   }
   tTableMgr->getData(aDataMap);
  }

 

 // 获取一个对象数据

  template <typename T>
  void getOne(const string &aPrimary, T& aEntity)
  {
   T tEtt;
   EntityTable<T> *tTableMgr;
   {
    string tKey=tEtt.getDBName()+"_"+tEtt.getTableName();
    boost::mutex::scoped_lock lock(_mutex);
    if(data.find(tKey)==data.end()) return;
    tTableMgr=(EntityTable<T>*)data[tKey];
   }
   tTableMgr->getOne(aPrimary, aEntity);
  }

  private:
  map<string, void*> data;
  boost::mutex _mutex;

  ~EntityManager()
  {

  }

 };