【MyBatis】高级特性（三）：MBG、通用Mapper、Mybatis-plus

布满荆棘的人生 2022-12-28 08:29 241阅读 0赞

我们在项目中使用 MyBaits 的时候，针对需要操作的一张表，需要创建实体类、Mapper 映射器、Mapper 接口，里面又有很多的字段和方法的配置，这部分的工作是非常繁琐的。而大部分时候我们对于表的操作是相同的，比如根据主键查询、根据Map查询、单条插入、批量插入、根据主键删除等等等等。

当我们的表很多的时候，意味着有大量的重复工作。所以有没有一种办法，可以根据我们的表，自动生成实体类、Mapper映射器、Mapper接口，里面包含了我们需要用到的这些基本方法和SQL呢？

## 1.MBG ##

MyBatis也提供了一个这样的东西，叫做 MyBatis Generator，简称 MBG。我们只需要修改一个配置文件，使用相关的 jar 包命令或者Java 代码就可以帮助我们生成实体类、映射器和接口文件。

### 1.1 使用步骤 ###

第一步，引入依赖

<plugin>
    	<groupId>org.mybatis.generator</groupId>
    	<artifactId>mybatis-generator-maven-plugin</artifactId>
    	<version>1.3.7</version>
    
    	<dependencies>
    		<dependency>
    		  <groupId>org.mybatis.generator</groupId>
     		  <artifactId>mybatis-generator-core</artifactId>
              <version>1.3.7</version>
            </dependency>
    
            <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>8.0.13</version>
            </dependency>
         </dependencies>
    
         <executions>
            <execution>
              <id>mybatis generator</id>
              <phase>package</phase>
              <goals>
                <goal>generate</goal>
              </goals>
              <configuration>
                
                <verbose>true</verbose>
                
                <overwrite>true</overwrite>
                <configurationFile>
                  src/main/resources/generatorConfig.xml
                </configurationFile>
           </configuration>
         </execution>
         </executions>
    </plugin>

第二步，配置文件（generator-config.xml)

<?xml version="1.0" encoding="UTF-8"?>  
    <!DOCTYPE generatorConfiguration  
      PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"  
      "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">  
    <generatorConfiguration>  
        
    	  
        <classPathEntry  location="mysql-connector-java-5.1.38.jar"/>  
        <context id="DB2Tables"  targetRuntime="MyBatis3">  
            <commentGenerator>  
                <property name="suppressDate" value="true"/>  
                  
                <property name="suppressAllComments" value="true"/>  
            </commentGenerator>  
              
            <jdbcConnection driverClass="com.mysql.jdbc.Driver" 
               connectionURL="jdbc:mysql://localhost/mybatis-test" userId="root" password="123456">  
            </jdbcConnection>  
            <javaTypeResolver>  
                <property name="forceBigDecimals" value="false"/>  
            </javaTypeResolver>  
            
            
              
            <javaModelGenerator targetPackage="com.my.entity" targetProject="src">  
                <property name="enableSubPackages" value="true"/>  
                <property name="trimStrings" value="true"/>  
            </javaModelGenerator>  
              
            <sqlMapGenerator targetPackage="com.my.mapper" targetProject="src">  
                <property name="enableSubPackages" value="true"/>  
            </sqlMapGenerator>  
              
            <javaClientGenerator type="XMLMAPPER" targetPackage="com.my.dao" 
                                 targetProject="src">  
                <property name="enableSubPackages" value="true"/>  
            </javaClientGenerator>  
            
            
              
            <table tableName="blog" domainObjectName="Blog" enableCountByExample="false" 
                   enableUpdateByExample="false" enableDeleteByExample="false" 
                   enableSelectByExample="false" selectByExampleQueryId="false"></table>
        </context>  
    </generatorConfiguration>

第三步，执行mybatis-generator插件。生成的类和xml如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center][]

### 1.2 mapper中的函数 ###

我们随便打开一个dao层的接口，看 MBG 给我们生成了什么方法：

public interface UserMapper {
        
        // 按条件计数
        int countByExample(UserExample example);
    
    	// 插入数据（返回值为ID）
        int insert(User record);
        // 选择性插入，插入值不为null的数据
        int insertSelective(User record);
    
        // 按主键删除
        int deleteByPrimaryKey(Integer uId);
    	// 按条件删除
        int deleteByExample(UserExample example);
        
