关于mongo的思考

第一阶段的弱联网游戏已基本完成，截至今天下午，测试也基本差不多了，前端还有一些小bug需要优化，接下来会接入小米，360，百度，腾讯等平台，然后推广一波，年前公司还能赚一笔，而我，也即将准备做下一款SLG。上一次，我第一次尝试了Netty，并且也着实感受到了Nio的魅力，Netty的魅力，在做的过程中也学到了很多有用的东西，这一次，在数据持久化方面，我思考了很久，我越发的觉得，我即将做的这款游戏的数据用nosql来存储更合适，甚至是之前做的那款弱联网游戏的存储，我也认为似乎应该使用nosql来做存储，因为游戏数据的扩展性太强了，也不需要传统关系型数据库那些复杂的约束，似乎是高性能的mongo更适合这类数据的存储，之前因为项目比较急，没敢在数据库这块做尝试，而这次，我准备尝试使用Mongo做数据层的持久化，以前做Web开发的时候，项目中用过Mongo，但是当时对它了解并不多，最多了解到它是一种文档型数据库，和传统数据库有较大区别，但我并没有太多的了解，而当我开始做游戏之后，却越来越觉得这种Nosql数据库似乎更加适合游戏数据存储的需求。最终我还是准备使用mongo来做数据持久化，然后开始了我的mongo之旅，心中不由说了一句——你好，mongo！

初识mongo

众多nosql数据库中，我为什么要用mongo呢？实际上，我还会用到memcache和redis，memcached用来做缓存，memcache的缓存性能相信大家也清楚，用它来配合mongo来做缓存再适合不过了，把玩家完整的游戏数据都放在缓存中，读取全部数据直接读取缓存（具体哪些数据缓存到时候看情况而定），而使用redis，主要是看中它多样的数据类型和数据本地化的功能，并且redis的性能也不必memcache差多少，而mongo，更是一种高性能的文档型数据库，不了解的同学可以去官网逛逛，mongo的官网地址：http://www.mongo.org Mongo主要特下如下：

  1. 文档存储：首先就是存储方式——文档存储，这一特性某种程度上决定了mongo数据库的性能，mongo中得数据以bson形式存储（二进制的json），属性中可以再嵌套bson，非常灵活，对于一个层级式的数据结构来说，如果要将这样的数据使用扁平式的，表状的结构来保存数据，这无论是在查询还是获取数据时都十分困难。比如说一个玩家数据，有角色名，有性别，有等级，还有背包，背包中物品，物品还有属性，如果按照传统数据库的思维，可能会有一个玩家基础属性表，一个背包表，这样查询起来就要联合两张表进行查询，而在mongo中，这就是一条数据，一个玩家一条数据，直接一个玩家id，就包括了角色名，性别等，还包括了背包，背包中再嵌套一个bson来存储背包中得物品，物品再继续嵌套其属性，就这样，一个id就能查出这个玩家所有的数据，而且mongo的查询性能也是相当高效的。MongoDB javascript shell是一个基于javascript的解释器，在mongo中，你还可以使用js来操作mongo。
  2. 可扩展性：这一点大概是最适合游戏开发中得特性之一，游戏数据是多变，可能今天玩家数据结构中要加一个属性，明天玩家数据结构中又要去掉一个属性，对于关系型数据库来说，面对千行数据，可能你就发愁了，而mongo不用担心，它可以很容易的横向扩展
  3. 易于查询：这和第一点有很大关系，MongoDB以文档的形式存储数据，不支持事务和表连接。因此查询的编写、理解和优化都容易得多。简单查询设计思路不同于SQL模式，嵌入文档在特定的环境下可得到更好的查询。游戏后端处理是要求效率的，这一点点大大提升了mongo在游戏后端中可用性。
  4. 安全性：由于MongoDB客户端生成的查询为BSON对象，而不是可以被解析的字符串，所以可降低受到SQL注入的攻击的危险。不同于常见的sql语句，普通的sql攻击自然对bson无效。

仅凭以上4点，我认为，像我做的这种数据类型复杂多变的游戏数据用mongo来存储再合适不过了。当然mongo还有更多的优点如复制和故障恢复，支持完全索引等。

了解API

