Mybatis-Plus一文详解BaseMapper和Service 使用

MyBatis-Plus零基础极速入门全套实战教程｜逻辑清晰+配置齐全+全代码可直接运行

前言：很多同学学MyBatis-Plus觉得教程杂乱、章节跳脱、配置缺漏、代码跑不起来。本篇重新梳理标准学习逻辑，从「是什么→为什么搭环境→怎么配置→一键生成代码→每层代码详解→CRUD实操→条件构造器→业务层使用→分页插件→联表查询」循序渐进，结构工整、内容全覆盖，无删减、无错乱，新手照着一步步做百分百成功运行。

一、MyBatis-Plus核心介绍（必懂基础）

1.1 什么是MyBatis-Plus？

MyBatis-Plus简称MP，不是替代MyBatis，而是对MyBatis做增强，核心原则：只做增强、不做修改、零侵入。

原生MyBatis开发单表业务，需要手写大量重复CRUD SQL、XML映射语句，字段易写错、冗余代码多、开发效率极低。而MyBatis-Plus内置通用CRUD、条件构造器、代码生成器、分页插件等核心能力，单表开发零SQL即可完成所有增删改查操作。

1.2 核心实战特性（企业开发必备）

• 零侵入兼容：不改动原有MyBatis代码，老项目直接引入依赖即可使用，无缝迁移
• 性能损耗极小：启动自动注入基础CRUD方法，运行性能和原生MyBatis几乎一致
• 内置通用CRUD：BaseMapper、IService顶层封装，单表增删改查无需手写一行SQL
• Lambda类型安全查询：直接引用实体类属性，杜绝数据库字段名拼写错误
• 自动主键生成：默认分布式雪花算法ID，单机、分布式项目主键唯一无需自增
• 一键代码生成器：自动生成Entity、Mapper、Service、Controller、XML全套分层代码
• 多功能插件支持：物理分页、SQL性能分析、逻辑删除、全表操作防护全覆盖
• 全数据库适配：兼容MySQL、Oracle、SQLServer等主流关系型数据库

二、SpringBoot整合MyBatis-Plus完整环境搭建

2.1 核心Maven依赖pom.xml（直接复制可用）

新建SpringBoot项目，引入MP核心、数据库驱动、代码生成器、Lombok全套必备依赖，版本适配稳定无冲突。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>mybatis-plus-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatis-plus-demo</name>
    <description>MyBatis-Plus标准实战项目</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-boot.version>2.6.13</spring-boot.version>
        <mybatis-plus.version>3.5.1</mybatis-plus.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- SpringBoot核心Web依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 单元测试依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- MyBatis-Plus核心启动依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

        <!-- MyBatis-Plus代码生成器依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

        <!-- 代码生成器模板引擎 -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity</artifactId>
            <version>1.7</version>
        </dependency>

        <!-- 多表联查拓展依赖（可选必备） -->
        <dependency>
            <groupId>com.github.yulichang</groupId>
            <artifactId>mybatis-plus-join</artifactId>
            <version>1.2.4</version>
        </dependency>

        <!-- MySQL数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
            <scope>runtime</scope>
        </dependency>

        <!-- Lombok简化实体类代码 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <!-- 版本统一管理 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <!-- Maven编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- SpringBoot打包插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
            </plugin>
        </plugins>
    </build>
</project>

2.2 application.yml核心配置文件（数据库+日志必备）

配置数据库连接、Mapper扫描路径、SQL日志打印，开发环境可视化执行SQL，方便调试排错。

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/mp_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true&useSSL=false
    username: root
    password: 123456

