经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » 游戏设计 » 查看文章
从零开始实现放置游戏（十二）——实现战斗挂机（3）数据字典和缓存改造
来源：cnblogs　　作者：丶谦信　　时间：2019/11/4 8:29:48　　对本文有异议

　　上一章，我们添加了游戏的主界面和注册登录功能。由于距离上上篇间隔较长，可能有些内容想些的后来就忘了。同时，逻辑也不复杂，所以描述比较粗略。

　　现在随着模块的增加，整个架构也暴露出一些问题。本章我们将对整个系统进行大规模重构。

　　比如，之前为了快速开发，rms模块，我们采用了直接访问数据库的方式，对于rms模块本身来说，没有什么问题。

　　但是，在game模块中，对于频繁访问的、不经常改变的数据或接口，希望采用缓存的方式，将数据缓存起来，减少后端压力，同时加快响应速度，从而提升体验。

　　之前rms模块中尝试使用了EhCache，作为内存缓存。但现在增加了game模块，内存缓存无法在两个进程中共享。因此，我们引入redis，把缓存数据统一存到redis中。这里我们先使用spring-data-redis来进行缓存。通过在Service的方法上标记注解，来将方法返回结果进行缓存。这样一个粗粒度的缓存，目前能满足大部分需求。后面有需要时，我们再手动操作redis，进行细粒度的缓存。

　　除了缓存改造，发现一些枚举值，比如：种族、职业、阵营等，目前以静态类、枚举类的形式，在各个模块定义，这样每当我修改时，需要同时修改几个地方。因此，我添加了数据字典表，将这类数据统一配置到数据库中，同时由于不常修改，各个模块可以直接将其读到缓存中。数据字典的UML类图如下。

　　这样，我只需要一个静态类，枚举出父级配置即可，以后只会增加，一般情况下都不会修改。代码如下：

  1. package com.idlewow.datadict.model;
  3. import java.io.Serializable;
  5. public enum DataType implements Serializable {
  6.     Occupy("10100", "领土归属"),
  7.     Faction("10110", "阵营"),
  8.     Race("10200", "种族"),
  9.     Job("10250", "职业"),
  10.     MobType("10300", "怪物类型"),
  11.     MobClass("10310", "怪物种类");
  13.     private String code;
  14.     private String value;
  16.     DataType(String code, String value) {
  17.         this.code = code;
  18.         this.value = value;
  19.     }
  21.     public String getCode() {
  22.         return code;
  23.     }
  25.     public String getValue() {
  26.         return value;
  27.     }
  28. }
DataType.java

附一、spring-data-redis

　　此缓存组件使用比较简单，安装好redis，添加好依赖和配置后。在需要缓存的方法上标记注解即可。主要有@Cacheable、@CacheEvict、@CachePut。

例一：下面的注解，代表此方法执行成功后，将返回结果缓存到redis中， key为 mapMob:#{id}，当结果为NULL时，不缓存。

  1. @Cacheable(value = "mapMob", key = "#id", unless = "#result == null")
  2. public CommonResult find(String id) {
  3.     return super.find(id);
  4. }

例二：下面的注解，代表此方法执行成功后，将缓存 dataDict: 中的键全部清除

  1. @CacheEvict(value = "dataDict", allEntries = true)
  2. public CommonResult update(DataDict dataDict) {
  3.     return super.update(dataDict);
  4. }

例三：下面的注解，代表方法执行成功后，将key为 levelExp:#{id} 的缓存更新为方法返回的结果

  1. @CachePut(value = "levelExp", key = "#levelExp.getId()")
  2. public CommonResult update(LevelExp levelExp) {
  3.     return super.update(levelExp);
  4. }

　　

一、缓存改造

　　因为是在hessian的方法上进行缓存，这里我们在hessian模块的pom.xml中添加依赖如下：

  1.         <!-- 缓存相关 -->
  2.         <dependency>
  3.             <groupId>org.springframework.data</groupId>
  4.             <artifactId>spring-data-redis</artifactId>
  5.             <version>2.2.0.RELEASE</version>
  6.         </dependency>
  7.         <dependency>
  8.             <groupId>redis.clients</groupId>
  9.             <artifactId>jedis</artifactId>
  10.             <version>3.1.0</version>
  11.         </dependency>
pom.xml

