mybtais-plus学习--BaseMapper提供的方法及SQL语句生成

约定不等于承诺〃 2023-09-29 06:03 18阅读 0赞

这篇博客我们介绍一下关于[Mybatis][]\-Plus相关的知识，Mybatis-Plus可以简单的理解为Mybatis的加强，其在Mybatis的基础上完成了一些封装，这样开发人员在使用起来就很容易和方便（确实是一个很好的框架），官网[Mybatis-Plus][]

## 优点 | Advantages ##

*  **无侵入**：Mybatis-Plus 在 Mybatis 的基础上进行扩展，只做增强不做改变，引入 Mybatis-Plus 不会对您现有的 Mybatis 构架产生任何影响，而且 MP 支持所有 Mybatis 原生的特性
 *  **依赖少**：仅仅依赖 Mybatis 以及 Mybatis-Spring
 *  **损耗小**：启动即会自动注入基本CURD，性能基本无损耗，直接面向对象操作
 *  **预防Sql注入**：内置Sql注入剥离器，有效预防Sql注入攻击
 *  **通用CRUD操作**：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
 *  **多种主键策略**：支持多达4种主键策略（内含分布式唯一ID生成器），可自由配置，完美解决主键问题
 *  **支持热加载**：Mapper 对应的 XML 支持热加载，对于简单的 CRUD 操作，甚至可以无 XML 启动
 *  **支持ActiveRecord**：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可实现基本 CRUD 操作
 *  **支持代码生成**：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用（P.S. 比 Mybatis 官方的 Generator 更加强大！）
 *  **支持自定义全局通用操作**：支持全局通用方法注入（ Write once, use anywhere ）
 *  **支持关键词自动转义**：支持数据库关键词（order、key......）自动转义，还可自定义关键词
 *  **内置分页插件**：基于Mybatis物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于写基本List查询
 *  **内置性能分析插件**：可输出Sql语句以及其执行时间，建议开发测试时启用该功能，能有效解决慢查询
 *  **内置全局拦截插件**：提供全表 delete 、 update 操作智能分析阻断，预防误操作

在使用Mybatis-Plus中我们可能用到一个比较多的类是BaseMapper接口，其最终也是利用的Mybatis接口编程的实现机制，其默认提供了一系列的增删改查的基础方法，并且开发人员对于这些基础操作不需要写SQL进行处理操作（Mybatis提供的机制就是需要开发人员在mapper.xml中提供[sql语句][sql]），那样我们可以猜测肯定是Mybatis-Plus完成了BaseMapper接口提供的方法的SQL语句的生成操作。

BaseMapper类：

