SpringBoot整合MongoDB,MongoTemplent的使用（3）

简介

MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。
MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。它支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是它支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

其实对MongoDB更详细的介绍我前两章有写，如果有兴趣可以看看

今日内容：

• MongoTemplent实现增删改查

正文

第一步 导入pom文件、配置yml文件

pom文件

<!--    springBoot需要的依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
            <version>2.4.1</version>
        </dependency>
        <!--        test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

yml配置文件

spring:
  data:
    mongodb:
      uri: mongodb://guyong:123456@localhost:27017/lx
      #uri:mongodb://用户名：密码@主机地址：端口号/集合
server:
  port: 8899
  #设置端口号

第二步 编写实体类、启动类

启动类

@SpringBootApplication
public class ApplicationMongoDB {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationMongoDB.class);
    }
}

实体类

@Document("emp")  //指定操作哪个集合
@Data   //省略get set方法
@AllArgsConstructor  //省略需要传参的构造器
@NoArgsConstructor  //省略无参构造器
public class Employee {

    @Id  //定义在主键上
    private Integer id;
    @Field("username")  //起别名
    private String name;

    private int age;

    private Double salary;

    private Date birthday;
}

• @Document(collection=“article”) 表示指定该类操作哪个集合

• @CreatedDate注解，和jpa用法一样，创建时会自动赋值，需要在启动类上添加@EnableMongoAuditing

• @Field注解，可以指定存储的键值对名称，默认是类字段名，如果设置了Field就是以括号中的名字为字段名

• @Id主键，不可重复，自带索引，可以在定义的列名上标注，需要自己生成并维护不重复的约束，如果自己不设置@Id主键，mongo会自动生成一个唯一主键，并且插入时效率远高于自己设置主键

• @Indexed声明该字段需要加索引，加索引后以该字段为条件检索将大大提高速度，唯一索引@Indexed(unique=true)

第三步 编写Dao层

条件查询

public Query() {  查询所有
}

public Query(CriteriaDefinition criteriaDefinition) { 定义标准条件
    this.addCriteria(criteriaDefinition);
}

增加数据

@Component
public class Insert {
    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 插入单条数据
     */
    public void testInsert(){
        Employee employee = new Employee(1, "小明", 30, 1000.00, new Date());

        //添加文档
//        save:_id存在是更新数据，不会抛出异常
//        public <T> T save(T objectToSave)
        mongoTemplate.save(employee);
//        insert: _id存在会抛出异常  支持批量操作
        mongoTemplate.insert(employee);
    }

    /**
     * 插入多条数据
     */
    public void testInsert2(){
        List<Employee> list = Arrays.asList(
                new Employee(2, "张三", 30, 1000.00, new Date()),
                new Employee(3, "李四", 25, 1000.00, new Date()),
                new Employee(4, "王五", 18, 1000.00, new Date()),
                new Employee(5, "赵六", 54, 1000.00, new Date()),
                new Employee(6, "田七", 44, 1000.00, new Date())
        );
        mongoTemplate.insert(list,Employee.class);
    }
}

修改数据

@Component
public class Updates {
    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 更新满足条件的第一条数据，返回值是long类型的更新条数
     * @return
     */
    public long testUpdate(){
        Query query = new Query(Criteria.where("age").gte(20));
        Update update = new Update();
        update.set("salary",520);
//        updateFirst() 只更新满足条件的第一条记录
        UpdateResult updateResult = mongoTemplate.updateFirst(query, update, Employee.class);
        long modifiedCount = updateResult.getModifiedCount();
        return modifiedCount;
    }


    /**
     * 更新所有满足条件的数据
     * @return
     */
    public long testUpdate2(){
        Query query = new Query(Criteria.where("age").gte(20));
        Update update = new Update();
        update.set("salary",888);
        UpdateResult updateResult = mongoTemplate.updateMulti(query, update, Employee.class);
        long modifiedCount = updateResult.getModifiedCount();
        return modifiedCount;
    }


    /**
     * 没有符合条件的记录则插入数据
     * @return
     */
    public long testUpdate3(){
        Query query = new Query(Criteria.where("age").is(1));
        Update update = new Update();
        update.set("age",18).set("name","王麻子");
        UpdateResult upsert = mongoTemplate.upsert(query, update, Employee.class);
        return upsert.getModifiedCount();
    }

    public int testUpdate4(){
        Query query = new Query(Criteria.where("student").is("1101"));
        Update update = new Update();
//        inc对一个数值进行增加或者减少的操作
        update.inc("language",1);
        FindAndModifyOptions options = new FindAndModifyOptions();
//        返回实体的新状态
        options.returnNew(true);
        Grade grade = mongoTemplate.findAndModify(query, update, options, Grade.class);
        return grade.getLanguage();
    }
}

查找数据

@Component
public class Refer {
    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 查询所有数据
     * @return
     */
    public List<Employee> testFind(){
        List<Employee> all = mongoTemplate.findAll(Employee.class);
        return all;
    }

