Mybatis-Plus知识点详解

Mybatis-plus(简称MP),基于Mybatis的增强工具,保留了Mybatis的所有功能,同时增加了通用的CRUD,条件构造器,分页插件等等实用工具

特性

• 即拿即用:通过通用Mapper和Service,无需编写XML既可以完成单表CURE操作

• Lambda支持:使用Lambda表达式构建查询条件,避免硬编码字段名,提升代码安全性

• 更多的主键策略:支持多种主键生成方式,如雪花算法,自增等等

• 分页插件:内置分页插件,支持多种数据库,简化分页查询操作

与Mybatis相比

• 提供大量自动化功能,如通用的CRUD,条件构造器,分页支持极大减少操作代码,提高开发效率

• Mybatis需手动编写SQL,编写XML文件和映射接口DAO

快速入门

日志配置

• 日志输出到标准输出流中

mybatis-plus:# mapper配置文件mapper-locations: classpath:mapper/*.xml# resultType别名，没有这个配置resultType包名要写全，配置后只要写类名type-aliases-package: com.mashang.springboot04.domain//configuration:log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

添加依赖与配置application.yml

• 本人使用SpringBoot 2.7.18,JDK1.8:导入的依赖如下

        <dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.5.3.2</version></dependency>

• application.yml如下:

# 也是springboot的配置文件，两个都可以用
server:port: 8080servlet:#配置根路径context-path: /
# 配置数据源
spring:datasource:driver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://localhost:3306/xiaomi_store?userSSL=false;serverTimezone=Asia/Shanghaiusername: rootpassword: root
mybatis-plus:# mapper配置文件mapper-locations: classpath:mapper/*.xml# resultType别名，没有这个配置resultType包名要写全，配置后只要写类名type-aliases-package: com.mashang.springboot03.domain

定义实体类与Mapper接口

实体类

• 在实体类上使用Mybatis-plus的注解

• @TableName()→指定数据库查询的表,不添加默认将类名改为下划线型数据库名

• @TableId(name,type)→用于给主键标记,name为数据库对应名,用于指定自增算法雪花算法(Snowflake)是由Twitter开源的一种分布式ID生成算法.其核心思想是将64位的long型ID分为四个部分,分别为:符号位,时间戳,工作机器ID,序列号

@Data
@TableName("user")  // 指定数据库表名
public class User {@TableId(type = IdType.AUTO)  // 主键自增private Long id;private String name;private Integer age;
}

Mapper接口

• Mapper接口需继承BaseMapper<T>类,则此接口即可获得所有基本的CRUD方法

public interface UserMapper extends BaseMapper<User> {// 如果需要扩展自定义方法，也可以在此添加
}

Service层与Service实现层

MP也提供了IService接口和ServiceImpl类方便在Service层使用封装好的CRUD方法

Service层

• extends(继承)IService接口

public interface UserService extends IService<User> {// 可以在此定义更多业务方法
}

ServiceImpl层

• 继承 ServiceImpl<UserMapper, User> 和实现 IService<User> 接口,可以直接调用封装好的 CRUD 方法

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {// 继承了 ServiceImpl 后，已拥有 BaseMapper 中所有的 CRUD 方法
}

BaseMapper接口中常用的CRUD方法

• 即Mapper层中的常见方法,已经集成好了,直接操作数据库的原子性方法

插入操作

// 插入一条记录
int insert(T entity);

查询操作

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

删除操作

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

更新操作

// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

IService接口中的常用方法

• 即service层常见方法,业务逻辑层,可组合多个 Mapper 方法,添加事务等

插入操作(save)

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

存在更新,不存在插入(saveOrUpdate)

• boolean saveOrUpdate(T entity);:根据@TableId标识的主键判断,若主键不存在→执行INSERT,若主键存在→执行UPDATE

• boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);:先根据updateWrapper尝试进行更新操作,若影响行数为0,则回退到saveOrUpdate(T entity)逻辑(根据主键判断是否更新或插入)

• saveOrUpdateBatch(Collection<T>entityList) 和 saveOrUpdateBatch(Collection<T> entityList, int batchSize):批量处理集合中的实体，逻与 saveOrUpdate(T) 一致

删除操作(Remove)

可配合@TableLogic实现逻辑删除

// 根据 Wrapper 构造的条件删除记录 支持复杂条件
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
//根据 columnMap 中的字段值匹配删除记录 仅支持等值条件,
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

更新操作(Update)

