文章版权归腾讯GAD所有，禁止匿名转载；禁止商业使用；禁止个人使用。
一、前言
上文介绍了我们的SLG手游的服务器架构设计以及网络通信部分，本文介绍数据管理部分，在数据存储方面，我选择了Mysql、Memcache和Redis，利用这三种数据库各自的优势，各自发挥所长，在项目中有着不同的应用。
二、游戏数据分析
前文已经对游戏数据做了大概的分析，如下图所示：
这是我个人对游戏中的数据进行的一种划分。其中，游戏数据直接使用代码将表文件中的数据加载到内存，然后从内存中读取数据即可。玩家数据则分为了热数据和冷数据两部分分别进行存储，最大程度利用Mysql和Redis各自的优势。
三、游戏静态数据
在我们的这款游戏中，我们的静态数据配置在CSV表文件中，在服务器启动时，我读取所有的表文件，然后取出数据放到Map中，一般以一个标志性列（如ID）为key，一个JavaBean作为value放入到Map中。
读取CSV表文件步骤如下：
1.读取CSV文件
2.按一定格式对文件内容进行解析
3.将内容封装到JavaBean
4.存放数据到Map中
读取完了之后，在代码中如果需要，只需通过key在Map中来读取即可。
在项目中，我将整个过程进行了封装，封装成了dataConfig.xml文件、*.csv文件、JavaBean、CsvLoader.java、CsvParser.java和TempletService.java，添加一个CSV文件的步骤如下：
1.在dataConfig.xml中添加csv文件路径
2.创建一个和CSV文件中结构一模一样的JavaBean
3.服务器启动时调用CsvLoader的load()方法来加载所有的CSV文件
4.调用TempletService.listAll()方法，并传入Javabean的simpleName来加载CSV文件内容到List中
5.将List中的内容按一定结构存储（我一般都存为Map结构）
1.dataConfig.xml
dataConfig.xml中存储所有CSV表的路径，在CsvLoader.java中直接对这个xml表中的路径下的CSV文件进行读取加载。
<?xml version="1.0" encoding="UTF-8"?>
<config>
<file name="Card.csv" />
<file name="Equip.csv" />
<!--省略更多CSV表-->
</config>
2.CSV文件
CSV文件中存储具体的游戏数据，这个数据表一般是由数值策划来进行配置。CSV表的本质就是按逗号进行分割的数据，如下是卡牌表的前两行数据。
卡牌ID,卡牌名称,英雄动画名称,卡牌兵种name,卡牌兵种类型,卡牌兵种美术资源ID,品质编号,所属势力,英雄等级,英雄升星等级,技能id,统,勇,智,初始兵力,初始攻击力,兵力,攻击力,克制系数,被克制系数,移动速度,爆击率,爆击倍数,普攻伤害加深,普攻伤害减免,技能伤害加深,技能伤害减免,普攻伤害点数,普攻免伤点数,技能伤害点数,技能减伤点数,KPI,技能名称,技能描述：目标 目标个数（范围）效果数值buff描述,英雄定位
CardId,CardName,CardFlashName,CardSoldName,CardSoldID,CardSoldFlashID,RMBID,CountryID,CardLv,CardStar,SkillID,Tong,Yong,Zhi,HpStar,AttackStar,Hp,Attack,Kezhi,Beikezhi,Speed,Crit,Double,AttackAddbaifen,Attackreducebaifen,SkillAddbaifen,Skillreducebaifen,AttackNum,AttackreduceNum,SkillAddNum,SkillreduceNum,KPI,SkillName,SkillDes,HeroLocal
200001,吕布,lvbu,骑兵,2,4,8,4,1,1,200001,105,110,90,344,70,2.22,2.26,0.17,0.43,385,0.16,1.44,0.176,0.144,0.176,0.144,0,0,0,0,1000,猛将无双,对敌方所有目标造成 1倍伤害并且全体晕眩3秒
200002,赵云,zhaoyun,步兵,3,1,8,2,1,1,200002,103,106,100,381,62,2.464,2.008,0.31,0.29,300,0.16,1.44,0.128,0.208,0.128,0.208,0,0,0,0,1000,枪出如龙,对敌方目标造成3次0.5倍伤害并提升自身50%爆击率持续4秒
3.JavaBean
添加了CSV文件之后，我们需要创建一个和CSV表结构一模一样的JavaBean，如下是卡牌表对应的JavaBean。
package com.hjc._36.template;
public class Card {
private int CardId;
private String CardName;
private String CardFlashName;
private String CardSoldName;
private int CardSoldID;
private int CardSoldFlashID;
private int RMBID;
private int CountryID;
private int CardLv;
private int CardStar;
private int SkillID;
private int Tong;
private int Yong;
private int Zhi;
private int HpStar;
private int AttackStar;
private float Hp;
private float Attack;
private float Kezhi;
private float Beikezhi;
private int Speed;
private float Crit;
private float Double;
private float AttackAddbaifen;
private float Attackreducebaifen;
private float SkillAddbaifen;
private float Skillreducebaifen;
private float AttackreduceNum;
private float AttackNum;
private float SkillAddNum;
private float SkillreduceNum;
private int KPI;
// getter/setter
}
4.CsvDataLoader.java
CsvDataLoader封装了对CSV数据的载入，包括使用SAXReader对dataConfig.xml文件的读取，以及对其中的CSV文件的内容的读取，代码如下：
package com.hjc._36.util.csv;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.hjc._36.core.GameInit;
public class CsvDataLoader {
public static Logger logger = LoggerFactory.getLogger(CsvDataLoader.class);
private String packageName;
private String config; // 每一行就是一个配置文件名字
public static int ActivityMaxValue;
private static CsvDataLoader inst;
public CsvDataLoader(String packageName, String config) {
this.packageName = packageName;
this.config = config;
}
public static CsvDataLoader getInstance(String packageName, String config) {
if (inst == null) {
inst = new CsvDataLoader(packageName, config);
}
return inst;
}
/**
* 调用load方法加载所有的配置文件
*/
public void load() {
SAXReader reader = new SAXReader();
InputStream resourceStream = this.getClass().getResourceAsStream(
this.config);
InputStreamReader resourceStreamReader = new InputStreamReader(
resourceStream);
try {
Document doc = reader.read(resourceStreamReader);
List<?> nodes = doc.selectNodes("/config/file");
Map<String, List<?>> dataMap = new HashMap<String, List<?>>();
List<String> files = new LinkedList<String>();
for (Object n : nodes) {
Element t = (Element) n;
String f = t.attributeValue("name");
List<?> dataList = this.loadFile(f, true);
for (Object o : dataList) {
TempletService.getInstance().registerObject(o, dataMap);
}
files.add(f);
}
logger.info("读取配置完毕，准备afterLoad");
TempletService.templetMap = dataMap;
TempletService.getInstance().afterLoad();
logger.info("afterLoad 完毕");
} catch (DocumentException e) {
e.printStackTrace();
} finally {
if (resourceStreamReader != null) {
try {
resourceStreamReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (resourceStream != null) {
try {
resourceStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private List<?> loadFile(String file, boolean exitWhenFail) {// 读文件
InputStream resourceAsStream = null;
try {
String clzName = file.replaceAll(".csv", "");
file = GameInit.confFileBasePath + file;
logger.info("load file: {}", file);
// resourceAsStream = this.getClass().getResourceAsStream(file);
resourceAsStream = this.getClass().getClassLoader()
.getResource(file).openStream();
if (resourceAsStream == null) {
logger.error("文件不存在:" + file);
if (exitWhenFail) {
System.exit(0);
}
return null;
}
return loadFromStream(resourceAsStream, clzName);
} catch (Exception e) {
logger.error("载入文件出错：" + file);
e.printStackTrace();
System.exit(0);
} finally {
if (resourceAsStream != null) {
try {
resourceAsStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return Collections.EMPTY_LIST;
}
public List<?> loadFromStream(InputStream resourceAsStream, String clzName)
throws DocumentException, InstantiationException,
IllegalAccessException, IOException {// 读csv文件
CsvParser csvParser = new CsvParser(resourceAsStream);
List<String> nodes = csvParser.getListWithNoHeader();
// get clazz
String className = this.packageName + clzName;
try {
Class<?> classObject = Class.forName(className);
if (classObject == null) {
logger.error("未找到类" + className);
return null;
}
// Get all the declared fields
Field[] fields = classObject.getDeclaredFields();
LinkedList<Field> fieldList = new LinkedList<Field>();
int length = fields.length;
for (int i = -1; ++i < length;) {
boolean isStaticField = Modifier.isStatic(fields[i]
.getModifiers());
if (isStaticField)
continue;
boolean isTransientField = Modifier.isTransient(fields[i]
.getModifiers());
if (isTransientField)
continue;
fieldList.add(fields[i]);
}
// Get all the declared fields of supper class
Class<?> tmp = classObject;
while ((tmp = tmp.getSuperclass()) != Object.class) {
System.out.print("the extends class is" + tmp.getName());
fields = tmp.getDeclaredFields();
length = fields.length;
if (length == 0)
continue;
for (int i = -1; ++i < length;) {
boolean isStaticField = Modifier.isStatic(fields[i]
.getModifiers());
if (isStaticField)
continue;
boolean isTransientField = Modifier.isTransient(fields[i]
.getModifiers());
if (isTransientField)
continue;
fieldList.add(fields[i]);
}
}
// The truly need to return object
List<Object> instances = new ArrayList<Object>(nodes.size());
Object instance = null;
String fieldName = null;
String fieldValue = null;
for (String node : nodes) {
if (node != null) {
instance = classObject.newInstance();
boolean ok = false;
// Element row = (Element) node;
String[] values = node.split(",");// csv文件以英文逗号分割值
for (int i = 0; i < fieldList.size(); i++) {
Field field = fieldList.get(i);
fieldName = field.getName();
fieldValue = values[i];
if (fieldValue == null)
continue;
try {
this.setField(instance, field, fieldValue);
ok = true;
} catch (Exception e) {
logger.error("类名称是" + className + "的属性" + fieldName
+ "没有被成功赋予静态数据");
continue;
}
}
if (ok) {
instances.add(instance);
}
}
}
return instances;
} catch (ClassNotFoundException e1) {
e1.printStackTrace();
logger.error("未找到类" + className);
return null;
}
}
/**
*
* @Title: setUnknowField
* @Description:
* @param ob
* @param f
* @param v
* @throws IllegalArgumentException
* @throws IllegalAccessException
*/
private void setField(Object obj, Field f, String v)
throws IllegalArgumentException, IllegalAccessException {
f.setAccessible(true);
if (f.getType() == int.class) {
f.setInt(obj, Integer.parseInt(v));
} else if (f.getType() == short.class) {
f.setShort(obj, Short.parseShort(v));
} else if (f.getType() == byte.class) {
f.setByte(obj, Byte.parseByte(v));
} else if (f.getType() == long.class) {
f.setLong(obj, Long.parseLong(v));
} else if (f.getType() == double.class) {
f.setDouble(obj, Double.parseDouble(v));
} else if (f.getType() == float.class) {
f.setFloat(obj, Float.parseFloat(v));
} else if (f.getType() == Timestamp.class) {
f.set(obj, Timestamp.valueOf(v));
} else {
f.set(obj, f.getType().cast(v));
}
}
/**
* Test Code
*
* @param args
*/
public static void main(String[] args) {
CsvDataLoader dl = new CsvDataLoader("com.hjc._36.template.",
"/dataConfig.xml");
dl.load();
}
}
5.CsvParser
CsvDataLoader中用到的CsvParser是具体对CSV文件按逗号分割的格式的解析的类，代码如下：
package com.hjc._36.util.csv;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
//JAVA 操作 excel 中的 .csv文件格式
public class CsvParser {
private BufferedReader bufferedreader = null;
private List list = new ArrayList();
public CsvParser() {
}
public CsvParser(InputStream inStream) throws IOException {
InputStreamReader isr = new InputStreamReader(inStream, "UTF-8");
bufferedreader = new BufferedReader(isr);
String stemp;
while ((stemp = bufferedreader.readLine()) != null) {
list.add(stemp);
}
}
public List getList() throws IOException {
return list;
}
public List getListWithNoHeader() throws IOException {
return list.subList(2, list.size());
}
// 得到csv文件的行数
public int getRowNum() {
return list.size();
}
// 得到csv文件的列数
public int getColNum() {
if (!list.toString().equals("[]")) {
if (list.get(0).toString().contains(",")) { // csv文件中，每列之间的是用','来分隔的
return list.get(0).toString().split(",").length;
} else if (list.get(0).toString().trim().length() != 0) {
return 1;
} else {
return 0;
}
} else {
return 0;
}
}
// 取得指定行的值
public String getRow(int index) {
if (this.list.size() != 0)
return (String) list.get(index);
else
return null;
}
// 取得指定列的值
public String getCol(int index) {
if (this.getColNum() == 0) {
return null;
}
StringBuffer scol = new StringBuffer();
String temp = null;
int colnum = this.getColNum();
if (colnum > 1) {
for (Iterator it = list.iterator(); it.hasNext();) {
temp = it.next().toString();
scol = scol.append(temp.split(",")[index] + ",");
}
} else {
for (Iterator it = list.iterator(); it.hasNext();) {
temp = it.next().toString();
scol = scol.append(temp + ",");
}
}
String str = new String(scol.toString());
str = str.substring(0, str.length() - 1);
return str;
}
// 取得指定行，指定列的值
public String getString(int row, int col) {
String temp = null;
int colnum = this.getColNum();
if (colnum > 1) {
temp = list.get(row).toString().split(",")[col];
} else if (colnum == 1) {
temp = list.get(row).toString();
} else {
temp = null;
}
return temp;
}
public void CsvClose() throws IOException {
this.bufferedreader.close();
}
public List readCvs(String filename) throws IOException {
CsvParser cu = new CsvParser(new FileInputStream(new File(filename)));
List list = cu.getList();
return list;
}
public void createCsv(String biao, List list, String path)
throws IOException {
List tt = list;
String data = "";
SimpleDateFormat dataFormat = new SimpleDateFormat("yyyyMMdd");
Date today = new Date();
String dateToday = dataFormat.format(today);
File file = new File(path + "resource/expert/" + dateToday
+ "importerrorinfo.csv");
if (!file.exists())
file.createNewFile();
else
file.delete();
String str[];
StringBuilder sb = new StringBuilder("");
sb.append(biao);
FileOutputStream writerStream = new FileOutputStream(file, true);
BufferedWriter output = new BufferedWriter(new OutputStreamWriter(
writerStream, "UTF-8"));
for (Iterator itt = tt.iterator(); itt.hasNext();) {
String fileStr = itt.next().toString();
// str = fileStr.split(",");
// for (int i = 0; i <= str.length - 1; i++) { // 拆分成数组 用于插入数据库中
// System.out.print("str[" + i + "]=" + str[i] + " ");
// }
// System.out.println("");
sb.append(fileStr + "
");
}
output.write(sb.toString());
output.flush();
output.close();
}
}
6.TempletService.java
服务器启动时，调用CsvDataLoader的load()方法，以完成对CSV文件的加载，之后就需要使用TempletService的listAll方法来讲数据加载到List中，TempletService根据JavaBean的simpleName来对数据进行加载，代码如下：
package com.hjc._36.util.csv;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 添加一个数据表需要做以下几步
* 1.在包com.hjc._36.template下创建对应的模板类，类名与数据文件一致
* 2.在src/main/resources/csv/中添加模板数据文件
* 3.在src/main/resources/dataConfig.xml加入刚才的模板数据文件
*
* @author 何金成
*
*/
public class TempletService {
public static Logger log = LoggerFactory.getLogger(TempletService.class);
public static TempletService templetService = new TempletService();
/**
* key:实体名 value:该实体下的所有模板数据
*/
public static Map<String, List<?>> templetMap = new HashMap<String, List<?>>();
public TempletService() {
}
public static TempletService getInstance() {
return templetService;
}
/**
* 获取该实体类下所有模板数据
*
* @param beanName
* @return
*/
@SuppressWarnings("unchecked")
public static List listAll(String beanName) {
return templetMap.get(beanName);
}
/**
* @Title: registerObject
* @Description: 注册对象到对应类的List中
* @param o
* @param dataMap
* @return void
* @throws
*/
public void registerObject(Object o, Map<String, List<?>> dataMap) {
add(o.getClass().getSimpleName(), o, dataMap);
}
@SuppressWarnings("unchecked")
private void add(String key, Object data, Map<String, List<?>> dataMap) {
List list = dataMap.get(key);
if (list == null) {
list = new ArrayList();
dataMap.put(key, list);
}
list.add(data);
}
public void afterLoad() {
// 加载后处理
// List tests = TempletService.listAll(Test.class.getSimpleName());
// for (Object object : tests) {
// Test test = (Test)object;
// System.out.print(test.getEquipLv());
// System.out.print(","+test.getLv1());
// System.out.print(","+test.getLv2());
// System.out.print(","+test.getLv3());
// System.out.print(","+test.getLv4());
// System.out.print(","+test.getLv5());
// System.out.print(","+test.getLv6());
// System.out.print(","+test.getLv7());
// System.out.print(","+test.getLv8());
// System.out.print(","+test.getLv9());
// System.out.println(","+test.getLv10());
// }
}
public void loadCanShu() {
// 加载全局参数xml配置
}
}
7.使用静态数据
在完成了添加和加载等一系列操作之后，就可以在代码中调用CSV表中加载进来的数据了，例如上文提到的卡牌数据表，加载代码如下：
// 卡牌数据表
List<Card> cardList = TempletService
.listAll(Card.class.getSimpleName());
Map<Integer, Card> cardMap = new HashMap<Integer, Card>();
for (Card card : cardList) {
cardMap.put(card.getCardId(), card);
}
this.cardMap = cardMap;
使用时只需要根据卡牌的Id，就可以取到这张卡牌的所有数据。
四、Mysql存储数据
我们使用Mysql作为冷数据的存储数据库，并使用Druid和Hibernate来创建数据库的连接以及增删改查的操作。在游戏数据中，我对游戏中的冷数据做了一个总结，如下图所示：
完成要存储的游戏数据的分析之后，我们就可以进行具体建模建表的工作，完成对数据的设计。由于在游戏服务器的数据存储中，数据库基本上只是一个游戏数据临时存放的地方，所以游戏数据中的关联性并不是特别强，所以不需要严密的数据库设计，只需简单的将玩家所有的数据按照一个userid进行关联即可，在使用Hibernate的时候，我们使用了Hibernate4，使用了它注解JavaBean自动建表的功能，我们只需将需要存储的Model写成JavaBean，并写上注解，在启动时，Hibernate扫描到JavaBean会自动为我们创建或更新表。
1.Druid数据库连接池
游戏服务器运行中经常是多个玩家同时在线的，可想而知，如果同时进行某一项涉及数据库的操作时，也会并发请求数据库，多个数据库请求就需要我们对多个数据库连接进行有效的管理，当然，我们可以自己写一个数据库卡连接池来进行数据库管理，但好在以后前辈为我们做足了工作，有很多成型的开源数据库连接池可供我们选择，常见的有c3p0、dbcp、proxool和driud等，这里我们使用阿里巴巴公司的开源产品Druid，这是我个人认为最好用的数据库连接池，它不仅提供了数据库连接池应有的功能，更是提供了良好的数据库监控性能，这是我们作为开发人员在遇到性能瓶颈时最需要的东西，感兴趣的朋友可以参考下官方github，根据官方wiki配置一个Druid的数据监控系统，通过系统可以查看数据库的各种性能指标。
Druid在github中的地址是：https://github.com/alibaba/druid
在项目中使用druid，首先我们需要导入druid所需jar包以及Mysql的驱动jar包，由于我们是maven项目，我们就直接添加pom依赖，代码如下：
<!--Mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.22</version>
<scope>runtime</scope>
</dependency>
<!--数据库连接池-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>0.2.26</version>
</dependency>
在spring的xml中对druid进行配置
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.user}" />
<property name="password" value="${jdbc.password}" />
<property name="maxActive" value="${jdbc.maxActive}" />
<property name="initialSize" value="${jdbc.initialSize}" />
<!-- 配置获取连接等待超时的时间 -->
<property name="maxWait" value="${jdbc.maxWait}" />
<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
<property name="timeBetweenEvictionRunsMillis" value="${jdbc.timeBetweenEvictionRunsMillis}" />
<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
<property name="minEvictableIdleTimeMillis" value="${jdbc.minEvictableIdleTimeMillis}" />
<!--过滤 -->
<property name="filters" value="config,wall,mergeStat" />
<!--密码加密 -->
<!-- property name="connectionProperties" value="config.decrypt=true" / -->
<!--合并多个数据源 -->
<property name="useGloalDataSourceStat" value="true" />
<property name="proxyFilters">
<list>
<ref bean="log-filter" />
<ref bean="stat-filter" />
</list>
</property>
</bean>
<bean id="log-filter" class="com.alibaba.druid.filter.logging.Log4jFilter">
<property name="statementLogErrorEnabled" value="true" />
<property name="statementLogEnabled" value="true" />
</bean>
<bean id="stat-filter" class="com.alibaba.druid.filter.stat.StatFilter">
<property name="slowSqlMillis" value="1000" />
<property name="logSlowSql" value="true" />
</bean>
然后需要在web.xml中再对druid的filter进行配置：
<filter>
<filter-name>DruidWebStatFilter</filter-name>
<filter-class>com.alibaba.druid.support.http.WebStatFilter</filter-class>
<init-param>
<param-name>exclusions</param-name>
<param-value>weburi.json,.html,.js,.gif,.jpg,.png,.css,.ico,/fonts/*,/datas/*,images/*</param-value>
</init-param>
<init-param>
<param-name>sessionStatMaxCount</param-name>
<param-value>1000</param-value>
</init-param>
<init-param>
<param-name>principalSessionName</param-name>
<param-value>FRONT_USER</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>DruidWebStatFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<servlet>
<servlet-name>DruidStatView</servlet-name>
<servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>DruidStatView</servlet-name>
<url-pattern>/druid/*</url-pattern>
</servlet-mapping>
至此为止，Druid的配置就算是完成，启动工程之后我们还能通过/druid路径来访问Druid提供的监控系统，更多关于Druid的使用可以参照github中的wiki介绍，了解更多Druid配置及参数设置。
2.Hibernate
使用Hibernate作为Mysql数据库的ORM框架，主要是因为其良好的封装，首先我个人认为Hibernate的性能是不足与和原生JDBC以及MyBatis这样的框架所匹敌的，封装的更好却带来了更多的性能损失，但我使用他也是看中他良好的封装性，因为我对性能的需求还没有达到很高的级别；其次，Hibernate很难写出复杂的SQL查询，而MyBatis却可以写出一些复杂的SQL，但在我的设计中，我不需要太复杂的查询，基本上我所有的SQL语句的where条件都是"where userid=?"，因此在性能需求上以及易用的对比上，我选择了Hibernate。
我使用的版本你是Hibernate4，因为Hibernate4提供了注解自动创建表的功能，Hibernate集成在spring的配置的xml代码如下：
<!-- 定义事务管理 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<!-- 事务执行方式 REQUIRED：指定当前方法必需在事务环境中运行， 如果当前有事务环境就加入当前正在执行的事务环境， 如果当前没有事务，就新建一个事务。
这是默认值。 -->
<tx:method name="create*" propagation="REQUIRED" />
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="remove*" propagation="REQUIRED" />
<tx:method name="del*" propagation="REQUIRED" />
<tx:method name="import*" propagation="REQUIRED" />
<!-- 指定当前方法以非事务方式执行操作，如果当前存在事务，就把当前事务挂起，等我以非事务的状态运行完，再继续原来的事务。 查询定义即可
read-only="true" 表示只读 -->
<tx:method name="*" propagation="NOT_SUPPORTED" read-only="true" />
</tx:attributes>
</tx:advice>
<!-- hibernate SessionFactory -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<!-- 数据源 -->
<property name="dataSource" ref="dataSource" />
<!-- hibernate的相关属性配置 -->
<property name="hibernateProperties">
<value>
<!-- 设置数据库方言 -->
hibernate.dialect=org.hibernate.dialect.MySQLDialect
<!-- 设置自动创建|更新|验证数据库表结构 -->
hibernate.hbm2ddl.auto=update
<!-- 是否在控制台显示sql -->
hibernate.show_sql=false
<!-- 是否格式化sql，优化显示 -->
hibernate.format_sql=false
<!-- 是否开启二级缓存 -->
hibernate.cache.use_second_level_cache=false
<!-- 是否开启查询缓存 -->
hibernate.cache.use_query_cache=false
<!-- 数据库批量查询最大数 -->
hibernate.jdbc.fetch_size=50
<!-- 数据库批量更新、添加、删除操作最大数 -->
hibernate.jdbc.batch_size=50
<!-- 是否自动提交事务 -->
hibernate.connection.autocommit=true
<!-- 指定hibernate在何时释放JDBC连接 -->
hibernate.connection.release_mode=auto
<!-- 创建session方式 hibernate4.x 的方式 -->
hibernate.current_session_context_class=thread
<!-- javax.persistence.validation.mode默认情况下是auto的，就是说如果不设置的话它是会自动去你的classpath下面找一个bean-validation**包
所以把它设置为none即可 -->
javax.persistence.validation.mode=none
</value>
</property>
<!-- 自动扫描实体对象 tdxy.bean的包结构中存放实体类 -->
<property name="packagesToScan" value="com.hjc._36" />
</bean>
配置完了之后，我们需要对我们需要进行存储的数据进行注解，如君主信息的Model如下：
package com.hjc._36.manager.junzhu;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import com.hjc._36.util.cache.MCSupport;
@Entity
@Table(name = "JunZhu")
public class JunZhu implements MCSupport {
// id，用户id，用户名字，用户所属国家，用户头像（用数字表示），用户等级，用户vip等级，用户军令数，用户金宝，用户银宝，用户粮食，用户精铁，用户木材，
// 用户兵数量，用户军工数，用户将魂数
private static final long serialVersionUID = -5385044598250102957L;
@Id
public long id;// —用户id
public String name;// — 用户名
@Column(columnDefinition = "INT default 1")
public int headImg;// —用户头像
public int role;// —用户角色
public int country;// —用户所属国家 1表示蜀国 2表示魏国 3表示吴国
@Column(columnDefinition = "INT default 0")
public int exp;// —用户等级 —君主等级
@Column(columnDefinition = "INT default 1")
public int level;// —用户等级 —君主等级
@Column(columnDefinition = "INT default 0")
public int vip;// —用户vip等级
@Column(columnDefinition = "INT default 0")
public int vipExp;// —用户vip经验
@Column(columnDefinition = "INT default 0")
public int junling;// —用户军令数
@Column(columnDefinition = "INT default 0")
public int coin;// —用户金币
@Column(columnDefinition = "INT default 0")
public int yuanbao;// —用户元宝
@Column(columnDefinition = "INT default 0")
public int food;// —用户粮食
@Column(columnDefinition = "INT default 0")
public int iron;// —用户精铁
@Column(columnDefinition = "INT default 0")
public int wood;// —用户木材
@Column(columnDefinition = "INT default 0")
public int soldierNum;// —用户兵力
@Column(columnDefinition = "INT default 0")
public int jungongNum;// —用户军功数
@Column(columnDefinition = "INT default 0")
public int jianghunNum;// —将魂数量
@Column(columnDefinition = "INT default 0")
public int shengwang;// —声望
@Column(columnDefinition = "INT default 0")
public int zxId;// —阵型id
@Column(columnDefinition = "INT default 0")
public int paySum;// -充值总额
@Column(columnDefinition = "INT default 0")
public int conduction;// -新手引导
// getter/setter
}
以上代码中，@Entity和@Table(name = "JunZhu")就可以使Hibernate在启动时自动创建一个JunZhu表，@Id的属性即设为主键的字段。创建好Model之后，就可以使用Hibernate的session进行数据库操作，这里我将数据库的操作封装为一个工具类HibernateUtil，这个工具类大家可以拿去直接使用，具体代码如下：
package com.hjc._36.util.hibernate;
import java.lang.reflect.Field;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONObject;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.annotations.Where;
import org.hibernate.transform.Transformers;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import com.alibaba.fastjson.JSON;
import com.hjc._36.core.GameInit;
import com.hjc._36.manager.card.CardInfo;
import com.hjc._36.manager.equip.EquipInfo;
import com.hjc._36.manager.mail.MailInfo;
import com.hjc._36.manager.pve.PveInfo;
import com.hjc._36.manager.zhenxing.ZhenXingInfo;
import com.hjc._36.manager.zhenxing.ZhenxingMgr;
import com.hjc._36.task.ExecutorPool;
import com.hjc._36.util.cache.MC;
import com.hjc._36.util.cache.MCSupport;
import com.hjc._36.util.memcached.MemcachedCRUD;
public class HibernateUtil {
public static boolean showMCHitLog = false;
public static Logger log = LoggerFactory.getLogger(HibernateUtil.class);
public static Map<Class<?>, String> beanKeyMap = new HashMap<Class<?>, String>();
public static long synDelayT = 0;// 延迟同步周期
private static SessionFactory sessionFactory;
public static void init() {
sessionFactory = buildSessionFactory();
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
public static Throwable insert(Object o, long id) {
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();
try {
session.save(o);
session.getTransaction().commit();
if (MC.cachedList.contains(o.getClass().getSimpleName())) {
synMC4Insert(o.getClass().getSimpleName(), o,
String.valueOf(id));
}
} catch (Throwable e) {
log.error("0要insert的数据{}", o == null ? "null" : JSONObject
.fromObject(o).toString());
log.error("0保存出错", e);
session.getTransaction().rollback();
return e;
}
return null;
}
/**
* FIXME 不要这样返回异常，没人会关系返回的异常。
*
* @param o
* @return
*/
public static Throwable save(Object o, long id) {
Session session = sessionFactory.getCurrentSession();
Transaction t = session.beginTransaction();
boolean mcOk = false;
try {
if (o instanceof MCSupport) {
MCSupport s = (MCSupport) o;// 需要对控制了的对象在第一次存库时调用MC.add
MC.update(o, String.valueOf(s.getIdentifier()));// MC中控制了哪些类存缓存。
mcOk = true;
// session.update(o);
session.saveOrUpdate(o);
} else {
session.saveOrUpdate(o);
}
t.commit();
if (o instanceof MCSupport) {
if (MC.cachedList.contains(o.getClass().getSimpleName())) {
synMC4Save(o.getClass().getSimpleName(), o,
String.valueOf(id));
}
}
} catch (Throwable e) {
log.error("1要save的数据{},{}", o, o == null ? "null" : JSONObject
.fromObject(o).toString());
if (mcOk) {
log.error("MC保存成功后报错，可能是数据库条目丢失。");
}
log.error("1保存出错", e);
t.rollback();
return e;
}
return null;
}
public static Throwable update(Object o, String id) {
Session session = sessionFactory.getCurrentSession();
Transaction t = session.beginTransaction();
try {
if (o instanceof MCSupport) {
MCSupport s = (MCSupport) o;// 需要对控制了的对象在第一次存库时调用MC.add
MC.update(o, String.valueOf(s.getIdentifier()));// MC中控制了哪些类存缓存。
session.update(o);
} else {
session.update(o);
}
t.commit();
if (o instanceof MCSupport) {
if (MC.cachedList.contains(o.getClass().getSimpleName())) {
synMC4Update(o.getClass().getSimpleName(), o,
String.valueOf(id));
}
}
} catch (Throwable e) {
log.error("1要update的数据{},{}", o, o == null ? "null" : JSONObject
.fromObject(o).toString());
log.error("1保存出错", e);
t.rollback();
return e;
}
return null;
}
public static <T> T find(Class<T> t, long id) {
String keyField = getKeyField(t);
if (keyField == null) {
throw new RuntimeException("类型" + t + "没有标注主键");
}
if (!MC.cachedClass.contains(t)) {
return find(t, "where " + keyField + "=" + id, false);
}
T ret = MC.get(t, String.valueOf(id));
if (ret == null) {
if (showMCHitLog)
log.info("MC未命中{}#{}", t.getSimpleName(), id);
ret = find(t, "where " + keyField + "=" + id, false);
if (ret != null) {
if (showMCHitLog)
log.info("DB命中{}#{}", t.getSimpleName(), id);
MC.add(ret, String.valueOf(id));
} else {
if (showMCHitLog)
log.info("DB未命中{}#{}", t.getSimpleName(), id);
}
} else {
if (showMCHitLog)
log.info("MC命中{}#{}", t.getSimpleName(), id);
}
return ret;
}
public static <T> T find(Class<T> t, String where) {
return find(t, where, true);
}
public static <T> T find(Class<T> t, String where, boolean checkMCControl) {
// if (checkMCControl && MC.cachedClass.contains(t)) {
// // 请使用static <T> T find(Class<T> t,long id)
// throw new BaseException("由MC控制的类不能直接查询DB:" + t);
// }
Session session = sessionFactory.getCurrentSession();
Transaction tr = session.beginTransaction();
T ret = null;
try {
// FIXME 使用 session的get方法代替。
String hql = "from " + t.getSimpleName() + " " + where;
Query query = session.createQuery(hql);
ret = (T) query.uniqueResult();
tr.commit();
} catch (Exception e) {
tr.rollback();
log.error("list fail for {} {}", t, where);
log.error("list fail", e);
}
return ret;
}
public static <T> List<T> list(Class<T> t, long id, String where) {
String keyField = getKeyField(t);
if (keyField == null) {
throw new RuntimeException("类型" + t + "没有标注主键");
}
if (!MC.cachedList.contains(t.getSimpleName())) {
return list(t, where, false);
}
List<T> ret = MC.getList(t, String.valueOf(id), where);
if (ret == null) {
if (showMCHitLog)
log.info("MC未命中{}#{}", t.getSimpleName(), where);
ret = list(t, where, false);
if (ret != null) {
if (showMCHitLog)
log.info("DB命中{}#{}", t.getSimpleName(), where);
MC.addList(ret, t.getSimpleName(), String.valueOf(id), where);
} else {
if (showMCHitLog)
log.info("DB未命中{}#{}", t.getSimpleName(), where);
}
} else {
if (showMCHitLog)
log.info("MC命中{}#{}", t.getSimpleName(), where);
}
return ret;
}
/**
* @param t
* @param where
* 例子： where uid>100
* @return
*/
public static <T> List<T> list(Class<T> t, String where,
boolean checkMCControl) {
// if (checkMCControl && MC.cachedList.contains(t)) {
// // 请使用static <T> T find(Class<T> t,long id)
// throw new BaseException("由MC控制的类不能直接查询DB:" + t);
// }
Session session = sessionFactory.getCurrentSession();
Transaction tr = session.beginTransaction();
List<T> list = Collections.EMPTY_LIST;
try {
String hql = "from " + t.getSimpleName() + " " + where;
Query query = session.createQuery(hql);
list = query.list();
tr.commit();
} catch (Exception e) {
tr.rollback();
log.error("list fail for {} {}", t, where);
log.error("list fail", e);
}
return list;
}
public static SessionFactory buildSessionFactory() {
log.info("开始构建hibernate");
String path = "classpath*:spring-conf/applicationContext.xml";
ApplicationContext ac = new FileSystemXmlApplicationContext(path);
sessionFactory = (SessionFactory) ac.getBean("sessionFactory");
log.info("结束构建hibernate");
return sessionFactory;
}
public static Throwable delete(Object o, long id) {
if (o == null) {
return null;
}
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();
try {
session.delete(o);
session.getTransaction().commit();
if (o instanceof MCSupport) {
MCSupport s = (MCSupport) o;// 需要对控制了的对象在第一次存库时调用MC.add
MC.delete(o.getClass(), String.valueOf(s.getIdentifier()));// MC中控制了哪些类存缓存。
if (MC.cachedList.contains(o.getClass().getSimpleName())) {
synMC4Delete(o.getClass().getSimpleName(), o,
String.valueOf(id));
}
}
} catch (Throwable e) {
log.error("要删除的数据{}", o);
log.error("出错", e);
session.getTransaction().rollback();
return e;
}
return null;
}
/**
* 注意这个方法会返回大于等于1的值。数据库无记录也会返回1，而不是null
*
* @param t
* @return
*/
public static <T> Long getTableIDMax(Class<T> t) {
Long id = null;
Session session = sessionFactory.getCurrentSession();
Transaction tr = session.beginTransaction();
String hql = "select max(id) from " + t.getSimpleName();
try {
Query query = session.createQuery(hql);
Object uniqueResult = query.uniqueResult();
if (uniqueResult == null) {
id = 1L;
} else {
id = Long.parseLong(uniqueResult + "");
id = Math.max(1L, id);
}
tr.commit();
} catch (Exception e) {
tr.rollback();
log.error("query max id fail for {} {}", t, hql);
log.error("query max id fail", e);
}
return id;
}
public static List<Map<String, Object>> querySql(String hql) {
Session session = sessionFactory.getCurrentSession();
Transaction tr = session.beginTransaction();
List list = Collections.emptyList();
try {
SQLQuery query = session.createSQLQuery(hql);
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
list = query.list();
tr.commit();
} catch (Exception e) {
tr.rollback();
log.error("query failed {}", hql);
log.error("query count(type) fail", e);
}
return list;
}
}
以上代码中，除了调用session的数据库操作API之外，我还使用了Memcache进行结果集的缓存，具体关系Memcache和Mysql的集合使用，在下文中在进行讲解。上文代码中首先在服务器启动时，需要构建SessionFactory，然后通过操作session开始事务，通过session调用CRUD方法进行操作，之后再调用commit方法提交并结束事务，中间如果发生异常则进行rollback操作回滚事务。
五、Redis存储数据
游戏中的热数据的存储我选用了Redis，Redis不仅是运行在内存上的内存数据库，并且它的数据存储结构也是很丰富的，包括String，Set，List，Sorted Set和Hash五种数据结构，我对游戏数据的热数据进行了分析，如下图：
使用Redis首先得了解Redis的五种基本数据类型，每一种数据类型都对应不同的Redis操作API，在Java中使用Redis可以使用官方提供的Jedis客户端，Jedis客户端中包含了各种数据类型的操作，我将所有的Redis操作都封装在了Redis类中，启动时调用init方法进行Redis连接，使用时通过getInstance获取实例，再调用相应的API即可完成相关的Redis操作，在init方法中，我是通过调用JedisSentinelPool去获取Redis的连接，因为我在服务器对Redis做了Sentinel的集群部署，大家可以直接拿这个Redis工具类去使用，Redis类的方法如下：
package com.hjc._36.util.redis;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.beanutils.BeanUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisSentinelPool;
import redis.clients.jedis.Tuple;
import com.hjc._36.core.GameInit;
public class Redis {
private static Redis instance;
public static Logger log = LoggerFactory.getLogger(Redis.class);
public static final int GLOBAL_DB = 0;// 全局
public static final int LOGIC_DB = GameInit.serverId;// 模块库
public static String password = null;
public static Redis getInstance() {
if (instance == null) {
instance = new Redis();
}
return instance;
}
// private JedisPool pool;
private JedisSentinelPool sentinelPool;
public String host;
public int port;
// public int getDB(long userid){
//
// }
public Jedis getJedis() {
return this.sentinelPool.getResource();
}
public void returnResource(Jedis jedis) {
jedis.close();
// this.sentinelPool.returnResource(jedis);
}
public void init() {
String redisServer = null;
if (GameInit.cfg != null) {
redisServer = GameInit.cfg.get("redisServer");
password = GameInit.cfg.get("redisPwd");
}
if (redisServer == null) {
redisServer = "127.0.0.1:6440";
}
redisServer = redisServer.trim();
String[] tmp = redisServer.split(":");
host = tmp[0];
port = Integer.parseInt(tmp[1]);
if (tmp.length == 2) {
port = Integer.parseInt(tmp[1].trim());
}
log.info("Redis sentinel at {}:{}", host, port);
// sentinelPool = new JedisPool(host, port);
Set sentinels = new HashSet();
sentinels.add(new HostAndPort(host, port).toString());
sentinelPool = new JedisSentinelPool("master1", sentinels);
}
// private void init() {
// String redisServer = null;
// if (GameInit.cfg != null) {
// redisServer = GameInit.cfg.get("redisServer");
// password = GameInit.cfg.get("redisPwd");
// }
// if (redisServer == null) {
// redisServer = "127.0.0.1:6379";
// }
// redisServer = redisServer.trim();
// String[] tmp = redisServer.split(":");
// host = tmp[0];
// port = Integer.parseInt(tmp[1]);
// if (tmp.length == 2) {
// port = Integer.parseInt(tmp[1].trim());
// }
// log.info("Redis at {}:{}", host, port);
// // sentinelPool = new JedisPool(host, port);
// JedisPoolConfig config = new JedisPoolConfig();
// sentinelPool = new JedisPool(config, host, port, 100000, password);
// }
public void test() {
Jedis j = getJedis();
j.auth(password);
returnResource(j);
}
public void select(int index) {
Jedis j = getJedis();
j.auth(password);
j.select(index);
returnResource(j);
}
public boolean hexist(int db, String key, String field) {
if (key == null) {
return false;
}
Jedis redis = getJedis();
redis.auth(password);
redis.select(db);
boolean ret = redis.hexists(key, field);
returnResource(redis);
return ret;
}
public Long hdel(int db, String key, String... fields) {
Jedis redis = getJedis();
redis.auth(password);
redis.select(db);
Long cnt = redis.hdel(key, fields);
returnResource(redis);
return cnt;
}
public String hget(int db, String key, String field) {
if (key == null) {
return null;
}
Jedis redis = getJedis();
redis.auth(password);
redis.select(db);
String ret = redis.hget(key, field);
returnResource(redis);
return ret;
}
public Map<String, String> hgetAll(int db, String key) {
if (key == null) {
return null;
}
Jedis redis = getJedis();
redis.auth(password);
redis.select(db);
Map<String, String> ret = redis.hgetAll(key);
returnResource(redis);
return ret;
}
public void hset(int db, String key, String field, String value) {
if (field == null || field.length() == 0) {
return;
}
if (value == null || value.length() == 0) {
return;
}
Jedis redis = getJedis();
redis.auth(password);
redis.select(db);
redis.hset(key, field, value);
returnResource(redis);
}
public void add(int db, String group, String key, String value) {
if (value == null || key == null) {
return;
}
Jedis redis = getJedis();
redis.auth(password);
redis.select(db);
redis.hset(group, key, value);
returnResource(redis);
}
public void set(int db, String key, String value) {
if (value == null || key == null) {
return;
}
Jedis redis = getJedis();
redis.auth(password);
redis.select(db);
redis.set(key, value);
returnResource(redis);
}
public String get(int db, String key) {
Jedis redis = getJedis();
redis.auth(password);
redis.select(db);
String ret = redis.get(key);
returnResource(redis);
return ret;
}
/**
* 添加元素到集合中
*
* @param key
* @param element
*/
public boolean sadd(int db, String key, String... element) {
if (element == null || element.length == 0) {
return false;
}
Jedis redis = getJedis();
redis.auth(password);
redis.select(db);
boolean success = redis.sadd(key, element) == 1;
returnResource(redis);
return success;
}
public boolean smove(int db, String oldKey, String newKey, String element) {
if (element == null) {
return false;
}
Jedis redis = getJedis();
redis.auth(password);
redis.select(db);
boolean success = (redis.smove(oldKey, newKey, element) == 1);
returnResource(redis);
return success;
}
public static void destroy() {
getInstance().sentinelPool.destroy();
}
// 中间省略一万字：中间都是Redis的各种API的操作，需要了解的朋友可以去看看Jedis的API文档
六、Memcache数据结果集缓存
上文在介绍Hibernate中说到了Memcache对Mysql结果集的缓存，Memcache作为一种内存数据库，经常用作应用系统的缓存系统，我也将Memcache引入到项目作为Mysql数据结果集的缓存系统，其实在实现Memcache对Mysql查询的缓存的过程中，我曾进行了多种尝试，具体有以下几种缓存模型：
1.无缓存
这种方式不使用Memcache缓存，游戏服务器的操作直接穿透到Mysql中，这种方式在高并发环境下容易引起Mysql服务器高负载情况，如下图所示：
2.查询使用缓存，更新穿透到数据库，数据库同步数据到缓存
这种方式在客户端表现来看可以提供一部分速度，因为查询操作都是基于缓存的，但实际上Mysql的负担反而加大了，因为每一个更新请求，都需要Mysql同步最新的查询结果集给Memcache，因为每一个更新操作都会带来一个查询操作，当然这个同步过程可以使异步，但是就算我们感受不到这个同步的过程，但在实际上也是加大了数据库的负载，如下图所示：
3.更新和查询都使用缓存，缓存按策略与数据库进行同步
这种方式是比较好的方式，因为客户端的所有操作都是被缓存给拦截下来了，所有操作均是基于缓存，不会穿透到数据库，而缓存与数据库之间可以按照一定策略进行同步，如每5分钟同步一次数据到数据库等，具体同步策略可根据情况具体调整，当然这种方式的缺陷就是一旦服务器宕机，那么在上次同步到宕机这段时间之间的数据都会丢失，如下图所示：
4.更新和查询都是用缓存，更新操作同时穿透到数据库，数据库同步缓存的查询
这种方式是我最终使用的方式，虽然更新操作穿透到数据库，但是我可以在保证查询效率的同时，也保证数据的安全稳定性，因为每一步更新操作都是要进行数据库存储的，并且所有的查询操作可以直接在缓存中进行，如下图所示：
需要支持缓存的类需实现MCSupport接口：
package com.hjc._36.util.cache;
import java.io.Serializable;
/**
* 实现此接口后还需要再MC类中增加cachedClass，并使用
* com.qx.persistent.HibernateUtil.find(Class<T>, long)
* 代替where进行查询。
* 需要对控制了的对象在第一次存库时调用MC.add，再调用HIbernateUtil.insert
* @author 何金成
*
*/
public interface MCSupport extends Serializable{
long getIdentifier();
}
Memcache的工具类MemcacheCRUD实现了Memcache的连接，以及add，update，delete等操作，具体代码如下：
package com.hjc._36.util.memcached;
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
import com.hjc._36.core.GameInit;
/**
* @author 何金成
*/
public class MemcachedCRUD {
protected static Logger logger = LoggerFactory
.getLogger(MemcachedCRUD.class);
public static String poolName = "gameDBPool";
protected static MemCachedClient memCachedClient;
protected static MemcachedCRUD memcachedCRUD = null;
public static SockIOPool sockIoPool;
private MemcachedCRUD() {
}
public void init() {
sockIoPool = init(poolName, "cacheServer");
memCachedClient = new MemCachedClient(poolName);
// if true, then store all primitives as their string value.
memCachedClient.setPrimitiveAsString(true);
}
public static SockIOPool init(String poolName, String confKey) {
// 缓存服务器
String cacheServers = null;
if (GameInit.cfg != null) {
cacheServers = GameInit.cfg.getServerByName(confKey);
}
String server[] = { "127.0.0.1:11211" };
if (cacheServers == null || "".equals(cacheServers)) {
} else {
server[0] = cacheServers;
}
// 创建一个连接池
SockIOPool pool = SockIOPool.getInstance(poolName);
logger.info("连接池{}缓存配置 {}", poolName, Arrays.toString(server));
pool.setServers(server);// 缓存服务器
pool.setInitConn(50); // 初始化链接数
pool.setMinConn(50); // 最小链接数
pool.setMaxConn(500); // 最大连接数
pool.setMaxIdle(1000 * 60 * 60);// 最大处理时间
pool.setMaintSleep(3000);// 设置主线程睡眠时,每3秒苏醒一次，维持连接池大小
pool.setNagle(false);// 关闭套接字缓存
pool.setSocketTO(3000);// 链接建立后超时时间
pool.setSocketConnectTO(0);// 链接建立时的超时时间
pool.initialize();
return pool;
}
public static void destroy() {
sockIoPool.shutDown();
}
public static MemcachedCRUD getInstance() {
if (memcachedCRUD == null) {
memcachedCRUD = new MemcachedCRUD();
}
return memcachedCRUD;
}
private static final long INTERVAL = 100;
public boolean exist(String key) {
return memCachedClient.keyExists(key);
}
public boolean add(String key, Object o) {
return memCachedClient.add(key, o);
}
public boolean update(String key, Object o) {
return memCachedClient.replace(key, o);
}
public boolean saveObject(String key, Object msg) {
boolean o = memCachedClient.keyExists(key);
if (o) {// 存在替换掉
return memCachedClient.replace(key, msg);
} else {
return memCachedClient.add(key, msg);
}
}
public boolean keyExist(String key) {
return memCachedClient.keyExists(key);
}
/**
* delete
*
* @param key
*/
public boolean deleteObject(String key) {
return memCachedClient.delete(key);
}
public Object getObject(String key) {
Object obj = memCachedClient.get(key);
return obj;
}
public static MemCachedClient getMemCachedClient() {
return memCachedClient;
}
}
使用Memcache进行缓存，则需要封装一个缓存的操作工具类MC，封装各种缓存操作方法，具体代码如下：
package com.hjc._36.util.cache;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSON;
import com.hjc._36.core.GameInit;
import com.hjc._36.manager.bag.ItemInfo;
import com.hjc._36.manager.building.BuildingInfo;
import com.hjc._36.manager.card.CardInfo;
import com.hjc._36.manager.equip.EquipInfo;
import com.hjc._36.manager.junzhu.JunZhu;
import com.hjc._36.manager.mail.MailInfo;
import com.hjc._36.manager.pve.PveInfo;
import com.hjc._36.manager.task.MainTaskInfo;
import com.hjc._36.manager.tec.TecInfo;
import com.hjc._36.manager.zhenxing.ZhenXingInfo;
import com.hjc._36.util.memcached.MemcachedCRUD;
public class MC {
/**
* 控制哪些类进行memcached缓存。 被控制的类在进行创建时，需要注意调用MC的add和hibernate的insert。
*/
public static Set<Class<? extends MCSupport>> cachedClass = new HashSet<Class<? extends MCSupport>>();
public static Set<String> cachedList = new HashSet<String>();
static {
cachedClass.add(JunZhu.class);
// 添加需要缓存find操作的类
}
static {
cachedList.add(CardInfo.class.getSimpleName());
// 添加需要缓存list操作的类
}
public static <T> T get(Class<T> t, String id) {
if (!cachedClass.contains(t)) {
return null;
}
StringBuffer key = new StringBuffer();
key.append(GameInit.serverId).append("#").append(t.getSimpleName())
.append("#").append(id);
Object o = MemcachedCRUD.getInstance().getObject(key.toString());
return (T) o;
}
public static <T> List<T> getList(Class<T> t, String id, String where) {
if (!cachedList.contains(t.getSimpleName())) {
return null;
}
StringBuffer key = new StringBuffer();
key.append(GameInit.serverId).append("#").append(id).append("#")
.append(t.getSimpleName()).append("#").append(where);
Object o = MemcachedCRUD.getInstance().getObject(key.toString());
return (List<T>) o;
}
public static <T> String getListKeys(String tName, String id) {
if (!cachedList.contains(tName)) {
return null;
}
StringBuffer key = new StringBuffer();
key.append(GameInit.serverId).append("#").append(id).append("#")
.append(tName);
Object o = MemcachedCRUD.getInstance().getObject(key.toString());
return (String) o;
}
public static Object getValue(String key) {
Object o = MemcachedCRUD.getInstance().getObject(key);
return o;
}
public static boolean add(Object t, String id) {
if (!cachedClass.contains(t.getClass())) {
return false;
}
StringBuffer key = new StringBuffer();
key.append(GameInit.serverId).append("#")
.append(t.getClass().getSimpleName()).append("#").append(id);
return MemcachedCRUD.getInstance().add(key.toString(), t);
}
public static boolean addList(List list, String tName, String id,
String where) {
if (!cachedList.contains(tName)) {
return false;
}
StringBuffer key = new StringBuffer();
key.append(GameInit.serverId).append("#").append(id).append("#")
.append(tName);
String c = key.toString();
key.append("#").append(where);
Object tmp = MemcachedCRUD.getInstance().getObject(c);
String keys = tmp == null ? "" : (String) tmp;
if (keys.equals("")) {
MemcachedCRUD.getInstance().add(c, key.toString());
} else if (!keys.contains(key.toString())) {
MemcachedCRUD.getInstance().update(c, keys + "," + key.toString());
}
return MemcachedCRUD.getInstance().add(key.toString(), list);
}
public static boolean addKeyValue(String key, Object value) {
return MemcachedCRUD.getInstance().add(key, value);
}
public static void update(Object t, String id) {
if (!cachedClass.contains(t.getClass())) {
return;
}
StringBuffer key = new StringBuffer();
key.append(GameInit.serverId).append("#")
.append(t.getClass().getSimpleName()).append("#").append(id);
MemcachedCRUD.getInstance().update(key.toString(), t);
}
public static boolean updateList(List list, String tName, String id,
String where) {
if (!cachedList.contains(tName)) {
return false;
}
StringBuffer key = new StringBuffer();
key.append(GameInit.serverId).append("#").append(id).append("#")
.append(tName);
String c = key.toString();
key.append("#").append(where);
Object tmp = MemcachedCRUD.getInstance().getObject(c);
String keys = tmp == null ? "" : (String) tmp;
if (keys.equals("")) {
MemcachedCRUD.getInstance().add(c, key.toString());
} else if (!keys.contains(key)) {
MemcachedCRUD.getInstance().update(c, keys + "," + key.toString());
}
return MemcachedCRUD.getInstance().update(key.toString(), list);
}
/**
* 根据主键删除缓存
*
* @param obj
* 删除对象
* @param id
* 主键id
*/
public static void delete(Class clazz, String id) {
if (!cachedClass.contains(clazz)) {
return;
}
StringBuffer key = new StringBuffer();
key.append(GameInit.serverId).append("#").append(clazz.getSimpleName())
.append("#").append(id);
MemcachedCRUD.getInstance().deleteObject(key.toString());
}
}
以上代码中，find方法的缓存和list方法的缓存需要分别实现，find方法缓存只需要将类名和id作为key，对象作为value即可，而list的缓存不仅需要缓存所有的结果集，还需要缓存所有的where查询条件，根据类型查询出where条件，然后根据where条件分别进行缓存。
HibernateUtil中使用缓存部分的java代码如下，其中注释的方法为上面第二种缓存模型的实现（现已被我淘汰）：
public static void synMC4Insert(String tName, Object o, String id) {
String keys = MC.getListKeys(tName, id);
if (keys != null && keys.length() > 0) {// 遍历所有的where缓存
String[] wheres = keys.split(",");
for (String where : wheres) {
where = where.split("#")[3];
List list = MC.getList(o.getClass(), id, where);
list.add(o);
MC.updateList(list, tName, id, where);
}
}
}
public static void synMC4Save(String tName, Object o, String id) {
String keys = MC.getListKeys(tName, id);
if (keys != null && keys.length() > 0) {// 遍历所有的where缓存
String[] wheres = keys.split(",");
for (String where : wheres) {
where = where.split("#")[3];
List list = MC.getList(o.getClass(), id, where);
MCSupport mc = (MCSupport) o;
boolean flag = false;
int index = 0;
for (Iterator iterator = list.iterator(); iterator.hasNext(); index++) {
MCSupport tmpObj = (MCSupport) iterator.next();
if (tmpObj.getIdentifier() == mc.getIdentifier()) {
list.set(index, o);
flag = true;
}
}
if (!flag) {
list.add(o);
}
MC.updateList(list, tName, id, where);
}
}
}
public static void synMC4Update(String tName, Object o, String id) {
String keys = MC.getListKeys(tName, id);
if (keys != null && keys.length() > 0) {// 遍历所有的where缓存
String[] wheres = keys.split(",");
for (String where : wheres) {
where = where.split("#")[3];
List list = MC.getList(o.getClass(), id, where);
MCSupport mc = (MCSupport) o;
int index = 0;
for (Iterator iterator = list.iterator(); iterator.hasNext(); index++) {
MCSupport tmpObj = (MCSupport) iterator.next();
if (tmpObj.getIdentifier() == mc.getIdentifier()) {
list.set(index, o);
break;
}
}
MC.updateList(list, tName, id, where);
}
}
}
public static void synMC4Delete(String tName, Object o, String id) {
String keys = MC.getListKeys(tName, id);
if (keys != null && keys.length() > 0) {// 遍历所有的where缓存
String[] wheres = keys.split(",");
for (String where : wheres) {
where = where.split("#")[3];
List list = MC.getList(o.getClass(), id, where);
MCSupport mc = (MCSupport) o;
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
MCSupport tmpObj = (MCSupport) iterator.next();
if (tmpObj.getIdentifier() == mc.getIdentifier()) {
iterator.remove();
break;
}
}
MC.updateList(list, tName, id, where);
}
}
}
// public static <T> void synchronizeDB2MemAsy(final Class<T> t,
// final String id) {
// ExecutorPool.dbThread.execute(new Runnable() {
// @Override
// public void run() {
// String keys = MC.getListKeys(t.getSimpleName(), id);
// if (keys != null && keys.length() > 0) {// 遍历所有的where缓存
// String[] wheres = keys.split(",");
// for (String where : wheres) {
// where = where.split("#")[3];
// List<T> list = list(t, where, false);
// MC.updateList(list, t.getSimpleName(), id, where);
// if (showMCHitLog) {
// log.info("DB 同步 MC 成功 t:{},where:{}",
// t.getSimpleName(), where);
// }
// }
// }
// }
// });
// }
//
// public static <T> void synchronizeDB2MemSyn(final Class<T> t,
// final String id) {
// String keys = MC.getListKeys(t.getSimpleName(), id);
// if (keys != null && keys.length() > 0) {// 遍历所有的where缓存
// String[] wheres = keys.split(",");
// for (String where : wheres) {
// where = where.split("#")[3];
// List<T> list = list(t, where, false);
// MC.updateList(list, t.getSimpleName(), id, where);
// if (showMCHitLog) {
// log.info("DB 同步 MC 成功 t:{},where:{}", t.getSimpleName(),
// where);
// }
// }
// }
// }
七、总结
以上是本文对我们这款游戏中的数据管理的介绍，游戏服务器中的各种数据是多种多样的，我们应该根据各种数据的各种性质，合理利用进行存取，以保证不管什么类型的游戏数据，在我们的游戏服务器中都可以安全稳定的运行，数据安全，玩家才会放心！