mybatis-plus:
  # 扫描Mapper XML文件路径
  mapper-locations: classpath:mapper/*.xml
  # 开启驼峰命名自动映射
  configuration:
    map-underscore-to-camel-case: true
    # 控制台打印完整执行SQL
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

2.3 启动类配置Mapper扫描（必须配置，否则报错）

启动类添加@MapperScan注解，扫描所有Mapper接口，让MyBatis-Plus自动识别DAO层。

package com.example.mybatisplus;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

// 扫描Mapper接口所在包
@MapperScan("com.example.mybatisplus.mapper")
@SpringBootApplication
public class MybatisPlusApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusApplication.class, args);
    }
}

三、MyBatis-Plus代码生成器（一键生成全套分层代码）

无需手动逐层新建类，运行以下工具类，一键生成Entity实体、Mapper接口、Service业务层、Controller控制器、MapperXML所有基础代码，省时不重复。

package com.example.mybatisplus.utils;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.engine.VelocityTemplateEngine;
import java.util.Collections;

public class MpCodeGenerator {
    public static void main(String[] args) {
        // 数据库连接信息
        String dbUrl = "jdbc:mysql://127.0.0.1:3306/mp_db?serverTimezone=Asia/Shanghai";
        String dbUser = "root";
        String dbPwd = "123456";
        // 代码输出路径
        String javaPath = System.getProperty("user.dir") + "/src/main/java";
        String xmlPath = System.getProperty("user.dir") + "/src/main/resources/mapper";
        // 项目父包名
        String parentPack = "com.example.mybatisplus";

        // 执行代码生成
        FastAutoGenerator.create(dbUrl, dbUser, dbPwd)
                .globalConfig(builder -> {
                    builder.author("开发人员")
                            .fileOverride()
                            .outputDir(javaPath)
                            .disableOpenDir();
                })
                .packageConfig(builder -> {
                    builder.parent(parentPack)
                            .entity("entity")
                            .mapper("mapper")
                            .service("service")
                            .serviceImpl("service.impl")
                            .controller("controller")
                            .pathInfo(Collections.singletonMap(OutputFile.mapperXml, xmlPath));
                })
                .strategyConfig(builder -> {
                    // 修改为自己需要生成的数据库表名
                    builder.addInclude("user")
                            .entityBuilder().enableLombok().enableTableFieldAnnotation()
                            .mapperBuilder().superClass(BaseMapper.class).enableMapperAnnotation().enableBaseResultMap()
                            .serviceBuilder()
                            .controllerBuilder().enableRestStyle();
                })
                .templateEngine(new VelocityTemplateEngine())
                .execute();
    }
}

四、项目五层核心结构详解（每层附带完整代码示例）

代码生成后项目分为五层结构，各司其职，下面每层都附带完整可直接运行代码。

4.1 Entity实体层（数据库表映射）

对应数据库user表结构，通过Lombok简化代码，注解关联数据库主键和字段映射。

package com.example.mybatisplus.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("user")
public class User {
    // 雪花算法自动生成主键
    @TableId(type = IdType.ASSIGN_ID)
    private Long id;
    // 用户名
    private String name;
    // 性别
    private String sex;
    // 年龄
    private Integer age;
    // 邮箱
    private String email;
}

4.2 Mapper数据访问层（DAO层）

继承MP内置BaseMapper，自带全套CRUD方法，无需手写任何SQL和方法。

package com.example.mybatisplus.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.mybatisplus.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
    // 无需手写任何代码，BaseMapper已内置所有CRUD方法
}

4.3 Service业务接口层

继承MP内置IService业务通用接口，封装业务层基础操作规范。

package com.example.mybatisplus.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.mybatisplus.entity.User;

public interface UserService extends IService<User> {
    // 无需手写基础方法，IService已全部内置
}

4.4 ServiceImpl业务实现层

继承ServiceImpl实现类，自动注入Mapper，实现业务层所有CRUD逻辑。

package com.example.mybatisplus.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.mybatisplus.entity.User;
import com.example.mybatisplus.mapper.UserMapper;
import com.example.mybatisplus.service.UserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 无需手写实现代码，ServiceImpl已内置所有逻辑
}

4.5 Mapper XML映射文件（自定义复杂SQL专用）

存放多表联查、复杂统计、自定义业务SQL，基础CRUD无需在此写代码。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mybatisplus.mapper.UserMapper">
    <resultMap id="BaseResultMap" type="com.example.mybatisplus.entity.User">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="sex" property="sex"/>
        <result column="age" property="age"/>
        <result column="email" property="email"/>
    </resultMap>
    <!-- 自定义复杂SQL、联表查询写此处 -->
</mapper>

五、BaseMapper全套CRUD实操示例（DAO层核心）

5.1 新增数据（雪花算法自动回填主键）

@Test
void testInsert(){
    User user = new User();
    user.setName("张三");
    user.setSex("0");
    user.setAge(22);
    user.setEmail("zhangsan@163.com");
    // 执行新增
    int result = userMapper.insert(user);
    System.out.println("新增影响行数：" + result);
    System.out.println("自动生成主键ID：" + user.getId());
}

5.2 查询数据（ID查询、批量查询、条件查询）

// 单个ID查询
@Test
void testSelectById(){
    User user = userMapper.selectById(1583712489828356098L);
    System.out.println("用户信息：" + user);
}

// 批量ID查询
@Test
void testSelectBatch(){
    List<User> list = userMapper.selectBatchIds(Arrays.asList(1L,2L,3L));
    list.forEach(System.out::println);
}

// 条件查询列表
@Test
void testSelectList(){
    QueryWrapper<User> wrapper = new QueryWrapper<>().eq("age",22);
    userMapper.selectList(wrapper).forEach(System.out::println);
}

5.3 修改数据（按ID修改、按条件修改）

// 按ID修改
@Test
void testUpdateById(){
    User user = new User();
    user.setId(1583712489828356098L);
    user.setName("张三修改版");
    userMapper.updateById(user);
}

// 按Wrapper条件修改
@Test
void testUpdateByWrapper(){
    User user = new User();
    user.setEmail("update@163.com");
    UpdateWrapper<User> wrapper = new UpdateWrapper<>().eq("name","张三");
    userMapper.update(user,wrapper);
}

5.4 删除数据（ID删除、批量删除、条件删除）

// 按ID删除
@Test
void testDeleteById(){
    userMapper.deleteById(1583712489828356098L);
}

// 批量删除
@Test
void testDeleteBatch(){
    userMapper.deleteBatchIds(Arrays.asList(1L,2L));
}

// 条件删除
@Test
void testDeleteWrapper(){
    QueryWrapper<User> wrapper = new QueryWrapper<>().eq("age",18);
    userMapper.delete(wrapper);
}

六、Wrapper条件构造器全套精细化用法（复杂查询核心必学）

Wrapper是MyBatis-Plus核心核心组件，无需手写SQL，通过链式方法封装查询、更新、排序、分组、模糊匹配等所有数据库条件，适配简单单条件到复杂多嵌套条件所有场景，杜绝硬编码SQL，代码整洁易维护。

6.1 五大核心Wrapper类核心作用说明

MP内置5款常用Wrapper，分工明确，适配不同业务场景，按需选择使用：

• QueryWrapper：基础查询条件封装，用于常规字符串字段条件查询、多条件拼接查询
• UpdateWrapper：基础更新条件封装，用于不带实体、纯条件字段赋值更新操作
• AbstractLambdaWrapper：Lambda语法顶层父类，统一规范Lambda链式调用核心能力
  • LambdaQueryWrapper：基于Lambda语法的安全查询Wrapper，直接引用实体属性，杜绝数据库字段拼写错误
  • LambdaUpdateWrapper：基于Lambda语法的安全更新Wrapper，类型安全更新，适配企业开发主流写法

6.2 Wrapper顶层父类核心说明

AbstractWrapper是所有查询、更新Wrapper的顶层父类，核心作用是统一生成SQL的where条件，封装所有通用条件拼接方法，所有子类Wrapper全部继承拥有这些公有方法，一次学习、所有Wrapper通用。

6.3 AbstractWrapper通用基础方法全明细表（开发高频必备）

6.3.1 基本比较操作

方法名	方法解释	使用示例 & 等效SQL
eq	等于 =	eq(“name”, “老王”) ——> name = ‘老王’
ne	不等于 <>	ne(“name”, “老王”) ——> name <> ‘老王’
gt	大于 >	gt(“age”, 18) ——> age > 18
ge	大于等于 >=	ge(“age”, 18) ——> age >= 18
lt	小于 <	lt(“age”, 18) ——> age < 18
le	小于等于 <=	le(“age”, 18) ——> age <= 18
between	区间范围 between 值1 and 值2	between(“age”, 18, 30) ——> age between 18 and 30
notBetween	不在区间范围	notBetween(“age”, 18, 30) ——> age not between 18 and 30

6.3.2 模糊查询操作

方法名	方法解释	使用示例 & 等效SQL
like	全模糊匹配 LIKE ‘%值%’	like(“name”, “王”) ——> name like ‘%王%’
notLike	模糊不匹配 NOT LIKE ‘%值%’	notLike(“name”, “王”) ——> name not like ‘%王%’
likeLeft	左模糊匹配 LIKE ‘%值’	likeLeft(“name”, “王”) ——> name like ‘%王’
likeRight	右模糊匹配 LIKE ‘值%’	likeRight(“name”, “王”) ——> name like ‘王%’

6.3.3 分组排序操作

方法名	方法解释	使用示例 & 等效SQL
groupBy	字段分组 GROUP BY	groupBy(“id”, “name”) ——> group by id,name
orderByAsc	升序排序 ORDER BY ASC	orderByAsc(“id”, “name”) ——> order by id ASC,name ASC
orderByDesc	降序排序 ORDER BY DESC	orderByDesc(“id”, “name”) ——> order by id DESC,name DESC
orderBy	自定义升降序排序	orderBy(true, true, “id”, “name”) ——> order by id ASC,name ASC
having	分组后条件过滤 HAVING	having(“sum(age) > 10”) ——> having sum(age) > 10

6.3.4 空值判断 & 子查询操作

方法名	方法解释	使用示例 & 等效SQL
isNull	字段为空 IS NULL	isNull(“name”) ——> name is null
isNotNull	字段非空 IS NOT NULL	isNotNull(“name”) ——> name is not null
in	字段包含指定值 IN	in(“age”, 1, 2, 3) ——> age in (1,2,3)
notIn	字段不包含指定值 NOT IN	notIn(“age”, 1, 2, 3) ——> age not in (1,2,3)
inSql	子查询IN条件	inSql(“id”, “select id from user where id < 3”) ——> id in (子查询SQL)
notInSql	子查询NOT IN条件	notInSql(“id”, “select id from user where id < 3”) ——> id not in (子查询SQL)

6.3.5 逻辑拼接 & 高级SQL操作

方法名	方法解释	使用示例 & 等效SQL
func	动态条件拼接，适配if判断拼接场景	func(i -> if(true){i.eq(“id”,1)}else{i.ne(“id”,1)})
or	OR逻辑条件拼接	eq(“id”,1).or().eq(“name”,“老王”) ——> id=1 or name=‘老王’
and	AND嵌套条件拼接	and(i -> i.eq(“name”,“李白”).ne(“status”,“活着”))
nested	多条件括号嵌套拼接	nested(i -> i.eq(“name”,“李白”).ne(“status”,“活着”))
apply	自定义拼接原生SQL语句	apply(“name like {0} and age > {1}”,“%J%”,18)
last	拼接SQL末尾后缀，无视规则强制拼接	last(“limit 1”) ——SQL最后拼接limit 1
exists/notExists	存在/不存在子查询拼接	exists(“select id from user where age = 1”)

6.4 Wrapper对象两种创建方式

日常开发推荐使用Wrappers静态工具类创建，代码更简洁、无需手动new对象，官方推荐写法：

// 方式1：Wrappers静态工具类创建（推荐）
QueryWrapper<User> wrapper = Wrappers.query();

// 方式2：通过构造方法new创建
QueryWrapper<User> wrapper2 = new QueryWrapper<>();

6.5 QueryWrapper查询专用实操（指定查询字段+条件查询）

QueryWrapper专属select方法，可自定义指定查询返回字段，避免查询全表字段，提升查询性能，适配按需查询业务场景。

/**
 * QueryWrapper实操：指定查询字段+in条件查询
 * @throws Exception 异常捕获
 */