必须设置 SET 字段,如果未调用 .set()，SQL会缺少更新内容导致错误

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

查询单个对象(getOne)

若实体类配置了 @TableLogic，查询时会自动过滤已删除数deleted = 0

// 根据 ID 查询
T getById(Serializable id);// 根据 Wrapper，查询一条记录,结果集，如果是多个会抛出异常, 随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);// 根据 Wrapper，查询一条记录,可控制是否在结果不唯一时抛出异常
//不抛出异常，返回第一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

查询列表(list)

// 查询所有
List<T> list();// 查询列表
List<T> list(Wrapper<T> queryWrapper);// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);// 查询所有列表
List<Map<String, Object>> listMaps();// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);// 查询全部记录
List<Object> listObjs();// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

分页查询(page)

• 分页对象Page类

  主要属性:current:当前页码,从 1 开始size:每页显示的记录数searchCount:是否执行 SELECT COUNT(*) 查询总记录数,不统计总数适用于大数据量场景

Page<User> pageParam = new Page<>(1, 10);
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.gt(User::getAge, 25).orderByDesc(User::getCreateTime);IPage<User> userPage = userService.page(pageParam, wrapper);

// 无条件分页查询
IPage<T> page(IPage<T> page);
// 条件分页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

查询记录数(count)

// 查询总记录数
int count();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

// 统计年龄大于25且状态为激活的用户数量
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.gt(User::getAge, 25).eq(User::getStatus, 1);int count = userService.count(wrapper);

条件构造器

• 条件构造器用于动态生成SQL中的WHERE条件,替代手动拼接SQL语句,MP中提供了两种主要的条件构造器:QueryWrapper与LambdaQueryWrapperQueryWrapper:基于字符串名的条件构造器,写法直观,但存在字段拼写错误的风险LambdaQuertWrapped:基于Lambda表达式的构造器,避免了硬编码字段,更加推荐使用

常用方法

等于.eq()

• 用于生成字段＝值的条件

  使用字符串

new QueryWrapper<User>().eq("age", 25); // 生成 SQL: WHERE age = 25

• 使用Lambda表达式

new LambdaQueryWrapper<User>().eq(User::getAge, 25);

不等于.nq()

• 生成字段<>值条件

new LambdaQueryWrapper<User>().ne(User::getStatus, 0); // SQL: WHERE status <> 0

模糊查询.like()

• 生成字段LIKE ‘%值%’条件

 new LambdaQueryWrapper<User>().like(User::getName, "张"); // SQL: WHERE name LIKE '%张%'

逻辑连接or()与and()

• or():一般用法

new LambdaQueryWrapper<User>().eq(User::getAge, 25).or().eq(User::getName, "张三");
// 生成 SQL: WHERE age = 25 OR name = '张三'

• 嵌套用法

new LambdaQueryWrapper<User>().or(wrapper -> wrapper.eq(User::getAge, 25).ne(User::getStatus, 0));
// 生成 SQL: OR (age = 25 AND status <> 0)

• and():作用是拼接多个条件,用 AND 连接默认条件连接就是 AND,一般无需显式调用

动态查询

• 在查询条件前加上布尔判断,true则执行

new LambdaQueryWrapper<User>().eq(age != null, User::getAge, age) // 当 age 不为 null 时生效.like(StringUtils.isNotBlank(name), User::getName, name); // 当 name 非空时生效

分页查询

• MP中内置了分页插件,使用Page对象来封装分页参数和结果

• 在Springboot中通过配置类启动分页插件

  启用 MyBatis-Plus 的分页功能,使得在查询时可以直接使用分页方法

@Configuration
public class MyBatisPlusConfig {// MybatisPlus的配置@Beanpublic MybatisPlusInterceptor mybatisPlusInterceptor() {MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();// 在拦截器中加入了一个分页的拦截器// 指定数据库类型为 MySQLinterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));return interceptor;}
}

LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.gt(User::getAge, 20);
Page<User> pageParam = new Page<>(1, 10);
IPage<User> userPage = userService.page(pageParam, wrapper);

进阶操作

敏感字段屏蔽

• 某些字段直接发给前端会被用户恶意使用,导致安全隐患.有些字段(如日志字段,update_time,内部状态等等)对前端并无必要,过滤这些可以减少网络数据量,提高性能

方案一:手动赋值

• 手动创建VO对象,并逐字赋值

