【MongoDB for Java】Java操作MongoDB，

http://www.cnblogs.com/hoojo/archive/2011/06/02/2068665.html

【MongoDB for Java】Java操作MongoDB

上一篇文章: http://www.cnblogs.com/hoojo/archive/2011/06/01/2066426.html介绍到了在MongoDB的控制台完成MongoDB的数据操作，通过前一篇文章我们对MongoDB有了全面的认识和理解。现在我们就用Java来操作MongoDB的数据。

 

开发环境：

System：Windows

IDE：eclipse、MyEclipse 8

Database：mongoDB

开发依赖库：

JavaEE5、mongo-2.5.3.jar、junit-4.8.2.jar

Email：hoojo_@126.com

Blog：http://blog.csdn.net/IBM_hoojo

http://hoojo.cnblogs.com/

 

一、准备工作

1、 首先，下载mongoDB对Java支持的驱动包

驱动包下载地址：https://github.com/mongodb/mongo-java-driver/downloads

mongoDB对Java的相关支持、技术：http://www.mongodb.org/display/DOCS/Java+Language+Center

驱动源码下载：https://download.github.com/mongodb-mongo-java-driver-r2.6.1-7-g6037357.zip

在线查看源码：https://github.com/mongodb/mongo-java-driver

2、 下面建立一个JavaProject工程，导入下载下来的驱动包。即可在Java中使用mongoDB，目录如下：

 

二、Java操作MongoDB示例

在本示例之前你需要启动mongod.exe的服务，启动后，下面的程序才能顺利执行；

 

1、 建立SimpleTest.java，完成简单的mongoDB数据库操作

Mongo mongo = new Mongo();

这样就创建了一个MongoDB的数据库连接对象，它默认连接到当前机器的localhost地址，端口是27017。

DB db = mongo.getDB(“test”);

这样就获得了一个test的数据库，如果mongoDB中没有创建这个数据库也是可以正常运行的。如果你读过上一篇文章就知道，mongoDB可以在没有创建这个数据库的情况下，完成数据的添加操作。当添加的时候，没有这个库，mongoDB会自动创建当前数据库。

得到了db，下一步我们要获取一个“聚集集合DBCollection”，通过db对象的getCollection方法来完成。

DBCollection users = db.getCollection("users");

这样就获得了一个DBCollection，它相当于我们数据库的“表”。

查询所有数据

DBCursor cur = users.find();

while (cur.hasNext()) {

System.out.println(cur.next());

}

 

完整源码

package com.hoo.test;

import java.net.UnknownHostException;

import com.mongodb.DB;

import com.mongodb.DBCollection;

import com.mongodb.DBCursor;

import com.mongodb.Mongo;

import com.mongodb.MongoException;

import com.mongodb.util.JSON;

/**

 * <b>function:</b>MongoDB 简单示例

 * @author hoojo

 * @createDate 2011-5-24 下午02:42:29

 * @file SimpleTest.java

 * @package com.hoo.test

 * @project MongoDB

 * @blog http://blog.csdn.net/IBM_hoojo

 * @email hoojo_@126.com

 * @version 1.0

 */

public class SimpleTest {

    public static void main(String[] args) throws UnknownHostException, MongoException {

        Mongo mg = new Mongo();

        //查询所有的Database

        for (String name : mg.getDatabaseNames()) {

            System.out.println("dbName: " + name);

        }

        DB db = mg.getDB("test");

        //查询所有的聚集集合

        for (String name : db.getCollectionNames()) {

            System.out.println("collectionName: " + name);

        }

        DBCollection users = db.getCollection("users");

        //查询所有的数据

        DBCursor cur = users.find();

        while (cur.hasNext()) {

            System.out.println(cur.next());

        }

        System.out.println(cur.count());

        System.out.println(cur.getCursorId());

        System.out.println(JSON.serialize(cur));

    }

}

 

2、 完成CRUD操作，首先建立一个MongoDB4CRUDTest.java，基本测试代码如下：

package com.hoo.test;

import java.net.UnknownHostException;

import java.util.ArrayList;

import java.util.List;

import org.bson.types.ObjectId;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import com.mongodb.BasicDBObject;

