关于java:更便捷的Mybatis插件EasyMybatis

easy-mybatis是一个对 Mybatis 的加强框架（插件）。在 Spring 集成 Mybatis 的根底上，将我的项目开发中对数据库的罕用操作统一化。应用本框架能够很便捷的对数据库进行操作，进步开发效率，缩小机械行为。

我的项目主页：https://mybatis.zuoyu.top

API 文档地址：https://mybatis.zuoyu.top/doc…

GitHub 地址：https://github.com/zuoyuip/ea…

Gitee 地址：https://gitee.com/zuoyuip/eas…

Maven 依赖引入


<!-- https://mvnrepository.com/artifact/top.zuoyu.mybatis/easy-mybatis-spring-boot-starter -->
<dependency>
    <groupId>top.zuoyu.mybatis</groupId>
    <artifactId>easy-mybatis-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

Gradle 依赖引入


// https://mvnrepository.com/artifact/top.zuoyu.mybatis/easy-mybatis-spring-boot-starter
implementation 'top.zuoyu.mybatis:easy-mybatis-spring-boot-starter:1.0.0'

这个框架的初衷是，缩小 Java 程序员千篇一律的数据库操作。

对于开发人员来说：

精力应该破费在业务逻辑上，而非机械式的“技术”上。
我的项目中缩小无关痛痒的代码，从形象的角度看实现。
各司其职，各劳其力，谋求我的项目角度的服务流水线。

现在已很难看到单体架构的我的项目（感兴趣的能够查看我对架构演变的形容《浅谈微服务》），目前的我的项目大都是通过 RESTful、MQ、Socket 的形式（协定）进行数据传输。

这让我开始质疑传统 JavaWeb 我的项目中的数据库操作模式——即 Model(DTO) 存在的意义。实践上，数据库设计是不可能齐全遵循视图模型的，这就导致“正确”的做法是在我的项目中引入 VO，由多个DTO 来组装。

那么，为什么不能用灵便的 Map 来代替呢？

对一个 Map 的办法进行拓展，减少其对 Json 的解析能力，那么是不是就能够解脱 POJO 的各种麻烦组装。

我在思考如何设计这个框架的时候，被须要思考的方方面面给阻挡住了。

因为一个数据库框架须要思考的货色切实太多了，比方：

事务机制
类型转换
会话治理

···

思来想去，发现自己方向跑偏了，我只是心愿 对立数据库操作的接口 + 解脱 Model，没必要从新高山起墙，齐全能够在一个现有的框架根底上进行封装。

那么，对这个现有框架的抉择就尤为重要了。

目前 Java 中支流的数据库操作框架：

Spring JDBC
Spring Data JPA
Mybatis
Hibernate

抉择现有框架有一个准则——“对立数据库操作的接口 + 解脱 Model”是对该框架的增强，而非变异；不能因为“对立数据库操作的接口 + 解脱 Model”而无奈应用原框架的局部性能。

“解脱 Model”这个特点，首先就要排除重度 ORM 框架，也就是反对 JPA 操作的数据库——Spring Data JPA、Hibernate；起因很简略，这两个框架的弱小之处恰好就在它齐全面向 Model 操作。

剩下的就只有两个框架了，Spring JDBC和 Mybatis。其中，Spring JDBC 留给了开发人员大量的可操作空间，更加自在，但恰好是这种自在使得它更加繁琐。而 Mybatis 是一个轻量 ORM 框架，精确来说 Mybatis 不能称为 ORM 框架，因为它并不是面向 Model 操作数据库，仅仅是将数据库字段与 Model 字段相互赋值，并没有做到 ORM 定义的关系映射。

由以上各框架的特点，联合国内 Java 语言中数据库操作框架的热度，毫无疑问的抉择了Mybatis。

思考到 SpringBoot 对Mybatis优良的反对级别，我决定基于 mybatis-spring-boot-starter 开发这款框架，筹备来说应该称其为“插件”。

