Springboot整合MongoDB系列(三)---MongoTemplate

最新推荐文章于 2024-08-23 23:36:39 发布
最新推荐文章于 2024-08-23 23:36:39 发布
阅读量2k 收藏 8
点赞数 2
分类专栏： springboot整合MongoDB 文章标签： mongodb 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H900302/article/details/119210208
版权

我们继续MongoDB系列博客的第三篇，记录下springboot整合MongoDB的基本curd操作，各位看到此博客的小伙伴，如有不对的地方请及时通过私信我或者评论此博客的方式指出，以免误人子弟。多谢！

目录

测试环境准备

测试MongoTemplate的curd

insert 操作

save：没有则创建，存在则更新

删除操作

修改操作

基本查询、范围查询、模糊查询

排序

分页查询

管道Aggregation查询

管道Aggregation分页查询

通过BasicQuery指定返回的字段

通过Aggregation.project指定返回的字段

测试环境准备

测试环境的准备工作就不贴图了，就是创建一个springboot项目，贴一下测试用到的实体类和pom依赖

@Data
@Builder
@Document("user")
public class User {
    private String username;
    private String sex;
    private String address;
    private String createTime;
    private Integer age;
}
<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>mongo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mongo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- SpringBoot 测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- SpringBoot Web容器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

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

        <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

测试数据

    public User getUser(){
        return User.builder().username("zhaoliu").age(10).sex("男").address(
                "rizhao").build();
    }
    public List<User> getUserList(){
        User user2 =
                User.builder().username("zhangsan").age(10).sex("男").address("jinan").build();
        User user3 =
                User.builder().username("lisi").age(20).sex("女").address("jinan").build();
        List<User> userList = new ArrayList<>();
        userList.add(user2);
        userList.add(user3);
        return userList;
    }

    public void clearDb(){
        mongoTemplate.dropCollection(User.class);
    }

测试MongoTemplate的curd

insert 操作

    @Test
    public void insert(){
        clearDb();

        // insert one
        User user = getUser();
        User user1 = mongoTemplate.insert(user);
    
        // insert many
        List<User> userList = getUserList();
        mongoTemplate.insert(userList,User.class);
        //mongoTemplate.insertAll(userList);
    }

查看数据库结果如下：

如上，上面我们构建User对象时，并没有为createTime属性赋值，也没有为id属性赋值，在保存后，数据库中并没有createTime， 不同于保存mysql 对象属性不赋值会有默认保存进数据库， 比如这个字符串类型的createTime 会默认为空保存，并且也没有id属性，但是保存时mongoDB会默认生成一个Object类型的_id。

上面我们User试题中并没有id属性，保存后在数据库中默认生成了一个Object类型的_id,看下加上id属性后的效果：

    private String id;

同样执行上面的测试方法，执行结果如下：

 如上：虽然我们在User对象中加了id属性，但是保存时并没有单独的id字段，id会自动映射成"_id"吗？测试一下：

User user = User.builder().id("qazwsx").username("zhaoliu").age(20).sex("男").address("rizhao").build();

 我们为id赋值，再次保存后，发现_id的值为qazwsx，可以确定id属性自动映射成了 _id。 我们不想让id自动映射为_id,就想要数据库中保存id怎么办呢，可以使用@Field显示的指定它对应的属性名。

也可以使用@Field注解指定保存到数据库中字段的名字，比如指定User对象id属性保存到数据库中为uid，可以这样：

@Field("uid")
private String id;

User user2 = User.builder().id("zbc").username("yjh").age(18).build();
mongoTemplate.insert(user2);

执行结果如下：

 如果我们既不想使用数据库默认生成的_id，也不想用id自动映射的 _id，可以使用@Id注解标识任意字段为数据库的 _id,比如使用@Id标识username属性，保存后username就会作为数据库的 _id。当然一般我们不会这么办，毕竟username作为主键还是不合适的，这里只是为了测试。

