Java游戏服务器成长之路——弱联网游戏源码分析

小篱

文 / 何小成

　　前言

　　前段时间由于公司的一款弱联网游戏急着上线，没能及时分享，现在基本做的差不多，剩下的就是测试阶段了（本来说元旦来分享一下服务器技术的）。公司的这款游戏已经上线一年多了，在我来之前一直都是单机版本，由于人民群众的力量太强大，各种内购破解，刷体力，刷金币，刷钻石版本的出现，公司才决定将这款游戏转型为弱联网游戏，压制百分之八十的破解用户（毕竟原则上还是属于单机游戏，不可能做到百分之百的防破解），招了我这一个服务器来进行后台的开发。什么是弱联网游戏？在这之前我也没有做过弱联网游戏的服务器，但是按照我对策划对我提出的需求的理解，就是游戏的大部分逻辑运算都是在移动端本地完成，而服务器要做的就是登录、支付验证、游戏存档读档的工作，这相对于我在上家公司做的ARPG那种强联网游戏要简单多了，那款ARPG就是所有游戏产出，逻辑运算都是在服务器端完成，服务器要完成大部分的游戏运算，而我做的这款弱联网游戏，只需要简简单单的登录、验证、读取和存储。这一类的游戏，做的最火的，就是腾讯早期手游中的《全民消消乐》《节奏大师》《天天飞车》（天天飞车后来加的实时竞赛应该还是强联网的实时数据）等，这类游戏中，服务器就只需要负责游戏数据存储和一些简单的社交功能，例如qq好友送红心送体力的等。

　　概括

　　公司招聘我进来做服务器开发其实是为了两个项目，一个是这款单机转弱联网的游戏，另一款是公司准备拿来发家致富的SLG——战争策略游戏。从入职到现在，我一直是在支持弱联网游戏的开发，到现在，基本上这款游戏也算是差不多了，这款游戏的目前版本仍然基本属于单机，到年后会加上竞技场功能，到时候可能就会需要实时的数据交互了，现在就先来分享一下目前这个版本开发的过程。

　　要开发一个后台系统，首先要考虑的就是架构了，系统的高效稳定性，可扩展性。在游戏开发中，我认为后台服务器无非负责几个大得模块：

• 网络通信
• 逻辑处理
• 数据存储
• 游戏安全
  

　　首先从需求分析入手，我在这款弱联网游戏中，后端需要做的事情就是，登录，支付验证，数据存储，数据读取，再加上一些简单的逻辑判断，第一眼看去，并没有任何难点，我就分别从以上几点一一介绍

　　网络通信

　　弱联网游戏，基本上来说，最简单直接的，就是使用http短连接来进行网络层的通信，那么我又用什么来做http服务器呢，servlet还是springmvc，还是其他框架。因为之前做的ARPG用的一款nio框架——mina，然后对比servlet和springmvc的bio（实质上，springmvc只是层层封装servlet后的框架，它的本质原理还是servlet），个人还是觉得，作为需要处理大量高并发请求的业务需求来说，还是nio框架更适合，然而，我了解到netty又是比mina更好一点的框架，于是我选择了netty，然后自己写了demo测试，发现netty的处理性能确实是很可观的，netty是一个异步的，事件驱动的网络编程框架，使用netty可以快速开发出可维护的，高性能、高扩展能力的协议服务及其客户端应用。netty使用起来基本上就是傻瓜式的，它很好的封装了java的nio api。我也是刚刚接触这款网络通信框架，为此我还买了《Netty权威指南》，想系统的多了解下这款框架，以下几点，就是我使用netty作为网络层的理由：

　　netty的通信机制就是它本身最大的优势，nio的通信机制无论是可靠性还是吞吐量都是优于bio的。

　　netty使用自建的buffer API，而不是使用NIO的ByteBuffer来代表一个连续的字节序列。与ByteBuffer相比这种方式拥有明显的优势。netty使用新的buffer类型ChannelBuffer，ChannelBuffer被设计为一个可从底层解决ByteBuffer问题（netty的ByteBuf的使用跟C语言中使用对象一样，需要手动malloc和release，否则可能出现内存泄露，昨天遇到这个问题我都傻眼了，后来才知道，原来netty的ByteBuf是需要手动管理内存的，它不受java的gc机制影响，这点设定有点返璞归真的感觉！）。

　　netty也提供了多种编码解码类，可以支持Google的Protobuffer，Facebook的Trift，JBoss的Marshalling以及MessagePack等编解码框架，我记得用mina的时候，当时看老大写的编解码的类，貌似是自己写protobuffer编解码工具的，mina并没有支持protobuffer。这些编解码框架的出现就是解决Java序列化后的一些缺陷。

