用原生java客户端连接mongodb，实现对mongodb的简单增删改查

1.新增功能。

2.删除username为cang的人

3.删除age大于8小于25的人

4.修改username为chen的age为8

5.给喜爱东京的人也爱好小电影2和小电影3

6. db.users.updateOne({“username”:“lison”,},
   {
   “$push”: {
   “comments”: {
   $each: [
   {
   “author” : “james”,
   “content” : “lison是个好老师！”,
   “commentTime” : ISODate(“2018-01-06T04:26:18.354Z”)
   }
   ],
   KaTeX parse error: Expected 'EOF', got '}' at position 33: …me":-1} }̲ } …sort运算符进行排序，插入评论后，再按照评论时间降序排序；

7.查看人员时加载最新的三条评论；
db.users.find({“username”:“lison”},{“comments”:{"$slice":[0,3]}}).pretty()

8.点击评论的下一页按钮，新加载三条评论
db.users.find({“username”:“lison”},{“comments”:{“KaTeX parse error: Expected 'EOF', got '}' at position 13: slice":[3,3]}̲,"id”:1}).pretty();

9.查询总共有多少数据

10.查询喜好城市为东莞和东京的人

11.查询username中含有“s”，country为“English”或"USA"

12.db.users.find({“username”:“lison”},{“comments”:{“KaTeX parse error: Expected 'EOF', got '}' at position 13: slice":[0,3]}̲,"id”:1}).pretty();

13.db.users.aggregate([{“KaTeX parse error: Expected 'EOF', got '}' at position 28: …rname":"lison"}}̲, …unwind”:“KaTeX parse error: Expected 'EOF', got '}' at position 10: comments"}̲, …sort:{“comments.commentTime”:-1}},
{“KaTeX parse error: Expected 'EOF', got '}' at position 24: …:{"comments":1}}̲, …skip”:6},
{”$limit":3}])
如果有多种排序需求怎么处理？使用聚合

14.DbRef查询
15.db.users.update({"":""},{“username”:“leilei”},{“upsert”:true})
16.db.users.updateMany({“username”:“lison”},{“KaTeX parse error: Expected 'EOF', got '}' at position 31: …y":"","age":""}}̲) 17.db.users.u…rename”:{“country”:“guojia”,“age”:“nianling”}})
18.db.users.updateMany({ “username” : “jack”}, { “KaTeX parse error: Expected '}', got 'EOF' at end of input: …s.movies" : { "each” : [ “小电影2 " , “小电影3”]}}})
19.db.users.updateMany({ “username” : “jack”}, { “KaTeX parse error: Expected 'EOF', got '}' at position 55: …影2 " , "小电影3"]}}̲) 20.db.users.u…push”:{“comments”:{“author”:“lison23”,“content”:“ydddyyytttt”}}})
21.db.users.updateOne({“username”:“jack”},
{“KaTeX parse error: Expected '}', got 'EOF' at end of input: … {"each”:[{“author”:“lison22”,“content”:“yyyytttt”},
{“author”:“lison23”,“content”:“ydddyyytttt”}]}}})
22.db.users.updateOne({“username”:“jack”},
{“KaTeX parse error: Expected '}', got 'EOF' at end of input: … {"each”:[ {“author”:“lison22”,“content”:“yyyytttt”},
{“author”:“lison23”,“content”:“ydddyyytttt”} ],
KaTeX parse error: Expected 'EOF', got '}' at position 20: …: {"author":1} }̲ } }) 23.db.use…pull”:{“comments”:{“author”:“lison22”}}})
24.db.users.update({“username”:“lison”},
{“KaTeX parse error: Expected 'EOF', got '}' at position 131: …ison是苍老师的小迷弟"}}}̲) 25.db.users.u…set”:{“comments. $.content":"xxoo", "comments.$.author”:“lison10” }})
注意：本文用的数据脚本和详细代码在git仓库上：https://github.com/shidebin/mongodb/tree/master/java-pojo
doc形式：

package com.shidebin.mongodb.java_pojo;


import static com.mongodb.client.model.Filters.eq;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.bson.Document;
import org.bson.conversions.Bson;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.mongodb.core.query.Update;

import com.mongodb.Block;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.ServerAddress;
import com.mongodb.WriteConcern;
import com.mongodb.client.AggregateIterable;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.FindOneAndUpdateOptions;
import com.mongodb.client.model.Projections;
import com.mongodb.client.model.PushOptions;
import com.mongodb.client.model.ReturnDocument;
import com.mongodb.client.model.Sorts;
import com.mongodb.client.model.UpdateOptions;
import com.mongodb.client.model.Updates;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.mongodb.operation.UpdateOperation;

public class JavaDocTest {
	private static final Logger logger = LoggerFactory.getLogger(JavaDocTest.class);
	private MongoClient client;
	private MongoDatabase database;
	private MongoCollection<Document> collection;
	@Before
	public void init() {
//		MongoClientOptions mco = MongoClientOptions.builder()
//				.writeConcern(WriteConcern.ACKNOWLEDGED)
//				.connectionsPerHost(100)
//				.threadsAllowedToBlockForConnectionMultiplier(5)
//				.maxWaitTime(120000).connectTimeout(10000).build();
//		client = new MongoClient(new ServerAddress("192.168.126.128",27022),mco);
		client = new MongoClient("192.168.126.128",27022);
		database = client.getDatabase("lison");
		collection = database.getCollection("users");
	}
	@Test
	public void insert() {
		Document doc1 = new Document();
    	doc1.append("username", "cang");
    	doc1.append("country", "USA");
    	doc1.append("age", 20);
    	doc1.append("lenght", 1.77f);
    	doc1.append("salary", new BigDecimal("6565.22"));
    	
    	Map<String, String> address1 = new HashMap<String, String>();
    	address1.put("aCode", "0000");
    	address1.put("add", "xxx000");
    	doc1.append("address", address1);
    	
    	Map<String, Object> favorites1 = new HashMap<String, Object>();
    	favorites1.put("movies", Arrays.asList("aa","bb"));
    	favorites1.put("cites", Arrays.asList("东莞","东京"));
    	doc1.append("favorites", favorites1);
    	
    	Document doc2  = new Document();
    	doc2.append("username", "chen");
    	doc2.append("country", "China");
    	doc2.append("age", 30);
    	doc2.append("lenght", 1.77f);
    	doc2.append("salary", new BigDecimal("8888.22"));
    	Map<String, String> address2 = new HashMap<String, String>();
    	address2.put("aCode", "411000");
    	address2.put("add", "我的地址2");
    	doc1.append("address", address2);
    	Map<String, Object> favorites2 = new HashMap<String, Object>();
    	favorites2.put("movies", Arrays.asList("东游记","一路向东"));
    	favorites2.put("cites", Arrays.asList("珠海","东京"));
    	doc2.append("favorites", favorites2);
    	collection.insertMany(Arrays.asList(doc1,doc2));
	}
	@Test
	public void delete() {
		//删除username为cang的人
		DeleteResult result = collection.deleteMany(Filters.eq("username", "cang"));
		logger.info("删除的数量："+result.getDeletedCount());
		//删除age大于8小于25的人
		long count = collection.count(Filters.and(Filters.lt("age", 25),Filters.gt("age", 8)));
		logger.info("age大于8小于25的人:"+count);
		DeleteResult result2 = collection.deleteMany(Filters.and(Filters.gt("age", 8),Filters.lt("age", 25)));
		logger.info("删除的数量2："+result2.getDeletedCount());
	}
	@Test
	public void update() {
		//修改username为chen的age为8
		UpdateResult result = collection.updateMany(Filters.eq("username", "chen"), Updates.set("age", 8));
		logger.info("修改的数量："+result.getModifiedCount());
		//给喜爱东京的人也爱好小电影2和小电影3
		UpdateResult result2 = collection.updateMany(Filters.eq("favorites.cites", "东京"), 
				Updates.addEachToSet("favorites.movies", Arrays.asList("小电影2","小电影3")));
		logger.info("修改的数量2："+result2.getModifiedCount());
	}
	/**
	 * db.users.updateOne({"username":"lison",},
					{
					  "$push": {
						 "comments": {
						   $each: [
								{
									"author" : "james",
									"content" : "lison是个好老师！",
									"commentTime" : ISODate("2018-01-06T04:26:18.354Z")
								}
							],
						   $sort: {"commentTime":-1}
						 }
					  }
					}
				);
	新增评论时，使用$sort运算符进行排序，插入评论后，再按照评论时间降序排序；
	 */
	@Test
	public void update1() {
		Document doc = new Document().append("author", "james").append("content", "lison是个好老师！").
				append("commentTime", new Date());
		PushOptions sortDocument = new PushOptions().sortDocument(new Document().append("commentTime", -1));
		Bson pushEach = Updates.pushEach("comments", Arrays.asList(doc), sortDocument);
		UpdateResult updateOne = collection.updateOne(Filters.eq("username", "lison"),pushEach);
		System.out.println("++++++++++"+updateOne.getModifiedCount());
	}
	@Test
	/**
	 * db.users.update({"":""},{"username":"leilei"},{"upsert":true})

	 */
	public void update3() {
		UpdateOptions upsert = new UpdateOptions().upsert(true);
		UpdateResult updateOne = collection.updateOne(Filters.eq("username", ""),Updates.setOnInsert("username", "leilei"),upsert);
		System.out.println("++++++++++"+updateOne.getModifiedCount());
	}
	/**
	 * db.users.updateMany({"username":"lison"},{"$unset":{"country":"","age":""}})
	 */
	@Test
	public void update4() {
		UpdateResult updateMany = collection.updateMany(Filters.eq("username", "lison"), 
				Updates.combine(Updates.unset("country"),Updates.unset("age")));
		System.out.println("++++++++++"+updateMany.getModifiedCount());
	}
	/**
	 * db.users.updateMany({"username":"jack"},{"$rename":{"country":"guojia","age":"nianling"}})
	 */
	@Test
	public void update5() {
		UpdateResult updateMany = collection.updateMany(Filters.eq("username", "jack"), 
				Updates.combine(Updates.rename("country", "guojia"),Updates.rename("age", "nianling")));
		System.out.println("++++++++++"+updateMany.getModifiedCount());
	}
	/**
	 * db.users.updateMany({ "username" : "jack"}, { "$addToSet" : { "favorites.movies" : { "$each" : [ "小电影2 " , "小电影3"]}}})
	 */
	@Test
	public void updat6() {
		UpdateResult updateMany = collection.updateMany(Filters.eq("username", "jack"), 
				Updates.addEachToSet("favorites.movies", Arrays.asList("小电影2 " , "小电影3")));
		System.out.println("++++++++++"+updateMany.getModifiedCount());
	}
	/**
	 * db.users.updateMany({ "username" : "jack"}, { "$pull" : { "favorites.movies" : [ "小电影2 " , "小电影3"]}})
	 */
	@Test
	public void update7() {
		UpdateResult updateMany = collection.updateMany(Filters.eq("username", "jack"), 
				Updates.pullAll("favorites.movies", Arrays.asList("小电影2 " , "小电影3")));
		System.out.println("++++++++++"+updateMany.getModifiedCount());
	}
	/**
	 * db.users.updateOne({"username":"jack"},
	 * {"$push":{"comments":{"author":"lison23","content":"ydddyyytttt"}}})
	 */
	@Test
	public void update8() {
		Document document = new Document();
		document.append("author", "lison23");
		document.append("content", "ydddyyytttt");
		UpdateResult updateOne = collection.updateOne(Filters.eq("username", "jack"), Updates.push("comments", document));
		System.out.println("++++++++++"+updateOne.getModifiedCount());
	}
	/**
	 * db.users.updateOne({"username":"jack"},     
       {"$push":{"comments":
                  {"$each":[{"author":"lison21","content":"yyyytttt"},
                                  {"author":"lison22","content":"ydddyyytttt"}]}}})
	 */
	@Test
	public void update9() {
		Document document = new Document();
		document.append("author", "lison21");
		document.append("content", "ydddyyytttt");
		Document document2 = new Document();
		document2.append("author", "lison22");
		document2.append("content", "ydddyyytttt");
		UpdateResult updateOne = collection.updateOne(Filters.eq("username", "jack"), 
				Updates.pushEach("comments", Arrays.asList(document,document2)));
		System.out.println("++++++++++"+updateOne.getModifiedCount());
	}
	/**
	 * db.users.updateOne({"username":"jack"}, 
      {"$push": {"comments":
                {"$each":[ {"author":"lison24","content":"yyyytttt"},
                                {"author":"lison25","content":"ydddyyytttt"} ], 
                  $sort: {"author":1} } } })
	 */
	@Test
	public void update10() {
		Document document = new Document();
		document.append("author", "lison24");
		document.append("content", "ydddyyytttt");
		Document document2 = new Document();
		document2.append("author", "lison25");
		document2.append("content", "ydddyyytttt");
		PushOptions sortDocument = new PushOptions().sortDocument(Sorts.ascending("author"));
		UpdateResult updateOne = collection.updateOne(Filters.eq("username", "jack"), 
				Updates.pushEach("comments", Arrays.asList(document,document2),sortDocument));
		System.out.println("++++++++++"+updateOne.getModifiedCount());
	}
	/**
	 * db.users.update({"username":"jack"},
                               {"$pull":{"comments":{"author":"lison22"}}})
	 */
	@Test
	public void update11() {
		Document document = new Document();
		document.append("author", "lison22");
		UpdateResult updateMany = collection.updateMany(Filters.eq("username", "jack"), 
				Updates.pull("comments",document));
		System.out.println("++++++++++"+updateMany.getModifiedCount());
	}
	/**
	 * db.users.update({"username":"lison"},
                               {"$pull":{"comments":{"author":"lison5",
                                   "content":"lison是苍老师的小迷弟"}}})
	 */
	@Test
	public void update12() {
		Document doc = new Document();
		doc.append("author", "lison5");
		doc.append("content", "lison是苍老师的小迷弟");
		UpdateResult updateOne = collection.updateOne(Filters.eq("username", "lison"), 
				Updates.pull("comments", doc));
		System.out.println("++++++++++"+updateOne.getModifiedCount());
	}
	/**
	 * db.users.updateMany({"username":"jack","comments.author":"lison1"},
                    {"$set":{"comments.$.content":"xxoo",
                                "comments.$.author":"lison10" }})
	 */
	@Test
	public void update13() {
		UpdateResult updateMany = collection.updateMany(Filters.and(Filters.eq("username", "jack"),Filters.eq("comments.author", "lison16")),
				Updates.combine(Updates.set("comments.$.content", "xxoo"),
						Updates.set("comments.$.author", "lison10")));
//		Document doc = new Document();
//		doc.append("content","xxoo");
//		doc.append("author", "lison10");
//		UpdateResult updateMany = collection.updateMany(Filters.and(Filters.eq("username", "jack"),Filters.eq("comments.author", "lison16")),
//				Updates.set("comments", doc));
		System.out.println("++++++++++"+updateMany.getModifiedCount());
	}
	/**
	 * db.users.findAndModify({{"username":"json","comments.author":"lison1"},
                    {"$set":{"comments.$.content":"xxoo",
                                "comments.$.author":"lison10" }},"new":true})
	 */
	@Test
	public void update14() {
		Document findOneAndUpdate = collection.findOneAndUpdate(Filters.and(Filters.eq("username", "lison"),Filters.eq("comments.author", "lison2")), 
				Updates.combine(Updates.set("comments.$.content", "xxoo2"),
						Updates.set("comments.$.author", "lison12")),new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER));
		System.out.println("++++++++++"+findOneAndUpdate.toJson());
	}
	/**
	 * 查看人员时加载最新的三条评论；
	db.users.find({"username":"lison"},{"comments":{"$slice":[0,3]}}).pretty()
	 */
	@Test
	public void query2() {
		FindIterable<Document> projection = collection.find(Filters.eq("username", "lison")).
		projection(Projections.slice("comments", 0, 3));
		Block<Document> block = getBlock();
		forEach(projection,block);
	}
	/**
	 * 点击评论的下一页按钮，新加载三条评论
	db.users.find({"username":"lison"},{"comments":{"$slice":[3,3]},"$id":1}).pretty();
	 */
	@Test
	public void query3() {
		Bson slice = Projections.slice("comments", 3, 3);
		Bson include = Projections.include("$id");
		FindIterable<Document> projection = collection.find(Filters.eq("username", "lison")).
		projection(Projections.fields(slice,include));
		Block<Document> block = getBlock();
		forEach(projection,block);
	}
	@Test
	public void query() {
		//查询总共有多少数据
		logger.info("总共有多少数据："+collection.count());
		//查询喜好城市为东莞和东京的人
		/*FindIterable<Document> result = collection.find(Filters.and(Filters.eq("favorites.cites","东莞"),
				Filters.eq("favorites.cites","东京")));*/
		FindIterable<Document> result = collection.find(Filters.all("favorites.cites", "东京","东莞"));
		@SuppressWarnings("unchecked")
		Block<Document> block = new Block() {
			@Override
			public void apply(Object t) {
				logger.info(t.toString());
			}
			
		};
		result.forEach(block);
		//查询username中含有“s”，country为“English”或"USA"
		FindIterable<Document> result2 = collection.find(Filters.and(Filters.regex("username", ".*s.*"),
				Filters.in("country", "English","USA")));
		result2.forEach(block);
		//db.users.find({"username":"lison"},{"comments":{"$slice":[0,3]},"$id":1}).pretty();
		FindIterable<Document> result3 = collection.find(Filters.eq("username", "lison"))
				.projection(Projections.fields(Projections.include("$id"),Projections.slice("comments", 0, 3)));
		result3.forEach(block);
		FindIterable<Document> result4 = collection.find(Filters.eq("username", "lison"))
				.projection(Projections.fields(Projections.include("$id"),Projections.slice("comments", 3, 3)));
		result4.forEach(block);
	}
	
	/**
	 * db.users.aggregate([{"$match":{"username":"lison"}},
	                       {"$unwind":"$comments"},
	                       {$sort:{"comments.commentTime":-1}},
	                       {"$project":{"comments":1}},
	                       {"$skip":6},
	                       {"$limit":3}])
	              如果有多种排序需求怎么处理？使用聚合         
	 */
	@Test
	public void query1() {
		Block<Document> block = new Block<Document>() {
			@Override
			public void apply(Document t) {
				logger.info(t.toJson());
			}
			
		};
		AggregateIterable<Document> aggregate = collection.aggregate(Arrays.asList(Aggregates.match(Filters.eq("username", "lison")),
				Aggregates.unwind("$comments"),Aggregates.sort(Sorts.descending("commentTime")),
				Aggregates.project(Projections.include("comments")),Aggregates.skip(6),Aggregates.limit(3)));
		aggregate.forEach(block);
	}
	//测试DbRef
	@Test
	public void test() {
		Block<Document> block = new Block<Document>() {
			@Override
			public void apply(Document t) {
				logger.info("---------------------");
//				logger.info(t.toJson());
				Object object = t.get("comments");
				System.out.println(object);
				logger.info("---------------------");
			}
			
		};
		FindIterable<Document> find = collection.find(Filters.eq("username", "lison"));
		find.forEach(block);
	}
	public Block<Document> getBlock(){
		return new Block<Document>() {
			@Override
			public void apply(Document t) {
				logger.info(t.toJson());
			}
			
		};
	}
	public void forEach(FindIterable<Document> projection,Block<Document> block) {
		projection.forEach(block);
	}
	
}

注意：如何发现连不上远程mongodb，请查看另一篇文章。
pojo形式：

package com.shidebin.mongodb.java_pojo;


import static com.mongodb.client.model.Filters.all;
import static com.mongodb.client.model.Filters.and;
import static com.mongodb.client.model.Filters.eq;
import static com.mongodb.client.model.Filters.gt;
import static com.mongodb.client.model.Filters.lt;
import static com.mongodb.client.model.Filters.or;
import static com.mongodb.client.model.Filters.regex;
import static com.mongodb.client.model.Updates.addEachToSet;

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

import org.bson.Document;
import org.bson.codecs.configuration.CodecRegistries;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.codecs.pojo.PojoCodecProvider;
import org.bson.conversions.Bson;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.dongnao.mongo.entity.Address;
import com.dongnao.mongo.entity.Favorites;
import com.dongnao.mongo.entity.User;
import com.mongodb.Block;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;

//原生java驱动 Pojo的操作方式
public class QuickStartJavaPojoTest {

	private static final Logger logger = LoggerFactory.getLogger(QuickStartJavaPojoTest.class);
	
    private MongoDatabase db;
    
    private MongoCollection<User> doc;
    
    private MongoClient client;
	
	
    @Before
    public void init(){
    	//编解码器的list
    	List<CodecRegistry> codecResgistes = new ArrayList<CodecRegistry>();
    	//编解码器的list加入默认的编解码器结合
    	codecResgistes.add(MongoClient.getDefaultCodecRegistry());
    	//生成一个pojo的编解码器
    	CodecRegistry pojoProviders = CodecRegistries.
    			fromProviders(PojoCodecProvider.builder().automatic(true).build());
    	
    	codecResgistes.add(pojoProviders);
    	//通过编解码器的list生成编解码器注册中心
    	CodecRegistry registry = CodecRegistries.fromRegistries(codecResgistes);
    	
    	//把编解码器注册中心放入MongoClientOptions
    	MongoClientOptions build = MongoClientOptions.builder().
    			codecRegistry(registry).build();

    	ServerAddress serverAddress = new ServerAddress("192.168.126.128",27022);

		client = new MongoClient(serverAddress, build);
    	db =client.getDatabase("lison");
    	doc = db.getCollection("users",User.class);
    }
    
    @Test
    public void insertDemo(){
    	User user = new User();
    	user.setUsername("cang");
    	user.setCountry("USA");
    	user.setAge(20);
    	user.setLenght(1.77f);
    	user.setSalary(new BigDecimal("6265.22"));
    	Address address1 = new Address();
    	address1.setaCode("411222");
    	address1.setAdd("sdfsdf");
    	user.setAddress(address1);
    	Favorites favorites1 = new Favorites();
    	favorites1.setCites(Arrays.asList("东莞","东京"));
    	favorites1.setMovies(Arrays.asList("西游记","一路向西"));
    	user.setFavorites(favorites1);
    	
    	
    	User user1 = new User();
    	user1.setUsername("chen");
    	user1.setCountry("China");
    	user1.setAge(30);
    	user1.setLenght(1.77f);
    	user1.setSalary(new BigDecimal("6885.22"));
    	Address address2 = new Address();
    	address2.setaCode("411000");
    	address2.setAdd("我的地址2");
    	user1.setAddress(address2);
    	Favorites favorites2 = new Favorites();
    	favorites2.setCites(Arrays.asList("珠海","东京"));
    	favorites2.setMovies(Arrays.asList("东游记","一路向东"));
    	user1.setFavorites(favorites2);
    	
    	
    	
    	doc.insertMany(Arrays.asList(user,user1));
    	
    }
    
    //@Test
    public void testDelete(){
    	
    	//delete from users where username = ‘lison’
    	
    	DeleteResult deleteMany = doc.deleteMany(eq("username", "lison"));
    	logger.info(String.valueOf(deleteMany.getDeletedCount()));
    	
    	//delete from users where age >8 and age <25
    	DeleteResult deleteMany2 = doc.deleteMany(and(gt("age",8),lt("age",25)));
    	logger.info(String.valueOf(deleteMany2.getDeletedCount()));
    }
    
    //@Test
    public void testUpdate(){
    	//update  users  set age=6 where username = 'lison' 
    	UpdateResult updateMany = doc.updateMany(eq("username", "lison"), 
    			                  new Document("$set",new Document("age",6)));
    	logger.info(String.valueOf(updateMany.getModifiedCount()));
    	
    	//update users  set favorites.movies add "小电影2 ", "小电影3" where favorites.cites  has "东莞"
    	UpdateResult updateMany2 = doc.updateMany(eq("favorites.cites", "东莞"), 
    			                                  addEachToSet("favorites.movies", Arrays.asList( "小电影2 ", "小电影3")));
    	logger.info(String.valueOf(updateMany2.getModifiedCount()));
    }
    
    //@Test
    public void testFind(){
    	
    	final List<User> ret = new ArrayList<>();
    	Block<User> printBlock = new Block<User>() {
			@Override
			public void apply(User t) {
//				logger.info();
				System.out.println(t.getUsername());
				System.out.println(t.getSalary());
				ret.add(t);
			}
    		
		};
		
    	//select * from users  where favorites.cites has "东莞"、"东京"
		FindIterable<User> find = doc.find(all("favorites.cites", Arrays.asList("东莞","东京")));
		find.forEach(printBlock);
		logger.info(String.valueOf(ret.size()));
		ret.removeAll(ret);
    	
    	
    	//select * from users  where username like '%s%' and (contry= English or contry = USA)
		String regexStr = ".*s.*";
		Bson regex = regex("username", regexStr);
		Bson or = or(eq("country","English"),eq("country","USA"));
		FindIterable<User> find2 = doc.find(and(regex,or));
		find2.forEach(printBlock);
		logger.info(String.valueOf(ret.size()));

    }
    
	
	
	

}

pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.shidebin.mongodb</groupId>
  <artifactId>java-pojo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>java-pojo</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
 
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>mongo-java-driver</artifactId>
			<version>3.5.0</version>
	</dependency>
	<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.7.10</version>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>1.1.2</version>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-core</artifactId>
			<version>1.1.2</version>
		</dependency>  
  </dependencies>
  <build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.1</version>
				<configuration>
					<source>1.7</source>
					<target>1.7</target>
				</configuration>
			</plugin>
		</plugins>
  </build>
</project>

注意：此类用到的java bean请到git仓库下载：https://github.com/shidebin/mongodb/tree/master/java-pojo。