MyBaitsPlus

最新推荐文章于 2023-11-14 19:57:02 发布

a听闻

最新推荐文章于 2023-11-14 19:57:02 发布

阅读量795

点赞数 1

分类专栏： Java EE Java 文章标签： mybatis java

本文链接：https://blog.csdn.net/LuKeliyy/article/details/115677985

版权

Java 同时被 2 个专栏收录

20 篇文章 0 订阅

订阅专栏

Java EE

14 篇文章 0 订阅

订阅专栏

MyBatis-Plus

1. 什么是MyBatis-Plus

官网链接：https://mybatis.plus/

版本发布历史：https://github.com/baomidou/mybatis-plus/blob/3.0/CHANGELOG.md

1.1 简介

MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。

1.2 特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

1.3 支持数据库

任何能使用 mybatis 进行 crud, 并且支持标准 sql 的数据库

1.4 框架结构

在这里插入图片描述

2. 快速应用

2.1 准备数据库表

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int(0) NOT NULL AUTO_INCREMENT COMMENT '系统主键',
  `account` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '账号',
  `password` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '密码',
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '用户名',
  `head` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '头像',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '管理员用户表';

INSERT INTO `user` VALUES (1, 'admin', '123456', '张三', '0.gif');
INSERT INTO `user` VALUES (2, 'test', 'test', '测试用户', '');
INSERT INTO `user` VALUES (3, 'demo', 'demo01', '示例用户', NULL);
INSERT INTO `user` VALUES (4, 'zhangsan', '123456', '张三', NULL);
INSERT INTO `user` VALUES (5, 'lisi', 'lisi123', '李四', NULL);
INSERT INTO `user` VALUES (6, 't16admin', 'abcdef', '管理员', NULL);
INSERT INTO `user` VALUES (7, 'adminn', '111111', '欧阳', NULL);

2.2 搭建环境

2.2.1 创建项目添加依赖

配置父模块

<!--管理spring-boot的版本-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
</parent>

添加依赖的jar包

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    
    <!--web启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!--JDBC驱动依赖-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    
    <!--mybatis-plus启动器-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.0</version>
    </dependency>

    <!--代码生成器依赖-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-generator</artifactId>
        <version>3.4.0</version>
    </dependency>

    <!--单元测试启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

2.2.2 配置数据源

# 配置数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://www.xxx.com:13307/forum?serverTimezone=Asia/Shanghai
    username: customer
    password: customer

2.2.3 添加Mapper扫描注解

在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹

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


@SpringBootApplication
@MapperScan("com.luke.frame.mybatis.plus.mapper")
public class App {
    public static void main(String[] args) {

        SpringApplication.run(App.class, args);
    }
}

2.3 完成MyBatis-Plus的使用

2.3.1 编写数据库实体类

package com.luke.frame.mybatis.plus.domain.entity;
import lombok.Data;
import java.io.Serializable;


@Data
public class User implements Serializable {
    private Integer id;
    private String account;
    private String password;
    private String name;
    private String head;
}

2.3.2 编写Mapper

需要继承BaseMapper

package com.luke.frame.mybatis.plus.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.xuetang9.frame.mybatis.plus.domain.entity.User;


public interface UserMapper extends BaseMapper<User> {
}

2.3.2 测试Mapper

package com.luke.frame.mybatis.plus.mapper;
import com.luke.frame.mybatis.plus.domain.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testUserMapper(){

        User user = userMapper.selectById(1);

        System.out.println(user);

        assertNotEquals(null,user);
    }
}

运行测试结果如下图
在这里插入图片描述

3. MVC项目中引入

前面演示了在Spring Boot项目中的引入，同样MP也支持在MVC中引用

3.1 引入jar包

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.4.0</version>
</dependency>

3.2 配置

配置 MapperScan

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.baomidou.mybatisplus.samples.quickstart.mapper"/>
</bean>

调整 SqlSessionFactory 为 MyBatis-Plus 的 SqlSessionFactory

<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
</bean>

示例参考地址：https://github.com/baomidou/mybatis-plus-samples/tree/master/mybatis-plus-sample-quickstart-springmvc

4. 常用配置

官网地址：https://mybatis.plus/config/#%E5%9F%BA%E6%9C%AC%E9%85%8D%E7%BD%AE

