SpringBoot MongoDB

一、介绍

MongoDB 中有三个比较重要的名词:数据库、集合、文档

  • 数据库(Database):和关系型数据库一样,每个数据库中有自己的用户权限,不同的项目组可以使用不同的数据库
  • 集合(Collection):集合指的是文档组(类似于 MySQL 中的表的概念),里面可以存储许多文档
  • 文档(Document):文档是 MongoDB 中最基本的数据单元,由键值对组成,类似于 JSON 格式,可以存储不同字段,字段的值可以包括其他文档、数组和文档数组

明白这三个名词,基本就可以上手了,以 Java 语言为例,详细的介绍 Java 客户端改如何操作 MongoDB !

二、Java 客户端

2.1、MongoDB 连接

Java 连接 MongoDB 服务器,与常用的连接关系型数据库方式类似!
标准 URI 连接语法:

  1. mongodb://username:password@host1:port1,host2:port2,...,hostN:portN/database?options

参数说明:

  • mongodb://:这是固定的格式,必须要指定
  • username:password@:可选项,如果设置,在连接数据库服务器之后,驱动都会尝试登录这个数据库
  • host1:port1:主机IP和端口号,必须指定至少一个host。如果要连接复制集,请指定多个主机地址
  • /database:如果指定了username:password@,连接时会验证并登录指定数据库。若不指定,默认打开 test 数据库
  • ?options:连接可选项,例如connectTimeoutMS=5000ms,表示连接等待时间最长 5 秒

例如,无密码连接 MongoDB

  1. mongodb://127.0.0.1:27017

使用用户名test,密码test登录 MongoDB 的test_db数据库

  1. mongodb://test:test@127.0.0.1:27017/test_db

无密码连接指定三台服务器 (端口 27017, 27018, 和27019)

  1. mongodb://127.0.0.1:27017,127.0.0.1:27018,127.0.0.1:27019

2.2、添加依赖包

和关系型数据库操作一样,在 Java 程序中如果要使用 MongoDB,先要添加对应的 MongoDB JDBC 驱动器,然后才能继续操作!
在选择的版本号的时候,注意需要和服务器中的安装版本匹配,具体的版本号选择可以从如下地址中获取到最新的版本:mongo-java-driver

  1. <dependency>
  2. <groupId>org.mongodb</groupId>
  3. <artifactId>mongo-java-driver</artifactId>
  4. <version>3.12.7</version>
  5. </dependency>

2.3、连接数据库

连接数据库的 Java 代码如下:

  1. private static MongoClient mongoClient;
  2. static {
  3. try {
  4. //连接到MongoDB服务 如果是远程连接可以替换“localhost”为服务器所在IP地址
  5. mongoClient = MongoClients.create("mongodb://test:test@127.0.0.1:27017/test_db");
  6. System.out.println("Connect to database successfully");
  7. } catch (Exception e) {
  8. System.err.println( e.getClass().getName() + ": " + e.getMessage() );
  9. }
  10. }

上文中采用的是用户名和密码方式登录数据库,因为数据库已经开启了权限验证,因此需要通过用户名和密码才能登录。

2.4、创建集合

com.mongodb.client包里面都集成好了大部分常用的 api,可以通过MongoDatabase类中的createCollection()方法来创建集合。
创建一个tb_role集合,代码片段如下:

  1. /**
  2. * 创建集合
  3. * @param args
  4. */
  5. public static void main(String[] args) {
  6. // 连接到数据库
  7. MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
  8. System.out.println("Connect to database successfully");
  9. mongoDatabase.createCollection("tb_role");
  10. System.out.println("集合创建成功");
  11. }

如果想删除集合,操作也很简单!

  1. /**
  2. * 删除集合
  3. * @param args
  4. */
  5. public static void main(String[] args) {
  6. // 连接到数据库
  7. MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
  8. System.out.println("Connect to database successfully");
  9. mongoDatabase.getCollection("tb_role").drop();
  10. System.out.println("集合 tb_role 删除成功");
  11. }