更便捷

摒弃传统 mybatis 的model、xml、dao数据库操作模式，避繁就简，疾速开发。

更高效

采纳预编译SQL，回绝运行期间反射生成SQL，性能更高效。

无侵入

只是对 Mybatis-Spring 的加强插件，对已有工程不做任何批改，仍可应用原生框架的性能，仅仅是简化了开发阶段对数据库的操作。

对立操作接口

对数据库的所有操作共用一个接口，升高应用门槛，轻松操作数据库。

对立操作对象

应用 JsonObject 为数据对象，提供一系列操作方法，不便从长久化对象组装为视图对象。

易上手

整个框架只提供了一个接口、一个注解、两个对象，仅仅一行配置便可实现对数据库进行罕用操作。

在 mybatis-spring-boot 环境下，应用该框架（插件），能够缩小传统 Mybatis 应用中对 model、xml、dao 的机械式开发。
所有的数据库操作均应用 MapperRepository 接口，通过注解 @Magic("xxx") 标记接口的数据表归属，即可间接应用。
该框架（插件）不障碍同时应用传统 Mybatis 中model、xml、dao的数据库开发方式。

装置 mybatis-spring-boot 环境

mybatis-spring-boot 的 Maven 依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>${spring-boot.version}</version>
        <relativePath/>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis-spring-boot.version}</version>
        </dependency>
    </dependencies>

mybatis-spring-boot 的 Gradle 依赖

    plugins {id 'org.springframework.boot' version '${springBootVersion}'
    id 'io.spring.dependency-management' version '${springManagementVersion}'
    id 'java'
    }

    dependencies {implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:${mybatisSpringVersion}'
    }

装置本框架（插件）

Maven 依赖引入


<!-- https://mvnrepository.com/artifact/top.zuoyu.mybatis/easy-mybatis-spring-boot-starter -->
<dependency>
    <groupId>top.zuoyu.mybatis</groupId>
    <artifactId>easy-mybatis-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

Gradle 依赖引入


// https://mvnrepository.com/artifact/top.zuoyu.mybatis/easy-mybatis-spring-boot-starter
implementation 'top.zuoyu.mybatis:easy-mybatis-spring-boot-starter:1.0.0'

这里以 MySQL 数据库为例，Oracle数据库配置请参考 配置阐明

配置 spring-boot-jdbc 数据库


spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://172.0.0.1:3306/xxxx
    username: xxxx
    password: xxxx

对于 springBoot 的配置，这里不多赘述，更多移步 springBoot 官网。

配置 easy-mybatis 反对的表名（例子）


easy-mybatis:
  table-names: teacher, student

这里的 table-names 配置，示意须要 easy-mybatis 框架反对的数据表名，多个表名应用逗号隔开。

即可应用 easy-mybatis 框架操作 teacher 和student两个数据表，如果须要反对其余数据表，须要在此配置。


@SpringBootTest
class DemoApplicationTests {

    // 示意该接口用来操作名称为 'teacher' 的数据表
    @Magic("teacher")
    private MapperRepository teacherRepository;

    // 示意该接口用来操作名称为 'student' 的数据表
    @Magic("student")
    private MapperRepository studentRepository;


    // 查问 teacher 表下所有数据
    @Test
    void teacherTest() {teachertRepository.selectList().forEach(System.out::println);
    }

    // 查问 student 表下合乎特定条件的数据
    @Test
    void studentTest() {
        studentRepository.selectListByExample(new JsonObject().put("birthday", "2009/12/12 12:12:12")
          ).forEach(System.out::println);
    }

}

应用 MapperRepository 接口对数据库进行操作，须要应用 @Magic("表名称") 标记该接口的数据表归属。

在本例中，@Magic("teacher")示意该 MapperRepository 为"teacher"数据表的操作接口，能够通过 teacherRepository 调用一系列办法实现对 "teacher" 数据表的操作。