　　这里，我们需要配置一个叫 cacheManager 的 bean。之前我们一直使用xml对各组件进行配置，此 cacheManager 也可以使用xml进行配置。但在实际使用中，我想将redis的key统一配置成 idlewow:xxx:...，研究了半天未找到xml形式的配置方法，因此这里使用Java代码进行配置。在hessian模块添加包 com.idlewow，然后新建  CacheConfig 类，如下:

  1. package com.idlewow.config;
  3. import org.springframework.cache.CacheManager;
  4. import org.springframework.cache.annotation.CachingConfigurerSupport;
  5. import org.springframework.cache.annotation.EnableCaching;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  9. import org.springframework.data.redis.cache.RedisCacheManager;
  10. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
  11. import redis.clients.jedis.JedisPoolConfig;
  13. import java.time.Duration;
  15. @EnableCaching
  16. @Configuration
  17. public class CacheConfig extends CachingConfigurerSupport {
  18.     @Bean
  19.     public JedisPoolConfig jedisPoolConfig() {
  20.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  21.         jedisPoolConfig.setMaxTotal(200);
  22.         jedisPoolConfig.setMaxIdle(50);
  23.         jedisPoolConfig.setMinIdle(20);
  24.         jedisPoolConfig.setMaxWaitMillis(5000);
  25.         jedisPoolConfig.setTestOnBorrow(true);
  26.         jedisPoolConfig.setTestOnReturn(false);
  27.         return jedisPoolConfig;
  28.     }
  30.     @Bean
  31.     public JedisConnectionFactory jedisConnectionFactory() {
  32.         JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig());
  33.         return jedisConnectionFactory;
  34.     }
  36.     @Bean
  37.     public CacheManager cacheManager() {
  38.         RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
  39.                 .entryTtl(Duration.ofHours(1))
  40.                 .disableCachingNullValues()
  41.                 .computePrefixWith(cacheName -> "idlewow:" + cacheName + ":");
  43.         RedisCacheManager redisCacheManager = RedisCacheManager.builder(jedisConnectionFactory())
  44.                 .cacheDefaults(configuration)
  45.                 .build();
  47.         return redisCacheManager;
  48.     }
  49. }
CacheConfig

　   这里我只简单的配置了下，缓存的有效期为1小时，当结果为NULL时不缓存，key前缀为 idlewow:。 有兴趣的话可以研究下到底能否用xml配置key前缀，注意这里用的是spring-data-redis 2.x版本，和 1.x 版本配置区别较大。

 

　   添加好依赖后，我们需要在服务的方法上打上标记即可。服务的实现类，在core模块下。

　　比如，我们这里以 MapMobServiceImpl 为例，此服务的方法update、delete、find执行成功后，我们均需要更新缓存。因为我们不缓存NULL值，因此add执行后，无需更新缓存。这里的方法已经在BaseServiceImpl里实现过来，但需要打注解，不能直接在父类里标记，因此各个子类重写一下方法签名，内容直接 super.find(id)，即可，也比较方便。代码如下：

  1. package com.idlewow.mob.service.impl;
  3. import com.idlewow.common.BaseServiceImpl;
  4. import com.idlewow.common.model.CommonResult;
  5. import com.idlewow.mob.manager.MapMobManager;
  6. import com.idlewow.mob.model.MapMob;
  7. import com.idlewow.mob.service.MapMobService;
  8. import com.idlewow.query.model.MapMobQueryParam;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.cache.annotation.CacheEvict;
  11. import org.springframework.cache.annotation.CachePut;
  12. import org.springframework.cache.annotation.Cacheable;
  13. import org.springframework.stereotype.Service;
  15. import java.util.List;
  17. @Service("mapMobService")
  18. public class MapMobServiceImpl extends BaseServiceImpl<MapMob, MapMobQueryParam> implements MapMobService {
  19.     @Autowired
  20.     MapMobManager mapMobManager;
  22.     /**
  23.      * 更新数据
  24.      *
  25.      * @param mapMob 数据对象
  26.      * @return
  27.      */
  28.     @Override
  29.     @CachePut(value = "mapMob", key = "#mapMob.getId()")
  30.     public CommonResult update(MapMob mapMob) {
  31.         return super.update(mapMob);
  32.     }
  34.     /**
  35.      * 删除数据
  36.      *
  37.      * @param id 主键id
  38.      * @return
  39.      */
  40.     @Override
  41.     @CacheEvict(value = "mapMob", key = "#id")
  42.     public CommonResult delete(String id) {
  43.         return super.delete(id);
  44.     }
  46.     /**
  47.      * 根据ID查询
  48.      *
  49.      * @param id 主键id
  50.      * @return
  51.      */
  52.     @Override
  53.     @Cacheable(value = "mapMob", key = "#id")
  54.     public CommonResult find(String id) {
  55.         return super.find(id);
  56.     }
  58.     /**
  59.      * 根据地图ID查询列表
  60.      *
  61.      * @param mapId 地图ID
  62.      * @return
  63.      */
  64.     @Override
  65.     @Cacheable(value = "mapMobList", key = "#mapId", unless = "#reuslt==null")
  66.     public List<MapMob> listByMapId(String mapId) {
  67.         try {
  68.             return mapMobManager.listByMapId(mapId);
  69.         } catch (Exception ex) {
  70.             logger.error(ex.getMessage(), ex);
  71.             return null;
  72.         }
  73.     }
  74. }
