第二章 MyBatis源码骨架分析笔记

柔情只为你懂 2024-04-18 04:24 80阅读 0赞

# **一、MyBatis 源码概述** #

### **1、怎么下载MyBatis源码？** ###

MyBatis 源码下载地址：[https://github.com/MyBatis/MyBatis-3][https_github.com_MyBatis_MyBatis-3]建议直接用网盘里的源码包

源码包导入过程：

*  下载MyBatis的源码
 *  检查 maven 的版本，必须是3.25以上，建议使用maven的最新版本
 *  MyBatis 的工程是maven工程，在开发工具中导入，工程必须使用 jdk1.8以上版本；
 *  把MyBatis源码的pom文件中<optional>true</optional>，全部改为 false；
 *  在工程目录下执行mvn clean install -Dmaven.test.skip=true,将当前工程安装到本地仓库（pdf 插件报错的话，需要将这个插件屏蔽）。

注意：安装过程中会可能会有很多异常信息，只要不中断运行，请耐心等待；其他工程依赖此工程

### **2、源码架构分** ###

MyBatis 源码共 16 个模块，可以分成三层，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70][]

基础支撑层：技术组件专注于底层技术实现，通用性较强无业务含义；

核心处理层：业务组件专注 MyBatis 的业务流程实现，依赖于基础支撑层； 接口层：MyBatis 对外提供的访问接口，面向 SqlSession 编程；

**思考题：系统为什么要分层？**

**1）****代码和系统的可维护性更高****：**

系统分层之后，每个层次都有自己的定位，每个层次内部的组件都有自己的分工，系统就会变得很清晰，维护起来非常明确；

**2）****方便开发团队分工和开发效率的提升****：**

举个例子，mybatis 这么大的一个源码框架不可能是一个人开发的，他需要一个团队，团队之间肯定有分工，既然有了层次的划分，分工也会变得容易，开发人员可以专注于某一层的某一个模块的实现，专注力提升了，开发效率自然也会提升；

**3）****提高系统的伸缩性和性能****：**

系统分层之后，我们只要把层次之间的调用接口明确了，那我们就可以从逻辑上的分层变成物理上的分层。当系统并发量吞吐量上来了，怎么办？ 为了提高系统伸缩性和性能，我们可以把不同的层部署在不同服务器集群上，不同的组件放在不同的机器上，用多台机器去抗压力，这就提高了系统的性能。压力大的时候扩展节点加机器，压力小的时候，压缩节点减机器，系统的伸缩性就是这么来的；

### **3、外观模式（门面模式）** ###

从源码的架构分析，特别是接口层的设计，可以看出来MyBatis 的整体架构符合门面模式的。门面模式定义：提供了一个统一的接口，用来访问子系统中的一群接口。外观模式定义了一个高层接口，让子系统更容易使用。类图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1][]

Facade 角色：提供一个外观接口，对外，它提供一个易于客户端访问的接 口，对内，它可以访问子系统中的所有功能。SubSystem（子系统）角色：子系统在整个系统中可以是一个或多个模块， 每个模块都有若干类组成，这些类可能相互之间有着比较复杂的关系。

**门面模式优点：**使复杂子系统的接口变的简单可用，减少了客户端对子系统的依赖，达到了解耦的效果；遵循了 OO 原则中的迪米特法则，对内封装具体细节，对外只暴露必要的接口。

**门面模式使用场景：**

一个复杂的模块或子系统提供一个供外界访问的接口

子系统相对独立 ― 外界对子系统的访问只要黑箱操作即可

### **4、面向对象设计需要遵循的六大设计原则** ###

学习源码的目的除了学习编程的技巧、经验之外，最重要的是学习源码的设计的思想以及设计模式的灵活应用，因此在学习源码之前有必要对面向对象设计的几个原则先深入的去了解，让自己具备良好的设计思想和理念；

**1）****单一职责原则：**一个类或者一个接口只负责唯一项职责，尽量设计出功能单一的接口；

**2）****依赖倒转原则：**高层模块不应该依赖低层模块具体实现，解耦高层与低层。既面向接口编程，当实现发生变化时，只需提供新的实现类，不需要修改高层模块代码;

**3）****开放-封闭原则**：程序对外扩展开放，对修改关闭；换句话说，当需求发生变化时， 我们可以通过添加新模块来满足新需求，而不是通过修改原来的实现代码来满足新需求；

**4）****迪米特法则：**一个对象应该对其他对象保持最少的了解，尽量降低类与类之间的耦合度；实现这个原则，要注意两个点，一方面在做类结构设计的时候尽量降低成员的访问权限，能用 private 的尽量用 private；另外在类之间，如果没有必要直接调用，就不要有依赖关系；这个法则强调的还是类之间的松耦合；

**5）****里氏代换原则**：所有引用基类（父类）的地方必须能透明地使用其子类的对象；

**6）****接口隔离原则：**客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上；

扩展知识：Lison老师2019年8月6号的公开课《这样Code迅速脱单》，其中讲到的代码优化技巧归根究底就是在遵循单一职责原则和迪米特法则。

# **二、日志模块分析** #

### **1、日志模块需求分析** ###

1）MyBatis 没有提供日志的实现类，需要接入第三方的日志组件，但第三方日志组件都有各自的 Log 级别，且各不相同，而MyBatis 统一提供了 trace、debug、warn、error 四个级别；

2）自动扫描日志实现，并且第三方日志插件加载优先级如下：slf4J → commonsLoging →Log4J2 → Log4J → JdkLog;