该框架（插件）的全副相干配置


#easy-mybatis 的相干配置
easy-mybatis:
  #示意须要载入的数据库表
  table-names: SYS_USER, SYS_DEPT
  #默认的日期字符串格局
  data-format: yyyy-MM-dd HH:mm:ss
  #当数据库为 Oracle 时，数据表对应的主键 SEQ 名称
  sequences:
    SYS_USER: SEQ_SYS_USER,
    SYS_DEPT: SEQ_SYS_DEPT
  #当数据库为 Oracle 时，数据表的日期类型字段格局
  oracle-date-format: yyyy-mm-dd hh24:mi:ss

table-names

此配置示意须要载入的数据表，多个表名由逗号隔开，只有在此处配置了的数据表，能力在我的项目中应用 @Magic("表名称") 标记 MapperRepository 接口的数据表归属。

data-format

此配置示意在 JsonObject 中的日期存在格局，JsonObject中对日期的存储类型为 String 类型，可通过此配置自定义存储格局，默认格局为yyyy-MM-dd HH:mm:ss。

留神
当data-format的格局批改，请务必将 oracle-date-format 的格局与之匹配。

sequences

此配置示意当数据库为 Oracle 时，每个数据表的主键生成器名称，以键值对的格局进行参数配置。若此处没有对数据表的主键生成器进行配置，那么在做该数据表的数据插入行为时需自定义填充主键数值。

oracle-date-format

此配置示意当数据库为 Oracle 时，传入日期格局字段时的参数格局，即TO_DATE(field, '$dateFormat')。

留神
当oracle-date-format的格局批改，请务必将 data-format 的格局与之匹配。

本框架（插件）的数据库操作惟一接口——top.zuoyu.mybatis.service.MapperRepository。

以 ByExample 为结尾的办法

此类是依据 JsonObject 类型的参数 example 中键值对，对符合要求的数据进行操作，例如：


    // 构建 example，这里指字段 "birthday" 为 "2009/12/12 12:12:12"
    JsonObject example = new JsonObject().put("birthday", "2009/12/12 12:12:12");
    // 查问所有字段 "birthday" 为 "2009/12/12 12:12:12" 的学生数据
    List<JsonObject> studentList = studentRepository.selectListByExample(example);

这里的 selectListByExample 办法就是依据参数 example 中键值对查找符合要求的数据。
同理，countByExample办法就是获取合乎参数 example 中键值对的数据总量 …

以 By 为结尾的办法

此类是依据 String 类型的参数 suffixSql 对办法追加参数中 SQL 语句的内容，例如：


    // 查找 "is_delete" 字段为 0 的数据，并以年龄进行排序
    List<JsonObject> teachers = teacherRepository.selectListBy("WHERE is_delete = 0 ORDER BY age");

    // 将 "birthday" 字段大于 "1990/1/1 00:00:00" 的数据，"salary" 字段改为 20000。（也就是出生日期在 1990 年之前的老师，工资改为 2W）JsonObject example = new JsonObject().put("salary", 20000);
    int count = teacherRepository.updateBy(example, "WHERE birthday <'1990/1/1 00:00:00'");

这里的 selectListBy 办法就是查找出合乎参数中 SQL 语句要求的内容，updateBy办法就是将合乎参数中 SQL 语句要求的数据批改为 example 定义的数值。

同理，countBy办法就是获取合乎参数中 SQL 语句要求的数据总量 …

insert、insertBatch办法

当数据库为 MySQL 时，如果数据表主键自增，则无需定义主键数值；若主键为非自增，则需定义主键数值。

当数据库为 Oracle 时，如果在配置中定义了数据表的主键生成器，则无需定义主键数值；反之，则需定义主键数值。

MapperRepository提供了丰盛的办法，以不便对数据库的 CURD 操作，更多对于 MapperRepository 的应用阐明请移步MapperRepository 阐明、MapperRepository 的 API 文档。

