说明：MyBatis-Flex 是一个优雅的 MyBatis 增强框架，它非常轻量、同时拥有极高的性能与灵活性。我们可以轻松的使用 Mybaits-Flex 链接任何数据库，其内置的 QueryWrapper^亮点 帮助我们极大的减少了 SQL 编写的工作的同时，减少出错的可能性。（官方语）

Mybatis-Flex是数据访问层框架，本文介绍Mybatis-Flex的使用，及一些扩展功能。

一、使用

Spring Boot整合Mybatis-Flex参考下面这篇文章：

• Spring Boot整合MyBatis-Flex

这篇文章使用的是Postgresql数据库，如果是MySQL（8.X版本），pom.xml文件如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
        <relativePath/>
    </parent>

    <groupId>com.hezy</groupId>
    <artifactId>mybatis-flex-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>

        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>com.mybatis-flex</groupId>
            <artifactId>mybatis-flex-spring-boot-starter</artifactId>
            <version>1.9.3</version>
        </dependency>
        <dependency>
            <groupId>com.mybatis-flex</groupId>
            <artifactId>mybatis-flex-processor</artifactId>
            <version>1.9.3</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

同时，application.yml文件修改如下：

server:
  port: 8080

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456

二、API

（1）添加数据

    @Test
    public void insertUserTest() {
        // 1.通过实体类添加
        User user1 = new User();
        user1.setId(8);
        user1.setUsername("hezy");
        user1.setPassword("123456");
        userMapper.insert(user1);

        // 2.部分字段添加，可设置是否忽略。如下，没有设置的字段为null，如果数据库有设置默认值，默认值会生效
        User user2 = new User();
        user2.setUsername("hezy3");
        userMapper.insertSelective(user2);

        // 3.通过实体类添加，忽略掉未设置的，为null的属性，如果这些字段数据库有设置默认值，则默认值会生效
        User user3 = new User();
        user3.setId(3);
        user3.setUsername("wangwu");
        userMapper.insert(user3, true);

        // 4.批量插入实体类数据
        User user4 = new User();
        user4.setId(4);
        user4.setUsername("lisi");
        User user5 = new User();
        user5.setId(5);
        user5.setUsername("zhaoliu");
        user5.setPassword("123456");

        ArrayList<User> userList = new ArrayList<>();
        userList.add(user4);
        userList.add(user5);
        userMapper.insertBatch(userList);

        // 5.插入或者更新，主键有值则更新，没有值则插入，不忽略null
        // 如下，数据库有记录：1-zhangsan-dsaf，修改后为：1-zhangsan_fix-null
        User user6 = new User();
        user6.setId(1);
        user6.setUsername("zhangsan_fix");
        userMapper.insertOrUpdate(user6);

        // 6.插入或者更新，主键有值则更新，没值则插入，忽略null
        // 如下，数据库有记录：1-zhangsan-dsaf，修改后为：1-zhangsan_fix-dsaf
        User user7 = new User();
        user7.setId(1);
        user7.setUsername("zhangsan_fix");
        userMapper.insertOrUpdateSelective(user7);

        // 7.插入或者更新，主键有值则更新，没有值则新增，可设置是否忽略
        User user8 = new User();
        user8.setId(1);
        user8.setUsername("zhangsan");
        userMapper.insertOrUpdate(user8, false);

        // 8.UpdateWrapper新增数据，可以用MySQL的函数，如UUID()，生成随机字符串
        User user9 = new User();
        user9.setUsername("zhangsan");
        User newUser = UpdateWrapper.of(user9).setRaw(User::getPassword, "UUID()").toEntity();
        userMapper.insert(newUser);
    }

可设置是否忽略确实不错，另外还可以选择插入或者更新，这在一些插入后冲突的场景里可以用到，框架开发者想得很周到。