3）日志的使用要优雅的嵌入到主体功能中；

### **2、适配器模式** ###

日志模块的第一个需求是一个典型的使用适配器模式的场景，适配器模式（Adapter Pattern） 是作为两个不兼容的接口之间的桥梁，将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作；类图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2][]

*  Target：目标角色,期待得到的接口.
 *  将源接口转换成目标接口.
 *  Adapter：适配器角色,
 *  被适配的接口.
 *  Adaptee：适配者角色,

**适用场景：**当调用双方都不太容易修改的时候，为了复用现有组件可以使用适配器模式；在系统中接入第三方组件的时候经常被使用到；注意：如果系统中存在过多的适配器，会增加系统的复杂性，设计人员应考虑对系统进行重构；

**MyBatis 日志模块是怎么使用适配器模式？实现如下：**

Target：目标角色,期待得到的接口。org.apache.ibatis.logging.Log 接口，对内提供了统一的日志接口；

Adaptee：适配者角色,被适配的接口。其他日志组件组件如 slf4J、commonsLoging、Log4J2 等被包含在适配器中。

Adapter：适配器角色,将源接口转换成目标接口。针对每个日志组件都提供了适配器， 每 个 适 配 器 都 对 特 定 的 日 志 组 件 进 行 封 装 和 转 换 ； 如 Slf4jLoggerImpl 、JakartaCommonsLoggingImpl 等；

日志模块适配器结构类图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3][]

**总结：**

日志模块实现采用适配器模式，日志组件（Target）、适配器以及统一接口（Log 接口）定义清晰明确符合单一职责原则；同时，客户端在使用日志时，面向 Log 接口编程，不需要关心底层日志模块的实现，符合依赖倒转原则；最为重要的是，如果需要加入其他第三方日志框架，只需要扩展新的模块满足新需求，而不需要修改原有代码，这又符合了开闭原则。

### **3、怎么实现优先加载日志组件？** ###

见 org.apache.ibatis.logging.LogFactory 中的静态代码块，通过静态代码块确保第三方日志插件加载优先级如下：slf4J → commonsLoging → Log4J2 → Log4J → JdkLog;

public final class LogFactory {
      /**
       * Marker to be used by logging implementations that support markers
       */
      public static final String MARKER = "MYBATIS";
      //被选定的第三方日志组件适配器的构造方法
      private static Constructor<? extends Log> logConstructor;
      //自动扫描日志实现，并且第三方日志插件加载优先级如下：slf4J → commonsLoging → Log4J2 → Log4J → JdkLog
      static {
        tryImplementation(LogFactory::useSlf4jLogging);
        tryImplementation(LogFactory::useCommonsLogging);
        tryImplementation(LogFactory::useLog4J2Logging);
        tryImplementation(LogFactory::useLog4JLogging);
        tryImplementation(LogFactory::useJdkLogging);
        tryImplementation(LogFactory::useNoLogging);
      }
      private LogFactory() {
        // disable construction
      }

# **三、代理模式和动态代理** #

代理模式定义：给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用；目的：

1）通过引入代理对象的方式来间接访问目标对象，防止直接访问目标对象给系统带来的不必要复杂性；

2）通过代理对象对原有的业务增强；

代理模式类图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4][]

代理模式有静态代理和动态代理两种实现方式。

### **1、静态代理** ###

这种代理方式需要代理对象和目标对象实现一样的接口。

**优点：**可以在不修改目标对象的前提下扩展目标对象的功能。

**缺点：**

*  冗余：由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
 *  不易维护：一旦接口增加方法，目标对象与代理对象都要进行修改。

### **2、动态代理** ###

动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。

动态代理又被称为JDK 代理或接口代理。静态代理与动态代理的区别主要在：

*  静态代理在编译时就已经实现，编译完成后代理类是一个实际的 class 文件
 *  动态代理是在运行时动态生成的，即编译完成后没有实际的 class 文件，而是在运行时动态生成类字节码，并加载到 JVM 中

注意：动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。

JDK 中生成代理对象主要涉及两个类，第一个类为 java.lang.reflect.Proxy，通过静态方法newProxyInstance 生成代理对象，第二个为 java.lang.reflect.InvocationHandler 接口，通过invoke 方法对业务进行增强；

### **3、优雅的增强日志功能** ###

首先搞清楚那些地方需要打印日志？通过对日志的观察，如下几个位置需要打日志：

1）在创建 prepareStatement 时，打印执行的 SQL 语句；

2）访问数据库时，打印参数的类型和值

3）查询出结构后，打印结果数据条数

因此在日志模块中有 BaseJdbcLogger 、ConnectionLogger 、PreparedStatementLogger 和

ResultSetLogge 通过动态代理负责在不同的位置打印日志；几个相关类的类图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 5][]

BaseJdbcLogger：所有日志增强的抽象基类，用于记录JDBC那些方法需要增强，保存运行期间sql参数信息；

ConnectionLogger：负责打印连接信息和SQL语句。通过动态代理，对connection进行增强，如果是调用 prepareStatement、prepareCall、createStatement的方法，打印要执行的sql语句并返回prepareStatement的代理对象（PreparedStatementLogger），让prepareStatement也具备日志能力，打印参数；

PreparedStatementLogger：对prepareStatement对象增强，增强的点如下：

1）增强 PreparedStatement的setxxx方法将参数设置到columnMap、columnNames、columnValues，为打印参数做好准备。

public final class ConnectionLogger extends BaseJdbcLogger implements InvocationHandler {
    
