MyBatis常用工具类一-使用SQL类生成语句

使用JDBC API开发过项目的读者应该知道，当我们需要使用Statement对象执行SQL时，SQL语句会嵌入Java代码中。SQL语句比较复杂时，我们可能会在代码中对SQL语句进行拼接，查询条件不固定时，还需要根据不同条件拼接不同的SQL语句，拼接语句时不要忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。这个过程对于开发人员来说简直就是一场噩梦，而且代码可维护性级低，例如：

String orgSql = "SELECT P.ID, P.USERNAME, P.PASSWORD, P.FULL_NAME, P.LAST_NAME, P.CREATED_ON, P.UPDATED_ON\n" +
                        "FROM PERSON P, ACCOUNT A\n" +
                        "INNER JOIN DEPARTMENT D on D.ID = P.DEPARTMENT_ID\n" +
                        "INNER JOIN COMPANY C on D.COMPANY_ID = C.ID\n" +
                        "WHERE (P.ID = A.ID AND P.FIRST_NAME like ?) \n" +
                        "OR (P.LAST_NAME like ?)\n" +
                        "GROUP BY P.ID\n" +
                        "HAVING (P.LAST_NAME like ?) \n" +
                        "OR (P.FIRST_NAME like ?)\n" +
                        "ORDER BY P.ID, P.FULL_NAME";

为了解决这个问题，MyBatis中提供了一个SQL工具类。使用这个工具类，我们可以很方便地在Java代码中动态构建SQL语句。上面的语句如果使用SQL工具类来构建，就会简单很多。下面是使用MyBatis中的SQL工具类动态构建SQL语句的案例

String newSql =  new SQL() {{
                    SELECT("P.ID, P.USERNAME, P.PASSWORD, P.FULL_NAME");
                    SELECT("P.LAST_NAME, P.CREATED_ON, P.UPDATED_ON");
                    FROM("PERSON P");
                    FROM("ACCOUNT A");
                    INNER_JOIN("DEPARTMENT D on D.ID = P.DEPARTMENT_ID");
                    INNER_JOIN("COMPANY C on D.COMPANY_ID = C.ID");
                    WHERE("P.ID = A.ID");
                    WHERE("P.FIRST_NAME like ?");
                    OR();
                    WHERE("P.LAST_NAME like ?");
                    GROUP_BY("P.ID");
                    HAVING("P.LAST_NAME like ?");
                    OR();
                    HAVING("P.FIRST_NAME like ?");
                    ORDER_BY("P.ID");
                    ORDER_BY("P.FULL_NAME");
                }}.toString();

如上面的代码所示，创建了一个匿名的SQL类的子类，在匿名子类的初始化代码块中，调用SELECT()、FROM()等方法构建SQL语句，这种方式能够很好地避免字符串拼接过程中缺少空格或者偶然间重复出现的AND关键字导致的SQL语句不正确。

除了SELECT语句外，SQL工具类也可以用作构建UPDATE、INSERT等语句。下面是SQL工具类的一些使用案例：

@Test
    public  void testInsertSql() {
        String insertSql = new SQL().
            INSERT_INTO("PERSON").
            VALUES("ID, FIRST_NAME", "#{id}, #{firstName}").
            VALUES("LAST_NAME", "#{lastName}").toString();
        System.out.println(insertSql);
    }
 @Test
    public void  testDeleteSql() {
        String deleteSql =  new SQL() {{
            DELETE_FROM("PERSON");
            WHERE("ID = #{id}");
        }}.toString();
        System.out.println(deleteSql);
    }
 @Test
    public void testUpdateSql() {
        String updateSql =  new SQL() {{
            UPDATE("PERSON");
            SET("FIRST_NAME = #{firstName}");
            WHERE("ID = #{id}");
        }}.toString();
        System.out.println(updateSql);
    }

使用SQL工具类的另一个好处是可以很方便地在Java代码中根据条件动态地拼接SQL语句，例如：

