• SpringBoot整合Mongodb

    SpringBoot整合MongoDB

    一、创建项目，选择依赖

    仅选择Spring Web、Spring Data MongoDB即可

    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述

    二、引入相关依赖

    

    org.springframework.boot
    spring-boot-starter-data-mongodb



    org.projectlombok
    lombok


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    三、如果是第一次使用MongoDB，首先先创建用户

    > use admin
switched to db admin
> db.createUser({user:"zlfeng", pwd:"123456", roles:[{role:"readWriteAnyDatabase", db:"admin"}]});
Successfully added user: {
	"user" : "zlfeng",
	"roles" : [
		{
			"role" : "readWriteAnyDatabase",
			"db" : "admin"
		}
	]
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    MongoDB权限介绍

    权限

    说明

    read

    允许用户读取指定数据库

    readWrite

    允许用户读写指定数据库

    dbAdmin

    允许用户在指定数据库中执行管理函数，如索引创建、删除、查看统计或访问system.profile

    userAdmin

    允许用户向system.users集合写入，可以在指定数据库中创建、删除和管理用户

    clusterAdmin

    必须在admin数据库中定义，赋予用户所有分片和复制集相关函数的管理权限

    readAnyDatabase

    必须在admin数据库中定义，赋予用户所有数据库的读权限

    readWriteAnyDatabase

    必须在admin数据库中定义，赋予用户所有数据库的读写权限

    userAdminAnyDatabase

    必须在admin数据库中定义，赋予用户所有数据库的userAdmin权限

    dbAdminAnyDatabase

    必须在admin数据库中定义，赋予用户所有数据库的dbAdmin权限

    root

    必须在admin数据库中定义，超级账号，超级权限

    定义核心配置文件

    # 登录用户所在的数据库
spring.data.mongodb.authentication-database=admin

# 数据库的ip地址
spring.data.mongodb.host=192.168.133.142

# MongoDB端口号
spring.data.mongodb.port=27017

# 用户账号
spring.data.mongodb.username=zlfeng

# 用户密码
spring.data.mongodb.password=123456

# 指定使用的数据库
# 不必预先创建，不存在该数据库会自动创建
spring.data.mongodb.database=db_student

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    五、创建实体类

    package cn.byuan.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import org.springframework.data.annotation.Id;

import java.io.Serializable;
import java.util.Date;

@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
@Data
public class Student implements Serializable {
    @Id// 必须指定id列
    private String studentId;

    private String studentName;

    private Integer studentAge;

    private Double studentScore;
    
    private Date studentBirthday;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    创建dao层，这里的dao层有两种写法

    （一）dao层写法一

    1. 编码部分

      package cn.byuan.dao;

      import cn.byuan.entity.Student;
      import org.springframework.data.mongodb.repository.MongoRepository;

      /*

      • dao层写法一
      • 这里的用法其实和SpringDataJPA相似, 可根据需要来自定义方法
      • 这种写法不需要写实现类
      • MongoRepository<行对应的对象类型, 主键列类型>
      • */
        public interface StudentDaoTypeOne extends MongoRepository {

      // 可根据需求自己定义方法, 无需对方法进行实现
      Student getAllByStudentName(String studentName);

      }

    在这里插入图片描述

    2.测试部分
    在进行测试之前，我们先查询一下数据库，此时不存在db_student的库
    在这里插入图片描述
    开始测试

    package cn.byuan;

import cn.byuan.dao.StudentDaoTypeOne;
import cn.byuan.entity.Student;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;
import java.util.List;

@SpringBootTest
class StudentDaoTypeOneTests {

    @Autowired
    private StudentDaoTypeOne studentDaoTypeOne;

    @Test
    void addOneStudent(){
//        插入10行
        for (Integer count = 0; count < 10; count++) {
            Student student = new Student()
                    .setStudentId("student_"+count) //如果自己不去设置id则系统会分配给一个id
                    .setStudentName("Godfery"+count)
                    .setStudentAge(count)
                    .setStudentScore(98.5-count)
                    .setStudentBirthday(new Date());
            studentDaoTypeOne.save(student);
        }
    }

    @Test
    void deleteOneStudentByStudentId(){
//        删除id为student_0的学生
        studentDaoTypeOne.deleteById("student_0");
    }

    @Test
    void updateOneStudent(){
//        修改姓名为Godfery1的Student年龄为22
        Student student = studentDaoTypeOne.getAllByStudentName("Godfery1");
        student.setStudentAge(22);
        studentDaoTypeOne.save(student);

    }

    @Test
    void getOneStudentByStudentId(){
        System.out.println(studentDaoTypeOne.findById("student_1"));
    }

    @Test
    void getAllStudent(){
        List studentList = studentDaoTypeOne.findAll();
        studentList.forEach(System.out::println);
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    （二）dao层写法二
    1.编码部分
    接口部分

    package cn.byuan.dao;

import cn.byuan.entity.Student;

import java.util.List;

/*
* dao层写法二
*
* 写法二需要进行实现
* */
public interface StudentDaoTypeTwo {
//    增加一位学生
    void addOneStudent(Student student);

//    根据id删除一位学生
    void deleteOneStudentByStudentId(String studentId);

//    修改一位学生的信息
    void updateOneStudent(Student student);

//    根据主键id获取一名学生
    Student getOneStudentByStudentId(String studentId);

//    获取全部学生
    List getAllStudent();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    实现类

    package cn.byuan.dao.imp;

import cn.byuan.dao.StudentDaoTypeTwo;
import cn.byuan.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class StudentDaoTypeTwoImp implements StudentDaoTypeTwo {

//    使用MongoTemplate模板类实现数据库操作
    @Autowired
    private MongoTemplate mongoTemplate;

//    增加一位学生
    public void addOneStudent(Student student){
        mongoTemplate.save(student);

    }

//    根据id删除一位学生
    public void deleteOneStudentByStudentId(String studentId){
        Student student = mongoTemplate.findById(studentId, Student.class);
        if(student != null){
            mongoTemplate.remove(student);
        }

    }

//    修改一位学生的信息
    public void updateOneStudent(Student student){
        mongoTemplate.save(student);
    }

//    根据主键id获取一名学生
    public Student getOneStudentByStudentId(String studentId){
        return mongoTemplate.findById(studentId, Student.class);
    }

//    获取全部学生
    public List getAllStudent(){
        return mongoTemplate.findAll(Student.class);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    2.测试部分

    package cn.byuan;

import cn.byuan.dao.StudentDaoTypeOne;
import cn.byuan.dao.StudentDaoTypeTwo;
import cn.byuan.entity.Student;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;
import java.util.List;

@SpringBootTest
class StudentDaoTypeTwoTests {

    @Autowired
    private StudentDaoTypeTwo studentDaoTypeTwo;

    @Test
    void addOneStudent(){
//        插入10行
        for (Integer count = 0; count < 10; count++) {
            Student student = new Student()
                    .setStudentId("study_"+count) //如果自己不去设置id则系统会分配给一个id
                    .setStudentName("Echo"+count)
                    .setStudentAge(count)
                    .setStudentScore(98.5-count)
                    .setStudentBirthday(new Date());
            studentDaoTypeTwo.addOneStudent(student);
        }
    }

    @Test
    void deleteOneStudentByStudentId(){
//        删除id为study_0的学生
        studentDaoTypeTwo.deleteOneStudentByStudentId("study_0");
    }

    @Test
    void updateOneStudent(){
//        修改id为study_1的Student年龄为21
        Student student = studentDaoTypeTwo.getOneStudentByStudentId("study_1");
        student.setStudentAge(21);
        studentDaoTypeTwo.updateOneStudent(student);

    }

    @Test
    void getOneStudentByStudentId(){
        System.out.println(studentDaoTypeTwo.getOneStudentByStudentId("study_1"));
    }

    @Test
    void getAllStudent(){
        List studentList = studentDaoTypeTwo.getAllStudent();
        studentList.forEach(System.out::println);
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59

    在这里插入图片描述

    进入数据库查看一下数据
    在这里插入图片描述
    原文地址：https://www.cnblogs.com/byuan/p/14992548.html

    MongoTemplate基本使用

    一、普通查询操作

    1.is查询

    Query query = new Query();
// where...is... 相当于 where ? = ?
query.addCriteria(Criteria.where("数据库字段名").is("你的参数"));
// findOne 返回的是一个对象 Class代表你的表对应的映射类
mongoTemplate.findOne(query, Class.class);
// find 返回的是数组
mongoTemplate.find(query, Class.class);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    2.in查询

    ArrayList list = new ArrayList<>();
// list代表你的数据
Query query = Query.query(Criteria.where("数据库字段").in(list));
mongoTemplate.find(query, Class.class);


// 如果想要查询指定的数据是否在数据库的数组中，可以用以下方法
Query query = Query.query(Criteria.where("数据库字段（数组）").is("你的数组"));

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3.字符模糊查询

    Query query = Query.query(Criteria.where("name").regex("小"));

    • 1

    4.指定字段不返回

    query.fields().exclude("field");

    • 1

    5.数组中添加或删除一条数据

    Query query = Query.query(Criteria.where("_id").is("id"));
Update update = new Update();
// push方法可以在数组中添加一条数据
// pull方法可以在数组中删除一条数据
// update.pull()
update.push("字段名称", "data");
mongoTemplate.updateFirst(query, update, Class.class);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    6.批量添加

    ArrayList list = new ArrayList<>();
mongoTemplate.insert(list, Class.class);

    • 1
    • 2

    7.数组查询

    数组格式：
{
    name:"小明",
    age:13,
    friends:[
        {
            name:"小王",
            age:12
        },
        {
            name:"小李",
            age:18
        }
    ]
}


当要查询朋友中姓名为小王时
Query query = new Query();
query.addCriteria(Criteria.where("friends.$.name").is("小王"));
mongoTemplate.find(query, User.class);


同样更新时也是一样，但是注意，更新时查询条件需要添加
query.addCriteria(Criteria.where("friends").elemMatch(Criteria.where("name").is("小王"));
Update update = Update.update("friends.$.friends", "小赵");

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    8.数字字符串排序操作

    对数据库中数字字符串排序：
加上这一行就行了 亲身体验
query.collation(Collation.of("zh").numericOrdering(true));
还有根据字符串排序时又是顺序并不是我们所想的字典序,加上下面这个也ok
query.collation(Collation.of("zh"));

    • 1
    • 2
    • 3
    • 4
    • 5

    9.分页

    //分页
query.limit(10);
//排序
Sort sort=Sort.by(Sort.Direction.DESC,"timestamp");
query.with(sort);

    • 1
    • 2
    • 3
    • 4
    • 5

    Criteria浅解

    关键字

    解释

    eq

    等于，第一个参数是对象属性，第二个参数是值

    allEq

    参数为一个Map对象，相当于多个eq的叠加

    gt

    大于

    ge

    大于等于

    lt

    小于

    le

    小于等于

    between

    在两个值之间Expression.between(“age”,new Integer(10),new Integer(20));

    like

    like查询

    in

    in查询

    先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。自己不成体系的自学效率很低又漫长，而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。添加下方名片，即可获取全套学习资料哦

  • 相关阅读:
    10 个最佳地理空间数据分析 GIS 软件
    docker 安装nacos
    2022 年 前40道 ReactJS 面试问题和答案
    观测云产品更新 | 监控、图表、服务管理、单点登录、Pipeline 等优化
    计算机毕业设计ssmJava防作弊的电子投票系统rgobs系统+程序+源码+lw+远程部署
    前端周刊第二十期
    Ubuntu中关闭防火墙
    windows10下安装和配置nodejs环境
    33.Mybatis-Plus
    关于matplotlib的一些小技巧
  • 原文地址：https://blog.csdn.net/m0_67402235/article/details/126114852