源码分析系列教程（08） - 手写MyBatis（注解版）-阿里云开发者社区

代码已上传到GitHub，有兴趣的同学可以下载来看看：https://github.com/ylw-github/Java-CodeAnalysis-Demo

1. MyBatis相关核心知识

MyBatis和数据库的交互有两种方式：

使用传统的MyBatis提供的API；
使用Mapper接口；

1.1 使用Mapper接口

MyBatis 将配置文件中的每一个<mapper>节点抽象为一个 Mapper 接口：

根据MyBatis 的配置规范配置好后，通过SqlSession.getMapper(XXXMapper.class)方法，MyBatis 会根据相应的接口声明的方法信息，通过动态代理机制生成一个Mapper 实例，我们使用Mapper接口的某一个方法时，MyBatis会根据这个方法的方法名和参数类型，确定Statement Id，底层还是通过SqlSession.select("statementId",parameterObject);或者SqlSession.update("statementId",parameterObject); 等等来实现对数据库的操作，MyBatis引用Mapper 接口这种调用方式，纯粹是为了满足面向接口编程的需要。（其实还有一个原因是在于，面向接口的编程，使得用户在接口上可以使用注解来配置SQL语句，这样就可以脱离XML配置文件，实现“0配置”）。

1.2 数据处理层

数据处理层可以说是MyBatis的核心，从大的方面上讲，它要完成两个功能：

通过传入参数构建动态SQL语句；
SQL语句的执行以及封装查询结果集成 List<E>；

1.3 框架支撑层

1.3.1 事务管理机制

事务管理机制对于ORM框架而言是不可缺少的一部分，事务管理机制的质量也是考量一个ORM框架是否优秀的一个标准。

1.3.2 连接池管理机制

由于创建一个数据库连接所占用的资源比较大，对于数据吞吐量大和访问量非常大的应用而言，连接池的设计就显得非常重要。

1.3.3 缓存机制

为了提高数据利用率和减小服务器和数据库的压力，MyBatis 会对于一些查询提供会话级别的数据缓存，会将对某一次查询，放置到SqlSession 中，在允许的时间间隔内，对于完全相同的查询，MyBatis会直接将缓存结果返回给用户，而不用再到数据库中查找。

1.4 SQL语句的配置方式

传统的MyBatis 配置SQL语句方式就是使用XML文件进行配置的，但是这种方式不能很好地支持面向接口编程的理念，为了支持面向接口的编程，MyBatis 引入了Mapper接口的概念，面向接口的引入，对使用注解来配置SQL语句成为可能，用户只需要在接口上添加必要的注解即可，不用再去配置XML文件了。

但是，目前的MyBatis 只是对注解配置SQL语句提供了有限的支持，某些高级功能还是要依赖XML配置文件配置SQL 语句。

1.5 引导层

引导层是配置和启动MyBatis配置信息的方式。MyBatis 提供两种方式来引导MyBatis ：

基于XML配置文件的方式
基于Java API 的方式。

1.6 主要构件及其相互关系

从MyBatis代码实现的角度来看，MyBatis的主要的核心部件有以下几个：

SqlSession：作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能；
Executor：MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护；
StatementHandler：封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合。
ParameterHandler：负责对用户传递的参数转换成JDBC Statement 所需要的参数；
ResultSetHandler：负责将JDBC返回的ResultSet结果集对象转换成List类型的集合；
TypeHandler：负责java数据类型和jdbc数据类型之间的映射和转换；
MappedStatement：MappedStatement维护了一条<select|update|delete|insert>节点的封装；
SqlSource：负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装BoundSql对象中，并返回；
BoundSql：表示动态生成的SQL语句以及相应的参数信息；
Configuration：MyBatis所有的配置信息都维持在Configuration对象之中；

2. 手写MyBatis代码

1.定义JDBCUtils：