    	// 按主键查询
        User selectByPrimaryKey(Integer uId);
        // 按条件查询
        List<User> selectByExample(UserExample example);
    	
    	// 按主键更新
        int updateByPrimaryKey(User record);
        // 按条件更新
        int updateByExample(@Param("record") User record, @Param("example") UserExample example);
        // 按主键更新值不为null的字段
        int updateByPrimaryKeySelective(User record);
        // 按条件更新值不为null的字段
        int updateByExampleSelective(@Param("record") User record, @Param("example") UserExample example);
    }

那这些作为参数的 Example 是什么呢？

### 1.2 Example ###

MBG 的配置文件里面有一个 Example 的开关，这个东西用来构造复杂的筛选条件的，换句话说就是根据我们的代码去生成 where 条件

xxxExample example = new xxxExample();
    Criteria criteria = new Example().createCriteria();

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">example.setOrderByClause(“字段名 ASC”);</td> 
   <td align="left">添加升序排列条件，DESC为降序</td> 
  </tr> 
  <tr> 
   <td align="left">example.setDistinct(false)</td> 
   <td align="left">去除重复，boolean型，true为选择不重复的记录。</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxIsNull</td> 
   <td align="left">添加字段xxx为null的条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxIsNotNull</td> 
   <td align="left">添加字段xxx不为null的条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxEqualTo(value)</td> 
   <td align="left">添加xxx字段等于value条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxNotEqualTo(value)</td> 
   <td align="left">添加xxx字段不等于value条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxGreaterThan(value)</td> 
   <td align="left">添加xxx字段大于value条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxGreaterThanOrEqualTo(value)</td> 
   <td align="left">添加xxx字段大于等于value条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxLessThan(value)</td> 
   <td align="left">添加xxx字段小于value条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxLessThanOrEqualTo(value)</td> 
   <td align="left">添加xxx字段小于等于value条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxIn(List&lt;？&gt;)</td> 
   <td align="left">添加xxx字段值在List&lt;？&gt;条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxNotIn(List&lt;？&gt;)</td> 
   <td align="left">添加xxx字段值不在List&lt;？&gt;条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxLike(“%”+value+”%”)</td> 
   <td align="left">添加xxx字段值为value的模糊查询条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxNotLike(“%”+value+”%”)</td> 
   <td align="left">添加xxx字段值不为value的模糊查询条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxBetween(value1,value2)</td> 
   <td align="left">添加xxx字段值在value1和value2之间条件</td> 
  </tr> 
  <tr> 
   <td align="left">criteria.andXxxNotBetween(value1,value2)</td> 
   <td align="left">添加xxx字段值不在value1和value2之间条件</td> 
  </tr> 
 </tbody> 
</table>

原理：在实体类中包含了两个有继承关系的Criteria，用其中自动生成的方法来构建查询条件。把这个包含了 Criteria 的实体类作为参数传到查询参数中，在解析 Mapper映射器的时候会转换成SQL条件。

UserMapper mapper = session.getMapper(UserMapper.class); 
    UserExample example = new UserExample (); 
    UserExample.Criteria criteria = example.createCriteria();
    criteria.andUidEqualTo(1);
    List<Blog> list = mapper.selectByExample(example)

生成的sql语句

select 'true' as QUERYID, uid, username, phone from t_user WHERE ( uid = ? )

### 1.4 MBG 存在的问题 ###

当我们使用 MBG 时，如果表字段发生了变化，我们需要修改实体类和 Mapper 文件定义的字段和方法。如果是增量维护，那么一个个文件去修改。如果是全量替换，我们还要去对比用 MBG 生成的文件。字段变动一次就修改一次，维护起来非常麻烦。

解决这个问题，我们有两种思路。

**解决方案一**

因为 MyBatis 的 Mapper 是[支持继承的][Link 1]，所以我们可以把 Mapper.xml 和 Mapper 接口都分成两个文件。

*  一个是MBG生成的，这部分是固定不变的。
 *  一个是自己手动创建的DAO类，并且继承生成的接口

所以以后发生变化的部分就在手动创建的DAO里面维护。具体操作步骤如下：

第一步，BlogMapperExt 继承generator生成的 Mapper

public interface BlogMapperExt extends BlogMapper {
        