5. 实体类常用注解

官网地址：https://mybatis.plus/guide/annotation.html

6. 代码生成器

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

这里介绍两种方式，第一种自己使用AutoGenerator构建代码生成器，第二种使用开源UI框架，首先来看第一种。

6.1 控制台构建代码生成器

官网演示效果

在这里插入图片描述

下面是引入步骤

6.1.1 添加依赖

MyBatis-Plus 从 3.0.3 之后移除了代码生成器与模板引擎的默认依赖，需要手动添加相关依赖：

添加 代码生成器 依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.4.0</version>
</dependency>

添加 模板引擎 依赖，MyBatis-Plus 支持 Velocity（默认）、Freemarker、Beetl，用户可以选择自己熟悉的模板引擎，如果都不满足您的要求，可以采用自定义模板引擎。

Velocity（默认）：

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.2</version>
</dependency>

Freemarker：

<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>2.3.30</version>
</dependency>

Beetl：

<dependency>
    <groupId>com.ibeetl</groupId>
    <artifactId>beetl</artifactId>
    <version>3.2.4.RELEASE</version>
</dependency>

注意！如果您选择了非默认引擎，需要在 AutoGenerator 中设置模板引擎。

AutoGenerator generator = new AutoGenerator();

// set freemarker engine
generator.setTemplateEngine(new FreemarkerTemplateEngine());

// set beetl engine
generator.setTemplateEngine(new BeetlTemplateEngine());

// set custom engine (reference class is your custom engine class)
generator.setTemplateEngine(new CustomTemplateEngine());

6.1.2 编写配置

MyBatis-Plus 的代码生成器提供了大量的自定义参数供用户选择，能够满足绝大部分人的使用需求。

配置 GlobalConfig

GlobalConfig globalConfig = new GlobalConfig();
globalConfig.setOutputDir(System.getProperty("user.dir") + "/src/main/java");
globalConfig.setAuthor("luke");
globalConfig.setOpen(false);

配置 DataSourceConfig

DataSourceConfig dataSourceConfig = new DataSourceConfig();
dataSourceConfig.setUrl("jdbc:mysql://localhost:3306/ant?useUnicode=true&useSSL=false&characterEncoding=utf8");
dataSourceConfig.setDriverName("com.mysql.cj.jdbc.Driver");
dataSourceConfig.setUsername("root");
dataSourceConfig.setPassword("password");

更多详细配置，请参考代码生成器配置一文。

6.1.3 完整示例

package com.luke.frame.mybatis.plus.generator;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

public class MySqlGenerator {
    public static void main(String[] args) {
        // 创建自动生成器对象
        AutoGenerator autoGenerator = new AutoGenerator();
        // 1. 创建数据源配置对象
        DataSourceConfig dataSourceConfig = new DataSourceConfig();
        dataSourceConfig.setDriverName("com.mysql.cj.jdbc.Driver");
        dataSourceConfig.setUrl("jdbc:mysql://www.xxx.com:13307/forum?serverTimezone=Asia/Shanghai");
        dataSourceConfig.setUsername("customer");
        dataSourceConfig.setPassword("customer");
        autoGenerator.setDataSource(dataSourceConfig);

        // 2. 创建全局配置对象
        GlobalConfig globalConfig = new GlobalConfig();
        // 设置输出路径
        String root = System.getProperty("user.dir");
        globalConfig.setOutputDir(root + "/src/main/java");
        // 设置作者
        globalConfig.setAuthor("luke");
        // 设置是否打开输出目录
        globalConfig.setOpen(false);
        // 覆盖现有的文件
        globalConfig.setFileOverride(true);
        // 启用Swagger注解
        globalConfig.setSwagger2(true);
        // 数据库主键自增
        globalConfig.setIdType(IdType.AUTO);
        // 设置全局配置
        autoGenerator.setGlobalConfig(globalConfig);

        // 3. 创建包配置
        PackageConfig packageConfig = new PackageConfig();
        // 设置父包名
        packageConfig.setParent("com.xuetang9.frame.mybatis.plus");
        // 设置实体类所在的包
        packageConfig.setEntity("domain.entity");
        // 设置Mapper接口所在的包
        packageConfig.setMapper("mapper");
        // 设置xml文件所在的包
        packageConfig.setXml("mapper");

        autoGenerator.setPackageInfo(packageConfig);

        // 4. 生成策略配置
        StrategyConfig strategyConfig = new StrategyConfig();
        // 实体类启用字段注解
        strategyConfig.setEntityTableFieldAnnotationEnable(true);
        // 设置下划线转驼峰
        strategyConfig.setColumnNaming(NamingStrategy.underline_to_camel);
        autoGenerator.setStrategy(strategyConfig);

        // 5. 执行生成器
        autoGenerator.execute();


    }
}