mongo本身是由C++编写的，可它却也支持很多语言，当然，最重要的是，它有提供Java api，以下是mongo java api官方文档：http://api.mongodb.org/java/2.11.2/ 当然，既然有官方api，那就一定有人封装了更方便更好用的框架出来，像morphia，就是一款类似于关系型数据库ORM的Hibernate一样，方便易用，另外，spring也提供了mongo的封装，有兴趣的都可以去了解一下，毕竟每个人有自己的习惯，自己喜欢的才是最好的。使用官方提供的java api，操作mongo也是非常的方便，举例，比如以下保存对象的方法：

  1.           //第一：实例化mongo对象，连接mongodb服务器  包含所有的数据库  
  2.           //默认构造方法，默认是连接本机，端口号，默认是27017  
  3.           //相当于Mongo mongo =new Mongo("localhost",27017)  
  4.           Mongo mongo =new Mongo();  
  5.            
  6.           //第二：连接具体的数据库  
  7.           //其中参数是具体数据库的名称，若服务器中不存在，会自动创建  
  8.           DB db=mongo.getDB("myMongo");  
  9.            
  10.           //第三：操作具体的表  
  11.          //在mongodb中没有表的概念，而是指集合  
  12.           //其中参数是数据库中表，若不存在，会自动创建  
  13.           DBCollection collection=db.getCollection("user");  
  14.            
  15.           //添加操作  
  16.           //在mongodb中没有行的概念，而是指文档  
  17.           BasicDBObject document=new BasicDBObject();  
  18.            
  19.           document.put("id", 1);  
  20.           document.put("name", "小明");  
  21.           //然后保存到集合中  
  22.           //collection.insert(document);  
  23.    
  24.           //当然我也可以保存这样的json串  
  25.           /*  {  
  26.                "id":1,  
  27.                "name","小明",  
  28.                "address":  
  29.                {  
  30.                "city":"beijing",  
  31.                "code":"065000"  
  32.                }  
  33.           }*/  
  34.           //实现上述json串思路如下：  
  35.           //第一种：类似xml时，不断添加  
  36.           BasicDBObject addressDocument=new BasicDBObject();  
  37.           addressDocument.put("city", "beijing");  
  38.           addressDocument.put("code", "065000");  
  39.           document.put("address", addressDocument);  
  40.           //然后保存数据库中  
  41.           collection.insert(document);  
  42.            
  43.           //第二种：直接把json存到数据库中  
  44.           /* String jsonTest="{'id':1,'name':'小明',"+  
  45.                    "'address':{'city':'beijing','code':'065000'}"+  
  46.                     "}";  
  47.          DBObject dbobjct=(DBObject)JSON.parse(jsonTest);  
  48.          collection.insert(dbobjct);*/  

其余方法我就不赘述了，想了解的可以查官方文档。

使用mongo

既然决定使用mongo，那就要着手开始写工具类，按照官方文档，我写了MongoUtil和DBObjectUtil两个工具类，MongoUtil负责数据库的连接和操作，DBObjectUtil则是Mongo中的操作对象DBObject与Javabean之间的相互转换。首先，我要在我的maven的pom.xml文件中依赖mongo的jar包

  1. <dependency>
  2.   <groupId>org.mongodb</groupId>
  3.   <artifactId>mongo-java-driver</artifactId>
  4.   <version>2.11.2</version>
  5. </dependency>