public String selectPerson(final String id, final String firstName, final String lastName) {
        return new SQL() {{
            SELECT("P.ID, P.USERNAME, P.PASSWORD");
            SELECT("P.FIRST_NAME, P.LAST_NAME");
            FROM("PERSON P");
            if (id != null) {
                WHERE("P.ID = #{id}");
            }
            if (firstName != null) {
                WHERE("P.FIRST_NAME = #{firstName}");
            }
            if (lastName != null) {
                WHERE("P.LAST_NAME = #{lastName}");
            }
            ORDER_BY("P.LAST_NAME");
        }}.toString();
    }

SQL工具类中提供的所有方法及作用可参考表的内容。

方法	描述
SELECT(String) SELECT(String...)	开始一个SELECT子句或将内容追加到SELECT子句。方法可以被多次调用，参数也会添加到 SELECT 子句。参数通常是使用逗号分隔的列名或列的别名列表，也可以是数据库驱动程序接收的任意关键字
SELECT DISTINCT(String) SELECT DISTINCT(String...)	开始一个SELECT子句或将内容追加到 SELECT子句。同时可以插入DISTINCT 关键字到SELECT 语句中。方法可以被多次调用，参数也会添加到SELECT子句。参数通常使用逗号分隔的列名或者列的别名列表，也可以是数据库驱动程序接收的任意关键字
FROM(String) FROM(String...)	开始或插入 FROM子句。方法可以被多次调用，参数会添加到 FROM子句。参数通常是表名或别名，也可以是数据库驱动程序接收的任意关键字
JOIN(String) JOIN(String...) INNERJOIN(String) INNERJOIN(String...) LEFT OUTER JOIN(String) LEFT OUTER JOIN(String...) RIGHT OUTERJOIN(String) RIGHT OUTER JOIN(String....）	根据不同的方法添加对应类型的JOIN子句，例如INNERJOINO方法添加INNER JOIN 子句，LEFT OUTER JOINO方法添加 LEFT JOIN子句。参数可以包含由列命和JOINON条件组合成的标准JOIN
WHERE(String) WHERE(String...)	插入新的 WHERE 子句条件，并通过AND 关键字连接。方法可以多次被调用，每次都由AND 来连接新条件。使用 OR0方法可以追加 OR关键字
OR()	使用OR来分隔当前的 WHERE 子句条件。可以被多次调用，但在一行中多次调用可能生成错误的 SQL语句
AND()	使用AND 来分隔当前的 WHERE 子句条件。可以被多次调用，但在一行中多次调用可能会生成错误的 SQL 语句。这个方法使用较少，因为WHEREO和HAVINGO方法都会自动追加 AND，只有必要时才会额外调用AND0方法
GROUP BY(String) GROUP BY(String...)	插入新的 GROUP BY 子句，通过逗号连接。方法可以被多次调用每次都会使用逗号连接新的条件
HAVING(String) HAVING(String...)	插入新的 HAVING子句条件。由AND 关键字连接。方法可以被多次调用，每次都由 AND 来连接新的条件
ORDER BY(String) ORDER BY(String...)	插入新的 ORDER BY 子句元素，由逗号连接。可以多次被调用，每次都由逗号连接新的条件
DELETE FROM(String)	开始一个DELETE 语句并指定表名。通常它后面都会跟着 WHERE语句
INSERT INTO(String)	开始一个 INSERT语句并指定表名，后面都会跟着一个或者多个VALUES0，或者INTO COLUMNSO和INTO VALUES（）
SET(String) SET(String...)	针对UPDATE语句，插入SET子句中
UPDATE(String)	开始一个UPDATE 语句并指定需要更新的表名。后面都会跟着一个或者多个 SETO方法，通常会有一个或多个 WHEREO方法
VALUES(String,String)	插入 INSERT 语句中，第一个参数是要插入的列名，第二个参数则是该列的值
INTO COLUMNS(String...)	追加字段到INSERT子句中，该方法必须和INTOVALUESO联合使用
INTO VALUES(String...)	追加字段值到INSERT子句中,该方法必须和INTOCOLUMNSO方法联合使用

在学习完SQL工具类的使用后，接下来我们简单地了解一下SQL工具类的实现源码。SQL继承至AbstractSQL类，只重写了该类的getSelf()方法，代码如下：

public class SQL extends AbstractSQL<SQL> {

  @Override
  public SQL getSelf() {
    return this;
  }

}

所有的功能由AbstractSQL类完成，AbstractSQL类中维护了一个SQLStatement内部类的实例和一系列前面提到过的构造SQL语句的方法，例如SELECT()、UPDATE()等方法。AbstractSQL类的部分代码如下：

private static final String AND = ") \nAND (";
  private static final String OR = ") \nOR (";

  private final SQLStatement sql = new SQLStatement();

  public abstract T getSelf();

  public T UPDATE(String table) {
    sql().statementType = SQLStatement.StatementType.UPDATE;
    sql().tables.add(table);
    return getSelf();
  }

  public T SET(String sets) {
    sql().sets.add(sets);
    return getSelf();
  }

SQLStatement内部类用于描述一个SQL语句，该类中通过StatementType确定SQL语句的类型。SQLStatement类中还维护了一系列的ArrayList属性，当调用SELECT()、UPDATE()等方法时，这些方法的参数内容会记录在这些ArrayList对象中，SQLStatement类中的属性如下：

private static class SQLStatement {

    public enum StatementType {
      DELETE, INSERT, SELECT, UPDATE
    }

    StatementType statementType;
    List<String> sets = new ArrayList<>();
    List<String> select = new ArrayList<>();
    List<String> tables = new ArrayList<>();
    List<String> join = new ArrayList<>();
    List<String> innerJoin = new ArrayList<>();
    List<String> outerJoin = new ArrayList<>();
    List<String> leftOuterJoin = new ArrayList<>();
    List<String> rightOuterJoin = new ArrayList<>();
    List<String> where = new ArrayList<>();
    List<String> having = new ArrayList<>();
    List<String> groupBy = new ArrayList<>();
    List<String> orderBy = new ArrayList<>();
    List<String> lastList = new ArrayList<>();
    List<String> columns = new ArrayList<>();
    List<String> values = new ArrayList<>();
    boolean distinct;

    public SQLStatement() {
        // Prevent Synthetic Access
    }

    private void sqlClause(SafeAppendable builder, String keyword, List<String> parts, String open, String close,
                           String conjunction) {
      if (!parts.isEmpty()) {
        if (!builder.isEmpty()) {
          builder.append("\n");
        }
        builder.append(keyword);
        builder.append(" ");
        builder.append(open);
        String last = "________";
        for (int i = 0, n = parts.size(); i < n; i++) {
          String part = parts.get(i);
          if (i > 0 && !part.equals(AND) && !part.equals(OR) && !last.equals(AND) && !last.equals(OR)) {
            builder.append(conjunction);
          }
          builder.append(part);
          last = part;
        }
        builder.append(close);
      }
    }

    private String selectSQL(SafeAppendable builder) {
      if (distinct) {
        sqlClause(builder, "SELECT DISTINCT", select, "", "", ", ");
      } else {
        sqlClause(builder, "SELECT", select, "", "", ", ");
      }

      sqlClause(builder, "FROM", tables, "", "", ", ");
      joins(builder);
      sqlClause(builder, "WHERE", where, "(", ")", " AND ");
      sqlClause(builder, "GROUP BY", groupBy, "", "", ", ");
      sqlClause(builder, "HAVING", having, "(", ")", " AND ");
      sqlClause(builder, "ORDER BY", orderBy, "", "", ", ");
      return builder.toString();
    }

    private void joins(SafeAppendable builder) {
      sqlClause(builder, "JOIN", join, "", "", "\nJOIN ");
      sqlClause(builder, "INNER JOIN", innerJoin, "", "", "\nINNER JOIN ");
      sqlClause(builder, "OUTER JOIN", outerJoin, "", "", "\nOUTER JOIN ");
      sqlClause(builder, "LEFT OUTER JOIN", leftOuterJoin, "", "", "\nLEFT OUTER JOIN ");
      sqlClause(builder, "RIGHT OUTER JOIN", rightOuterJoin, "", "", "\nRIGHT OUTER JOIN ");
    }

    private String insertSQL(SafeAppendable builder) {
      sqlClause(builder, "INSERT INTO", tables, "", "", "");
      sqlClause(builder, "", columns, "(", ")", ", ");
      sqlClause(builder, "VALUES", values, "(", ")", ", ");
      return builder.toString();
    }

    private String deleteSQL(SafeAppendable builder) {
      sqlClause(builder, "DELETE FROM", tables, "", "", "");
      sqlClause(builder, "WHERE", where, "(", ")", " AND ");
      return builder.toString();
    }

    private String updateSQL(SafeAppendable builder) {
      sqlClause(builder, "UPDATE", tables, "", "", "");
      joins(builder);
      sqlClause(builder, "SET", sets, "", "", ", ");
      sqlClause(builder, "WHERE", where, "(", ")", " AND ");
      return builder.toString();
    }

    public String sql(Appendable a) {
      SafeAppendable builder = new SafeAppendable(a);
      if (statementType == null) {
        return null;
      }

      String answer;

      switch (statementType) {
        case DELETE:
          answer = deleteSQL(builder);
          break;

        case INSERT:
          answer = insertSQL(builder);
          break;

        case SELECT:
          answer = selectSQL(builder);
          break;

        case UPDATE:
          answer = updateSQL(builder);
          break;

        default:
          answer = null;
      }

      return answer;
    }
  }

AbstrastSQL类重写了toString()方法，该方法中会调用SQLStatement对象的sql()方法生成SQL字符串，代码如下：

public String toString() {
    StringBuilder sb = new StringBuilder();
    sql().sql(sb);
    return sb.toString();
  }

sql(Appendable a)方法中会判断SQL语句的类型，以UPDATE语句为例，会调用SQLStatement对象的updateSql()方法生成UPDATE语句。updateSql()方法代码如下：

private String updateSQL(SafeAppendable builder) {
      sqlClause(builder, "UPDATE", tables, "", "", "");// update语句
      joins(builder);  // join语句
      sqlClause(builder, "SET", sets, "", "", ", "); // set语句
      sqlClause(builder, "WHERE", where, "(", ")", " AND ");// where 语句
      return builder.toString();
    }

如上面的代码所示，updateSql()方法中，最终会调用sqlCalause()方法完成SQL语句的拼接。sqlCalause()方法实现代码如下：

/**
     * SQL语句拼接
     * @param builder SQL 字符串构建对象
     * @param keyword SOL 关键宁
     * @param parts SOL关键字子句内容
     * @param open SQL 关键字后开始字符
     * @param close SOL 关键字后结束字符Cparam
     * @param conjunction SQL连接关键字，通常为AND或OR
     */
private void sqlClause(SafeAppendable builder, String keyword, List<String> parts, String open, String close,
                           String conjunction) {
      if (!parts.isEmpty()) {
        if (!builder.isEmpty()) {
          builder.append("\n");
        }
          //拼接 SQL 关键字
        builder.append(keyword);
        builder.append(" ");
          //拼接关键字后开始字符
        builder.append(open);
        String last = "________";
        for (int i = 0, n = parts.size(); i < n; i++) {
          String part = parts.get(i);
            //如果SQL 关键字对应的子句内容不为OR或AND，则追加连接关键字
          if (i > 0 && !part.equals(AND) && !part.equals(OR) && !last.equals(AND) && !last.equals(OR)) {
            builder.append(conjunction);
          }
            //追加子句内容
          builder.append(part);
            //追加关键字后结束字符
          last = part;
        }
        builder.append(close);
      }
    }

MyBatis常用工具类一-使用SQL类生成语句

继续阅读

Mybatis之批量插入的几种方法

Eclipse/MyEclipse插件安装的问题

Android toast工具类

MyBatis日志实现一-Java日志体系

读取excel表格进行数据库数据的插入

postman常见问题处理方法

Mybatis /MySQL 常用功能记录

常用开发工具----搜索工具

3.项目中的公共返回类CommonResult

获取浏览器url地址请求参数--requestParam.js

动力节点|MyBatis从入门实战到深入源码

javaMail实现邮件发送

8. fluent-mybatis 关联查询

9 fluent-mybatis 使用PageHelper进行分页查询

MyBatis动态sql标签帮你轻松搞定sql拼接

领导说谁再直接删数据就滚蛋，悄悄用上MyBatis-Plus逻辑删除