2.5、创建文档

可以通过MongoCollection类中的insertMany()方法来插入一个文档。
tb_role集合中插入文档,代码片段如下:

  1. /**
  2. * 插入文档
  3. * @param args
  4. */
  5. public static void main(String[] args) {
  6. // 连接到数据库
  7. MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
  8. System.out.println("Connect to database successfully");
  9. //获取集合
  10. MongoCollection<Document> collection = mongoDatabase.getCollection("tb_role");
  11. //向集合中插入文档
  12. Document document = new Document("name", "管理员").
  13. append("code", "manager").
  14. append("sort", 100);
  15. List<Document> documents = new ArrayList<>();
  16. documents.add(document);
  17. collection.insertMany(documents);
  18. System.out.println("文档插入成功");
  19. }

2.6、更新文档

可以通过MongoCollection类中的updateMany()方法来更新集合中的文档。
更新tb_role集合中的指定文档信息,代码片段如下:

  1. /**
  2. * 更新文档
  3. * @param args
  4. */
  5. public static void main(String[] args) {
  6. // 连接到数据库
  7. MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
  8. System.out.println("Connect to database successfully");
  9. //获取集合
  10. MongoCollection<Document> collection = mongoDatabase.getCollection("tb_role");
  11. //更新文档
  12. collection.updateMany(Filters.eq("code", "manager"), new Document("$set",new Document("name","经理")));
  13. //遍历所有文档
  14. FindIterable<Document> findIterable = collection.find();
  15. MongoCursor<Document> mongoCursor = findIterable.iterator();
  16. while(mongoCursor.hasNext()){
  17. System.out.println(mongoCursor.next());
  18. }
  19. }

上文操作类似于 SQL语句中的update tb_role set name = '经理' where code = 'manager'

2.7、删除文档

可以通过MongoCollection类中的deleteOne()或者deleteMany方法来删除集合中的文档。
删除tb_role集合中的指定文档信息,代码片段如下:

  1. /**
  2. * 删除文档
  3. * @param args
  4. */
  5. public static void main(String[] args) {
  6. // 连接到数据库
  7. MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
  8. System.out.println("Connect to database successfully");
  9. //获取集合
  10. MongoCollection<Document> collection = mongoDatabase.getCollection("tb_role");
  11. //删除符合条件的第一个文档
  12. collection.deleteOne(Filters.eq("code", "manager"));
  13. //删除所有符合条件的文档
  14. collection.deleteMany (Filters.eq("code", "manager"));
  15. //遍历所有文档
  16. FindIterable<Document> findIterable = collection.find();
  17. MongoCursor<Document> mongoCursor = findIterable.iterator();
  18. while(mongoCursor.hasNext()){
  19. System.out.println(mongoCursor.next());
  20. }
  21. }

在这里需要注意一下,在删除的时候,官方推荐尽可能先查询一下这个数据是否存在,如果存在,然后在执行删除操作,可以调用findOneAndDelete()方法进行删除!

2.8、查询文档

MongoCollection类中提供了非常丰富的检索文档的方法,例如,可以通过find()方法来获取集合中的所有文档。
检索tb_role集合中的文档信息,代码片段如下:

  1. /**
  2. * 查询文档
  3. * @param args
  4. */
  5. public static void main(String[] args) {
  6. // 连接到数据库
  7. MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
  8. System.out.println("Connect to database successfully");
  9. //获取集合
  10. MongoCollection<Document> collection = mongoDatabase.getCollection("tb_role");
  11. //遍历所有文档
  12. FindIterable<Document> findIterable = collection.find();
  13. MongoCursor<Document> mongoCursor = findIterable.iterator();
  14. while(mongoCursor.hasNext()){
  15. System.out.println(mongoCursor.next());
  16. }
  17. //查询当前集合所有文档数量
  18. long count = collection.countDocuments();
  19. System.out.println("当前文档数量:" + count);
  20. //带条件遍历文档
  21. FindIterable<Document> documentFindIterable = collection.find(Filters.eq("code", "manager"));
  22. MongoCursor<Document> documentMongoCursor = documentFindIterable.iterator();
  23. while(documentMongoCursor.hasNext()){
  24. System.out.println(documentMongoCursor.next());
  25. }
  26. }

