Java + 原生MongoDB驱动 API 使用案例详说（两种方式）

前不久，博主利用spring-boot结合spring-data-mongodb包，搞了一把mongodb的集成  -- 增删改查

这种方式，比较固执，使用起来虽然方便，但是太依赖spring，我想创建自己的dbname，都无从下手（可能我还没探究到），只能使用配置文件里面一开始就默认的url

很烦，我不知道我要创建数据库A、B、C.....什么的，要怎么做？ 而且查询也非常繁琐，so，本篇打算用原生的MongoDB API进行mongodb的使用，不难，看了后，就可以举一反三了，好了，我们开始吧！

一、pom依赖

注：由于博主习惯使用Spring-Boot框架写demo，因此，下面贴出来的pom符合Spring-Boot的依赖规范，但是，明眼人一眼就可以看出MongoDB API 用到的两个依赖是什么

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.appleyk</groupId>
	<artifactId>Spring-Boot-MongoAPI</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>MongoDB-API</name>
	<description>使用Java原生MongoDB_API进行数据的存储和访问</description>
	<!-- 继承官网最新父POM【假设当前项目不再继承其他POM】 -->
	<!-- http://projects.spring.io/spring-boot/#quick-start -->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.9.RELEASE</version>
	</parent>
	<!-- 使用Java8，嘗試使用新特新【stream和lambda】 -->
	<properties>
		<java.version>1.8</java.version>
		<mongodb.version>3.6.3</mongodb.version>
	</properties>
	<dependencies>
		<!-- Starter POMs是可以包含到应用中的一个方便的依赖关系描述符集合 -->
		<!-- 该Starters包含很多你搭建项目， 快速运行所需的依赖， 并提供一致的， 管理的传递依赖集。 -->
		<!-- 大多数的web应用都使用spring-boot-starter-web模块进行快速搭建和运行。 -->
		<!-- spring-boot-starter-web -->
		<!-- 对全栈web开发的支持， 包括Tomcat和 spring-webmvc -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency><!-- 添加Mybatis、Spring-Mybatis依赖 -->
		<!-- Spring 单元测试 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<!-- JUnit单元测试 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
		</dependency>
		<!-- 添加热部署 devtools：监听文件变动 -->
		<!-- 当Java文件改动时，Spring-boo会快速重新启动 -->
		<!-- 最简单的测试，就是随便找一个文件Ctrl+S一下，就可以看到效果 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<!-- optional=true,依赖不会传递 -->
			<!-- 本项目依赖devtools；若依赖本项目的其他项目想要使用devtools，需要重新引入 -->
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>mongo-java-driver</artifactId>
			<version>${mongodb.version}</version><!--$NO-MVN-MAN-VER$-->
		</dependency>
		<dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>bson</artifactId>
			<version>${mongodb.version}</version>
		</dependency>
	</dependencies>
</project>

注意两个地方

1、版本一定要统一，否则，出现未知的异常（比如说：‘’为什么我的数据保存不上，博主你的却可以呢？ ”）我可不管

2、关键的两个依赖包

下面开始，只贴代码，说明都在注释里面了，希望需要的朋友对照自己的项目进行拷贝改造，别往运行看效果！！！

二、API使用快速入门 ☞ Document对象

QuickStartTest.java

import static com.mongodb.client.model.Filters.*;
import static com.mongodb.client.model.Updates.*;

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

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

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;

public class QuickStartTest {

	
	MongoClient mongoClient = new MongoClient("localhost" , 27017);
	
	//或者使用下面的方法，使用连接字符串进行构建Mongo客户端实例
//	 MongoClientURI connectionString = new MongoClientURI("mongodb://localhost:27017");
//	 MongoClient mongoClient = new MongoClient(connectionString);
	
