日志适配、数据源与事务

public static synchronized void useJdkLogging() {
    setImplementation(org.apache.ibatis.logging.jdk14.Jdk14LoggingImpl.class);
}

private static void setImplementation(Class<? extends Log> implClass) {
  try {
    // 获取implClass这个适配器的构造方法
    Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
    // 尝试加载implClass这个适配器，加载失败会抛出异常
    Log log = candidate.newInstance(LogFactory.class.getName());
    // 加载成功，则更新logConstructor字段，记录适配器的构造方法
    logConstructor = candidate;
  } catch (Throwable t) {
    throw new LogException("Error setting Log implementation.  Cause: " + t, t);
  }
}

public class Jdk14LoggingImpl implements Log {
  // 指向一个java.util.logging.Logger对象
  private final Logger log;

public Jdk14LoggingImpl(String clazz) {
    // 初始化log字段
    log = Logger.getLogger(clazz);
  }

@Override
  public void error(String s, Throwable e) {
    // 全部调用依赖java.util.logging.Logger对象进行实现
    log.log(Level.SEVERE, s, e);
  }
  // 省略其他级别的日志输出方法
}

public class DemoInvokerHandler implements InvocationHandler {
    private Object target; // 真正的业务对象，也就是RealSubject对象
    // DemoInvokerHandler构造方法
    public DemoInvokerHandler(Object target) {
        this.target = target;
    }
    public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable {
        ... // 在执行业务逻辑之前的预处理逻辑
        Object result = method.invoke(target, args);
        ... // 在执行业务逻辑之后的后置处理逻辑
        return result;
    }
    public Object getProxy() {
        // 创建代理对象
        return Proxy.newProxyInstance(Thread.currentThread()
            .getContextClassLoader(),
                target.getClass().getInterfaces(), this);
    }
}

public class Main {
    public static void main(String[] args) {
        Subject subject = new RealSubject();
        DemoInvokerHandler invokerHandler =
            new DemoInvokerHandler(subject);
        // 获取代理对象
        Subject proxy = (Subject) invokerHandler.getProxy();
        // 调用代理对象的方法，它会调用DemoInvokerHandler.invoke()方法
        proxy.operation();
    }
}

public static Object newProxyInstance(ClassLoader loader,
     Class[] interfaces, InvocationHandler h)
         throws IllegalArgumentException {
    final Class<?>[] intfs = interfaces.clone();
    ... // 省略权限检查等代码
    Class<?> cl = getProxyClass0(loader, intfs);  // 获取代理类
    ... // 省略try/catch代码块和相关异常处理
    // 获取代理类的构造方法
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    final InvocationHandler ih = h;
    return cons.newInstance(new Object[]{h});  // 创建代理对象
}

private static Class getProxyClass0 (ClassLoader loader,
        Class... interfaces) {
    // 边界检查，限制接口数量（略）
    // 如果指定的类加载器中已经创建了实现指定接口的代理类，则查找缓存；
    // 否则通过ProxyClassFactory创建实现指定接口的代理类
    return proxyClassCache.get(loader, interfaces);
}

private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache
     = new WeakCache<>(new KeyFactory(),
           new ProxyClassFactory());

public Class apply(ClassLoader loader, Class[] interfaces) {
    // ... 对interfaces集合进行一系列检测（略）
    // ... 选择定义代理类的包名（略）
    // 代理类的名称是通过包名、代理类名称前缀以及编号这三项组成的
    long num = nextUniqueNumber.getAndIncrement();
    String proxyName = proxyPkg + proxyClassNamePrefix + num;
    // 生成代理类，并写入文件
    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);

// 加载代理类，并返回Class对象
    return defineClass0(loader, proxyName, proxyClassFile, 0,
      proxyClassFile.length);
}

public static byte[] generateProxyClass(final String name,
       Class[] interfaces) {
    ProxyGenerator gen = new ProxyGenerator(name, interfaces);
    // 动态生成代理类的字节码，具体生成过程不再详细介绍
    final byte[] classFile = gen.generateClassFile();
    // 如果saveGeneratedFiles值为true，会将生成的代理类的字节码保存到文件中
    if (saveGeneratedFiles) {
        java.security.AccessController.doPrivileged(
            new java.security.PrivilegedAction() {
                public Void run() {
                    // 省略try/catch代码块
                    FileOutputStream file = new FileOutputStream(
                        dotToSlash(name) + ".class");
                    file.write(classFile);
                    file.close();
                    return null;
                }
            }
        );
    }
    return classFile; // 返回上面生成的代理类的字节码
}