MapMobServiceImpl

　　OK, hessian模块的缓存已改造完毕。可以尝试调用一下，redis里应该已经可以写入数据。

　　另外：这里我还添加了一个listByMapId方法，后面game模块会调用。这里没有再统一返回CommonResult类型。因为我在实际写代码过程中，发现每次调接口都去做判断实在太繁琐了，对内调用一般无需这么麻烦。一般在跨部门、公司之间的接口对接，或者对容错要求比较高时，可以将异常全部捕获处理。因此，后面对内的即接口都直接返回需要的数据类型。

二、RMS系统对应改造

　　hessian既然已经改成了redis缓存。RMS系统需要做对应的改造。game模块中读取了缓存，如果rms模块修改了数据，却没有更新redis缓存，会造成最终的数据不一致。

　　因此，我们将rms模块改造为通过访问hessian服务来读写数据，这样调用hessian方法时就能触发缓存，不再直接访问数据库。

　　这里把EhCache、数据库相关的代码、配置、依赖都删掉。并在pom中添加对hessian的引用，并像game模块一样，配置hessian-client.xml并在applicationContext.xml中引入。

　　在代码中，我们将CrudController中的BaseManager替换成BaseService，并将其他地方做对应修改。如下图：

  1. package com.idlewow.rms.controller;
  3. import com.idlewow.common.model.BaseModel;
  4. import com.idlewow.common.model.CommonResult;
  5. import com.idlewow.common.model.PageList;
  6. import com.idlewow.common.model.QueryParam;
  7. import com.idlewow.common.service.BaseService;
  8. import com.idlewow.util.validation.ValidateGroup;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.ui.Model;
  11. import org.springframework.web.bind.annotation.PathVariable;
  12. import org.springframework.web.bind.annotation.RequestBody;
  13. import org.springframework.web.bind.annotation.RequestMapping;
  14. import org.springframework.web.bind.annotation.RequestMethod;
  15. import org.springframework.web.bind.annotation.RequestParam;
  16. import org.springframework.web.bind.annotation.ResponseBody;
  18. import javax.servlet.http.HttpServletRequest;
  20. public abstract class CrudController<T extends BaseModel, Q extends QueryParam> extends BaseController {
  21.     private final String path = this.getClass().getAnnotation(RequestMapping.class).value()[0];
  23.     @Autowired
  24.     BaseService<T, Q> baseService;
  25.     @Autowired
  26.     HttpServletRequest request;
  28.     @RequestMapping("/list")
  29.     public Object list() {
  30.         return this.path + "/list";
  31.     }
  33.     @ResponseBody
  34.     @RequestMapping(value = "/list", method = RequestMethod.POST)
  35.     public Object list(@RequestParam(value = "page", defaultValue = "1") int pageIndex, @RequestParam(value = "limit", defaultValue = "10") int pageSize, Q q) {
  36.         try {
  37.             q.setPage(pageIndex, pageSize);
  38.             CommonResult commonResult = baseService.list(q);
  39.             if (commonResult.isSuccess()) {
  40.                 PageList<T> pageList = (PageList<T>) commonResult.getData();
  41.                 return this.parseTable(pageList);
  42.             } else {
  43.                 request.setAttribute("errorMessage", commonResult.getMessage());
  44.                 return "/error";
  45.             }
  46.         } catch (Exception ex) {
  47.             logger.error(ex.getMessage(), ex);
  48.             request.setAttribute("errorMessage", ex.getMessage());
  49.             return "/error";
  50.         }
  51.     }
  53.     @RequestMapping("/add")
  54.     public Object add() {
  55.         return this.path + "/add";
  56.     }
  58.     @ResponseBody
  59.     @RequestMapping(value = "/add", method = RequestMethod.POST)
  60.     public Object add(@RequestBody T t) {
  61.         try {
  62.             CommonResult commonResult = this.validate(t, ValidateGroup.Create.class);
  63.             if (!commonResult.isSuccess())
  64.                 return commonResult;
  66.             t.setCreateUser(this.currentUserName());
  67.             commonResult = baseService.insert(t);
  68.             return commonResult;
  69.         } catch (Exception ex) {
  70.             logger.error(ex.getMessage(), ex);
  71.             return CommonResult.fail(ex.getMessage());
  72.         }
  73.     }
  75.     @RequestMapping(value = "/edit/{id}", method = RequestMethod.GET)
  76.     public Object edit(@PathVariable String id, Model model) {
  77.         try {
  78.             CommonResult commonResult = baseService.find(id);
  79.             if (commonResult.isSuccess()) {
  80.                 T t = (T) commonResult.getData();
  81.                 model.addAttribute(t);
  82.                 return this.path + "/edit";
  83.             } else {
  84.                 request.setAttribute("errorMessage", commonResult.getMessage());
  85.                 return "/error";
  86.             }
  87.         } catch (Exception ex) {
  88.             logger.error(ex.getMessage(), ex);
  89.             request.setAttribute("errorMessage", ex.getMessage());
  90.             return "/error";
  91.         }
  92.     }
  94.     @ResponseBody
  95.     @RequestMapping(value = "/edit/{id}", method = RequestMethod.POST)
  96.     public Object edit(@PathVariable String id, @RequestBody T t) {
  97.         try {
  98.             if (!id.equals(t.getId())) {
  99.                 return CommonResult.fail("id不一致");
  100.             }
  102.             CommonResult commonResult = this.validate(t, ValidateGroup.Update.class);
  103.             if (!commonResult.isSuccess())
  104.                 return commonResult;
  106.             t.setUpdateUser(this.currentUserName());
  107.             commonResult = baseService.update(t);
  108.             return commonResult;
  109.         } catch (Exception ex) {
  110.             logger.error(ex.getMessage(), ex);
  111.             return CommonResult.fail(ex.getMessage());
  112.         }
  113.     }
  115.     @ResponseBody
  116.     @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
  117.     public Object delete(@PathVariable String id) {
  118.         try {
  119.             baseService.delete(id);
  120.             return CommonResult.success();
  121.         } catch (Exception ex) {
  122.             logger.error(ex.getMessage(), ex);
  123.             return CommonResult.fail(ex.getMessage());
  124.         }
  125.     }
  126. }