@Id
private String username;

数据库结果如下：

简单总结下保存时的一些细节：

1.保存时mongoDB会默认生成一个Object类型的_id。

2.不初始化属性，保存后数据库没有此filed。

3.执行保存时在java class中的id属性，会自动映射成"_id"。

4.使用@Id标记的字段也会在数据库中显示为_id

接下来的就只贴测试方法不在贴数据库截图了，大家感兴趣可以自己在本地试下：

save：没有则创建，存在则更新

    @Test
    public void save(){
        clearDb();
        // id为 610253fe88164b310a41ca2f 的数据age修改为100
        User user = User.builder().id("610253fe88164b310a41ca2f").username("zhaoliu").sex("男").age(100).build();
        mongoTemplate.save(user);
        // 创建testuser集合 并新增一条数据
        mongoTemplate.save(user,"testuser");
    }

删除操作

    @Test
    public void delete(){
        Query query = new Query();
        Criteria criteria = Criteria.where("_id").is("60ec045d0c385469452d1c21");
        query.addCriteria(criteria);
        mongoTemplate.remove(query,User.class);
        Query query1 = new Query(Criteria.where("_id").ne("60ec0c56b0f4dc6363dfc02a"));
        mongoTemplate.remove(query1,"testuser");
        // delete all datas in collection
        mongoTemplate.dropCollection(User.class);
        // delete collection
        mongoTemplate.dropCollection("mytest1");
    }

修改操作

    /**
     * Update.update(key,value)也可完成修改 ---> 修改一个字段
     * Update.update(key,value).set("key,value) ---> 修改两个字段
     * Update.update(key,value).set("key,value).set(key,value).set...... ---> 修改多个字段
     * 1.修改满足条件的第一条数据 使用updateFirst
     * 2.修改满足条件的所有数据 使用updateMulti
     * 3.upsert: 按条件查询  查询到数据则修改  没查询到则添加  并且upsert只会更新匹配到的第一条数据
     *   如下：若查询到有username为wangwu的数据则将sex改为男
     *        若没查询到有username为wangwu的数据则新插入一条数据(username：wangwu sex：男)
     */
    @Test
    public void update(){
        /*ObjectId objectId = new ObjectId("60ee4af0771c712494b9ac4d");
        Query query = new Query();
        Criteria criteria = Criteria.where("_id").is(objectId);
        query.addCriteria(criteria);
        Update update = new Update();
        update.set("username","zhangsan");*/
        Criteria criteria = Criteria.where("username").is("lisi123");
        Query query = Query.query(criteria);
        Update update = Update.update("username", "lisi");
        //mongoTemplate.updateFirst(query,update,User.class);
        //mongoTemplate.updateMulti(query,update,User.class);
        //mongoTemplate.upsert(query,update,User.class);
        Criteria criteria1 = Criteria.where("username").is("wangwu");
        Query query1 = Query.query(criteria1);
        Update update1 = Update.update("sex","男");
        mongoTemplate.upsert(query1,update1,User.class);
    }

基本查询、范围查询、模糊查询

需要注意的是范围查询，范围查询需要使用Criteria 的andOperator(Criteria... criteria)方法，比如按照age的范围进行查询时需要这样写：

Criteria criteria3 = new Criteria();
criteria3.andOperator(Criteria.where("age").gt(10),Criteria.where("age").lt(50));

 而不能像追加多个条件一样使用如下的方式：

Criteria criteria3 = Criteria.where("age").gt(10).and("age").lt(50);
Criteria criteria3 = new Criteria(); criteria3.and("age").gt(10); criteria3.and("age").lt(50);

 否则会报如下错误：