	/**
	 * 一旦有了连接到MongoDB部署的MongoClient实例，就可以使用MongoClient.getdatabase()方法来访问数据库。
	 * 将数据库的名称指定到getDatabase()方法。如果数据库不存在，MongoDB将在您第一次为该数据库存储数据时创建数据库
	 * 数据库实例不可变
	 */
	MongoDatabase database = mongoClient.getDatabase("mydb");
	
	/**
	 * 
	 * 一旦有了DB实例后，就使用它的getCollection()方法来访问一个集合。
	 * 将集合的名称指定到getCollection()方法。如果一个集合不存在，MongoDB将在您第一次为该集合存储数据时创建集合。
	 */
	
	/**
	 * 例如，使用数据库实例，下面的语句访问mydb数据库中的名为test的集合
	 * 集合不可变
	 */	
	MongoCollection<Document> collection = database.getCollection("test");
	
	
	
	/**
	 * 存入一条数据【插入一个文档对象】
	 */
	
	@Test
	public void SaveOne(){
			

		/**
		 * 有了DB实例、Collection集合后，就该存储文档（数据）了
		 * 要使用Java驱动程序创建文档，请使用Document(文档)类 --org.bson.Document
		 * 要使用Java驱动程序创建文档，实例化一个具有字段和值的文档对象 
		 * new Document(Map<String,Object>) 或者  new Document(key,value)
		 * 并使用其append()方法将其他字段和值包含到文档对象中
		 * 该值可以是另一个文档对象，以指定嵌入的文档
		 */
		
		/**
		 * 数据（含文档套文档） :
{
   "name" : "MongoDB",
   "type" : "nosqlDB",
   "count" : 1,
   "versions": [ "v3.6", "v3.0", "v2.6" ],
   "info" : { x : 203, y : 102 }
}
		 */
		Map<String, Object> map = new HashMap<>();
		map.put("x", 203);
		map.put("y", 102);
		Document document = new Document("name","MongoDB")
				.append("type", "nosqlDB")
				.append("count", 1)
				.append("versions", Arrays.asList("v3.6","v3.0","v2.6"))
				.append("info", new Document(map));
		
		/**
		 * 有了文档对象后，就是向集合collection中保存了 
		 * 也可以批量插入List<Document>，方法为collection.insertMany(documents);
		 */
		
		collection.insertOne(document); 
		
		/**
		 * 要计算集合中的文档数，可以使用集合的count()方法。
		 */
		
		System.err.println("count of documents from collection is :"+collection.count());
		
	}
	
	/**
	 * 无条件取出（查询）第一个文档对象（第一条数据）
	 */
	@Test
	public void findOne(){
		
		Document doc = collection.find().first();
		System.err.println("只取【test】集合中的第一个文档对象："+doc.toJson());
	}
	
	/**
	 * 无条件取出（查询）所有的文档对象（所有数据）
	 */
	@Test
	public void findAll(){
		
		/**
		 * 要检索集合中的所有文档，我们将使用find()方法，而不需要任何参数。
		 * 为了遍历结果，将iterator()方法链接到find()中。
		 * 迭代器类似SQL的游标cursor
		 */
		MongoCursor<Document> cursor = collection.find().iterator();
		try {
			/**
			 * 如果迭代到下一个对象等于false，退出迭代，并关闭迭代器
			 */
			int index = 0;
		    while (cursor.hasNext()) {
		        System.err.println((index+1)+":"+cursor.next().toJson());
		        index++;
		    }
		} finally {
			cursor.close();
		}
		
		System.err.println("=======不推荐下面的遍历法");
		/**
		 * 虽然可以允许迭代使用下面的习惯用法，但避免使用它，因为如果循环提前终止，应用程序可能会泄漏一个游标:
		 */
		for (Document cur : collection.find()) {
		    System.err.println(cur.toJson());
		}
	}
	
	
	/**
	 * 带条件查询文档对象
	 */
	@Test
	public void queryOne(){
		
		/**
		 * 要查询匹配某些条件的文档，请将filter对象传递给find()方法。
		 * 为了方便创建过滤器对象，Mongo-Java驱动程序提供了过滤器帮助器。
		 */
		
		/**
		 * 查询count == 1 的文档对象
		 */
		Document doc = collection.find(eq("count", 1)).first();
		if(doc!=null){
			System.err.println("条件1查询结果："+doc.toJson());
		}else{
			System.err.println("条件1查询结果：无");
		}
		
		
		/**
		 * 查询count<2  且 name.equals("Mongo")的文档对象,显然不存在
		 * 如果查询全部符合条件的文档集合，请使用find(*).iterator()
		 */
		doc = collection.find(and(lt("count",2),eq("name", "Mongo"))).first();
		if(doc!=null){
			System.err.println("条件2查询结果："+doc.toJson());
		}else{
			System.err.println("条件2查询结果：无");
		}
		
		/**
		 * Filters
		 * gt gte  === >  >=
		 * lt lte  === <  <=
		 * eq      === ==
		 * and     === 相当于 sql语句的 where xxx  and xxx
		 * or      === 相当于 sql语句的 where xxx  or  xxx
		 */
		
	}
	