然后是我的MongoUtil类，其中简单做了数据库的连接管理，MC是Memcache缓存，这部分代码就不贴出来了，上篇文章已贴出过Memcache部分代码：

  1. /**
  2.  * @ClassName: MongoUtil
  3.  * @Description: mongo
  4.  * @author 何金成
  5.  * @date 2016年1月19日 下午3:35:25
  6.  * 
  7.  */
  8. public class MongoUtil {
  10.  private MongoClient mongo = null;
  11.  private DB db = null;
  12.  private static Logger logger = LoggerFactory.getLogger(MongoUtil.class);
  13.  private static final Map<String, MongoUtil> instances = new ConcurrentHashMap<String, MongoUtil>();
  14.  private static final String CONF_PATH = "/spring-mongodb/mongodb.properties";
  15.  public static final String DB_ID = "id";// DB中id字段名
  17.  /**
  18.   * 实例化
  19.   * 
  20.   * @return MongoDBManager对象
  21.   */
  22.  static {
  23.   getInstance("db");// 初始化默认的MongoDB数据库
  24.  }
  26.  public static MongoUtil getInstance() {
  27.   return getInstance("db");// 配置文件默认数据库前缀为db
  28.  }
  30.  public static MongoUtil getInstance(String dbName) {
  31.   MongoUtil mongoMgr = instances.get(dbName);
  32.   if (mongoMgr == null) {
  33.    mongoMgr = buildInstance(dbName);
  34.    if (mongoMgr == null) {
  35.     return null;
  36.    }
  37.    instances.put(dbName, mongoMgr);
  38.   }
  39.   return mongoMgr;
  40.  }
  42.  private static synchronized MongoUtil buildInstance(String dbName) {
  43.   MongoUtil mongoMgr = new MongoUtil();
  44.   try {
  45.    mongoMgr.mongo = new MongoClient(getServerAddress(dbName),
  46.      getMongoCredential(dbName), getDBOptions(dbName));
  47.    mongoMgr.db = mongoMgr.mongo.getDB(getProperty(CONF_PATH, dbName
  48.      + ".database"));
  49.    logger.info("connect to MongoDB success!");
  50.    boolean flag = mongoMgr.db.authenticate(
  51.      getProperty(CONF_PATH, dbName + ".username"),
  52.      getProperty(CONF_PATH, dbName + ".password").toCharArray());
  53.    if (!flag) {
  54.     logger.error("MongoDB auth failed");
  55.     return null;
  56.    }
  57.   } catch (Exception e) {
  58.    logger.info("Can't connect " + dbName + " MongoDB! {}", e);
  59.    return null;
  60.   }
  61.   return mongoMgr;
  62.  }
  64.  /**
  65.   * 根据properties文件的key获取value
  66.   * 
  67.   * @param filePath
  68.   *            properties文件路径
  69.   * @param key
  70.   *            属性key
  71.   * @return 属性value
  72.   */
  73.  private static String getProperty(String filePath, String key) {
  74.   Properties props = new Properties();
  75.   try {
  76.    InputStream in = MongoUtil.class.getResourceAsStream(filePath);
  77.    props.load(in);
  78.    String value = props.getProperty(key);
  79.    return value;
  80.   } catch (Exception e) {
  81.    logger.info("load mongo properties exception {}", e);
  82.    System.exit(0);
  83.    return null;
  84.   }
  85.  }
  87.  /**
  88.   * 获取集合（表）
  89.   * 
  90.   * @param collection
  91.   */
  92.  public DBCollection getCollection(String collection) {
  93.   DBCollection collect = db.getCollection(collection);
  94.   return collect;
  95.  }
  97.  /**
  98.   * 插入
  99.   * 
  100.   * @param collection
  101.   * @param o
  102.   */
  103.  public void insert(String collection, DBObject o) {
  104.   getCollection(collection).insert(o);
  105.   // 添加到MC控制
  106.   MC.add(o, o.get(DB_ID));
  107.  }
  109.  /**
  110.   * 批量插入
  111.   * 
  112.   * @param collection
  113.   * @param list
  114.   */
  115.  public void insertBatch(String collection, List<DBObject> list) {
  116.   if (list == null || list.isEmpty()) {
  117.    return;
  118.   }
  119.   getCollection(collection).insert(list);
  120.   // 批量插入MC
  121.   for (DBObject o : list) {
  122.    MC.add(o, o.get(DB_ID));
  123.   }
  124.  }
  126.  /**
  127.   * 删除
  128.   * 
  129.   * @param collection
  130.   * @param q
  131.   *            查询条件
  132.   */
  133.  public List<DBObject> delete(String collection, DBObject q) {
  134.   getCollection(collection).remove(q);
  135.   List<DBObject> list = find(collection, q);
  136.   // MC中删除
  137.   for (DBObject tmp : list) {
  138.    DBObject dbObject = MC.<DBObject> get(DBObject.class,
  139.      (Long) tmp.get(DB_ID));
  140.    if (null != dbObject) {
  141.     MC.delete(DBObject.class, (Long) dbObject.get(DB_ID));
  142.    }
  143.   }
  144.   return list;
  145.  }
  147.  /**
  148.   * 批量删除
  149.   * 
  150.   * @param collection
  151.   * @param list
  152.   *            删除条件列表
  153.   */
  154.  public void deleteBatch(String collection, List<DBObject> list) {
  155.   if (list == null || list.isEmpty()) {
  156.    return;
  157.   }
  158.   for (int i = 0; i < list.size(); i++) {
  159.    // 批量条件删除
  160.    delete(collection, list.get(i));
  161.   }
  162.  }
  164.  /**
  165.   * 计算集合总条数
  166.   * 
  167.   * @param collection
  168.   */
  169.  public int getCount(String collection) {
  170.   int count = (int) getCollection(collection).find().count();
  171.   return count;
  172.  }
  174.  /**
  175.   * 计算满足条件条数
  176.   * 
  177.   * @param collection
  178.   * @param q
  179.   *            查询条件
  180.   */
  182.  public long getCount(String collection, DBObject q) {
  183.   return getCollection(collection).getCount(q);
  184.  }
  186.  /**
  187.   * 更新
  188.   * 
  189.   * @param collection
  190.   * @param q
  191.   *            查询条件
  192.   * @param setFields
  193.   *            更新对象
  194.   * @return List<DBObject> 更新后的对象列表
  195.   */
  196.  public List<DBObject> update(String collection, DBObject q,
  197.    DBObject setFields) {
  198.   getCollection(collection).updateMulti(q,
  199.     new BasicDBObject("$set", setFields));
  200.   List<DBObject> list = find(collection, q);
  201.   // 遍历
  202.   for (DBObject dbObject : list) {
  203.    // MC 中修改
  204.    DBObject tmp = MC.<DBObject> get(DBObject.class,
  205.      (Long) dbObject.get(DB_ID));
  206.    if (null != tmp) {
  207.     MC.update(dbObject, (Long) tmp.get(DB_ID));
  208.    }
  209.   }
  210.   return list;
  211.  }
  213.  /**
  214.   * 查找集合所有对象
  215.   * 
  216.   * @param collection
  217.   */
  218.  public List<DBObject> findAll(String collection) {
  219.   List<DBObject> list = getCollection(collection).find().toArray();
  220.   return list;
  221.  }
  223.  /**
  224.   * 按顺序查找集合所有对象
  225.   * 
  226.   * @param collection
  227.   *            数据集
  228.   * @param orderBy
  229.   *            排序
  230.   */
  231.  public List<DBObject> findAll(String collection, DBObject orderBy) {
  232.   return getCollection(collection).find().sort(orderBy).toArray();
  233.  }
  235.  /**
  236.   * 查找（返回一个对象）
  237.   * 
  238.   * @param collection
  239.   * @param q
  240.   *            查询条件
  241.   */
  242.  public DBObject findOne(String collection, DBObject q) {
  243.   return findOne(collection, q, null);
  244.  }
  246.  /**
  247.   * 查找（返回一个对象）
  248.   * 
  249.   * @param collection
  250.   * @param q
  251.   *            查询条件
  252.   * @param fileds
  253.   *            返回字段
  254.   */
  255.  public DBObject findOne(String collection, DBObject q, DBObject fields) {
  256.   if (q.containsField(DB_ID)) {// 如果根据id来查询,先从缓存取数据
  257.    DBObject tmp = MC.<DBObject> get(DBObject.class,
  258.      (Long) q.get(DB_ID));
  259.    if (tmp != null) {// 缓存没有数据，从数据库取
  260.     if (fields != null) {// 留下需要返回的字段
  261.      for (String key : tmp.keySet()) {
  262.       if (!fields.containsField(key)) {
  263.        tmp.removeField(key);
  264.       }
  265.      }
  266.     }
  267.     return tmp;
  268.    }
  269.   }
  270.   return fields == null ? getCollection(collection).findOne(q)
  271.     : getCollection(collection).findOne(q, fields);
  272.  }
  274.  /**
  275.   * 查找返回特定字段（返回一个List<DBObject>）
  276.   * 
  277.   * @param collection
  278.   * @param q
  279.   *            查询条件
  280.   * @param fileds
  281.   *            返回字段
  282.   */
  283.  public List<DBObject> findLess(String collection, DBObject q,
  284.    DBObject fileds) {
  285.   DBCursor c = getCollection(collection).find(q, fileds);
  286.   if (c != null)
  287.    return c.toArray();
  288.   else
  289.    return null;
  290.  }
  292.  /**
  293.   * 查找返回特定字段（返回一个List<DBObject>）
  294.   * 
  295.   * @param collection
  296.   * @param q
  297.   *            查询条件
  298.   * @param fileds
  299.   *            返回字段
  300.   * @param orderBy
  301.   *            排序
  302.   */
  303.  public List<DBObject> findLess(String collection, DBObject q,
  304.    DBObject fileds, DBObject orderBy) {
  305.   DBCursor c = getCollection(collection).find(q, fileds).sort(orderBy);
  306.   if (c != null)
  307.    return c.toArray();
  308.   else
  309.    return null;
  310.  }
  312.  /**
  313.   * 分页查找集合对象，返回特定字段
  314.   * 
  315.   * @param collection
  316.   * @param q
  317.   *            查询条件
  318.   * @param fileds
  319.   *            返回字段
  320.   * @pageNo 第n页
  321.   * @perPageCount 每页记录数
  322.   */
  323.  public List<DBObject> findLess(String collection, DBObject q,
  324.    DBObject fileds, int pageNo, int perPageCount) {
  325.   return getCollection(collection).find(q, fileds)
  326.     .skip((pageNo - 1) * perPageCount).limit(perPageCount)
  327.     .toArray();
  328.  }
  330.  /**
  331.   * 按顺序分页查找集合对象，返回特定字段
  332.   * 
  333.   * @param collection
  334.   *            集合
  335.   * @param q
  336.   *            查询条件
  337.   * @param fileds
  338.   *            返回字段
  339.   * @param orderBy
  340.   *            排序
  341.   * @param pageNo
  342.   *            第n页
  343.   * @param perPageCount
  344.   *            每页记录数
  345.   */
  346.  public List<DBObject> findLess(String collection, DBObject q,
  347.    DBObject fileds, DBObject orderBy, int pageNo, int perPageCount) {
  348.   return getCollection(collection).find(q, fileds).sort(orderBy)
  349.     .skip((pageNo - 1) * perPageCount).limit(perPageCount)
  350.     .toArray();
  351.  }
  353.  /**
  354.   * 查找（返回一个List<DBObject>）
  355.   * 
  356.   * @param collection
  357.   * @param q
  358.   *            查询条件
  359.   */
  360.  public List<DBObject> find(String collection, DBObject q) {
  361.   DBCursor c = getCollection(collection).find(q);
  362.   if (c != null)
  363.    return c.toArray();
  364.   else
  365.    return null;
  366.  }
  368.  /**
  369.   * 按顺序查找（返回一个List<DBObject>）
  370.   * 
  371.   * @param collection
  372.   * @param q
  373.   *            查询条件
  374.   * @param orderBy
  375.   *            排序
  376.   */
  377.  public List<DBObject> find(String collection, DBObject q, DBObject orderBy) {
  378.   DBCursor c = getCollection(collection).find(q).sort(orderBy);
  379.   if (c != null)
  380.    return c.toArray();
  381.   else
  382.    return null;
  383.  }
  385.  /**
  386.   * 分页查找集合对象
  387.   * 
  388.   * @param collection
  389.   * @param q
  390.   *            查询条件
  391.   * @pageNo 第n页
  392.   * @perPageCount 每页记录数
  393.   */
  394.  public List<DBObject> find(String collection, DBObject q, int pageNo,
  395.    int perPageCount) {
  396.   return getCollection(collection).find(q)
  397.     .skip((pageNo - 1) * perPageCount).limit(perPageCount)
  398.     .toArray();
  399.  }
  401.  /**
  402.   * 按顺序分页查找集合对象
  403.   * 
  404.   * @param collection
  405.   *            集合
  406.   * @param q
  407.   *            查询条件
  408.   * @param orderBy
  409.   *            排序
  410.   * @param pageNo
  411.   *            第n页
  412.   * @param perPageCount
  413.   *            每页记录数
  414.   */
  415.  public List<DBObject> find(String collection, DBObject q, DBObject orderBy,
  416.    int pageNo, int perPageCount) {
  417.   return getCollection(collection).find(q).sort(orderBy)
  418.     .skip((pageNo - 1) * perPageCount).limit(perPageCount)
  419.     .toArray();
  420.  }
  422.  /**
  423.   * distinct操作
  424.   * 
  425.   * @param collection
  426.   *            集合
  427.   * @param field
  428.   *            distinct字段名称
  429.   */
  430.  public Object[] distinct(String collection, String field) {
  431.   return getCollection(collection).distinct(field).toArray();
  432.  }
  434.  /**
  435.   * distinct操作
  436.   * 
  437.   * @param collection
  438.   *            集合
  439.   * @param field
  440.   *            distinct字段名称
  441.   * @param q
  442.   *            查询条件
  443.   */
  444.  public Object[] distinct(String collection, String field, DBObject q) {
  445.   return getCollection(collection).distinct(field, q).toArray();
  446.  }
  448.  /**
  449.   * group分组查询操作，返回结果少于10,000keys时可以使用
  450.   * 
  451.   * @param collection
  452.   *            集合
  453.   * @param key
  454.   *            分组查询字段
  455.   * @param q
  456.   *            查询条件
  457.   * @param reduce
  458.   *            reduce Javascript函数，如：function(obj,
  459.   *            out){out.count++;out.csum=obj.c;}
  460.   * @param finalize
  461.   *            reduce
  462.   *            function返回结果处理Javascript函数，如：function(out){out.avg=out.csum
  463.   *            /out.count;}
  464.   */
  465.  public BasicDBList group(String collection, DBObject key, DBObject q,
  466.    DBObject initial, String reduce, String finalize) {
  467.   return ((BasicDBList) getCollection(collection).group(key, q, initial,
  468.     reduce, finalize));
  469.  }
  471.  /**
  472.   * group分组查询操作，返回结果大于10,000keys时可以使用
  473.   * 
  474.   * @param collection
  475.   *            集合
  476.   * @param map
  477.   *            映射javascript函数字符串，如：function(){ for(var key in this) {
  478.   *            emit(key,{count:1}) } }
  479.   * @param reduce
  480.   *            reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var
  481.   *            i in emits){ total+=emits[i].count; } return {count:total}; }
  482.   * @param q
  483.   *            分组查询条件
  484.   * @param orderBy
  485.   *            分组查询排序
  486.   */
  487.  public Iterable<DBObject> mapReduce(String collection, String map,
  488.    String reduce, DBObject q, DBObject orderBy) {
  489.   // DBCollection coll = db.getCollection(collection);
  490.   // MapReduceCommand cmd = new MapReduceCommand(coll, map, reduce, null,
  491.   // MapReduceCommand.OutputType.INLINE, q);
  492.   // return coll.mapReduce(cmd).results();
  493.   MapReduceOutput out = getCollection(collection).mapReduce(map, reduce,
  494.     null, q);
  495.   return out.getOutputCollection().find().sort(orderBy).toArray();
  496.  }
  498.  /**
  499.   * group分组分页查询操作，返回结果大于10,000keys时可以使用
  500.   * 
  501.   * @param collection
  502.   *            集合
  503.   * @param map
  504.   *            映射javascript函数字符串，如：function(){ for(var key in this) {
  505.   *            emit(key,{count:1}) } }
  506.   * @param reduce
  507.   *            reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var
  508.   *            i in emits){ total+=emits[i].count; } return {count:total}; }
  509.   * @param q
  510.   *            分组查询条件
  511.   * @param orderBy
  512.   *            分组查询排序
  513.   * @param pageNo
  514.   *            第n页
  515.   * @param perPageCount
  516.   *            每页记录数
  517.   */
  518.  public List<DBObject> mapReduce(String collection, String map,
  519.    String reduce, DBObject q, DBObject orderBy, int pageNo,
  520.    int perPageCount) {
  521.   MapReduceOutput out = getCollection(collection).mapReduce(map, reduce,
  522.     null, q);
  523.   return out.getOutputCollection().find().sort(orderBy)
  524.     .skip((pageNo - 1) * perPageCount).limit(perPageCount)
  525.     .toArray();
  526.  }
  528.  /**
  529.   * group分组查询操作，返回结果大于10,000keys时可以使用
  530.   * 
  531.   * @param collection
  532.   *            集合
  533.   * @param map
  534.   *            映射javascript函数字符串，如：function(){ for(var key in this) {
  535.   *            emit(key,{count:1}) } }
  536.   * @param reduce
  537.   *            reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var
  538.   *            i in emits){ total+=emits[i].count; } return {count:total}; }
  539.   * @param outputCollectionName
  540.   *            输出结果表名称
  541.   * @param q
  542.   *            分组查询条件
  543.   * @param orderBy
  544.   *            分组查询排序
  545.   */
  546.  public List<DBObject> mapReduce(String collection, String map,
  547.    String reduce, String outputCollectionName, DBObject q,
  548.    DBObject orderBy) {
  549.   if (!db.collectionExists(outputCollectionName)) {
  550.    getCollection(collection).mapReduce(map, reduce,
  551.      outputCollectionName, q);
  552.   }
  553.   return getCollection(outputCollectionName)
  554.     .find(null, new BasicDBObject("_id", false)).sort(orderBy)
  555.     .toArray();
  556.  }
  558.  /**
  559.   * group分组分页查询操作，返回结果大于10,000keys时可以使用
  560.   * 
  561.   * @param collection
  562.   *            集合
  563.   * @param map
  564.   *            映射javascript函数字符串，如：function(){ for(var key in this) {
  565.   *            emit(key,{count:1}) } }
  566.   * @param reduce
  567.   *            reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var
  568.   *            i in emits){ total+=emits[i].count; } return {count:total}; }
  569.   * @param outputCollectionName
  570.   *            输出结果表名称
  571.   * @param q
  572.   *            分组查询条件
  573.   * @param orderBy
  574.   *            分组查询排序
  575.   * @param pageNo
  576.   *            第n页
  577.   * @param perPageCount
  578.   *            每页记录数
  579.   */
  580.  public List<DBObject> mapReduce(String collection, String map,
  581.    String reduce, String outputCollectionName, DBObject q,
  582.    DBObject orderBy, int pageNo, int perPageCount) {
  583.   if (!db.collectionExists(outputCollectionName)) {
  584.    getCollection(collection).mapReduce(map, reduce,
  585.      outputCollectionName, q);
  586.   }
  587.   return getCollection(outputCollectionName)
  588.     .find(null, new BasicDBObject("_id", false)).sort(orderBy)
  589.     .skip((pageNo - 1) * perPageCount).limit(perPageCount)
  590.     .toArray();
  591.  }
  593.  /**
  594.   * @Title: getServerAddress
  595.   * @Description: 获取数据库服务器列表
  596.   * @param dbName
  597.   * @return
  598.   * @throws UnknownHostException
  599.   * @return List<ServerAddress>
  600.   * @throws
  601.   */
  602.  private static List<ServerAddress> getServerAddress(String dbName)
  603.    throws UnknownHostException {
  604.   List<ServerAddress> list = new ArrayList<ServerAddress>();
  605.   String hosts = getProperty(CONF_PATH, dbName + ".host");
  606.   for (String host : hosts.split("&")) {
  607.    String ip = host.split(":")[0];
  608.    String port = host.split(":")[1];
  609.    list.add(new ServerAddress(ip, Integer.parseInt(port)));
  610.   }
  611.   return list;
  612.  }
  614.  /**
  615.   * @Title: getMongoCredential
  616.   * @Description: 获取数据库安全验证信息
  617.   * @param dbName
  618.   * @return
  619.   * @return List<MongoCredential>
  620.   * @throws
  621.   */
  622.  private static List<MongoCredential> getMongoCredential(String dbName) {
  623.   String username = getProperty(CONF_PATH, dbName + ".username");
  624.   String password = getProperty(CONF_PATH, dbName + ".password");
  625.   String database = getProperty(CONF_PATH, dbName + ".database");
  626.   MongoCredential credentials = MongoCredential.createMongoCRCredential(
  627.     username, database, password.toCharArray());
  628.   List<MongoCredential> credentialsList = new ArrayList<MongoCredential>();
  629.   credentialsList.add(credentials);
  630.   return credentialsList;
  631.  }
  633.  /**
  634.   * @Title: getDBOptions
  635.   * @Description: 获取数据参数设置
  636.   * @return
  637.   * @return MongoClientOptions
  638.   * @throws
  639.   */
  640.  private static MongoClientOptions getDBOptions(String dbName) {
  641.   MongoClientOptions.Builder build = new MongoClientOptions.Builder();
  642.   build.connectionsPerHost(Integer.parseInt(getProperty(CONF_PATH, dbName
  643.     + ".connectionsPerHost"))); // 与目标数据库能够建立的最大connection数量为50
  644.   build.threadsAllowedToBlockForConnectionMultiplier(Integer
  645.     .parseInt(getProperty(CONF_PATH, dbName
  646.       + ".threadsAllowedToBlockForConnectionMultiplier"))); // 如果当前所有的connection都在使用中，则每个connection上可以有50个线程排队等待
  647.   build.maxWaitTime(Integer.parseInt(getProperty(CONF_PATH, dbName
  648.     + ".maxWaitTime")));
  649.   build.connectTimeout(Integer.parseInt(getProperty(CONF_PATH, dbName
  650.     + ".connectTimeout")));
  651.   MongoClientOptions myOptions = build.build();
  652.   return myOptions;
  653.  }
  655.  public static void main(String[] args) {
  656.   try {
  657.    // getInstance().insert(
  658.    // "user",
  659.    // new BasicDBObject().append("name", "admin3")
  660.    // .append("type", "2").append("score", 70)
  661.    // .append("level", 2)
  662.    // .append("inputTime", new Date().getTime()));
  663.    // getInstance().update("user",
  664.    // new BasicDBObject().append("status", 1),
  665.    // new BasicDBObject().append("status", 2));
  666.    // === group start =============
  667.    // StringBuilder sb = new StringBuilder(100);
  668.    // sb.append("function(obj, out){out.count++;out.").append("scoreSum")
  669.    // .append("+=obj.").append("score").append(";out.")
  670.    // .append("levelSum").append("+=obj.").append("level")
  671.    // .append('}');
  672.    // String reduce = sb.toString();
  673.    // BasicDBList list = getInstance().group(
  674.    // "user",
  675.    // new BasicDBObject("type", true),
  676.    // new BasicDBObject(),
  677.    // new BasicDBObject().append("count", 0)
  678.    // .append("scoreSum", 0).append("levelSum", 0)
  679.    // .append("levelAvg", (Double) 0.0), reduce,
  680.    // "function(out){ out.levelAvg = out.levelSum / out.count }");
  681.    // for (Object o : list) {
  682.    // DBObject obj = (DBObject) o;
  683.    // System.out.println(obj);
  684.    // }
  685.    // ======= group end=========
  686.    // === mapreduce start =============
  687.    // Iterable<DBObject> list2 = getInstance()
  688.    // .mapReduce(
  689.    // "user",
  690.    // "function(){emit( {type:this.type}, {score:this.score, level:this.level} );}",
  691.    // "function(key,values){var result={score:0,level:0};var count = 0;values.forEach(function(value){result.score += value.score;result.level += value.level;count++});result.level = result.level / count;return result;}",
  692.    // new BasicDBObject(), new BasicDBObject("score", 1));
  693.    // for (DBObject o : list2) {
  694.    // System.out.println(o);
  695.    // }
  697.    // List<DBObject> list3 = getInstance().mapReduce("user",
  698.    // "function(){emit({type:this.type},{type:this.type,score:this.score,level:this.level});}",
  699.    // "function(key,values){var result={type:key.type,score:0,level:0};var count=0;values.forEach(function(value){result.score+=value.score;result.level+=value.level;count++});result.level=result.level/count;return result;}",
  700.    // "group_temp_user",
  701.    // new BasicDBObject(),
  702.    // new BasicDBObject("score",1));
  703.    // for (DBObject o : list3) {
  704.    // System.out.println(o);
  705.    // }
  706.    // ======= mapreduce end=========
  707.    // System.out.print(getInstance().findAll("user"));
  708.    // System.out.print(getInstance().find(
  709.    // "user",
  710.    // new BasicDBObject("inputTime", new BasicDBObject("$gt",
  711.    // 1348020002890L)),
  712.    // new BasicDBObject().append("_id", "-1"), 1, 2));
  713.    // getInstance().delete("user", new BasicDBObject());
  714.   } catch (Exception e) {
  715.    System.out.println(e.getMessage());
  716.   }
  717.  }
  718. }