public 
          
          
           interface 
          
          
           BaseMapper<T> {
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 插入一条记录
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param entity 实体对象
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              Integer 
          
          
           insert
          
          
           (T entity);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 ID 删除
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param id 主键ID
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              Integer 
          
          
           deleteById
          
          
           (Serializable id);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 columnMap 条件，删除记录
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param columnMap 表字段 map 对象
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              Integer 
          
          
           deleteByMap
          
          
           (@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 entity 条件，删除记录
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param queryWrapper 实体对象封装操作类（可以为 null）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              Integer 
          
          
           delete
          
          
           (@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 删除（根据ID 批量删除）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param idList 主键ID列表(不能为 null 以及 empty)
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              Integer 
          
          
           deleteBatchIds
          
          
           (@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 ID 修改
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param entity 实体对象
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              Integer 
          
          
           updateById
          
          
           (@Param(Constants.ENTITY) T entity);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 whereEntity 条件，更新记录
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param entity        实体对象 (set 条件值,不能为 null)
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              Integer 
          
          
           update
          
          
           (@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 ID 查询
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param id 主键ID
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              T 
          
          
           selectById
          
          
           (Serializable id);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 查询（根据ID 批量查询）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param idList 主键ID列表(不能为 null 以及 empty)
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              List<T> 
          
          
           selectBatchIds
          
          
           (@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 查询（根据 columnMap 条件）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param columnMap 表字段 map 对象
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              List<T> 
          
          
           selectByMap
          
          
           (@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 entity 条件，查询一条记录
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param queryWrapper 实体对象
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              T 
          
          
           selectOne
          
          
           (@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 Wrapper 条件，查询总记录数
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param queryWrapper 实体对象
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              Integer 
          
          
           selectCount
          
          
           (@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 entity 条件，查询全部记录
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param queryWrapper 实体对象封装操作类（可以为 null）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              List<T> 
          
          
           selectList
          
          
           (@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 Wrapper 条件，查询全部记录
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param queryWrapper 实体对象封装操作类（可以为 null）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              List<Map<String, Object>> 
          
          
           selectMaps
          
          
           (@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 Wrapper 条件，查询全部记录
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 注意： 只返回第一个字段的值
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param queryWrapper 实体对象封装操作类（可以为 null）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              List<Object> 
          
          
           selectObjs
          
          
           (@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 entity 条件，查询全部记录（并翻页）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param queryWrapper 实体对象封装操作类（可以为 null）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              IPage<T> 
          
          
           selectPage
          
          
           (IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * <p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 根据 Wrapper 条件，查询全部记录（并翻页）
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * </p>
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                *
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param page         分页查询条件
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * @param queryWrapper 实体对象封装操作类
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              IPage<Map<String, Object>> 
          
          
           selectMapsPage
          
          
           (IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
          }

在Mybatis-Plus中提供了SqlMethod类，从这个类中我们可以看到针对BaseMapper类中的每个方法，SqlMethod都提供了一个SQL语句的模板来生成SQL语句，最终还是一个namespace+method对应一条sql语句

public 
          
          
           enum 
          
          
           SqlMethod { 
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 插入
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              INSERT_ONE(
          
          
           "insert", 
          
          
           "插入一条数据（选择字段插入）", 
          
          
           "<script>INSERT INTO %s %s VALUES %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 删除
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              DELETE_BY_ID(
          
          
           "deleteById", 
          
          
           "根据ID 删除一条数据", 
          
          
           "<script>DELETE FROM %s WHERE %s=#{%s}</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              DELETE_BY_MAP(
          
          
           "deleteByMap", 
          
          
           "根据columnMap 条件删除记录", 
          
          
           "<script>DELETE FROM %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              DELETE(
          
          
           "delete", 
          
          
           "根据 entity 条件删除记录", 
          
          
           "<script>DELETE FROM %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              DELETE_BATCH_BY_IDS(
          
          
           "deleteBatchIds", 
          
          
           "根据ID集合，批量删除数据", 
          
          
           "<script>DELETE FROM %s WHERE %s IN (%s)</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 逻辑删除
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              LOGIC_DELETE_BY_ID(
          
          
           "deleteById", 
          
          
           "根据ID 逻辑删除一条数据", 
          
          
           "<script>UPDATE %s %s WHERE %s=#{%s} %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              LOGIC_DELETE_BY_MAP(
          
          
           "deleteByMap", 
          
          
           "根据columnMap 条件逻辑删除记录", 
          
          
           "<script>UPDATE %s %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              LOGIC_DELETE(
          
          
           "delete", 
          
          
           "根据 entity 条件逻辑删除记录", 
          
          
           "<script>UPDATE %s %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              LOGIC_DELETE_BATCH_BY_IDS(
          
          
           "deleteBatchIds", 
          
          
           "根据ID集合，批量逻辑删除数据", 
          
          
           "<script>UPDATE %s %s WHERE %s IN (%s) %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 修改
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              UPDATE_BY_ID(
          
          
           "updateById", 
          
          
           "根据ID 选择修改数据", 
          
          
           "<script>UPDATE %s %s WHERE %s=#{%s} %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              UPDATE(
          
          
           "update", 
          
          
           "根据 whereEntity 条件，更新记录", 
          
          
           "<script>UPDATE %s %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 逻辑删除 -> 修改
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              LOGIC_UPDATE_BY_ID(
          
          
           "updateById", 
          
          
           "根据ID 修改数据", 
          
          
           "<script>UPDATE %s %s WHERE %s=#{%s} %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              LOGIC_UPDATE_ALL_COLUMN_BY_ID(
          
          
           "updateAllColumnById", 
          
          
           "根据ID 选择修改数据", 
          
          
           "<script>UPDATE %s %s WHERE %s=#{%s} %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 查询
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SELECT_BY_ID(
          
          
           "selectById", 
          
          
           "根据ID 查询一条数据", 
          
          
           "SELECT %s FROM %s WHERE %s=#{%s}"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SELECT_BY_MAP(
          
          
           "selectByMap", 
          
          
           "根据columnMap 查询一条数据", 
          
          
           "<script>SELECT %s FROM %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SELECT_BATCH_BY_IDS(
          
          
           "selectBatchIds", 
          
          
           "根据ID集合，批量查询数据", 
          
          
           "<script>SELECT %s FROM %s WHERE %s IN (%s)</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SELECT_ONE(
          
          
           "selectOne", 
          
          
           "查询满足条件一条数据", 
          
          
           "<script>SELECT %s FROM %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SELECT_COUNT(
          
          
           "selectCount", 
          
          
           "查询满足条件总记录数", 
          
          
           "<script>SELECT COUNT(1) FROM %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SELECT_LIST(
          
          
           "selectList", 
          
          
           "查询满足条件所有数据", 
          
          
           "<script>SELECT %s FROM %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SELECT_PAGE(
          
          
           "selectPage", 
          
          
           "查询满足条件所有数据（并翻页）", 
          
          
           "<script>SELECT %s FROM %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SELECT_MAPS(
          
          
           "selectMaps", 
          
          
           "查询满足条件所有数据", 
          
          
           "<script>SELECT %s FROM %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SELECT_MAPS_PAGE(
          
          
           "selectMapsPage", 
          
          
           "查询满足条件所有数据（并翻页）", 
          
          
           "<script>SELECT %s FROM %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SELECT_OBJS(
          
          
           "selectObjs", 
          
          
           "查询满足条件所有数据", 
          
          
           "<script>SELECT %s FROM %s %s</script>"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           /**
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                * 逻辑删除 -> 查询
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
          
          
                */
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              LOGIC_SELECT_BY_ID(
          
          
           "selectById", 
          
          
           "根据ID 查询一条数据", 
          
          
           "SELECT %s FROM %s WHERE %s=#{%s} %s"),
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              LOGIC_SELECT_BATCH_BY_IDS(
          
          
           "selectBatchIds", 
          
          
           "根据ID集合，批量查询数据", 
          
          
           "<script>SELECT %s FROM %s WHERE %s IN (%s) %s</script>");
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           private 
          
          
           final String method;
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           private 
          
          
           final String desc;
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           private 
          
          
           final String sql;
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              SqlMethod(String method, String desc, String sql) {
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
                  
          
          
           this.method = method;
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
                  
          
          
           this.desc = desc;
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
                  
          
          
           this.sql = sql;
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              }
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           public String 
          
          
           getMethod
          
          
           () {
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
                  
          
          
           return method;
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              }
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           public String 
          
          
           getDesc
          
          
           () {
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
                  
          
          
           return desc;
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              }
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
              
          
          
           public String 
          
          
           getSql
          
          
           () {
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
                  
          
          
           return sql;
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
              }
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
           
         
         
          
        
        
         
        
        
        
         
         
         
          
        
        
         
        
        
         
         
         
          
           
          
          }

[Mybatis]: https://so.csdn.net/so/search?q=Mybatis&spm=1001.2101.3001.7020
[Mybatis-Plus]: https://github.com/baomidou/mybatis-plus
[sql]: https://so.csdn.net/so/search?q=sql%E8%AF%AD%E5%8F%A5&spm=1001.2101.3001.7020