　　netty不仅能进行TCP/UDP开发，更是支持Http开发，netty的api中就有支持http开发的类，以及http请求响应的编解码工具，真的可谓是人性化，我使用的就是这些工具，除此之外，netty更是支持WebSocket协议的开发，还记得之前我自己试着写过mina的WebSocket通信，我得根据WebSocket的握手协议自己来写消息编解码机制，虽然最终也写出来了，但是当我听说netty的api本身就能支持WebSocket协议开发的时候，我得内心几乎是崩溃的，为什么当初不用netty呢？

　　另外，netty还有处理TCP粘包拆包的工具类！

　　可能对于netty的理解还是太浅，不过以上几个优势就让我觉得，我可以使用这款框架。实时也证明，它确实很高效很稳定的。

　　废话不多说，以下就贴出我使用netty作为Http通信的核心类：

1. public class HttpServer {
   
2. public static Logger log = LoggerFactory.getLogger(HttpServer.class);
   
3. public static HttpServer inst;
   
4. public static Properties p;
   
5. public static int port;
   
6. private NioEventLoopGroup bossGroup = new NioEventLoopGroup();
   
7. private NioEventLoopGroup workGroup = new NioEventLoopGroup();
   
8. public static ThreadPoolTaskExecutor handleTaskExecutor;// 处理消息线程池
   
9. 
   
10. private HttpServer() {// 线程池初始化
    
11. 
    
12. }
    
13. 
    
14. /**
    
15. * @Title: initThreadPool
    
16. * @Description: 初始化线程池
    
17. * void
    
18. * @throws
    
19. */
    
20. public void initThreadPool() {
    
21.   handleTaskExecutor = new ThreadPoolTaskExecutor();
    
22.   // 线程池所使用的缓冲队列
    
23. handleTaskExecutor.setQueueCapacity(Integer.parseInt(p
    
24.     .getProperty("handleTaskQueueCapacity")));
    
25.   // 线程池维护线程的最少数量
    
26.   handleTaskExecutor.setCorePoolSize(Integer.parseInt(p
    
27.     .getProperty("handleTaskCorePoolSize")));
    
28.   // 线程池维护线程的最大数量
    
29.   handleTaskExecutor.setMaxPoolSize(Integer.parseInt(p
    
30.     .getProperty("handleTaskMaxPoolSize")));
    
31.   // 线程池维护线程所允许的空闲时间
    
32.   handleTaskExecutor.setKeepAliveSeconds(Integer.parseInt(p
    
33.     .getProperty("handleTaskKeepAliveSeconds")));
    
34.   handleTaskExecutor.initialize();
    
35. }
    
36. 
    
37. public static HttpServer getInstance() {
    
38.   if (inst == null) {
    
39.    inst = new HttpServer();
    
40.    inst.initData();
    
41.    inst.initThreadPool();
    
42.   }
    
43.   return inst;
    
44. }
    
45. 
    
46. public void initData() {
    
47.   try {
    
48.    p = readProperties();
    
49.    port = Integer.parseInt(p.getProperty("port"));
    
50.   } catch (IOException e) {
    
51.    log.error("socket配置文件读取错误");
    
52.    e.printStackTrace();
    
53.   }
    
54. }
    
55. 
    
56. public void start() {
    
57.   ServerBootstrap bootstrap = new ServerBootstrap();
    
58.   bootstrap.group(bossGroup, workGroup);
    
59.   bootstrap.channel(NioServerSocketChannel.class);
    
60.   bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
    
61.    @Override
    
62.    protected void initChannel(SocketChannel ch) throws Exception {
    
63.     ChannelPipeline pipeline = ch.pipeline();
    
64.     pipeline.addLast("decoder", new HttpRequestDecoder());
    
65.     pipeline.addLast("aggregator", new HttpObjectAggregator(65536));
    
66.     pipeline.addLast("encoder", new HttpResponseEncoder());
    
67.     pipeline.addLast("http-chunked", new ChunkedWriteHandler());
    
68.     pipeline.addLast("handler", new HttpServerHandler());
    
69.    }
    
70.   });
    
71.   log.info("端口{}已绑定", port);
    
72.   bootstrap.bind(port);
    
73. }
    
74. 
    
75. public void shut() {
    
76.   workGroup.shutdownGracefully();
    
77.   workGroup.shutdownGracefully();
    
78.   log.info("端口{}已解绑", port);
    
79. }
    
80. 
    
81. /**
    
82.   * 读配置socket文件
    
83.   *
    
84.   * @return
    
85.   * @throws IOException
    
86.   */
    
87. protected Properties readProperties() throws IOException {
    
88.   Properties p = new Properties();
    
89.   InputStream in = HttpServer.class
    
90.     .getResourceAsStream("/net.properties");
    
91.   Reader r = new InputStreamReader(in, Charset.forName("UTF-8"));
    
92.   p.load(r);
    
93.   in.close();
    
94.   return p;
    
95. }
    
96. }

复制代码