InvalidMongoDbApiUsageException: Due to limitations of the com.mongodb.BasicDocument, you can't add a second 'age' expression specified as 'age : Document{{$lt=50}}'. Criteria already contains 'age : Document{{$gt=10}}'.

    /**
     * 基本查询 模糊查询 范围查询
     * 使用regex(Pattern pattern) 实现模糊查询
     * 完全匹配：Pattern pattern = Pattern.compile("^张$", Pattern.CASE_INSENSITIVE);
     * 右匹配：Pattern pattern = Pattern.compile("^.*张$", Pattern.CASE_INSENSITIVE);
     * 左匹配：Pattern pattern = Pattern.compile("^张.*$", Pattern.CASE_INSENSITIVE);
     * 模糊匹配：Pattern pattern = Pattern.compile("^.*张.*$", Pattern.CASE_INSENSITIVE);
     */
    @Test
    public void select(){
        Criteria criteria = Criteria.where("username").is("wangwu");
        Query query = Query.query(criteria);
        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);
        List<User> all = mongoTemplate.findAll(User.class);
        System.out.println(all);
        // 模糊查询
        Pattern pattern = Pattern.compile("^lisi.*$", Pattern.CASE_INSENSITIVE);
        Criteria criteria1 = Criteria.where("username").regex(pattern);
        Query query1 = Query.query(criteria1);
        User user = mongoTemplate.findOne(query1, User.class);
        System.out.println(user);
        Criteria criteria2 = Criteria.where("_id").is("60ee4af0771c712494b9ac4d");
        Query query2 = Query.query(criteria2);
        User user1 = mongoTemplate.findOne(query2, User.class);
        System.out.println(user1);
        User user2 = mongoTemplate.findById("60ee4af0771c712494b9ac4d", User.class);
        System.out.println(user2);
        long count = mongoTemplate.count(query, User.class);
        System.out.println(count);
        boolean exists = mongoTemplate.exists(query, User.class);
        System.out.println(exists);
        // 范围查询
        // InvalidMongoDbApiUsageException: Due to limitations of the com.mongodb.BasicDocument, you can't add a second 'age' expression specified as 'age : Document{{$lt=50}}'. Criteria already contains 'age : Document{{$gt=10}}'.
        // Criteria criteria3 = Criteria.where("age").gt(10).and("age").lt(50);
        // Criteria criteria3 = new Criteria(); criteria3.and("age").gt(10); criteria3.and("age").lt(50);
        Criteria criteria3 = new Criteria();
        criteria3.andOperator(Criteria.where("age").gt(10),Criteria.where("age").lt(50));
        Query query3 = Query.query(criteria3);
        List<User> userList1 = mongoTemplate.find(query3, User.class);
        System.out.println(userList1);
        // 查询指Map定collection中的数据
        Criteria criteria10 = Criteria.where("name").is("zhangsan");
        Query query10 = Query.query(criteria10);
        List<Map> testuser = mongoTemplate.find(query10, Map.class,"testuser");
        System.out.println(testuser);

    }

排序

/**
     * 排序
     * 1.默认升序 Sort.by("age")
     * 2.可通过Sort.by(Sort.Order.desc("age")) 或 Sort.by(Sort.Direction.DESC,"age") 指定排序方式
     * 3.
     */
    @Test
    public void select1(){
        Query query = new Query();
        Sort sort = Sort.by("age");
        query.with(sort);
        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);
        Sort sort1 = Sort.by(Sort.Order.desc("age"));
        query.with(sort1);
        List<User> userList1 = mongoTemplate.find(query, User.class);
        System.out.println(userList1);
        Sort sort2 = Sort.by(Sort.Direction.DESC,"age");
        query.with(sort2);
        List<User> userList2 = mongoTemplate.find(query, User.class);
        System.out.println(userList2);
    }

分页查询