（2）删除数据

    @Test
    public void deleteUserTest() {
        // 1.根据主键删除，多个主键的需要传入数组，如100、101
        userMapper.deleteById(1);
        userMapper.deleteById(new Integer[]{100, 101});

        // 2.根据实体类删除，这里是考虑到复合主键的情况
        User user1 = new User();
        user1.setId(1);
        user1.setUsername("zhangsan");
        userMapper.delete(user1);

        // 3.根据主键批量删除数据
        ArrayList<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(3);
        userMapper.deleteBatchByIds(list);

        // 4.根据Map构建的条件删除数据，删除username为zhangsan的记录
        HashMap<String, Object> conditionMap = new HashMap<>();
        conditionMap.put("username", "zhangsan");
        userMapper.deleteByMap(conditionMap);

        // 5.根据查询条件删除数据，删除username为lisi的记录
        QueryWrapper queryWrapper = QueryWrapper.create();
        queryWrapper.where("username = 'lisi'");
        userMapper.deleteByQuery(queryWrapper);
    }

（3）修改数据

    @Test
    public void updateUserTest() {
        // 1.根据实体类更新，需要设置主键
        User user1 = new User();
        user1.setId(1);
        user1.setUsername("lisi");
        user1.setPassword("456");
        userMapper.update(user1);

        // 2.根据实体类更新，可设置是否忽略未设置的字段
        User user2 = new User();
        user2.setId(1);
        user2.setUsername("lisi");
        userMapper.update(user2, true);

        // 3.根据Map构建的条件来更新，修改lisi的password为abcdef
        HashMap<String, Object> conditionMap1 = new HashMap<>();
        conditionMap1.put("username", "lisi");

        User user3 = new User();
        user3.setPassword("abcdef");
        userMapper.updateByMap(user3, conditionMap1);

        // 4.根据Map构建的条件来更新，可设置是否忽略未设置的字段
        // 修改lisi的password为abcdef，username未设置为null，或者数据库有默认值为默认值
        HashMap<String, Object> conditionMap2 = new HashMap<>();
        conditionMap2.put("username", "lisi");

        User user4 = new User();
        user4.setPassword("abcdef");
        userMapper.updateByMap(user4, false, conditionMap2);

        // 5.根据查询条件来更新数据
        // 修改username=lisi的password为123456
        QueryWrapper queryWrapper1 = QueryWrapper.create();
        queryWrapper1.where("username = 'lisi'");
        User user5 = new User();
        user5.setPassword("123456");
        userMapper.updateByQuery(user5, queryWrapper1);

        // 6.根据查询条件来更新数据，可设置是否忽略默认值
        // 修改username=lisi的password为123456，username未设置为null，或者数据库有默认值为默认值
        QueryWrapper queryWrapper2 = QueryWrapper.create();
        queryWrapper2.where("username = 'lisi'");
        User user6 = new User();
        user6.setPassword("123456");
        userMapper.updateByQuery(user6, false, queryWrapper2);
    }

（4）查询数据

    @Test
    public void selectUserTest() {
        // 1.根据主键查询数据
        User user1 = userMapper.selectOneById(1);
        System.out.println(user1);

        // 2.根据实体类查询数据，考虑到复合主键的情况
        User user = new User();
        user.setId(1);
        User user2 = userMapper.selectOneByEntityId(user);
        System.out.println(user2);

        // 3.根据Map构建的条件查询数据
        HashMap<String, Object> conditionMap1 = new HashMap<>();
        conditionMap1.put("username", "zhangsan");
        User user3 = userMapper.selectOneByMap(conditionMap1);
        System.out.println(user3);

        // 4.根据查询条件查询数据
        QueryWrapper queryWrapper = QueryWrapper.create();
        queryWrapper.where("username = 'zhangsan'");
        User user4 = userMapper.selectOneByQuery(queryWrapper);
        System.out.println(user4);

        // 5.根据多个主键查询多条数据
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        List<User> users1 = userMapper.selectListByIds(list);
        System.out.println(users1);

        // 6.根据Map构建的条件，查询多条数据
        HashMap<String, Object> conditionMap2 = new HashMap<>();
        conditionMap2.put("username", "zhangsan");
        List<User> users2 = userMapper.selectListByMap(conditionMap2);
        System.out.println(users2);

        // 7.根据查询条件，查询多条数据
        QueryWrapper queryWrapper2 = QueryWrapper.create();
        queryWrapper2.where("username = 'zhangsan'");
        List<User> users3 = userMapper.selectListByQuery(queryWrapper2);
        System.out.println(users3);

        // 8.分页查询，传入一个空的QueryWrapper表示全查分页
        QueryWrapper queryWrapper3 = QueryWrapper.create();
        Page<User> paginate = userMapper.paginate(2, 2, queryWrapper3);
        System.out.println(paginate.getRecords());

        // 9.根据查询条件分页查询，分页查询username=zhangsan的记录
        QueryWrapper queryWrapper4 = QueryWrapper.create();
        queryWrapper4.where("username = 'zhangsan'");
        Page<User> paginate2 = userMapper.paginate(2, 2, queryWrapper4);
        System.out.println(paginate2.getRecords());
    }