import com.mongodb.Bytes;

import com.mongodb.DB;

import com.mongodb.DBCollection;

import com.mongodb.DBCursor;

import com.mongodb.DBObject;

import com.mongodb.Mongo;

import com.mongodb.MongoException;

import com.mongodb.QueryOperators;

import com.mongodb.util.JSON;

/**

 * <b>function:</b>实现MongoDB的CRUD操作

 * @author hoojo

 * @createDate 2011-6-2 下午03:21:23

 * @file MongoDB4CRUDTest.java

 * @package com.hoo.test

 * @project MongoDB

 * @blog http://blog.csdn.net/IBM_hoojo

 * @email hoojo_@126.com

 * @version 1.0

 */

public class MongoDB4CRUDTest {

    private Mongo mg = null;

    private DB db;

    private DBCollection users;

    @Before

    public void init() {

        try {

            mg = new Mongo();

            //mg = new Mongo("localhost", 27017);

        } catch (UnknownHostException e) {

            e.printStackTrace();

        } catch (MongoException e) {

            e.printStackTrace();

        }

        //获取temp DB；如果默认没有创建，mongodb会自动创建

        db = mg.getDB("temp");

        //获取users DBCollection；如果默认没有创建，mongodb会自动创建

        users = db.getCollection("users");

    }

    @After

    public void destory() {

        if (mg != null)

            mg.close();

        mg = null;

        db = null;

        users = null;

        System.gc();

    }

    public void print(Object o) {

        System.out.println(o);

    }

}

 

3、 添加操作

在添加操作之前，我们需要写个查询方法，来查询所有的数据。代码如下：

/**

 * <b>function:</b> 查询所有数据

 * @author hoojo

 * @createDate 2011-6-2 下午03:22:40

 */

private void queryAll() {

    print("查询users的所有数据：");

    //db游标

    DBCursor cur = users.find();

    while (cur.hasNext()) {

        print(cur.next());

    }

}

@Test

public void add() {

    //先查询所有数据

    queryAll();

    print("count: " + users.count());

    DBObject user = new BasicDBObject();

    user.put("name", "hoojo");

    user.put("age", 24);

    //users.save(user)保存，getN()获取影响行数

    //print(users.save(user).getN());

    //扩展字段，随意添加字段，不影响现有数据

    user.put("sex", "男");

    print(users.save(user).getN());

    //添加多条数据，传递Array对象

    print(users.insert(user, new BasicDBObject("name", "tom")).getN());

    //添加List集合

    List<DBObject> list = new ArrayList<DBObject>();

    list.add(user);

    DBObject user2 = new BasicDBObject("name", "lucy");

    user.put("age", 22);

    list.add(user2);

    //添加List集合

    print(users.insert(list).getN());

    //查询下数据，看看是否添加成功

    print("count: " + users.count());

    queryAll();

}

 

4、 删除数据

@Test

public void remove() {

    queryAll();

    print("删除id = 4de73f7acd812d61b4626a77：" + users.remove(new BasicDBObject("_id", new ObjectId("4de73f7acd812d61b4626a77"))).getN());

    print("remove age >= 24: " + users.remove(new BasicDBObject("age", new BasicDBObject("$gte", 24))).getN());

}

 

5、 修改数据

@Test

public void modify() {

    print("修改：" + users.update(new BasicDBObject("_id", new ObjectId("4dde25d06be7c53ffbd70906")), new BasicDBObject("age", 99)).getN());

    print("修改：" + users.update(

            new BasicDBObject("_id", new ObjectId("4dde2b06feb038463ff09042")), 

            new BasicDBObject("age", 121),

            true,//如果数据库不存在，是否添加

            false//多条修改

            ).getN());

    print("修改：" + users.update(

            new BasicDBObject("name", "haha"), 

            new BasicDBObject("name", "dingding"),

            true,//如果数据库不存在，是否添加

            true//false只修改第一天，true如果有多条就不修改

            ).getN());

    //当数据库不存在就不修改、不添加数据，当多条数据就不修改

    //print("修改多条：" + coll.updateMulti(new BasicDBObject("_id", new ObjectId("4dde23616be7c19df07db42c")), new BasicDBObject("name", "199")));

}

 

