weixin_42073629

Sharding-JDBC 源码分析 —— JDBC实现与读写分离

1. 概述

本文主要分享 JDBC 与 读写分离 的实现。为什么会把这两个东西放在一起讲呢？客户端直连数据库的读写分离主要通过获取读库和写库的不同连接来实现，和 JDBC Connection 刚好放在一块。

OK，我们先来看一段 Sharding-JDBC 官方对自己的定义和定位

Sharding-JDBC定位为轻量级java框架，使用客户端直连数据库，以jar包形式提供服务，未使用中间层，无需额外部署，无其他依赖，DBA也无需改变原有的运维方式，可理解为增强版的JDBC驱动，旧代码迁移成本几乎为零。

可以看出，Sharding-JDBC 通过实现 JDBC规范，对上层提供透明化数据库分库分表的访问。黑科技？实际我们使用的数据库连接池也是通过这种方式实现对上层无感知的提供连接池。甚至还可以通过这种方式实现对 Lucene、MongoDB 等等的访问。

扯远了，下面来看看 Sharding-JDBC jdbc 包的结构：

unsupported：声明不支持的数据操作方法
adapter：适配类，实现和分库分表无关的方法
core：核心类，实现和分库分表相关的方法

根据 core 包，可以看出分到四种我们超级熟悉的对象

Datasource
Connection
Statement
ResultSet

实现层级如下：JDBC 接口 <=(继承)== unsupported抽象类 <=(继承)== unsupported抽象类 <=(继承)== core类。

本文内容顺序

unspported 包
adapter 包
插入流程，分析的类：
- ShardingDataSource
- ShardingConnection
- ShardingPreparedStatement（ShardingStatement 类似，不重复分析）
- GeneratedKeysResultSet、GeneratedKeysResultSetMetaData
查询流程，分析的类：
- ShardingPreparedStatement
- ShardingResultSet
读写分离，分析的类：
- MasterSlaveDataSource

Sharding-JDBC 正在收集使用公司名单：传送门。
你的登记，会让更多人参与和使用 Sharding-JDBC。传送门
Sharding-JDBC 也会因此，能够覆盖更多的业务场景。传送门
登记吧，骚年！传送门

2. unspported 包

unspported 包内的抽象类，声明不支持操作的数据对象，所有方法都是 throw new SQLFeatureNotSupportedException() 方式。

public abstract class AbstractUnsupportedGeneratedKeysResultSet extends AbstractUnsupportedOperationResultSet {
    
    @Override
    public boolean getBoolean(final int columnIndex) throws SQLException {
        throw new SQLFeatureNotSupportedException("getBoolean");
    }
    
    // .... 省略其它类似方法
}

public abstract class AbstractUnsupportedOperationConnection extends WrapperAdapter implements Connection {
    
    @Override
    public final CallableStatement prepareCall(final String sql) throws SQLException {
        throw new SQLFeatureNotSupportedException("prepareCall");
    }
    
   // .... 省略其它类似方法
}

3. adapter 包

adapter 包内的抽象类，实现和分库分表无关的方法。

考虑到第4、5两小节更容易理解，本小节贴的代码会相对多

3.1 WrapperAdapter

WrapperAdapter，JDBC Wrapper 适配类。

对 Wrapper 接口实现如下两个方法：

@Override
public final  T unwrap(final Class iface) throws SQLException {
   if (isWrapperFor(iface)) {
       return (T) this;
   }
   throw new SQLException(String.format("[%s] cannot be unwrapped as [%s]", getClass().getName(), iface.getName()));
}
    
@Override
public final boolean isWrapperFor(final Class iface) throws SQLException {
   return iface.isInstance(this);
}

提供子类 #recordMethodInvocation() 记录方法调用，#replayMethodsInvocation() 回放记录的方法调用：


/**
* 记录的方法数组
*/
private final Collection jdbcMethodInvocations = new ArrayList<>();

/**
* 记录方法调用.
* 
* @param targetClass 目标类
* @param methodName 方法名称
* @param argumentTypes 参数类型
* @param arguments 参数
*/
public final void recordMethodInvocation(final Class targetClass, final String methodName, final Class[] argumentTypes, final Object[] arguments) {
   try {
       jdbcMethodInvocations.add(new JdbcMethodInvocation(targetClass.getMethod(methodName, argumentTypes), arguments));
   } catch (final NoSuchMethodException ex) {
       throw new ShardingJdbcException(ex);
   }
}
    
/**
* 回放记录的方法调用.
* 
* @param target 目标对象
*/
public final void replayMethodsInvocation(final Object target) {
   for (JdbcMethodInvocation each : jdbcMethodInvocations) {
       each.invoke(target);
   }
}

这两个方法有什么用途呢？例如下文会提到的 AbstractConnectionAdapter 的 #setAutoCommit()，当它无数据库连接时，先记录；等获得到数据连接后，再回放：

// AbstractConnectionAdapter.java
@Override
public final void setAutoCommit(final boolean autoCommit) throws SQLException {
   this.autoCommit = autoCommit;
   if (getConnections().isEmpty()) { // 无数据连接时，记录方法调用
       recordMethodInvocation(Connection.class, "setAutoCommit", new Class[] {boolean.class}, new Object[] {autoCommit});
       return;
   }
   for (Connection each : getConnections()) {
       each.setAutoCommit(autoCommit);
   }
}