List<StudentVo> studentVos = new ArrayList<>();
for (Student s : students) {StudentVo vo = new StudentVo();vo.setName(s.getName());vo.setClassId(s.getClassId());// 其它字段也需手动赋值studentVos.add(vo);
}

• 优点:可控,不存在反射性能开销

• 缺点:当字段过多时,代码冗长,维护成本高,若实体类改变,需要改变多个地方

方案二:BeanUtils.copyProperties

• 实现方法:利用反射机制自动复制同名属性

List<StudentVo> studentVos = new ArrayList<>();
for (Student s : students) {StudentVo vo = new StudentVo();BeanUtils.copyProperties(student, vo);studentVos.add(vo);
}

• 优点:代码简洁,快速复制

• 缺点:反射操作性能慢,约为手动复制的10倍,缺乏灵活性

方案三:MapStruct 推荐

• 导入MapStruct依赖

<dependency><groupId>org.mapstruct</groupId><artifactId>mapstruct</artifactId><version>1.4.2.Final</version>
</dependency>
<dependency><groupId>org.mapstruct</groupId><artifactId>mapstruct-processor</artifactId><version>1.4.2.Final</version>
</dependency>

• 建一个专门用于映射的文件夹mapping,编写映射接口,利用MapStruct在编译阶段自动生成高效映射代码

@Mapper//注意mapper注解不要引错了,要引入mapstruct包下的
public interface StudentMapping {StudentMapping INSTANCE = Mappers.getMapper(StudentMapping.class);StudentVo toStudentVo(Student student);List<StudentVo> toStudentVoList(List<Student> list);
}

//使用方法如下:
List<StudentVo> vos = StudentMapping.INSTANCE.toStudentVoList(students);

• 优点:性能高,生成的代码类似于手动赋值,运行时没有反射开销,灵活性高

联表分页查询

• 假设需要查询主表数据(如商品),及其关联的子表数据(如评论),支持分页和条件过滤.以商品(主表)和评论(子表)为例

集中式

• 核心逻辑是提供JOIN查询主表和子数据,在单次SQL中完成所有数据的获取

• 代码实例

  mapper.xml

<!-- 商品和评论联表查询 -->
<select id="selectProductWithComments" resultMap="productWithCommentsMap">SELECT p.id, p.name, p.price,c.id AS comment_id,c.content,c.user_idFROM product pLEFT JOIN comment c ON p.id = c.product_id${ew.customSqlSegment}  <!-- 动态条件 -->
</select><!-- 结果映射 -->
<resultMap id="productWithCommentsMap" type="ProductVO"><id property="id" column="id"/><result property="name" column="name"/><result property="price" column="price"/><collection property="comments" ofType="Comment"><id property="id" column="comment_id"/><result property="content" column="content"/><result property="userId" column="user_id"/></collection>
</resultMap>

核心点:

• 使用处理一对多的关系,将子表数据映射为集合

• ${ew.customSqlSegment}

  其是MP中用于动态拼接的特殊占位符,将QueryWrapper或LambdaQueryWrapper中定义的查询条件如(eq,like,between),转换为合法的Sql片段,并插入到XML映射文件的SQL语句中

  mapper接口定义

// 方法参数中必须声明 @Param(Constants.WRAPPER)
Page<ProductVO> selectPage(@Param("page") Page<ProductVO> page, @Param(Constants.WRAPPER) Wrapper<ProductVO> wrapper // 关键参数
);

• XML的使用

<select id="selectPage" resultMap="productMap">SELECT * FROM product${ew.customSqlSegment}  <!-- 动态插入 WHERE 条件 -->
</select>

• 核心机制ew是Wrapper的别名,对应Mapper接口方法中的@Param(Constans.WRAPPER)参数当调用wrapper.eq(”name”,”张三”)时,会自动赋值为WHERE name= ‘张三’如WHERE name = '手机'需直接拼接,不能作为预编译参数

分布式(嵌套查询)

• 分为两次查询:1.分页查询主表()商品表,2.子查询:根据主表id批量查询关联的子表数据(评论表)

• 代码实例

<!-- 主查询 -->
<select id="selectProductPage" resultMap="productPageMap">SELECT id, name, price FROM product${ew.customSqlSegment}  <!-- 动态条件 -->
</select><!-- 嵌套子查询 根据商品ID查评论 -->
<select id="selectCommentsByProductIds" resultType="Comment">SELECT id, content, user_id, product_id FROM comment WHERE product_id IN <foreach collection="productIds" item="id" open="(" separator="," close=")">#{id}</foreach>
</select><!-- 结果映射 -->
<resultMap id="productPageMap" type="ProductVO"><id property="id" column="id"/><result property="name" column="name"/><result property="price" column="price"/><collection property="comments" ofType="Comment"select="selectCommentsByProductIds"  <!-- 关联子查询方法 -->column="{productIds=id}"             <!-- 传递参数 -->/>
</resultMap>