以下是mongo的连接配置properties文件

  1. #ip和端口，多个主机用&相连
  2. db.host=127.0.0.1:27017
  3. #数据库名字
  4. db.database=war
  5. #用户名
  6. db.username=root
  7. #密码
  8. db.password=123456
  9. #每个主机的最大连接数
  10. db.connectionsPerHost=50
  11. #线程允许最大等待连接数
  12. db.threadsAllowedToBlockForConnectionMultiplier=50
  13. #连接超时时间1分钟
  14. db.connectTimeout=60000
  15. #一个线程访问数据库的时候，在成功获取到一个可用数据库连接之前的最长等待时间为2分钟
  16. #这里比较危险，如果超过maxWaitTime都没有获取到这个连接的话，该线程就会抛出Exception
  17. #故这里设置的maxWaitTime应该足够大，以免由于排队线程过多造成的数据库访问失败
  18. db.maxWaitTime=120000

DBObject和Javabean之间的转换就容易多了，可以通过json为中介来转换。

  1. public class DBObjectUtil {
  3.  /**
  4.   * 把实体bean对象转换成DBObject
  5.   * 
  6.   * @param bean
  7.   * @return
  8.   * @throws IllegalArgumentException
  9.   * @throws IllegalAccessException
  10.   */
  11.  public static <T> DBObject bean2DBObject(T bean) {
  12.   if (bean == null) {
  13.    return null;
  14.   }
  15.   DBObject dbObject = new BasicDBObject();
  16.   String json = JsonUtils.objectToJson(bean);
  17.   dbObject = (DBObject) JSON.parse(json);
  18.   return dbObject;
  19.  }
  21.  /**
  22.   * 把DBObject转换成bean对象
  23.   * 
  24.   * @param dbObject
  25.   * @param bean
  26.   * @return
  27.   * @throws IllegalAccessException
  28.   * @throws InvocationTargetException
  29.   * @throws NoSuchMethodException
  30.   */
  31.  @SuppressWarnings("unchecked")
  32.  public static <T> T dbObject2Bean(DBObject dbObject, T bean) {
  33.   if (bean == null) {
  34.    return null;
  35.   }
  36.   String json = JSON.serialize(dbObject);
  37.   bean = (T) JsonUtils.jsonToBean(json, bean.getClass());
  38.   return bean;
  39.  }
  40. }