查询数据，不管是哪一款DAO框架都是重点，Mybatis-Flex除了上面我介绍的API，还提供了游标查询、Relations注解查询、多表查询（关联查询）

三、扩展功能

（1）核心注解

“核心注解”是我自己的说法，表示@Table、@Id、@Column，三个打在实体里面的注解，在Mybatis-Flex帮助文档里的核心功能里面。下面介绍这三个注解的用法。

---

@Table注解，打在实体类上面，必填属性为该实体类对应的数据库表名，还有其他属性，如下：

• schema()：数据库的schema（模式）；

• camelToUnderLine()：默认为 驼峰属性 转为 下划线字段；

• dataSource()：默认使用哪个数据源，找不到默认使用第一个（思考，读写分离是否能用得上？）

• …

（官方文档）

---

@Id注解，打在实体类对应数据库主键的属性上，可设置主键生成策略，有以下四种；

• Auto：自增的方式；

• Sequence：通过执行数据库 sql 生成；

• Generator：通过 IKeyGenerator生成器生成；

• None：其他方式，或业务层手动生成，或使用数据库自增（默认）；

---

@Column注解，打在实体类的属性上，有几个值得注意的属性；

• value()：字段名，表示实体类属性名与数据库字段名的映射，在属性名与数据库关键字冲突时用得上；

• ignore()：是否忽略字段，表示该属性只是业务字段，而非数据库字段，也就是说这个属性在数据库没有对应的字段；

• isLogicDelete()：是否为逻辑删除的字段，只能打在一个属性上；

• …

（2）逻辑删除

逻辑删除，是在数据库表里面用一个字段表示该条记录的删除状态，通常是boolean类型。当删除记录时，不会真的把这条记录删掉，而是将这个字段置为“已删除”，后续查询需加上该字段的“未删除”条件，对于业务来说就等同于删除掉了。

在Mybatis-Flex里实现，只需要在对应实体类的属性上加上逻辑删除注解即可。如下，deleted为逻辑删除字段；

@Data
@Table("i_users")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    private Integer id;

    @Column
    private String username;

    private String password;

    @Column(isLogicDelete = true)
    private boolean deleted;
}

此时，调用删除方法，删除主键为1的记录

		userMapper.deleteById(1);

可以看到，实际上并没有删除，只是将此字段置为1；

后续查询，也不会查出来；

        // 8.分页查询，传入一个空的QueryWrapper表示全查分页
        QueryWrapper queryWrapper3 = QueryWrapper.create();
        Page<User> paginate = userMapper.paginate(1, 10, queryWrapper3);
        System.out.println(paginate.getRecords());

（3）SQL打印

一般框架，打印SQL，SQL语句和参数都是分开的，如Mybatis，如果要实现打印出一条在数据库中可以直接执行的SQL，还需要手写拦截器拼接SQL语句和参数（参考：MyBatis如何自定义项目中SQL日志）。

在Mybatis-Flex中，可以直接粘贴这个类到项目中，控制台就可以打印出完整的SQL语句，并且附带执行时长。如下：

import com.mybatisflex.core.audit.AuditManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBatisFlexConfiguration {

    private static final Logger logger = LoggerFactory
        .getLogger("mybatis-flex-sql");


    public MyBatisFlexConfiguration() {
        //开启审计功能
        AuditManager.setAuditEnable(true);

        //设置 SQL 审计收集器
        AuditManager.setMessageCollector(auditMessage ->
            logger.info("{},{}ms", auditMessage.getFullSql()
                , auditMessage.getElapsedTime())
        );
    }
}

控制台打印完整SQL，如下：

