【MongoDB for Java】Java操作MongoDB

最新推荐文章于 2018-01-28 14:40:48 发布
最新推荐文章于 2018-01-28 14:40:48 发布
阅读量608 收藏
点赞数
分类专栏： JavaWeb

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，目录如下：

clip_image002

 
二、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 plain copy
  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 plain copy
  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

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







今晚打酱油8
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mongodb安装配置及java操作mongodb
07-02
mongodb安装配置及java操作mongodb 三个word文档和一个Jar包，记录了使用说明
java连接MongoDB的方法（包括java和MongoDB环境的搭建）
maochencw的专栏
02-11 2万+
首先在官网官网：http://www.mongodb.org/下载最新的mongodb。 在硬盘中新建一个名为mongodb的文件夹，我的位置是 d:\mongodb。在该文件夹中新建名为data和logs的文件夹，分别存放数据库数据和日志。 将下载好的文件解压，复制bin文件夹中的所有文件到之前新建的文件夹mongodb中。在cmd中分别输入命令： D: cd mongodb mon
MongoDB Java使用指南
热门推荐
Leo的博客
09-02 4万+
MongoDB是当今非常流行的一款NoSQL数据库，本文介绍如何使用MongoDB的Java驱动来操作MongoDB。 引入MongoDB Java Driver包如果需要操作MongoDB的Java项目是一个Maven项目，可以在依赖中加上以下的配置。<dependencies> <dependency> <groupId>org.mongodb</groupId>
MongoDB 安装及 java使用案例
whp404的博客
01-28 1022
MongoDB 的安装使用案例 ，及java使用MongoDB驱动的案例
MongDB java 操作
简单-生活
12-04 943
主要注意操作mongo-java-driver包的版本，个人以为应该也要注意安装安mongoDB数据的版本，最好能相对应比较好！用记录ID号更新信息不能是UpdateResult updateResult = collection.replaceOne(new BasicDBObject("_id", "58438f325967e41d208f5901"), new Docume
【MongoDB for Java】Java操作MongoDB数据库
09-01
本篇文章现在我们就用Java来操作MongoDB的数据。小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
MongoDB for Java Developers
06-12
MongoDB for Java Developers Design, build, and deliver efficient Java applications using the most advanced NoSQL database
java操作mongoDB查询的实例详解
12-16
java操作mongo查询的实例详解 前言：  MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。  MongoDB是一个介于关系数据库和非关系数据库之间的产品，...
Java操作MongoDB数据库方法详解
08-28
本文给大家分享的是使用Java操作MongoDB的一些基本方法，包含多种数据库的连接方式，增删改查等方法，非常的实用，有需要的小伙伴可以参考下
mongodb安装、启动及java操作
凌云之陟
05-31 620
最近项目中用到MongoDB 简单的研究了一下 ，还是很简单的，mongoDB是nosql中的佼佼者，被广泛应用的一种非关系型的数据库。1，mongodb的下载安装，csdn中随便搜索mongodb的资源，一堆，没有的可以加群255453635 加群备注CSDN下载mongodb的资源和java中使用mongodb的驱动程序以及mongodb实战等pdf书籍。2，解压mongodb.zip到任意
Mongodb的安装以及Java连接Mongodb初探
天道酬勤
10-24 4301
一、MongoDB的下载与安装         文件名：mongodb-linux-x86_64-2.4.7.tgz         下载地址：http://pan.baidu.com/s/1kT5tu         系统环境：Centos-6.3         解压：tar -zvxf mongodb-linux-x86_64-2.4.7.tgz , 里面最重要的就是bin目录，
Java-GUI介绍和使用
最新发布
04-18
GUI API包含的类分为三个部分:组件类(component class) 容器类(container class),和辅助类(helper class) 1. 组件类是用来创建用户图形界面的,例如JButton,JLabel,JTextField. 2. 容器类是用来包含其他组件的,例如JFrame,JPanel 3. 辅助类是用来支持GUI组件的,例如Color,Font
汉诺塔c语言递归.zip
04-18
汉诺塔c语言递归
mybatis-plus-core-3.0.6.jar
04-18
mybatis-plus-core.jar 各个版本，免费下载， mybatis-plus-core.jar 是 MyBatis 的增强工具核心包。免费下载 。 MyBatis-Plus(简称 MP)，是一个 MyBatis 的增强工具包，只做增强不做改变，为简化开发工作、提高生产率而生。
mybatis-plus-generator-3.4.0.jar
04-18
mybatis-plus-generato.jar 包，各个版本，免费下载。 mybatis-plus 代码生成器生成代码框架。各个版本，免费下载。 下载不了，关注我，评论区联系我。
2023年纺织行业分析.pptx
04-18
行业研究
知识领域: 网络安全 技术关键词: 漏洞分析、渗透测试、加密算法 内容关键词: 攻击防范、身份验证、网络流量分析
04-18
stm32项目知识领域: 网络安全 技术关键词: 漏洞分析、渗透测试、加密算法 内容关键词: 攻击防范、身份验证、网络流量分析 用途: 学习保护信息系统免受恶意攻击和数据泄露 资源描述: "OWASP官方网站"提供了全面的网络安全知识和工具，包括常见漏洞、安全指南和最佳实践。
mybatis-plus-core-2.3.3.jar
04-18
mybatis-plus-core.jar 各个版本，免费下载， mybatis-plus-core.jar 是 MyBatis 的增强工具核心包。免费下载 。 MyBatis-Plus(简称 MP)，是一个 MyBatis 的增强工具包，只做增强不做改变，为简化开发工作、提高生产率而生。
测试YUV图像数据的具体格式(1).zip
04-18
测试YUV图像数据的具体格式(1).zip
java操作mongodb
05-05
要操作 MongoDB 数据库，你需要使用 MongoDB 的 Java 驱动程序。以下是一些简单的步骤： 1. 下载 MongoDB 的 Java 驱动程序。 2. 添加驱动程序到你的 Java 项目中。 3. 连接到 MongoDB 数据库。可以使用以下代码： ``` MongoClient mongoClient = new MongoClient("localhost", 27017); MongoDatabase database = mongoClient.getDatabase("mydb"); ``` 这将连接到本地 MongoDB 数据库，并打开名为 "mydb" 的数据库。 4. 插入数据。可以使用以下代码： ``` MongoCollection<Document> collection = database.getCollection("mycollection"); Document doc = new Document("name", "John Doe") .append("age", 30) .append("email", "[email protected]"); collection.insertOne(doc); ``` 这将在名为 "mycollection" 的集合中插入一个名为 "John Doe" 的文档。 5. 查询数据。可以使用以下代码： ``` MongoCollection<Document> collection = database.getCollection("mycollection"); Document query = new Document("name", "John Doe"); MongoCursor<Document> cursor = collection.find(query).iterator(); while (cursor.hasNext()) { Document doc = cursor.next(); System.out.println(doc.toJson()); } ``` 这将查询名为 "John Doe" 的文档，并将它们打印到控制台上。 以上是一些简单的操作 MongoDB 的代码示例，你可以根据自己的需求进行修改和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值