数据库接口的操作对象次要为 JsonObject 类型和 JsonArray 类型。

其中 top.zuoyu.mybatis.json.JsonObject 为键值对容器，以键值的模式装载，数据结构为：


{
    'field1' : 'value1',
    'field2' : 'value2',
    'field3' : 'value3',
    ...
}

键的类型为 java.lang.String 类型，值的类型能够为任何类型。

JsonObject提供了丰盛的办法，以不便操作键值对和类型转换，更多对于 JsonObject 的应用阐明请移步JsonObject 阐明、JsonObject 的 API 文档。

其中 top.zuoyu.mybatis.json.JsonArray 为数组容器，以多个单位的模式装载，数据结构为：


[
    object1,
    object2,
    object3,
    ...
]

每个单位能够为任何类型，且各单位类型容许与其余单位类型不同。

JsonArray提供了丰盛的办法，以不便操作键值对和类型转换，更多对于 JsonArray 的应用阐明请移步JsonArray 阐明、JsonArray 的 API 文档。

具体方法可参考API 文档。

查问所有`selectList`

    /**
     * 查问所有
     *
     * @return 所有数据
     */
    List<JsonObject> selectList();

查问合乎样例的数据`selectListByExample`

    /**
     * 依据已有键值查问
     *
     * @param example - 已有键值
     * @return 符合要求的数据汇合
     */
    List<JsonObject> selectListByExample(JsonObject example);

依据主键查问惟一对象`selectByPrimaryKey`

    /**
     * 依据主键查问惟一对象
     *
     * @param primaryKey - 主键
     * @return 惟一对象
     */
    JsonObject selectByPrimaryKey(Serializable primaryKey);

查问符合条件的数据`selectListBy`

    /**
     * 查问符合条件的数据
     *
     * @param suffixSql - 条件语句（例如：where field = xxx）* @return 数据数量
     */
    List<JsonObject> selectListBy(String suffixSql);

查问特定的字段或后果`selectFields`

    /**
     * 查问特定的字段或后果
     *（例如："fieldA, fieldB, fieldC"）*（例如："COUNT(field)"）*
     * @param fields - 特定的字段或后果
     * @return 特定的字段或后果
     */
    JsonArray selectFields(String fields);

依据样例查问特定的字段或后果`selectFieldsByExample`

    /**
     * 依据已有键值查问特定的字段或后果
     *（例如："fieldA, fieldB, fieldC"）*（例如："COUNT(field)"）*
     * @param fields  - 特定的字段或后果
     * @param example - 已有键值
     * @return 特定的字段或后果
     */
    JsonArray selectFieldsByExample(String fields, JsonObject example);

依据主键查问特定的字段或后果`selectFieldsByPrimaryKey`

    /**
     * 依据主键查问特定的字段或后果
     *
     * @param fields     - 特定的字段或后果（例如："fieldA, fieldB, fieldC"）* @param primaryKey - 主键
     * @return 特定的字段或后果
     */
    JsonArray selectFieldsByPrimaryKey(String fields, Serializable primaryKey);

依据主键汇合查问特定的字段或后果`selectFieldsByPrimaryKeys`

    /**
     * 依据主键汇合查问特定的字段或后果
     *
     * @param fields      - 特定的字段或后果（例如："fieldA, fieldB, fieldC"）* @param primaryKeys - 主键汇合
     * @return 特定的字段或后果
     */
    JsonArray selectFieldsByPrimaryKeys(String fields, Serializable[] primaryKeys);

查问符合条件的数据`selectFieldsBy`

    /**
     * 查问符合条件的数据
     *
     * @param fields    - 特定的字段或后果（例如："fieldA, fieldB, fieldC"）* @param suffixSql - 条件语句（例如：where field = xxx）* @return 特定的字段或后果
     */
    JsonArray selectFieldsBy(String fields, String suffixSql);

