Spring data mongodb (mongoTemplate)_spring.data.mongodb.database-CSDN博客

本文链接：https://blog.csdn.net/qq_34505594/article/details/119972194

本文详细介绍了如何在SpringBoot应用中集成MongoDB，包括依赖管理、配置、实体类映射、数据的增删改查操作，以及查询条件、排序、分页和聚合操作。示例代码详尽展示了各种操作方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.依赖管理

底层是mongoDriver

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifateId>spring-boot-starter-parent</artifactId>
   <version>2.3.2.RELEASE</version>
</parent>

<dependencies>
<dependency>
 		<groupId>org.springframework.boot</groupId>
   		 <artifateId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
</dependencies>

2.application.yml

spring.data.mongodb.host

spring.data.mongodb.port

spring.data.mongodb.database

spring.data.mongodb.userName

spring.data.mongodb.password

spring.data.mongodb.authentication-database

#spring-data-mongodb 会准备mongotemplate提供mong远程操作

3.mongotemplate提供mongo远程访问的方法

4.定义实体类，对应mongo中的集合collection

1）@Document注解，org.springframework.data.mongodb.core.mapping。

例如 @Document("order")，其中value：order对应mongo集合命名。命名规则：类名首字母转小写。例如Order-order, EgoItem-egoItem

2）spring data mongodb 对数据和实体对象的映射处理是基于property的，需要为实体类型提供getter和setter方法

3）主键字段，可以使用注解Id字段，代表该字段是主键字段。

如果属性命名是id或_id，注解可以省略

mongdb中，默认的主键类型是ObjectId,对应java中的类型是String或ObjectId（是Bson包中的）org.bson.types

如果java实体中使用字符串类型作为主键，映射的mongodb默认主键方式是

mongodb - ObjectId("xxxxxxxx")

java对象 -"xxxxxxxxxxxxxx"

@Id

private String id;

4）可以使用注解field描述属性，用于配置java实体属性和mongodb集合field字段的映射关系，默认映射关系是同名映射

@Field（"title"）

private String title;

5.新增

T insert(T pojo) //使用注解配置或默认映射机制，实现数据新增。返回新增处理后的对象，如果有自动主键生成，赋值并返回。

T insert(Collection pojos, Class clazz) //批量新增，集合中每个对象的类型都是clazz，对应同一个注解配置或者默认映射

T insert(T pojo, String collectionName) //使用注解配置（除@Document之外）或者默认映射，向指定的collection中新增数据

mongTemplate.insert()

_class 反向查询的时候，可以进行快速数据转换 //有待研究

6.修改 - 全量替换 | 覆盖

使用save方法，用于保存数据。如果数据不包含主键信息，则一定是新增。

如果数据包含主键信息，则匹配检查，相同覆盖，不同新增。

mongoTemplate.save()

修改 - 表达式更新

$set $inc $push等

updateXXX 是基于BSON执行的修改操作，不是基于实体对象的修改操作。save和insert是基于实体对象的。

updateFirst - 相当于db.collection.update({},{},{"multiple":flase})

updateMulti - 相当于db.collection.update({},{},{"multiple":true})

参数

UpdateResult updateFirst(Query query, Update update, Class clazz) //查询条件，修改条件，类型

根据实体类中的注解配置或者默认映射，实现修改

UpdateResult updateFirst(Query query, Update update, String collectionName)

Class | String参数，映射的是Query中的条件字段名，Class使用实体类中的属性名，String使用集合中的字段名

@Test

public void testUpdate(){

        Query query = new Query( //mongo.core包

                Criteria.where("title").is("o2");

        );

        //{$set:{"title":"更新数据"}},最常用的更新策略就是$set

        Update update = Update.update("title","更新数据");

        UpdataResult res = mongoTemplate.update(query, update, Order.class);

        // res.getMatchedCount() 匹配了多少行数据

        // res.getModifiedCount() 修改了多少行数据

        Query multiQuery = new Query();

        Criteria c = Critreia.where("title").in("o3","o4");

        multiQuery.addCrietria(c);

        Update multiUpdate = new Update();

        multiUpdate.set("title","批量更新");

        UpdateResult multiResult = mongoTemplate.updateMulti(mutiQuery, multiUpdate, Order.class);

        // multiResult.getMatchedCount() 匹配了多少行数据

        // multiResult.getModifiedCount() 修改了多少行数据

}

7.删除

删除 - 主键删除

remove(Object pojo) 使用pojo对象中的主键作为条件，删除数据

删除 - 全删除

remove(Class clazz) 直接删除类型对应的集合中的全部数据

删除 - 条件删除

remove(Query query) 根据条件删除匹配的数据

注意：直接new Query()作为条件，就是删除全部

@Test

public void testDeleteById(){

    Order o = new Order();

    o.setId("1111111");

    o.setTitle("title");

    DeleteResutl res = mongTemplate.remove(o);

    Query query = new Query(

    Criteria.where("payment").lt(100).gt(30) //{"$and": [{"$gt":30},{"$lt":100}]}

    );
    
    mongTemplate.remove(query, Order.class);

}

8.查询

查询 - 全部

findAll(Class clazz)

根据类型的注解或者默认映射，查询集合全部数据，封装成list集合，泛型是Class对应类型

findAll(Class clazz, String collectionName)

查询collectionName对应的集合，查询结果封装为Class对应类型的对象，并保存在list集合中返回

@Test

public void testFindAll(){

    List order = mongoTemplate.findAll(Order.class);

    printList(order);

    List otherOrders = mongoTemplate.findAll(Order.class, "order");

}

查询单一对象 - 主键查询

T findById(Object id, Class clazz);