    @Override
    //对连接的增强
    public Object invoke(Object proxy, Method method, Object[] params)
        throws Throwable {
      try {
       //如果是从Obeject继承的方法直接忽略
        if (Object.class.equals(method.getDeclaringClass())) {
          return method.invoke(this, params);
        }
        //如果是调用prepareStatement、prepareCall、createStatement的方法，打印要执行的sql语句
        //并返回prepareStatement的代理对象，让prepareStatement也具备日志能力，打印参数
        if ("prepareStatement".equals(method.getName())) {
          if (isDebugEnabled()) {
            debug(" Preparing: " + removeBreakingWhitespace((String) params[0]), true);//打印sql语句
          }        
          PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
          stmt = PreparedStatementLogger.newInstance(stmt, statementLog, queryStack);//创建代理对象
          return stmt;
        } else if ("prepareCall".equals(method.getName())) {
          if (isDebugEnabled()) {
            debug(" Preparing: " + removeBreakingWhitespace((String) params[0]), true);//打印sql语句
          }        
          PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);//创建代理对象
          stmt = PreparedStatementLogger.newInstance(stmt, statementLog, queryStack);
          return stmt;
        } else if ("createStatement".equals(method.getName())) {
          Statement stmt = (Statement) method.invoke(connection, params);
          stmt = StatementLogger.newInstance(stmt, statementLog, queryStack);//创建代理对象
          return stmt;
        } else {
          return method.invoke(connection, params);
        }
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    /*
     * Creates a logging version of a connection
     */
    public static Connection newInstance(Connection conn, Log statementLog, int queryStack) {
      InvocationHandler handler = new ConnectionLogger(conn, statementLog, queryStack);
      ClassLoader cl = Connection.class.getClassLoader();
      return (Connection) Proxy.newProxyInstance(cl, new Class[]{Connection.class}, handler);
    }

2）增强PreparedStatement的execute相关方法，当方法执行时，通过动态代理打印参数,返回动态代理能力的resultSet；

public final class PreparedStatementLogger extends BaseJdbcLogger implements InvocationHandler {
    
    //1，增强PreparedStatement的setxxx方法将参数设置到columnMap、columnNames、columnValues，为打印参数做好准备
    //2. 增强PreparedStatement的execute相关方法，当方法执行时，通过动态代理打印参数,返回动态代理能力的resultSet
    //3. 如果是查询，增强PreparedStatement的getResultSet方法，返回动态代理能力的resultSet
    // 如果是更新，直接打印影响的行数
    @Override
    public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
      try {
        if (Object.class.equals(method.getDeclaringClass())) {
          return method.invoke(this, params);
        }          
        if (EXECUTE_METHODS.contains(method.getName())) {//增强PreparedStatement的execute相关方法
          if (isDebugEnabled()) {
            debug("Parameters: " + getParameterValueString(), true);//当方法执行时，通过动态代理打印参数
          }
          clearColumnInfo();
          if ("executeQuery".equals(method.getName())) {//返回动态代理能力的resultSet
            ResultSet rs = (ResultSet) method.invoke(statement, params);
            return rs == null ? null : ResultSetLogger.newInstance(rs, statementLog, queryStack);
          } else {
            return method.invoke(statement, params);
          }
        } else if (SET_METHODS.contains(method.getName())) {//将参数设置到columnMap、columnNames、columnValues，为打印参数做好准备
          if ("setNull".equals(method.getName())) {
            setColumn(params[0], null);
          } else {
            setColumn(params[0], params[1]);
          }
          return method.invoke(statement, params);
        } else if ("getResultSet".equals(method.getName())) {//返回动态代理能力的resultSet
          ResultSet rs = (ResultSet) method.invoke(statement, params);
          return rs == null ? null : ResultSetLogger.newInstance(rs, statementLog, queryStack);
        } else if ("getUpdateCount".equals(method.getName())) {//   如果是更新，直接打印影响的行数
          int updateCount = (Integer) method.invoke(statement, params);
          if (updateCount != -1) {
            debug("   Updates: " + updateCount, false);
          }
          return updateCount;
        } else {
          return method.invoke(statement, params);
        }
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    
    public static PreparedStatement newInstance(PreparedStatement stmt, Log statementLog, int queryStack) {
      InvocationHandler handler = new PreparedStatementLogger(stmt, statementLog, queryStack);
      ClassLoader cl = PreparedStatement.class.getClassLoader();
      return (PreparedStatement) Proxy.newProxyInstance(cl, new Class[]{PreparedStatement.class, CallableStatement.class}, handler);
    }

3）如果是查询，增强PreparedStatement的getResultSet方法，返回动态代理能力的

public final class ResultSetLogger extends BaseJdbcLogger implements InvocationHandler {
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
      try {
        if (Object.class.equals(method.getDeclaringClass())) {
          return method.invoke(this, params);
        }    
        Object o = method.invoke(rs, params);//执行result.next方法，判断是否还有数据
        if ("next".equals(method.getName())) {//如果还有数据，计数器rows加一
          if (((Boolean) o)) {
            rows++;
            if (isTraceEnabled()) {
              ResultSetMetaData rsmd = rs.getMetaData();
              final int columnCount = rsmd.getColumnCount();
              if (first) {
                first = false;
                printColumnHeaders(rsmd, columnCount);
              }
              printColumnValues(columnCount);
            }
          } else {
            debug(" Total: " + rows, false); // 如果没有数据了，打印rows，打印查询出来的数据条数
          }
        }
        clearColumnInfo();
        return o;
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }

resultSet：如果是更新，直接打印影响的行数

ResultSetLogge：负责打印数据结果信息；

最后一个问题：上面讲这么多，都是日志功能的实现，那日志功能是怎么加入主体功能的？ 答：既然在 Mybatis 中 Executor 才是访问数据库的组件，日志功能是在 Executor 中被嵌入的， 具体代码在

org.apache.ibatis.executor.SimpleExecutor.prepareStatement(StatementHandler, Log) 方法中，如下所示：

//创建Statement
    private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
      Statement stmt;
      //获取connection对象的动态代理，添加日志能力；
      Connection connection = getConnection(statementLog);
      //通过不同的StatementHandler，利用connection创建（prepare）Statement
      stmt = handler.prepare(connection, transaction.getTimeout());
      //使用parameterHandler处理占位符
      handler.parameterize(stmt);
      return stmt;
    }

### **4、Batis中那些地方需要打印日志？** ###

在创建prepareStatement时，打印执行的SQL语句；

访问数据库时，打印参数的类型和值

查询出结构后，打印结果数据条数

*  ConnectionLogger：负责打印连接信息和SQL语句，并创建PreparedStatementLogger；
 *  PreparedStatementLogger：负责打印参数信息，并创建ResultSetLogger
 *  ResultSetLogge：r负责打印数据结果信息；

## **四、基础支撑层源码分析** ##

常见的数据源组件都实现了javax.sql.DataSource接口；

MyBatis不但要能集成第三方的数据源组件，自身也提供了数据源的实现；

一般情况下，数据源的初始化过程参数较多，比较复杂；

### **1、工厂模式：** ###

工厂模式（Factory Pattern）属于创建型模式，它提供了一种创建对象的最佳方式。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行

工厂模式uml类图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 6][]

**产品接口（Product）：**产品接口用于定义产品类的功能，具体工厂类产生的所有产品都必须实现这个接口。调用者与产品接口直接交互，这是调用者最关心的接口。

**具体产品类（ConcreteProduct）：**实现产品接口的实现类，具体产品类中定义了具体的业务逻辑。

**工厂接口（Factory）：**工厂接口是工厂方法模式的核心接口，调用者会直接和工厂接口交互用于获取具体的产品实现类。

**具体工厂类（ConcreteFactory）:**是工厂接口的实现类，用于实例化产品对象，不同的具体工厂类会根据需求实例化不同的产品实现类。

### **2、数据源模块类图：** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 7][]

### **3、为什么要使用工厂模式？** ###

**创建对象的方式：**

*  使用new关键字直接创建对象；
 *  通过反射机制创建对象；
 *  通过工厂类创建对象；

**优点：**

*  把对象的创建和使用的过程分开，对象创建和对象使用使用的职责解耦。
 *  如果创建对象的过程很复杂，创建过程统一到工厂里管理，既减少了重复代码，也方便以后对创建过程的修改维护。
 *  当业务扩展时，只需要增加工厂子类，符合开闭原则。

**缺点****：**

*  对象创建和对象使用的职责耦合在一起，违反单一原则；
 *  当业务扩展时，必须修改代业务代码，违反了开闭原则；

**数据源连接池核心类****：**

PooledDataSource：一个简单，同步的、线程安全的数据库连接池

//使用连接池的数据源
    public class PooledDataSource implements DataSource {
      private static final Log log = LogFactory.getLog(PooledDataSource.class);
      private final PoolState state = new PoolState(this);
      private final UnpooledDataSource dataSource; //真正用于创建连接的数据源
      protected int poolMaximumActiveConnections = 10; //最大活跃连接数
      protected int poolMaximumIdleConnections = 5; //最大闲置连接数
      protected int poolMaximumCheckoutTime = 20000; //最大checkout时长（最长使用时间）
      protected int poolTimeToWait = 20000; //无法取得连接是最大的等待时间
      protected int poolMaximumLocalBadConnectionTolerance = 3; //最多允许几次无效连接
      //测试连接是否有效的sql语句
      protected String poolPingQuery = "NO PING QUERY SET";
      protected boolean poolPingEnabled; //是否允许测试连接
      //配置一段时间，当连接在这段时间内没有被使用，才允许测试连接是否有效
      protected int poolPingConnectionsNotUsedFor;
      //根据数据库url、用户名、密码生成一个hash值，唯一标识一个连接池，由这个连接池生成的连接都会带上这个值
      private int expectedConnectionTypeCode;

回收连接资源pushConnection()方法：

protected void pushConnection(PooledConnection conn) throws SQLException {
      synchronized (state) {
        //回收连接必须是同步的
        state.activeConnections.remove(conn);//从活跃连接池中删除此连接
        if (conn.isValid()) {
            //判断闲置连接池资源是否已经达到上限
          if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) {
           // 没有达到上限，进行回收
            state.accumulatedCheckoutTime += conn.getCheckoutTime();
            if (!conn.getRealConnection().getAutoCommit()) {
              conn.getRealConnection().rollback();//如果还有事务没有提交，进行回滚操作
            }
            // 基于该连接，创建一个新的连接资源，并刷新连接状态
            PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
            state.idleConnections.add(newConn);
            newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
            newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
            conn.invalidate(); //老连接失效
            if (log.isDebugEnabled()) {
              log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
            }
            // 唤醒其他被阻塞的线程
            state.notifyAll();
          } else {
            //如果闲置连接池已经达到上限了，将连接真实关闭
            state.accumulatedCheckoutTime += conn.getCheckoutTime();
            if (!conn.getRealConnection().getAutoCommit()) {
              conn.getRealConnection().rollback();
            }
            //关闭真的数据库连接
            conn.getRealConnection().close();
            if (log.isDebugEnabled()) {
              log.debug("Closed connection " + conn.getRealHashCode() + ".");
            }
            //将连接对象设置为无效
            conn.invalidate();
          }
        } else {
          if (log.isDebugEnabled()) {
            log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool,discarding connection.");
          }
          state.badConnectionCount++;
        }
      }
    }

**从连接池获取资源popConnection()：**

private PooledConnection popConnection(String username, String password) throws SQLException {
      boolean countedWait = false;
      PooledConnection conn = null;
      long t = System.currentTimeMillis();//记录尝试获取连接的起始时间戳
      int localBadConnectionCount = 0;//初始化获取到无效连接的次数
      while (conn == null) {
        synchronized (state) {//获取连接必须是同步的
          if (!state.idleConnections.isEmpty()) {//检测是否有空闲连接
            // Pool has available connection有空闲连接直接使用
            conn = state.idleConnections.remove(0);
            if (log.isDebugEnabled()) {
              log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
            }
          } else {// 没有空闲连接
    
            //判断活跃连接池中的数量是否大于最大连接数
            if (state.activeConnections.size() < poolMaximumActiveConnections) {
              // 没有则可创建新的连接
              conn = new PooledConnection(dataSource.getConnection(), this);
              if (log.isDebugEnabled()) {
                log.debug("Created connection " + conn.getRealHashCode() + ".");
              }
            } else {// 如果已经等于最大连接数，则不能创建新连接
              //获取最早创建的连接
              PooledConnection oldestActiveConnection = state.activeConnections.get(0);
              long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
              if (longestCheckoutTime > poolMaximumCheckoutTime) {//检测是否已经以及超过最长使用时间
                // 如果超时，对超时连接的信息进行统计
                state.claimedOverdueConnectionCount++;//超时连接次数+1
                state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;//累计超时时间增加
                state.accumulatedCheckoutTime += longestCheckoutTime;//累计的使用连接的时间增加
                state.activeConnections.remove(oldestActiveConnection);//从活跃队列中删除
                if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {//如果超时连接未提交，则手动回滚
                  try {
                    oldestActiveConnection.getRealConnection().rollback();
                  } catch (SQLException e) {//发生异常仅仅记录日志
                    log.debug("Bad connection. Could not roll back");
                  }  
                }
                //在连接池中创建新的连接，注意对于数据库来说，并没有创建新连接；
                conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
                conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
                conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
                //让老连接失效
                oldestActiveConnection.invalidate();
                if (log.isDebugEnabled()) {
                  log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
                }
              } else {// 无空闲连接，最早创建的连接没有失效，无法创建新连接，只能阻塞
                try {
                  if (!countedWait) {
                    state.hadToWaitCount++;//连接池累计等待次数加1
                    countedWait = true;
                  }
                  if (log.isDebugEnabled()) {
                    log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
                  }
                  long wt = System.currentTimeMillis();
                  state.wait(poolTimeToWait);//阻塞等待指定时间
                  state.accumulatedWaitTime += System.currentTimeMillis() - wt;//累计等待时间增加
                } catch (InterruptedException e) {
                  break;
                }
              }
            }
          }
          if (conn != null) {//获取连接成功的，要测试连接是否有效，同时更新统计数据
            // ping to server and check the connection is valid or not
            if (conn.isValid()) {//检测连接是否有效
              if (!conn.getRealConnection().getAutoCommit()) {
                conn.getRealConnection().rollback();//如果遗留历史的事务，回滚
              }
              //连接池相关统计信息更新
              conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
              conn.setCheckoutTimestamp(System.currentTimeMillis());
              conn.setLastUsedTimestamp(System.currentTimeMillis());
              state.activeConnections.add(conn);
              state.requestCount++;
              state.accumulatedRequestTime += System.currentTimeMillis() - t;
            } else {//如果连接无效
              if (log.isDebugEnabled()) {
                log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
              }
              state.badConnectionCount++;//累计的获取无效连接次数+1
              localBadConnectionCount++;//当前获取无效连接次数+1
              conn = null;
              //拿到无效连接，但如果没有超过重试的次数，允许再次尝试获取连接，否则抛出异常
              if (localBadConnectionCount > (poolMaximumIdleConnections + poolMaximumLocalBadConnectionTolerance)) {
                if (log.isDebugEnabled()) {
                  log.debug("PooledDataSource: Could not get a good connection to the database.");
                }
                throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
              }
            }
          }
        }
      }
      if (conn == null) {
        throw new SQLException("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
      }
      return conn;
    }

**PooledConnection：使用动态代理封装了真正的数据库连接对象；**

// 此方法专门用来增强数据库connect对象，使用前检查连接是否有效，关闭时对连接进行回收
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      String methodName = method.getName();
      if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
    
    //如果是调用连接的close方法，不是真正的关闭，而是回收到连接池
        dataSource.pushConnection(this);//通过pooled数据源来进行回收
        return null;
      } else {
        try {//使用前要检查当前连接是否有效
          if (!Object.class.equals(method.getDeclaringClass())) {
            checkConnection();//
          }
          return method.invoke(realConnection, args);
        } catch (Throwable t) {
          throw ExceptionUtil.unwrapThrowable(t);
        }
      }
    }
    private void checkConnection() throws SQLException {
      if (!valid) {
        throw new SQLException("Error accessing PooledConnection. Connection is invalid.");
      }
    }

**PoolState：用于管理PooledConnection对象状态的组件，通过两个list分别管理空闲状态的连接资源和活跃状态的连接资源**

public class PoolState {
      protected PooledDataSource dataSource;
      //空闲的连接池资源集合
      protected final List<PooledConnection> idleConnections = new ArrayList<>();
      //活跃的连接池资源集合
      protected final List<PooledConnection> activeConnections = new ArrayList<>();
      protected long requestCount = 0;//请求的次数
      protected long accumulatedRequestTime = 0;//累计的获得连接的时间
      //累计的使用连接的时间。从连接取出到归还，算一次使用的时间；
      protected long accumulatedCheckoutTime = 0;
      protected long claimedOverdueConnectionCount = 0; //使用连接超时的次数
      protected long accumulatedCheckoutTimeOfOverdueConnections = 0; //累计超时时间
      protected long accumulatedWaitTime = 0;  //累计等待时间
      protected long hadToWaitCount = 0;  //等待次数 
      protected long badConnectionCount = 0; //无效的连接次数

高频面试题：请详细描述从数据库连接池中获取一个连接资源的过程？

### **4、PooledDataSource获取和归还连接过程** ###

获取连接getConnection()方法：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 9][]

**pushConnection()****方法：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 10][]

### **5、缓存模块需求** ###

MyBatis缓存的实现是基于Map的，从缓存里面读写数据是缓存模块的核心基础功能；

除核心功能之外，有很多额外的附加功能，如：防止缓存击穿，添加缓存清空策略（fifo、lru）、序列化功能、日志能力、定时清空能力等；

附加功能可以以任意的组合附加到核心基础功能之上；

怎么样优雅的为核心功能添加多种附加能力？

使用动态代理或继承的办法扩展多种附加功能？

A：这些方式是静态的，用户不能控制增加行为的方式和时机。另外，新功能的存在多种组合，使用继承可能导致大量子类存在；

优化思路：装饰器模式是一种用于代替继承的技术，无需通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀；

## **五、装饰器模式** ##

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，是一种用于代替继承的技术，无需通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。

### **1、装饰器模式uml类图：** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 11][]

组件Component：组件接口定义了全部组件类和装饰器实现的行为。

组件实现类ConcreteComponent：实现Component接口，组件实现类就是被装饰器装饰的原始对象，新功能或者附加功能都是通过装饰器添加到该类的对象上的。

装饰器抽象类Decorator：实现Component接口的抽象类，在其中封装了一个Component 对象，也就是被装饰的对象。

具体装饰器类ConcreteDecorator：该实现类要向被装饰的对象添加某些功能。

### **2、装饰器模式使用图示：** ###

![20190903111951195.png][]

**优点****：**

相对于继承，装饰器模式灵活性更强，扩展性更强。

**灵活性：**装饰器模式将功能切分成一个个独立的装饰器，在运行期可以根据需要动态的添加功能，甚至对添加的新功能进行自由的组合。

**扩展性：**当有新功能要添加的时候，只需要添加新的装饰器实现类，然后通过组合方式添加这个新装饰器，无需修改已有代码，符合开闭原则。

### **3、装饰器模式使用举例：** ###

IO中输入流和输出流的设计：

BufferedReader bufferedReader=**new BufferedReader(new InputStreamReader(new FileInputStream("c://a.txt")));**

对网络爬虫的自定义增强，可增强的功能包括：多线程能力、缓存、自动生成报表、黑白名单、random触发等

### **4、MyBatis的缓存组件：** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 12][]

**装饰器模式使用举例****：**

**Cache：**Cache接口是缓存模块的核心接口，定义了缓存的基本操作。

**PerpetualCache：**在缓存模块中扮演ConcreteComponent角色，使用HashMap来实现cache的相关操作。

public class PerpetualCache implements Cache {
      private final String id;
      private Map<Object, Object> cache = new HashMap<>();
      public PerpetualCache(String id) {
        this.id = id;
      }

**BlockingCache：**阻塞版本的缓存装饰器，保证只有一个线程到数据库去查找指定的key对应的数据。

public class BlockingCache implements Cache {
      private long timeout; //阻塞的超时时长
      private final Cache delegate; //被装饰的底层对象，一般是PerpetualCache
      //锁对象集，粒度到key值
      private final ConcurrentHashMap<Object, ReentrantLock> locks;
      public BlockingCache(Cache delegate) {
        this.delegate = delegate;
        this.locks = new ConcurrentHashMap<>();
      }
      @Override
      public String getId() {return delegate.getId();}
      @Override
      public int getSize() { return delegate.getSize(); }
      @Override
      public void putObject(Object key, Object value) {
        try {
          delegate.putObject(key, value);
        } finally {
          releaseLock(key);
        }
      }
      @Override
      public Object getObject(Object key) {
        acquireLock(key);//根据key获得锁对象，获取锁成功加锁，获取锁失败阻塞一段时间重试
        Object value = delegate.getObject(key);
        if (value != null) {//获取数据成功的，要释放锁
          releaseLock(key);
        }        
        return value;
      }
      @Override
      public Object removeObject(Object key) { // despite of its name, this method is called only to release locks
        releaseLock(key);
        return null;
      }
      @Override
      public void clear() { delegate.clear(); }
      @Override
      public ReadWriteLock getReadWriteLock() {  return null;}
      private ReentrantLock getLockForKey(Object key) {
        ReentrantLock lock = new ReentrantLock();//创建锁
    
    //把新锁添加到locks集合中，如果添加成功使用新锁，如果添加失败则使用locks集合中的锁
        ReentrantLock previous = locks.putIfAbsent(key, lock);   
    
    return previous == null ? lock : previous;
      }
      //根据key获得锁对象，获取锁成功加锁，获取锁失败阻塞一段时间重试
      private void acquireLock(Object key) {
        Lock lock = getLockForKey(key); //获得锁对象
        if (timeout > 0) {//使用带超时时间的锁
          try {
            boolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS);
            if (!acquired) {//如果超时抛出异常
              throw new CacheException("Couldn't get a lock in " + timeout + " for the key " +  key +" at the cache " + delegate.getId());  
            }
          } catch (InterruptedException e) {
            throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e);
          }
        } else {//使用不带超时时间的锁
          lock.lock();
        }
      }
      private void releaseLock(Object key) {
        ReentrantLock lock = locks.get(key);
        if (lock.isHeldByCurrentThread()) {
          lock.unlock();
        }
      }
      public long getTimeout() { return timeout; }
      public void setTimeout(long timeout) { this.timeout = timeout; }  
    }