package com.ylw.mybatis.orm.utils;
import java.sql.*;
import java.util.List;
public final class JDBCUtils {
  private static String connect;
  private static String driverClassName;
  private static String URL;
  private static String username;
  private static String password;
  private static boolean autoCommit;
  /** 声明一个 Connection类型的静态属性，用来缓存一个已经存在的连接对象 */
  private static Connection conn;
  static {
    config();
  }
  /**
   * 开头配置自己的数据库信息
   */
  private static void config() {
    /*
     * 获取驱动
     */
    driverClassName = "com.mysql.jdbc.Driver";
    /*
     * 获取URL
     */
    URL = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8";
    /*
     * 获取用户名
     */
    username = "root";
    /*
     * 获取密码
     */
    password = "123456";
    /*
     * 设置是否自动提交，一般为false不用改
     */
    autoCommit = false;
  }
  /**
   * 载入数据库驱动类
   */
  private static boolean load() {
    try {
      Class.forName(driverClassName);
      return true;
    } catch (ClassNotFoundException e) {
      System.out.println("驱动类 " + driverClassName + " 加载失败");
    }
    return false;
  }
  /**
   * 专门检查缓存的连接是否不可以被使用 ，不可以被使用的话，就返回 true
   */
  private static boolean invalid() {
    if (conn != null) {
      try {
        if (conn.isClosed() || !conn.isValid(3)) {
          return true;
          /*
           * isValid方法是判断Connection是否有效,如果连接尚未关闭并且仍然有效，则返回 true
           */
        }
      } catch (SQLException e) {
        e.printStackTrace();
      }
      /*
       * conn 既不是 null 且也没有关闭 ，且 isValid 返回 true，说明是可以使用的 ( 返回 false )
       */
      return false;
    } else {
      return true;
    }
  }
  /**
   * 建立数据库连接
   */
  public static Connection connect() {
    if (invalid()) { /* invalid为true时，说明连接是失败的 */
      /* 加载驱动 */
      load();
      try {
        /* 建立连接 */
        conn = DriverManager.getConnection(URL, username, password);
      } catch (SQLException e) {
        System.out.println("建立 " + connect + " 数据库连接失败 , " + e.getMessage());
      }
    }
    return conn;
  }
  /**
   * 设置是否自动提交事务
   **/
  public static void transaction() {
    try {
      conn.setAutoCommit(autoCommit);
    } catch (SQLException e) {
      System.out.println("设置事务的提交方式为 : " + (autoCommit ? "自动提交" : "手动提交") + " 时失败: " + e.getMessage());
    }
  }
  /**
   * 创建 Statement 对象
   */
  public static Statement statement() {
    Statement st = null;
    connect();
    /* 如果连接是无效的就重新连接 */
    transaction();
    /* 设置事务的提交方式 */
    try {
      st = conn.createStatement();
    } catch (SQLException e) {
      System.out.println("创建 Statement 对象失败: " + e.getMessage());
    }
    return st;
  }
  /**
   * 根据给定的带参数占位符的SQL语句，创建 PreparedStatement 对象
   * 
   * @param SQL
   *            带参数占位符的SQL语句
   * @return 返回相应的 PreparedStatement 对象
   */
  private static PreparedStatement prepare(String SQL, boolean autoGeneratedKeys) {
    PreparedStatement ps = null;
    connect();
    /* 如果连接是无效的就重新连接 */
    transaction();
    /* 设置事务的提交方式 */
    try {
      if (autoGeneratedKeys) {
        ps = conn.prepareStatement(SQL, Statement.RETURN_GENERATED_KEYS);
      } else {
        ps = conn.prepareStatement(SQL);
      }
    } catch (SQLException e) {
      System.out.println("创建 PreparedStatement 对象失败: " + e.getMessage());
    }
    return ps;
  }
  public static ResultSet query(String SQL, List<Object> params) {
    if (SQL == null || SQL.trim().isEmpty() || !SQL.trim().toLowerCase().startsWith("select")) {
      throw new RuntimeException("你的SQL语句为空或不是查询语句");
    }
    ResultSet rs = null;
    if (params.size() > 0) {
      /* 说明 有参数 传入，就需要处理参数 */
      PreparedStatement ps = prepare(SQL, false);
      try {
        for (int i = 0; i < params.size(); i++) {
          ps.setObject(i + 1, params.get(i));
        }
        rs = ps.executeQuery();
      } catch (SQLException e) {
        System.out.println("执行SQL失败: " + e.getMessage());
      }
    } else {
      /* 说明没有传入任何参数 */
      Statement st = statement();
      try {
        rs = st.executeQuery(SQL); // 直接执行不带参数的 SQL 语句
      } catch (SQLException e) {
        System.out.println("执行SQL失败: " + e.getMessage());
      }
    }
    return rs;
  }
  private static Object typeof(Object o) {
    Object r = o;
    if (o instanceof java.sql.Timestamp) {
      return r;
    }
    // 将 java.util.Date 转成 java.sql.Date
    if (o instanceof java.util.Date) {
      java.util.Date d = (java.util.Date) o;
      r = new java.sql.Date(d.getTime());
      return r;
    }
    // 将 Character 或 char 变成 String
    if (o instanceof Character || o.getClass() == char.class) {
      r = String.valueOf(o);
      return r;
    }
    return r;
  }
  public static boolean execute(String SQL, Object... params) {
    if (SQL == null || SQL.trim().isEmpty() || SQL.trim().toLowerCase().startsWith("select")) {
      throw new RuntimeException("你的SQL语句为空或有错");
    }
    boolean r = false;
    /* 表示 执行 DDL 或 DML 操作是否成功的一个标识变量 */
    /* 获得 被执行的 SQL 语句的 前缀 */
    SQL = SQL.trim();
    SQL = SQL.toLowerCase();
    String prefix = SQL.substring(0, SQL.indexOf(" "));
    String operation = ""; // 用来保存操作类型的 变量
    // 根据前缀 确定操作
    switch (prefix) {
    case "create":
      operation = "create table";
      break;
    case "alter":
      operation = "update table";
      break;
    case "drop":
      operation = "drop table";
      break;
    case "truncate":
      operation = "truncate table";
      break;
    case "insert":
      operation = "insert :";
      break;
    case "update":
      operation = "update :";
      break;
    case "delete":
      operation = "delete :";
      break;
    }
    if (params.length > 0) { // 说明有参数
      PreparedStatement ps = prepare(SQL, false);
      Connection c = null;
      try {
        c = ps.getConnection();
      } catch (SQLException e) {
        e.printStackTrace();
      }
      try {
        for (int i = 0; i < params.length; i++) {
          Object p = params[i];
          p = typeof(p);
          ps.setObject(i + 1, p);
        }
        ps.executeUpdate();
        commit(c);
        r = true;
      } catch (SQLException e) {
        System.out.println(operation + " 失败: " + e.getMessage());
        rollback(c);
      }
    } else { // 说明没有参数
      Statement st = statement();
      Connection c = null;
      try {
        c = st.getConnection();
      } catch (SQLException e) {
        e.printStackTrace();
      }
      // 执行 DDL 或 DML 语句，并返回执行结果
      try {
        st.executeUpdate(SQL);
        commit(c); // 提交事务
        r = true;
      } catch (SQLException e) {
        System.out.println(operation + " 失败: " + e.getMessage());
        rollback(c); // 回滚事务
      }
    }
    return r;
  }
  /*
   * 
   * @param SQL 需要执行的 INSERT 语句
   * 
   * @param autoGeneratedKeys 指示是否需要返回由数据库产生的键
   * 
   * @param params 将要执行的SQL语句中包含的参数占位符的 参数值
   * 
   * @return 如果指定 autoGeneratedKeys 为 true 则返回由数据库产生的键； 如果指定 autoGeneratedKeys
   * 为 false 则返回受当前SQL影响的记录数目
   */
  public static int insert(String SQL, boolean autoGeneratedKeys, List<Object> params) {
    int var = -1;
    if (SQL == null || SQL.trim().isEmpty()) {
      throw new RuntimeException("你没有指定SQL语句，请检查是否指定了需要执行的SQL语句");
    }
    // 如果不是 insert 开头开头的语句
    if (!SQL.trim().toLowerCase().startsWith("insert")) {
      System.out.println(SQL.toLowerCase());
      throw new RuntimeException("你指定的SQL语句不是插入语句，请检查你的SQL语句");
    }
    // 获得 被执行的 SQL 语句的 前缀 ( 第一个单词 )
    SQL = SQL.trim();
    SQL = SQL.toLowerCase();
    if (params.size() > 0) { // 说明有参数
      PreparedStatement ps = prepare(SQL, autoGeneratedKeys);
      Connection c = null;
      try {
        c = ps.getConnection(); // 从 PreparedStatement 对象中获得 它对应的连接对象
      } catch (SQLException e) {
        e.printStackTrace();
      }
      try {
        for (int i = 0; i < params.size(); i++) {
          Object p = params.get(i);
          p = typeof(p);
          ps.setObject(i + 1, p);
        }
        int count = ps.executeUpdate();
        if (autoGeneratedKeys) { // 如果希望获得数据库产生的键
          ResultSet rs = ps.getGeneratedKeys(); // 获得数据库产生的键集
          if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
            var = rs.getInt(1); // 获得值并赋值给 var 变量
          }
        } else {
          var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
        }
        commit(c);
      } catch (SQLException e) {
        System.out.println("数据保存失败: " + e.getMessage());
        rollback(c);
      }
    } else { // 说明没有参数
      Statement st = statement();
      Connection c = null;
      try {
        c = st.getConnection(); // 从 Statement 对象中获得 它对应的连接对象
      } catch (SQLException e) {
        e.printStackTrace();
      }
      // 执行 DDL 或 DML 语句，并返回执行结果
      try {
        int count = st.executeUpdate(SQL);
        if (autoGeneratedKeys) { // 如果企望获得数据库产生的键
          ResultSet rs = st.getGeneratedKeys(); // 获得数据库产生的键集
          if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
            var = rs.getInt(1); // 获得值并赋值给 var 变量
          }
        } else {
          var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
        }
        commit(c); // 提交事务
      } catch (SQLException e) {
        System.out.println("数据保存失败: " + e.getMessage());
        rollback(c); // 回滚事务
      }
    }
    return var;
  }
  /** 提交事务 */
  private static void commit(Connection c) {
    if (c != null && !autoCommit) {
      try {
        c.commit();
      } catch (SQLException e) {
        e.printStackTrace();
      }
    }
  }
  /** 回滚事务 */
  private static void rollback(Connection c) {
    if (c != null && !autoCommit) {
      try {
        c.rollback();
      } catch (SQLException e) {
        e.printStackTrace();
      }
    }
  }
  /**
   * 释放资源
   **/
  public static void release(Object cloaseable) {
    if (cloaseable != null) {
      if (cloaseable instanceof ResultSet) {
        ResultSet rs = (ResultSet) cloaseable;
        try {
          rs.close();
        } catch (SQLException e) {
          e.printStackTrace();
        }
      }
      if (cloaseable instanceof Statement) {
        Statement st = (Statement) cloaseable;
        try {
          st.close();
        } catch (SQLException e) {
          e.printStackTrace();
        }
      }
      if (cloaseable instanceof Connection) {
        Connection c = (Connection) cloaseable;
        try {
          c.close();
        } catch (SQLException e) {
          e.printStackTrace();
        }
      }
    }
  }
}