另外，我们观察到一点，所谓逻辑删除实际上也是通过拼接deleted = 0实现的，也就是说DAO框架实现也就是拼接SQL而已。

（4）数据填充

有些字段，我们想在数据新增、更新时，自动带上，不用我们手动set，可以在对应的属性上设置，如下：

import com.mybatisflex.annotation.Column;
import com.mybatisflex.annotation.Id;
import com.mybatisflex.annotation.KeyType;
import com.mybatisflex.annotation.Table;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;

@Data
@Table("i_users")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    private Integer id;

    @Column
    private String username;

    private String password;

    @Column(isLogicDelete = true)
    private boolean deleted;

    @Column(onInsertValue = "now()")
    private Date createDate;

    @Column(onUpdateValue = "now()")
    private Date updateDate;
}

其中，createDate字段会在添加数据时，自动填充，值为数据库的now()函数结果，updateDate()字段会在更新数据时，自动填充。

查看SQL日志，可以发现，也是通过拼接SQL实现的。

另外，除了上面简单的数据填充，还可以设置填充的字段值为数据库原来的字段值，或者为一个SQL查询结果，参考官方帮助文档。如下：

（5）数据脱敏

脱敏，就是加密，不脱敏，就是不加密。一般的数据脱敏，需要我们手动调用加密工具类的方法，将明文传入，获取密文。在Mybatis-Flex中提供了方便快捷的方法，如下：

import com.mybatisflex.annotation.*;
import com.mybatisflex.core.mask.Masks;
import lombok.Data;

import java.io.Serializable;
import java.util.Date;

@Data
@Table("i_users")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    private Integer id;

    @Column
    private String username;

    private String password;

    @ColumnMask(Masks.MOBILE)
    private String phone;

    @Column(isLogicDelete = true)
    private boolean deleted;

    @Column(onInsertValue = "now()")
    private Date createDate;

    @Column(onUpdateValue = "now()")
    private Date updateDate;
}

在需要脱敏的字段上，加上@ColumnMask(Masks.MOBILE)注解，里面填需要脱敏的类型，框架自带了以下九种类型，可直接使用。

设置完后，查询出来的数据，会自动根据对应的类型脱敏，如下，查到的手机号字段；

但如果要想查到非脱敏数据，可使用下面这种方式；

        List<User> userList = MaskManager.execWithoutMask(userMapper::selectAll);
        System.out.println(userList);

（6）数据源加密

配置文件里面的数据库配置，一般来说是明文显示的，为了安全性可以加密。这个功能一般的数据源框架都有，像dynamic-datasource，如果没有，也可以手动实现。

在Mybatis-Flex框架中，可以注册下面这个Bean，然后在里面实现对数据源配置的加密。如下，我没有做解密操作，只是将用户名的前四位，密码的前六位作为用户名、密码。这里完全可以用加解密的方式实现，写个main方法，把数据库配置加密成密文，然后填到配置文件里，然后这里就解密。

import com.mybatisflex.core.datasource.DataSourceDecipher;
import com.mybatisflex.core.datasource.DataSourceProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfiguration {
    
    @Bean
    public DataSourceDecipher decipher(){
        DataSourceDecipher decipher = (property, value) -> {
            // 解密用户名，通过编码支持任意加密方式的解密
            if (property == DataSourceProperty.USERNAME) {
                return value.substring(0, 4);
            }
            // 解密密码
            else if (property == DataSourceProperty.PASSWORD) {
                return value.substring(0, 6);
            }
            return value;
        };
        return decipher;
    }
}

测试下，配置文件除了前面的有效位数，后面的随便填，看能否正常访问数据库。

能正常访问数据库，说明上面这个Bean起到了作用。

（7）另外

除了上面介绍的几个功能，Mybatis-Flex还提供了多租户、读写分离、多数据源等功能，可参看官方文档学习。

总结

本文介绍了数据访问层框架MyBatis-Flex框架的使用，官方帮助文档参考：https://mybatis-flex.com/zh/core/datasource-encryption.html

另一款数据库访问层框架，Mybatis-Plus的使用，参考：MyBatis-Plus框架

文章所用的完整源码：https://github.com/HeZhongYing/mybatis_flex_demo