@Test
public void testQueryWrapperSelect() throws Exception {
    // 创建查询条件构造器
    QueryWrapper<User> wrapper = Wrappers.query();
    // 手动指定只查询id、name、sex三个字段，不查询全部字段
    wrapper.select("id", "name", "sex");
    // 设置in条件：id为1和2
    wrapper.in("id","1","2");
    // 执行查询，等效SQL：SELECT id,name,sex FROM user WHERE (id IN (?,?))
    List<User> userList = userMapper.selectList(wrapper);
    // 遍历打印查询结果
    userList.forEach(System.out::println);
}

6.6 UpdateWrapper更新专用实操（纯条件赋值更新）

UpdateWrapper继承AbstractWrapper所有条件方法，额外新增set、setSql更新专属方法，无需封装实体对象，直接通过条件设置字段新值，适配纯更新业务。

6.6.1 set方法字段赋值更新实操

/**
 * UpdateWrapper实操：set方法逐个设置字段更新
 * @throws Exception 异常捕获
 */
@Test
public void testUpdateWrapperSet() throws Exception {
    // 封装查询条件实体
    User user = new User();
    user.setId(1L);
    // 创建更新条件构造器
    UpdateWrapper<User> wrapper = Wrappers.update(user);
    // 逐个设置需要更新的字段及新值
    wrapper.set("name", "xiaohui");
    wrapper.set("sex", "0");
    wrapper.set("age", "22");
    // 执行更新，实体传null，所有更新逻辑走UpdateWrapper
    // 等效SQL : UPDATE user SET name=?,sex=?,age=? WHERE id=?
    userMapper.update(null, wrapper);
}