三、SpringBoot 整合 MongoDB

采用 SpringBoot 来对接 MongoDB,下面就以常用的几个操作为例来介绍,过程如下!

3.1、创建 SpringBoot 工程,添加 MongoDB 依赖包

  1. <!-- 引入springboot -->
  2. <parent>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-starter-parent</artifactId>
  5. <version>2.1.0.RELEASE</version>
  6. </parent>
  7. <dependency>
  8. <groupId>org.springframework.boot</groupId>
  9. <artifactId>spring-boot-starter-data-mongodb</artifactId>
  10. </dependency>

3.2、添加配置文件

application.properties文件中添加mongodb配置

  1. #配置数据库连接地址
  2. spring.data.mongodb.uri=mongodb://test123:test123@127.0.0.1:27017/test_db

3.3、创建实体类

创建用于示例中测试的实体类Person
其中注解@Document(collection="persons")用于指定当前文档属于集合persons
注解@Id表示当前id字段属于主键类型。

  1. /**
  2. * 使用@Document注解指定集合名称
  3. */
  4. @Document(collection="persons")
  5. public class Person implements Serializable {
  6. private static final long serialVersionUID = -3258839839160856613L;
  7. /**
  8. * 使用@Id注解指定MongoDB中的 _id 主键
  9. */
  10. @Id
  11. private Long id;
  12. private String userName;
  13. private String passWord;
  14. private Integer age;
  15. private Date createTime;
  16. //...get/set
  17. @Override
  18. public String toString() {
  19. return "Person{" +
  20. "id=" + id +
  21. ", userName='" + userName + '\'' +
  22. ", passWord='" + passWord + '\'' +
  23. ", age=" + age +
  24. ", createTime=" + createTime +
  25. '}';
  26. }
  27. }

3.4、操作 MongoDB

Springboot 操作 MongoDB 有两种方式。

  • 第一种方式是采用 Springboot 官方推荐的 JPA 方式,这种操作方式,使用简单但是灵活性比较差。
  • 第二种方式是采用 Spring Data MongoDB 封装的 MongoDB 官方 Java 驱动 MongoTemplate 对 MongoDB 进行操作,这种方式非常灵活,能满足绝大部分需求。

这里将采用第二种方式进行介绍!

3.5、插入文档

MongoTemplate提供了insert()方法,用于插入文档,示例代码如下:

插入文档

没指定集合名称时,会取@Document注解中的集合名称

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 插入文档
  8. * @throws Exception
  9. */
  10. @Test
  11. public void insert() throws Exception {
  12. Person person =new Person();
  13. person.setId(1l);
  14. person.setUserName("张三");
  15. person.setPassWord("123456");
  16. person.setCreateTime(new Date());
  17. mongoTemplate.insert(person);
  18. }
  19. }

自定义集合名称,插入文档

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 自定义集合,插入文档
  8. * @throws Exception
  9. */
  10. @Test
  11. public void insertCustomCollection() throws Exception {
  12. Person person =new Person();
  13. person.setId(1l);
  14. person.setUserName("张三");
  15. person.setPassWord("123456");
  16. person.setCreateTime(new Date());
  17. mongoTemplate.insert(person, "custom_person");
  18. }
  19. }

自定义集合,批量插入文档