**缓存装饰器解读：**

*  FifoCache：先进先出缓存淘汰策略的缓存；
 *  LoggingCache：日志能力的缓存；
 *  ScheduledCache：定时清空的缓存；
 *  **BlockingCache：阻塞式缓存；**
 *  SerializedCache：序列化能力的缓存；
 *  SynchronizedCache：进行同步控制的缓存；

思考题：Mybatis的缓存功能使用HashMap实现会不会出现并发安全的问题？

**锁粒度的问题 粗粒度锁：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 13][]

**锁粒度的问题 细粒度锁(按key)：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 14][]

### **5、CacheKey解读：** ###

MyBatis中涉及到动态SQL的原因，缓存项的key不能仅仅通过一个String来表示，所以通过CacheKey来封装缓存的Key值，CacheKey可以封装多个影响缓存项的因素；判断两个CacheKey是否相同关键是比较两个对象的hash值是否一致。

**5.1、构成CacheKey的对象：**

*  mappedStatment的id
 *  指定查询结果集的范围（分页信息）
 *  查询所使用的SQL语句
 *  用户传递给SQL语句的实际参数值

public class CacheKey implements Cloneable, Serializable {
      public static final CacheKey NULL_CACHE_KEY = new NullCacheKey();
      private static final int DEFAULT_MULTIPLYER = 37;
      private static final int DEFAULT_HASHCODE = 17;
      private final int multiplier;//参与hash计算的乘数
      private int hashcode;//CacheKey的hash值，在update函数中实时运算出来的
      private long checksum;//校验和，hash值的和
      private int count;//updateList的中元素个数
      //该集合中的元素觉得两个CacheKey是否相等
      private List<Object> updateList;
      public CacheKey() {
        this.hashcode = DEFAULT_HASHCODE;
        this.multiplier = DEFAULT_MULTIPLYER;
        this.count = 0;
        this.updateList = new ArrayList<>();
      }

**5.2、重点解读方法：**

**update(Object obj)方法实现：**

public void update(Object object) {
       //获取object的hash值
       int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object); 
       //更新count、checksum以及hashcode的值
       count++;
       checksum += baseHashCode;
       baseHashCode *= count;
       hashcode = multiplier * hashcode + baseHashCode;
       //将对象添加到updateList中
       updateList.add(object);
     }