6.6.2 setSql原生SQL拼接更新实操

/**
 * UpdateWrapper实操：setSql拼接原生SQL批量更新
 * @throws Exception 异常捕获
 */
@Test
public void testUpdateWrapperSetSql() throws Exception {
    // 创建更新条件构造器
    UpdateWrapper<User> wrapper = Wrappers.update();
    // 直接拼接更新SQL语句，批量设置多个字段
    wrapper.setSql("name='abc',sex='0',age=18 where id=1");
    // 执行更新
    // 等效SQL: UPDATE user SET name='abc',sex='0',age=18 where id=1
    userMapper.update(null, wrapper);
}

6.7 LambdaQueryWrapper安全查询实操（企业推荐，杜绝字段写错）

LambdaQueryWrapper基于Lambda语法，直接引用实体类属性，无需手写数据库字符串字段名，编译阶段校验字段合法性，杜绝字段拼写报错，企业开发首选。

/**
 * LambdaQueryWrapper实操：Lambda安全链式条件查询
 * @throws Exception 异常捕获
 */
@Test
public void testLambdaQueryWrapper() throws Exception {
    // 创建Lambda查询条件构造器
    LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery();
    // Lambda链式编程：in条件+模糊查询+指定查询字段
    wrapper.in(User::getId,"1","2","3")
            .like(User::getName,"a")
            .select(User::getId,User::getName,User::getAge);
    // 执行查询
    List<User> userList = userMapper.selectList(wrapper);
    // 遍历输出结果
    for (User user : userList) {
        System.out.println(user);
    }
}