　　网络层，除了网络通信，还有就是数据传输协议了，服务器跟客户端怎么通信，传什么，怎么传。跟前端商议最终还是穿json格式的数据，前面说到了netty的编解码工具的使用，下面贴出消息处理类：

1. public class HttpServerHandlerImp {
   
2. private static Logger log = LoggerFactory
   
3.    .getLogger(HttpServerHandlerImp.class);
   
4. public static String DATA = "data";// 游戏数据接口
   
5. public static String PAY = "pay";// 支付接口
   
6. public static String TIME = "time";// 时间验证接口
   
7. public static String AWARD = "award";// 奖励补偿接口
   
8. public static volatile boolean ENCRIPT_DECRIPT = true;
   
9. 
   
10. public void channelRead(final ChannelHandlerContext ctx, final Object msg)
    
11.    throws Exception {
    
12.   HttpServer.handleTaskExecutor.execute(new Runnable() {
    
13.    @Override
    
14.    public void run() {
    
15.     if (!GameServer.shutdown) {// 服务器开启的情况下
    
16.      DefaultFullHttpRequest req = (DefaultFullHttpRequest) msg;
    
17.      if (req.getMethod() == HttpMethod.GET) { // 处理get请求
    
18.      }
    
19.      if (req.getMethod() == HttpMethod.POST) { // 处理POST请求
    
20.       HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(
    
21.         new DefaultHttpDataFactory(false), req);
    
22.       InterfaceHttpData postGameData = decoder
    
23.         .getBodyHttpData(DATA);
    
24.       InterfaceHttpData postPayData = decoder
    
25.         .getBodyHttpData(PAY);
    
26.       InterfaceHttpData postTimeData = decoder
    
27.         .getBodyHttpData(TIME);
    
28.       InterfaceHttpData postAwardData = decoder
    
29.         .getBodyHttpData(AWARD);
    
30.       try {
    
31.        if (postGameData != null) {// 存档回档
    
32.         String val = ((Attribute) postGameData)
    
33.           .getValue();
    
34.         val = postMsgFilter(val);
    
35.         Router.getInstance().route(val, ctx);
    
36.        } else if (postPayData != null) {// 支付
    
37.         String val = ((Attribute) postPayData)
    
38.           .getValue();
    
39.         val = postMsgFilter(val);
    
40.         Router.getInstance().queryPay(val, ctx);
    
41.        } else if (postTimeData != null) {// 时间
    
42.         String val = ((Attribute) postTimeData)
    
43.           .getValue();
    
44.         val = postMsgFilter(val);
    
45.         Router.getInstance().queryTime(val, ctx);
    
46.        } else if (postAwardData != null) {// 补偿
    
47.         String val = ((Attribute) postAwardData)
    
48.           .getValue();
    
49.         val = postMsgFilter(val);
    
50.         Router.getInstance().awardOperate(val, ctx);
    
51.        }
    
52.       } catch (Exception e) {
    
53.        e.printStackTrace();
    
54.       }
    
55.       return;
    
56.      }
    
57.     } else {// 服务器已关闭
    
58.      JSONObject jsonObject = new JSONObject();
    
59.      jsonObject.put("errMsg", "server closed");
    
60.      writeJSON(ctx, jsonObject);
    
61.     }
    
62.    }
    
63.   });
    
64. }
    
65. 
    
66. private String postMsgFilter(String val)
    
67.    throws UnsupportedEncodingException {
    
68.   val = val.contains("%") ? URLDecoder.decode(val, "UTF-8") : val;
    
69.   String valTmp = val;
    
70.   val = ENCRIPT_DECRIPT ? XXTeaCoder.decryptBase64StringToString(val,
    
71.     XXTeaCoder.key) : val;
    
72.   if (Constants.MSG_LOG_DEBUG) {
    
73.    if (val == null) {
    
74.     val = valTmp;
    
75.    }
    
76.    log.info("server received : {}", val);
    
77.   }
    
78.   return val;
    
79. }
    
80. 
    
81. public static void writeJSON(ChannelHandlerContext ctx,
    
82.    HttpResponseStatus status, Object msg) {
    
83.   String sentMsg = JsonUtils.objectToJson(msg);
    
84.   if (Constants.MSG_LOG_DEBUG) {
    
85.    log.info("server sent : {}", sentMsg);
    
86.   }
    
87.   sentMsg = ENCRIPT_DECRIPT ? XXTeaCoder.encryptToBase64String(sentMsg,
    
88.     XXTeaCoder.key) : sentMsg;
    
89.   writeJSON(ctx, status,
    
90.     Unpooled.copiedBuffer(sentMsg, CharsetUtil.UTF_8));
    
91.   ctx.flush();
    
92. }
    
93. 
    
94. public static void writeJSON(ChannelHandlerContext ctx, Object msg) {
    
95.   String sentMsg = JsonUtils.objectToJson(msg);
    
96.   if (Constants.MSG_LOG_DEBUG) {
    
97.    log.info("server sent : {}", sentMsg);
    
98.   }
    
99.   sentMsg = ENCRIPT_DECRIPT ? XXTeaCoder.encryptToBase64String(sentMsg,
    
100.     XXTeaCoder.key) : sentMsg;
     
101.   writeJSON(ctx, HttpResponseStatus.OK,
     
102.     Unpooled.copiedBuffer(sentMsg, CharsetUtil.UTF_8));
     
103.   ctx.flush();
     
104. }
     
105. 
     
106. private static void writeJSON(ChannelHandlerContext ctx,
     
107.    HttpResponseStatus status, ByteBuf content/* , boolean isKeepAlive */) {
     
108.   if (ctx.channel().isWritable()) {
     
109.    FullHttpResponse msg = null;
     
110.    if (content != null) {
     
111.     msg = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status,
     
112.       content);
     
113.     msg.headers().set(HttpHeaders.Names.CONTENT_TYPE,
     
114.       "application/json; charset=utf-8");
     
115.    } else {
     
116.     msg = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status);
     
117.    }
     
118.    if (msg.content() != null) {
     
119.     msg.headers().set(HttpHeaders.Names.CONTENT_LENGTH,
     
120.       msg.content().readableBytes());
     
121.    }
     
122.    // not keep-alive
     
123.    ctx.write(msg).addListener(ChannelFutureListener.CLOSE);
     
124.   }
     
