MongoDB学习总结四（详细记录使用MongoTemplate操作MongoDB数据库）

    前提：本文详细记录使用MongoTemplate对MongoDB数据库常见的操作内容。（接上篇文章SpringBoot2.X集成MongoDB配置）

    MongoDB中Aggregation聚合查询（重点）--------------下篇文章

 （个人记录学习总结内容，若出现错误/改进地方，请指出/分享，共同学习进步！！！）

一、Person实体类（测试）

                 简明：为了简化代码，已引入Lombok依赖，省略Setter()、Getter()方法。

重点：已使用@Document注解，默认下Person实体类数据存储在指定的集合PersonCollection

import lombok.Getter;
import lombok.Setter;
import org.bson.types.ObjectId;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

/**
 *  Person 实体类
 *
 *  @Document注解  默认情况下，创建Person集合（可使用@Document注解指定创建集合PersonCollection）
 *
 *  @author LBF
 *  @date 2022/1/18 11:18
 */
@Setter
@Getter
@Document(collection = "PersonCollection")
public class Person {

    /** Id */
    @Id
    private ObjectId id;

    /** 名字 */
    private String name;

    /** 年龄 */
    private Integer age;

    /** 地址 */
    private String addr;

    public Person(String name, Integer age, String addr) {
        this.name = name;
        this.age = age;
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", addr='" + addr + '\'' +
                '}';
    }
}

二、测试案例

简明：引入MongoTemplate进行操作MongoDB数据库

    /**  MongoTemplate 实现构建对MongoDB的CRUD */
    @Autowired
    private MongoTemplate mongoTemplate;

1、插入文档（数据）

（1）插入文档（单个）

    /**
     *   插入文档（数据）操作 ---------- 能以对象形式、集合形式插入
     */
    @GetMapping("/insertDocument")
    public void insertDocument(){
        // 初始化Person对象（文档）
        Person person1 = new Person("LBF",22,"上海");
        Person person2 = new Person("MBF",33,"南京");

        // 无指定存储集合 (Person类已使用@Document注解创建对应存储Person对象的集合，即存储在PerCollection集合)
        mongoTemplate.save(person1);

        // 注意：此处是指定存储的集合PersonCollection2  (若不存在，则新建)
        mongoTemplate.save(person2,"PersonCollection2");
    }

（2）插入文档（集合）（必须指定   实体类  或   所插入集合的名称）

    /**  插入文档（集合） */
    @GetMapping("/insertDocument2")
    public void insertDocument2(){
        //  保存数据
        List<Person> personList = new ArrayList<>();
        //  初始化Person对象 （新增数据）
        personList.add(new Person("李子航",21,"思明区"));
        personList.add(new Person("莫子其",26,"湖里区"));
        personList.add(new Person("刘始于",21,"南路区"));

        //  将集合的数据插入到PersonCollection集合（注意：此处要指定实体类  或  要插入集合的名称，否则报错）
        mongoTemplate.insert(personList,Person.class);
    }

 2、查询文档（数据）

       注意：Person类已使用@Document注解指定存储的集合，所以只进行测试PersonCollection集合内的数据。
       若需操作其他集合，只需在方法中加上所想查询的集合名即可。

测试数据如下：

（1）条件查询（单个）

    /**
     *  条件查询（单个）
     *  Criteria：查询容器，构建查询的条件
     *  Query：封装传入构建的查询条件
     *  @return  查询集合结果
     */
    @GetMapping("/findDocument1")
    public List<?> findDocument1(){
        //  初始化查询容器（用来构建查询条件）
        Criteria criteria = new Criteria();
        //  查询条件：name == LBF
        criteria.and("name").is("LBF");
        //  将构建好的查询条件传入Query中
        Query query = new Query(criteria);
        //  第一个参数query：封装的查询条件
        //  第二个参数Person.class：反射获取该实体类所对应存储的集合PersonCollection，该实体类已使用@Document注解
        return mongoTemplate.find(query,Person.class);
    }

（2）条件查询（多个）（简化代码注释：以下起Criteria、Query不再重复解释）

    /**  条件查询（多个） */
    @GetMapping("/findDocument2")
    public List<?> findDocument2(){
        //  初始化查询容器（用来构建查询条件）
        Criteria criteria = new Criteria();
        //  多个查询条件：age == 21 或 23
        criteria.and("age").in(21,23);
        //  将构建好的查询条件传入Query中
        Query query = new Query(criteria);
        //  结果加上排序  （以 "age" 字段为属性，进行降序）
        query.with(Sort.by("age").descending());
        return mongoTemplate.find(query,Person.class);
    }

 （3）条件查询（所有）（已成功查询所有数据，数据较多，此处不便显示）

    /**  查询所有  */
    @GetMapping("/findDocument3")
    public List<?> findDocument3(){
        // Person.class：通过反射获取到Person实体类所对应存储的集合（使用@Document注解指定创建存储的集合）
        return mongoTemplate.findAll(Person.class);
    }

