java mongdodb API增删改查操作

源代码：MongoDBTest.java

部分代码讲解：

连接数据库

代码1之数据库连接

    static{
        //连接数据库仓库
        mongo = new Mongo(HOST,PORT);
        //通过数据库仓库连接数据库仓库中的数据库：testDB
        db = mongo.getDB(DB_NAME);
    }

解释：

连接数据库仓库概述
mongo = new Mongo(HOST,PORT);

实际生活案例：当想打电话给男友时，首先需要手机有信号，信号就是有服务，可以打通电话，可以发短信。当手机卡坏掉时，无服务，此时无法打电话，无法发短信。此时手机处于无法连接状态。

同理，欲想和数据库进行操作，首先需要和数据库进行连接。而数据库连接的规则是传入HOST,PORT

通过数据库仓库连接数据库仓库中的数据库：testDB
db = mongo.getDB(DB_NAME);

实际生活案例：当手机具备连接条件时，我们就可以打电话了，此时，需要获取男友的手机号码猜可以找到男友

同理：数据库仓库中存在很多数据库，我们想要找到我们想要的数据库，通过代码实现，需要调用getDB(我们想要的数据库)方法。

总结：

通过数据库仓库mongo连接数据库db，再通过数据库db获取到操作的权限，只有dbCollection具有增删改查的权限。

代码2之连接数据表

 DBCollection dbCollection = db.getCollection("test");

实际生活案例：当我们有了男友的手机号码时还不够，最关键的是需要点击呼叫，此时电话才能打通。当我们向挂断时，就需要提供挂断的按钮

同理：当我们找到我们想要的数据库还不够，因为我们的增删改查是针对一张表的，所以我们还需要找到此表才可以进行操作。用代码实现通过：db.getCollection(表名)方法。

添加

代码3之添加对象到数据库中 insert(DBObject obj)

搜索：Java MongoDB : Insert a document

    public static void addOne1(DBCollection dbCollection){
        DBObject dbObject = new BasicDBObject("name","jolie").append("age",45).append("sex","男").append("address",
                new BasicDBObject("postCode",100000).append("street","南京西路").append("city","上海"));
        dbCollection.insert(dbObject);
    }

疑问：
1. BasicDBObject类的put方法与Map的put方法有什么关系？
2.BasicDBObject的append方法（String key, Object val）中的val参数是object类型，怎么运用？
3.BasicDBObject是什么？什么情况下需要用到？
4.dbCollection能添加的对象有哪些类型？

解答1.
BasicDBObject 与 Map是继承关系，BasicDBObject类的put方法是继承自Map的，所以put用法与Map的put方法一样。

解答2.
由于value值是object类型，所以value的类型可以是任意类型，如String,Map,List，自定义User等等。

解答3：
自我理解，BasicDBObject是mongodb中存入对象格式的规范写法。

就是说在mongodb的数据库中存的对象都是Bson结构，因为BasicDBObject继承了类BSONObject和实现了接口Bson，所以mongodb固定了对象的输出格式是Bson格式

并且每个对象都是属于BasicDBObject类的对象。

向mongodb数据库中添加对象也只能添加 BasicDBObject 类型的对象

解答4：
4.dbCollection只能添加DBObject类型的对象，或者关系是：继承自DBObject的集合。

而DBObject是接口，对象的创建只能通过实现类来创建：

<? extends DBObject>

DBObject dbObject = new BasicDBObject（）
append put是添加此对象的属性fields，如名字，age等等属性

创建对象的思路：
查看代码，在创建对象时用了三种方法
1. 有参构造函数
2. append方法
3. 参数中再次new BasicDBObject和apend的思路

代码4之添加批量对象到数据库中

 public static void addList(DBCollection dbCollection) {
        //向list中添加三个不同的对象
        List<DBObject> list = new ArrayList<DBObject>();

        //1.  添加一个对象jolie
        DBObject obj1 = new BasicDBObject("name","jolie");
        list.add(obj1);

        //2.  添加一个对象Jack，此对象的nickName有多个（思路：可以存储在list中）
        //重新给dbObject赋值，此时的dbObject引用是指向另一个BasicDBObject类型的对象，和上面创建的对象不再有关系
        obj1 = new BasicDBObject();
        obj1.put("name","jack");

        List<String> listNickName = new ArrayList<String>();
        listNickName.add("多多");
        listNickName.add("熊猫");
        listNickName.add("盼盼");
        obj1.put("nickName",listNickName);
        list.add(obj1);

        //添加一个对象Tom，指定此对象的爱好有sing  song  （思路：map/BasicDBObject和list分别指定,本例使用map实现）
        obj1 = new BasicDBObject();
        obj1.put("name","Tom");

        Map<String,List<String>> map = new HashMap<String,List<String>>();
        List<String> hobbys = new ArrayList<String>();
        hobbys.add("sing");
        hobbys.add("song");
        map.put("爱好",hobbys);
        obj1.put("hobby",map);
        list.add(obj1);

        obj1 = new BasicDBObject();
        obj1.put("name", "刘德华");
        obj1.put("age", 51);
        obj1.put("sex", "男");
        //put参数中添加的是BasicDBObject，此对象又append
        obj1.put("remark", new BasicDBObject("address", "南京西路").append("street", "888号"));
        list.add(obj1);
        dbCollection.insert(list);
    }

