mongoDB--SpringBoot整合

SpringBoot MongoDB

spring-data-mongodb提供了两种方式访问mongodb：
（1）MongoTemplate
（2）MongoRepository
MongoRepository操作简单，MongoTemplate操作灵活;

前置配置

1、添加依赖

        <!--mongoDB依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>

2、配置mongodb

# mongoDB配置，# 格式：mongodb://用户名:密码@主机:端口/认证数据库?选项
spring.data.mongodb.uri=mongodb://root:root@0.90.0.0:27017/tahacoo?authSource=admin

authSource 用于指定认证数据库的名称。在 MongoDB 中，用户信息存储在特定的数据库里，当你使用用户名和密码进行认证时，
MongoDB 需要知道去哪个数据库里查找用户信息。默认情况下，如果不指定 authSource，MongoDB 会尝试在连接字符串中指定的目标数据库里查找用户信息，
但很多时候用户信息是存储在 admin 数据库中的。
3、添加实体类

package com.tahacoo.exercise.mongo.model;

import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.bson.types.ObjectId;

@ToString
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User implements Serializable {
    
    private ObjectId id;
    private Double age;
    private Object name;
    private Boolean sex;
  
    public void setId(ObjectId id){
    this.id = id;
    }
    public void setAge(Double age){
    this.age = age;
    }
    public void setName(Object name){
    this.name = name;
    }
    public void setSex(Boolean sex){
    this.sex = sex;
    }
    public ObjectId getId(){
    return this.id;
    }
    public Double getAge(){
    return this.age;
    }
    public Object getName(){
    return this.name;
    }
    public Boolean getSex(){
    return this.sex;
    }

}

MongoTemplate

常用方法

常用方法

mongoTemplate.findAll(User.class): 查询User文档的全部数据

mongoTemplate.findById(, User.class): 查询User文档id为id的数据

mongoTemplate.find(query, User.class);: 根据query内的查询条件查询

mongoTemplate.upsert(query, update, User.class): 修改

mongoTemplate.remove(query, User.class): 删除

mongoTemplate.insert(User): 新增

Query对象

1、创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）

2、精准条件：criteria.and(“key”).is(“条件”) 模糊条件：criteria.and(“key”).regex(“条件”)

3、封装条件：query.addCriteria(criteria)

4、大于（创建新的criteria）：Criteria gt = Criteria.where(“key”).gt（“条件”）小于（创建新的criteria）：Criteria lt = Criteria.where(“key”).lt（“条件”）

5、Query.addCriteria(new Criteria().andOperator(gt,lt));

6、一个query中只能有一个andOperator()。其参数也可以是Criteria数组。

7、排序：query.with（new Sort(Sort.Direction.ASC, "age"). and(new Sort(Sort.Direction.DESC, "date")))

代码示例

package com.tahacoo.exercise.mongo;

import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.tahacoo.exercise.mongo.model.User;
import jakarta.annotation.Resource;
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 java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.regex.Pattern;

/**
 * @description: 基于mongoTemplate开发增删改查
 */
public class OperateMongoTemplate {

    @Resource
    private MongoTemplate mongoTemplate;
    
    /**
     * mongoDB插入数据
     * 使用方法：public <T> T insert(T objectToSave)
     */
    
    public void insert(){
        User user = new User();
        user.setName("Qadys");
        user.setAge(25.0);
        user.setSex(true);
        User insert = mongoTemplate.insert(user);
        System.out.println(insert);
    }

    /**
     * mongoDB批量插入
     */
    
    public void insertBatch(){
        ArrayList<User> users = new ArrayList<>();
        users.add(User.builder().name("Aadys").age(30.0).sex(true).build());
        users.add(User.builder().name("Oddys").age(15.0).sex(true).build());
        users.add(User.builder().name("terdys").age(40.0).sex(true).build());
        users.add(User.builder().name("dysia").age(40.0).sex(true).build());
        users.add(User.builder().name("dyswia").age(40.0).sex(true).build());

        Collection<User> insert = mongoTemplate.insert(users, User.class);
        System.out.println(insert);
    }

    /**
     * mongoDB查询所有数据
     * 使用方法：public <T> List<T> findAll(Class<T> entityClass)
     */
    
    public void findAll(){
        List<User> all = mongoTemplate.findAll(User.class);
        System.out.println(all);
    }

    /**
     * mongoDB通过id查询数据
     * public <T> T findById(Object id, Class<T> entityClass)
     */
    
    public void findById(){
        User byId = mongoTemplate.findById("686bd73c35d21f213af2be21", User.class);
        System.out.println(byId);


    }

    /**
     * mongoDB条件查询
     * 使用：public <T> List<T> find(Query query, Class<T> entityClass)
     */
    
    public void findCriteria(){
        Query query = new Query(Criteria.where("name").is("Tom").and("age").is(20));
        List<User> users = mongoTemplate.find(query, User.class);
        System.out.println(users);
    }

    /**
     * mongoDB模糊查询,通过正则表达式实现
     * 1、在使用Pattern.compile函数时，可以加入控制正则表达式的匹配行为的参数：
     *         Pattern Pattern.compile(String regex, int flag)
     * 2、regex设置匹配规则
     * 3、Pattern.CASE_INSENSITIVE,这个标志能让表达式忽略大小写进行匹配。
     * 4、调用public <T> List<T> find(Query query, Class<T> entityClass)查询
     */
    