public final class $Proxy143
      extends Proxy implements Subject {  // 实现了Subject接口
    // 这里省略了从Object类继承下来的相关方法和属性
    private static Method m3;
    static {
        // 省略了try/catch代码块
        // 记录了operation()方法对应的Method对象
        m3 = Class.forName("design.proxy.Subject")
          .getMethod("operation", new Class[0]);
    }
    // 构造方法的参数就是我们在示例中使用的DemoInvokerHandler对象
    public $Proxy11(InvocationHandler var1) throws {
        super(var1);
    }
    public final void operation() throws {
        // 省略了try/catch代码块
        // 调用DemoInvokerHandler对象的invoke()方法
        // 最终调用RealSubject对象的对应方法
        super.h.invoke(this, m3, (Object[]) null);
    }
}

public Object invoke(Object proxy, Method method, Object[] params)
        throws Throwable {
    try {
        if (Object.class.equals(method.getDeclaringClass())) {
            // 如果调用的是从Object继承的方法，则直接调用，不做任何拦截
            return method.invoke(this, params);
        }
        // 调用prepareStatement()方法、prepareCall()方法的时候，
        // 会在创建PreparedStatement对象之后，用PreparedStatementLogger为其创建代理对象
        if ("prepareStatement".equals(method.getName()) || "prepareCall".equals(method.getName())) {
            if (isDebugEnabled()) {
                // 通过statementLog这个Log输出日志
                debug(" Preparing: " + removeExtraWhitespace((String) params[0]), true);
            }
            PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
            stmt = PreparedStatementLogger.newInstance(stmt, statementLog, queryStack);
            return stmt;
        } else if ("createStatement".equals(method.getName())) {
            // 调用createStatement()方法的时候，
            // 会在创建Statement对象之后，用StatementLogger为其创建代理对象
            Statement stmt = (Statement) method.invoke(connection, params);
            stmt = StatementLogger.newInstance(stmt, statementLog, queryStack);
            return stmt;
        } else {
            // 除了上述三个方法之外，其他方法的调用将直接传递给底层Connection对象的相应方法处理
            return method.invoke(connection, params);
        }
    } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
    }
}

public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
  try {
      if (Object.class.equals(method.getDeclaringClass())) {
          // 如果调用Object的方法，则直接调用，不做任何其他处理
          return method.invoke(this, params);
      }
      Object o = method.invoke(rs, params);
      // 针对ResultSet.next()方法进行后置处理
      if ("next".equals(method.getName())) {
          if ((Boolean) o) { // 检测next()方法的返回值，确定是否还存在下一行数据
              rows++; // 记录ResultSet中的行数
              if (isTraceEnabled()) {
                  // 获取数据集的列元数据
                  ResultSetMetaData rsmd = rs.getMetaData();
                  // 获取数据集的列数
                  final int columnCount = rsmd.getColumnCount();
                  if (first) { // 如果是数据集的第一行数据，会输出表头信息
                      first = false;
                      // 这里除了输出表头，还会记录BLOB等超大类型的列名
                      printColumnHeaders(rsmd, columnCount);
                  }
                  // 输出当前遍历的这行记录，这里会过滤掉超大类型列的数据，不进行输出
                  printColumnValues(columnCount);
              }
          } else { // 完成结果集的遍历之后，这里会在日志中输出总行数
              debug("     Total: " + rows, false);
          }
      }
      clearColumnInfo(); // 清空column*集合
      return o;
  } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
  }
}

static {
    // 从DriverManager中读取JDBC驱动
    Enumeration<Driver> drivers = DriverManager.getDrivers();
    while (drivers.hasMoreElements()) {
        Driver driver = drivers.nextElement();
        // 将DriverManager中的全部JDBC驱动记录到registeredDrivers集合
        registeredDrivers.put(driver.getClass().getName(), driver);
    }
}

private Connection doGetConnection(Properties properties) throws SQLException {
    // 初始化数据库驱动
    initializeDriver();
    // 创建数据库连接
    Connection connection = DriverManager.getConnection(url, properties);
    // 配置数据库连接
    configureConnection(connection);
    return connection;
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String methodName = method.getName();
    if (CLOSE.equals(methodName)) {
        // 如果调用close()方法，并没有直接关闭底层连接，而是将其归还给关联的连接池
        dataSource.pushConnection(this);
        return null;
    }
    if (!Object.class.equals(method.getDeclaringClass())) {
        // 只要不是Object的方法，都需要检测当前PooledConnection是否可用
        checkConnection();
    }
    // 调用realConnection的对应方法
    return method.invoke(realConnection, args);
}

