當(dāng)我們使用MyBatis的時(shí)候，需要在mapper.xml中書寫大量的SQL語(yǔ)句。當(dāng)我們使用MyBatis Generator（MBG）作為代碼生成器時(shí)，也會(huì)生成大量的mapper.xml文件。其實(shí)從MBG 1.3.6版本以后，MyBatis官方已經(jīng)推薦使用Dynamic SQL，使用這一新特性基本就不用寫mapper.xml文件了，使用起來(lái)非常方便，推薦給大家！

Dynamic SQL簡(jiǎn)介

在我們使用Spring的時(shí)候，有XML和Java兩種配置方式。在使用SpringBoot時(shí)，已經(jīng)推薦使用Java配置，基本不用xml配置了。使用Dynamic SQL就好比是使用Java的方式來(lái)操作MyBatis。Dynamic SQL是用于生成動(dòng)態(tài)SQL語(yǔ)句的框架，提倡使用Java API的方式來(lái)實(shí)現(xiàn)SQL操作，支持復(fù)雜查詢和多表查詢。

Dynamic SQL具有如下特性：

• 類型安全：可以確保參數(shù)類型和數(shù)據(jù)庫(kù)字段類型相匹配；
• 富有表現(xiàn)力：語(yǔ)句的構(gòu)建方式可以清楚地傳達(dá)其含義；
• 使用靈活：可以使用and，or和nested條件的任意組合來(lái)構(gòu)建where子句；
• 擴(kuò)展性強(qiáng)：可以同時(shí)為MyBatis3, Spring JDBC和純JDBC框架生成SQL語(yǔ)句；
• 輕量級(jí)：只需添加一個(gè)小的依賴項(xiàng)，沒(méi)有傳遞依賴。

開(kāi)始使用

首先我們通過(guò)一個(gè)入門示例將Dynamic SQL用起來(lái)，該示例會(huì)包含基礎(chǔ)的CRUD操作。

集成Dynamic SQL

• 在pom.xml中添加如下依賴，對(duì)比之前使用MBG，僅僅多添加了MyBatis的動(dòng)態(tài)SQL依賴；

<dependencies>
    <!--SpringBoot整合MyBatis-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.3</version>
    </dependency>
    <!--MyBatis分頁(yè)插件-->
    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper-spring-boot-starter</artifactId>
        <version>1.3.0</version>
    </dependency>
    <!--集成druid連接池-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>
    <!-- MyBatis 生成器 -->
    <dependency>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-core</artifactId>
        <version>1.4.0</version>
    </dependency>
    <!-- MyBatis 動(dòng)態(tài)SQL支持 -->
    <dependency>
        <groupId>org.mybatis.dynamic-sql</groupId>
        <artifactId>mybatis-dynamic-sql</artifactId>
        <version>1.2.1</version>
    </dependency>
    <!--Mysql數(shù)據(jù)庫(kù)驅(qū)動(dòng)-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.15</version>
    </dependency>
</dependencies>

• 在application.yml中對(duì)數(shù)據(jù)源和MyBatis的mapper.xml文件路徑進(jìn)行配置，只需配置自定義mapper.xml路徑即可；

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mall?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: root

mybatis:
  mapper-locations:
    - classpath:dao/*.xml

• 添加Java配置，用于掃描Mapper接口路徑，MBG生成的放在mapper包下，自定義的放在dao包下。

/**
 * MyBatis配置類
 * Created by macro on 2019/4/8.
 */
@Configuration
@MapperScan({"com.macro.mall.tiny.mbg.mapper","com.macro.mall.tiny.dao"})
public class MyBatisConfig {
}

使用代碼生成器

• 在使用MBG生成代碼前，我們還需要對(duì)其進(jìn)行一些配置，首先在enerator.properties文件中配置好數(shù)據(jù)庫(kù)連接信息；

jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.connectionURL=jdbc:mysql://localhost:3306/mall?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
jdbc.userId=root
jdbc.password=root

• 然后在generatorConfig.xml文件中對(duì)MBG進(jìn)行配置，配置屬性說(shuō)明直接參考注釋即可；