查问符合条件的数据数量`countBy`

    /**
     * 查问符合条件的数据数量
     *
     * @param suffixSql - 条件语句（例如：where field = xxx）* @return 数据数量
     */
    long countBy(String suffixSql);

查问是否存在合乎样例的数据数量`countByExample`

    /**
     * 依据已有键值查问是否存在符合条件的数据数量
     *
     * @param example - 已有键值
     * @return 数据数量
     */
    long countByExample(JsonObject example);

是否存在符合条件的数据`existsBy`

    /**
     * 是否存在符合条件的数据
     *
     * @param suffixSql - 条件语句（例如：where field = xxx）* @return 是否存在
     */
    boolean existsBy(String suffixSql);

是否存在合乎样例的数据`existsByExample`

    /**
     * 依据已有键值查问是否存在符合条件的数据
     *
     * @param example - 已有键值
     * @return 是否存在
     */
    boolean existsByExample(JsonObject example);

新增对象`insert`

    /**
     * 新增对象
     *
     * @param jsonObject - 对象键值
     * @return 变动数据的数量
     */
    int insert(JsonObject jsonObject);

批量新增对象`insertBatch`

    /**
     * 批量新增对象
     *
     * @param jsonObjects - 对象键值汇合
     * @return 变动数据的数量
     */
    int insertBatch(List<JsonObject> jsonObjects);

依据主键批改对象属性`updateByPrimaryKey`

    /**
     * 依据主键批改对象属性
     *
     * @param jsonObject - 蕴含主键对象键值
     * @return 变动数据的数量
     */
    int updateByPrimaryKey(JsonObject jsonObject);

批改特定条件的对象属性`updateBy`

    /**
     * 批改特定条件的对象属性
     *
     * @param jsonObject - 要批改的键值
     * @param suffixSql  - 条件语句（例如：where field = xxx）* @return 变动数据的数量
     */
    int updateBy(JsonObject jsonObject, String suffixSql);

批量依据主键批改对象属性`updateByPrimaryKeyBatch`

    /**
     * 批量依据主键批改对象属性
     *
     * @param jsonObjects - 对象键值汇合
     * @return 变动数据的数量
     */
    int updateByPrimaryKeyBatch(List<JsonObject> jsonObjects);

依据主键删除对象`deleteByPrimaryKey`

    /**
     * 依据主键删除对象
     *
     * @param primaryKey - 主键
     * @return 变动数据的数量
     */
    int deleteByPrimaryKey(Serializable primaryKey);

删除符合条件的数据`deleteBy`

    /**
     * 删除符合条件的数据
     *
     * @param suffixSql - 条件语句（例如：where field = xxx）* @return 变动数据的数量
     */
    int deleteBy(String suffixSql);

批量依据主键删除对象`deleteByPrimaryKeys`

    /**
     * 批量依据主键删除对象
     *
     * @param primaryKeys - 主键组
     * @return 变动数据的数量
     */
    int deleteByPrimaryKeys(Serializable[] primaryKeys);

依据样例删除对象`deleteByExample`

    /**
     * 依据已有键值删除对象
     *
     * @param example - 已有键值
     * @return 变动数据的数量
     */
    int deleteByExample(JsonObject example);

top.zuoyu.mybatis.json.JsonObject为键值对容器，以键值的模式装载，数据结构为：

{
    'field1' : 'value1',
    'field2' : 'value2',
    'field3' : 'value3',
    ...
}

键的类型为 java.lang.String 类型，值的类型能够为任何类型。

外部默认已蕴含惯例的类型转换，默认反对以下类型：

java.math.BigInteger
java.math.BigDecimal
java.lang.Boolean
java.lang.Byte
java.lang.Character
java.util.Date
java.lang.Double
java.lang.Float
java.lang.Integer
java.lang.Long
java.lang.Short
java.lang.String

如果默认的转换器无奈满足需要，或者须要转换为其余类型，可通过自定义转换器 ConvertClass<T> 进行实现，接口办法：