6.8 LambdaUpdateWrapper安全更新实操（类型安全更新）

LambdaUpdateWrapper为更新专用Lambda构造器，继承所有更新、条件方法，Lambda引用实体属性更新，安全无拼写错误，适配核心业务数据更新场景。

/**
 * LambdaUpdateWrapper实操：Lambda安全条件更新
 * @throws Exception 异常捕获
 */
@Test
public void testLambdaUpdateWrapper() throws Exception {
    // 创建Lambda更新条件构造器
    LambdaUpdateWrapper<User> wrapper = Wrappers.lambdaUpdate();
    // 按id匹配条件，设置姓名和年龄新值
    wrapper.eq(User::getId,"1").set(User::getName,"lili").set(User::getAge,18);
    // 执行更新操作
    userMapper.update(null,wrapper);
}

七、Service业务层全套CRUD精细化实操（按功能分类+全方法注解+可直接运行）

MP业务层核心基于IService接口封装，在Mapper基础上新增批量操作、新增或修改、分页统计等高频企业级方法，下面按新增、删除、修改、查询、分页五大核心场景规整，每个场景先罗列官方核心方法说明，再配套完整带注释测试代码，拿来直接运行即可使用。

7.1 新增相关核心方法及实操

核心方法说明

• default boolean save(T entity)：新增单条记录
• boolean saveBatch(Collection entityList)：批量插入多条记录
• saveBatch(Collection entityList, int batchSize)：分批次批量插入，每次插入batchSize条，适配大数据量批量新增

新增单条数据测试代码

/**
 * 业务层-新增单条用户数据
 * @throws Exception 异常捕获
 */