**equals(Object obj)方法：**

@Override
    public boolean equals(Object object) {
      if (this == object) {//比较是不是同一个对象
        return true;
      }
      if (!(object instanceof CacheKey)) {//是否类型相同
        return false;
      }
      final CacheKey cacheKey = (CacheKey) object;
      if (hashcode != cacheKey.hashcode) {//hashcode是否相同
        return false;
      }
      if (checksum != cacheKey.checksum) {//checksum是否相同
        return false;
      }
      if (count != cacheKey.count) {//count是否相同
        return false;
      }
      //以上都不相同，才按顺序比较updateList中元素的hash值是否一致
      for (int i = 0; i < updateList.size(); i++) {
        Object thisObject = updateList.get(i);
        Object thatObject = cacheKey.updateList.get(i);
        if (!ArrayUtil.equals(thisObject, thatObject)) {
          return false;
        }
      }
      return true;
    }

**二级缓存入口：**

**org.apache.ibatis.executor.CachingExecutor.query(MappedStatement, Object, RowBounds, ResultHandler)。**

public class CachingExecutor implements Executor {
      private final Executor delegate;
      private final TransactionalCacheManager tcm = new TransactionalCacheManager();
    
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler
    
    resultHandler) throws SQLException {
    
    //获取sql语句信息，包括占位符，参数等信息
      BoundSql boundSql = ms.getBoundSql(parameterObject);
     //拼装缓存的key值
       CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
       return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
     }
    
    @Override
    public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
      return delegate.createCacheKey(ms, parameterObject, rowBounds, boundSql);
    }