至此，mongo搭建基本完成，更多关于mongo的探索，还是要在实践中完成，实践是检验真理的唯一标准，nosql如今炙手可热，但我们也要保持理性的态度看待问题，传统数据库和nosql究竟谁更胜一筹，不妨我们都动手试一试，是骡子是马，都拉出来溜溜！以上代码可直接用过工具类，欢迎交流探讨！

Java游戏服务器成长之路——你好，Mongo的更多相关文章

  1. Java游戏服务器成长之路——感悟篇

    又是一个美好的周末啊,现在一到周末,早上就起得晚,下午困了又会睡一两个小时,上班的时候,早上起来喝一杯咖啡,然后就能高效的工作一整天,然而到了周末人就懒散了,哈哈. 最近刚跳槽,到新公司已经干了有两周 ...

  2. Java游戏服务器成长之路——弱联网游戏篇（源码分析）

    前言 前段时间由于公司的一款弱联网游戏急着上线,没能及时分享,现在基本做的差不多,剩下的就是测试阶段了(本来说元旦来分享一下服务器技术的).公司的这款游戏已经上线一年多了,在我来之前一直都是单机版本, ...

  3. Java游戏服务器搭建

    一.前言 此游戏服务器架构是一个单服的形式,也就是说所有游戏逻辑在一个工程里,没有区分登陆服务器.战斗服务器.世界服务器等.此架构已成功应用在了多款页游服务器 .在此框架中没有实现相关业务逻辑,只有简 ...

  4. 分享下对JAVA程序员成长之路的总结<转>

    我也搞了几年JAVA了,由于一向懒惰,没有成为大牛,只是一普通程序猿,手痒来给新人分享下从新手成长为老鸟的已见.   首先初识语法的阶段,必须要学会怎么操作对象,操作if和for,操作list set ...

  5. 【转载】分享下多年积累的对JAVA程序员成长之路的总结

    注:该文是从百度贴吧转载过来,之前看到觉得写得还不错,对Java开发学习者来说很有意义的,可以看看. 我也搞了几年JAVA了,由于一向懒惰,没有成为大牛,只是一普通程序猿,不爱玩社交网站,不爱玩微博, ...

  6. 一个JAVA程序员成长之路分享

    我搞JAVA也有些日子了, 因为我比较贪玩,上进心不那么强, 总是逼不得已为了高薪跳槽才去学习, 所以也没混成什么大牛, 但好在现在也已经成家立业, 小日子过的还算滋润, 起码顶得住一月近万元的吃喝拉 ...

  7. 分享下多年积累的对JAVA程序员成长之路的总结

    http://blog.csdn.net/zhongzelin/article/details/8643269我也搞了几年JAVA了,由于一向懒惰,没有成为大牛,只是一普通程序猿,不爱玩社交网站,不爱 ...

  8. java实习生的成长之路<转>

    首先初识语法的阶段,必须要学会怎么操作对象,操作if和for,操作list set map,然后是线程.IO和jdbc什么的,其余的,若是一时不理解,可以后边需要时再学. 这阶段完了,你可以写些能在控 ...

  9. Java程序的成长之路

    转载链接:http://www.admin10000.com/document/2901.html 互联网发展日新月异,社会科技每天都在发生着翻天覆地的变化,而程序员已经成了这个时代的庞大群体,各种各 ...

