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

最新推荐文章于 2024-10-20 16:22:46 发布
最新推荐文章于 2024-10-20 16:22:46 发布
阅读量650 收藏 3
点赞数
分类专栏： MongoDB 文章标签： mongodb spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46075209/article/details/124717657
版权

简介

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();
    }
}

结尾

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

是程小姐呀
关注
专栏目录
【微服务】springboot整合mongodb使用详解
congge_study的博客
07-30 4974
springboot整合mongodb使用详解
SpringBoot 整合 MongoDB实战
liuxialixiao的博客
05-16 882
在前面的文章中，我们详细的介绍了 MongoDB 的配置和使用，如果你对 MongoDB 还不是很了解，也没关系，在 MongoDB 中有三个比较重要的名词：数据库、集合、文档！文档（Document）： 文档是 MongoDB 中最基本的数据单元，由键值对组成，类似于 JSON 格式，可以存储不同字段，字段的值可以包括其他文档、数组和文档数组。索引在所有的数据库中，暂居的位置非常重要，例如当你检索一张上百万的数据表的时候，如果没走索引，查询效率会极其缓慢，对于 MongoDB 来说，同样如此。
springboot整合mongodb
07-23
mongodb版本号3.2,需手动开启http服务，启动时使用命令 ./mongod --httpinterface 新增 修改 删除 查询 排序 分页 可查看： https://blog.csdn.net/m0_37132783/article/details/96992439
MongoDB的安装
shall潇の菜园
06-01 697
文章目录一、解压缩二、创建目录三、配置文件三、启动 一、解压缩 tar -zxvf mongodb-linux-x86_64-rhel70-4.0.24.tgz mv mongodb-linux-x86_64-rhel70-4.0.24 mongodb 二、创建目录 进入mongoda目录 数据库目录： mkdir -p data/db 数据库日志： mkdir log 三、配置文件 vi mongodb.conf systemLog: destination: file path: "
springBoot整合mongodb
孟斌斌的博客
07-09 1273
适用范围：指定数据库。权限：允许用户读取指定数据库中的数据。
springboot 集成mongodb
weixin_34192732的博客
06-14 107
环境依赖 在pom文件引入spring-boot-starter-data-mongodb依赖： &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-mon...
SpringBoot整合Mongodb
klcss的博客
04-18 1139
一个文档数据库，以JSON为数据模型，由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。
springboot整合mongodb changestream代码
02-23
在本文中，我们将深入探讨如何在Spring Boot应用中整合MongoDB的Change Stream功能。Change Stream是MongoDB提供的一种强大特性，允许我们实时监控数据库中的变化，例如文档的插入、更新和删除操作。这对于构建实时...
SpringBoot整合MongoDB快速上手文档.zip
09-30
总结，SpringBoot整合MongoDB涉及的主要步骤包括：添加依赖，配置数据库连接，定义Repository接口，使用MongoTemplate进行复杂操作，以及创建实体类。通过这些步骤，开发者可以快速地在SpringBoot项目中搭建起与...
Springboot整合mongodb
m0_63837020的博客
07-31 3786
总结的关于springboot如何整理mongodb的一些用法
springBoot集成MongoDB
11-27
springBoot集成MongoDB，内部为单元测试。 springBoot集成MongoDB，内部为单元测试。
SpringBoot整合mongoDB
weixin_34358365的博客
05-05 155
MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。 这一片文章介绍一个springboot整合mongodb，如果你了解整合mysql之类的数据库，可以一带而过。 还是同样的套路，pom文件中加入mongodb依赖，完整pom文件如下： &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;pr...
SpringBoot整合MongoDB
qq_65142821的博客
04-13 5907
MongoDB是一种开源的文档型数据库管理系统，它使用类似于JSON的BSON格式（Binary JSON）来存储数据。与传统关系型数据库不同，MongoDB不使用表和行的结构，而是采用集合（Collection）(Mysql表)和文档（Document）（MySql行）的概念来组织数据。
SpringBoot集成MongoDB
weixin_44463473的博客
04-23 4130
官方文档 https://www.mongodb.com/docs/manual/reference/method/ MongoDB介绍 https://blog.csdn.net/weixin_44463473/article/details/124333852 MongoDB命令行使用 https://blog.csdn.net/weixin_44463473/article/details/124334979 SpringBoot集成MongoDB MongoDB副本集和...
SpringBoot集成Mongodb
最新发布
2301_81405087的博客
10-20 1198
MongoDB是一种非关系型数据库，被广泛用于大型数据存储和分布式系统的构建。MongoDB支持的数据模型比传统的关系型数据库更加灵活，支持动态查询和索引，也支持json格式和bson格式的数据存储，这种格式可以支持读取和写入大量的数据。
Springboot 集成 MongoDB
hjx_code的专栏
11-13 1598
在SpringBoot项目中集成MongoDB后的一些基本操作。
springboot整合mongodb使用
03-16
在 Spring Boot 中整合 MongoDB 的步骤如下： 1. 在项目的 pom.xml 文件中添加 MongoDB 的依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-mongodb ``` 2. 在 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值