Java单例模式下的MongoDB数据库操作工具类

本文实例讲述了java单例模式下的mongodb数据库操作工具类。分享给大家供大家参考，具体如下：

我经常对mongodb进行一些基础操作，将这些常用操作合并到一个工具类中，方便自己开发使用。

没用spring data、morphia等框架是为了减少学习、维护成本，另外自己直接jdbc方式的话可以更灵活，为自己以后的积累留一个脚印。

java驱动版本：

<!-- mongodb驱动 -->
<dependency>
  <groupid>org.mongodb</groupid>
  <artifactid>mongo-java-driver</artifactid>
  <version>3.0.2</version>
</dependency>

工具类代码如下：

package utils;
import java.util.arraylist;
import java.util.list;
import org.apache.commons.configuration.compositeconfiguration;
import org.apache.commons.configuration.configurationexception;
import org.apache.commons.configuration.propertiesconfiguration;
import org.bson.document;
import org.bson.conversions.bson;
import org.bson.types.objectid;
import com.mongodb.basicdbobject;
import com.mongodb.mongoclient;
import com.mongodb.mongoclientoptions;
import com.mongodb.mongoclientoptions.builder;
import com.mongodb.writeconcern;
import com.mongodb.client.mongocollection;
import com.mongodb.client.mongocursor;
import com.mongodb.client.mongodatabase;
import com.mongodb.client.mongoiterable;
import com.mongodb.client.model.filters;
import com.mongodb.client.result.deleteresult;
/**
 * mongodb工具类 mongo实例代表了一个数据库连接池，即使在多线程的环境中，一个mongo实例对我们来说已经足够了<br>
 * 注意mongo已经实现了连接池，并且是线程安全的。 <br>
 * 设计为单例模式， 因 mongodb的java驱动是线程安全的，对于一般的应用，只要一个mongo实例即可，<br>
 * mongo有个内置的连接池（默认为10个） 对于有大量写和读的环境中，为了确保在一个session中使用同一个db时，<br>
 * db和dbcollection是绝对线程安全的<br>
 *
 * @author zhoulingfei
 * @date 2015-5-29 上午11:49:49
 * @version 0.0.0
 * @copyright (c)1997-2015 navinfo co.ltd. all rights reserved.
 */