CrudController.java

　　另外，因为添加了数据字典。rms模块需要添加对应的contoller和页面。这里不一一赘述。既然已经有了数据字典，之前写死的枚举，EnumUtil都可以废除了。直接从hessian读取数据字典配置到缓存。

　　在com.idlewow.rms.support.util包下添加DataDictUtil类，代码如下：

  1. package com.idlewow.rms.support.util;
  3. import com.idlewow.common.model.CommonResult;
  4. import com.idlewow.datadict.model.DataDict;
  5. import com.idlewow.datadict.model.DataType;
  6. import com.idlewow.datadict.service.DataDictService;
  7. import com.idlewow.query.model.DataDictQueryParam;
  8. import org.apache.logging.log4j.LogManager;
  9. import org.apache.logging.log4j.Logger;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.stereotype.Component;
  13. import java.io.Serializable;
  14. import java.util.HashMap;
  15. import java.util.List;
  16. import java.util.Map;
  18. @Component
  19. public class DataDictUtil implements Serializable {
  20.     private static final Logger logger = LogManager.getLogger(DataDictUtil.class);
  22.     @Autowired
  23.     DataDictService dataDictService;
  25.     public static Map<String, Map<String, String>> ConfigMap = new HashMap<>();
  27.     public void initialize() {
  28.         DataDictQueryParam dataDictQueryParam = new DataDictQueryParam();
  29.         CommonResult commonResult = dataDictService.list(dataDictQueryParam);
  30.         if (commonResult.isSuccess()) {
  31.             List<DataDict> dataDictList = (List<DataDict>) commonResult.getData();
  32.             for (DataDict dataDict : dataDictList) {
  33.                 if (ConfigMap.containsKey(dataDict.getParentCode())) {
  34.                     ConfigMap.get(dataDict.getParentCode()).put(dataDict.getCode(), dataDict.getValue());
  35.                 } else {
  36.                     Map map = new HashMap();
  37.                     map.put(dataDict.getCode(), dataDict.getValue());
  38.                     ConfigMap.put(dataDict.getParentCode(), map);
  39.                 }
  40.             }
  41.         } else {
  42.             logger.error("缓存加载失败！");
  43.         }
  44.     }
  46.     public static Map<String, String> occupy() {
  47.         return ConfigMap.get(DataType.Occupy.getCode());
  48.     }
  50.     public static Map<String, String> job() {
  51.         return ConfigMap.get(DataType.Job.getCode());
  52.     }
  54.     public static Map<String, String> faction() {
  55.         return ConfigMap.get(DataType.Faction.getCode());
  56.     }
  58.     public static Map<String, String> mobClass() {
  59.         return ConfigMap.get(DataType.MobClass.getCode());
  60.     }
  62.     public static Map<String, String> mobType() {
  63.         return ConfigMap.get(DataType.MobType.getCode());
  64.     }
  65. }