**对CacheKey进行赋值操作：**

@Override
    public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
      if (closed) {
        throw new ExecutorException("Executor was closed.");
      }
      CacheKey cacheKey = new CacheKey();
      cacheKey.update(ms.getId());
      cacheKey.update(rowBounds.getOffset());
      cacheKey.update(rowBounds.getLimit());
      cacheKey.update(boundSql.getSql());
      List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
      TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
      // mimic DefaultParameterHandler logic
      for (ParameterMapping parameterMapping : parameterMappings) {
        if (parameterMapping.getMode() != ParameterMode.OUT) {
          Object value;
          String propertyName = parameterMapping.getProperty();
          if (boundSql.hasAdditionalParameter(propertyName)) {
            value = boundSql.getAdditionalParameter(propertyName);
          } else if (parameterObject == null) {
            value = null;
          } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
            value = parameterObject;
          } else {
            MetaObject metaObject = configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName);
          }
          cacheKey.update(value);
        }
      }
      if (configuration.getEnvironment() != null) { // issue #176
        cacheKey.update(configuration.getEnvironment().getId());
      }
      return cacheKey;
    }

查找到CacheKey以后进行真正的查询，从MappedStatement中获取二级缓存，从二级缓存中获取数据，二级缓存为空，才会调用BaseExecutor.query（调用一级缓存进行查询）：