6.1.4 自定模板

参考官方说明：https://mybatis.plus/guide/generator.html#%E8%87%AA%E5%AE%9A%E4%B9%89%E6%A8%A1%E6%9D%BF%E5%BC%95%E6%93%8E

6.2 开源UI代码生成器

开源地址：https://github.com/davidfantasy/mybatis-plus-generator-ui

提供交互式的Web UI用于生成兼容mybatis-plus框架的相关功能代码，包括Entity,Mapper,Mapper.xml,Service,Controller等，可以自定义模板以及各类输出参数，也可通过SQL查询语句直接生成代码。

6.2.1 添加依赖

<dependency>
    <groupId>com.github.davidfantasy</groupId>
    <artifactId>mybatis-plus-generator-ui</artifactId>
    <version>1.4.0</version>
    <scope>test</scope>
</dependency>

6.2.2 代码资源生成服务器

package com.luke.frame.mybatis.plus;
import com.github.davidfantasy.mybatisplus.generatorui.GeneratorConfig;
import com.github.davidfantasy.mybatisplus.generatorui.MybatisPlusToolsApplication;

public class MyBatisPlusGeneratorUIServer {
    public static void main(String[] args) {
        GeneratorConfig config = GeneratorConfig.builder()
                .driverClassName("com.mysql.cj.jdbc.Driver")
                .jdbcUrl("jdbc:mysql://www.xxx.com:13307/forum?serverTimezone=Asia/Shanghai")
                .userName("customer")
                .password("customer")
                .basePackage("com.luke.frame.mybatis.plus")
                .port(8888)
                .build();
        MybatisPlusToolsApplication.run(config);
    }
}

启动服务，访问http://localhost:8888，就可以看到类似下图的UI界面。

在这里插入图片描述

下面来演示以下链表查询

SELECT id,`code`,`name`,(SELECT `name` FROM foods_type WHERE id=type) foods_name FROM foods

在这里插入图片描述

生成后示例代码

<mapper namespace="com.luke.quickstartmp.health.mapper.PartsMapper">
  <resultMap id="SelectAllResultDtoMap" type="com.luke.quickstartmp.health.dto.SelectAllResultDto">
    <result column="id" property="id"/>
    <result column="code" property="code"/>
    <result column="name" property="name"/>
    <result column="foods_name" property="foodsName"/>
  </resultMap>
  <!--Date:2020-11-10,由mybatis-plus-generator-ui自动生成-->
  <select id="selectAll" resultMap="SelectAllResultDtoMap">SELECT id,`code`,`name`,(SELECT `name` FROM foods_type WHERE id=type) foods_name FROM foods</select>
</mapper>

7. CRUD接口

7.1 Service CRUD 接口

说明:

通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆
泛型 T 为任意实体对象
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
对象 Wrapper 为 条件构造器

Save

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

参数说明

类型	参数名	描述
T	entity	实体对象
Collection	entityList	实体对象集合
int	batchSize	插入批次数量

SaveOrUpdate

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

参数说明

类型	参数名	描述
T	entity	实体对象
Wrapper	updateWrapper	实体对象封装操作类 UpdateWrapper
Collection	entityList	实体对象集合
int	batchSize	插入批次数量

Remove

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

参数说明

类型	参数名	描述
Wrapper	queryWrapper	实体包装类 QueryWrapper
Serializable	id	主键ID
Map<String, Object>	columnMap	表字段 map 对象
Collection<? extends Serializable>	idList	主键ID列表

Update

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

参数说明

类型	参数名	描述
Wrapper	updateWrapper	实体对象封装操作类 UpdateWrapper
T	entity	实体对象
Collection	entityList	实体对象集合
int	batchSize	更新批次数量

