MongoDB开发效率革命：5分钟上手mongo-plus，告别重复CRUD代码-优快云博客

🔥MongoDB开发效率革命：5分钟上手mongo-plus，告别重复CRUD代码

【免费下载链接】mongo-plus 🔥🔥🔥使用MyBatisPlus的方式，优雅的操作MongoDB 项目地址: https://gitcode.com/aizuda/mongo-plus

你还在手写MongoDB的CRUD操作吗？还在为复杂的查询条件拼接烦恼吗？本文将带你体验mongo-plus带来的开发效率提升，5分钟即可完成从环境搭建到实现完整业务逻辑的全过程，让你像使用MyBatis-Plus一样优雅操作MongoDB。

读完本文你将获得：

掌握mongo-plus的安装与配置技巧
学会使用CRUD接口实现零SQL操作MongoDB
了解高级特性如动态数据源、逻辑删除的实战应用
获取企业级项目的最佳实践指南

为什么选择mongo-plus？

MongoDB作为最流行的NoSQL数据库之一，以其灵活的文档模型和强大的查询能力被广泛应用。但原生Java驱动使用复杂，需要编写大量重复代码：

// 传统MongoDB Java驱动查询示例
MongoCollection<Document> collection = mongoDatabase.getCollection("user");
Document query = new Document("age", new Document("$gt", 18));
FindIterable<Document> result = collection.find(query)
    .skip(10)
    .limit(20)
    .sort(new Document("createTime", -1));
List<User> users = new ArrayList<>();
for (Document doc : result) {
    User user = new User();
    user.setId(doc.getObjectId("_id").toString());
    user.setName(doc.getString("name"));
    // 更多字段映射...
    users.add(user);
}

而使用mongo-plus后，代码简化为：

// 使用mongo-plus查询示例
List<User> users = userService.lambdaQuery()
    .gt(User::getAge, 18)
    .orderByDesc(User::getCreateTime)
    .page(new PageParam(10, 20))
    .getRecords();

mongo-plus核心优势对比

特性	传统驱动	mongo-plus	优势体现
CRUD操作	需要手动构建Document	内置通用接口	减少80%重复代码
查询条件	嵌套Document构造	Lambda链式调用	类型安全，避免字段拼写错误
分页功能	手动计算skip/limit	内置PageParam	一行代码实现分页
主键生成	需手动处理	5种策略自动生成	支持分布式ID，避免重复
逻辑删除	手动拼接条件	注解自动实现	无需修改业务代码
动态数据源	手动切换连接	注解+配置实现	零侵入式切换数据源

环境准备与安装

系统要求

依赖	版本要求	备注
JDK	8+	推荐JDK 17获得更好性能
MongoDB	4.0+	支持所有主流版本
Spring Boot	2.0+	如使用Spring集成
Maven	3.5+	构建工具

快速安装

方式一：Maven依赖（推荐）

在Spring Boot项目的pom.xml中添加以下依赖：

<!-- mongo-plus启动器 -->
<dependency>
    <groupId>com.mongoplus</groupId>
    <artifactId>mongo-plus-boot-starter</artifactId>
    <version>2.1.9</version>
</dependency>

<!-- MongoDB驱动 -->
<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver-sync</artifactId>
    <version>4.6.0</version>
</dependency>

方式二：源码编译安装

# 克隆代码仓库
git clone https://gitcode.com/aizuda/mongo-plus.git
cd mongo-plus

# 编译安装到本地仓库
mvn clean install -Dmaven.test.skip=true

快速入门实战

1. 配置文件

在application.yml中添加MongoDB连接配置：

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/mongoplus_demo
      username: admin
      password: 123456
      database: mongoplus_demo

# mongo-plus配置
mongoplus:
  # 开启日志打印
  log: true
  # 主键生成策略
  id-type: AUTO
  # 逻辑删除配置
  logic-delete:
    enable: true
    field: deleted
    value: 1
    not-value: 0

2. 创建实体类

package com.example.demo.entity;

import com.mongoplus.annotation.ID;
import com.mongoplus.annotation.collection.Collection;
import com.mongoplus.annotation.logice.LogicDelete;
import com.mongoplus.enums.IdTypeEnum;
import lombok.Data;
import java.time.LocalDateTime;

@Data
@Collection("user") // 指定集合名
public class User {
    
    @ID(type = IdTypeEnum.AUTO) // 自动生成ID
    private String id;
    
    private String name;
    
    private Integer age;
    
    private String email;
    
    private LocalDateTime createTime;
    
    @LogicDelete // 逻辑删除字段
    private Integer deleted;
}

3. 创建Mapper接口

package com.example.demo.mapper;

import com.example.demo.entity.User;
import com.mongoplus.mapper.BaseMapper;

public interface UserMapper extends BaseMapper<User> {
    // 无需编写实现代码，继承BaseMapper即可获得所有CRUD方法
}