@Override
    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler
    resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
       //从MappedStatement中获取二级缓存
       Cache cache = ms.getCache();
       if (cache != null) {
         flushCacheIfRequired(ms);
         if (ms.isUseCache() && resultHandler == null) {
           ensureNoOutParams(ms, boundSql);
           @SuppressWarnings("unchecked")
           List<E> list = (List<E>) tcm.getObject(cache, key);//从二级缓存中获取数据
           if (list == null) {
             //二级缓存为空，才会调用BaseExecutor.query
             list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
             tcm.putObject(cache, key, list); // issue #578 and #116
           }
           return list;
         }
       }
       return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
     }

一级缓存入口：org.apache.ibatis.executor.BaseExecutor.query(MappedStatement, Object, RowBounds, ResultHandler)。实现了executor接口的大部分方法，主要提供了缓存管理和事务管理的能力，其他子类需要实现的抽象方法为：doUpdate,doQuery等方法BaseExecutor.java

@Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
      ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
      if (closed) {//检查当前executor是否关闭
        throw new ExecutorException("Executor was closed.");
      }
      if (queryStack == 0 && ms.isFlushCacheRequired()) {
    
    //非嵌套查询，并且FlushCache配置为true，则需要清空一级缓存
        clearLocalCache();
      }
      List<E> list;
      try {
        queryStack++;//查询层次加一
        list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;//查询以及缓存
        if (list != null) {//针对调用存储过程的结果处理
          handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
        } else {//缓存未命中，从数据库加载数据
          list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
        }
      } finally {
        queryStack--;
      }
      if (queryStack == 0) {
        for (DeferredLoad deferredLoad : deferredLoads) {//延迟加载处理
          deferredLoad.load();
        }
        // issue #601
        deferredLoads.clear();
        if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
    
    //如果当前sql的一级缓存配置为STATEMENT，查询完既清空一集缓存
          clearLocalCache();
        }
      }
      return list;
    }

