【Java 代理模式 · Mybatis源码】Mapper简单模拟

1. 概述

我们将在这一节介绍：

1、什么是代理？

2、为什么要使用ORM框架？

3、MyBatis简介

1.1 代理

Java 代理模式 有 3种实现：

• 静态代理
• JDK 动态代理
• CGLib 动态代理

1.2 ORM框架

ORM（Object Relational Mapping）框架采用元数据来描述对象与关系映射的细节，元数据一般采用XML格式，并且存放在专门的对象一映射文件中。

只要提供了持久化类与表的映射关系，ORM框架在运行时就能参照映射文件的信息，把对象持久化到数据库中。当前ORM框架主要有五种：Hibernate(Nhibernate)，iBATIS，MyBatis (MyBatis Plus)，EclipseLink，JFinal。

如果我们不使用ORM框架，就会在业务代码中出现大量以下冗余代码，这使得数据库操作笨重，而易忽视业务本身：

try {
    Class.forName("com.mysql.cj.jdbc.Driver");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
    connection = DriverManager.getConnection("");
    statement = connection.createStatement();
    resultSet = statement.executeQuery("SELECT * FROM USER");
    ArrayList<User> userList = Lists.newArrayList();
    while (resultSet.next()) {
        int id = resultSet.getInt("user_id");
        String name = resultSet.getString("user_name");
        int age = resultSet.getInt("user_age");
        userList.add(new User(id, name, age));
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    if (resultSet != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (statement != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (connection != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

所以，我们可以使用ORM框架，它应用了代理模式，能够减少我们代码的冗余，从而更加关注业务本身。

1.3 MyBatis

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。

iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAOs）

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。

1.3.1 从 XML 中构建 SqlSessionFactory

每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。

从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。 但也可以使用任意的输入流（InputStream）实例，比如用文件路径字符串或 file:// URL 构造的输入流。MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。

String resource = "org/mybatis/example/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

XML 配置文件中包含了对 MyBatis 系统的核心设置，包括获取数据库连接实例的数据源（DataSource），这里给出一个简单的示例：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  </mappers>
</configuration>

environment 元素体中包含了事务管理和连接池的配置。

mappers 元素则包含了一组映射器（mapper），这些映射器的 XML 映射文件包含了 SQL 代码和映射定义信息。

1.3.2 不使用 XML 构建 SqlSessionFactory

我们可以使用 Java 代码顶替 XML 文件创建配置，MyBatis 提供了完整的配置类，提供了所有与 XML 文件等价的配置项。

DataSource dataSource = BlogDataSourceFactory.getBlogDataSource();
TransactionFactory transactionFactory = new JdbcTransactionFactory();
Environment environment = new Environment("development", transactionFactory, dataSource);
Configuration configuration = new Configuration(environment);
configuration.addMapper(BlogMapper.class);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);

注意：configuration 添加了一个映射器类（mapper class）。映射器类是 Java 类，它们包含 SQL 映射注解从而避免依赖 XML 文件。

不过，由于 Java 注解的一些限制以及某些 MyBatis 映射的复杂性，要使用大多数高级映射（比如：嵌套联合映射），仍然需要使用 XML 配置。

有鉴于此，如果存在一个同名 XML 配置文件，MyBatis 会自动查找并加载它（在这个例子中，基于类路径和 BlogMapper.class 的类名，会加载 BlogMapper.xml）。

1.3.3 从 SqlSessionFactory 中获取 SqlSession

顾名思义，我们可以从 SqlSessionFactory中获得 SqlSession 的实例。

SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。

我们可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。例如：

try (SqlSession session = sqlSessionFactory.openSession()) {
  Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
}

现在有一种更简洁的方式：

• 使用和指定语句的参数和返回值相匹配的接口（比如 BlogMapper.class），现在不用担心可能出错的字符串字面值以及强制类型转换。

例如：

try (SqlSession session = sqlSessionFactory.openSession()) {
  BlogMapper mapper = session.getMapper(BlogMapper.class);
  Blog blog = mapper.selectBlog(101);
}

2. 代理原理模拟

ORM 框架的核心技术应用为：反射、代理，这里我们对代理进行简单论述。

JDK 动态代理，本质上是通过JVM获取方法名、方法参数。

我们无法通过Java程序本身操作JVM，所以通过反射机制来模拟这个过程，但效率不如JVM直接获取高。

使用POM项目时，反射获取方法的参数名称会使用拟态名，所以需要在 pom.xml 引入以下配置：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.6.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <debug>true</debug>
                <debuglevel>lines,vars,source</debuglevel>
                <compilerArgs>
                    <arg>-parameters</arg>
                </compilerArgs>
            </configuration>
        </plugin>
    </plugins>
</build>

2.1 构建过程

这里对代理所用到的代理接口、工具接口、代理实例（方法创建）进行构建。

2.1.1 代理接口

即被代理的接口，它没有实现与实例，它的实现由代理创建，

interface Test {
    void say();
}

2.1.2 工具接口

这里的工具接口模拟代理模式中的InvocationHandler接口，唯一的区别是我们没有对异常进行抛出处理。

interface InvokeHandler {
    Object invoke(Object proxy, Method method, Object ...args);
}

2.1.3 代理实例

构建代理接口的实现：

/**
 * 创建代理实例方法
 *
 * @param handler 工具接口
 * @param clazz   类对象
 * @return 返回代理接口实例
 */
// 匿名内部类，引用外部类变量，默认加final
public Test createProxyInstance(final InvokeHandler handler, final Class<?> clazz) {
    return new Test() {
        @Override
        public void say() {
            try {
                Method sayMethod = clazz.getMethod("say");
                handler.invoke(this, sayMethod);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };
}

2.2 调用过程

2.2.1 创建代理实例

创建代理接口的实例：

Test test = createProxyInstance(new InvokeHandler() {
   /**
     * 代理方法
     * @param proxy     调用方法代理类实例
     * @param method    代理实例所包含方法
     * @param args      方法包含参数（数组）
     * @return 可返回参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object... args) {
        // 代理方法体
        System.out.println("say方法：代理方法体");
        return null;
    }
}, Test.class);

2.2.2 调用代理实例相应方法

test.say();

可以看到，已经执行了代理的方法体：

3. 简单实现 - JDK动态代理

3.1 构建过程

同样，这里我们构建简单实现所用到的必要类：实体类、Mapper、SQL处理方法。

3.1.1 建立实体类

建立一个实体类，这里我们用到了Lombok，但并未通过XML对两者（Entity — Table）名称进行映射关联

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String name;
    private Integer age;
}

3.1.2 建立Mapper类

建立对应的Mapper类：

/**
 * 模拟 Mybatis Mapper 接口
 */
interface UserMapper {
    @Select("SELECT * FROM user_tab WHERE user_id = #{id} AND user_name = #{name}")
    List<User> selectUserList(Integer id, String name);
}

3.1.4 创建SQL处理方法

当我们输入了形如SELECT * FROM blog WHERE id = #{id} AND name = #{name}的SQL语句，需对其进行处理后，改装为真正的SQL语句。SQL语句可以来源于 注解 / XML文件，这里我们对其进行简单实现：

 /**
  * SQL 语句转换
  * @param sql        原始SQL
  * @param nameArgMap 名称-数值 Map 关联结构
  * @return 整合SQL语句
  */
public static String parseSQL(String sql, Map<String, Object> nameArgMap) {
    // 整合SQL语句
    StringBuilder parseSQL = new StringBuilder();
    // 记录原始SQL语句长度
    int length = sql.length();
    /* 循环：调整SQL语句 */
    for (int i = 0; i < length; i++) {
        // 获取当前SQL中选中字符
        char c = sql.charAt(i);
        // 若字符为 '#'：该部分需要处理
        if (c == '#') {
            // 获取后一字符
            int nextIndex = i + 1;
            char nextChar = sql.charAt(nextIndex);
            // 若字符不为'{'，抛异常：语句错误
            if (nextChar != '{') {
                throw new RuntimeException(String.format("这里应该为#{\n sql:%s\nindex:%d}"
                                                         , parseSQL.toString(), nextIndex));
            }
            //  '#{ }' 内名称
            StringBuilder args = new StringBuilder();
            // 获取新索引（即该参数后一字符索引）
            i = parseSQLArg(args, sql, nextIndex);
            //  '#{ }' 内名称
            String argName = args.toString();
            // 通过 名称、Map关联，从Map结构中提取参数值
            Object argValue = nameArgMap.get(argName);
            // 参数值判空，抛异常：无参数值
            if (Objects.isNull(argValue)) {
                throw new RuntimeException(String.format("找不到参数值:%s"
                                                         , argName));
            }
            // 拼接参数值
            parseSQL.append(argValue.toString());
            continue;
        }
        // 其余字符：直接拼接
        parseSQL.append(c);
    }
    // 返回整合后SQL语句
    return parseSQL.toString();
}

/**
  * SQL语句：提取 '#{ }' 内部名称
  * @param args      参数
  * @param sql       接收拼接SQL语句
  * @param nextIndex '#'后一字符索引，即'{'
  * @return '}'后一字符索引
  */
private static int parseSQLArg(StringBuilder args, String sql, int nextIndex) {
    nextIndex++;    // 向后，替换
    for (; nextIndex < sql.length(); nextIndex++) {
        // 获取字符
        char c = sql.charAt(nextIndex);
        // 流程未至 '}'：继续拼接
        if (c != '}') {
            args.append(c);
            continue;
        }
        // 流程至 '}' 结束
        if (c == '}') {
            return nextIndex;
        }
    }
    // 循环结束后，方法仍旧未返回，则抛出异常：无右括号
    throw new RuntimeException(String.format("缺少右括号\nindex:%d", nextIndex));
}

3.2 调用过程

3.2.1 创建代理实例

通过 JDK 动态代理，实现接口的相关方法，并调用 SQL的组装方法，从而实现对接口的代理。

// 通过 JDK 动态代理，实现接口的相关方法 <代理模式>
UserMapper userMapper = (UserMapper) Proxy.newProxyInstance(
    ProxyDemo.class.getClassLoader(),       // 实现接口类加载器
    new Class<?>[]{UserMapper.class},       // 创建接口class对象数组
    new InvocationHandler() {               // Handler匿名内部类
        /**
                     * 代理方法
                     * @param proxy     调用方法代理类实例
                     * @param method    代理实例所包含方法
                     * @param args      方法包含参数（数组）
                     * @return 可返回参数
                     */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 获取方法附加注解
            Select annotation = method.getAnnotation(Select.class);

            System.out.println(Arrays.toString(args));
            // 建立 名称-数值 Map 关联
            Map<String, Object> nameArgMap = buildMethodArgNameMap(method, args);

            // 注解判空
            if (Objects.nonNull(annotation)) {
                // 获取注解内 value 属性（数组）
                String[] value = annotation.value();
                // 取出原始SQL语句
                String sql = value[0];
                // SQL语句转换
                sql = parseSQL(sql, nameArgMap);

                System.err.println(sql);
                // 获取方法返回类型的方法
                // 1、无泛型
                System.out.println(method.getReturnType());
                // 2、有泛型
                System.out.println(method.getGenericReturnType());
            }
            // /// 对结果进行组装
            // /// 结果组装后，在此处返回即可
            return null;
        }
    });

3.2.2 调用代理相应方法

调用代理相应方法：

// 尝试调用方法
userMapper.selectUserList(1, "test");

最终我们完成SQL语句的拼装，只需调用重复代码，即可实现查询。

再根据有泛型的返回类型组装后，即可得到我们想要的结果。