详解1. 查看DBCollection类添加集合类型的方法：

可以看出，只可以添加List集合，并且集合中存储的对象类型要继承自DBObject。

List list = new ArrayList();

详解2. List包含类DBObject，而类DBObject可以包含List，map
即，向List中添加的DBObject对象，DBObject对象的属性可以有list，map，或者DBObject类型。
DBObject 对应 fields
集合 对应 elements

详解3.

   //put参数中添加的是BasicDBObject，此对象又append
    obj1.put("remark", new BasicDBObject("address", "南京西路").append("street", "888号"));

Map.put(key,Val)返回值为V，

即new BasicDBObject(“address”, “南京西路”)返回值为BasicDBObject，所以可以.append(“street”, “888号”));

详解4.

        //重新给dbObject赋值，此时的dbObject引用是指向另一个BasicDBObject类型的对象，和上面创建的对象不再有关系
        obj1 = new BasicDBObject();
        obj1.put("name","jack");

当obj1 = new BasicDBObject();时，obj1引用指向新的对象，和之前创建的对象没有关系。所以此时获取之前创建的对象的属性时，是获取不到或者获取的值是新创建对象的值。

举例：

public class Test {
    public static void main(String[] args) {
        //对String进行测试
        String str = "aaa";
        str = "bbb";
        System.out.println(str);

        str = new String();
        System.out.println(str);
        System.out.println(".......");

        //对User进行测试
        User u = new User();
        u.setName("Jolie");

        u = new User();
        System.out.println(u.getName());
    }
}

运行结果：

bbb
(空行，什么也不输出)
……
null

代码5之添加json对象到数据库中

    public static void addByJson(DBCollection dbCollection) {
        String json = "{\"name\" : \"jolie\",\"age\" : 77 ,\"sex\" : \"女\"}";
        DBObject dbObject = BasicDBObject.parse(json);
        dbCollection.insert(dbObject);
    }

    public static void addByJson2(DBCollection dbCollection) {
        String json = "{\"name\" : \"test\",\"age\" : 7 ,\"sex\" : \"女\"}";
        DBObject dbObject = (DBObject) JSON.parse(json);
        dbCollection.insert(dbObject);
    }

详解5.
解析的方法名一般都是parse，所以无论是通过BasicDBObject还是Json解析，都是调用他们的parse方法

添加总结

添加一个对象：dbCollection.insert(DBObject dbObject);

添加很多对象：dbCollection.insert(List list);

查询

代码6之查询一条数据的对象（findOne）