4. 创建Service层

package com.example.demo.service;

import com.example.demo.entity.User;
import com.mongoplus.service.IService;

public interface UserService extends IService<User> {
}

package com.example.demo.service.impl;

import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import com.example.demo.service.UserService;
import com.mongoplus.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

5. 控制器层实现

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import com.mongoplus.model.PageResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.List;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    // 添加用户
    @PostMapping
    public String addUser(@RequestBody User user) {
        user.setCreateTime(LocalDateTime.now());
        boolean save = userService.save(user);
        return save ? "添加成功" : "添加失败";
    }

    // 更新用户
    @PutMapping
    public String updateUser(@RequestBody User user) {
        boolean update = userService.updateById(user);
        return update ? "更新成功" : "更新失败";
    }

    // 删除用户(逻辑删除)
    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable String id) {
        boolean remove = userService.removeById(id);
        return remove ? "删除成功" : "删除失败";
    }

    // 查询用户
    @GetMapping("/{id}")
    public User getUser(@PathVariable String id) {
        return userService.getById(id);
    }

    // 分页查询
    @GetMapping("/page")
    public PageResult<User> getUserPage(
            @RequestParam Integer pageNum, 
            @RequestParam Integer pageSize) {
        return userService.lambdaQuery()
                .orderByDesc(User::getCreateTime)
                .page(new com.mongoplus.model.PageParam(pageNum, pageSize));
    }

    // 复杂条件查询
    @GetMapping("/list")
    public List<User> getUserList(
            @RequestParam(required = false) String name,
            @RequestParam(required = false) Integer minAge,
            @RequestParam(required = false) Integer maxAge) {
        
        return userService.lambdaQuery()
                .like(name != null, User::getName, name)
                .ge(minAge != null, User::getAge, minAge)
                .le(maxAge != null, User::getAge, maxAge)
                .orderByAsc(User::getAge)
                .list();
    }
}

核心功能详解

强大的条件构造器

mongo-plus提供了两种条件构造方式，满足不同场景需求：

Lambda条件构造器（推荐）

类型安全，编译期检查字段名：

// 查询年龄大于18，邮箱不为空，按创建时间倒序的前10条数据
List<User> users = userService.lambdaQuery()
    .gt(User::getAge, 18)
    .isNotNull(User::getEmail)
    .orderByDesc(User::getCreateTime)
    .last("limit 10")
    .list();

普通条件构造器

适合动态字段名场景：

// 动态条件查询
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 18)
    .isNotNull("email")
    .orderByDesc("createTime")
    .last("limit 10");
List<User> users = userService.list(queryWrapper);

分页查询

mongo-plus内置分页功能，无需额外配置：

// 分页查询第2页，每页10条数据
PageParam pageParam = new PageParam(2, 10);
PageResult<User> pageResult = userService.lambdaQuery()
    .ge(User::getAge, 18)
    .page(pageParam);

// 分页结果处理
long total = pageResult.getTotal(); // 总记录数
int pages = pageResult.getPages(); // 总页数
List<User> records = pageResult.getRecords(); // 当前页数据

分页查询执行流程：

mermaid

逻辑删除

通过注解自动实现逻辑删除，不影响物理数据：

// 逻辑删除实现原理
update user 
set deleted = 1 
where id = ? and deleted = 0

使用方法：

在实体类字段上添加@LogicDelete注解
配置文件中设置逻辑删除字段和值

mongoplus:
  logic-delete:
    enable: true
    field: deleted  # 逻辑删除字段名
    value: 1        # 删除值
    not-value: 0    # 未删除值

执行删除操作时，mongo-plus会自动将delete操作转为update操作，查询时自动添加deleted=0条件。

动态数据源

mongo-plus支持多数据源切换，只需简单配置：

添加多数据源配置：

mongoplus:
  datasource:
    # 主数据源
    primary: main
    # 数据源列表
    datasources:
      main:
        uri: mongodb://localhost:27017/main_db
      log:
        uri: mongodb://localhost:27017/log_db
      user:
        uri: mongodb://localhost:27017/user_db

在Mapper或方法上添加@DataSource注解切换数据源：

// 类级别指定数据源
@DataSource("user")
public interface UserMapper extends BaseMapper<User> {
    
    // 方法级别指定数据源，优先级高于类级别
    @DataSource("log")
    List<OperateLog> getUserOperateLog(String userId);
}

高级特性与最佳实践

自定义ID生成策略

mongo-plus提供5种内置ID生成策略：

public enum IdTypeEnum {
    AUTO,           // 自动生成(默认)
    NONE,           // 不生成ID
    INPUT,          // 用户输入ID
    UUID,           // UUID生成
    SNOWFLAKE       // 雪花算法(分布式ID)
}

使用方式：

@ID(type = IdTypeEnum.SNOWFLAKE)
private Long id;