<?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>
    <properties resource="generator.properties"/>
    <context id="MySqlContext" targetRuntime="MyBatis3DynamicSQL">
        <property name="beginningDelimiter" value="`"/>
        <property name="endingDelimiter" value="`"/>
        <property name="javaFileEncoding" value="UTF-8"/>
        <!-- 為模型生成序列化方法-->
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>
        <!-- 為生成的Java模型創(chuàng)建一個(gè)toString方法 -->
        <plugin type="org.mybatis.generator.plugins.ToStringPlugin"/>
        <!--可以自定義生成model的代碼注釋-->
        <commentGenerator type="com.macro.mall.tiny.mbg.CommentGenerator">
            <!-- 是否去除自動(dòng)生成的注釋 true：是 ：false:否 -->
            <property name="suppressAllComments" value="true"/>
            <property name="suppressDate" value="true"/>
            <property name="addRemarkComments" value="true"/>
        </commentGenerator>
        <!--配置數(shù)據(jù)庫(kù)連接-->
        <jdbcConnection driverClass="${jdbc.driverClass}"
                        connectionURL="${jdbc.connectionURL}"
                        userId="${jdbc.userId}"
                        password="${jdbc.password}">
            <!--解決mysql驅(qū)動(dòng)升級(jí)到8.0后不生成指定數(shù)據(jù)庫(kù)代碼的問(wèn)題-->
            <property name="nullCatalogMeansCurrent" value="true" />
        </jdbcConnection>
        <!--指定生成model的路徑-->
        <javaModelGenerator targetPackage="com.macro.mall.tiny.mbg.model" targetProject="mall-tiny-dynamic-sql\src\main\java"/>
        <!--指定生成mapper接口的的路徑-->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.macro.mall.tiny.mbg.mapper"
                             targetProject="mall-tiny-dynamic-sql\src\main\java"/>
        <!--生成全部表tableName設(shè)為%-->
        <table tableName="ums_admin">
            <generatedKey column="id" sqlStatement="MySql" identity="true"/>
        </table>
        <table tableName="ums_role">
            <generatedKey column="id" sqlStatement="MySql" identity="true"/>
        </table>
        <table tableName="ums_admin_role_relation">
            <generatedKey column="id" sqlStatement="MySql" identity="true"/>
        </table>
    </context>
</generatorConfiguration>

• 與之前使用MBG有所不同，targetRuntime需要改為MyBatis3DynamicSql，用于配置生成mapper.xml路徑的sqlMapGenerator標(biāo)簽也不需要配置了；
• 之前使用MBG時(shí)自定義了實(shí)體類注解的生成，寫了個(gè)類CommentGenerator繼承DefaultCommentGenerator，在addFieldComment方法中將Swagger注解寫入到了實(shí)體類的屬性上；

/**
 * 自定義注釋生成器
 * Created by macro on 2018/4/26.
 */
public class CommentGenerator extends DefaultCommentGenerator {
    /**
     * 給字段添加注釋
     */
    @Override
    public void addFieldComment(Field field, IntrospectedTable introspectedTable,
                                IntrospectedColumn introspectedColumn) {
        String remarks = introspectedColumn.getRemarks();
        //根據(jù)參數(shù)和備注信息判斷是否添加備注信息
        if(addRemarkComments&&StringUtility.stringHasValue(remarks)){
            //數(shù)據(jù)庫(kù)中特殊字符需要轉(zhuǎn)義
            if(remarks.contains("\"")){
                remarks = remarks.replace("\"","'");
            }
            //給model的字段添加swagger注解
            field.addJavaDocLine("@ApiModelProperty(value = \""+remarks+"\")");
        }
    }
}

• 在使用Dynamic SQL的時(shí)候，這種方法已經(jīng)無(wú)用，需要在addFieldAnnotation中將Swagger注解寫入到了實(shí)體類的屬性上；

/**
 * 自定義注釋生成器
 * Created by macro on 2018/4/26.
 */
public class CommentGenerator extends DefaultCommentGenerator {

    @Override
    public void addFieldAnnotation(Field field, IntrospectedTable introspectedTable, IntrospectedColumn introspectedColumn, Set<FullyQualifiedJavaType> imports) {
        if (!addRemarkComments || CollUtil.isEmpty(imports)) return;
        long count = imports.stream()
                .filter(item -> API_MODEL_PROPERTY_FULL_CLASS_NAME.equals(item.getFullyQualifiedName()))
                .count();
        if (count <= 0L) {
            return;
        }
        String remarks = introspectedColumn.getRemarks();
        //根據(jù)參數(shù)和備注信息判斷是否添加備注信息
        if (StringUtility.stringHasValue(remarks)) {
            //數(shù)據(jù)庫(kù)中特殊字符需要轉(zhuǎn)義
            if (remarks.contains("\"")) {
                remarks = remarks.replace("\"", "'");
            }
            //給model的字段添加swagger注解
            field.addJavaDocLine("@ApiModelProperty(value = \"" + remarks + "\")");
        }
    }
}