2.定义MyInvocationHandlerMbatis

package com.ylw.mybatis.orm.mybatis.aop;
import com.ylw.mybatis.orm.annotation.ExtInsert;
import com.ylw.mybatis.orm.annotation.ExtParam;
import com.ylw.mybatis.orm.annotation.ExtSelect;
import com.ylw.mybatis.orm.utils.JDBCUtils;
import com.ylw.mybatis.orm.utils.SQLUtils;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
public class MyInvocationHandlerMbatis implements InvocationHandler {
  private Object object;
  public MyInvocationHandlerMbatis(Object object) {
    this.object = object;
  }
  // proxy 代理对象 method拦截方法 args方法上的参数值
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("使用动态代理技术拦截接口方法开始");
    // 使用白话问翻译,@ExtInsert封装过程
    // 1. 判断方法上是否存在@ExtInsert
    ExtInsert extInsert = method.getDeclaredAnnotation(ExtInsert.class);
    if (extInsert != null) {
      return extInsert(extInsert, proxy, method, args);
    }
    // 2.查询的思路
    // 1. 判断方法上是否存 在注解
    ExtSelect extSelect = method.getDeclaredAnnotation(ExtSelect.class);
    if (extSelect != null) {
      // 2. 获取注解上查询的SQL语句
      String selectSQL = extSelect.value();
      // 3. 获取方法上的参数,绑定在一起
      ConcurrentHashMap<Object, Object> paramsMap = paramsMap(proxy, method, args);
      // 4. 参数替换？传递方式
      List<String> sqlSelectParameter = SQLUtils.sqlSelectParameter(selectSQL);
      // 5.传递参数
      List<Object> sqlParams = new ArrayList<>();
      for (String parameterName : sqlSelectParameter) {
        Object parameterValue = paramsMap.get(parameterName);
        sqlParams.add(parameterValue);
      }
      // 6.将sql语句替换成?
      String newSql = SQLUtils.parameQuestion(selectSQL, sqlSelectParameter);
      System.out.println("newSQL:" + newSql + ",sqlParams:" + sqlParams.toString());
      // 5.调用jdbc代码底层执行sql语句
      // 6.使用反射机制实例对象### 获取方法返回的类型，进行实例化
      // 思路:
      // 1.使用反射机制获取方法的类型
      // 2.判断是否有结果集,如果有结果集，在进行初始化
      // 3.使用反射机制,给对象赋值
      ResultSet res = JDBCUtils.query(newSql, sqlParams);
      // 判断是否存在值
      if (!res.next()) {
        return null;
      }
      // 下标往上移动移位
      res.previous();
      // 使用反射机制获取方法的类型
      Class<?> returnType = method.getReturnType();
      Object object = returnType.newInstance();
      while (res.next()) {
        // 获取当前所有的属性
        Field[] declaredFields = returnType.getDeclaredFields();
        for (Field field : declaredFields) {
          String fieldName = field.getName();
          Object fieldValue = res.getObject(fieldName);
          field.setAccessible(true);
          field.set(object, fieldValue);
        }
        // for (String parameteName : sqlSelectParameter) {
        // // 获取参数值
        // Object resultValue = res.getObject(parameteName);
        // // 使用java的反射值赋值
        // Field field = returnType.getDeclaredField(parameteName);
        // // 私有方法允许访问
        // field.setAccessible(true);
        // field.set(object, resultValue);
        // }
      }
      return object;
    }
    return null;
  }
  private Object extInsert(ExtInsert extInsert, Object proxy, Method method, Object[] args) {
    // 方法上存在@ExtInsert,获取他的SQL语句
    // 2. 获取SQL语句,获取注解Insert语句
    String insertSql = extInsert.value();
    // System.out.println("insertSql:" + insertSql);
    // 3. 获取方法的参数和SQL参数进行匹配
    // 定一个一个Map集合 KEY为@ExtParamValue,Value 结果为参数值
    ConcurrentHashMap<Object, Object> paramsMap = paramsMap(proxy, method, args);
    // 存放sql执行的参数---参数绑定过程
    String[] sqlInsertParameter = SQLUtils.sqlInsertParameter(insertSql);
    List<Object> sqlParams = sqlParams(sqlInsertParameter, paramsMap);
    // 4. 根据参数替换参数变为?
    String newSQL = SQLUtils.parameQuestion(insertSql, sqlInsertParameter);
    System.out.println("newSQL:" + newSQL + ",sqlParams:" + sqlParams.toString());
    // 5. 调用jdbc底层代码执行语句
    return JDBCUtils.insert(newSQL, false, sqlParams);
  }
  private List<Object> sqlParams(String[] sqlInsertParameter, ConcurrentHashMap<Object, Object> paramsMap) {
    List<Object> sqlParams = new ArrayList<>();
    for (String paramName : sqlInsertParameter) {
      Object paramValue = paramsMap.get(paramName);
      sqlParams.add(paramValue);
    }
    return sqlParams;
  }
  private ConcurrentHashMap<Object, Object> paramsMap(Object proxy, Method method, Object[] args) {
    ConcurrentHashMap<Object, Object> paramsMap = new ConcurrentHashMap<>();
    // 获取方法上的参数
    Parameter[] parameters = method.getParameters();
    for (int i = 0; i < parameters.length; i++) {
      Parameter parameter = parameters[i];
      ExtParam extParam = parameter.getDeclaredAnnotation(ExtParam.class);
      if (extParam != null) {
        // 参数名称
        String paramName = extParam.value();
        Object paramValue = args[i];
        // System.out.println(paramName + "," + paramValue);
        paramsMap.put(paramName, paramValue);
      }
    }
    return paramsMap;
  }
  public Object extInsertSQL() {
    return object;
  }
}

