MyBatis3源码深度解析(八)MyBatis常用工具类(一)SQL工具类

第3章 MyBatis常用工具类

3.1 使用SQL类生成语句

在使用JDBC API开发时，当使用Statement对象执行SQL时，SQL语句会嵌入到Java代码中。

如果SQL语句比较复杂，则需要在代码中对SQL语句进行拼接，当条件不固定时，还需要根据条件进行不同的拼接，同时还要注意空格、逗号等的使用。这就使得开发的难度大大增加，且代码的可维护性大大降低。

为了解决这个问题，MyBatis提供了一个SQL工具类。通过使用该工具类，可以方便地在Java代码中动态地构建SQL语句。

3.1.1 SQL工具类示例用法

示例如下：

@Test
public void testSelectSql() {
    String sql = new SQL(){{
        SELECT("id, name, age");
        SELECT("phone, birthday");
        FROM("user");
        WHERE("id = 2");
        OR();
        WHERE("name = 'user1'");
        ORDER_BY("id");
    }}.toString();
    System.out.println(sql);
}

@Test
public void testInsertSql() {
    String sql = new SQL(){{
        INSERT_INTO("user");
        VALUES("name, age, phone, birthday", "'user3', 45, '15789654532', '2015-12-13'");
    }}.toString();
    System.out.println(sql);
}

@Test
public void testUpdateSql() {
    String sql = new SQL(){{
        UPDATE("user");
        SET("name", "玉皇大帝");
        WHERE("id = 1");
    }}.toString();
    System.out.println(sql);
}

@Test
public void testDeleteSql() {
    String sql = new SQL(){{
        DELETE_FROM("user");
        WHERE("id = 1");
    }}.toString();
    System.out.println(sql);
}

控制台输出执行结果：

SELECT id, name, age, phone, birthday
FROM user
WHERE (id = 2) 
OR (name = 'user1')
ORDER BY id

INSERT INTO user
 (name, age, phone, birthday)
VALUES ('user3', 45, '15789654532', '2015-12-13')

UPDATE user
SET name, 玉皇大帝
WHERE (id = 1)

DELETE FROM user
WHERE (id = 1)

如上面的示例所示，SQL工具类可以调用SELECT()、FROM()等方法构建SQL语句，这种方式能够有效地避免字符串拼接过程中出现的问题。

使用SQL工具类还可以很方便地在Java代码中根据条件动态地构建SQL语句。示例如下：

public void selectUser(User user) {
    String sql = new SQL(){{
        SELECT("id, name, age");
        SELECT("phone, birthday");
        FROM("user");
        if(user.getId() != null) {
            WHERE("id = #{id}");
        }
        if(user.getName() != null) {
            WHERE("name like #{name}");
        }
        ORDER_BY("id");
    }}.toString();
    System.out.println(sql);
}

@Test
public void testSelectUser() {
    User user = new User();
    user.setId(1);
    user.setName("user");
    selectUser(user);
}

控制台打印执行结果：