    public void findLike(){
        String regex = String.format("%s%s%s", "^.*", "dys", ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        List<User> users = mongoTemplate.find(new Query(Criteria.where("name").regex(pattern)), User.class);
        System.out.println(users);
    }

    /**
     * mongoDB Page
     *使用Criteria自带的skip()和limit()方法实现分页查询
     */
    
    public void findPageLike(){
        //1.设置分页条件
        int pageNo = 2; //设置当前页
        int pageSize = 3;//设置每页显示的文档数

        //2.设置模糊查询条件
        String regex = String.format("%s%s%s", "^.*", "dys", ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);

        //3. 分页构建，先查询总文档数，然后根据文档数进行分页
        long count = mongoTemplate.count(new Query(Criteria.where("name").regex(regex)), User.class);

        List<User> users = mongoTemplate.find(new Query(Criteria.where("name").regex(regex)).skip((pageNo - 1) * pageSize).limit(pageSize), User.class);
        System.out.println(String.format("当前页数：%d",pageNo));
        System.out.println(users);
    }

    /**
     *mongoDB update
     * 使用：public UpdateResult upsert(Query query, UpdateDefinition update, Class<?> entityClass)
     */
    
    public void update(){
        List<User> users = mongoTemplate.find(new Query(Criteria.where("name").is("Tom").and("age").is(25)), User.class);
        users.forEach(user -> {user.setSex(false);user.setName("Toms");});
        User user = users.get(0);

        Update update = new Update();
        update.set("name",user.getName());
        update.set("sex",user.getSex());

        UpdateResult upsert = mongoTemplate.upsert(new Query(Criteria.where("_id").is(user.getId())), update, User.class);
        long modifiedCount = upsert.getModifiedCount();//获取到修改受影响的行数
        System.out.println("受影响的条数："+modifiedCount);
    }

    /**
     * mongoDB delete
     * 使用public DeleteResult remove(Query query, Class<?> entityClass)
     */
    
    public void delete(){
        DeleteResult remove = mongoTemplate.remove(new Query(Criteria.where("name").is("Tom")), User.class);
        long deletedCount = remove.getDeletedCount();
        System.out.println("删除的条数："+deletedCount);
    }
}

MongoRepository

SpringData提供了MongoRepository接口，非常方便的实现了增删改查。

我们只需要继承MongoRepository类，按照Spring Data规范就可以了。

SpringData方法规范
SpringData 定义的规范：
查询方法以 find 、read 、get 开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性以首字母大写。

添加Repository接口

package com.tahacoo.exercise.mongo;

import com.tahacoo.exercise.mongo.model.User;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

/**
 * @description: User代表要操作的实体类，String代表ObjectId的类型
 */
@Repository
public interface UserRepository extends MongoRepository<User,String> {
}

代码示例

package com.tahacoo.exercise.mongo;

import com.tahacoo.exercise.mongo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.ExampleMatcher;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;

import java.util.List;

public class OperateMongoRepository {
    
    @Autowired
    UserRepository userRepository;

    /**
     * mongoDB insert
     * 使用<S extends T> S save(S entity);
     */

    
    public void insert(){
        User toms = User.builder().name("Toms").age(25.0).sex(true).build();
        User user = userRepository.save(toms);
        System.out.println(user);
    }

    /**
     * mongoDB select--findAll
     * List<T> findAll();
     */
    
    public void findAll(){
        List<User> all = userRepository.findAll();
        System.out.println(all);
    }

    /**
     * mongoDB select--findById
     * Optional<T> findById(ID id);
     */
    
    public void findById(){
        User user = userRepository.findById("686bd73c35d21f213af2be21").get();
        System.out.println(user);
    }

    /**
     * mongoDB select--where
     * 使用<S extends T> List<S> findAll(Example<S> example);
     */
    
    public void findByWhere(){
        User toms = User.builder().name("Toms").age(25.0).build();
        Example<User> userExample = Example.of(toms);
        List<User> all = userRepository.findAll(userExample);
        System.out.println(all);
    }

    /**
     * mongoDB select--like
     * 1. 使用ExampleMatcher创建匹配规则
     * 2. 使用<S extends T> List<S> findAll(Example<S> example);
     */
    
    public void findByLike(){
        //创建匹配器，即如何使用查询条件
        ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING)//改变默认字符串匹配方式：模糊查询
                .withIgnoreCase(true);//改变默认大小写忽略方式：忽略大小写

        User dys = User.builder().name("dys").build();
        Example<User> userExample = Example.of(dys, matcher);
        List<User> all = userRepository.findAll(userExample);
        System.out.println(all);
    }

    /**
     * mongoDB select--page
     * 1. 使用PageRequest设置分页参数；
     * 2. 使用<S extends T> Page<S> findAll(Example<S> example, Pageable pageable);
     */

    
    public void findByPage(){
        //设置分页参数,0代表第一页
        PageRequest pageRequest = PageRequest.of(0, 3);

        ExampleMatcher matcher = ExampleMatcher.matching().withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING).withIgnoreCase(true);
        //构建查询条件
        User dys = User.builder().name("dys").build();
        Example<User> userExample = Example.of(dys, matcher);

        Page<User> all = userRepository.findAll(userExample, pageRequest);
        System.out.println(all.getContent());
    }

    /**
     * mongoDB update
     * 与保存使用同一个方法<S extends T> S save(S entity);
     * 先查询出需要修改的对象，然后更改对象中的值，然后重新保存；
     */
    
    public void update(){
        //先根据id出要修改的用户
        User user = userRepository.findById("686bde04201a796b917f9ef7").get();
        //设置修改的值
        user.setName("Joudyss");
        User save = userRepository.save(user);
        System.out.println(save);
    }

    /**
     * mongoDB delete
     * void deleteById(ID id);或void delete(T entity);
     */
    
    public void delete(){
        userRepository.deleteById("686bde04201a796b917f9ef7");
    }
}

参考链接：

posted @ 2025-07-09 23:30 joudys 阅读(42) 评论(0) 收藏举报

刷新页面返回顶部

joudys