乐趣区

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

作者：

jiezi

在

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的各种麻烦组装。

思考框架设计

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

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

  1. 事务机制
  2. 类型转换

  3. 会话治理

    ···

思来想去，发现自己方向跑偏了，我只是心愿对立数据库操作的接口 + 解脱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数据库配置请参考配置阐明

  1. 配置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官网。

  1. 配置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

具体阐明

  1. table-names

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

  1. data-format

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

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

  1. sequences

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

  1. oracle-date-format

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

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

操作接口约定

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

  1. 以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中键值对的数据总量…

  1. 以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语句要求的数据总量…

  1. insert、insertBatch办法

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

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

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

操作对象约定

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

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

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

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

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

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

[
    object1,
    object2,
    object3,
    ...
]

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

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

具体方法可参考API文档。

MapperRepository阐明

查问所有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);

JsonObject阐明

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文档。

JsonArray阐明

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…

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章