如果采用批量插入文档,必须指定集合名称

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 自定义集合,批量插入文档
  8. * @throws Exception
  9. */
  10. @Test
  11. public void insertBatch() throws Exception {
  12. List<Person> personList = new ArrayList<>();
  13. Person person1 =new Person();
  14. person1.setId(10l);
  15. person1.setUserName("张三");
  16. person1.setPassWord("123456");
  17. person1.setCreateTime(new Date());
  18. personList.add(person1);
  19. Person person2 =new Person();
  20. person2.setId(11l);
  21. person2.setUserName("李四");
  22. person2.setPassWord("123456");
  23. person2.setCreateTime(new Date());
  24. personList.add(person2);
  25. mongoTemplate.insert(personList, "custom_person");
  26. }
  27. }

3.6、存储文档

MongoTemplate提供了save()方法,用于存储文档。
在存储文档的时候会通过主键ID进行判断,如果存在就更新,否则就插入,示例代码如下:

存储文档,如果没有插入,否则通过主键ID更新

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 存储文档,如果没有插入,否则更新
  8. * @throws Exception
  9. */
  10. @Test
  11. public void save() throws Exception {
  12. Person person =new Person();
  13. person.setId(13l);
  14. person.setUserName("八八");
  15. person.setPassWord("123456");
  16. person.setAge(40);
  17. person.setCreateTime(new Date());
  18. mongoTemplate.save(person);
  19. }
  20. }

自定义集合,存储文档

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 自定义集合,存储文档
  8. * @throws Exception
  9. */
  10. @Test
  11. public void saveCustomCollection() throws Exception {
  12. Person person =new Person();
  13. person.setId(1l);
  14. person.setUserName("张三");
  15. person.setPassWord("123456");
  16. person.setCreateTime(new Date());
  17. mongoTemplate.save(person, "custom_person");
  18. }
  19. }

3.7、更新文档

MongoTemplate提供了updateFirst()updateMulti()方法,用于更新文档,示例代码如下:

更新文档,匹配查询到的文档数据中的第一条数据

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 更新文档,匹配查询到的文档数据中的第一条数据
  8. * @throws Exception
  9. */
  10. @Test
  11. public void updateFirst() throws Exception {
  12. //更新对象
  13. Person person =new Person();
  14. person.setId(1l);
  15. person.setUserName("张三123");
  16. person.setPassWord("123456");
  17. person.setCreateTime(new Date());
  18. //更新条件
  19. Query query= new Query(Criteria.where("id").is(person.getId()));
  20. //更新值
  21. Update update= new Update().set("userName", person.getUserName()).set("passWord", person.getPassWord());
  22. //更新查询满足条件的文档数据(第一条)
  23. UpdateResult result =mongoTemplate.updateFirst(query,update, Person.class);
  24. if(result!=null){
  25. System.out.println("更新条数:" + result.getMatchedCount());
  26. }
  27. }
  28. }

更新文档,匹配查询到的文档数据中的所有数据

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 更新文档,匹配查询到的文档数据中的所有数据
  8. * @throws Exception
  9. */
  10. @Test
  11. public void updateMany() throws Exception {
  12. //更新对象
  13. Person person =new Person();
  14. person.setId(1l);
  15. person.setUserName("张三");
  16. person.setPassWord("123456");
  17. person.setCreateTime(new Date());
  18. //更新条件
  19. Query query= new Query(Criteria.where("id").is(person.getId()));
  20. //更新值
  21. Update update= new Update().set("userName", person.getUserName()).set("passWord", person.getPassWord());
  22. //更新查询满足条件的文档数据(全部)
  23. UpdateResult result = mongoTemplate.updateMulti(query, update, Person.class);
  24. if(result!=null){
  25. System.out.println("更新条数:" + result.getMatchedCount());
  26. }
  27. }
  28. }

3.8、删除文档

MongoTemplate提供了remove()findAndRemove()findAllAndRemove()方法,用于删除文档,示例代码如下:

删除符合条件的所有文档

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 删除符合条件的所有文档
  8. * @throws Exception
  9. */
  10. @Test
  11. public void remove() throws Exception {
  12. Person person =new Person();
  13. person.setId(1l);
  14. person.setUserName("张三");
  15. person.setPassWord("123456");
  16. person.setCreateTime(new Date());
  17. Query query = new Query(Criteria.where("userName").is(person.getUserName()));
  18. DeleteResult result = mongoTemplate.remove(query, Person.class);
  19. System.out.println("删除条数:" + result.getDeletedCount());
  20. }
  21. }

删除符合条件的单个文档,并返回删除的文档

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 删除符合条件的单个文档,并返回删除的文档
  8. * @throws Exception
  9. */
  10. @Test
  11. public void findAndRemove() throws Exception {
  12. Person person =new Person();
  13. person.setId(1l);
  14. person.setUserName("张三");
  15. person.setPassWord("123456");
  16. person.setCreateTime(new Date());
  17. Query query = new Query(Criteria.where("id").is(person.getId()));
  18. Person result = mongoTemplate.findAndRemove(query, Person.class);
  19. System.out.println("删除的文档数据:" + result.toString());
  20. }
  21. }

删除符合条件的所有文档,并返回删除的文档

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 删除符合条件的所有文档,并返回删除的文档
  8. * @throws Exception
  9. */
  10. @Test
  11. public void findAllAndRemove() throws Exception {
  12. Person person =new Person();
  13. person.setId(1l);
  14. person.setUserName("张三");
  15. person.setPassWord("123456");
  16. person.setCreateTime(new Date());
  17. Query query = new Query(Criteria.where("id").is(person.getId()));
  18. List<Person> result = mongoTemplate.findAllAndRemove(query, Person.class);
  19. System.out.println("删除的文档数据:" + result.toString());
  20. }
  21. }

3.9、查询文档

MongoTemplate提供了非常多的文档查询方法,日常开发中用的最多的就是find()方法,示例代码如下:

查询集合中的全部文档数据

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 查询集合中的全部文档数据
  8. * @throws Exception
  9. */
  10. @Test
  11. public void findAll() throws Exception {
  12. List<Person> result = mongoTemplate.findAll(Person.class);
  13. System.out.println("查询结果:" + result.toString());
  14. }
  15. }

查询集合中指定的ID文档数据

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 查询集合中指定的ID文档数据
  8. * @throws Exception
  9. */
  10. @Test
  11. public void findById() {
  12. long id = 1l;
  13. Person result = mongoTemplate.findById(id, Person.class);
  14. System.out.println("查询结果:" + result.toString());
  15. }
  16. }

根据条件查询集合中符合条件的文档,返回第一条数据

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 根据条件查询集合中符合条件的文档,返回第一条数据
  8. */
  9. @Test
  10. public void findOne() {
  11. String userName = "张三";
  12. Query query = new Query(Criteria.where("userName").is(userName));
  13. Person result = mongoTemplate.findOne(query, Person.class);
  14. System.out.println("查询结果:" + result.toString());
  15. }
  16. }

根据条件查询集合中符合条件的文档

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 根据条件查询集合中符合条件的文档
  8. */
  9. @Test
  10. public void findByCondition() {
  11. String userName = "张三";
  12. Query query = new Query(Criteria.where("userName").is(userName));
  13. List<Person> result = mongoTemplate.find(query, Person.class);
  14. System.out.println("查询结果:" + result.toString());
  15. }
  16. }

根据【AND】关联多个查询条件,查询集合中的文档数据

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 根据【AND】关联多个查询条件,查询集合中的文档数据
  8. */
  9. @Test
  10. public void findByAndCondition() {
  11. // 创建条件
  12. Criteria criteriaUserName = Criteria.where("userName").is("张三");
  13. Criteria criteriaPassWord = Criteria.where("passWord").is("123456");
  14. // 创建条件对象,将上面条件进行 AND 关联
  15. Criteria criteria = new Criteria().andOperator(criteriaUserName, criteriaPassWord);
  16. // 创建查询对象,然后将条件对象添加到其中
  17. Query query = new Query(criteria);
  18. List<Person> result = mongoTemplate.find(query, Person.class);
  19. System.out.println("查询结果:" + result.toString());
  20. }
  21. }