private PooledConnection popConnection(String username, String password) throws SQLException {
    while (conn == null) {
        synchronized (state) { // 加锁同步
            // 步骤1：检测空闲连接集合
            if (!state.idleConnections.isEmpty()) {
                // 获取空闲连接
                conn = state.idleConnections.remove(0);
            } else { // 没有空闲连接
                // 步骤2：活跃连接数没有到上限值，则创建新连接
                if (state.activeConnections.size() < poolMaximumActiveConnections) {
                    // 创建新数据库连接，并封装成PooledConnection对象
                    conn = new PooledConnection(dataSource.getConnection(), this);
                } else {// 活跃连接数已到上限值，则无法创建新连接
                    // 步骤3：检测超时连接
                    // 获取最早的活跃连接
                    PooledConnection oldestActiveConnection = state.activeConnections.get(0);
                    long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
                    // 检测该连接是否超时
                    if (longestCheckoutTime > poolMaximumCheckoutTime) {
                        // 对超时连接的信息进行统计
                        state.claimedOverdueConnectionCount++;
                        state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
                        state.accumulatedCheckoutTime += longestCheckoutTime;
                        // 将超时连接移出activeConnections集合
                        state.activeConnections.remove(oldestActiveConnection);
                        // 如果超时连接上有未提交的事务，则自动回滚
                        if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
                            try {
                                oldestActiveConnection.getRealConnection().rollback();
                            } catch (SQLException e) {
                            }
                        }
                        // 创建新PooledConnection对象，但是真正的数据库连接
                        conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
                        conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
                        conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
                        // 将超时PooledConnection设置为无效
                        oldestActiveConnection.invalidate();
                    } else {
                        // 步骤4：无空闲连接、无法创建新连接且无超时连接，则只能阻塞等待
                        if (!countedWait) { // 统计阻塞等待次数
                            state.hadToWaitCount++;
                            countedWait = true;
                        }
                        long wt = System.currentTimeMillis();
                        state.wait(poolTimeToWait);// 阻塞等待
                        // 统计累积的等待时间
                        state.accumulatedWaitTime += System.currentTimeMillis() - wt;
                    }
                }
            }
            if (conn != null) { // 对连接进行统计
                if (conn.isValid()) { // 检测PooledConnection是否有效
                    // 配置PooledConnection的相关属性，设置connectionTypeCode、checkoutTimestamp、lastUsedTimestamp字段的值
                    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 {
                    ... ...// 统计失败的情况
                }
            }
        }
    }
    return conn;
}

protected void pushConnection(PooledConnection conn) throws SQLException {
    synchronized (state) {
        state.activeConnections.remove(conn); // 步骤1：从活跃连接集合中删除该连接
        if (conn.isValid()) {// 步骤2：检测该 PooledConnection 对象是否可用
            // 步骤3：检测当前PooledDataSource连接池中的空闲连接是否已经达到上限值
            if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) {
                // 累计增加accumulatedCheckoutTime
                state.accumulatedCheckoutTime += conn.getCheckoutTime();
                if (!conn.getRealConnection().getAutoCommit()) {
                    // 回滚未提交的事务
                    conn.getRealConnection().rollback();
                }
                // 步骤4：将底层连接重新封装成PooledConnection对象，
                // 并添加到空闲连接集合（也就是前面提到的 idleConnections 集合）
                PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
                state.idleConnections.add(newConn);
                // 设置新PooledConnection对象的创建时间戳和最后使用时间戳
                newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
                newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
                conn.invalidate(); // 丢弃旧PooledConnection对象
                // 唤醒所有阻塞等待空闲连接的线程
                state.notifyAll();
            } else {
                // 当前PooledDataSource连接池中的空闲连接已经达到上限值
                // 当前数据库连接无法放回到池中

// 累计增加accumulatedCheckoutTime
                state.accumulatedCheckoutTime += conn.getCheckoutTime();
                if (!conn.getRealConnection().getAutoCommit()) {
                    // 回滚未提交的事务
                    conn.getRealConnection().rollback();
                }
                // 关闭真正的数据库连接
                conn.getRealConnection().close();
                // 将PooledConnection对象设置为无效
                conn.invalidate();
            }
        } else {
            // 统计无效PooledConnection对象个数
            state.badConnectionCount++;
        }
    }
}

protected boolean pingConnection(PooledConnection conn) {
    boolean result = true; // 记录此次ping操作是否成功完成
    try {
        // 检测底层数据库连接是否已经关闭
        result = !conn.getRealConnection().isClosed();
    } catch (SQLException e) {
        result = false;
    }
    // 如果底层与数据库的网络连接没断开，则需要检测poolPingEnabled字段的配置，决定
    // 是否能执行ping操作。另外，ping操作不能频繁执行，只有超过一定时长
    // (超过poolPingConnectionsNotUsedFor指定的时长)未使用的连接，才需要ping
    // 操作来检测数据库连接是否正常
    if (result && poolPingEnabled && poolPingConnectionsNotUsedFor >= 0
            && conn.getTimeElapsedSinceLastUse() > poolPingConnectionsNotUsedFor) {
        try {
            // 执行poolPingQuery字段中记录的测试SQL语句
            Connection realConn = conn.getRealConnection();
            try (Statement statement = realConn.createStatement()) {
                statement.executeQuery(poolPingQuery).close();
            }
            if (!realConn.getAutoCommit()) {
                realConn.rollback();
            }
            result = true; // 不抛异常，即为成功
        } catch (Exception e) {
            conn.getRealConnection().close();
            result = false;  // 抛异常，即为失败
        }
    }
    return result;
}