SELECT id, name, age, phone, birthday
FROM user
WHERE (id = #{id} AND name like #{name})
ORDER BY id

3.1.2 SQL工具类方法集锦

SQL工具类中提供的主要方法及作用如下：

源码1：org/apache/ibatis/jdbc/AbstractSQL.java

// 开始一个 SELECT 子句或将内容追加到 SELECT 子句中
// 方法可以被多次调用，参数也会添加到 SELECT 子句
// 参数通常是使用逗号分隔的列名或列的别名列表，也可以是数据库驱动程序接收的任意关键字
SELECT(String)
SELECT(String...)

// 开始一个 SELECT 子句或将内容追加到 SELECT 子句中
// 同时可以插入 DISTINCT 关键字到 SELECT 子句中
// 方法可以被多次调用，参数也会添加到 SELECT 子句中
// 参数通常使用逗号分隔的列名或者列的别名列表，也可以是数据库驱动程序接收的任意关键字
SELECT_DISTINCT(String)
SELECT_DISTINCT(String...)

// 开始一个 SELECT 子句或将内容追加到 SELECT 子句中
// 同时可以插入 DISTINCT 关键字到 SELECT 子句中
// 方法可以被多次调用，参数也会添加到 SELECT 子句中
// 参数通常使用逗号分隔的列名或者列的别名列表，也可以是数据库驱动程序接收的任意关键字
FROM(String table)
FROM(String... tables)

// 根据不同的方法添加对应类型的 JOIN 子句
// 例如 INNER_JOIN() 方法添加 INNER JOIN 子句
// LEFT_OUTER_JOIN() 方法添加 LEFT JOIN 子句
// 参数可以包含由列命和 JOIN ON 条件组合成的标准JOIN
JOIN(String join)
JOIN(String... joins)
INNER_JOIN(String join)
INNER_JOIN(String... joins)
LEFT_OUTER_JOIN(String join)
LEFT_OUTER_JOIN(String... joins)
RIGHT_OUTER_JOIN(String join)
RIGHT_OUTER_JOIN(String... joins)

// 插入新的 WHERE 子句条件，并通过AND关键字连接
// 方法可以多次被调用，每次都由 AND 来连接新条件
// 使用 OR() 方法可以追加 OR 关键字
WHERE(String conditions)
WHERE(String... conditions)

// 使用 OR 来分隔当前的 WHERE 子句条件
// 可以被多次调用，但在一行中多次调用可能生成错误的SOL语句
OR()

// 使用 AND 来分隔当前的 WHERE 子句条件
// 可以被多次调用，但在一行中多次调用可能会生成错误的SQL语句
// 这个方法使用较少，因为 WHERE() 和 HAVING() 方法都会自动追加 AND，只有必要时才会额外调用 AND() 方法
AND()

// 插入新的 GROUP BY 子句，通过逗号连接
// 方法可以被多次调用，每次都会使用逗号连接新的条件
GROUP_BY(String columns)
GROUP_BY(String... columns)

// 插入新的 HAVING 子句条件。由AND关键字连接
// 方法可以被多次调用，每次都由 AND 来连接新的条件
HAVING(String conditions)
HAVING(String... conditions)

// 插入新的 ORDER BY子句元素，由逗号连接
// 可以多次被调用，每次都由逗号连接新的条件
ORDER_BY(String columns)
ORDER_BY(String... columns)

// 开始一个 DELETE 语句并指定表名
// 通常它后面都会跟着 WHERE 语句
DELETE_FROM(String table)

// 开始一个 INSERT 语句并指定表名
// 后面都会跟着一个或者多个 VALUES()，或者INTO_COLUMNS()和INTO_VALUES()
INSERT_INTO(String tableName)

// 针对 UPDATE 语句，插入 SET 子句中
SET(String sets)
SET(String... sets)

// 开始一个 UPDATE 语句并指定需要更新的表名
// 后面都会跟着一个或者多个 SET() 方法，通常会有一个或多个 WHERE() 方法
UPDATE(String table)

// 插入 INSERT 语句中，第一个参数是要插入的列名，第二个参数则是该列的值
VALUES(String columns, String values)

// 追加字段到 INSERT 子句中，该方法必须和 INTO_VALUES() 联合使
用
INTO_COLUMNS(String... columns)

// 追加字段值到 INSERT 子句中，该方法必须和 INTO_COLUMNS() 方法联合使用
INTO_VALUES(String... values)

3.1.3 SQL工具类源码解析

源码2：org/apache/ibatis/jdbc/SQL.java

public class SQL extends AbstractSQL<SQL> {

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

}

由 源码2 可知，SQL类继承自AbstractSQL类，只重写了父类的getSelf()方法。

源码3：org/apache/ibatis/jdbc/AbstractSQL.java

public abstract class AbstractSQL<T> {
    private final SQLStatement sql = new SQLStatement();
    public abstract T getSelf();

    private static class SQLStatement {
        // ......
    }
    
    // ......
}

由 源码3 可知，AbstractSQL类负责完成SQL语句的构造工作，其内部维护了一个内部类SQLStatement对象的实例，和一系列上面列举的构造SQL语句的方法。

源码4：org/apache/ibatis/jdbc/AbstractSQL.java

public abstract class AbstractSQL<T> {
    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<List<String>> valuesList = new ArrayList<>();
        boolean distinct;
        // ......
    }
}