根据【OR】关联多个查询条件,查询集合中的文档数据

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 根据【OR】关联多个查询条件,查询集合中的文档数据
  8. */
  9. @Test
  10. public void findByOrCondition() {
  11. // 创建条件
  12. Criteria criteriaUserName = Criteria.where("userName").is("张三");
  13. Criteria criteriaPassWord = Criteria.where("passWord").is("123456");
  14. // 创建条件对象,将上面条件进行 OR 关联
  15. Criteria criteria = new Criteria().orOperator(criteriaUserName, criteriaPassWord);
  16. // 创建查询对象,然后将条件对象添加到其中
  17. Query query = new Query(criteria);
  18. List<Person> result = mongoTemplate.find(query, Person.class);
  19. System.out.println("查询结果:" + result.toString());
  20. }
  21. }

根据【IN】关联多个查询条件,查询集合中的文档数据

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 根据【IN】关联多个查询条件,查询集合中的文档数据
  8. */
  9. @Test
  10. public void findByInCondition() {
  11. // 设置查询条件参数
  12. List<Long> ids = Arrays.asList(1l, 10l, 11l);
  13. // 创建条件
  14. Criteria criteria = Criteria.where("id").in(ids);
  15. // 创建查询对象,然后将条件对象添加到其中
  16. Query query = new Query(criteria);
  17. List<Person> result = mongoTemplate.find(query, Person.class);
  18. System.out.println("查询结果:" + result.toString());
  19. }
  20. }

根据【逻辑运算符】查询集合中的文档数据

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 根据【逻辑运算符】查询集合中的文档数据
  8. */
  9. @Test
  10. public void findByOperator() {
  11. // 设置查询条件参数
  12. int min = 20;
  13. int max = 35;
  14. Criteria criteria = Criteria.where("age").gt(min).lte(max);
  15. // 创建查询对象,然后将条件对象添加到其中
  16. Query query = new Query(criteria);
  17. List<Person> result = mongoTemplate.find(query, Person.class);
  18. System.out.println("查询结果:" + result.toString());
  19. }
  20. }

根据【正则表达式】查询集合中的文档数据

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 根据【正则表达式】查询集合中的文档数据
  8. */
  9. @Test
  10. public void findByRegex() {
  11. // 设置查询条件参数
  12. String regex = "^张*";
  13. Criteria criteria = Criteria.where("userName").regex(regex);
  14. // 创建查询对象,然后将条件对象添加到其中
  15. Query query = new Query(criteria);
  16. List<Person> result = mongoTemplate.find(query, Person.class);
  17. System.out.println("查询结果:" + result.toString());
  18. }
  19. }

根据条件查询集合中符合条件的文档,获取其文档列表并排序

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 根据条件查询集合中符合条件的文档,获取其文档列表并排序
  8. */
  9. @Test
  10. public void findByConditionAndSort() {
  11. String userName = "张三";
  12. Query query = new Query(Criteria.where("userName").is(userName)).with(Sort.by("age"));
  13. List<Person> result = mongoTemplate.find(query, Person.class);
  14. System.out.println("查询结果:" + result.toString());
  15. }
  16. }

根据单个条件查询集合中的文档数据,并按指定字段进行排序与限制指定数目

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 根据单个条件查询集合中的文档数据,并按指定字段进行排序与限制指定数目
  8. */
  9. @Test
  10. public void findByConditionAndSortLimit() {
  11. String userName = "张三";
  12. //从第一行开始,查询2条数据返回
  13. Query query = new Query(Criteria.where("userName").is(userName)).with(Sort.by("createTime")).limit(2).skip(1);
  14. List<Person> result = mongoTemplate.find(query, Person.class);
  15. System.out.println("查询结果:" + result.toString());
  16. }
  17. }

