MongoDB在java中的使用

在一年前就开始在项目中使用Mongodb作为爬虫（crawler）待下载URL、下载成功URL等的存储库，最近对项目进行版本更新，根据Mongodb的最近升级情况，也对项目中的Mongodb进行了相关的调整。

主要的调整在于2.10.0版本中引入了MongoClient类，同时在其API中也说明了Mongo类会在将来的版本中被MongoClient替换（Note: This class has been superseded by MongoClient, and may be deprecated in a future release.）。故在这次调整中，也对原先的Mongodb部分做了相应的修改。

MongoClient被设计成线程安全、可以被多线程共享的。通常访问数据库集群的应用只需要一个实例，所以这次调整我们设计成单例形式。如果出于某些原因，你决定使用多个实例，请注意：所有资源使用限制（最大连接数等等）对每个MongoClient都适用；销毁一个实例时，请确认调用MongoClient.close()方法来清理资源。

下面给出相关的代码：

接口类

 

[java] view plaincopy
 
  1. /** 
  2.   * 项目名：SpiderCrawler 
  3.   * 文件名：MongoDBDao.java 
  4.   * 作者：zhouyh 
  5.   * 时间：2014-8-30 下午03:46:55 
  6.   * 描述：TODO(用一句话描述该文件做什么)  
  7.   */  
  8. package com.newsTest.dao;  
  9.   
  10. import java.util.ArrayList;  
  11.   
  12. import com.mongodb.DB;  
  13. import com.mongodb.DBCollection;  
  14. import com.mongodb.DBObject;  
  15.   
  16. /** 
  17.  * 类名： MongoDBDao 
  18.  * 包名： com.newsTest.dao 
  19.  * 作者： zhouyh 
  20.  * 时间： 2014-8-30 下午03:46:55 
  21.  * 描述： TODO(这里用一句话描述这个类的作用)  
  22.  */  
  23. public interface MongoDBDao {  
  24.     /** 
  25.      *  
  26.      * 方法名：getDb 
  27.      * 作者：zhouyh 
  28.      * 创建时间：2014-8-30 下午03:53:40 
  29.      * 描述：获取指定的mongodb数据库 
  30.      * @param dbName 
  31.      * @return 
  32.      */  
  33.     public DB getDb(String dbName);  
  34.     /** 
  35.      *  
  36.      * 方法名：getCollection 
  37.      * 作者：zhouyh 
  38.      * 创建时间：2014-8-30 下午03:54:43 
  39.      * 描述：获取指定mongodb数据库的collection集合 
  40.      * @param dbName    数据库名 
  41.      * @param collectionName    数据库集合 
  42.      * @return 
  43.      */  
  44.     public DBCollection getCollection(String dbName, String collectionName);  
  45.     /** 
  46.      *  
  47.      * 方法名：inSert 
  48.      * 作者：zhouyh 
  49.      * 创建时间：2014-8-30 下午04:07:35 
  50.      * 描述：向指定的数据库中添加给定的keys和相应的values 
  51.      * @param dbName 
  52.      * @param collectionName 
  53.      * @param keys 
  54.      * @param values 
  55.      * @return 
  56.      */  
  57.     public boolean inSert(String dbName, String collectionName, String[] keys, Object[] values);  
  58.     /** 
  59.      *  
  60.      * 方法名：delete 
  61.      * 作者：zhouyh 
  62.      * 创建时间：2014-8-30 下午04:09:00 
  63.      * 描述：删除数据库dbName中，指定keys和相应values的值 
  64.      * @param dbName 
  65.      * @param collectionName 
  66.      * @param keys 
  67.      * @param values 
  68.      * @return 
  69.      */  
  70.     public boolean delete(String dbName, String collectionName, String[] keys, Object[] values);  
  71.     /** 
  72.      *  
  73.      * 方法名：find 
  74.      * 作者：zhouyh 
  75.      * 创建时间：2014-8-30 下午04:11:11 
  76.      * 描述：从数据库dbName中查找指定keys和相应values的值 
  77.      * @param dbName 
  78.      * @param collectionName 
  79.      * @param keys 
  80.      * @param values 
  81.      * @param num 
  82.      * @return 
  83.      */  
  84.     public ArrayList<DBObject> find(String dbName, String collectionName, String[] keys, Object[] values, int num);  
  85.     /** 
  86.      *  
  87.      * 方法名：update 
  88.      * 作者：zhouyh 
  89.      * 创建时间：2014-8-30 下午04:17:54 
  90.      * 描述：更新数据库dbName，用指定的newValue更新oldValue 
  91.      * @param dbName 
  92.      * @param collectionName 
  93.      * @param oldValue 
  94.      * @param newValue 
  95.      * @return 
  96.      */  
  97.     public boolean update(String dbName, String collectionName, DBObject oldValue, DBObject newValue);  
  98.     /** 
  99.      *  
  100.      * 方法名：isExit 
  101.      * 作者：zhouyh 
  102.      * 创建时间：2014-8-30 下午04:19:21 
  103.      * 描述：判断给定的keys和相应的values在指定的dbName的collectionName集合中是否存在 
  104.      * @param dbName 
  105.      * @param collectionName 
  106.      * @param keys 
  107.      * @param values 
  108.      * @return 
  109.      */  
  110.     public boolean isExit(String dbName, String collectionName, String key, Object value);  
  111.       
  112. }  

