springboot学习笔记----使用 MongoTemp

发表于

简介：当前这个笔记 记录啦 springboot项目中 如何连接 mongo 并对其集合进行相关操作 主要使用 MongoTemplate 和 MongoRepository 操作的集合

1
2
js复制代码 MongoTemplate使用起来比较灵活 可以根据mongo相关操作数据库语言进行操作
 MongoRepository 封装性良好 不但封装啦基础的增删改查 相关构造条件查询 也可以根据规则在接口中自定义相关方法 对应相应的mongo语句  使用起来比较简单

maven引入依赖

1
2
3
4
5
xml复制代码<!--版本号 我这里在父工程指定了 有需要百度  [maven spring-boot-starter-data-mongodb] 进入网页自己选择版本号-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

application.properties 配置连接信息

1
2
xml复制代码#配置信息的参数                    主机地址      端口号  要连数据库名称
spring.data.mongodb.uri=mongodb://192.168.6.100:27017/test

springboot启动原理 会加载124个配置类 【自动配置类检查相应的类是否存在或加载 属性配置类加载配置文件相应的属性】 自动生成相应的操作对象 所以只要添加相应依赖 和 配置连接属性 会自动创建 MongoTemplate 对象 所以直接注入即可

使用 MongoTemplate 操作集合

跟文档数据属性相对应的模型类 User

1
2
3
4
5
6
7
8
9
10
11
12
13
14
java复制代码import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Data
@Document(collection = "user")      //实体模型对应的集合名称
public class User {
    @Id   //【主键是自动生成的】
    private String id;
    private String username;
    private Integer age;
    private String password;
    private String address;
}

controller层代码

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
java复制代码
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

@RestController
@RequestMapping("/mongo1")
public class TestMongo1 {

    //这个对象 是自动创建出来的 这个关系到springboot启动该原理在开头有解释
    @Autowired
    private MongoTemplate mongoTemplate;

    @GetMapping("create")
    public void createUser(){
        User user = new User();
        user.setAge(20);
        user.setUsername("test");
        user.setAddress("4932200@qq.com");
        User user1 = mongoTemplate.insert(user);

        //返回来 有自己生成的 id
        System.out.println(user1);
    }


    //查询所有
    @GetMapping("findAll")
    public void findUser() {
        List<User> userList = mongoTemplate.findAll(User.class);
        System.out.println("userList = " + userList);
    }

    //根据id查询
    @GetMapping("findById")
    public User getById(){
        User user = mongoTemplate.findById("614196627e7800008b0037a5", User.class);
        return user;
    }

    //条件查询
    @GetMapping("findUser")
    public List<User> findUserList() {

        //筛选条件
        Query query = new Query(Criteria
                .where("username").is("张三")
                .and("age").is(23)
        );

        //执行查询
        List<User> userList = mongoTemplate.find(query, User.class);
        return userList;

    }