6、 查询数据

@Test

public void query() {

    //查询所有

    //queryAll();

    //查询id = 4de73f7acd812d61b4626a77

    print("find id = 4de73f7acd812d61b4626a77: " + users.find(new BasicDBObject("_id", new ObjectId("4de73f7acd812d61b4626a77"))).toArray());

    //查询age = 24

    print("find age = 24: " + users.find(new BasicDBObject("age", 24)).toArray());

    //查询age >= 24

    print("find age >= 24: " + users.find(new BasicDBObject("age", new BasicDBObject("$gte", 24))).toArray());

    print("find age <= 24: " + users.find(new BasicDBObject("age", new BasicDBObject("$lte", 24))).toArray());

    print("查询age!=25：" + users.find(new BasicDBObject("age", new BasicDBObject("$ne", 25))).toArray());

    print("查询age in 25/26/27：" + users.find(new BasicDBObject("age", new BasicDBObject(QueryOperators.IN, new int[] { 25, 26, 27 }))).toArray());

    print("查询age not in 25/26/27：" + users.find(new BasicDBObject("age", new BasicDBObject(QueryOperators.NIN, new int[] { 25, 26, 27 }))).toArray());

    print("查询age exists 排序：" + users.find(new BasicDBObject("age", new BasicDBObject(QueryOperators.EXISTS, true))).toArray());

    print("只查询age属性：" + users.find(null, new BasicDBObject("age", true)).toArray());

    print("只查属性：" + users.find(null, new BasicDBObject("age", true), 0, 2).toArray());

    print("只查属性：" + users.find(null, new BasicDBObject("age", true), 0, 2, Bytes.QUERYOPTION_NOTIMEOUT).toArray());

    //只查询一条数据，多条去第一条

    print("findOne: " + users.findOne());

    print("findOne: " + users.findOne(new BasicDBObject("age", 26)));

    print("findOne: " + users.findOne(new BasicDBObject("age", 26), new BasicDBObject("name", true)));

    //查询修改、删除

    print("findAndRemove 查询age=25的数据，并且删除: " + users.findAndRemove(new BasicDBObject("age", 25)));

    //查询age=26的数据，并且修改name的值为Abc

    print("findAndModify: " + users.findAndModify(new BasicDBObject("age", 26), new BasicDBObject("name", "Abc")));

    print("findAndModify: " + users.findAndModify(

        new BasicDBObject("age", 28), //查询age=28的数据

        new BasicDBObject("name", true), //查询name属性

        new BasicDBObject("age", true), //按照age排序

        false, //是否删除，true表示删除

        new BasicDBObject("name", "Abc"), //修改的值，将name修改成Abc

        true, 

        true));

    queryAll();

}

mongoDB不支持联合查询、子查询，这需要我们自己在程序中完成。将查询的结果集在Java查询中进行需要的过滤即可。

 

7、 其他操作

public void testOthers() {

    DBObject user = new BasicDBObject();

    user.put("name", "hoojo");

    user.put("age", 24);

    //JSON 对象转换        

    print("serialize: " + JSON.serialize(user));

    //反序列化

    print("parse: " + JSON.parse("{ \"name\" : \"hoojo\" , \"age\" : 24}"));

    print("判断temp Collection是否存在: " + db.collectionExists("temp"));

    //如果不存在就创建

    if (!db.collectionExists("temp")) {

        DBObject options = new BasicDBObject();

        options.put("size", 20);

        options.put("capped", 20);

        options.put("max", 20);

        print(db.createCollection("account", options));

    }

    //设置db为只读

    db.setReadOnly(true);

    //只读不能写入数据

    db.getCollection("test").save(user);

}

好了，这里基本上就介绍这么多Java操作MongoDB的方法。其他的东西还需要你自己多多研究。上面操作MongoDB的方法都是一些常用的方法，比较简单。如果有什么问题，可以给我留言或是发Email:hoojo_@126.com

版权所有，转载请注明出处 本文出自： 
版权所有，欢迎转载，转载请注明出处，谢谢

--------------------------------------------

在一年前就开始在项目中使用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

版权声明：本文为博主原创文章，未经博主允许不得转载。