统计集合中符合【查询条件】的文档【数量】

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 统计集合中符合【查询条件】的文档【数量】
  8. */
  9. @Test
  10. public void countNumber() {
  11. // 设置查询条件参数
  12. String regex = "^张*";
  13. Criteria criteria = Criteria.where("userName").regex(regex);
  14. // 创建查询对象,然后将条件对象添加到其中
  15. Query query = new Query(criteria);
  16. long count = mongoTemplate.count(query, Person.class);
  17. System.out.println("统计结果:" + count);
  18. }
  19. }

4.0、创建索引

索引在所有的数据库中,暂居的位置非常重要,例如检索一张上百万的数据表的时候,如果没走索引,查询效率会极其缓慢,对于 MongoDB 来说,同样如此。
示例如下:

创建升序索引

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 创建升序索引
  8. */
  9. @Test
  10. public void createAscendingIndex() {
  11. // 设置字段名称
  12. String field = "userName";
  13. // 创建索引
  14. mongoTemplate.getCollection("persons").createIndex(Indexes.ascending(field));
  15. }
  16. }

移除索引

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 根据索引名称移除索引
  8. */
  9. @Test
  10. public void removeIndex() {
  11. // 设置字段名称
  12. String field = "userName";
  13. // 删除索引
  14. mongoTemplate.getCollection("persons").dropIndex(field);
  15. }
  16. }

查询集合中所有的索引

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class PersonServiceTest {
  4. @Autowired
  5. private MongoTemplate mongoTemplate;
  6. /**
  7. * 查询集合中所有的索引
  8. */
  9. @Test
  10. public void getIndexAll() {
  11. // 获取集合中所有列表
  12. ListIndexesIterable<Document> indexList = mongoTemplate.getCollection("persons").listIndexes();
  13. // 获取集合中全部索引信息
  14. for (Document document : indexList) {
  15. System.out.println("索引列表:" + document);
  16. }
  17. }
  18. }

通过在实体类上加注解方式来创建索引

  1. /**
  2. * 使用@Document注解指定集合名称
  3. */
  4. @Document(collection="persons")
  5. public class Person implements Serializable {
  6. private static final long serialVersionUID = -3258839839160856613L;
  7. /**
  8. * 使用@Id注解指定MongoDB中的 _id 主键
  9. */
  10. @Id
  11. private Long id;
  12. private String userName;
  13. private String passWord;
  14. private Integer age;
  15. /**
  16. * 创建一个5秒之后文档自动删除的索引
  17. */
  18. @Indexed(expireAfterSeconds=5)
  19. private Date createTime;
  20. //...get/set
  21. @Override
  22. public String toString() {
  23. return "Person{" +
  24. "id=" + id +
  25. ", userName='" + userName + '\'' +
  26. ", passWord='" + passWord + '\'' +
  27. ", age=" + age +
  28. ", createTime=" + createTime +
  29. '}';
  30. }
  31. }

4.1、引入 MongoDB 中的事务

单节点 mongodb 不支持事务,需要搭建 MongoDB 复制集。

  1. /**
  2. * 配置事务管理器
  3. *
  4. */
  5. @Configuration
  6. public class TransactionConfig {
  7. @Bean
  8. MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) {
  9. return new MongoTransactionManager(dbFactory);
  10. }
  11. }

事务服务测试!

  1. @Service
  2. public class TransactionExample {
  3. @Autowired
  4. private MongoTemplate mongoTemplate;
  5. @Transactional(rollbackFor = Exception.class)
  6. public Object transactionTest(){
  7. Person person =new Person();
  8. person.setId(1l);
  9. person.setUserName("张三");
  10. person.setPassWord("123456");
  11. person.setCreateTime(new Date());
  12. Person newPerson = mongoTemplate.insert(person);
  13. // 抛出异常,观察数据是否进行回滚
  14. if(1 == 1){
  15. throw new RuntimeException("异常");
  16. }
  17. return newPerson;
  18. }
  19. }