JAVA实现 mongoDB 的增删改查等基本操作

参考全教程: http://www.runoob.com/mongodb/mongodb-tutorial.html

创建maven工程并引入依赖

 <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongo-java-driver</artifactId>
        <version>3.4.3</version>
 </dependency>

增加

使用insertOne方法来插入文档。

package cn.mongodb.demo;

import java.util.HashMap;
import java.util.Map;

import org.bson.Document;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoData ;

public class TestAdd {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoData  data  = client.getData (\"mongodb\");
        //得到集合封装对象
        MongoCollection<Document> collection = data .getCollection(\"student\");
        Map<String,  > map=new HashMap();
        map.put(\"name\", \"诸葛亮\");
        map.put(\"sex\", \"男\");
        map.put(\"age\", 35.0);
        map.put(\"address\", \"南阳\");       
        Document doc=new Document(map);     
        collection.insertOne(doc);//插入一条记录
        //collection.insertMany(documents);//一次性插入多条文档
    }
}

删除

package cn.mongodb.demo;

import org.bson.Document;

import com.mongodb.BasicDB ;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoData ;

public class TestDelete {

    public static void main(String[] args) {
        
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoData  data  = client.getData (mongodb);
        //得到集合封装对象
        MongoCollection<Document> collection = data .getCollection(\"student\");
        
        BasicDB  bson=new BasicDB (\"name\", \"诸葛亮\");
                
        collection.deleteOne(bson);//删除记录（符合条件的第一条记录）
        //collection.deleteMany(bson);//删除符合条件的全部记录
    }
}

修改

package cn.mongodb.demo;

import org.bson.Document;

import com.mongodb.BasicDB ;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoData ;

public class TestUpdate {

    public static void main(String[] args) {
        
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoData  data  = client.getData (\"mongodb\");
        //得到集合封装对象
        MongoCollection<Document> collection = data .getCollection(\"student\");
        
        //修改的条件
        BasicDB  bson= new BasicDB (\"name\", \"诸葛亮\");
        //修改后的值
        BasicDB  bson2 = new BasicDB (\"$set\",  new BasicDB (\"address\", \"新野\"));
        //参数1：修改条件  参数2：修改后的值
        collection.updateOne(bson, bson2);
        //collection.updateMany(filter, update);//修改符合条件的所有记录
    }
}

查询全部记录

MongoDB的数字类型默认使用64位浮点型数值。{“x”：3.14}或{“x”：3}。对于整型值，可以使用NumberInt（4字节符号整数），{“x”:NumberInt(“3”)} 或NumberLong（8字节符号整数）{“x”:NumberLong(“3”)}

package cn.mongodb.demo;

import org.bson.Document;

import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoData ;

public class TestFindAll {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoData  data  = client.getData (\"mongodb\");
        //得到集合封装对象
        MongoCollection<Document> collection = data .getCollection(\"student\");
        //得到查询结果
        FindIterable<Document> find = collection.find();
        //遍历查询结果
        for(Document doc:find ){
            System.out.println(\"name:\"+ doc.getString(\"name\") );
            System.out.println(\"sex:\"+doc.getString(\"sex\"));
            System.out.println(\"age:\"+doc.getDouble(\"age\"));
            System.out.println(\"address:\"+doc.getString(\"address\"));
        }   
    }
}

匹配查询

MongoDB使用BasicDB 类型封装查询条件，构造方法的参数为key 和value。

package cn.mongodb.demo;

import org.bson.Document;
import org.bson.conversions.Bson;

import com.mongodb.BasicDB ;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoData ;

public class TestFindEq {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoData  data  = client.getData (\"mongodb\");
        //得到集合封装对象
        MongoCollection<Document> collection = data .getCollection(\"student\");
        
        //构建查询条件
        BasicDB  bson=new BasicDB (\"name\", \"诸葛亮\");
        
        //得到查询结果
        FindIterable<Document> find = collection.find(bson);
        //遍历查询结果
        for(Document doc:find ){
            System.out.println(\"name:\"+ doc.getString(\"name\") );
            System.out.println(\"sex:\"+doc.getString(\"sex\"));
            System.out.println(\"age:\"+doc.getDouble(\"age\"));
            System.out.println(\"address:\"+doc.getString(\"address\"));
        }
    }
}

模糊查询

构建模糊查询条件是通过正则表达式的方式来实现的

• （1）完全匹配Pattern pattern = Pattern.compile(\"^name$\");
• （2）右匹配Pattern pattern = Pattern.compile(\"^.*name$\");
• （3）左匹配Pattern pattern = Pattern.compile(\"^name.*$\");
• （4）模糊匹配Pattern pattern = Pattern.compile(\"^.name.$\");

package cn.mongodb.demo;

import java.util.regex.Pattern;

import org.bson.Document;

import com.mongodb.BasicDB ;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoData ;

public class TestFindLike {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoData  data  = client.getData (\"mongodb\");
        //得到集合封装对象
        MongoCollection<Document> collection = data .getCollection(\"student\");
        //模糊查询
        Pattern queryPattern=Pattern.compile(\"^.*南.*$\");
        //构建查询条件
        BasicDB  bson=new BasicDB (\"address\",queryPattern);
        
        //得到查询结果
        FindIterable<Document> find = collection.find(bson);
        //遍历查询结果
        for(Document doc:find ){
            System.out.println(\"name:\"+ doc.getString(\"name\") );
            System.out.println(\"sex:\"+doc.getString(\"sex\"));
            System.out.println(\"age:\"+doc.getDouble(\"age\"));
            System.out.println(\"address:\"+doc.getString(\"address\"));
        }
    }
}

条件查询：大于小于

在MongoDB提示符下条件json字符串为{ age: { $lt :20 } } ，对应的java代码也是BasicDB 的嵌套。
示例：查询student集合中age小于20的文档记录

package cn.mongodb.demo;

import org.bson.Document;

import com.mongodb.BasicDB ;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoData ;

public class TestFindLt {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoData  data  = client.getData (\"mongodb\");
        //得到集合封装对象
        MongoCollection<Document> collection = data .getCollection(\"student\");
        
        //构建查询条件
        BasicDB  bson=new BasicDB (\"age\", new BasicDB (\"$lt\", 20));
        
        //得到查询结果
        FindIterable<Document> find = collection.find(bson);
        //遍历查询结果
        for(Document doc:find ){
            System.out.println(\"name:\"+ doc.getString(\"name\") );
            System.out.println(\"sex:\"+doc.getString(\"sex\"));
            System.out.println(\"age:\"+doc.getDouble(\"age\"));
            System.out.println(\"address:\"+doc.getString(\"address\"));
        }
    }
}

条件连接--并且

$and 表示并且

package cn.mongodb.demo;

import java.util.Arrays;

import org.bson.Document;

import com.mongodb.BasicDB ;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoData ;

public class TestFindAnd {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoData  data  = client.getData (\"mongodb\");
        //得到集合封装对象
        MongoCollection<Document> collection = data .getCollection(\"student\");
        
        BasicDB  bson1=new BasicDB (\"age\", new BasicDB (\"$gte\",20));
        BasicDB  bson2=new BasicDB (\"age\", new BasicDB (\"$lt\",30));
        //构建查询条件
        BasicDB  bson=new BasicDB (\"$and\", Arrays.asList( bson1, bson2 )  );
        
        //得到查询结果
        FindIterable<Document> find = collection.find(bson);
        //遍历查询结果
        for(Document doc:find ){
            System.out.println(\"name:\"+ doc.getString(\"name\") );
            System.out.println(\"sex:\"+doc.getString(\"sex\"));
            System.out.println(\"age:\"+doc.getDouble(\"age\"));
            System.out.println(\"address:\"+doc.getString(\"address\"));
        }
    }
}

条件连接--或者

$or表示或者

package cn.mongodb.demo;

import java.util.Arrays;

import org.bson.Document;

import com.mongodb.BasicDB ;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoData ;

public class TestFindOr {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoData  data  = client.getData (\"mongodb\");
        //得到集合封装对象
        MongoCollection<Document> collection = data .getCollection(\"student\");
        
        BasicDB  bson1=new BasicDB (\"age\", new BasicDB (\"$lte\",20));     
        BasicDB  bson2=new BasicDB (\"sex\", \"女\");
        //构建查询条件
        BasicDB  bson=new BasicDB (\"$or\", Arrays.asList( bson1, bson2 )  );
        
        //得到查询结果
        FindIterable<Document> find = collection.find(bson);
        //遍历查询结果
        for(Document doc:find ){
            System.out.println(\"name:\"+ doc.getString(\"name\") );
            System.out.println(\"sex:\"+doc.getString(\"sex\"));
            System.out.println(\"age:\"+doc.getDouble(\"age\"));
            System.out.println(\"address:\"+doc.getString(\"address\"));
        }
    }
}

MongoDB连接池

MongoClient 被设计为线程安全的类，也就是我们在使用该类时不需要考虑并发的情况，这样我们可以考虑把MongoClient 做成一个静态变量，为所有线程公用，不必每次都销毁。这样可以极大提高执行效率。实际上，这是MongoDB提供的内置的连接池来实现的。

MongoDB写入策略。
WriteConcern.NONE:没有异常抛出
WriteConcern.NORMAL:仅抛出网络错误异常，没有服务器错误异常
WriteConcern.SAFE:抛出网络错误异常、服务器错误异常；并等待服务器完成写操作。
WriteConcern.MAJORITY: 抛出网络错误异常、服务器错误异常；并等待一个主服务器完成写操作。
WriteConcern.FSYNC_SAFE: 抛出网络错误异常、服务器错误异常；写操作等待服务器将数据刷新到磁盘。
WriteConcern.JOURNAL_SAFE:抛出网络错误异常、服务器错误异常；写操作等待服务器提交到磁盘的日志文件。
WriteConcern.REPLICAS_SAFE:抛出网络错误异常、服务器错误异常；等待至少2台服务器完成写操作。

首先我们先创建一个“管理类”，相当于我们原来的 Dao

package cn.mongodb.demo;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientOptions.Builder;
import com.mongodb.WriteConcern;
import com.mongodb.client.MongoData ;

public class MongoManager {

    private static MongoClient mongoClient=null;
    
    //对mongoClient初始化
    private static void init(){
        //连接池选项
        Builder builder = new MongoClientOptions.Builder();//选项构建者  
        builder.connectTimeout(5000);//设置连接超时时间
        builder.socketTimeout(5000);//读取数据的超时时间
        builder.connectionsPerHost(30);//每个地址最大请求数      
        builder.writeConcern(WriteConcern.NORMAL);//写入策略，仅抛出网络异常
        MongoClientOptions options = builder.build();
        mongoClient=new MongoClient(\"192.168.25.200\",options);  
}

    
    public static MongoData  getData (){
        if(mongoClient==null){
            init();
        }       
        return mongoClient.getData (\"mongodb\");
    }
}

然后我们创建一个StudentDao

package cn.mongodb.demo;
import org.bson.Document;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoData ;

public class StudentDao {

    public void save(String name,String sex,double age,String address){
        MongoData  data  = MongoManager.getData ();
        MongoCollection<Document> collection = data .getCollection(\"student2\");
        Document docment=new Document();
        docment.put(\"name\", name);
        docment.put(\"sex\", sex);        
        docment.put(\"age\", age);
        docment.put(\"address\", address);
        collection.insertOne(docment);
    }   
}

插入数据进行测试

package cn.mongodb.demo;
import java.util.Date;
public class TestPool {

    public static void main(String[] args) {
        long startTime = new Date().getTime();//开始时间
        
        StudentDao studentDao=new StudentDao();
        for(int i=0;i<20000;i++){
            studentDao.save(\"测试\"+i, \"男\", 25.0, \"测试地址\"+i);
        }
        long endTime = new Date().getTime();//完成时间
        System.out.println(\"完成时间：\"+(endTime-startTime)+\"毫秒\");
    }
}

经过测试：插入20000条数据所用毫秒数为1544。

作者：Cehae
链接：https://www.jianshu.com/p/209a25705b9e
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。