Spring Data MongoDB方法使用总结

最新推荐文章于 2024-04-29 01:00:00 发布

dglsx123

最新推荐文章于 2024-04-29 01:00:00 发布

阅读量1.4k

点赞数

分类专栏： Spring Data 文章标签： Spring Data MongoDB

本文链接：https://blog.csdn.net/dglsx123/article/details/103134976

版权

Spring Data 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.概述

Spring Data MongoDB 是Spring框架访问mongodb的神器，借助它可以非常方便的读写mongo库。本文介绍使用Spring Data MongoDB来访问mongodb数据库的几种方法：

使用Query和Criteria类
JPA自动生成的查询方法
使用@Query 注解基于JSON查询

1.1 添加maven依赖

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
    <version>2.2.2.RELEASE</version>
  </dependency>

2.使用Query和Criteria类查询DB

对于这一种方式，我将分一下几点来详细给大家具体的使用方法。

is查询
in查询
正则查询（模糊匹配）
LT和GT
Criteria类方法总结
排序
分页
特殊场景一：Criteria.orOperator
特殊场景二：Query.fields().exclude(“messageText”)
MongoTemplate.find()与MongoTemplate.count()

2.1 is查询

在以下示例中 - 我们正在寻找名为Eric的用户。

我们来看看我们的数据库：

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 55
    }
}]

让我们看看查询代码：

Query query = new Query();
query.addCriteria(Criteria.where("name").is("Eric"));
List<User> users = mongoTemplate.find(query, User.class);

如预期的那样，这个逻辑返回：

{
    "_id" : ObjectId("55c0e5e5511f0a164a581907"),
    "_class" : "org.baeldung.model.User",
    "name" : "Eric",
    "age" : 45
}

2.2 in查询

当我们需要查询name为“Eric”和“Antony”的User时，需要使用到in查询。
首先我们来看看我们的数据库：

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

我们来创建查询：

Query query = new Query();
List<String> names = Arrays.asList("Eric","Antony");
query.addCriteria(Criteria.where("name").in(names));
List<User> users = mongoTemplate.find(query,User.class);

这运行并返回2条记录：

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    }
]

2.3 正则查询（模糊匹配）

正则表达式是一个更灵活和强大的查询类型。这使用了一个使用MongoDB $ regex的标准，该标准返回适用于这个字段的这个正则表达式的所有记录。

它的作用类似于startingWith，endingWith操作 - 让我们来看一个例子。

寻找名称以A开头的所有用户，这是数据库的状态：

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

我们来创建查询：

Query query = new Query();
query.addCriteria(Criteria.where("name").regex("^A"));
List<User> users = mongoTemplate.find(query,User.class);

这运行并返回2条记录：

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

下面是另一个简单的例子，这次查找名称以c结尾的所有用户：

Query query = new Query();
query.addCriteria(Criteria.where("name").regex("c$"));
List<User> users = mongoTemplate.find(query, User.class);

所以结果是：

{
    "_id" : ObjectId("55c0e5e5511f0a164a581907"),
    "_class" : "org.baeldung.model.User",
    "name" : "Eric",
    "age" : 45
}

2.4 LT和GT

$ lt（小于）运算符和$ gt（大于）。

让我们快速看一个例子 - 我们正在寻找年龄在20岁到50岁之间的所有用户。

数据库是

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 55
    }
}

构造查询：

Query query = new Query();
query.addCriteria(Criteria.where("age").lt(50).gt(20));
List<User> users = mongoTemplate.find(query,User.class);

结果 - 年龄大于20且小于50的所有用户：

{
    "_id" : ObjectId("55c0e5e5511f0a164a581907"),
    "_class" : "org.baeldung.model.User",
    "name" : "Eric",
    "age" : 45
}

2.5 Criteria类方法总结

通过查看Criteria类的源码，发现它还有很多类似的方法，这里我把常用的几种以表格形式总结如下：

Criteria类方法	对应字符串
Criteria.ne()	$ne ----> 不等于
Criteria.lte()	$lte ----> 小于等于
Criteria.gte()	$ne ----> 大于等于
Criteria.exists()	$exists ----> 是否存在

2.6 排序

Sort用于指定结果的排序顺序。

首先 - 这里是现有的数据：

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

执行排序后：

Query query = new Query();
query.with(new Sort(Sort.Direction.ASC, "age"));
List<User> users = mongoTemplate.find(query,User.class);

这是查询的结果 - 很好地按年龄排序：

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    }
]

2.7 分页

我们来看一个使用分页的简单例子。

这是数据库的状态：

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

现在，查询逻辑，只需要一个大小为2的页面：

final Pageable pageableRequest = new PageRequest(0, 2);
Query query = new Query();
query.with(pageableRequest);

结果：

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    }
]

2.8 特殊场景一：Criteria.orOperator

假设这样一个场景：有一个Student类，这个类里面有一个字段Score，这个Score本身又是一个类，里面包含languageScore、mathScore, englishScore三个字段。现在需要查询任何一科分数等于90的Student，这时就需要用到Criteria.orOperator。具体的写法如下：

Criteria criteria = new Criteria();
criteria.orOperator(Criteria.where("Score.languageScore").is(90),
                    Criteria.where("Score.mathScore").is(90),
                    Criteria.where("Score.englishScore").is(90));
Query query = new Query(criteria );
List<Student> students = mongoTemplate.find(query,Student.class);

2.9 特殊场景二：Query.fields().exclude(“field”)

假设这样一个场景：有一个Student类，它里面有name、age、describle、height等字段，其中describle字段代表对这个学生的描述，一般内容比较长。于是，当我们在查询Student时，我并不是很关注describle信息，这时为了提高提高前台查询显示的效率，我们可以使用Query.fields().exclude(“dexcrible”)，去忽略这个字段。这样最后返回的Student集合中将不会包含这一个字段信息。具体代码如下：