Get

// 根据 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);

参数说明

类型	参数名	描述
Serializable	id	主键ID
Wrapper	queryWrapper	实体对象封装操作类 QueryWrapper
boolean	throwEx	有多个 result 是否抛出异常
T	entity	实体对象
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);

参数说明

类型	参数名	描述
Wrapper	queryWrapper	实体对象封装操作类 QueryWrapper
Collection<? extends Serializable>	idList	主键ID列表
Map<?String, Object>	columnMap	表字段 map 对象
Function<? super Object, V>	mapper	转换函数

Page

// 无条件分页查询
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);

参数说明

类型	参数名	描述
IPage	page	分页对象
Wrapper	queryWrapper	实体对象封装操作类 QueryWrapper

Count

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

参数说明

类型	参数名	描述
Wrapper	queryWrapper	实体对象封装操作类 QueryWrapper

7.2 Mapper CRUD 接口

说明:

通用 CRUD 封装BaseMapper接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
泛型 T 为任意实体对象
参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
对象 Wrapper 为条件构造器

Insert

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

参数说明

类型	参数名	描述
T	entity	实体对象

Delete

// 根据 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);

参数说明

类型	参数名	描述
Wrapper	wrapper	实体对象封装操作类（可以为 null）
Collection<? extends Serializable>	idList	主键ID列表(不能为 null 以及 empty)
Serializable	id	主键ID
Map<String, Object>	columnMap	表字段 map 对象

Update

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

参数说明

类型	参数名	描述
T	entity	实体对象 (set 条件值,可为 null)
Wrapper	updateWrapper	实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）

Select

// 根据 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);

参数说明

类型	参数名	描述
Serializable	id	主键ID
Wrapper	queryWrapper	实体对象封装操作类（可以为 null）
Collection<? extends Serializable>	idList	主键ID列表(不能为 null 以及 empty)
Map<String, Object>	columnMap	表字段 map 对象
IPage	page	分页查询条件（可以为 RowBounds.DEFAULT）

7.3 条件构造器

说明:

以下出现的第一个入参boolean condition表示该条件是否加入最后生成的sql中
以下代码块内的多个方法均为从上往下补全个别boolean类型的入参,默认为true
以下出现的泛型Param均为Wrapper的子类实例(均具有AbstractWrapper的所有方法)
以下方法在入参中出现的R为泛型,在普通wrapper中是String,在LambdaWrapper中是函数(例:Entity::getId,Entity为实体类,getId为字段id的getMethod)
以下方法入参中的R column均表示数据库字段,当R具体类型为String时则为数据库字段名(字段名是数据库关键字的自己用转义符包裹!)!而不是实体类数据字段名!!!,另当R具体类型为SFunction时项目runtime不支持eclipse自家的编译器!!!
以下举例均为使用普通wrapper,入参为Map和List的均以json形式表现!
使用中如果入参的Map或者List为空,则不会加入最后生成的sql中!!!
有任何疑问就点开源码看,看不懂函数的点击我学习新知识

警告:

不支持以及不赞成在 RPC 调用中把 Wrapper 进行传输

wrapper 很重
传输 wrapper 可以类比为你的 controller 用 map 接收值(开发一时爽,维护火葬场)
正确的 RPC 调用姿势是写一个 DTO 进行传输,被调用方再根据 DTO 执行相应的操作
我们拒绝接受任何关于 RPC 传输 Wrapper 报错相关的 issue 甚至 pr

7.3.1 AbstractWrapper

说明:

QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类

用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条件

注意： entity 生成的 where 条件与使用各个 api 生成的 where 条件没有任何关联行为

参考链接：https://baomidou.com/guide/wrapper.html#abstractwrapper

7.3.2 QueryWrapper

说明:

继承自 AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件

及 LambdaQueryWrapper, 可以通过 new QueryWrapper().lambda() 方法获取

参考链接：https://baomidou.com/guide/wrapper.html#querywrapper

简单使用：

package com.luke.frame.mybatis.plus.mapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xuetang9.frame.mybatis.plus.domain.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testQueryWrapper() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();

        queryWrapper.eq(true, "name", "admin");

        queryWrapper.lambda().select(User::getAccount, User::getName);

        userMapper.selectList(queryWrapper);
    }
}