使用逐渐作为查询条件，到clazz对应的集合中，查询单一数据

例如 Order order = mongoTemplate.findById("5485511", Order.class);

查询单一对象 -条件查询

T findOne(Query query, Class clazz);

到clazz对应的集合中，按照条件查询，并返回第一个匹配成功的数据。

直接new Query()相当于查询全部

条件查询

无条件查询全部

List find(Query query, Class clazz);

List orders = mongoTemplate.find(new Query(), Order.class):

条件查询 - 等值查询不等值查询

//等值查询

Query query = new Qury(

Criteria.where("payment").is(100)

);

List orders = mongoTemplate.find(query, Order.class);

//不等值查询

Query query = new Qury(

Criteria.where("payment").ne(100)

);

List orders = mongoTemplate.find(query, Order.class);

//不等值查询范围条件 100 < payment < 300

Query query = new Qury(

Criteria.where("payment").gt(100).lt(300)

);

List orders = mongoTemplate.find(query, Order.class);

//条件查询 in | not in | exists

Query query = new Qury(

Criteria.where("title").in("title2","title1")

);

List orders = mongoTemplate.find(query, Order.class);

Query query = new Qury(

Criteria.where("title").nin("title2","title1")

);

List orders = mongoTemplate.find(query, Order.class);

// title exists

Query query = new Qury(

Criteria.where("title").exists(true)

);

List orders = mongoTemplate.find(query, Order.class);

//条件查询 - 正则表达式

// 以‘测试’开头的数据,内容和mongo客户端中的一致。

//mongo客户端中 /表示开始和结束，java代码中不需要标记正则表达式的范围

Query query = new Qury(

Criteria.where("title").regex("^测试")

);

List orders = mongoTemplate.find(query, Order.class);

//条件查询 - 去除重复数据

List findsDistinct(Query query, String fieldName, Class pojoClass, Class fieldClass)

去重查询，是去除一个字段的重复数据，返回的是去除重复数据后的字段值的集合。类似投影

投影的是去除重复数据的字段

fieldName - 投影字段名，去除重复数据的字段名

pojoClass - 访问的集合对应的实体类型，检索Class中的注解或使用默认映射，找集合

fieldClass - 投影字段类型

Query query = new Qury();

List result = mongoTemplate.findDistinct(query, "titile", Order.class, String.class);

//条件查询 - 复合查询 and | or

如果多个条件对应字段相同，可以简化查询条件

混合条件，代表一个字段有多个条件，满足其一即可

如果是数学范围，则是满足全部条件 lt().gt()

！！！！！自行验证。

Query query = new Qury(

Criteria.where("title").is("测试").regex("2$") //title是测试或以2结尾

);

mongoTempalte.find(query, Order.class);

//多个条件字段不同，使用andOperator实现

Query query = new Qury(

new Criteria().andOperator(

Criteria.where("title").regex("测试"),

Criteria.where("payment").lt(300),

Criteria.where("payment").gte(20)

)

);

mongoTemplate.find(query,Order.class);

//条件查询 - 复合条件 or 使用orOperator

Query query = new Qury(

new Criteria().orOperator(

Criteria.where("title").regex("测试"),

Criteria.where("payment").lt(300),

Criteria.where("payment").gte(20)

)

);

mongoTemplate.find(query,Order.class);

//条件查询 - 复合条件 and + or 注意嵌套

Critieria and1 = new Criteria().andOpeator(

Criteria.where("title").is("测试"),

Criteria.where("payment").lt(1000)

);

Critieria and2 = new Criteria().andOpeator(

Criteria.where("title").is("测试2"),

Criteria.where("payment").lt(1000)

);

Query query = new Query(

new Criteria().orOperator(

and1, and2

)

);

mongoTemplate.find(query,Order.class);

Query query = new Qury(

new Criteria().orOperator(

Criteria.where("title").regex("测试"),

Criteria.where("payment").lt(300),

Criteria.where("payment").gte(20)

)

);

mongoTemplate.find(query,Order.class);

9.排序

Query query = new Query();

//默认升序

Sort sort = Sort.by(Sort.Direction.DESC, "titile"); //org.springframework.data.domain

query.with(sort);

mongoTemplate.find(quert,Order.class);

//多字段排序

Query query = new Query();

Sort sort = Sort.by(Sort.Order.desc("title"), Sort.Order.asc("payment"));

query.with(sort);

mongoTemplate.find(query, Order.class);

10.分页

Query query = new Query();

query.with(

PageRequest.of(page:0,size:3)

)； //查询第1页，每页查询3条数据

mongoTemplate.find(query, Order.class);

//分页 + 排序

Query query = new Query();

query.with(

PageRequest.of(page:0,size:3,Sort.by(Sort.Direction.ASC, "payment"))

);

mongoTemplate.find(query, Order.class);

11.聚合

aggregate(TypedAggregation,Class) //class通常为Map

TypedAggregation - 聚合逻辑

TypedAggregation.newAggregation(

Class, Aggregation...

);

例如 //需要注意前后顺序

TypedAggregation typedAggregation =

TypedAggregation.newAggregation(Order.class,

Aggregation.match(Criteria.where("payment").gt(120));

Aggregation.group("title").cout().as("rows") //除此之外，还可以排序和分页

);

AggregationResultresult = mongoTemplate.aggregate(typedAggregation, Map.class);

result.getUniqueMappedResult(); //返回聚合后的单行数据，如果聚合结果是多行，抛出异常

Listmaps = result.getMappedResults(); //返回聚合后的结果集合，多行数据。0-n行（建议使用）

=========================================================================

如有错漏，敬请指正