	/**
	 * 更新文档 -- ByOne
	 */
	@Test
	public void updateOne(){
		
		/**
		 * 要更新集合中的文档，使用集合的updateOne方法更新单个文档对象
		 * 
		 * $set  相当于 sql语句的 update collection set type = "database" where name = "MongoDB" limit 1
		 */
		UpdateResult result = collection.updateOne(eq("name", "MongoDB"), new Document("$set", new Document("type", "database")));
		System.err.println("更新影响的行数："+result.getModifiedCount());
				
	}
	
	/**
	 * 批量更新文档 -- ByMany
	 */
	@Test
	public void updateMany(){
		
		/**
		 * 要更新集合中的文档，使用集合的updateMany方法更新所有符合条件的文档对象
		 * 下面更新所有name等于"MongoDB"的文档对象的count属性 +100
		 */
		UpdateResult result = collection.updateMany(eq("name", "MongoDB"), inc("count", 100));
		System.err.println("更新影响的行数："+result.getModifiedCount());

	}
	
	
	/**
	 * 删除文档 -- ByOne
	 */
	@Test
	public void deleteOne(){
		/**
		 * 删除第一个type.equals("nosqlDB")的文档对象
		 */
		DeleteResult result = collection.deleteOne(eq("type", "nosqlDB"));
		System.err.println("删除影响的行数："+result.getDeletedCount());
	}
	
	/**
	 * 批量删除文档 -- ByMany
	 */
	@Test
	public void deleteMany(){
		
		/**
		 * 删除所有count>=100的文档对象
		 */
		DeleteResult result = collection.deleteMany(gte("count", 100));
		System.err.println("删除影响的行数："+result.getDeletedCount());
	}
	
}

注意一个地方

Mongo查询和更新的过滤器，需要引入这两个静态包，别忘啦（除非你拷贝了整个demo）

来几个测试效果图

1、保存单条文档

查询

2、按条件查询

其余不在演示

三、API使用快速入门 ☞ Pojos对象

先来两个Java实体类

Country.java

public final class Country {
	
	private String name;	
	private String province;
	private String city;

	public Country() {
	}
	
	public Country(String name , String pro, String city) {
	   this.name = name ;
	   this.province = pro;
	   this.city = city;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getProvince() {
		return province;
	}

	public void setProvince(String province) {
		this.province = province;
	}

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}

}

Person.java

import org.bson.types.ObjectId;

public final class Person {
	
	/**
	 * MongoDB自动分配的ID
	 */
	private ObjectId id;
    private String name;
    private int age;
    private Country country;

    public Person() {
    }

    public Person(String name , int age,Country country){
    	this.name = name ;
    	this.age  = age  ;
    	this.country = country;
    }
    public ObjectId getId() {
        return id;
    }