@Test
    public void select2(){
        Pageable page = PageRequest.of(0, 2);
        Query query = new Query();
        query.with(page);
        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList + "---" + userList.size());
        Sort sort = Sort.by("age");
        Pageable pageable = PageRequest.of(0,2,sort);
        Query query1 = new Query();
        query1.with(pageable);
        List<User> userList1 = mongoTemplate.find(query1, User.class);
        System.out.println(userList1);
        Pageable pageable1 = PageRequest.of(0, 2, Sort.Direction.DESC, new String[]{"age"});
        Query query2 = new Query();
        query2.with(pageable1);
        List<User> userList2 = mongoTemplate.find(query2, User.class);
        System.out.println(userList2);
        // 分页1
        long count = mongoTemplate.count(new Query(), User.class);
        System.out.println(count);
        Page<User> userPage = new PageImpl<User>(userList2,pageable1,count);
        System.out.println("---getTotalElements---" + userPage.getTotalElements());// 总记录数
        System.out.println("---getTotalPages---" + userPage.getTotalPages());// 总页数
        System.out.println("---getNumber---" + userPage.getNumber());// 当前页
        System.out.println("---getSize---" + userPage.getSize());// 每页大小
        System.out.println("---getContent---" + userPage.getContent()); // 数据
        System.out.println("---getNumberOfElements---" + userPage.getNumberOfElements());// 当前页的元素数
        // 分页2
        Page<User> userPage1 = PageableExecutionUtils.getPage(userList2, pageable1, () -> count);
        System.out.println("---getTotalElements---" + userPage1.getTotalElements());// 总记录数
        System.out.println("---getTotalPages---" + userPage1.getTotalPages());// 总页数
        System.out.println("---getNumber---" + userPage1.getNumber());// 当前页
        System.out.println("---getSize---" + userPage1.getSize());// 每页大小
        System.out.println("---getContent---" + userPage1.getContent()); // 数据
        System.out.println("---getNumberOfElements---" + userPage1.getNumberOfElements());// 当前页的元素数
    }

管道Aggregation查询

/**
     * AggregationResults<T> 一般用查询的类接就好
     * [Document{{_id=60ee4af0771c712494b9ac4d, age=30.0}}, Document{{_id=60ee9cd8d82d3d76d2ed2204, age=30.0}}]
     * [User(id=60ee4af0771c712494b9ac4d, username=null, password=null, sex=null, address=null, createTime=null, age=30), User(id=60ee9cd8d82d3d76d2ed2204, username=null, password=null, sex=null, address=null, createTime=null, age=30)]
     */
    @Test
    public void aggregation(){
        // select * from user where age > 20
        Criteria criteria = Criteria.where("age").gt(20);
        // 使用List<AggregationOperation>封装查询条件 或者直接用Aggregation构建 如：Aggregation.match(criteria)
        List<AggregationOperation> operations = new ArrayList<>();
        operations.add(Aggregation.match(criteria));
        TypedAggregation<User> aggregation = Aggregation.newAggregation(User.class,operations);
        AggregationResults<Document> aggregationResults =
                mongoTemplate.aggregate(aggregation, Document.class);
        System.out.println(aggregationResults.getMappedResults());
        // select age,count(*) from user group by age
        List<AggregationOperation> operations1 = new ArrayList<>();
        operations1.add(Aggregation.group("age").sum("age").as("counts"));
        TypedAggregation<User> typedAggregation = TypedAggregation.newAggregation(User.class, operations1);
        AggregationResults<User> aggregationResults1 = mongoTemplate.aggregate(typedAggregation,
                User.class);
        System.out.println(aggregationResults1.getMappedResults());
        Set<String> names = new HashSet<String>();
        names.add("lisi");
        names.add("wangwu");
        Aggregation agg = Aggregation.newAggregation(
                Aggregation.match(Criteria.where("username").in(names)),
                Aggregation.match(Criteria.where("age").gt(10))
        );
        AggregationResults<User> aggregationResults2 = mongoTemplate.aggregate(agg, "user", User.class);
        System.out.println(aggregationResults2.getMappedResults());
    }

管道Aggregation分页查询

