mongo-java-driver 3.0版本学习例子 根据官网指南写的

官网指南地址 http://mongodb.github.io/mongo-java-driver/3.0/driver/getting-started/quick-tour/

例子目录结构

pom.xml

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.0.3</version>
</dependency>
  </dependencies>

mongodb.properties

mongodb.host=127.0.0.1
mongodb.port=
mongodb.replicaSet=
mongodb.connectionsPerHost=100
mongodb.threadsAllowedToBlockForConnectionMultiplier=5
mongodb.maxWaitTime=120000
mongodb.connectTimeout=60000
mongodb.socketTimeout=60000
mongodb.autoConnectRetry=true

mongodb连接配置

package mongodb.mongodb.test;

import java.util.ResourceBundle;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;

/**
 * mongodb连接配置工具类
 * @author wbq
 *
 */
public class MongoManager {
 //MongoClient的实例代表数据库连接池，是线程安全的，可以被多线程共享，客户端在多线程条件下仅维持一个实例即可 
 //Mongo是非线程安全的，目前mongodb API中已经建议用MongoClient替代Mongo 
private MongoClient mongoClient = null;  

private static MongoManager instance = null;

private MongoManager(){
//属性文件读取参数信息
ResourceBundle bundle = ResourceBundle.getBundle("mongodb");

MongoClientOptions.Builder build = new MongoClientOptions.Builder(); 
//与目标数据库能够建立的最大connection数量,默认100
build.connectionsPerHost(Integer.valueOf(bundle.getString("mongodb.connectionsPerHost")));
build.threadsAllowedToBlockForConnectionMultiplier(Integer.valueOf(bundle.getString("mongodb.threadsAllowedToBlockForConnectionMultiplier")));
/*
 * 一个线程访问数据库的时候，在成功获取到一个可用数据库连接之前的最长等待时间为2分钟
 * 这里比较危险，如果超过maxWaitTime都没有获取到这个连接的话，该线程就会抛出Exception
 * 故这里设置的maxWaitTime应该足够大，以免由于排队线程过多造成的数据库访问失败
 */
build.maxWaitTime(Integer.valueOf(bundle.getString("mongodb.maxWaitTime")));  
//与数据库建立连接的timeout设置为1分钟
build.connectTimeout(Integer.valueOf(bundle.getString("mongodb.connectTimeout"))); 
build.socketTimeout(Integer.valueOf(bundle.getString("mongodb.socketTimeout")));

MongoClientOptions myOptions = build.build();
        //数据库连接实例  
        mongoClient = new MongoClient("127.0.0.1", myOptions);            
}

public static MongoManager getInstance(){
if(instance ==null){
instance = new MongoManager();
}
return instance;
}

public static MongoClient getMongoClient(){
return MongoManager.getInstance().mongoClient;
}
}

测试代码

package mongodb.mongodb.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.bson.Document;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.mongodb.Block;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;

import static com.mongodb.client.model.Filters.*;
import static com.mongodb.client.model.Projections.*;
import static com.mongodb.client.model.Sorts.*;

import com.mongodb.client.model.BulkWriteOptions;
import com.mongodb.client.model.DeleteOneModel;
import com.mongodb.client.model.InsertOneModel;
import com.mongodb.client.model.ReplaceOneModel;
import com.mongodb.client.model.UpdateOneModel;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;

public class MongoTest {

private MongoClient client = MongoManager.getMongoClient();
private MongoDatabase md = client.getDatabase("local");
private MongoCollection<Document> coll = null;

//创建集合
@Before
public void create(){
md.createCollection("test");
coll = md.getCollection("test");
}

@Test
public void run(){
add();
query();
update();
testDel();
bulk();
}

//添加测试
public void add(){

//添加单条记录
Document doc = new Document("name","MongoDB").append("type", "database").append("count", 1)
.append("info", new Document("x", 203).append("y", 102));
coll.insertOne(doc);

//添加多条记录
List<Document> list = new ArrayList<Document>();
for(int i= 0 ;i< 100 ;i++){
list.add(new Document("i", i));
}
coll.insertMany(list);
}

//查询
public void query(){
//查询第一条
Document doc = coll.find().first();
System.out.println(doc.toJson());

//查询所有
try(MongoCursor<Document> cursor = coll.find().iterator()){
while(cursor.hasNext()){
System.out.println(cursor.next().toJson());
}
}

//过滤查询 单条
doc = coll.find(eq("i", 71)).first();
System.out.println(doc.toJson());
//过滤查询 多条
Block<Document> printBlock = new Block<Document>(){

@Override
public void apply(Document t) {
System.out.println("i>50  "+t.toJson());
}
};
coll.find(gt("i",50)).forEach(printBlock);
//排除 降序 第一条数据
doc = coll.find(exists("i")).sort(descending("i")).first();
System.out.println("sort: " + doc.toJson());

doc = coll.find().projection(excludeId()).first();
System.out.println("excludeId: "+doc.toJson());
}


//更新测试
public void update(){
//更新单独记录
coll.updateOne(eq("i","10"), new Document("$set",new Document("i", 110)));
//跟新多条记录  $set 设置为指定值  $inc 原子性操作 将原来的加上 新值
UpdateResult updateResult = coll.updateMany(lt("i", 100),new Document("$inc",new Document("i",100)));
System.out.println("ModifiedCount:" + updateResult.getModifiedCount());
}

//删除测试
public void testDel(){
//删除单个 找到符合条件的第一个 删除
coll.deleteOne(eq("i",110));
//删除多个 只要符合条件就全部删除
DeleteResult deleteResult = coll.deleteMany(gte("i",100));
System.out.println("DeletedCount:"+deleteResult.getDeletedCount());
}

//批量操作
public void bulk(){
//有序
coll.bulkWrite(
Arrays.asList(new InsertOneModel<Document>(new Document("_id", 1)),
  new InsertOneModel<Document>(new Document("_id", 2)),
  new InsertOneModel<Document>(new Document("_id", 3)),
  new UpdateOneModel<Document>(new Document("_id", 1),new Document("$set", new Document("x", 2))),
  new DeleteOneModel<Document>(new Document("_id",2)),
  new ReplaceOneModel<Document>(new Document("_id", 3), new Document("_id", 3).append("x",4))));
//无序
coll.bulkWrite(
  Arrays.asList(new InsertOneModel<Document>(new Document("_id", 4)),
                new InsertOneModel<Document>(new Document("_id", 5)),
                new InsertOneModel<Document>(new Document("_id", 6)),
                new UpdateOneModel<Document>(new Document("_id", 4),
                                     new Document("$set", new Document("x", 2))),
                new DeleteOneModel<Document>(new Document("_id", 5)),
                new ReplaceOneModel<Document>(new Document("_id", 6),
                                      new Document("_id", 6).append("x", 4))),
  new BulkWriteOptions().ordered(false));

}

@After
public void queryAll(){
System.out.println(coll.count());
        FindIterable<Document> docs = coll.find();
        MongoCursor<Document> cur = docs.iterator();
        while(cur.hasNext()){
        System.out.println(cur.next());
        }
        //删除集合
        coll.drop();
}
}