    public void setId(final ObjectId id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(final int age) {
        this.age = age;
    }

	public Country getCountry() {
		return country;
	}

	public void setCountry(Country country) {
		this.country = country;
	}

	@Override
    public String toString(){
    	return "name："+name+",age："+age+",国家："+country.getName()+",省/州："
    			+country.getProvince()+",市："+country.getCity();
    }
}

再来个测试用例类

QuickStartPojosTest.java

import static org.bson.codecs.configuration.CodecRegistries.fromProviders;
import static org.bson.codecs.configuration.CodecRegistries.fromRegistries;
import static com.mongodb.client.model.Filters.*;

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

import org.bson.codecs.configuration.CodecProvider;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.codecs.pojo.PojoCodecProvider;
import org.junit.Test;

import com.appleyk.entity.Country;
import com.appleyk.entity.Person;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;


public class QuickStartPojosTest {

	/**
	 * 在使用驱动程序使用POJO之前，您需要配置CodecRegistry以包含一个codecs来处理从bson到POJO的转换
	 * 要做到这一点，最简单的方法是使用PojoCodecProvider.builder()来创建和配置一个CodecProvider
	 * 下面的示例将合并默认的codec注册表，并将PojoCodecProvider配置为自动创建PojoCodecs
	 */

	CodecProvider pojoCodecProvider = PojoCodecProvider.builder().automatic(true).build();
	CodecRegistry pojoCodecRegistry = fromRegistries(MongoClient.getDefaultCodecRegistry(),
			fromProviders(pojoCodecProvider));
	
	/**
	 * 设置pojoCodecRegistry的方法有多种 可以在实例化MongoClient对象时设置它
	 * 1.MongoClient mongoClient = new MongoClient("localhost", MongoClientOptions.builder().codecRegistry(pojoCodecRegistry).build());
	 * 也可以在创建database的时候使用它
	 * 2.database = database.withCodecRegistry(pojoCodecRegistry);
	 * 3.也可以在使用集合的时候使用它
	 * collection = collection.withCodecRegistry(pojoCodecRegistry);
	 */

	/**
	 * 客户端实例不可变
	 */
	MongoClient mongoClient = new MongoClient("localhost", 27017);
	
	/**
	 * 数据库实例不可变
	 */
	MongoDatabase database = mongoClient.getDatabase("mydb").withCodecRegistry(pojoCodecRegistry);

	
	/**
	 * 集合不可变
	 */
	MongoCollection<Person> collection = database.getCollection("people", Person.class);
	
	
	/**
	 * 插入单个Person实体对象
	 */
	@Test
	public void SaveOne() {
		
		Person person = new Person("appleyk", 20, new Country("中国", "河南省", "郑州市"));
		collection.insertOne(person);
		System.err.println("保存成功！");

	}
	
	/**
	 * 批量插入
	 */
	@Test
	public void SaveMany() {
		
	
		List<Person> persons = Arrays.asList(
				 new Person("kobe", 38, new Country("美国", "加利福尼亚州", "洛杉矶市"))
				,new Person("刘翔", 33, new Country("中国", "上海", "上海市")));
				
		collection.insertMany(persons);
		System.err.println("保存成功！");

	}
	
	/**
	 * 查询集合中的第一个pojo对象  === pojos的查询 等同于 documents的查询
	 */
	@Test
	public void findOne(){
		Person person = collection.find().first();
		System.err.println(person);
	}
	
	/**
	 * 根据过滤条件进行单个Person实体对象的查询
	 */
	@Test
	public void queryOne(){
		Person person = collection.find(eq("name","kobe")).first();
		System.err.println(person);
	}
	
	
	/**
	 * ..............此处省略100行代码，自己补充
	 */
}

同理，注意一个地方   --- 静态包的手动引入

效果演示

1、保存多条

其余不再演示

有问题请留言

喜欢的给个赞

------------------------------------------------学习使人快乐！