字段自动填充

通过@FieldFill注解实现字段自动填充：

public class User {
    // ...其他字段
    
    @FieldFill(FieldFill.INSERT) // 插入时自动填充
    private LocalDateTime createTime;
    
    @FieldFill(FieldFill.INSERT_UPDATE) // 插入和更新时自动填充
    private LocalDateTime updateTime;
}

实现元对象处理器：

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    
    @Override
    public void insertFill(MetaObject metaObject) {
        // 设置创建时间
        this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now());
        // 设置更新时间
        this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }
    
    @Override
    public void updateFill(MetaObject metaObject) {
        // 设置更新时间
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }
}

拦截器使用

mongo-plus支持自定义拦截器，实现SQL拦截、数据脱敏等功能：

@Component
public class MyInterceptor implements Interceptor {
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 执行前处理
        System.out.println("执行前：" + invocation.getMethod().getName());
        
        // 执行目标方法
        Object result = invocation.proceed();
        
        // 执行后处理
        System.out.println("执行后：" + result);
        
        return result;
    }
    
    // 指定拦截的方法
    @Override
    public List<Signature> getSignature() {
        return Arrays.asList(
            new Signature("insert", Object.class),
            new Signature("updateById", boolean.class, Object.class)
        );
    }
}

企业级应用最佳实践

项目结构推荐

com.example.demo
├── config/           # 配置类
│   ├── MongoPlusConfig.java  # mongo-plus配置
│   └── MyMetaObjectHandler.java # 元对象处理器
├── controller/       # 控制器
├── service/          # 服务层
│   ├── impl/         # 服务实现
├── mapper/           # Mapper接口
├── entity/           # 实体类
├── dto/              # 数据传输对象
├── vo/               # 视图对象
└── interceptor/      # 拦截器

性能优化建议

索引优化：为查询频繁的字段创建索引

@Index(value = "name", direction = IndexDirection.ASC) // 单字段索引
@CompoundIndex(name = "age_email_idx", def = "{'age': 1, 'email': -1}") // 复合索引
public class User {
    // ...
}

批量操作：大量数据操作使用批量接口

// 批量插入
List<User> userList = new ArrayList<>();
// 添加数据...
userService.saveBatch(userList, 1000); // 每1000条一批次

// 批量更新
userService.updateBatchById(userList, 500);

投影查询：只查询需要的字段，减少数据传输

List<User> users = userService.lambdaQuery()
    .select(User::getId, User::getName, User::getAge) // 只查询指定字段
    .list();

常见问题与解决方案

Q1: 启动时报错"找不到MongoClient"

A: 检查是否添加了mongodb-driver依赖，mongo-plus需要依赖官方驱动。

Q2: 分页查询返回total为0

检查逻辑删除配置是否正确，是否过滤了所有数据
确认查询条件是否正确，是否有数据满足条件
检查MongoDB连接是否正常，是否连错了数据库

Q3: 逻辑删除后查询不到数据

A: 这是正常现象，逻辑删除后mongo-plus会自动过滤已删除数据。如需查询全部数据（包括已删除），可使用：

userService.lambdaQuery()
    .eq(User::getId, id)
    .disableLogicDelete() // 禁用逻辑删除过滤
    .one();

Q4: 如何实现复杂的聚合查询

A: 使用mongo-plus的AggregateWrapper：

AggregateWrapper<User> aggregateWrapper = new AggregateWrapper<>();
// 分组统计
aggregateWrapper.group("age")
    .count("id", "userCount")
    .first("age", "age");
// 过滤
aggregateWrapper.match(Criteria.where("userCount").gt(10));
// 排序
aggregateWrapper.sort(Sort.by(Sort.Order.desc("userCount")));

List<Map<String, Object>> result = userService.aggregate(aggregateWrapper);

总结与展望

mongo-plus作为一款优秀的MongoDB增强工具，通过提供类似MyBatis-Plus的API风格，极大降低了MongoDB的使用门槛，大幅提升了开发效率。本文介绍了mongo-plus的安装配置、核心功能和高级特性，从入门到精通只需5分钟。

主要优势回顾：

无侵入设计，可与现有项目无缝集成
丰富的CRUD接口，减少80%重复代码
强大的条件构造器，支持Lambda表达式
完善的高级特性，满足企业级需求
优秀的性能表现，无额外性能损耗

未来，mongo-plus将继续迭代优化，计划支持更多高级特性如分布式事务、更丰富的聚合操作等。

如果你觉得本文对你有帮助，请点赞、收藏、关注三连支持，你的支持是我们持续优化的动力！下一篇将带来《mongo-plus高级实战：从分库分表到数据脱敏》，敬请期待。

【免费下载链接】mongo-plus 🔥🔥🔥使用MyBatisPlus的方式，优雅的操作MongoDB 项目地址: https://gitcode.com/aizuda/mongo-plus

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考