搜索：Java MongoDB : Query document

    public static void queryOne(DBCollection dbCollection) {
        DBObject dbObject = new BasicDBObject("name", "jolie");
        dbCollection.insert(dbObject);
        DBObject result = dbCollection.findOne(dbObject);
        System.out.println(result);

详解.
mongodb通过fingOne查询一条记录的对象

代码7之分页查询对象—find().skip(x).limit(x)

    public static void queryPage(DBCollection dbCollection) {
        DBCursor cursor = dbCollection.find().skip(2).limit(3);
        DBObject obj = null;

        while (cursor.hasNext()) {
            obj = cursor.next();
            System.out.println(obj);
        }
    }

详情： 分页使用dbCollection.find().skip(2).limit(3);

代码8之范围查询对象—find(DBObject obj)

    public static void queryRange(DBCollection dbCollection) {
        addList(dbCollection);

        DBObject range = new BasicDBObject();
        range.put("$gte", 50);
        range.put("$lte", 52);

        DBObject obj = new BasicDBObject();
        obj.put("age", range);

        DBCursor dbCursor = dbCollection.find(obj);
        while (dbCursor.hasNext()) {
            System.out.println(dbCursor.next());
        }
    }

详情 使用$gte，$lte确认范围

代码9之查询所有的对象—find()

    public static void queryList(DBCollection dbCollection) {
        //addList(dbCollection);
        DBObject obj = null;

        DBCursor cursor = dbCollection.find();
        while (cursor.hasNext()) {
            obj = cursor.next();
            System.out.println(obj);
        }
    }

详情 通过dbCollection.find();方法

查询总结

dbCollection.find(); 查找所有的对象

dbCollection.find(obj); 查找有条件限制的对象，传入的对象obj一定是DBObject 类型，而obj也已经满足查找的条件，是通过put(key,val)来限制的

dbCollection.find().skip(2).limit(3); 分页查询

dbCollection.findOne(dbObject); 查询一条记录

删除

代码10之删除第一个对象—remove(DBObject obj )

搜索：Java MongoDB : Delete document

    public static void deleteFirst(DBCollection dbCollection) {
        DBObject obj = dbCollection.findOne();
        dbCollection.remove(obj);
    }

详情 先查找到第一个对象：

DBObject obj = dbCollection.findOne();

然后删除查找到的对象

dbCollection.remove(obj);

代码11之删除指定对象—remove(DBObject obj )

    public static void deleteOne(DBCollection dbCollection) {
        //addList(dbCollection);

        DBObject obj = new BasicDBObject();
        ObjectId id = new ObjectId("59cb888e704d333268138155");
        obj.put("_id", id);
        dbCollection.remove(obj);
    }

详情：
1. 删除指定对象条件：条件必须是具有唯一性的
2. BasicDBObject(String key, Object value) 指定key是String类型，而不是任意类型，所以DBObject.put（key,val）时，key绝对是String类型

3. Object value 没有指定是哪种类型，然后从mongodb数据库中可以看出，value的类型是Type显示的那一栏。ObjectId与Object是不同的概念，所以，当指定 通过id删除对象时，先new一个ObjectId来指定此id的值

4. 思路：先找到指定对象，然后再删除

代码12之删除所有对象—remove(DBObject obj )

    public static void deleteAll(DBCollection dbCollection) {
        //addList(dbCollection);

        DBCursor dbCursor = dbCollection.find();
        while (dbCursor.hasNext()) {
            dbCollection.remove(dbCursor.next());
        }
    }

详情：
1. 思路： find()查找出所有的对象，竟而一个一个的删除

代码12之删除多条对象—remove(DBObject obj )

    public static void deleteByIn(DBCollection dbCollection) {
        addList(dbCollection);

        DBObject obj = new BasicDBObject();
        List<String> list = new ArrayList<String>();
        list.add("刘德华");
        list.add("jolie");
        obj.put("name", new BasicDBObject("$in", list));
        dbCollection.remove(obj);
    }

详情：
思路： 先列出需要删除对象的条件是，name为jolie和刘德华,然后删除

删除总结

由于mongdb中存储的是DBObject类型的对象，所以只能删除DBObject此类型对象。

因为remove（DBObject obj）参数是DBObject类型。而传入的obj就是要删除的对象，而此对象已经满足想要删除的条件是什么，它是通过put（key,val）来指定的

修改

搜索：Java MongoDB : Update document

代码13之修改一条对象—update(searchQuery, newDocument);

//第一种修改方法
        addList(dbCollection);

        DBObject newDocument = new BasicDBObject();
        newDocument.put("$set", new BasicDBObject("age", 110));

        DBObject searchQuery = new BasicDBObject();
        searchQuery.put("name", "刘德华");

        dbCollection.update(searchQuery, newDocument);
    }

//第二种修改方法
    public static void updateOne2(DBCollection dbCollection) {
        addList(dbCollection);

        DBObject newObj = dbCollection.findOne(new BasicDBObject("_id", new ObjectId("59c252a5704d3387d4c9bcf3")));
        newObj.put("name", "aaa");

        DBObject searchObj = dbCollection.findOne(new BasicDBObject("_id", new ObjectId("59c252a5704d3387d4c9bcf3")));
        dbCollection.update(searchObj, newObj);
    }

详情
第一种通过$set来辨别是修改的操作

第二种通过put来实现

代码14之修改多条对象—updateMulti(searchQuery, newDocument);

   public static void updateMulti(DBCollection dbCollection) {
        DBObject newDocument = new BasicDBObject();
        newDocument.put("$set", new BasicDBObject("name", "刘德华"));

        DBObject searchQuery = new BasicDBObject();
        searchQuery.put("name", "asdf");

        dbCollection.updateMulti(searchQuery, newDocument);
    }

修改总结

dbCollection.update(searchObj, newObj); 修改一条

dbCollection.updateMulti(searchQuery, newDocument); 修改多条