• 一切準(zhǔn)備就緒，執(zhí)行Generator類的main方法，生成代碼結(jié)構(gòu)信息如下，可以發(fā)現(xiàn)已經(jīng)不再生成mapper.xml文件和Example類，取而代之的是生成了DynamicSqlSupport類。
  image.png
  
  實(shí)現(xiàn)基本的CRUD操作

這里使用的是mall-tiny項(xiàng)目中權(quán)限管理功能相關(guān)表，具體可以參考《還在從零開(kāi)始搭建項(xiàng)目？手?jǐn)]了款快速開(kāi)發(fā)腳手架》。

• 查看下MBG生成的Mapper接口，比之前使用MBG時(shí)增加了很多方法，并且有了一些默認(rèn)的方法實(shí)現(xiàn)，可見(jiàn)之前在mapper.xml中的實(shí)現(xiàn)都已經(jīng)轉(zhuǎn)移到Mapper接口中去了，單表CRUD直接調(diào)用對(duì)應(yīng)方法即可；

@Mapper
public interface UmsAdminMapper {
    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    BasicColumn[] selectList = BasicColumn.columnList(id, username, password, icon, email, nickName, note, createTime, loginTime, status);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @SelectProvider(type=SqlProviderAdapter.class, method="select")
    long count(SelectStatementProvider selectStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @DeleteProvider(type=SqlProviderAdapter.class, method="delete")
    int delete(DeleteStatementProvider deleteStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @InsertProvider(type=SqlProviderAdapter.class, method="insert")
    @SelectKey(statement="SELECT LAST_INSERT_ID()", keyProperty="record.id", before=false, resultType=Long.class)
    int insert(InsertStatementProvider<UmsAdmin> insertStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @SelectProvider(type=SqlProviderAdapter.class, method="select")
    @ResultMap("UmsAdminResult")
    Optional<UmsAdmin> selectOne(SelectStatementProvider selectStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @SelectProvider(type=SqlProviderAdapter.class, method="select")
    @Results(id="UmsAdminResult", value = {
        @Result(column="id", property="id", jdbcType=JdbcType.BIGINT, id=true),
        @Result(column="username", property="username", jdbcType=JdbcType.VARCHAR),
        @Result(column="password", property="password", jdbcType=JdbcType.VARCHAR),
        @Result(column="icon", property="icon", jdbcType=JdbcType.VARCHAR),
        @Result(column="email", property="email", jdbcType=JdbcType.VARCHAR),
        @Result(column="nick_name", property="nickName", jdbcType=JdbcType.VARCHAR),
        @Result(column="note", property="note", jdbcType=JdbcType.VARCHAR),
        @Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP),
        @Result(column="login_time", property="loginTime", jdbcType=JdbcType.TIMESTAMP),
        @Result(column="status", property="status", jdbcType=JdbcType.INTEGER)
    })
    List<UmsAdmin> selectMany(SelectStatementProvider selectStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @UpdateProvider(type=SqlProviderAdapter.class, method="update")
    int update(UpdateStatementProvider updateStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default long count(CountDSLCompleter completer) {
        return MyBatis3Utils.countFrom(this::count, umsAdmin, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int delete(DeleteDSLCompleter completer) {
        return MyBatis3Utils.deleteFrom(this::delete, umsAdmin, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int deleteByPrimaryKey(Long id_) {
        return delete(c -> 
            c.where(id, isEqualTo(id_))
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int insert(UmsAdmin record) {
        return MyBatis3Utils.insert(this::insert, record, umsAdmin, c ->
            c.map(username).toProperty("username")
            .map(password).toProperty("password")
            .map(icon).toProperty("icon")
            .map(email).toProperty("email")
            .map(nickName).toProperty("nickName")
            .map(note).toProperty("note")
            .map(createTime).toProperty("createTime")
            .map(loginTime).toProperty("loginTime")
            .map(status).toProperty("status")
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int insertSelective(UmsAdmin record) {
        return MyBatis3Utils.insert(this::insert, record, umsAdmin, c ->
            c.map(username).toPropertyWhenPresent("username", record::getUsername)
            .map(password).toPropertyWhenPresent("password", record::getPassword)
            .map(icon).toPropertyWhenPresent("icon", record::getIcon)
            .map(email).toPropertyWhenPresent("email", record::getEmail)
            .map(nickName).toPropertyWhenPresent("nickName", record::getNickName)
            .map(note).toPropertyWhenPresent("note", record::getNote)
            .map(createTime).toPropertyWhenPresent("createTime", record::getCreateTime)
            .map(loginTime).toPropertyWhenPresent("loginTime", record::getLoginTime)
            .map(status).toPropertyWhenPresent("status", record::getStatus)
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default Optional<UmsAdmin> selectOne(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectOne(this::selectOne, selectList, umsAdmin, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default List<UmsAdmin> select(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectList(this::selectMany, selectList, umsAdmin, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default List<UmsAdmin> selectDistinct(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectDistinct(this::selectMany, selectList, umsAdmin, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default Optional<UmsAdmin> selectByPrimaryKey(Long id_) {
        return selectOne(c ->
            c.where(id, isEqualTo(id_))
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int update(UpdateDSLCompleter completer) {
        return MyBatis3Utils.update(this::update, umsAdmin, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    static UpdateDSL<UpdateModel> updateAllColumns(UmsAdmin record, UpdateDSL<UpdateModel> dsl) {
        return dsl.set(username).equalTo(record::getUsername)
                .set(password).equalTo(record::getPassword)
                .set(icon).equalTo(record::getIcon)
                .set(email).equalTo(record::getEmail)
                .set(nickName).equalTo(record::getNickName)
                .set(note).equalTo(record::getNote)
                .set(createTime).equalTo(record::getCreateTime)
                .set(loginTime).equalTo(record::getLoginTime)
                .set(status).equalTo(record::getStatus);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    static UpdateDSL<UpdateModel> updateSelectiveColumns(UmsAdmin record, UpdateDSL<UpdateModel> dsl) {
        return dsl.set(username).equalToWhenPresent(record::getUsername)
                .set(password).equalToWhenPresent(record::getPassword)
                .set(icon).equalToWhenPresent(record::getIcon)
                .set(email).equalToWhenPresent(record::getEmail)
                .set(nickName).equalToWhenPresent(record::getNickName)
                .set(note).equalToWhenPresent(record::getNote)
                .set(createTime).equalToWhenPresent(record::getCreateTime)
                .set(loginTime).equalToWhenPresent(record::getLoginTime)
                .set(status).equalToWhenPresent(record::getStatus);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int updateByPrimaryKey(UmsAdmin record) {
        return update(c ->
            c.set(username).equalTo(record::getUsername)
            .set(password).equalTo(record::getPassword)
            .set(icon).equalTo(record::getIcon)
            .set(email).equalTo(record::getEmail)
            .set(nickName).equalTo(record::getNickName)
            .set(note).equalTo(record::getNote)
            .set(createTime).equalTo(record::getCreateTime)
            .set(loginTime).equalTo(record::getLoginTime)
            .set(status).equalTo(record::getStatus)
            .where(id, isEqualTo(record::getId))
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int updateByPrimaryKeySelective(UmsAdmin record) {
        return update(c ->
            c.set(username).equalToWhenPresent(record::getUsername)
            .set(password).equalToWhenPresent(record::getPassword)
            .set(icon).equalToWhenPresent(record::getIcon)
            .set(email).equalToWhenPresent(record::getEmail)
            .set(nickName).equalToWhenPresent(record::getNickName)
            .set(note).equalToWhenPresent(record::getNote)
            .set(createTime).equalToWhenPresent(record::getCreateTime)
            .set(loginTime).equalToWhenPresent(record::getLoginTime)
            .set(status).equalToWhenPresent(record::getStatus)
            .where(id, isEqualTo(record::getId))
        );
    }
}

• 生成代碼中有一些DynamicSqlSupport類，比如UmsAdminDynamicSqlSupport，主要是把數(shù)據(jù)庫(kù)表和字段抽象成了SqlTable和SqlColumn對(duì)象，估計(jì)是為了防止我們硬編碼；

public final class UmsAdminDynamicSqlSupport {
    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final UmsAdmin umsAdmin = new UmsAdmin();

    public static final SqlColumn<Long> id = umsAdmin.id;

    public static final SqlColumn<String> username = umsAdmin.username;

    public static final SqlColumn<String> password = umsAdmin.password;

    public static final SqlColumn<String> icon = umsAdmin.icon;

    public static final SqlColumn<String> email = umsAdmin.email;

    public static final SqlColumn<String> nickName = umsAdmin.nickName;

    public static final SqlColumn<String> note = umsAdmin.note;

    public static final SqlColumn<Date> createTime = umsAdmin.createTime;

    public static final SqlColumn<Date> loginTime = umsAdmin.loginTime;

    public static final SqlColumn<Integer> status = umsAdmin.status;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final class UmsAdmin extends SqlTable {
        public final SqlColumn<Long> id = column("id", JDBCType.BIGINT);

        public final SqlColumn<String> username = column("username", JDBCType.VARCHAR);

        public final SqlColumn<String> password = column("password", JDBCType.VARCHAR);

        public final SqlColumn<String> icon = column("icon", JDBCType.VARCHAR);

        public final SqlColumn<String> email = column("email", JDBCType.VARCHAR);

        public final SqlColumn<String> nickName = column("nick_name", JDBCType.VARCHAR);

        public final SqlColumn<String> note = column("note", JDBCType.VARCHAR);

        public final SqlColumn<Date> createTime = column("create_time", JDBCType.TIMESTAMP);

        public final SqlColumn<Date> loginTime = column("login_time", JDBCType.TIMESTAMP);

        public final SqlColumn<Integer> status = column("status", JDBCType.INTEGER);

        public UmsAdmin() {
            super("ums_admin");
        }
    }
}

• 利用好MBG生成的代碼即可完成單表的CRUD操作了，比如下面最常見(jiàn)的操作。

/**
 * 后臺(tái)用戶管理Service實(shí)現(xiàn)類
 * Created by macro on 2020/12/8.
 */
@Service
public class UmsAdminServiceImpl implements UmsAdminService {
    @Autowired
    private UmsAdminMapper adminMapper;

    @Override
    public void create(UmsAdmin entity) {
        adminMapper.insert(entity);
    }

    @Override
    public void update(UmsAdmin entity) {
        adminMapper.updateByPrimaryKeySelective(entity);
    }

    @Override
    public void delete(Long id) {
        adminMapper.deleteByPrimaryKey(id);
    }

    @Override
    public UmsAdmin select(Long id) {
        Optional<UmsAdmin> optionalEntity = adminMapper.selectByPrimaryKey(id);
        return optionalEntity.orElse(null);
    }

    @Override
    public List<UmsAdmin> listAll(Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        return adminMapper.select(SelectDSLCompleter.allRows());
    }
}

進(jìn)階使用

想要用好Dynamic SQL，上面的基礎(chǔ)操作是不夠的，還需要一些進(jìn)階的使用技巧。

SqlBuilder

SqlBuilder是一個(gè)非常有用的類，使用它可以靈活地構(gòu)建SQL語(yǔ)句的條件，一些常用的條件構(gòu)建方法如下。

image.png

回想一下之前我們?cè)?code>mapper.xml中定義select標(biāo)簽的方式，各個(gè)select標(biāo)簽相當(dāng)于Statement。而這里的StatementProvider好比是Statement中參數(shù)和SQL語(yǔ)句的封裝，方便以Java的方式創(chuàng)建Statement。

條件查詢

使用SqlBuilder類構(gòu)建StatementProvider，然后調(diào)用Mapper接口中的方法即可。

• 這里以按用戶名和狀態(tài)查詢后臺(tái)用戶并按創(chuàng)建時(shí)間降序排列為例，SQL實(shí)現(xiàn)如下；

SELECT
 id,
 username,
 PASSWORD,
 icon,
 email,
 nick_name,
 note,
 create_time,
 login_time,
STATUS 
FROM
 ums_admin 
WHERE
 ( username = 'macro' AND STATUS IN ( 0, 1 ) ) 
ORDER BY
 create_time DESC;

• 使用Dynamic SQL對(duì)應(yīng)的Java代碼實(shí)現(xiàn)如下，使用SqlBuilder的select方法可以指定查詢列，使用from方法可以指定查詢表，使用where方法可以構(gòu)建查詢條件，使用orderBy方法可以指定排序。

/**
 * 后臺(tái)用戶管理Service實(shí)現(xiàn)類
 * Created by macro on 2020/12/8.
 */
@Service
public class UmsAdminServiceImpl implements UmsAdminService {
    @Override
    public List<UmsAdmin> list(Integer pageNum, Integer pageSize, String username, List<Integer> statusList) {
        PageHelper.startPage(pageNum, pageSize);
        SelectStatementProvider selectStatement = SqlBuilder.select(UmsAdminMapper.selectList)
                .from(UmsAdminDynamicSqlSupport.umsAdmin)
                .where(UmsAdminDynamicSqlSupport.username, isEqualToWhenPresent(username))
                .and(UmsAdminDynamicSqlSupport.status, isIn(statusList))
                .orderBy(UmsAdminDynamicSqlSupport.createTime.descending())
                .build()
                .render(RenderingStrategies.MYBATIS3);
        return adminMapper.selectMany(selectStatement);
    }
}

Lambda條件查詢

• 使用Lambda表達(dá)式實(shí)現(xiàn)單表?xiàng)l件查詢更加簡(jiǎn)單，實(shí)現(xiàn)上面的條件查詢，對(duì)應(yīng)Java代碼實(shí)現(xiàn)如下。

/**
 * 后臺(tái)用戶管理Service實(shí)現(xiàn)類
 * Created by macro on 2020/12/8.
 */
@Service
public class UmsAdminServiceImpl implements UmsAdminService {
    @Override
    public List<UmsAdmin> lambdaList(Integer pageNum, Integer pageSize, String username, List<Integer> statusList) {
        PageHelper.startPage(pageNum, pageSize);
        List<UmsAdmin> list = adminMapper.select(c -> c.where(UmsAdminDynamicSqlSupport.username, isEqualToWhenPresent(username))
                .and(UmsAdminDynamicSqlSupport.status, isIn(statusList))
                .orderBy(UmsAdminDynamicSqlSupport.createTime.descending()));
        return list;
    }
}

子查詢

之前使用MBG需要在mapper.xml中手寫SQL才能實(shí)現(xiàn)子查詢，使用Dynamic SQL可以直接在Java代碼中實(shí)現(xiàn)。

這里以按角色I(xiàn)D查詢后臺(tái)用戶為例，SQL實(shí)現(xiàn)如下；

SELECT
 * 
FROM
 ums_admin 
WHERE
 id IN ( SELECT admin_id FROM ums_admin_role_relation WHERE role_id = 1 )

• 使用Dynamic SQL對(duì)應(yīng)的Java代碼實(shí)現(xiàn)如下，可以發(fā)現(xiàn)SqlBuilder的條件構(gòu)造方法isIn中還可以嵌套SqlBuilder的查詢。

/**
 * 后臺(tái)用戶管理Service實(shí)現(xiàn)類
 * Created by macro on 2020/12/8.
 */
@Service
public class UmsAdminServiceImpl implements UmsAdminService {
    @Override
    public List<UmsAdmin> subList(Long roleId) {
        SelectStatementProvider selectStatement = SqlBuilder.select(UmsAdminMapper.selectList)
                .from(UmsAdminDynamicSqlSupport.umsAdmin)
                .where(UmsAdminDynamicSqlSupport.id, isIn(SqlBuilder.select(UmsAdminRoleRelationDynamicSqlSupport.adminId)
                        .from(UmsAdminRoleRelationDynamicSqlSupport.umsAdminRoleRelation)
                        .where(UmsAdminRoleRelationDynamicSqlSupport.roleId, isEqualTo(roleId))))
                .build()
                .render(RenderingStrategies.MYBATIS3);
        return adminMapper.selectMany(selectStatement);
    }
}

Group和Join查詢

涉及到多表查詢，之前使用MBG的時(shí)候基本只能在mapper.xml中手寫SQL實(shí)現(xiàn)，使用Dynamic SQL可以支持多表查詢。

• 這里以按角色統(tǒng)計(jì)后臺(tái)用戶數(shù)量為例，SQL實(shí)現(xiàn)如下；

SELECT
 ur.id AS roleId,
 ur.NAME AS roleName,
 count( ua.id ) AS count 
FROM
 ums_role ur
 LEFT JOIN ums_admin_role_relation uarr ON ur.id = uarr.role_id
 LEFT JOIN ums_admin ua ON uarr.admin_id = ua.id 
GROUP BY
 ur.id;

• 先在Dao中添加一個(gè)groupList方法，然后使用@Results注解定義好resultMap；

/**
 * Created by macro on 2020/12/9.
 */
public interface UmsAdminDao {
    @SelectProvider(type = SqlProviderAdapter.class, method = "select")
    @Results(id = "RoleStatResult", value = {
            @Result(column = "roleId", property = "roleId", jdbcType = JdbcType.BIGINT, id = true),
            @Result(column = "roleName", property = "roleName", jdbcType = JdbcType.VARCHAR),
            @Result(column = "count", property = "count", jdbcType = JdbcType.INTEGER)
    })
    List<RoleStatDto> groupList(SelectStatementProvider selectStatement);
}

• 然后在Service中調(diào)用groupList方法傳入StatementProvider即可，對(duì)應(yīng)的Java代碼實(shí)現(xiàn)如下。

/**
 * 后臺(tái)用戶管理Service實(shí)現(xiàn)類
 * Created by macro on 2020/12/8.
 */
@Service
public class UmsAdminServiceImpl implements UmsAdminService {
    @Override
    public List<RoleStatDto> groupList() {
        SelectStatementProvider selectStatement = SqlBuilder.select(UmsRoleDynamicSqlSupport.id.as("roleId"), UmsRoleDynamicSqlSupport.name.as("roleName"), count(UmsAdminDynamicSqlSupport.id).as("count"))
                .from(UmsRoleDynamicSqlSupport.umsRole)
                .leftJoin(UmsAdminRoleRelationDynamicSqlSupport.umsAdminRoleRelation)
                .on(UmsRoleDynamicSqlSupport.id, equalTo(UmsAdminRoleRelationDynamicSqlSupport.roleId))
                .leftJoin(UmsAdminDynamicSqlSupport.umsAdmin)
                .on(UmsAdminRoleRelationDynamicSqlSupport.adminId, equalTo(UmsAdminDynamicSqlSupport.id))
                .groupBy(UmsRoleDynamicSqlSupport.id)
                .build()
                .render(RenderingStrategies.MYBATIS3);
        return adminDao.groupList(selectStatement);
    }
}

條件刪除

使用Dynamic SQL實(shí)現(xiàn)條件刪除，直接調(diào)用Mapper接口中生成好的delete方法即可。

• 這里以按用戶名刪除后臺(tái)用戶為例，SQL實(shí)現(xiàn)如下；

DELETE 
FROM
 ums_admin 
WHERE
 username = 'andy';

• 使用Dynamic SQL對(duì)應(yīng)Java中的實(shí)現(xiàn)如下。

/**
 * 后臺(tái)用戶管理Service實(shí)現(xiàn)類
 * Created by macro on 2020/12/8.
 */
@Service
public class UmsAdminServiceImpl implements UmsAdminService {
    @Override
    public void deleteByUsername(String username) {
        DeleteStatementProvider deleteStatement = SqlBuilder.deleteFrom(UmsAdminDynamicSqlSupport.umsAdmin)
                .where(UmsAdminDynamicSqlSupport.username, isEqualTo(username))
                .build()
                .render(RenderingStrategies.MYBATIS3);
        adminMapper.delete(deleteStatement);
    }
}

條件修改

使用Dynamic SQL實(shí)現(xiàn)條件修改，直接調(diào)用Mapper接口中生成好的update方法即可。

• 這里以按指定ID修改后臺(tái)用戶的狀態(tài)為例，SQL實(shí)現(xiàn)如下；

UPDATE ums_admin 
SET STATUS = 1 
WHERE
 id IN ( 1, 2 );

• 使用Dynamic SQL對(duì)應(yīng)Java中的實(shí)現(xiàn)如下。

/**
 * 后臺(tái)用戶管理Service實(shí)現(xiàn)類
 * Created by macro on 2020/12/8.
 */
@Service
public class UmsAdminServiceImpl implements UmsAdminService {
    @Override
    public void updateByIds(List<Long> ids, Integer status) {
        UpdateStatementProvider updateStatement = SqlBuilder.update(UmsAdminDynamicSqlSupport.umsAdmin)
                .set(UmsAdminDynamicSqlSupport.status).equalTo(status)
                .where(UmsAdminDynamicSqlSupport.id, isIn(ids))
                .build()
                .render(RenderingStrategies.MYBATIS3);
        adminMapper.update(updateStatement);
    }
}

一對(duì)多查詢

使用Dynamic SQL也可以實(shí)現(xiàn)一對(duì)多查詢，只是由于Java注解無(wú)法實(shí)現(xiàn)循環(huán)引用，所以一對(duì)多的resultMap只能在mapper.xml來(lái)配置，這可能是唯一需要使用mapper.xml的地方。

• 這里以按ID查詢后臺(tái)用戶信息（包含對(duì)應(yīng)角色列表）為例，SQL實(shí)現(xiàn)如下；

SELECT
 ua.*,
 ur.id AS role_id,
 ur.NAME AS role_name,
 ur.description AS role_description,
 ur.create_time AS role_create_time,
 ur.STATUS AS role_status,
 ur.sort AS role_sort 
FROM
 ums_admin ua
 LEFT JOIN ums_admin_role_relation uarr ON ua.id = uarr.admin_id
 LEFT JOIN ums_role ur ON uarr.role_id = ur.id 
WHERE
 ua.id = 1

• 然后在Dao接口中添加selectWithRoleList方法，這里使用@ResultMap注解引用mapper.xml中定義的resultMap；

/**
 * Created by macro on 2020/12/9.
 */
public interface UmsAdminDao {

    @SelectProvider(type = SqlProviderAdapter.class, method = "select")
    @ResultMap("AdminRoleResult")
    AdminRoleDto selectWithRoleList(SelectStatementProvider selectStatement);
}

• 在mapper.xml中添加名稱為AdminRoleResult的resultMap，這里有個(gè)小技巧，可以直接引用在Mapper接口中定義好的resultMap；

<resultMap id="AdminRoleResult" type="com.macro.mall.tiny.domain.AdminRoleDto"
           extends="com.macro.mall.tiny.mbg.mapper.UmsAdminMapper.UmsAdminResult">
    <collection property="roleList" resultMap="com.macro.mall.tiny.mbg.mapper.UmsRoleMapper.UmsRoleResult" columnPrefix="role_">
    </collection>
</resultMap>

• 然后在Service實(shí)現(xiàn)類中調(diào)用即可，為了方便結(jié)果集映射給查詢列取了別名。

/**
 * 后臺(tái)用戶管理Service實(shí)現(xiàn)類
 * Created by macro on 2020/12/8.
 */
@Service
public class UmsAdminServiceImpl implements UmsAdminService {   
    @Override
    public AdminRoleDto selectWithRoleList(Long id) {
        List<BasicColumn> columnList = new ArrayList<>(CollUtil.toList(UmsAdminMapper.selectList));
        columnList.add(UmsRoleDynamicSqlSupport.id.as("role_id"));
        columnList.add(UmsRoleDynamicSqlSupport.name.as("role_name"));
        columnList.add(UmsRoleDynamicSqlSupport.description.as("role_description"));
        columnList.add(UmsRoleDynamicSqlSupport.createTime.as("role_create_time"));
        columnList.add(UmsRoleDynamicSqlSupport.status.as("role_status"));
        columnList.add(UmsRoleDynamicSqlSupport.sort.as("role_sort"));
        SelectStatementProvider selectStatement = SqlBuilder.select(columnList)
                .from(UmsAdminDynamicSqlSupport.umsAdmin)
                .leftJoin(UmsAdminRoleRelationDynamicSqlSupport.umsAdminRoleRelation)
                .on(UmsAdminDynamicSqlSupport.id, equalTo(UmsAdminRoleRelationDynamicSqlSupport.adminId))
                .leftJoin(UmsRoleDynamicSqlSupport.umsRole)
                .on(UmsAdminRoleRelationDynamicSqlSupport.roleId, equalTo(UmsRoleDynamicSqlSupport.id))
                .where(UmsAdminDynamicSqlSupport.id, isEqualTo(id))
                .build()
                .render(RenderingStrategies.MYBATIS3);
        return adminDao.selectWithRoleList(selectStatement);
    }
}

總結(jié)

當(dāng)我們使用MyBatis官方代碼生成器MBG時(shí)，配置的targetRuntime決定了使用它的使用方式。Dynamic SQL更傾向于使用Java API來(lái)實(shí)現(xiàn)SQL操作，傳統(tǒng)的方式更傾向于在mapper.xml中手寫SQL來(lái)實(shí)現(xiàn)SQL操作。雖然MyBatis官方推薦使用Dynamic SQL，但選擇那種方式全看個(gè)人習(xí)慣了！

參考資料

官方文檔：https://mybatis.org/mybatis-dynamic-sql/docs/introduction.html