（4）分页查询

    /**  分页查询  */
    @GetMapping("/findDocument4")
    public List<?> findDocument4(){
        //  初始化查询容器（用来构建查询条件）
        Criteria criteria = new Criteria();
        //  多个查询条件：age == 21 或 23
        criteria.and("age").in(21,23);
        //  将构建好的查询条件传入Query中
        Query query = new Query(criteria);
        // 将查询结果进行分页  page参数：查询页码  size：每页显示的记录数   结果加上以" age " 属性降序
        query.with(PageRequest.of(0,5,Sort.by("age").descending()));
        return mongoTemplate.find(query,Person.class);
    }

（5）查询数量

    /**  查询数量  */
    @GetMapping("/findDocument5")
    public Long findDocument5(){
        //  初始化查询容器（用来构建查询条件）
        Criteria criteria = new Criteria();
        //  查询条件：age == 25
        criteria.and("age").is(25);
        //  将构建好的查询条件传入Query中
        Query query = new Query(criteria);
        //  返回满足条件数据的数量
        return mongoTemplate.count(query,Person.class);
    }

 （6）查询条件（拼接多个）

    /**  条件查询（多个拼接） */
    @GetMapping("/findDocument6")
    public List<?> findDocument6(){
        //  初始化查询容器（用来构建查询条件）
        Criteria criteria = new Criteria();
        //  多个查询条件
        criteria.and("age").in(21,23);     // age == 21 或 23
        criteria.and("addr").is("海口");    // addr == "海口"
        criteria.and("name").is("刘希希");  // name == "刘希希"
        //  将构建好的查询条件传入Query中
        Query query = new Query(criteria);
        //  结果加上排序  （以 "age" 字段为属性，进行降序）
        query.with(Sort.by("age").descending());
        return mongoTemplate.find(query,Person.class);
    }

 （7）模糊查询

    /**  模糊查询  */
    @GetMapping("/findDocument7")
    public List<?> findDocument7(){
        //  初始化查询容器（用来构建查询条件）
        Criteria criteria = new Criteria();
        //  模糊查询  name键中的值含有 "小" 的数据 （全模糊）
        criteria.and("name").regex(".*?" + "小" + ".*");
        //  将构建好的查询条件传入Query中
        Query query = new Query(criteria);
        return mongoTemplate.find(query,Person.class);
    }

3、更新文档（重点：更新执行流程为 先查询后更新 ）

 （1）更新文档（单个）

    /**  更新文档（单个） */
    @GetMapping("/updateDocument1")
    public void updateDocument1(){
        //  初始化查询容器（用来构建查询条件）
        Criteria criteria = new Criteria();
        //  更新数据  _id == 61e77845d02d00001a006c85 
        criteria.and("_id").is("61e77845d02d00001a006c85");
        //  封装查询条件
        Query query = new Query(criteria);

        //  初始化构建更新的条件
        Update update = new Update();
        //  设置更新的值     键：name   更新值：李倩倩
        update.set("name","李倩倩");
        //  先查询后更新
        mongoTemplate.updateFirst(query,update,Person.class);
    }

（2）更新文档（多个）

    /**  更新文档（多个） */
    @GetMapping("/updateDocument2")
    public void updateDocument2(){
        Criteria criteria = new Criteria();
        //  更新数据  age == 25
        criteria.and("age").is(25);
        Query query = new Query(criteria);

        Update update = new Update();
        //  设置更新的值  键：addr   更新值：澳大利亚
        update.set("addr","澳大利亚");
        //  先查询后更新
        mongoTemplate.updateMulti(query,update, Person.class);
    }

（3）更新文档（先查询，若无该数据，则新增）

    /**  更新文档（若不存在，则新增） */
    @GetMapping("/updateDocument3")
    public void updateDocument3(){
        Criteria criteria = new Criteria();
        //  更新数据  age == 29
        criteria.and("age").is(29);
        Query query = new Query(criteria);

        Update update = new Update();
        //  设置更新的值  键：addr 值：澳大利亚     键：name 值：李小璐
        update.set("addr","南澳").set("name","李小璐");
        //  先查询后更新
        mongoTemplate.upsert(query,update, Person.class);
    }

4、删除文档（重点：删除执行流程为 先查询后删除 ）

 （1）删除文档（删除满足条件的数据，可单个/多个）

    /**  删除文档（单个/多个） */
    @GetMapping("/deleteDocument1")
    public void deleteDocument1(){
        //  初始化查询容器（用来构建查询条件）
        Criteria criteria = new Criteria();
        //  查询条件  _id == 61e77845d02d00001a006c85
        criteria.and("_id").is("61e77845d02d00001a006c85");

        Query query = new Query(criteria);
        mongoTemplate.remove(query,Person.class);
    }

5、 待以后遇到问题，此处补充新内容。

三、总结

         本文记录个人学习使用MongoTemplate操作MongoDB一些基本的语句，较为常用，由于聚合查询的重要性及涉及较多内容，因此单独编写一文。该文章涉及到部分内容仍未能够充分理解，若出现问题/错误，请指出/分享，共同学习进步！！！