125. }
     
126. 
     
127. public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
     
128.    throws Exception {
     
129. }
     
130. 
     
131. public void messageReceived(ChannelHandlerContext ctx, FullHttpRequest msg)
     
132.    throws Exception {
     
133. 
     
134. }
     
135. }

复制代码

　　以上代码，由于最后商议所有接口都通过post实现，所以get请求部分代码全都注释掉了。解析json数据使用的是gson解析，因为gson是可以直接解析为JavaBean的，这一点是非常爽的。工具类中代码如下：

1. /**
   
2.      * 将json转换成bean对象
   
3.      * @author fuyzh
   
4.      * @param jsonStr
   
5.      * @return
   
6.      */  
   
7.     public static Object jsonToBean(String jsonStr, Class<?> cl) {  
   
8.         Object obj = null;  
   
9.         if (gson != null) {  
   
10.             obj = gson.fromJson(jsonStr, cl);  
    
11.         }  
    
12.         return obj;  
    
13.     }  
    
14. /**
    
15.      * 将对象转换成json格式
    
16.      * @author fuyzh
    
17.      * @param ts
    
18.      * @return
    
19.      */  
    
20.     public static String objectToJson(Object ts) {  
    
21.         String jsonStr = null;  
    
22.         if (gson != null) {  
    
23.             jsonStr = gson.toJson(ts);  
    
24.         }  
    
25.         return jsonStr;  
    
26.     }

复制代码

　　逻辑处理

　　在这款弱联网游戏中，一个是登录逻辑，游戏有一个管理服务器，管理其他的逻辑服务器（考虑到下版本开竞技场会有分服选服），登录和支付都是在管理服务器造成的，其他接口才会通过管理服务器上获得的逻辑服务器IP去完成其他交互，在逻辑服务器上基本上也不会有什么逻辑处理，基本上是接到数据就进行解析，然后就进行存储或缓存。唯一有一点逻辑处理的就是，例如金币钻石减少到负数了，就把数据置零。逻辑上，netty接收到请求之后，就进入我的一个核心处理类，Router，由Router再将消息分发到各个功能模块。Router代码如下：

1. /**
   
2.   * @Title: route
   
3.   * @Description: 路由分发
   
4.   * @param @param msg
   
5.   * @param @param ctx
   
6.   * @return void
   
7.   * @throws
   
8.   */
   
9. public void route(String msg, ChannelHandlerContext ctx) {
   
10.   GameData data = null;
    
11.   try {
    
12.    data = (GameData) JsonUtils.jsonToBean(msg, GameData.class);
    
13.   } catch (Exception e) {
    
14.    logger.error("gameData的json格式错误,{}", msg);
    
15.    e.printStackTrace();
    
16.    HttpServerHandler.writeJSON(ctx, HttpResponseStatus.NOT_ACCEPTABLE,
    
17.      new BaseResp(1));
    
18.    return;
    
19.   }
    
20.   if (data.getUserID() == null) {
    
21.    logger.error("存放/回档错误，uid为空");
    
22.    HttpServerHandler.writeJSON(ctx, new BaseResp(1));
    
23.    return;
    
24.   }
    
25.   long junZhuId = data.getUserID() * 1000 + GameInit.serverId;
    
26.   /** 回档 **/
    
27.   if (JSONObject.fromObject(msg).keySet().size() == 1) {
    
28.    GameData ret = junZhuMgr.getMainInfo(junZhuId);
    
29.    ret.setTime(new Date().getTime());
    
30.    ret.setPay(getPaySum(data.getUserID()));
    
31.    HttpServerHandler.writeJSON(ctx, ret);
    
32.    return;
    
33.   }
    
34.   /** 存档 **/
    
35.   if (data.getDiamond() != null) {// 钻石
    
36.    if (!junZhuMgr.setDiamond(junZhuId, data)) {
    
37.     HttpServerHandler.writeJSON(ctx, new BaseResp(1));
    
38.     return;
    
39.    }
    
40.   }
    
41.   // 其他模块处理代码就省了
    
42.   JunZhu junZhu = HibernateUtil.find(JunZhu.class, junZhuId);
    
43.   HttpServerHandler.writeJSON(ctx, new BaseResp(junZhu.coin,
    
44.     junZhu.diamond, 0));
    
45. }