3.定义SQLUtils

package com.ylw.mybatis.orm.utils;
import java.util.ArrayList;
import java.util.List;
/**
 * SQL拼接<br>
 */
public class SQLUtils {
  /**
   * 
   * 获取Insert语句后面values 参数信息<br>
   * @param sql
   * @return
   */
  public static String[] sqlInsertParameter(String sql) {
    int startIndex = sql.indexOf("values");
    int endIndex = sql.length();
    String substring = sql.substring(startIndex + 6, endIndex).replace("(", "").replace(")", "").replace("#{", "")
        .replace("}", "");
    String[] split = substring.split(",");
    return split;
  }
  /**
   * 
   * 获取select 后面where语句
   *
   * @param sql
   * @return
   */
  public static List<String> sqlSelectParameter(String sql) {
    int startIndex = sql.indexOf("where");
    int endIndex = sql.length();
    String substring = sql.substring(startIndex + 5, endIndex);
    String[] split = substring.split("and");
    List<String> listArr = new ArrayList<>();
    for (String string : split) {
      String[] sp2 = string.split("=");
      listArr.add(sp2[0].trim());
    }
    return listArr;
  }
  /**
   * 将SQL语句的参数替换变为?<br>
   * 
   * @param sql
   * @param parameterName
   * @return
   */
  public static String parameQuestion(String sql, String[] parameterName) {
    for (int i = 0; i < parameterName.length; i++) {
      String string = parameterName[i];
      sql = sql.replace("#{" + string + "}", "?");
    }
    return sql;
  }
  public static String parameQuestion(String sql, List<String> parameterName) {
    for (int i = 0; i < parameterName.size(); i++) {
      String string = parameterName.get(i);
      sql = sql.replace("#{" + string + "}", "?");
    }
    return sql;
  }
}