        public Blog selectBlogByName(String name); 
    }

第二步，编写扩展的 mapper 文件 – BlogMapperExt.xml

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-
    3-mapper.dtd">
    <mapper namespace="com.my.mapper.BlogMapperExt">
        
        
        
        <resultMap id="BaseResultMap" type="blog">
            <id column="bid" property="bid" jdbcType="INTEGER"/>
            <result column="name" property="name" jdbcType="VARCHAR"/>
            <result column="author_id" property="authorId" jdbcType="INTEGER"/>
        </resultMap>
    
        
        <select id="selectBlogByName" resultMap="BaseResultMap" statementType="PREPARED">
            select * from blog where name = #{name}
        </select>
    </mapper>

3.配置mybatis-conf，扫描新的 BlogMapperExt.xml

> 以后只要修改Ext的文件就可以了。但是这么做有一个缺点 – 文件会增多冗余。

**解决方案二**

既然针对每张表生成的基本方法都是一样的，也就是公共的方法部分代码都是一样的，那么就可以把这部分合并成一个文件，通过泛型来实现多种类型。

public interface BlogMapper extends Mapper<Blog>

除了配置文件变动的问题之外，通用Mapper还可以解决：

*  每个Mapper接口中大量的重复方法的定义
 *  屏蔽数据库的差异
 *  提供批量操作的方法
 *  实现分页

这下就引出了我们接下来要说的通用Mapper…

> 多提一句，通用Mapper和PageHelper作者是同一个人（刘增辉）

## 2.通用Mapper ##

这里就不再过多介绍通用Mapper了，下面说一下在 SpringBoot 中如何使用：

第一步，引入依赖：

<dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper-spring-boot-starter</artifactId>
        <version>1.3.2</version>
    </dependency>

第二步，手动创建实体类

public class User {
        
    
        private Long uid;
        private String username;
        private String phone;
        private String password;
    	
    	// getter和setter这里就不列出来了
    }

第三步，创建 dao 层的接口并继承 Mapper

@Mapper
    public interface UserDao extends tk.mybatis.mapper.common.Mapper<User> {
        
    	
    	// 如果自动生成的sql不够我们用或者性能差，我们可以直接是使用注解写在接口中
    	// @Insert、@Delete、@Update、@Select
    	
        @Select("SELECT * from `user` WHERE uid = #{uid}")
        User selectUserByUid(long uid);
    
        @Update("UPDATE `user` set `password` = #{pwd} WHERE uid = #{uid}")
        int updatePwdByUid(String pwd, long uid);
    }

使用方式跟上面 MBG 一样，都是提供了那些基本的函数和 Example。

## 3.[Mybatis-plus][] ##

MyBatis-Plus 是原生 MyBatis 的一个增强工具，可以在使用原生 MyBatis 的所有功能的基础上，使用plus特有的功能。

MyBatis-Plus的核心功能：

*  通用 CRUD：定义好Mapper接口后，只需要继承BaseMapper 接口即可获得通用的增删改查功能，无需编写任何接口方法与配置文件。
 *  条件构造器：通过EntityWrapper（实体包装类），可以用于拼接 SQL 语句，并且支持排序、分组查询等复杂的SQL。
 *  代码生成器：支持一系列的策略配置与全局配置，比MyBatis的代码生成更好用。

> 另外，MyBatis-Plus 还自带了分页的功能

这里还是简单说一下 mybatis-plus 如何在 SpringBoot 中使用：

第一步，引入依赖

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

第二步，手动创建实体类

第三步，创建 dao 层的接口并继承 BaseMapper

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    
    @Mapper
    public interface UserMapper extends BaseMapper<User> {
        
    }

第四步，配置启用分页功能

@Configuration
    public class MybatisPlusConfig {
        
    
        /**
         * 分页插件
         */
        @Bean
        public PaginationInterceptor paginationInterceptor() {
        
            return new PaginationInterceptor();
        }
    }

在使用上，mybatis-plus 与上面两个略有不同。我们下面就来看看继承的 BaseMapper 到底是什么样子把。

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/3961d9674c974ea08e6c7bcb16c4d9c5.png
[Link 1]: https://github.com/mybatis/mybatis-3/issues/35
[Mybatis-plus]: https://mybatis.plus/guide