JdbcMethodInvocation，反射调用JDBC相关方法的工具类：

public class JdbcMethodInvocation {
    
   /**
    * 方法
    */
   @Getter
   private final Method method;
   /**
    * 方法参数
    */
   @Getter
   private final Object[] arguments;
   
   /**
    *  调用方法.
    * 
    * @param target 目标对象
    */
   public void invoke(final Object target) {
       try {
           method.invoke(target, arguments); // 反射调用
       } catch (final IllegalAccessException | InvocationTargetException ex) {
           throw new ShardingJdbcException("Invoke jdbc method exception", ex);
       }
   }
}

提供子类 #throwSQLExceptionIfNecessary() 抛出异常链：

protected void throwSQLExceptionIfNecessary(final Collection exceptions) throws SQLException {
   if (exceptions.isEmpty()) { // 为空不抛出异常
       return;
   }
   SQLException ex = new SQLException();
   for (SQLException each : exceptions) {
       ex.setNextException(each); // 异常链
   }
   throw ex;
}

3.2 AbstractDataSourceAdapter

AbstractDataSourceAdapter，数据源适配类。

直接点击链接查看源码。

3.3 AbstractConnectionAdapter

AbstractConnectionAdapter，数据库连接适配类。

我们来瞅瞅大家最关心的事务相关方法的实现。

/**
* 是否自动提交
*/
private boolean autoCommit = true;

/**
* 获得链接
*
* @return 链接
*/
protected abstract Collection getConnections();
    
@Override
public final boolean getAutoCommit() throws SQLException {
   return autoCommit;
}
    
@Override
public final void setAutoCommit(final boolean autoCommit) throws SQLException {
   this.autoCommit = autoCommit;
   if (getConnections().isEmpty()) { // 无数据连接时，记录方法调用
       recordMethodInvocation(Connection.class, "setAutoCommit", new Class[] {boolean.class}, new Object[] {autoCommit});
       return;
   }
   for (Connection each : getConnections()) {
       each.setAutoCommit(autoCommit);
   }
}

#setAutoCommit() 调用时，实际会设置其所持有的 Connection 的 autoCommit 属性
#getConnections() 和分库分表相关，因而仅抽象该方法，留给子类实现

@Override
public final void commit() throws SQLException {
   for (Connection each : getConnections()) {
       each.commit();
   }
}
    
@Override
public final void rollback() throws SQLException {
   Collection exceptions = new LinkedList<>();
   for (Connection each : getConnections()) {
       try {
           each.rollback();
       } catch (final SQLException ex) {
           exceptions.add(ex);
       }
   }
   throwSQLExceptionIfNecessary(exceptions);
}

#commit()、#rollback() 调用时，实际调用其所持有的 Connection 的方法
异常情况下，#commit() 和 #rollback() 处理方式不同，笔者暂时不知道答案，求证后会进行更新
- #commit() 处理方式需要改成和 #rollback() 一样。代码如下：

@Override
public final void commit() throws SQLException {
   Collection exceptions = new LinkedList<>();
   for (Connection each : getConnections()) {
       try {
           each.commit();
       } catch (final SQLException ex) {
           exceptions.add(ex);
       }
   }
   throwSQLExceptionIfNecessary(exceptions);
}

事务级别和是否只读相关代码如下：

/**
* 只读
*/
private boolean readOnly = true;
/**
* 事务级别
*/
private int transactionIsolation = TRANSACTION_READ_UNCOMMITTED;

@Override
public final void setReadOnly(final boolean readOnly) throws SQLException {
   this.readOnly = readOnly;
   if (getConnections().isEmpty()) {
       recordMethodInvocation(Connection.class, "setReadOnly", new Class[] {boolean.class}, new Object[] {readOnly});
       return;
   }
   for (Connection each : getConnections()) {
       each.setReadOnly(readOnly);
   }
}
    
@Override
public final void setTransactionIsolation(final int level) throws SQLException {
   transactionIsolation = level;
   if (getConnections().isEmpty()) {
       recordMethodInvocation(Connection.class, "setTransactionIsolation", new Class[] {int.class}, new Object[] {level});
       return;
   }
   for (Connection each : getConnections()) {
       each.setTransactionIsolation(level);
   }
}

3.4 AbstractStatementAdapter

AbstractStatementAdapter，静态语句对象适配类。

@Override
public final int getUpdateCount() throws SQLException {
   long result = 0;
   boolean hasResult = false;
   for (Statement each : getRoutedStatements()) {
       if (each.getUpdateCount() > -1) {
           hasResult = true;
       }
       result += each.getUpdateCount();
   }
   if (result > Integer.MAX_VALUE) {
       result = Integer.MAX_VALUE;
   }
   return hasResult ? Long.valueOf(result).intValue() : -1;
}

/**
* 获取路由的静态语句对象集合.
* 
* @return 路由的静态语句对象集合
*/
protected abstract Collection getRoutedStatements();

#getUpdateCount() 调用持有的 Statement 计算更新数量
#getRoutedStatements() 和分库分表相关，因而仅抽象该方法，留给子类实现

3.5 AbstractPreparedStatementAdapter

AbstractPreparedStatementAdapter，预编译语句对象的适配类。

#recordSetParameter()实现对占位符参数的设置：

/**
* 记录的设置参数方法数组
*/
private final List setParameterMethodInvocations = new LinkedList<>();
/**
* 参数
*/
@Getter
private final List