@Test
    public void aggregation1(){
        int pageNum = 0;
        int pageSize = 2;
        Pageable pageable = PageRequest.of(pageNum,pageSize);
        int totalCount;
        // 查询条件
        List<AggregationOperation> operations = new ArrayList<>();
        // 模拟一下带条件的查询
        String username = "zhaoliu";
        if(StringUtils.isNotBlank(username)){
            operations.add(Aggregation.match(Criteria.where("username").ne("zhaoliu")));
            Aggregation aggregation = Aggregation.newAggregation(operations);
            AggregationResults<User> aggregationResults = mongoTemplate.aggregate(aggregation, "user",
                    User.class);
            totalCount = aggregationResults.getMappedResults().size();
        }else{
            totalCount = mongoTemplate.findAll(User.class).size();
        }
        // 分页信息
        operations.add(Aggregation.skip((long)pageNum * pageSize));
        operations.add(Aggregation.limit(pageSize));
        // 排序  或者在Pageable中添加排序
        operations.add(Aggregation.sort(Sort.Direction.DESC, "age"));
        //当前页数据
        Aggregation aggregation = Aggregation.newAggregation(operations);
        AggregationResults<User> results = mongoTemplate.aggregate(aggregation, "user", User.class);
        // 分页查询
        Page<User> userPage = PageableExecutionUtils.getPage(results.getMappedResults(), pageable,
                () -> totalCount);
        System.out.println("---getTotalElements---" + userPage.getTotalElements());// 总记录数
        System.out.println("---getTotalPages---" + userPage.getTotalPages());// 总页数
        System.out.println("---getNumber---" + userPage.getNumber());// 当前页
        System.out.println("---getSize---" + userPage.getSize());// 每页大小
        System.out.println("---getContent---" + userPage.getContent()); // 数据
        System.out.println("---getNumberOfElements---" + userPage.getNumberOfElements());// 当前页的元素数
    }

通过BasicQuery指定返回的字段

/**
     * 通过BasicQuery指定返回的字段
     * 不设置的属性字段值为null
     * 如：[User(id=60ee4af0771c712494b9ac4d, username=lisi, sex=女, address=null, createTime=null, age=20)]
     */
    @Test
    public void select3(){
        // 查询条件
        BasicDBObject dbObject = new BasicDBObject();
        dbObject.put("username", "lisi");
        //指定返回的字段
        BasicDBObject fieldsObject = new BasicDBObject();
        fieldsObject.put("username",true);
        fieldsObject.put("age",true);
        fieldsObject.put("sex",true);
        Query query = new BasicQuery(dbObject.toJson(),fieldsObject.toJson());
        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);
    }

通过Aggregation.project指定返回的字段

/**
     * 通过Aggregation.project指定返回的字段
     * project ：控制返回的字段，例如一个实体类，我们只需要部分字段
     * 同上面一样通过对象接收结果时，没设置的属性值为null
     * 如：[User(id=60ee4af0771c712494b9ac4d, username=lisi, password=null, sex=女, address=null, createTime=null, age=20)]
     * 我们可以使用Map接收
     * 如：[{_id=60ee4af0771c712494b9ac4d, username=lisi, sex=女, age=20.0}]
     * 综上两种方式，如果只想返回指定字段，可以使用map类型来接收返回结果，但是也要看返回数据的结构是否利于后续解析
     * 如果结构复杂，用对象的方式会方便些，虽然有一些我们不需要的属性，但是在最终接口返回前可以转换一下去掉不需要的属性
     */
    @Test
    public void select4(){
        Criteria criteria = Criteria.where("username").is("lisi");
        MatchOperation match = Aggregation.match(criteria);
        ProjectionOperation project = Aggregation.project("username","age","sex");
        Aggregation aggregation = Aggregation.newAggregation(match,project);
        AggregationResults<User> results = mongoTemplate.aggregate(aggregation, "user", User.class);
        System.out.println(results.getMappedResults());
        AggregationResults<Map> results1 = mongoTemplate.aggregate(aggregation, "user", Map.class);
        System.out.println(results1.getMappedResults());
    }