随机推荐

  1. SQLServer------Sql Server性能优化辅助指标SET STATISTICS TIME ON和SET STATISTICS IO ON

    转载: http://www.cnblogs.com/xqhppt/p/4041799.html

  2. 工作流JBPM_day02：1-回顾_2-设计流程Transition

    工作流JBPM_day02:1-回顾 1,工作流框架 处理流程的 流程多,有变化 2,准备环境 + HelloWorld 一.概念 Deployment部署对象 ProcessDefinition 流 ...

  3. MySQL<多表操作>

    多表操作 外键 什么是外键 外键是指引用另一个表中的一列或多列,被引用的列应该具有主键约束或唯一性约束. 外键用于建立和加强两个表数据之间的链接. 为表添加外键约束 想要真正连接两个表的数据,就需要为 ...

  4. try catch finally的执行顺序

    1.将预见可能引发异常的代码包含在try语句块中. 2.如果发生了异常,则转入catch的执行.catch有几种写法: catch 这将捕获任何发生的异常. catch(Exception e) 这将 ...

  5. 服务端用例设计的思(tao)路!

    服务端的测试简单来说就是除了前端以外的的测试. 总的来说可以分为以下两类: 1.     WEB或者APP的提供业务逻辑的服务端接口测试 2.     数据库.缓存系统.中间件..jar包依赖.输入输 ...

  6. python2.0_day18_Django自带的用户认证模块的使用

    用户验证我们基于一个项目来学习利用Django框架中的user表实现用户认证Django练习小项目:学员管理系统设计开发 项目需求: 1.分讲师\学员\课程顾问角色, 2.学员可以属于多个班级,学员成 ...

  7. UE4修改自Rama的UDP通信蓝图插件

    UE4.15没有提供蓝图UDP的组件,可以在网上找到一个ID叫Rama写的源代码,我把它封装成插件了(MyUdpPlugin),方便在各个UE4版本工程中使用UDP通信. 使用方式: 1.在自己的工程 ...

  8. C# EMS Client

    从 C# 客户端连接 Tibco EMS 下面例子简要介绍 C# 客户端怎样使用 TIBCO.EMS.dll 来连接 EMS 服务器. using System; using System.Diagn ...

  9. 问答项目---登陆也要做验证！（JS和PHP验证）

    简单JS示例: var login = $( 'form[name=login]' ); login.submit( function () { if (validate.loginAccount & ...

  10. Linux（Centos）下搭建SVN服务器

    鉴于在搭建时,参考网上很多资料,网上资料在有用的同时,也坑了很多人,本文的目的,也就是想让后继之人在搭建svn服务器时不再犯错,不再被网上漫天的坑爹作品所坑害,故此总结! /******开始***** ...