由 源码4 可知，内部类SQLStatement用于描述一个SQL语句。该类中通过StatementType枚举类确定SQL语句的类型，内部维护了一些了ArrayList属性，当调用SELECT()、UPDATE()等方法时，这些方法的参数会记录在这些ArrayList对象中。

如在示例中，调用了UPDATE("user");方法：

源码5：org/apache/ibatis/jdbc/AbstractSQL.java

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

由 源码5 可知，UPDATE()方法会将SQLStatement对象的statementType属性设置为UPDATE，并将参数设置到tables集合中。

再例如执行SET("name", "玉皇大帝");：

源码6：org/apache/ibatis/jdbc/AbstractSQL.java

public T SET(String... sets) {
    sql().sets.addAll(Arrays.asList(sets));
    return getSelf();
}

由 源码6 可知，SET()方法会把参数设置到sets集合中。

在示例中，调用SQL对象的toString()方法即可打印出构造好的SQL语句，这个toString()方法可以作为研究源码的切入点。

源码7：org/apache/ibatis/jdbc/AbstractSQL.java

@Override
public String toString() {
    StringBuilder sb = new StringBuilder();
    // 调用SQLStatement的sql()方法生成SQL语句
    sql().sql(sb);
    return sb.toString();
}

private final SQLStatement sql = new SQLStatement();
private SQLStatement sql() {
    return sql;
}

由 源码7 可知，toString()方法在AbstractSQL类中实现，这里会调用SQLStatement类的sql()方法生成SQL语句。

源码8：org/apache/ibatis/jdbc/AbstractSQL.java

public String sql(Appendable a) {
    // ......
    // 判断SQL语句的类型，根据不同的SQL语句类型执行不同的方法
    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;
}

由 源码8 可知，sql()方法会判断SQL语句的类型，根据不同的SQL语句类型执行不同的方法。例如SQL语句类型为UPDATE时，调用updateSQL()方法构造UPDATE语句。

源码9：org/apache/ibatis/jdbc/AbstractSQL.java

private String updateSQL(SafeAppendable builder) {
    // 处理UPDATE子句
    sqlClause(builder, "UPDATE", tables, "", "", "");
    joins(builder);
    sqlClause(builder, "SET", sets, "", "", ", ");
    sqlClause(builder, "WHERE", where, "(", ")", " AND ");
    limitingRowsStrategy.appendClause(builder, null, limit);
    return builder.toString();
}

/**
 * SQL语句拼接
 * @param builder SQL字符串构建对象
 * @param keyword SQL关键字
 * @param parts SQL关键字子句内容
 * @param open SQL关键字后开始字符
 * @param close SQL关键字后结束字符
 * @param conjunction SQL连接关键字，通常为 AND 或 OR
 */
private void sqlClause(AbstractSQL.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);
    }
}

由 源码9 可知，updateSQL()方法的第一行是调用sqlClause()方法处理 UPDATE 子句，由其传入的参数可知，关键字keyword是"UPDATE"，关键字子集parts是名为tables的集合，这个集合保存了表的名称。

借助Debug，执行完第一行的sqlClause()方法得到的结果是：

接着继续执行第二行代码：joins(builder);。

源码10：org/apache/ibatis/jdbc/AbstractSQL.java

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

由 源码10 可知，joins()方法依旧是调用sqlClause()方法分别构建 JOIN、INNER JOIN、OUTER JOIN、LEFT OUTER JOIN、RIGHT OUTER JOIN 子句。

由于示例中没有这些关键字，所以第二行代码执行完后结果仍然不变。

继续执行第三行代码：sqlClause(builder, "SET", sets, "", "", ", ");，构建 SET 子句，构造完成后的结果如图：

继续执行第四行代码：``sqlClause(builder, “WHERE”, where, “(”, “)”, " AND ");```，构建 WHERE 子句，构造完成后的结果如图：

最后直接调用构造器的toString()方法将SQL语句转换为字符串形式。

由此可见，对于不同SQL语句的类型，selectSQL()、insertSQL()、updateSQL()、deleteSQL()这四个方法都已经最好了预设，逐一检索SQL语句可能会包含的关键字，并调用sqlClause()方法进行构造。

…

本节完，更多内容请查阅分类专栏：MyBatis3源码深度解析