    /**
     * 根据ID查询
     * @return
     */
    public Employee testFindById(){
        Employee byId = mongoTemplate.findById(1, Employee.class);
        return byId;
    }

    /**
     * 返回条件查询的第一个文档
     * @return
     */
    public Employee testFindOne(){
//        new Query()表示没有条件
        Employee one = mongoTemplate.findOne(new Query(), Employee.class);
        return one;
    }

    /**
     * 查询age大于18，小于30的员工信息
     * @return
     */
    public List<Employee> Q1(){
//        where(String key) 表示你查询的对应是哪个key 后面跟上值
        Query q = new Query(Criteria.where("age").gt(18).lt(30));
        List<Employee> employees = mongoTemplate.find(q, Employee.class);
        return employees;
    }

    /**
     * 正则查询（模糊查询）
     * java中正则不需要//
     * @return
     */
    public List<Employee> Q2(){
        Query query = new Query(Criteria.where("username").regex("张"));
        List<Employee> employees = mongoTemplate.find(query, Employee.class);
        return employees;
    }

    /**
     * 多条件查询
     * @return
     */
    public List<Employee> Q3(){
        Criteria c = new Criteria();
//       orOperator():or连接多个条件
//        andOperator:and可以传入多个条件
         c.andOperator(Criteria.where("age").gt(18), Criteria.where("username").regex("六"));
        Query query = new Query(c);
        return mongoTemplate.find(query, Employee.class);
    }

    /**
     * 排序查询
     * @return
     */
    public List<Employee> Q4(){
         Query query = new Query();
         query.with(Sort.by(Sort.Order.desc("age")));
         return mongoTemplate.find(query,Employee.class);
    }

    /**
     * 分页查询
     */
//    skip() 指定跳过记录数
//    limit() 限定返回的结果条数
    public List<Employee> Q5(){
        Query query = new Query();
        query.skip(0).limit(3);
        return mongoTemplate.find(query,Employee.class);
    }


    /**
     * 使用json字符串查询
     * @return
     */
    public List<Employee> FindByJson(){
//        username 和 name都可以
//        等值查询
//        String json ="{name:'王五'}";
        //gt 大于    gte大于等于
        String json = "{$or:[{age:{$gt:25}},{salary:{$gte:1000}}]}";

        Query query = new BasicQuery(json);
        List<Employee> employees = mongoTemplate.find(query, Employee.class);
        return employees;
    }
}

删除数据

@Component
public class Delete {
    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 删除指定条件的数据
     * @return
     */
    public long testDelete(){
        Query query = new Query(Criteria.where("age").gte(25));
        DeleteResult remove = mongoTemplate.remove(query, Employee.class);
        return  remove.getDeletedCount();
    }

    /**
     * 删除所有数据
     */
    public void testDelete2(){
//        直接删除集合
        mongoTemplate.dropCollection(Employee.class);

//        删除所有数据，但是这个是一条条数据删除，效率没有上面的高
//        mongoTemplate.remove(new Query(),Employee.class);
    }


}

编写 controller层

@RequestMapping("/test")
@RestController
public class TestController {
    @Autowired
    private Insert insert;

    @Autowired
    private Refer refer;

    @GetMapping("/i1")
    public void save(){
        insert.testInsert();
    }

    @GetMapping("/i2")
    public void insert(){
        insert.testInsert2();
    }

    @GetMapping("/r1")
    public List<Employee> find(){
        return refer.testFind();
    }

    @GetMapping("/r2")
    public Employee findById(){
        return refer.testFindById();
    }

    @GetMapping("/r3")
    public Employee findOne(){
        return refer.testFindOne();
    }

    @GetMapping("/r4")
    public List<Employee> findQ1(){
        return refer.Q1();
    }

    @GetMapping("/r5")
    public List<Employee> findQ2(){
        return refer.Q2();
    }

    @GetMapping("/r6")
    public List<Employee> findQ3(){
        return refer.Q3();
    }

    @GetMapping("/r7")
    public List<Employee> findQ4(){
        return refer.Q4();
    }

    @GetMapping("/r8")
    public List<Employee> findQ5(){
        return refer.Q5();
    }

    @GetMapping("/r9")
    public List<Employee> findQ6(){
        return refer.FindByJson();
    }
}

@RequestMapping("/test2")
@RestController
public class TestController2 {
    @Autowired
    private Updates updates;

    @Autowired
    private Delete delete;

    @GetMapping("/u1")
    public long test1(){
        return updates.testUpdate();
    }

    @GetMapping("/u2")
    public long test2(){
        return updates.testUpdate2();
    }

    @GetMapping("/u3")
    public long test3(){
        return updates.testUpdate3();
    }

    @GetMapping("/u4")
    public int test4(){
        return updates.testUpdate4();
    }

    @GetMapping("/d1")
    public long del1(){
        return  delete.testDelete();
    }

    @GetMapping("/d2")
    public void del2(){
        delete.testDelete2();
    }
}

结尾

本文的笔记可能需要兄弟们自己整理了，我一般把方法的注释都写在代码上，需要兄弟们自己跟着敲一遍整理一下笔记了