public interface ConvertClass<T> {

    /**
     * 将给定的 value 对象转换为 T 类型
     *
     * @param value - 给定对象
     * @return 指标转换类型的对象
     */
    T convert(Object value);

    /**
     * 将给定的 value 对象转换为 T 类型，否则返回  defaultValue
     *
     * @param value        - 给定对象
     * @param defaultValue - 默认值
     * @return 指标转换类型的对象
     */
    T convert(Object value, T defaultValue);
}

    @Test
    void convertTest() {
        // 应用 JSON 字符串初始化对象
        JsonObject student = new JsonObject(studentJSON);

        // 获取学生的性别，如果无奈转换则返回 "未知"
        String sex = student.getValue("sex", new SexConvert());

        // 获取学生的性别，如果无奈转换则返回 "未录入"
        String sexOrDefault = student.getValue("sex", new SexConvert(), "未录入");
    }

    static class SexConvert implements ConvertClass<String> {

        @Override
        public String convert(Object value) {if (value instanceof Integer) {if ((Integer) value == 1) {return "男";} else if ((Integer)value == 0) {return "女";}
            }
            return "未知";
        }

        @Override
        public String convert(Object value, String defaultValue) {if (value instanceof Integer) {if ((Integer) value == 1) {return "男";} else if ((Integer)value == 0) {return "女";}
            }
            return defaultValue;
        }
    }

本示例也可应用 StringConvert 转换器，StringConvert为 ConvertClass<T> 的子接口。

也能够通过 toClass 办法，将 JsonObject 对象转换为指定类型的实体类。

BigDecimalConvert
BigIntegerConvert
BooleanConvert
ByteConvert
CharacterConvert
DateConvert
DoubleConvert
FloatConvert
IntegerConvert
LongConvert
ShortConvert
StringConvert

更多办法请移步JsonObject 的 API 文档。

top.zuoyu.mybatis.json.JsonArray为数组容器，以多个单位的模式装载，数据结构为：


[
    object1,
    object2,
    object3,
    ...
]

每个单位能够为任何类型，且各单位类型容许与其余单位类型不同。

具体应用办法与 JsonObject 在类型转换操作统一，参考JsonObject 的类型转换操作

更多办法请移步JsonArray 的 API 文档。

我的项目主页：https://mybatis.zuoyu.top

API 文档地址：https://mybatis.zuoyu.top/doc…

GitHub 地址：https://github.com/zuoyuip/ea…

Gitee 地址：https://gitee.com/zuoyuip/eas…

框架初衷

服务拆散的时代

思考框架设计

现有框架的抉择

抉择

框架个性

安利

疾速上手

装置

配置

操作数据库（例子）

配置阐明

具体阐明

操作接口约定

操作对象约定

MapperRepository 阐明

查问所有selectList

查问合乎样例的数据selectListByExample

依据主键查问惟一对象selectByPrimaryKey

查问符合条件的数据selectListBy

查问特定的字段或后果selectFields

依据样例查问特定的字段或后果selectFieldsByExample

依据主键查问特定的字段或后果selectFieldsByPrimaryKey

依据主键汇合查问特定的字段或后果selectFieldsByPrimaryKeys

查问符合条件的数据selectFieldsBy

查问符合条件的数据数量countBy

查问是否存在合乎样例的数据数量countByExample

是否存在符合条件的数据existsBy

是否存在合乎样例的数据existsByExample

新增对象insert

批量新增对象insertBatch

依据主键批改对象属性updateByPrimaryKey

批改特定条件的对象属性updateBy

批量依据主键批改对象属性updateByPrimaryKeyBatch

依据主键删除对象deleteByPrimaryKey

删除符合条件的数据deleteBy

批量依据主键删除对象deleteByPrimaryKeys

依据样例删除对象deleteByExample

JsonObject 阐明

类型转换

示例

子接口：

JsonArray 阐明