DataDictUtil.java

　　在StartUpListener中，初始化缓存：

  1.     @Override
  2.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  3.         logger.info("缓存初始化。。。");
  4.         dataDictUtil.initialize();
  5.         logger.info("缓存初始化完毕。。。");
  6.     }

　　后端缓存有了，同样的，前端写死的枚举也不需要了。可以使用localStorage进行缓存。代码如下：

  1. /* 数据字典缓存 */
  2. var _cache = {
  3.     version: new Date().getTime(),
  4.     configmap: null
  5. };
  7. /* 读取缓存 */
  8. function loadCache() {
  9.     if (_cache.configmap == null || (new Date().getTime() - _cache.version) > 1000 * 60 * 30) {
  10.         var localConfigMap = localStorage.getItem("configmap");
  11.         if (localConfigMap) {
  12.             _cache.configmap = JSON.parse(localConfigMap);
  13.         } else {
  14.             /* 读取数据字典缓存 */
  15.             $.ajax({
  16.                 url: '/manage/data_dict/configMap',
  17.                 type: 'post',
  18.                 success: function (data) {
  19.                     _cache.configmap = data;
  20.                     localStorage.setItem("configmap", JSON.stringify(_cache.configmap));
  21.                 },
  22.                 error: function () {
  23.                     alert('ajax error');
  24.                 }
  25.             });
  26.         }
  27.     }
  28. }
  30. /* 数据字典Key */
  31. var DataType = {
  32.     "Occupy": "10100",  // 领土归属
  33.     "Faction": "10110", // 阵营
  34.     "Race": "10200",    // 种族
  35.     "Job": "10250",     // 职业
  36.     "MobType": "10300", // 怪物类型
  37.     "MobClass": "10310" // 怪物种类
  38. };
  40. DataDict.prototype = {
  41.     occupy: function (value) {
  42.         return _cache.configmap[DataType.Occupy][value];
  43.     },
  44.     job: function (value) {
  45.         return _cache.configmap[DataType.Job][value];
  46.     },
  47.     faction: function (value) {
  48.         return _cache.configmap[DataType.Faction][value];
  49.     },
  50.     mobClass: function (value) {
  51.         return _cache.configmap[DataType.MobClass][value];
  52.     },
  53.     mobType: function (value) {
  54.         return _cache.configmap[DataType.MobType][value];
  55.     }
  56. };
  58. loadCache();
Helper.js

　　注意，这里使用了jQuery的ajax请求，必须在引用之前引用jquery。

小结

       内容有些许遗漏，下周再补充些。

　　源码下载地址：https://545c.com/file/14960372-405053633

 

原文链接：http://www.cnblogs.com/lyosaki88/p/idlewow_12.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

游戏设计热门文章

  • DirectX11--深入理解与使用2D纹理资源
  • unity渲染篇：烘焙模型贴图
  • Unity导入模型出现 (Avatar Rig Configuration mis-match. Bone length in configuration does not match position in animation)?
  • Unreal: Dynamic load map from Pak file
  • 《unity 3D 游戏开发 第二版》宣雨松 分享 pdf下载
  • 空间划分的数据结构(网格/四叉树/八叉树/BSP树/k-d树/BVH/自定义划分)
  • Unity编辑器汉化(中文语言包)
  • [Unity编辑器扩展基础总结] 第3章 编辑器下的数据保存
  • Unity 3D游戏开发 pdf高清下载
  • 用C#写一个俄罗斯方块

    • 游戏设计推荐文章

  • Unity3D开发入门教程（二）—— Lua入门
  • Unity3D开发入门教程（三）——添加启动脚本
  • Unity3D开发入门教程（四）——用Lua实现组件
  • RectMask2D裁剪Canvas无效问题
  • Python编程环境设置
  • Minecraft类游戏地形生成机制
  • 3D网页小实验-基于Babylon.js与recast.js实现RTS式单位控制
  • Unity3D OpenVR 虚拟现实 保龄球打砖块游戏开发
  • [Unity编辑器扩展基础总结] 第3章 编辑器下的数据保存
  • 关于看门狗的两种模型以及带来的思考

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号