接口实现类：

 

 

[java] view plaincopy
 
  1. /** 
  2.   * 项目名：SpiderCrawler 
  3.   * 文件名：MongoDBDaoImpl.java 
  4.   * 作者：zhouyh 
  5.   * 时间：2014-8-30 下午04:21:11 
  6.   * 描述：TODO(用一句话描述该文件做什么)  
  7.   */  
  8. package com.newsTest.dao.impl;  
  9.   
  10. import java.net.UnknownHostException;  
  11. import java.util.ArrayList;  
  12.   
  13. import com.newsTest.dao.MongoDBDao;  
  14. import com.mongodb.BasicDBObject;  
  15. import com.mongodb.DB;  
  16. import com.mongodb.DBCollection;  
  17. import com.mongodb.DBCursor;  
  18. import com.mongodb.DBObject;  
  19. import com.mongodb.MongoClient;  
  20. import com.mongodb.MongoClientOptions;  
  21. import com.mongodb.MongoException;  
  22. import com.mongodb.WriteResult;  
  23.   
  24. /** 
  25.  * 类名： MongoDBDaoImpl 
  26.  * 包名： com.newsTest.dao.impl 
  27.  * 作者： zhouyh 
  28.  * 时间： 2014-8-30 下午04:21:11 
  29.  * 描述： TODO(这里用一句话描述这个类的作用)  
  30.  */  
  31. public class MongoDBDaoImpl implements MongoDBDao{  
  32.       
  33.     /** 
  34.      * MongoClient的实例代表数据库连接池，是线程安全的，可以被多线程共享，客户端在多线程条件下仅维持一个实例即可 
  35.      * Mongo是非线程安全的，目前mongodb API中已经建议用MongoClient替代Mongo 
  36.      */  
  37.     private MongoClient mongoClient = null;  
  38.     /** 
  39.      *  
  40.      * 私有的构造函数 
  41.      * 作者：zhouyh 
  42.      */  
  43.     private MongoDBDaoImpl(){  
  44.         if(mongoClient == null){  
  45.             MongoClientOptions.Builder build = new MongoClientOptions.Builder();          
  46.             build.connectionsPerHost(50);   //与目标数据库能够建立的最大connection数量为50  
  47.             build.autoConnectRetry(true);   //自动重连数据库启动  
  48.             build.threadsAllowedToBlockForConnectionMultiplier(50); //如果当前所有的connection都在使用中，则每个connection上可以有50个线程排队等待  
  49.             /* 
  50.              * 一个线程访问数据库的时候，在成功获取到一个可用数据库连接之前的最长等待时间为2分钟 
  51.              * 这里比较危险，如果超过maxWaitTime都没有获取到这个连接的话，该线程就会抛出Exception 
  52.              * 故这里设置的maxWaitTime应该足够大，以免由于排队线程过多造成的数据库访问失败 
  53.              */  
  54.             build.maxWaitTime(1000*60*2);  
  55.             build.connectTimeout(1000*60*1);    //与数据库建立连接的timeout设置为1分钟  
  56.               
  57.             MongoClientOptions myOptions = build.build();         
  58.             try {  
  59.                 //数据库连接实例  
  60.                 mongoClient = new MongoClient("127.0.0.1", myOptions);            
  61.             } catch (UnknownHostException e) {  
  62.                 // TODO 这里写异常处理的代码  
  63.                 e.printStackTrace();  
  64.             } catch (MongoException e){  
  65.                 e.printStackTrace();  
  66.             }  
  67.               
  68.         }  
  69.     }  
  70.       
  71.     /********单例模式声明开始，采用饿汉式方式生成，保证线程安全********************/  
  72.       
  73.     //类初始化时，自行实例化，饿汉式单例模式  
  74.     private static final MongoDBDaoImpl mongoDBDaoImpl = new MongoDBDaoImpl();  
  75.     /** 
  76.      *  
  77.      * 方法名：getMongoDBDaoImplInstance 
  78.      * 作者：zhouyh 
  79.      * 创建时间：2014-8-30 下午04:29:26 
  80.      * 描述：单例的静态工厂方法 
  81.      * @return 
  82.      */  
  83.     public static MongoDBDaoImpl getMongoDBDaoImplInstance(){  
  84.         return mongoDBDaoImpl;  
  85.     }  
  86.       
  87.     /************************单例模式声明结束*************************************/  
  88.       
  89.     @Override  
  90.     public boolean delete(String dbName, String collectionName, String[] keys,  
  91.             Object[] values) {  
  92.         DB db = null;  
  93.         DBCollection dbCollection = null;  
  94.         if(keys!=null && values!=null){  
  95.             if(keys.length != values.length){   //如果keys和values不对等，直接返回false  
  96.                 return false;  
  97.             }else{  
  98.                 try {  
  99.                     db = mongoClient.getDB(dbName); //获取指定的数据库  
  100.                     dbCollection = db.getCollection(collectionName);    //获取指定的collectionName集合  
  101.                       
  102.                     BasicDBObject doc = new BasicDBObject();    //构建删除条件  
  103.                     WriteResult result = null;  //删除返回结果  
  104.                     String resultString = null;  
  105.                       
  106.                     for(int i=0; i<keys.length; i++){  
  107.                         doc.put(keys[i], values[i]);    //添加删除的条件  
  108.                     }  
  109.                     result = dbCollection.remove(doc);  //执行删除操作  
  110.                       
  111.                     resultString = result.getError();  
  112.                       
  113.                     if(null != db){  
  114.                         try {  
  115.                             db.requestDone();   //请求结束后关闭db  
  116.                             db = null;  
  117.                         } catch (Exception e) {  
  118.                             // TODO: handle exception  
  119.                             e.printStackTrace();  
  120.                         }  
  121.                           
  122.                     }  
  123.                       
  124.                     return (resultString!=null) ? false : true; //根据删除执行结果进行判断后返回结果  
  125.                 } catch (Exception e) {  
  126.                     // TODO: handle exception  
  127.                     e.printStackTrace();  
  128.                 } finally{  
  129.                     if(null != db){  
  130.                         db.requestDone();   //关闭db  
  131.                         db = null;  
  132.                     }  
  133.                 }  
  134.                   
  135.             }  
  136.         }  
  137.         return false;  
  138.     }  
  139.   
  140.     @Override  
  141.     public ArrayList<DBObject> find(String dbName, String collectionName,  
  142.             String[] keys, Object[] values, int num) {  
  143.         ArrayList<DBObject> resultList = new ArrayList<DBObject>(); //创建返回的结果集  
  144.         DB db = null;  
  145.         DBCollection dbCollection = null;  
  146.         DBCursor cursor = null;  
  147.         if(keys!=null && values!=null){  
  148.             if(keys.length != values.length){  
  149.                 return resultList;  //如果传来的查询参数对不对，直接返回空的结果集  
  150.             }else{  
  151.                 try {  
  152.                     db = mongoClient.getDB(dbName); //获取数据库实例  
  153.                     dbCollection = db.getCollection(collectionName);    //获取数据库中指定的collection集合  
  154.                       
  155.                     BasicDBObject queryObj = new BasicDBObject();   //构建查询条件  
  156.                       
  157.                     for(int i=0; i<keys.length; i++){    //填充查询条件  
  158.                         queryObj.put(keys[i], values[i]);  
  159.                     }                 
  160.                     cursor = dbCollection.find(queryObj);   //查询获取数据  
  161.                     int count = 0;  
  162.                     if(num != -1){  //判断是否是返回全部数据，num=-1返回查询全部数据，num!=-1则返回指定的num数据  
  163.                         while(count<num && cursor.hasNext()){  
  164.                             resultList.add(cursor.next());  
  165.                             count++;  
  166.                         }  
  167.                         return resultList;  
  168.                     }else{  
  169.                         while(cursor.hasNext()){  
  170.                             resultList.add(cursor.next());  
  171.                         }  
  172.                         return resultList;  
  173.                     }  
  174.                 } catch (Exception e) {  
  175.                     // TODO: handle exception  
  176.                 } finally{                
  177.                     if(null != cursor){  
  178.                         cursor.close();  
  179.                     }  
  180.                     if(null != db){  
  181.                         db.requestDone();   //关闭数据库请求  
  182.                     }  
  183.                 }  
  184.             }  
  185.         }  
  186.   
  187.         return resultList;  
  188.     }  
  189.   
  190.     @Override  
  191.     public DBCollection getCollection(String dbName, String collectionName) {  
  192.         // TODO Auto-generated method stub  
  193.         return mongoClient.getDB(dbName).getCollection(collectionName);  
  194.     }  
  195.   
  196.     @Override  
  197.     public DB getDb(String dbName) {  
  198.         // TODO Auto-generated method stub  
  199.         return mongoClient.getDB(dbName);  
  200.     }  
  201.   
  202.     @Override  
  203.     public boolean inSert(String dbName, String collectionName, String[] keys,  
  204.             Object[] values) {  
  205.         DB db = null;  
  206.         DBCollection dbCollection = null;  
  207.         WriteResult result = null;  
  208.         String resultString = null;  
  209.         if(keys!=null && values!=null){  
  210.             if(keys.length != values.length){  
  211.                 return false;  
  212.             }else{  
  213.                 db = mongoClient.getDB(dbName); //获取数据库实例  
  214.                 dbCollection = db.getCollection(collectionName);    //获取数据库中指定的collection集合  
  215.                 BasicDBObject insertObj = new BasicDBObject();  
  216.                 for(int i=0; i<keys.length; i++){    //构建添加条件  
  217.                     insertObj.put(keys[i], values[i]);  
  218.                 }  
  219.                   
  220.                 try {  
  221.                     result = dbCollection.insert(insertObj);  
  222.                     resultString = result.getError();  
  223.                 } catch (Exception e) {  
  224.                     // TODO: handle exception  
  225.                     e.printStackTrace();  
  226.                 }finally{  
  227.                     if(null != db){  
  228.                         db.requestDone();   //请求结束后关闭db  
  229.                     }  
  230.                 }                 
  231.                 return (resultString != null) ? false : true;  
  232.             }  
  233.         }  
  234.         return false;  
  235.     }  
  236.   
  237.     @Override  
  238.     public boolean isExit(String dbName, String collectionName, String key,  
  239.             Object value) {  
  240.         // TODO Auto-generated method stub  
  241.         DB db = null;  
  242.         DBCollection dbCollection = null;  
  243.         if(key!=null && value!=null){  
  244.             try {  
  245.                 db = mongoClient.getDB(dbName); //获取数据库实例  
  246.                 dbCollection = db.getCollection(collectionName);    //获取数据库中指定的collection集合  
  247.                 BasicDBObject obj = new BasicDBObject();    //构建查询条件  
  248.                 obj.put(key, value);  
  249.                   
  250.                 if(dbCollection.count(obj) > 0) {  
  251.                     return true;  
  252.                 }else{  
  253.                     return false;  
  254.                 }  
  255.             } catch (Exception e) {  
  256.                 // TODO: handle exception  
  257.                 e.printStackTrace();  
  258.             } finally{  
  259.                 if(null != db){  
  260.                     db.requestDone();   //关闭db  
  261.                     db = null;  
  262.                 }  
  263.             }  
  264.               
  265.         }  
  266.         return false;  
  267.     }  
  268.   
  269.     @Override  
  270.     public boolean update(String dbName, String collectionName,  
  271.             DBObject oldValue, DBObject newValue) {  
  272.         DB db = null;  
  273.         DBCollection dbCollection = null;  
  274.         WriteResult result = null;  
  275.         String resultString = null;  
  276.           
  277.         if(oldValue.equals(newValue)){  
  278.             return true;  
  279.         }else{  
  280.             try {  
  281.                 db = mongoClient.getDB(dbName); //获取数据库实例  
  282.                 dbCollection = db.getCollection(collectionName);    //获取数据库中指定的collection集合  
  283.                   
  284.                 result = dbCollection.update(oldValue, newValue);  
  285.                 resultString = result.getError();  
  286.                   
  287.                 return (resultString!=null) ? false : true;  
  288.             } catch (Exception e) {  
  289.                 // TODO: handle exception  
  290.                 e.printStackTrace();  
  291.             } finally{  
  292.                 if(null != db){  
  293.                     db.requestDone();   //关闭db  
  294.                     db = null;  
  295.                 }  
  296.             }  
  297.               
  298.         }  
  299.           
  300.         return false;  
  301.     }  
  302.       
  303.     /** 
  304.      * 方法名：main 
  305.      * 作者：zhouyh 
  306.      * 创建时间：2014-8-30 下午04:21:11 
  307.      * 描述：TODO(这里用一句话描述这个方法的作用) 
  308.      * @param args 
  309.      */  
  310.     public static void main(String[] args) {  
  311.         // TODO Auto-generated method stub  
  312.           
  313.     }  
  314.       
  315. }  


这里使用的mongodb的java驱动版本是2.11.4，相关的驱动版本可以从这里下载mongodb java驱动，也可以查看相关的mongodb的api

posted @ 2015-12-28 12:32  java高级技术汇  阅读(675)  评论(0)  编辑  收藏  举报