7.3.3 UpdateWrapper

说明:

继承自 AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件

及 LambdaUpdateWrapper, 可以通过 new UpdateWrapper().lambda() 方法获取!

参考链接：https://baomidou.com/guide/wrapper.html#updatewrapper

7.3.4 使用 Wrapper 自定义SQL

需求来源:

在使用了mybatis-plus之后, 自定义SQL的同时也想使用Wrapper的便利应该怎么办？

在mybatis-plus版本3.0.7得到了完美解决版本需要大于或等于3.0.7, 以下两种方案取其一即可

Service.java

mysqlMapper.getAll(Wrappers.<MysqlData>lambdaQuery().eq(MysqlData::getGroup, 1));

方案一：注解方式 Mapper.java

@Select("select * from mysql_data ${ew.customSqlSegment}")
List<MysqlData> getAll(@Param(Constants.WRAPPER) Wrapper wrapper);

方案二：XML形式 Mapper.xml

<select id="getAll" resultType="MysqlData">
	SELECT * FROM mysql_data ${ew.customSqlSegment}
</select>

7.4 分页插件

7.4.1 配置分页拦截器

7.4.1.1 V3.4.0以前使用

@Configuration
@MapperScan("com.baomidou.cloud.service.*.mapper*")
public class MybatisPlusConfig {
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        // paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        // paginationInterceptor.setLimit(500);
        // 开启 count 的 join 优化,只针对部分 left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }
}

7.4.1.2 V3.4.0版本使用

package com.luke.frame.mybatis.plus.config;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.autoconfigure.ConfigurationCustomizer;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 老九学堂
 * @copyright 老九学堂
 */
@Configuration
@MapperScan("com.xuetang9.frame.mybatis.plus.mapper")
public class MyBatisPlusConfig {
    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,
     * 需要设置 MybatisConfiguration#useDeprecatedExecutor = false
     * 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> configuration.setUseDeprecatedExecutor(false);
    }
}

7.4.2 使用示例

这里没有条件，所以赋值为空

package com.luke.frame.mybatis.plus.mapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xuetang9.frame.mybatis.plus.domain.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testPage() {
        Page<User> userPage = new Page<>();
        userPage.setCurrent(2);
        userPage.setSize(3);
        userMapper.selectPage(userPage,null);
    }
}

7.4.3 拦截器参数说明

属性名	类型	默认值	描述
overflow	boolean	false	溢出总页数后是否进行处理(默认不处理,参见 `插件#continuePage` 方法)
maxLimit	Long		单页分页条数限制(默认无限制,参见 `插件#handlerLimit` 方法)
dbType	DbType		数据库类型(根据类型获取应使用的分页方言,参见 `插件#findIDialect` 方法)
dialect	IDialect		方言实现类(参见 `插件#findIDialect` 方法)

建议单一数据库类型的均设置 dbType

8. 其他使用说明

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
class UserMapperTest {

@Autowired
private UserMapper userMapper;

@Test
public void testPage() {
    Page<User> userPage = new Page<>();
    userPage.setCurrent(2);
    userPage.setSize(3);
    userMapper.selectPage(userPage,null);
}

}


### 7.4.3 拦截器参数说明

|  属性名  |   类型   | 默认值 |                             描述                             |
| :------: | :------: | :----: | :----------------------------------------------------------: |
| overflow | boolean  | false  | 溢出总页数后是否进行处理(默认不处理,参见 `插件#continuePage` 方法) |
| maxLimit |   Long   |        |  单页分页条数限制(默认无限制,参见 `插件#handlerLimit` 方法)  |
|  dbType  |  DbType  |        | 数据库类型(根据类型获取应使用的分页方言,参见 `插件#findIDialect` 方法) |
| dialect  | IDialect |        |          方言实现类(参见 `插件#findIDialect` 方法)           |

> 建议单一数据库类型的均设置 dbType

# 8. 其他使用说明

查看链接：https://baomidou.com/guide/

a听闻

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
MyBaitsPlus

MyBatis-Plus1. 什么是MyBatis-Plus官网链接：https://mybatis.plus/版本发布历史：https://github.com/baomidou/mybatis-plus/blob/3.0/CHANGELOG.md1.1 简介MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率
复制链接

扫一扫