字段填充

• 再更新或者新增行时,通常需要添加一些属性如创建时间,更新时间,操作人员,MP提供了一种方法自动化处理填充

代码层面的实现

• 再实体类中标记需要填充的字段

a. 使用@TableFiled主键的fill属性指定填充策略

@Data
public class Orders implements Serializable {private static final long serialVersionUID = -29854105041572661L;@TableId(type = IdType.ASSIGN_ID)private Long orderId;private String orderNum;private Integer userId;@TableField(fill = FieldFill.INSERT)private Date orderTime;/*** 创建者*/@TableField(fill = FieldFill.INSERT)private String createBy;/*** 创建时间*/@TableField(fill = FieldFill.INSERT)private Date createTime;/*** 更新者*/@TableField(fill = FieldFill.INSERT_UPDATE)private String updateBy;/*** 更新时间*/@TableField(fill = FieldFill.INSERT_UPDATE)private Date updateTime;/*** 备注*/private String remark;}

b. 实现MetaObjectHandler接口

@Slf4j
@Component
public class FieldHandler implements MetaObjectHandler {// 在插入数据时，自动填充createTime和createBy字段@Overridepublic void insertFill(MetaObject metaObject) {log.info("start insert fill...");// 设置createTime字段的值为当前时间this.setFieldValByName("createTime", new Date(), metaObject);// 设置createBy字段的值为adminthis.setFieldValByName("createBy", "admin", metaObject);// 设置orderTime字段的值为当前时间this.setFieldValByName("orderTime", new Date(), metaObject);// 设置updateTime字段的值为当前时间this.setFieldValByName("updateTime", new Date(), metaObject);// 设置updateBy字段的值为adminthis.setFieldValByName("updateBy", "admin", metaObject);}// 在更新数据时，自动填充updateTime和updateBy字段@Overridepublic void updateFill(MetaObject metaObject) {log.info("start update fill...");// 设置updateTime字段的值为当前时间this.setFieldValByName("updateTime", new Date(), metaObject);// 设置updateBy字段的值为adminthis.setFieldValByName("updateBy", "admin", metaObject);}
}

逻辑删除

• 数据“删除”后仍保留在数据库中,通过标记is_deleted字段过滤,在实体类中使用 @TableLogic 注解

• 避免误删导致数据永久丢失,防止删除主表数据后,关联的子表数据失效(如用户删除后,历史订单需保留)

public class User {@TableLogicprivate Integer deleted; // 1 表示删除，0 表示未删除
}

• 当执行删除操作时,实际是在执行update操作

userMapper.deleteById(1); 
//实际执行UPDATE user SET is_deleted = 1 WHERE id = 1;

• 查询操作通过is_deteted过滤

List<User> list = userMapper.selectList(null);
//实际执行
SELECT * FROM user WHERE is_deleted = 0;

乐观锁

• 通过版本号(如Vesion字段)或时间戳,再数据提交时检查是否发生并非冲突,若冲突则拒绝操作,提示重试或回滚,先操作,提交时再检查冲突,使用于低并发

MP实现乐观锁

• 在实体类中添加版本号,并使用@Version注解标记

public class Product {private Long id;private String name;@Version  // 版本号字段（MP自动管理）private Integer version;
}

• 在配置类中添加乐观锁插件

@EnableTransactionManagement
public class MPConfig {// 创建MybatisPlusInterceptor对象@Beanpublic MybatisPlusInterceptor mybatisPlusInterceptor() {MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();// 添加分页插件interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));// 添加乐观锁插件interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());return interceptor;}
}

当存在多线程的修改操作时,MP会通过SQL语句检查version版本是否一致,如查询商品时version为1,提交完修改时MP执行UPDATE product SET name='新名字', version=2 WHERE id=1 AND version=1;,若存在另一个线程抢先修改,则version变为2,你的更新就会失效

文章转载自： ihave2carryon

原文链接：Mybatis-Plus知识点详解 - ihav2carryon - 博客园

体验地址：引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程设计器_表单引擎_工作流引擎_软件架构