Mybatis工具—SQL构造器（SQL类）_abstractsql-优快云博客

本文链接：https://blog.youkuaiyun.com/Jas000/article/details/125592163

Mybatis为了提高构建SQL语句的统一性和便捷性，提供了一个构建SQL语句的工具类——SQL（org.apache.ibatis.jdbc.SQL），是的，你没看错它就叫SQL，使用这个工具类可以很方便地在Java代码中动态构建SQL语句，如下代码块所示：

 new SQL()
     .SELECT("*")
     .FROM("user_info")
     .WHERE("id = #{id}", "name = #{name}")
     .toString();

概述

SQL类继承自抽象类AbstractSQL，但是SQL类只重写了getSelf()方法，其余的功能由抽象类AbstractSQL提供，所以构建SQL语句的核心逻辑都在抽象类AbstractSQL中，UML用例图如下所示：

UML-1
从图UML-1可得出两个主要信息：

SQL继承自抽象类AbstractSQL;
抽象类AbstractSQL中有SQLStatement和SafeAppendable两个内部类。

SQL类

如代码块1所示SQL类是对外提供SQL语句构建服务的入口，且如前所述SQL类继承自抽象类AbstractSQL。

UML-2
SQL类中的信息很少，如UML-2所示SQL类仅重写了抽象类AbstractSQL的抽象方法getSelf()，其余有关SQL语句构建的功能全由其父类AbstractSQL提供，这就不再累述。

AbstractSQL类

SQL子类仅对抽象方法getSelf()进行重写，从而可见构建SQL语句的所有核心操作都在抽象类AbstractSQL中。

UML-3
如UML-3所示，抽象类AbstractSQL定义了抽象方法abstract T getSelf()提供给子类实现，除此之外还维护了变量sql（引用内部类SQLStatement）、内部类SQLStatement、内部类SafeAppendable和一系列构造SQL语句的方法，例如SELECT(String columns)和UPDATE(String table)等方法，以及重写了toString()方法。

public abstract class AbstractSQL<T> {
    
    private final SQLStatement sql = new SQLStatement();
    
    public abstract T getSelf();
    
    public T SELECT(String columns) {
        sql().statementType = SQLStatement.StatementType.SELECT;
        sql().select.add(columns);
        return getSelf();
    }
    
    private SQLStatement sql() {
        return sql;
    }
    
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sql().sql(sb);
        return sb.toString();
    }
    
    private static class SafeAppendable{}
    
    private static class SQLStatement{}
}

从上述抽象类AbstractSQL部分重点代码块，可以知道内部类SQLStatement专门用于描述SQL语句，而构造SQL语句的方法中，也几乎操作的是内部类SQLStatement中的方法。甚至重写的toString()方法也是在使用内部类SQLStatement来最终生成SQL语句。

SafeAppendable

SafeAppendable维护了SafeAppendable append(CharSequence s)方法，主要完成SQL语句生成时对各个SQL子句和关键字的维护。

SQLStatement

SQLStatement是抽象类AbstractSQL中的一个内部类，结合图UML-3和抽象类AbstractSQL代码块可以清晰的知道，SQLStatement用于描述一个SQL语句，其就是为描述和构造SQL语句而生。并且图UML-3表示SQLStatement类中有两个枚举类，StatementType和LimitingRowsStrategy，以及若干个用于存放SQL语句的对象数组。
在抽象类AbstractSQL的一系列构造SQL语句的方法中的SELECT、UPDATE、DELETE_FROM和INSERT方法都有sql().statementType = SQLStatement.StatementType.SELECT;这样语句代码，从代码结构上看StatementType是内部SQLStatement中的一个枚举内（参见UML-3），其含义就是用于定义当前方法对应的SQL类型。StatementType枚举类一共定义了四种SQL类型，即DELETE、INSERT、 SELECT和UPDATE。

private static class SQLStatement {
    
    /**
     * 定义SQL类型
     */
    public enum StatementType {
      DELETE, INSERT, SELECT, UPDATE
    }
}

借助抽象类AbstractSQL中SELECT_DISTINCT(String columns)方法，对SQLStatement类进行进一步剖析。从SELECT_DISTINCT代码中直接使用AbstractSQL类中的sql()方法来获取当前SQLStatement对象，然后对该对象进行操作，如设置distinct参数为true来表示在SQL语句中增加distinct关键字的构造。

public T SELECT(String... columns) {
    sql().statementType = SQLStatement.StatementType.SELECT;
    sql().select.addAll(Arrays.asList(columns));
    return getSelf();
}

public T SELECT_DISTINCT(String columns) {
    sql().distinct = true;
    SELECT(columns);
    return getSelf();
}

正如前文所述，SQLStatement类中若干个存放SQL语句的对象数组，所以抽象类AbstractSQL中定义构造SQL语句的方法，才会根据不同类型向对应的对象数组添加SQL语句，对象数组详见以下代码块。

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<List<String>> valuesList = new ArrayList<>();

SQL语句生成

抽象类AbstractSQL的主要职责就是构造SQL语句，那么最终SQL语句又是如何生成的呐？SQL语句生成的入口就在抽象类AbstractSQL重写后的toString()方法中，从toString()方法可以得到三点内容：

创建了一个StringBuilder对象来存放SQL语句
通过AbstractSQL类中的sql()方法获取当前SQLStatement对象
调用SQLStatement类中的sql(Appendable)方法生成SQL语句

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

显然SQLStatement类中的sql(Appendable)方法是生成SQL语句的关键，sql(Appendable)源码的步骤主要分为：

初始化SafeAppendable对象，用于存放SQL语句
根据StatementType枚举判断当前SQL语句的类型
根据不同类型调用对应的SQL语句生成方法，如DELETE类型调用deleteSQL(SafeAppendable)方法

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;
}

以deleteSQL(SafeAppendable)为例继续往下探索，发现各个类型SQL语句生成的方法里最终都会调用sqlClause来完成SQL语句拼装，详细代码代码如下：

sqlClause各入参的解释：
1. SafeAppendable builder：SQL语句构造对象
2. String keyword：SQL语句关键字，如SELECT
3. List parts：SQL语句关键字后接的SQL子句，如SELECT后接的想要查询的参数
4. String open：当前SQL语句的开始语句，如(
5. String close：当前SQL语句的结束语句，如)
6. String conjunction：各个子句之间的连接关键字，如AND/OR
sqlClause操作步骤分为：
1. 向SafeAppendable对象追加keyword关键字
2. 向SafeAppendable对象追加open开始语句
3. 遍历SQL子句，如果子句中有AND/OR关键字则不追加conjunction，否则追加conjunction连接关键字
4. 遍历SQL子句，向SafeAppendable对象追加子句
5. 向SafeAppendable对象追加close开始语句

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);
      }
}