SpringBoot使用MongoTemplate详解
谁念西风独自凉
03-05 1885
SpringBoot 使用MongoTemplate 操作MongoDB详解
Spring Boot 集成 MongoDB 小白篇
热门推荐
Java Pro
05-18 25万+
SpringBoot2.x与MongoDB集成(十) 准备工作 介绍MongoDB与Spring Boo集成，并通过MongoRepository以及MongoTemplate来执行CRUD操作。 Spring Boot：2.3.0.RELEASE Spring Boot Data MongoDB：2.3.0.RELEASE MongoDB：4.2.6 MongoDB Driver：4.0.3 要操作的集合示例数据结构(即model) Department： String id String name
在SpringBoot中优雅整合MongoDB——让你的数据存储更灵活
Takumilove的博客
08-23 1627
通过这篇博客，你已经了解了如何在SpringBoot中整合MongoDB，并通过两种不同的方式（MongoRepository和MongoTemplate）进行数据操作。对于简单的CRUD操作，MongoRepository可以让你的代码更加简洁；而MongoTemplate则在你需要更复杂的查询或更新操作时提供了更大的灵活性。
SpringBoot集成MongoDB之MongoTemplate
weixin_42806958的博客
04-16 826
spring-data-mongodb提供了两种方式访问mongodb。 本章主要介绍“MongoTemplate”的操作 pom.xml <!--mongodb--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb
MongoTemplate聚合查询代码解析
qq_51493136的博客
11-02 842
语法:aggregate([{$group:{_id:"$要分组的字段",分组函数处理后的数据名:{分组函数:"执行分组函数的字段"}}}])(6).$addToSet:把值加入数组中,若存在重复则不添加。(4).$first/$last:分组的第一条/最后一条数据。(5).$push:把值加入数组中,允许存在重复。(3).$min/$max:求最小/大值。(2).$avg:求平均值。(2) 不展示该字段:0。6.集合合并:$merge。(1) 展示该字段:1。(1).$sum:求和。
springboot整合mongodb用MongoTemplate.rar
03-19
pringboot整合mongodb用MongoTemplate，完整的一个demo实例
【主流技术】MongoTemplate 与 Spring Boot 项目集成（附CURD技巧）
weixin_43248862的博客
08-05 602
MongoTemplate 是Spring Data MongoDB 中的一个核心类，为 Spring 与 MongoDB 数据库的交互提供了丰富的功能集，包括创建、更新、删除和查询 MongoDB 文档的便利操作，并提供了编程语言的领域对象（POJO）和 MongoDB 文档之间的映射。
Springboot快速整合Mongodb及mongoTemplate使用示例（附源码下载）
dingdingdandang的博客
04-23 913
Springboot-cli 开发脚手架系列 Netty系列：Springboot优雅的整合Mongodb及mongoTemplate使用示例（附源码下载） 文章目录Springboot-cli 开发脚手架系列前言1. 环境2. 编写实体类3. mongoDB使用示例4. 编写测试类5. 效果演示6. 源码分享 前言 致力于让开发者快速搭建基础环境并让应用跑起来,提供使用示例供使用者参考，让初学者快速上手。 结尾有完整源码下载地址 1. 环境 引入依赖pom.xml <!--
【MongoDB】万字长文，命令与代码一一对应SpringBoot整合MongoDB之MongoTemplate
qq_61903414的博客
08-08 2855
命令：db.comment.insert({_id:"4",nickname:"ww",content:"这位是谁啊",userId:3,createTime:……命令：db.collectionName.find({ "nickname": "ww" }).sort({ "like": 1 })命令：db.comment.find({ "like": { $gt: 0, $lt: 5 } })命令：db.comment.find({}).skip(2).limit(2)
springboot整合MongoDB 简单的操作(MongoTemplate)、添加数据、查询数据、条件查询、模糊查询、分页查询。
weixin_53472653的博客
02-11 6516
1.创建springboot项目引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> <dependency> <groupId>
springboot整合mongodb changestream代码
02-23
在本文中，我们将深入探讨如何在Spring Boot应用中整合MongoDB的Change Stream功能。Change Stream是MongoDB提供的一种强大特性，允许我们实时监控数据库中的变化，例如文档的插入、更新和删除操作。这对于构建实时...
springboot-mybatis-druid-mongodb-logback-demo.zip
01-09
本实例将展示如何配置MongoDB数据源，以及如何使用MongoTemplate或ReactiveMongoTemplate进行数据访问。 Druid数据源是阿里巴巴开源的一款高性能、可扩展的数据库连接池组件。它提供了监控、连接池管理、SQL解析等...
SpringBoot整合MongoDB快速上手文档.zip
09-30
总结，SpringBoot整合MongoDB涉及的主要步骤包括：添加依赖，配置数据库连接，定义Repository接口，使用MongoTemplate进行复杂操作，以及创建实体类。通过这些步骤，开发者可以快速地在SpringBoot项目中搭建起与...
【微服务】springboot整合mongodb使用详解
congge_study的博客
07-30 4950
springboot整合mongodb使用详解
Springboot整合MongoDB操作DB——`MongoRepository`和`MongoTemplate`
蔡定努
03-20 866
启动 MongoDB 实例 引入相关依赖 主要的依赖为Web和MongoDB的starter，把下面代码加入到pom.xml中即可： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> <dependency&g..
SpringBoot2.x 整合MongoDB——MongoTemplate
客官你来啦，姑娘任你挑
11-26 2970
MongoDB 按照惯例，肯定是要介绍一番的，不想看的朋友可以直接跳到下面的MongoTemplate使用。 MongoDB是一个文档数据库，是一个非关系型数据库(NoSql)。处理速度超级快，同样的数据库还有Redis，被称为性能利器的Redis同样是非关系数据库，但是redis不能运算，尽管有脚本可以辅助，但是终究在某些方面是不如MongoDB的。可以说MongoDB是一个最接近关系型数据库的...
Spring Data MongoDB七：进阶Aggregation操作（下）
zhouzhiwengang的专栏
11-09 3903
本文转载至：http://blog.csdn.net/congcong68/article/details/52821362  一、Spring Data MongoDB   Aggregation 简介                                                                    上一篇已经Aggregation
springboot 操作 mongoTemplate
聋的传人
11-04 1222
springboot 操作 mongoTemplate
SpringBoot 操作 MongoTemplate
Mephisto180502的博客
04-27 1976
SpringBoot 操作 mongoTemplate
mongoTemplate分组前 字段倒序
最新发布
10-12
在MongoDB中，`MongoTemplate`是Spring Data MongoDB库提供的一个模板类，它简化了与MongoDB数据库的操作。如果你想要对集合进行分组并且希望在分组之前对某个字段进行倒序排序，你可以通过先执行排序操作，然后再进行分组。 假设你有一个名为`orders`的集合，你想按订单金额降序然后分组，可以这样做： ```java List<AggregationResult> results = mongoTemplate.aggregate( Aggregation.newAggregation( // 首先对订单金额字段进行降序排序 Aggregation.sort(Sort.by(Sort.Direction.DESC, "amount")), // 然后按照某个字段（如用户ID）进行分组 Aggregation.group("$userId", // 分组键 Aggregation.reduce("function(this, acc) { acc.push(this); return acc; }") // 这里只是一个示例，根据需求调整reduce函数 ) ).getMappedResults(); ``` 在这个例子中，`sort()`方法用于设置排序规则，`group()`方法则用于指定分组依据以及如何合并分组后的文档。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值