Mybatis增强型注解简化SQL语句

最新推荐文章于 2023-07-09 00:01:54 发布
最新推荐文章于 2023-07-09 00:01:54 发布
阅读量805 收藏 1
点赞数
分类专栏： MyBatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zlh313_01/article/details/80034073
版权

1. 背景

MyBatis提供了简单的Java注解，使得我们可以不配置XML格式的Mapper文件，也能方便的编写简单的数据库操作代码：

public interface UserMapper {
  @Select("SELECT * FROM users WHERE id = #{userId}")
  User getUser(@Param("userId") String userId);
}
  • 1
  • 2
  • 3
  • 4

但是注解对动态SQL的支持一直差强人意，即使MyBatis提供了InsertProvider等*Provider注解来支持注解的Dynamic SQL，也没有降低SQL的编写难度，甚至比XML格式的SQL语句更难编写和维护。 
注解的优势在于能清晰明了的看见接口所使用的SQL语句，抛弃了繁琐的XML编程方式。但没有良好的动态SQL支持，往往就会导致所编写的DAO层中的接口冗余，所编写的SQL语句很长，易读性差…… 
Mybatis在3.2版本之后，提供了LanguageDriver接口，我们可以使用该接口自定义SQL的解析方式。故在这里向大家介绍下以此来实现注解方式下的动态SQL。

2. 实现方案

我们先来看下LanguageDriver接口中的3个方法：

public interface LanguageDriver {
    ParameterHandler createParameterHandler(MappedStatement var1, Object var2, BoundSql var3);

    SqlSource createSqlSource(Configuration var1, XNode var2, Class<?> var3);

    SqlSource createSqlSource(Configuration var1, String var2, Class<?> var3);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  1. createParameterHandler方法为创建一个ParameterHandler对象，用于将实际参数赋值到JDBC语句中
  2. 将XML中读入的语句解析并返回一个sqlSource对象
  3. 将注解中读入的语句解析并返回一个sqlSource对象

一旦实现了LanguageDriver，我们即可指定该实现类作为SQL的解析器，在XML中我们可以使用 lang 属性来进行指定

<typeAliases>
  <typeAlias type="org.sample.MyLanguageDriver" alias="myLanguage"/>
</typeAliases>

<select id="selectBlog" lang="myLanguage">
  SELECT * FROM BLOG
</select>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

也可以通过设置指定解析器的方式：

<settings>
  <setting name="defaultScriptingLanguage" value="myLanguage"/>
</settings>
  • 1
  • 2
  • 3

如果不使用XML Mapper的形式，我们可以使用@Lang注解

public interface Mapper {
  @Lang(MyLanguageDriver.class) 
  @Select("SELECT * FROM users")
  List<User> selectUser();
}
  • 1
  • 2
  • 3
  • 4
  • 5

LanguageDriver的默认实现类为XMLLanguageDriver和RawLanguageDriver；分别为XML和Raw，Mybatis默认是XML语言，所以我们来看看XMLLanguageDriver中是怎么实现的：

public class XMLLanguageDriver implements LanguageDriver {
    public XMLLanguageDriver() {
    }

    public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
        return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
    }