Criteria criteria = new Criteria();
criteria.orOperator(Criteria.where("Score.languageScore").is(90),
                    Criteria.where("Score.mathScore").is(90),
                    Criteria.where("Score.englishScore").is(90));
Query query = new Query(criteria );
query.fields().exclude("dexcrible");
List<Student> students = mongoTemplate.find(query,Student.class);

2.10 MongoTemplate.count()

当我们只关注查询的记录数目时，可以使用MongoTemplate.count()这一个方法，十分方便，而不用等查询出来在去统计个数。

更多关于MongoTemplate的方法可以查看MongoTemplate类的源码，一般可以通过方法的命名就知道所实现的功能。

3. JPA自动生成的查询方法

生成查询方法是JPA的一个特性，在Spring Data Mongodb里也可以使用。

要做到2里功能，只需要在接口上声明方法即可，

public interface UserRepository 
  extends MongoRepository<User, String>, QueryDslPredicateExecutor<User> {
    ...
}

3.1 FindByX

我们将通过探索findBy类型的查询来简单地开始 - 在这种情况下，通过名称查找：

List<User> findByName(String name);

与上一节相同 2.1 - 查询将具有相同的结果，查找具有给定名称的所有用户：

List<User> users = userRepository.findByName("Eric");

3.2 StartingWith and endingWith

下面是操作过程的一个简单例子：

List<User> findByNameStartingWith(String regexp);

List<User> findByNameEndingWith(String regexp);

实际使用这个例子当然会非常简单：

List<User> users = userRepository.findByNameStartingWith("A");
List<User> users = userRepository.findByNameEndingWith("c");

结果是完全一样的。

3.3 Between

类似于2.3，这将返回年龄在ageGT和ageLT之间的所有用户：

List<User> findByAgeBetween(int ageGT, int ageLT);
List<User> users = userRepository.findByAgeBetween(20, 50);

3.4 Like和OrderBy

让我们来看看这个更高级的示例 - 为生成的查询组合两种类型的修饰符。

我们将要查找名称中包含字母A的所有用户，我们也将按年龄顺序排列结果：

List<User> users = userRepository.findByNameLikeOrderByAgeAsc("A");

结果：

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

3.5 总结

关于这一类，比较麻烦的地方就是不知道有哪些方法是JPA自动生成的。除了通过idea的提示可以做一部分判断，另一个方法还是要通过查看源码来判断。通过查看代码，发现每个类的Repository类都会继承MongoRepository，而MongoRepository继承了PagingAndSortingRepository，PagingAndSortingRepository继承CrudRepository，CrudRepository继承Repository。所以这几个Repository中已经有的方法都是JPA可以自动生成的。使用某一具体方法时可以在这几个Repository中查找是否有对应方法

3.6 注意

在这里我们需要区分两种情况：一种是；本身的Repository类继承的那一些Repository提供的基本的数据操作方法，包含基本的增删改查、分页查询、排序查询等，对于这一种，在创建的Repository类中是不需要再申明方法的。另一种是我们可以自己写一些简单的方法，这些方法只需要符合Spring Data制定的那一类规范就能被其识别出来，对于这一种就需要在Repository类中声明方法。
在前面这两种方法都不能满足你的需要时，就需要用到下面这种@Query方式了。

4. 使用@Query 注解基于JSON查询

如果我们无法用方法名称或条件来表示查询，那么我们可以做更低层次的事情 - 使用@Query注解。

通过这个注解，我们可以指定一个原始查询 - 作为一个Mongo JSON查询字符串。

4.1 FindBy

让我们先从简单的，看看我们是如何将是一个通过查找类型的方法第一：

@Query("{ 'name' : ?0 }")
List<User> findUsersByName(String name);

这个方法应该按名称返回用户 - 占位符?0引用方法的第一个参数。

4.2 $regex

让我们来看一个正则表达式驱动的查询 - 这当然会产生与2.2和3.2相同的结果：

@Query("{ 'name' : { $regex: ?0 } }")
List<User> findUsersByRegexpName(String regexp);

用法也完全一样：

List<User> users = userRepository.findUsersByRegexpName("^A");
List<User> users = userRepository.findUsersByRegexpName("c$");

4.3 $ lt和$ gt

现在我们来实现lt和gt查询：

@Query("{ 'age' : { $gt: ?0, $lt: ?1 } }")
List<User> findUsersByAgeBetween(int ageGT, int ageLT);

4.3 其他

排序
一下语句代表按照updatedDate字段正序排序。

@Query(value = "{'exceptionStatus':'UNPROCESSED','forceReprocess':true}", sort = "{'updatedDate':1}")

当为sort = "{‘updatedDate’:-1}时，代表逆序

表中含有类的字段时

@Query(value = "{?#{'Score.'+[0]}:?1 ,'status': ?2 }",sort = "{'age':1}")

上面的[0]代表Score类里面的某个字段属性（可能为languageScore、mathScore, englishScore,[1]代表具体的查询分数

以上就是Spring Data MongoDB方法的几种情况总结。本文有参考如下链接：

https://www.cnblogs.com/xiaoqi/p/queries-in-spring-data-mongodb.html
https://docs.spring.io/spring-data/mongodb/docs/2.2.2.RELEASE/reference/html/#reference

dglsx123

关注

0
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Spring Data MongoDB方法使用总结

1.概述Spring Data MongoDB 是Spring框架访问mongodb的神器，借助它可以非常方便的读写mongo库。本文介绍使用Spring Data MongoDB来访问mongodb数据库的几种方法：使用Query和Criteria类JPA自动生成的查询方法使用@Query 注解基于JSON查询1.1 添加maven依赖<dependency> ...
复制链接

扫一扫