public enum mongodbutil {
  /**
   * 定义一个枚举的元素，它代表此类的一个实例
   */
  instance;
  private mongoclient mongoclient;
  static {
    system.out.println("===============mongodbutil初始化========================");
    compositeconfiguration config = new compositeconfiguration();
    try {
      config.addconfiguration(new propertiesconfiguration("mongodb.properties"));
    } catch (configurationexception e) {
      e.printstacktrace();
    }
    // 从配置文件中获取属性值
    string ip = config.getstring("host");
    int port = config.getint("port");
    instance.mongoclient = new mongoclient(ip, port);
    // or, to connect to a replica set, with auto-discovery of the primary, supply a seed list of members
    // list<serveraddress> listhost = arrays.aslist(new serveraddress("localhost", 27017),new serveraddress("localhost", 27018));
    // instance.mongoclient = new mongoclient(listhost);
    // 大部分用户使用mongodb都在安全内网下，但如果将mongodb设为安全验证模式，就需要在客户端提供用户名和密码：
    // boolean auth = db.authenticate(myusername, mypassword);
    builder options = new mongoclientoptions.builder();
    // options.autoconnectretry(true);// 自动重连true
    // options.maxautoconnectretrytime(10); // the maximum auto connect retry time
    options.connectionsperhost(300);// 连接池设置为300个连接,默认为100
    options.connecttimeout(15000);// 连接超时，推荐>3000毫秒
    options.maxwaittime(5000); //
    options.sockettimeout(0);// 套接字超时时间，0无限制
    options.threadsallowedtoblockforconnectionmultiplier(5000);// 线程队列数，如果连接线程排满了队列就会抛出“out of semaphores to get db”错误。
    options.writeconcern(writeconcern.safe);//
    options.build();
  }
  // ------------------------------------共用方法---------------------------------------------------
  /**
   * 获取db实例 - 指定db
   *
   * @param dbname
   * @return
   */
  public mongodatabase getdb(string dbname) {
    if (dbname != null && !"".equals(dbname)) {
      mongodatabase database = mongoclient.getdatabase(dbname);
      return database;
    }
    return null;
  }
  /**
   * 获取collection对象 - 指定collection
   *
   * @param collname
   * @return
   */
  public mongocollection<document> getcollection(string dbname, string collname) {
    if (null == collname || "".equals(collname)) {
      return null;
    }
    if (null == dbname || "".equals(dbname)) {
      return null;
    }
    mongocollection<document> collection = mongoclient.getdatabase(dbname).getcollection(collname);
    return collection;
  }
  /**
   * 查询db下的所有表名
   */
  public list<string> getallcollections(string dbname) {
    mongoiterable<string> colls = getdb(dbname).listcollectionnames();
    list<string> _list = new arraylist<string>();
    for (string s : colls) {
      _list.add(s);
    }
    return _list;
  }
  /**
   * 获取所有数据库名称列表
   *
   * @return
   */
  public mongoiterable<string> getalldbnames() {
    mongoiterable<string> s = mongoclient.listdatabasenames();
    return s;
  }
  /**
   * 删除一个数据库
   */
  public void dropdb(string dbname) {
    getdb(dbname).drop();
  }
  /**
   * 查找对象 - 根据主键_id
   *
   * @param collection
   * @param id
   * @return
   */
  public document findbyid(mongocollection<document> coll, string id) {
    objectid _idobj = null;
    try {
      _idobj = new objectid(id);
    } catch (exception e) {
      return null;
    }
    document mydoc = coll.find(filters.eq("_id", _idobj)).first();
    return mydoc;
  }
  /** 统计数 */
  public int getcount(mongocollection<document> coll) {
    int count = (int) coll.count();
    return count;
  }
  /** 条件查询 */
  public mongocursor<document> find(mongocollection<document> coll, bson filter) {
    return coll.find(filter).iterator();
  }
  /** 分页查询 */
  public mongocursor<document> findbypage(mongocollection<document> coll, bson filter, int pageno, int pagesize) {
    bson orderby = new basicdbobject("_id", 1);
    return coll.find(filter).sort(orderby).skip((pageno - 1) * pagesize).limit(pagesize).iterator();
  }
  /**
   * 通过id删除
   *
   * @param coll
   * @param id
   * @return
   */
  public int deletebyid(mongocollection<document> coll, string id) {
    int count = 0;
    objectid _id = null;
    try {
      _id = new objectid(id);
    } catch (exception e) {
      return 0;
    }
    bson filter = filters.eq("_id", _id);
    deleteresult deleteresult = coll.deleteone(filter);
    count = (int) deleteresult.getdeletedcount();
    return count;
  }
  /**
   * fixme
   *
   * @param coll
   * @param id
   * @param newdoc
   * @return
   */
  public document updatebyid(mongocollection<document> coll, string id, document newdoc) {
    objectid _idobj = null;
    try {
      _idobj = new objectid(id);
    } catch (exception e) {
      return null;
    }
    bson filter = filters.eq("_id", _idobj);
    // coll.replaceone(filter, newdoc); // 完全替代
    coll.updateone(filter, new document("$set", newdoc));
    return newdoc;
  }
  public void dropcollection(string dbname, string collname) {
    getdb(dbname).getcollection(collname).drop();
  }
  /**
   * 关闭mongodb
   */
  public void close() {
    if (mongoclient != null) {
      mongoclient.close();
      mongoclient = null;
    }
  }
  /**
   * 测试入口
   *
   * @param args
   */
  public static void main(string[] args) {
    string dbname = "gc_map_display_db";
    string collname = "community_bj";
    mongocollection<document> coll = mongodbutil.instance.getcollection(dbname, collname);
    // 插入多条
    // for (int i = 1; i <= 4; i++) {
    // document doc = new document();
    // doc.put("name", "zhoulf");
    // doc.put("school", "nefu" + i);
    // document interests = new document();
    // interests.put("game", "game" + i);
    // interests.put("ball", "ball" + i);
    // doc.put("interests", interests);
    // coll.insertone(doc);
    // }
    // // 根据id查询
    // string id = "556925f34711371df0ddfd4b";
    // document doc = mongodbutil2.instance.findbyid(coll, id);
    // system.out.println(doc);
    // 查询多个
    // mongocursor<document> cursor1 = coll.find(filters.eq("name", "zhoulf")).iterator();
    // while (cursor1.hasnext()) {
    // org.bson.document _doc = (document) cursor1.next();
    // system.out.println(_doc.tostring());
    // }
    // cursor1.close();
    // 查询多个
    // mongocursor<person> cursor2 = coll.find(person.class).iterator();
    // 删除数据库
    // mongodbutil2.instance.dropdb("testdb");
    // 删除表
    // mongodbutil2.instance.dropcollection(dbname, collname);
    // 修改数据
    // string id = "556949504711371c60601b5a";
    // document newdoc = new document();
    // newdoc.put("name", "时候");
    // mongodbutil.instance.updatebyid(coll, id, newdoc);
    // 统计表
    // system.out.println(mongodbutil.instance.getcount(coll));
    // 查询所有
    bson filter = filters.eq("count", 0);
    mongodbutil.instance.find(coll, filter);
  }
}

更多关于java相关内容感兴趣的读者可查看本站专题：《java使用jdbc操作数据库技巧总结》、《java+mysql数据库程序设计总结》、《java数据结构与算法教程》、《java文件与目录操作技巧汇总》、《java操作dom节点技巧总结》和《java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。