@Test
public void test1() throws Exception {
    // 封装用户实体，id为null自动生成雪花主键
    User user = new User(null, "zhagnsan", "0", 21);
    // 调用service新增方法
    userService.save(user);
}

7.2 删除相关核心方法及实操

核心方法说明

• boolean removeById(Serializable id)：根据主键id单条删除
• boolean removeByMap(Map<String, Object> columnMap)：根据map键值对条件删除
• boolean remove(Wrapper queryWrapper)：使用Wrapper构造复杂条件删除
• boolean removeByIds(Collection<? extends Serializable> idList)：根据主键id集合批量删除

根据ID删除数据测试代码

/**
 * 业务层-根据主键id删除用户数据
 * @throws Exception 异常捕获
 */
@Test
public void test2() throws Exception {
    // 根据id删除对应用户记录
    userService.removeById(1L);
}

7.3 修改相关核心方法及实操

核心方法说明

• boolean updateById(T entity)：根据实体主键id修改数据
• boolean update(Wrapper updateWrapper)：纯根据Wrapper条件修改，无需传实体
• boolean update(T entity, Wrapper updateWrapper)：根据Wrapper匹配条件，修改为实体中的字段值
• boolean updateBatchById(Collection entityList)：根据id批量修改数据
• updateBatchById(Collection entityList, int batchSize)：分批次批量修改，每次修改batchSize条
• boolean saveOrUpdate(T entity)：核心常用，id存在则修改，id不存在则自动新增

新增或修改数据测试代码（id存在改，不存在增）

/**
 * 业务层-新增或修改数据
 * 如果id存在则修改,不存在则自动新增
 * @throws Exception 异常捕获
 */
@Test
public void test3() throws Exception {
    // 封装用户实体，携带主键id
    User user = new User(1L, "zhagnsan", "0", 18);
    // 自动判断新增或修改
    userService.saveOrUpdate(user);
}

根据ID单独修改数据测试代码

/**
 * 业务层-根据主键id单独修改用户信息
 * @throws Exception 异常捕获
 */
@Test
public void test4() throws Exception {
    // 封装修改后的用户新数据，携带主键id
    User user = new User(1L, "xiaolan", "1", 18);
    // 按id精准修改
    userService.updateById(user);
}

7.4 查询相关核心方法及实操

核心方法说明

• T getById(Serializable id)：根据主键id查询单条记录
• List listByIds(Collection<? extends Serializable> idList)：根据id集合批量查询多条记录
• List listByMap(Map<String, Object> columnMap)：根据map条件查询多条记录
• T getOne(Wrapper queryWrapper)：根据Wrapper查询单条，查到多条直接抛异常
• T getOne(Wrapper queryWrapper, boolean throwEx)：根据Wrapper查单条，throwEx控制是否抛异常
• int count()：查询表总记录数
• int count(Wrapper queryWrapper)：根据指定条件查询符合条件的记录数

根据ID查询单条数据测试代码

/**
 * 业务层-根据主键id查询单条用户信息
 * @throws Exception 异常捕获
 */
@Test
public void test5() throws Exception {
    // 根据id查询用户
    User user = userService.getById(1L);
    // 打印查询结果
    System.out.println(user);
}

Wrapper条件查询列表数据测试代码

/**
 * 业务层-通过Wrapper条件查询用户列表
 * @throws Exception 异常捕获
 */
@Test
public void test6() throws Exception {
    // 创建条件构造器
    QueryWrapper<User> wrapper = Wrappers.query();
    // 设置查询条件：id在1、2范围内
    wrapper.in("id", "1", "2");

    // 查询所有无参列表
//  List<User> userList = userService.list();

    // 根据wrapper条件查询列表
    List<User> userList = userService.list(wrapper);

    // 遍历打印查询结果
    for (User user : userList) {
        System.out.println(user);
    }
}

条件统计总记录数测试代码

/**
 * 业务层-根据条件查询总记录条数
 * @throws Exception 异常捕获
 */
@Test
public void test7() throws Exception {
    // 创建条件构造器
    QueryWrapper<User> wrapper = Wrappers.query();
    // 设置模糊查询条件：name包含a
    wrapper.like("name",