4.单元测试

@Test
public void test() throws SQLException {
    UserMapper userMapper = SqlSession.getMapper(UserMapper.class);
    User selectUser = userMapper.selectUser("Dumas", "26");
    System.out.println(
            "结果:" + selectUser.getNAME() + "," + selectUser.getAge());
}

运行结果：

手写MyBatis教程中，也有xml手写版，可以参考：https://blog.csdn.net/qq_35859844/article/details/86688098

源码分析系列教程（08） - 手写MyBatis（注解版）

1. MyBatis相关核心知识

1.1 使用Mapper接口

1.2 数据处理层

1.3 框架支撑层

1.3.1 事务管理机制

1.3.2 连接池管理机制

1.3.3 缓存机制

1.4 SQL语句的配置方式

1.5 引导层

1.6 主要构件及其相互关系

2. 手写MyBatis代码

总结

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

源码分析系列教程（08） - 手写MyBatis（注解版）

1. MyBatis相关核心知识

1.1 使用Mapper接口

1.2 数据处理层

1.3 框架支撑层

1.3.1 事务管理机制

1.3.2 连接池管理机制

1.3.3 缓存机制

1.4 SQL语句的配置方式

1.5 引导层

1.6 主要构件及其相互关系

2. 手写MyBatis代码

总结

热门文章

最新文章

相关课程

相关电子书