    //模糊查询
    @GetMapping("findLike")
    public List<User> findUsersLikeName() {
        //正则表达式 模糊查询【】
        String username = "张";
        String regex = String.format("%s%s%s", "^.*", username, ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        //名字符合正则表达式的条件 
        Query query = new Query(Criteria.where("username").regex(pattern));
        //mongodb 文档相对应的模型类
        List<User> userList = mongoTemplate.find(query, User.class);
        return userList;
    }

    //分页查询
    @GetMapping("findPage")
    public void findUsersPage() {
        String name = "est";
        int pageNo = 1;
        int pageSize = 10;
        
        //构造条件
        Query query = new Query();
        //正则表达式匹配
        String regex = String.format("%s%s%s", "^.*", name, ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        //添加条件
        query.addCriteria(Criteria.where("name").regex(pattern));
        //开始统计记录数
        int totalCount = (int) mongoTemplate.count(query, User.class);
        //分页查询 返回结果
        List<User> userList = mongoTemplate.find(query.skip((pageNo - 1) * pageSize).limit(pageSize), User.class);

        Map<String, Object> pageMap = new HashMap<>();
        pageMap.put("list", userList);
        pageMap.put("totalCount",totalCount);
        System.out.println(pageMap);
    }
    //修改
    @GetMapping("update")
    public void updateUser() {
        //修改一般是查询出来整个文档【document mongodb里面的叫法】
        User user = mongoTemplate.findById("5ffbfa2ac290f356edf9b5aa", User.class);
        user.setUsername("test_1");
        user.setAge(25);
        user.setPassword("493220990@qq.com");
        
        //修改好相应的数据 根据id进行修改 id是查询出来的
        Query query = new Query(Criteria.where("_id").is(user.getId()));
        Update update = new Update();
        update.set("username", user.getUsername());
        update.set("age", user.getAge());
        update.set("password", user.getPassword());
        //执行更新
        UpdateResult result = mongoTemplate.upsert(query, update, User.class);
        long count = result.getModifiedCount();
        System.out.println(count);
    }

    //删除操作
    @GetMapping("delete")
    public void delete() {
    
       //构造条件 根据id删除相应的文档
        Query query =
                new Query(Criteria.where("_id").is("5ffbfa2ac290f356edf9b5aa"));
        DeleteResult result = mongoTemplate.remove(query, User.class);
        long count = result.getDeletedCount();
        System.out.println(count);
    }



}

使用 MongoRepository 操作集合

Spring Data提供了对mongodb数据访问的支持，我们只需要继承MongoRepository类，按照Spring Data规范就可以了

image.png

image.png
SpringData 方法定义规范

1、不是随便声明的，而需要符合一定的规范

2、 查询方法以find | read | get开头

3、 涉及条件查询时，条件的属性用条件关键字连接

4、 要注意的是：条件属性首字母需要大写

5、 支持属性的级联查询，但若当前类有符合条件的属性则优先使用，而不使用级联属性,若需要使用级联属性，则属性之间使用_强制进行连接

实现 UserRepository 接口

1
2
3
4
5
6
7
8
9
10
11
12
13
java复制代码import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface UserRepository extends MongoRepository<User,String> {

    //这两个方法 是跟据匹配规则自定义出来的方法
    List<User> findByUsername(String username);

    List<User> findByUsernameLike(String username);
}

controller层代码

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
java复制代码import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.ExampleMatcher;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/mongo2")
public class TestMongo2 {
    
    @Autowired
    private UserRepository userRepository;
    
    //添加
    @GetMapping("create")
    public User createUser(){
        User user = new User();
        user.setUsername("王恒润");
        user.setPassword("admin");
        user.setAge(22);
        user.setAddress("河北省邢台市 纳河区 郝桥镇 缴存 225");

        User user1 = userRepository.insert(user);
        return user1;
    }

    //查询所有
    @GetMapping("findAll")
    public List<User> findAll(){
        List<User> userList = userRepository.findAll();
        return userList;
    }

    //根据id查询
    @GetMapping("findId")
    public User getById(){
      return userRepository.findById("614196627e7800008b0037a5").get();
    }

    //条件查询
    @GetMapping("findQuery")
    public List<User> findUserList(){
        User user = new User();
        user.setUsername("王恒润");
        user.setAge(22);
        Example<User> userExample = Example.of(user);
        return userRepository.findAll(userExample);
    }

    //模糊查询
    @GetMapping("findLike")
    public void findUsersLikeName() {
        //创建匹配器，即如何使用查询条件
        ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
                .withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写
        User user = new User();
        user.setUsername("三");
        Example<User> userExample = Example.of(user, matcher);
        List<User> userList = userRepository.findAll(userExample);
        System.out.println(userList);
    }

    //分页查询
    @GetMapping("findPage")
    public void findUsersPage() {
         Sort sort = Sort.by(Sort.Direction.DESC, "age");
        //0为第一页
        Pageable pageable = PageRequest.of(0, 10, sort);
        //创建匹配器，即如何使用查询条件
        ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
                        .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
                .withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写
        User user = new User();
        user.setName("三");
        Example<User> userExample = Example.of(user, matcher);
//创建实例
        Example<User> example = Example.of(user, matcher);
        Page<User> pages = userRepository.findAll(example, pageable);
        System.out.println(pages);
    }

    //修改
    @GetMapping("update")
    public void updateUser() {
        //先根据id查询问文档信息 
        User user = userRepository.findById("60b8d57ed539ed5b124942de").get();
        user.setUsername("张三_1");
        user.setAge(25);
        user.setPassword("883220990@qq.com");
        //如果当前文档存在 自动执行更新
        User save = userRepository.save(user);
        System.out.println(save);
    }

    //删除
    @GetMapping("delete")
    public void delete() {
        userRepository.deleteById("60b8d57ed539ed5b124942de");
    }

    //接口中自定义查询方法
    @GetMapping("findByUsername")
    public List<User> findByUsername(String username){
      return userRepository.findByUsername(username);
    }

2021-9-17 更新使用MongoRepository 实现分页查询

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
java复制代码@Override

//参数介绍  第几页 每页多少条  跟数据库映射的实体类
public Page<Department> selectPage(Integer page, Integer limit, DepartmentQueryVo departmentQueryVo) {

    //分页  根据 createTime 排序  排序规则：DESC
    Sort sort = Sort.by(Sort.Direction.DESC,"createTime");
    
    //第几页 每页多少条 排序规则
    Pageable pageable = PageRequest.of(page-1,limit,sort);

    //条件
    //条件构造器
    //当前创建 文档映射 实体类对象
    Department department = new Department();
    
    //想要往集合插入数据 需要将跟数据库映射的实体类数据 变成跟文档映射的实体类【两个实体类的源码放后边了】
    BeanUtils.copyProperties(departmentQueryVo,department);
    department.setIsDeleted(0);

    //匹配器：指定当前条件模糊查询
    ExampleMatcher matcher = ExampleMatcher.matching()
            .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING)
            .withIgnoreCase(true);

    //整合匹配器 和 条件构造器
    Example<Department> example = Example.of(department,matcher);

    //从这里反推 需要什么参数 就创建什么 一直推到第一行  最后返回 page对象
    Page<Department> departments = departmentRepository.findAll(example, pageable);
    return departments;
}

两个实体类的源码

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
java复制代码//
@Data
@ApiModel(description = "Department")
public class DepartmentQueryVo {
   
   @ApiModelProperty(value = "医院编号")
   private String hoscode;

   @ApiModelProperty(value = "科室编号")
   private String depcode;

   @ApiModelProperty(value = "科室名称")
   private String depname;

   @ApiModelProperty(value = "大科室编号")
   private String bigcode;

   @ApiModelProperty(value = "大科室名称")
   private String bigname;

}



//跟集合交互的文档实体类 声明当前文档的集合 为Department【mongo中的集合】
@Data
@ApiModel(description = "Department")
@Document("Department")
public class Department extends BaseMongoEntity {
   
   private static final long serialVersionUID = 1L;

   @ApiModelProperty(value = "医院编号")
   @Indexed //普通索引
   private String hoscode;

   @ApiModelProperty(value = "科室编号")
   @Indexed(unique = true) //唯一索引
   private String depcode;

   @ApiModelProperty(value = "科室名称")
   private String depname;

   @ApiModelProperty(value = "科室描述")
   private String intro;

   @ApiModelProperty(value = "大科室编号")
   private String bigcode;

   @ApiModelProperty(value = "大科室名称")
   private String bigname;

}

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%