复制代码

　　GameData则是用于发送接收的消息Bean

　　数据存储

　　在这样的游戏中，逻辑运算基本由客户端操作了，因此游戏数据的持久化才是服务器的重点，必须要保证游戏的数据的完整性。数据库上，我选择了Mysql，事实上，我认为MongoDB更适合这类数据的存储，因为本身数据库就可以完全按照json格式原样存储到数据库中，但由于项目预期紧，我也不敢去尝试我没尝试过的方式，然而选择mysql，也不是什么坏事，mysql在游戏数据的处理也是相当给力，mongo虽好，却没有关系型数据库的事务管理。根据策划的需求，我将游戏数据分析完了之后，就基本理清了数据库表结构，在项目中我使用了Hibernate4作为ORM框架，相对于前面的版本，Hibernate4有一个很爽的功能，就是在JavaBean中添加一些注解，就能在构建Hibernate的session的时候，自动在数据库创建表，这样使得开发效率快了好几倍，Hibernate本身就已经够爽了，我认为至今没有什么ORM框架能跟它比，以前也用过MyBatis，个人感觉MyBatis更适合那种需要手动写很复杂的sql才用的，每一个查询都要写sql，在Hibernate中，简简单单几行代码，就能完成一个查询，一下贴出Hibernate工具类：