**真正访问数据库获取结果的方法：**

//真正访问数据库获取结果的方法
    private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
      List<E> list;
      localCache.putObject(key, EXECUTION_PLACEHOLDER);//在缓存中添加占位符
      try {
        //调用抽象方法doQuery，方法查询数据库并返回结果，可选的实现包括：simple、reuse、batch
        list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
      } finally {
        localCache.removeObject(key);//在缓存中删除占位符
      }
      localCache.putObject(key, list);//将真正的结果对象添加到一级缓存
      if (ms.getStatementType() == StatementType.CALLABLE) {//如果是调用存储过程
        localOutputParameterCache.putObject(key, parameter);//缓存输出类型结果参数
      }
      return list;
    }

## **六、orm框架查询数据过程** ##

### **1、反射的核心类** ###

**ObjectFactory：**MyBatis每次创建结果对象的新实例时，它都会使用对象工厂（ObjectFactory）去构建POJO。

**ReflectorFactory：**创建Reflector的工厂类，Reflector是MyBatis反射模块的基础，每个Reflector对象都对应一个类，在其中缓存了反射操作所需要的类元信息。

**ObjectWrapper：**对对象的包装，抽象了对象的属性信息，他定义了一系列查询对象属性信息的方法，以及更新属性的方法。

**ObjectWrapperFactory：** ObjectWrapper 的工厂类，用于创建ObjectWrapper。

**MetaObject：**封装了对象元信息，包装了MyBatis中五个核心的反射类。也是提供给外部使用的反射工具类，可以利用它可以读取或者修改对象的属性信息。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 15][]

[https_github.com_MyBatis_MyBatis-3]: https://github.com/MyBatis/MyBatis-3
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/d9cfd374b82a4e84a89124033c1533fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/26617f64c8ac4434992a73337b589aae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/98535afc98e04162973bb9f94033f406.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/ebaacc400ed44eac8ba8d87de40744b2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/8564d86329af45a19b7243f43605fe12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/b2bb53c905b7442895129bbea218ddeb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/d0389fcc390743e4901602eecc0225aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/e8d5f17777d94980aee34407f5eb84e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/e0b76eb11feb4a1a98b39e34dca19a19.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/f51c145e6b5c4d0db2f9982a1e2a8cfe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/26279598b5344ee585557fc3d45fb512.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/9e12b5d9de6e4187aa6f1f41ed1bde59.png
[20190903111951195.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/d625f43ffd5f4d1ca4fcb1def25da80b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/2acf70c67ab34c1e923f15f1a8f86369.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/2f586d885da2409bb98ed1b8453e3674.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/356c63e4120347fb88f9174664a4c1e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/74c5db17626241d9a4c3c75204b936cc.png