    public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
        XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
        return builder.parseScriptNode();
    }

    public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) {
        if(script.startsWith("<script>")) {
            XPathParser textSqlNode1 = new XPathParser(script, false, configuration.getVariables(),
                                       new XMLMapperEntityResolver());
            return this.createSqlSource(configuration, textSqlNode1.evalNode("/script"), parameterType);
        } else {
            script = PropertyParser.parse(script, configuration.getVariables());
            TextSqlNode textSqlNode = new TextSqlNode(script);
            return (SqlSource)(textSqlNode.isDynamic()?new DynamicSqlSource(configuration, textSqlNode)
                   :new RawSqlSource(configuration, script, parameterType));
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

发现其实mybatis已经帮忙写好了解析逻辑，而且发现如果是以开头的字符串传入后，会被以XML的格式进行解析。那么方案就可以确认了，我们继承XMLLanguageDriver这个类，并且重写其createSqlSource方法，按照自己编写逻辑解析好sql后，再调用父类的方法即可。

3. 实现自定义注解

本段中给出一些常见的自定义注解的实现和使用方式。

3.1 自定义Select In注解

在使用Mybatis注解的时候，发现其对Select In格式的查询支持非常不友好，在字符串中输入十分繁琐，可以通过将自定义的标签转成格式；下面便通过我们自己实现的LanguageDriver来实现SQL的动态解析：

DAO接口层中代码如下：

@Select("SELECT * FROM users WHERE id IN (#{userIdList})")
@Lang(SimpleSelectInLangDriver.class)
List<User> selectUsersByUserId(List<Integer> userIdList);
  • 1
  • 2
  • 3

LanguageDriver实现类如下:

// 一次编写即可
public class SimpleSelectInLangDriver extends XMLLanguageDriver implements LanguageDriver {

    private static final Pattern inPattern = Pattern.compile("\\(#\\{(\\w+)\\}\\)");

    @Override
    public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) {

        Matcher matcher = inPattern.matcher(script);
        if (matcher.find()) {
            script = matcher.replaceAll("<foreach collection=\"$1\" item=\"_item\" open=\"(\" " +
                                        "separator=\",\" close=\")\" >#{_item}</foreach>");
        }


        script = "<script>" + script + "</script>";
        return super.createSqlSource(configuration, script, parameterType);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

通过自己实现LanguageDriver，在服务器启动的时候，就会将我们自定义的标签解析为动态SQL语句，其等同于：

@Select("SELECT * " +
        "FROM users " +
        "WHERE id IN " +
        "<foreach item='item' index='index' collection='list'open='(' separator=',' close=')'>" +
        "#{item}" +
        "</foreach>")
List<User> selectUsersByUserId(List<Integer> userIdList);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

通过实现LanguageDriver，剥离了冗长的动态SQL语句，简化了Select In的注解代码。

需要注意的是在使用Select In的时候，请务必在传入的参数前加@Param注解，否则会导致Mybatic找不到参数而抛出异常。

3.2 自定义Update Bean注解

在扩展update注解时，数据库每张表的字段和实体类的字段必须遵循一个约定（数据库中采用下划线命名法，实体类中采用驼峰命名法）。当我们update的时候，会根据每个字段的映射关系，写出如下代码：

<update id="updateUsersById" parameterType="com.lucifer.bean.User">
    UPDATE users
        <set>
        <if test=“userName != null">
            user_name = #{userName} ,
        </if>
        <if test=“password != null">
            password = #{password} ,
        </if>
        <if test=“phone != null">
            phone = #{phone},
        </if>
        <if test=“email != null">
            email = #{email},
        </if>
        <if test=“address != null">
            address = #{address},
        </if>
        <if test="gmtCreated != null">
            gmt_created = #{gmtCreated},
        </if>
        <if test="gmtModified != null">
            gmt_modified = #{gmtModified},
        </if>
    </set>
    WHERE id = #{id}
</update>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

我们可以将实体类中的驼峰式代码转换为下划线式命名方式，这样就可以将这种映射规律自动化 
经过实现LanguageDriver后，注解代码为

@Update("UPDATE users (#{user}) WHERE id = #{id}")
@Lang(SimpleUpdateLangDriver.class)
void updateUsersById(User user);
  • 1
  • 2
  • 3

相对于原始的代码量有很大的减少，并且，一个类中字段越多，改善也就越明显。实现方式为：

public class SimpleUpdateLangDriver extends XMLLanguageDriver implements LanguageDriver{

    private final Pattern inPattern = Pattern.compile("\\(#\\{(\\w+)\\}\\)");

    @Override
    public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) {
        Matcher matcher = inPattern.matcher(script);
        if (matcher.find()) {
            StringBuilder sb = new StringBuilder();
            sb.append("<set>");

            for (Field field : parameterType.getDeclaredFields()) {
                String tmp = "<if test=\"_field != null\">_column=#{_field},</if>";
                sb.append(tmp.replaceAll("_field", field.getName()).replaceAll("_column",
                        CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, field.getName())));
            }

            sb.deleteCharAt(sb.lastIndexOf(","));
            sb.append("</set>");

            script = matcher.replaceAll(sb.toString());
            script = "<script>" + script + "</script>";
        }

        return super.createSqlSource(configuration, script, parameterType);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

3.3 自定义Insert Bean注解

同理，我们可以抽象化Insert操作，简化后的Insert注解为

@Insert("INSERT INTO users (#{user})")
@Lang(SimpleInsertLangDriver.class)
void insertUserDAO(User user);
  • 1
  • 2
  • 3

实现方式为：

public class SimpleInsertLangDriver extends XMLLanguageDriver implements LanguageDriver {

    private final Pattern inPattern = Pattern.compile("\\(#\\{(\\w+)\\}\\)");

    @Override
    public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) {

        Matcher matcher = inPattern.matcher(script);
        if (matcher.find()) {
            StringBuilder sb = new StringBuilder();
            StringBuilder tmp = new StringBuilder();
            sb.append("(");

            for (Field field : parameterType.getDeclaredFields()) {
                sb.append(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, field.getName()) + ",");
                tmp.append("#{" + field.getName() + "},");
            }

            sb.deleteCharAt(sb.lastIndexOf(","));
            tmp.deleteCharAt(tmp.lastIndexOf(","));
            sb.append(") values (" + tmp.toString() + ")");

            script = matcher.replaceAll(sb.toString());
            script = "<script>" + script + "</script>";
        }

        return super.createSqlSource(configuration, script, parameterType);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

3.4 自定义Select注解

有的业务场景下，我们需要根据对象中的字段进行查询，就会写出如下代码：

<select id="selectUser" resultType="com.lucifer.bean.User">
    SELECT id,user_name,password,phone,address,email
    FROM users
    <where>
        <if test="isDel != null">
            AND is_del = #{isDel}
        </if>
        <if test="userName != null">
            AND user_name = #{userName}
        </if>
        <if test="email != null">
            AND email = #{email}
        </if>
        <if test="phone != null">
            AND phone = #{phone}
        </if>
    </where>
</select>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

和Update操作一样，我们可以实现LanguageDriver将where子句抽象化，以此来简化Select查询语句。简化后代码如下：


@Select("SELECT id,user_name,password,phone,address,email FROM users (#{user})")
@Lang(SimpleSelectLangDriver.class)
void selectUserDAO(User user);
  • 1
  • 2
  • 3
  • 4
public class SimpleSelectLangDriver extends XMLLanguageDriver implements LanguageDriver {

    private final Pattern inPattern = Pattern.compile("\\(#\\{(\\w+)\\}\\)");

    @Override
    public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) {

        Matcher matcher = inPattern.matcher(script);
        if (matcher.find()) {
            StringBuilder sb = new StringBuilder();
            sb.append("<where>");

            for (Field field : parameterType.getDeclaredFields()) {
                String tmp = "<if test=\"_field != null\">AND _column=#{_field}</if>";
                sb.append(tmp.replaceAll("_field", field.getName()).replaceAll("_column",
                        CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, field.getName())));
            }

            sb.append("</where>");

            script = matcher.replaceAll(sb.toString());
            script = "<script>" + script + "</script>";
        }

        return super.createSqlSource(configuration, script, parameterType);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

4.排除多余的变量

一个常见的情况是，可能会遇到实体类中的部分字段在数据库中并不存在相应的列，这就需要对多余的不匹配的字段进行逻辑隐藏；我们增加一个自定义的注解，并且对Language的实现稍作修改即可。 
注解为：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Invisible {
}
  • 1
  • 2
  • 3
  • 4
public class User {
    ...

    @Invisible
    private List<String> userList;


    ...
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

然后在实现类中将被该注解声明过的字段排除

for (Field field : parameterType.getDeclaredFields()) {
    if (!field.isAnnotationPresent(Invisible.class)) {  // 排除被Invisble修饰的变量
        String tmp = "<if test=\"_field != null\">_column=#{_field},</if>";
        sb.append(tmp.replaceAll("_field", field.getName()).replaceAll("_column",
                CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, field.getName())));
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

5.注意事项&遇到的一些坑

  1. 务必确保数据库中列名和实体类中字段能一一对应
  2. 在使用自定义SQL解析器的时候，只能传入一个参数，即相应的对象参数即可；传入多个参数会导致解析器中获得到的class对象改变，使得sql解析异常
  3. Update的实现能满足大部分的业务，但有些业务场景可以会遇到根据查询条件来更新查询参数的情况，比如Update uesrs SET uesr_name = ‘tom’ WHERE user_name = ‘Jack’; 在这中场景的时候请不要使用自定义的SQL解析器
  4. 请使用Mybatis 3.3以上版本。3.2版本有bug，会另开一篇重新描述

6.总结

通过实现Language Driver，我们可以方便的自定义自己的注解。在遵循一些约定的情况下（数据库下划线命名，实体驼峰命名），我们可以大幅度的减少SQL的编写量，并且可以完全的屏蔽掉麻烦的XML编写方式，再也不用编写复杂的动态SQL了有木有

// 简洁的数据库操作

@Select("SELECT * FROM users WHERE id IN (#{userIdList})")
@Lang(SimpleSelectInLangDriver.class)
List<User> selectUsersByUserId(List<Integer> userIdList);


@Insert("INSERT INTO users (#{user})")
@Lang(SimpleInsertLangDriver.class)
void insertUserDAO(User user);


@Update("UPDATE users (#{user}) WHERE id = #{id}")
@Lang(SimpleUpdateLangDriver.class)
void updateUsersById(User user);

@Select("SELECT id,user_name,password,phone,address,email FROM users (#{user})")
@Lang(SimpleSelectLangDriver.class)
void selectUserDAO(User user);
Mybatis增强型注解简化SQL语句(一)
ExcellentYuXiao的专栏
11-21 2万+
Mybatis增强型注解简化SQL语句
【Mybatis学习】增强型注解简化SQL
elricboa的专栏
12-19 560
1. 背景 MyBatis提供了简单的Java注解，使得我们可以不配置XML格式的Mapper文件，也能方便的编写简单的数据库操作代码： public interface UserMapper { @Select("SELECT * FROM users WHERE id = #{userId}") User getUser(@Param("userId") String
增强MyBatis注解
qq_38229543的博客
09-23 76
原文链接：https://www.jianshu.com/p/03642b807688?tdsourcetag=s_pcqq_aiomsg
MyBatis增强注解
qq_38229543的博客
09-28 212
MyBatis提供了简单的Java注解，使得我们可以不配置XML格式的Mapper文件，方便的编写简单的数据库操作代码： public interface UserMapper { @Select("SELECT * FROM users WHERE id = #{userId}") User getUser(@Param("userId") String userId); } <configuration> <settings> <setti
MyBatis 基于注解的增、删、改、查操作
09-02 2773
MyBatis 基于注解的增、删、改、查操作 程序清单：UserMapper.java package com.mapper; import org.apache.ibatis.annotations.Delete; import org.apache.ibatis.annotations.Insert; import org.apache.ibatis.annotations.Option...
MyBatisPlus 自定义sql语句的实现
08-25
MyBatisPlus 是一个基于 MyBatis 的增强型 ORM 框架，它提供了强大的 CRUD 操作和条件构造器，但是在某些情况下，我们需要自定义 sql 语句来满足业务需求。本文将详细介绍如何在 MyBatisPlus 中自定义 sql 语句，并...
elasticsearch sql支持增删改查且支持mybatis集成
07-16
1. **SQL支持**：Elasticsearch SQL的扩展使得开发者可以使用他们熟悉的SQL语句来操作Elasticsearch索引。这包括了创建、查询、更新和删除数据，使得数据库操作变得更加直观和高效。例如，你可以使用INSERT语句添加...
MyBatis-Plus---增强型mybatis
github_38596081的博客
02-27 981
指定数据库表名 @TableName("tianshu_log_event") //@IdClass(EventCompositePK.class) // 联合主键 public class Event implements Serializable { private static final long serialVersionUID = 1L; public sta...
MyBatis注解及动态Sql
01-27 617
一、注解实现MyBatis配置 　　java注解是在jdk1.5版本之后开始加入的，不得不说注解对于我们开发人员来说是个很方便的东西，实现起来也非常的简单，下边我们说一下在MyBatis中使用注解来替换Mapper配置文件。 package com.lhf.dao; import com.lhf.entity.User; import org.apache.ibatis....
mybatis注解SQL
华棋皓
07-30 1114
简单的举个例子 创建一个User 对象 设置name,age,id,等属性就可以 public interface UserMapper { @Insert("insert into users(name, age) values(#{name}, #{age})") public int add(Users user); @Delete("del...
Mybatis-注解sql
xxxzzzqqq_的博客
03-15 1671
/https://mybatis.org/mybatis-3/zh/configuration.html#settings setting设置autoMappingBehavior。至此一个对象的创建/填充就完成了,之后回到DefaultResultSetHandler的handleRowValuesForSimpleResultMap方法继续下一个对象的循环。根据command的类型,当前这个案例是SELECT,进入后判断返回类型,当前是返回一个集合,returnsMany属性为ture,进入到。
Mybatis注解写SQL语句
lyh1023812的博客
06-29 3739
1.根据ID查询数据 Mapper接口中 //注意事项: 映射文件和注解二选一 @Select("select * from demo_user where id = #{id}") User findUserById(int id); Test中 @Autowired private UserMapper userMapper; //根据ID查询数据 @Test public void findUserById(){ User user = userMap
MyBatis中注解SQL的使用
最新发布
qq_43877180的博客
07-09 1110
是指直接在接口中添加MyBatis注解完成CRUD功能，在实施此步骤前一定要先将接口全限定名注册到MyBtis的xml文件中的<mappers>
【MyBatis】（5）注解SQL
长生的梦呓
04-22 938
前言 使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。 上面这段来自：官方文档中的 探究已映射的 SQL 语句 在MyBatis中可以使用注解来写SQL语句。用的比较少，当作扩展吧。面对简单需求用起来还是挺顺手的。 二、案例 使用注解...
三十二、MyBatis注解SQL
I want to know a little more.
09-19 363
脚本sql XML配置方式的动态SQL我就不讲了，有兴趣可以自己了解，下面是用&lt;script&gt;的方式把它照搬过来，用注解来实现。适用于xml配置转换到注解配置很明显，在java中写xml可读性和维护性太差，尤其当SQL很长时，这样写是很痛苦的。 //查询所有，@Results字段里只需映射实体类和表字段名不一致的字段名 @Select(" SELECT * FROM child...
mybatis注解在方法直接编写SQL@Select@Insert@Update@Delete
热门推荐
快敲代码去
04-23 1万+
mybatis注解在方法直接编写SQL 查询 修改 插入 删除
mybatis(五): SQL 注解版
zm的博客
01-06 6745
Mybatis 注解 mybatis 注解在mybatis jar包中的E:org.apache.ibatis.annotations包中，所有注解类如下所示。 常用注解 @Select 用于查询sql。属性为String[]。@Select({"","") @Insert 用于插入sql。属性为String[]。 @Update 用于修改sql。属性为String[...
14. 使用MyBatis注解配置SQL
程序员阿红的博客
02-26 3608
14. 使用MyBatis注解配置SQL 1.MyBatis常用注解 @Insert：实现新增，代替了 @Delete：实现删除，代替了 @Update：实现更新，代替了 @Select：实现查询，代替了 @Result：实现结果集封装，代替了 @Results：可以与@Result 一起使用，封装多个结果集，代替了 @One：实现一对一结果集封装，代替了 @Many：实现一对多结果集封装，代替了 2.项目结构和核心配置 使用注解开发摒弃了传统的xml映射文件，而是在接
掌握MyBatis：实现SQL与Java对象的高效映射
动态SQL是通过在XML配置文件中使用特定的标签来实现的，这极大地增强了SQL语句的灵活性和复杂查询的处理能力。 4. **高级映射**：MyBatis能够将数据库表中的列映射到Java对象的属性上，无论是基本数据类型还是复杂...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值