1. public class HibernateUtil {
   
2. public static boolean showMCHitLog = false;
   
3. public static Logger log = LoggerFactory.getLogger(HibernateUtil.class);
   
4. public static Map<Class<?>, String> beanKeyMap = new HashMap<Class<?>, String>();
   
5. private static SessionFactory sessionFactory;
   
6. 
   
7. public static void init() {
   
8.   sessionFactory = buildSessionFactory();
   
9. }
   
10. 
    
11. public static SessionFactory getSessionFactory() {
    
12.   return sessionFactory;
    
13. }
    
14. 
    
15. public static Throwable insert(Object o) {
    
16.   Session session = sessionFactory.getCurrentSession();
    
17.   session.beginTransaction();
    
18.   try {
    
19.    session.save(o);
    
20.    session.getTransaction().commit();
    
21.   } catch (Throwable e) {
    
22.    log.error("0要insert的数据{}", o == null ? "null" : JSONObject
    
23.      .fromObject(o).toString());
    
24.    log.error("0保存出错", e);
    
25.    session.getTransaction().rollback();
    
26.    return e;
    
27.   }
    
28.   return null;
    
29. }
    
30. 
    
31. /**
    
32.   * FIXME 不要这样返回异常，没人会关系返回的异常。
    
33.   *
    
34.   * @param o
    
35.   * @return
    
36.   */
    
37. public static Throwable save(Object o) {
    
38.   Session session = sessionFactory.getCurrentSession();
    
39.   Transaction t = session.beginTransaction();
    
40.   boolean mcOk = false;
    
41.   try {
    
42.    if (o instanceof MCSupport) {
    
43.     MCSupport s = (MCSupport) o;// 需要对控制了的对象在第一次存库时调用MC.add
    
44.     MC.update(o, s.getIdentifier());// MC中控制了哪些类存缓存。
    
45.     mcOk = true;
    
46.     session.update(o);
    
47.    } else {
    
48.     session.saveOrUpdate(o);
    
49.    }
    
50.    t.commit();
    
51.   } catch (Throwable e) {
    
52.    log.error("1要save的数据{},{}", o, o == null ? "null" : JSONObject
    
53.      .fromObject(o).toString());
    
54.    if (mcOk) {
    
55.     log.error("MC保存成功后报错，可能是数据库条目丢失。");
    
56.    }
    
57.    log.error("1保存出错", e);
    
58.    t.rollback();
    
59.    return e;
    
60.   }
    
61.   return null;
    
62. }
    
63. 
    
64. public static Throwable update(Object o) {
    
65.   Session session = sessionFactory.getCurrentSession();
    
66.   Transaction t = session.beginTransaction();
    
67.   try {
    
68.    if (o instanceof MCSupport) {
    
69.     MCSupport s = (MCSupport) o;// 需要对控制了的对象在第一次存库时调用MC.add
    
70.     MC.update(o, s.getIdentifier());// MC中控制了哪些类存缓存。
    
71.     session.update(o);
    
72.    } else {
    
73.     session.update(o);
    
74.    }
    
75.    t.commit();
    
76.   } catch (Throwable e) {
    
77.    log.error("1要update的数据{},{}", o, o == null ? "null" : JSONObject
    
78.      .fromObject(o).toString());
    
79.    log.error("1保存出错", e);
    
80.    t.rollback();
    
81.    return e;
    
82.   }
    
83.   return null;
    
84. }
    
85. public static <T> T find(Class<T> t, long id) {
    
86.   String keyField = getKeyField(t);
    
87.   if (keyField == null) {
    
88.    throw new RuntimeException("类型" + t + "没有标注主键");
    
89.   }
    
90.   if (!MC.cachedClass.contains(t)) {
    
91.    return find(t, "where " + keyField + "=" + id, false);
    
92.   }
    
93.   T ret = MC.get(t, id);
    
94.   if (ret == null) {
    
95.    if (showMCHitLog)
    
96.     log.info("MC未命中{}#{}", t.getSimpleName(), id);
    
97.    ret = find(t, "where " + keyField + "=" + id, false);
    
98.    if (ret != null) {
    
99.     if (showMCHitLog)
    
100.      log.info("DB命中{}#{}", t.getSimpleName(), id);
     
101.     MC.add(ret, id);
     
102.    } else {
     
103.     if (showMCHitLog)
     
104.      log.info("DB未命中{}#{}", t.getSimpleName(), id);
     
105.    }
     
106.   } else {
     
107.    if (showMCHitLog)
     
108.     log.info("MC命中{}#{}", t.getSimpleName(), id);
     
109.   }
     
110.   return ret;
     
111. }
     
112. 
     
113. public static <T> T find(Class<T> t, String where) {
     
114.   return find(t, where, true);
     
115. }
     
116. 
     
117. public static <T> T find(Class<T> t, String where, boolean checkMCControl) {
     
118.   if (checkMCControl && MC.cachedClass.contains(t)) {
     
119.    // 请使用static <T> T find(Class<T> t,long id)
     
120.    throw new BaseException("由MC控制的类不能直接查询DB:" + t);
     
121.   }
     
122.   Session session = sessionFactory.getCurrentSession();
     
123.   Transaction tr = session.beginTransaction();
     
124.   T ret = null;
     
125.   try {
     
126.    // FIXME 使用 session的get方法代替。
     
127.    String hql = "from " + t.getSimpleName() + " " + where;
     
128.    Query query = session.createQuery(hql);
     
129. 
     
130.    ret = (T) query.uniqueResult();
     
131.    tr.commit();
     
132.   } catch (Exception e) {
     
133.    tr.rollback();
     
134.    log.error("list fail for {} {}", t, where);
     
135.    log.error("list fail", e);
     
136.   }
     
137.   return ret;
     
138. }
     
139. 
     
140. /**
     
141.   * 通过指定key值来查询对应的对象
     
142.   *
     
143.   * @param t
     
144.   * @param name
     
145.   * @param where
     
146.   * @return
     
147.   */
     
148. public static <T> T findByName(Class<? extends MCSupport> t, String name,
     
149.    String where) {
     
150.   Class<? extends MCSupport> targetClz = t;// .getClass();
     
151.   String key = targetClz.getSimpleName() + ":" + name;
     
152.   Object id = MC.getValue(key);
     
153.   T ret = null;
     
154.   if (id != null) {
     
155.    log.info("id find in cache");
     
156.    ret = (T) find(targetClz, Long.parseLong((String) id));
     
157.    return ret;
     
158.   } else {
     
159.    ret = (T) find(targetClz, where, false);
     
160.   }
     
161.   if (ret == null) {
     
162.    log.info("no record {}, {}", key, where);
     
163.   } else {
     
164.    MCSupport mc = (MCSupport) ret;
     
165.    long mcId = mc.getIdentifier();
     
166.    log.info("found id from DB {}#{}", targetClz.getSimpleName(), mcId);
     
167.    MC.add(key, mcId);
     
168.    ret = (T) find(targetClz, mcId);
     
169.   }
     
170.   return ret;
     
171. 
     
172. }
     
173. 
     
174. /**
     
175.   * @param t
     
176.   * @param where
     
177.   *            例子： where uid>100
     
178.   * @return
     
179.   */
     
180. public static <T> List<T> list(Class<T> t, String where) {
     
181.   Session session = sessionFactory.getCurrentSession();
     
182.   Transaction tr = session.beginTransaction();
     
183.   List<T> list = Collections.EMPTY_LIST;
     
184.   try {
     
185.    String hql = "from " + t.getSimpleName() + " " + where;
     
186.    Query query = session.createQuery(hql);
     
187. 
     
188.    list = query.list();
     
189.    tr.commit();
     
190.   } catch (Exception e) {
     
191.    tr.rollback();
     
192.    log.error("list fail for {} {}", t, where);
     
193.    log.error("list fail", e);
     
194.   }
     
195.   return list;
     
196. }
     
197. public static SessionFactory buildSessionFactory() {
     
198.   log.info("开始构建hibernate");
     
199.   String path = "classpath*:spring-conf/applicationContext.xml";
     
200.   ApplicationContext ac = new FileSystemXmlApplicationContext(path);
     
201.   sessionFactory = (SessionFactory) ac.getBean("sessionFactory");
     
202.   log.info("结束构建hibernate");
     
203.   return sessionFactory;
     
204. }
     
205. 
     
206. public static Throwable delete(Object o) {
     
207.   if (o == null) {
     
208.    return null;
     
209.   }
     
210.   Session session = sessionFactory.getCurrentSession();
     
211.   session.beginTransaction();
     
212.   try {
     
213.    if (o instanceof MCSupport) {
     
214.     MCSupport s = (MCSupport) o;// 需要对控制了的对象在第一次存库时调用MC.add
     
215.     MC.delete(o.getClass(), s.getIdentifier());// MC中控制了哪些类存缓存。
     
216.    }
     
217.    session.delete(o);
     
218.    session.getTransaction().commit();
     
219.   } catch (Throwable e) {
     
220.    log.error("要删除的数据{}", o);
     
221.    log.error("出错", e);
     
222.    session.getTransaction().rollback();
     
223.    return e;
     
224.   }
     
225.   return null;
     
226. }

复制代码

　　其中HibernateUtil中也用了SpyMemcached来做一些结果集的缓存，当然项目中也有其他地方用到了Memcache来做缓存。最开始的时候，我还纠结要不要把每个玩家的整个游戏数据（GameData）缓存起来，这样读起来会更快，但是我想了想，如果我把整个游戏数据缓存起来，那么每次存档，我都要把缓存中数据取出来，把要修改的那部分数据从数据库查询出来，再进行修改，再放回去，这样的话，每次存档就会多一次数据库操作，然而再想想，整个游戏中，读档只有进游戏的时候需要，而存档是随时都需要，权衡之下，还不如不做缓存，做了缓存反而需要更多数据库的操作。

　　缓存部分代码如下：

1. /**
   
2. * 对SpyMemcached Client的二次封装,提供常用的Get/GetBulk/Set/Delete/Incr/Decr函数的同步与异步操作封装.
   
3. *
   
4. * 未提供封装的函数可直接调用getClient()取出Spy的原版MemcachedClient来使用.
   
5. *
   
6. * @author 何金成
   
7. */
   
8. public class MemcachedCRUD implements DisposableBean {
   
9. 
   
10. private static Logger logger = LoggerFactory.getLogger(MemcachedCRUD.class);
    
11. private MemcachedClient memcachedClient;
    
12. private long shutdownTimeout = 2500;
    
13. private long updateTimeout = 2500;
    
14. private static MemcachedCRUD inst;
    
15. 
    
16. public static MemcachedCRUD getInstance() {
    
17.   if (inst == null) {
    
18.    inst = new MemcachedCRUD();
    
19.   }
    
20.   return inst;
    
21. }
    
22. 
    
23. // Test Code
    
24. public static void main(String[] args) {
    
25.   MemcachedCRUD.getInstance().set("test", 0, "testVal");
    
26.   for (int i = 0; i < 100; i++) {
    
27.    new Thread(new Runnable() {
    
28. 
    
29.     @Override
    
30.     public void run() {
    
31.      try {
    
32.       Thread.sleep(1000);
    
33.      } catch (InterruptedException e) {
    
34.       e.printStackTrace();
    
35.      }
    
36.      String val = MemcachedCRUD.getInstance().get("test");
    
37.      Long a = MemcachedCRUD.getInstance().<Long> get("aaa");
    
38.      System.out.println(a);
    
39.      System.out.println(val);
    
40.     }
    
41.    }).start();
    
42.   }
    
43. }
    
44. 
    
45. private MemcachedCRUD() {
    
46.   String cacheServer = GameInit.cfg.get("cacheServer");
    
47.   if (cacheServer == null) {
    
48.    cacheServer = "localhost:11211";
    
49.   }
    
50.   // String cacheServer = "123.57.211.130:11211";
    
51.   String host = cacheServer.split(":")[0];
    
52.   int port = Integer.parseInt(cacheServer.split(":")[1]);
    
53.   List<InetSocketAddress> addrs = new ArrayList<InetSocketAddress>();
    
54.   addrs.add(new InetSocketAddress(host, port));
    
55.   try {
    
56.    ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
    
57.    builder.setProtocol(Protocol.BINARY);
    
58.    builder.setOpTimeout(1000);
    
59.    builder.setDaemon(true);
    
60.    builder.setOpQueueMaxBlockTime(1000);
    
61.    builder.setMaxReconnectDelay(1000);
    
62.    builder.setTimeoutExceptionThreshold(1998);
    
63.    builder.setFailureMode(FailureMode.Retry);
    
64.    builder.setHashAlg(DefaultHashAlgorithm.KETAMA_HASH);
    
65.    builder.setLocatorType(Locator.CONSISTENT);
    
66.    builder.setUseNagleAlgorithm(false);
    
67.    memcachedClient = new MemcachedClient(builder.build(), addrs);
    
68.    logger.info("Memcached at {}:{}", host, port);
    
69.   } catch (IOException e) {
    
70.    e.printStackTrace();
    
71.   }
    
72. }
    
73. 
    
74. /**
    
75.   * Get方法, 转换结果类型并屏蔽异常, 仅返回Null.
    
76.   */
    
77. public <T> T get(String key) {
    
78.   try {
    
79.    return (T) memcachedClient.get(key);
    
80.   } catch (RuntimeException e) {
    
81.    handleException(e, key);
    
82.    return null;
    
83.   }
    
84. }
    
85.   /**
    
86.   * 异步Set方法, 不考虑执行结果.
    
87.   *
    
88.   * @param expiredTime
    
89.   *            以秒过期时间，0表示没有延迟，如果exptime大于30天，Memcached将使用它作为UNIX时间戳过期
    
90.   */
    
91. public void set(String key, int expiredTime, Object value) {
    
92.   memcachedClient.set(key, expiredTime, value);
    
93. }
    
94. 
    
95. /**
    
96.   * 安全的Set方法, 保证在updateTimeout秒内返回执行结果, 否则返回false并取消操作.
    
97.   *
    
98.   * @param expiredTime
    
99.   *            以秒过期时间，0表示没有延迟，如果exptime大于30天，Memcached将使用它作为UNIX时间戳过期
    
100.   */
     
101. public boolean safeSet(String key, int expiration, Object value) {
     
102.   Future<Boolean> future = memcachedClient.set(key, expiration, value);
     
103.   try {
     
104.    return future.get(updateTimeout, TimeUnit.MILLISECONDS);
     
105.   } catch (Exception e) {
     
106.    future.cancel(false);
     
107.   }
     
108.   return false;
     
109. }
     
110. 
     
111. /**
     
112.   * 异步 Delete方法, 不考虑执行结果.
     
113.   */
     
114. public void delete(String key) {
     
115.   memcachedClient.delete(key);
     
116. }
     
117. 
     
118. /**
     
119.   * 安全的Delete方法, 保证在updateTimeout秒内返回执行结果, 否则返回false并取消操作.
     
120.   */
     
121. public boolean safeDelete(String key) {
     
122.   Future<Boolean> future = memcachedClient.delete(key);
     
123.   try {
     
124.    return future.get(updateTimeout, TimeUnit.MILLISECONDS);
     
125.   } catch (Exception e) {
     
126.    future.cancel(false);
     
127.   }
     
128.   return false;
     
129. }
     
130. }

复制代码

　　游戏安全

　　首先是数据传输的安全问题：当我们完成了接口对接之后，就会考虑一个问题，当别人进行抓包之后，就能很轻松的知道服务器和客户端传输的数据格式，这样的话，不说服务器攻击，至少会有人利用这些接口做出一大批外挂，本身我们加上弱联网就是为了杜绝作弊现象，于是，我们对传输消息做了加密，先做XXTea加密，再做Base64加密，用约定好的秘钥，进行加密解密，进行消息收发。再一个就是支付验证的安全问题，现在有人能破解内购，就是利用支付之后断网，然后模拟返回结果为true，破解内购。我们做了支付验证，在完成支付之后，必须到后台查询订单状态，状态为完成才能获得购买的物品，支付我之前也是没有做过，一点点摸索的。代码就不贴了，涉及到业务。

　　总结

　　本文章只为了记录这款弱联网游戏的后台开发历程，可能之后还会遇到很多的问题，问题都是在摸索中解决的，我还需要了解更多关于netty性能方面知识。以上代码只是项目中的部分代码，并不涉及业务部分。分享出来也是给大家一个思路，或是直接拿去用，都是可以的，因为自己踩过一些坑，所以希望将这些记录下来，下次不能踩同样的坑。到目前为止，这款游戏也经过了大概半个多月的时间，到此作为记录，作为经验分享，欢迎交流探讨。我要参与的下一款游戏是长连接的SLG，到时候我应该还会面临更多的挑战，加油！

　　相关阅读：Java游戏服务器成长之路——感悟篇