数据库读写分离

为什么数据库需要配置读写分离f

   在数据库层面实现读写分离，就是配置一个Master数据库，多个Slave数据库，Master负责保存数据和读取实时数据，Slave主要读取非实时性的数据。

   在数据库读写操作中，读的频率远远大于写，并且读取操作所占用的资源和耗时也更多，所以把读写分离，可有效的缓解数据库的压力。

实现的原理

   实现的原理主要分为两种：

        1.静态的选择Master/Slave数据库（通过单独配置读写库，在方法中已经写死使用读库或者写库）

        2.数据库选择是动态切换（这里写的是这种方式实现读写分离）

   动态获取连接的流程：

         ps：我们的ReadWriteDataSourceConfig需要继承于AbstractRoutingDataSource

        1.AbstractRoutingDataSource初始化会依赖注入配置文件中你所配置的DataSource， 并保存于Map中（结构为key-DataSource，其中key为配置文件中设置的，key是为了标识对应的数据库，后续动态获取时会从ThreadLocal中获取key）

        2.通过aop拦截注解DBReadOnly（自定义），readDataSource的key保存于ThreadLocal中。

        3.获取数据库链接时，AbstractRoutingDataSource会调用覆写的getConnetion，其中getConnetion方法会调用determineTargetDataSource方法，它会调用抽象方法determineCurrentLookupKey（目的就是为了获取对应保存数据库的Map的key），我们的ReadWriteDataSourceConfig需要覆写determineCurrentLookupKey方法，返回ThreadLocal中的key（如果Key不存在，会使用默认库，下面会详细介绍），从而AbstractRoutingDataSource会去获取对应的数据库连接，实现动态获取数据库连接。

实现的原理：

   动态切换实现的原理主要是使用了annotation, Spring aop 等技术，在应用获取数据库连接时动态给于Master/Slave的connection，要实现它我们需要继承AbstractRoutingDataSource。

   

   

   可以看到AbstractRoutingDataSource是继承于AbstractDataSource类的，AbstractDataSource是实现的DataSource的接口

/**
  * Attempts to establish a connection with the data source that
  * this {@code DataSource} object represents.
  *
  * @return  a connection to the data source
  * @exception SQLException if a database access error occurs
  * @throws java.sql.SQLTimeoutException  when the driver has determined that the
  * timeout value specified by the {@code setLoginTimeout} method
  * has been exceeded and has at least tried to cancel the
  * current database connection attempt
  */
 Connection getConnection()  throws  SQLException;

    这是DataSource的抽象方法，最终获取数据库连接就是通过这个方法，最终的核心步骤就是去覆写getConnetion方法，让它去创建我们对应读写库的连接。

    我们的ReadWriteDataSourceConfig是继承于AbstractRoutingDataSource的，AbstractRoutingDataSource是去覆写了getConnetion的，但是在看getConnetion之前我们需要看另一段代码

    public  abstract  class  AbstractRoutingDataSource  extends  AbstractDataSource  implements  InitializingBean{


    private  Map targetDataSources; //保存对应key的DataSource

    private  Object defaultTargetDataSource; //默认的使用的DataSource的Bean

    private  boolean  lenientFallback =  true ;

    private  DataSourceLookup dataSourceLookup =  new  JndiDataSourceLookup();

    private  Map resolvedDataSources; //所有DateSource保存于这个Map中

    private  DataSource resolvedDefaultDataSource; //默认使用的DataSource，下面会详谈


    @Override
    public  void  afterPropertiesSet() {
        if  ( this .targetDataSources ==  null ) {
            throw  new  IllegalArgumentException( "Property 'targetDataSources' is required" );
        }
        this .resolvedDataSources =  new  HashMap( this .targetDataSources.size());
        for  (Map.Entry entry :  this .targetDataSources.entrySet()) { //这是
            Object lookupKey = resolveSpecifiedLookupKey(entry.getKey());
            DataSource dataSource = resolveSpecifiedDataSource(entry.getValue());
            this .resolvedDataSources.put(lookupKey, dataSource);
        }
        if  ( this .defaultTargetDataSource !=  null ) {
            this .resolvedDefaultDataSource = resolveSpecifiedDataSource( this .defaultTargetDataSource);
        }
    }
}

1.AbstractRoutingDataSource中的成员变量，和初始化所做的事情（转换并保存Map，可设置key不存在时候的默认DataSourcere）

      AbstractRoutingDataSource中有targetDataSources，AbstractRoutingDataSource初始化会依赖注入配置文件中你所配置的DataSource， 并保存于Map中（结构为key-DataSource，其中key为配置文件中设置的，key是为了标识对应的数据库，后续动态获取时会从ThreadLocal中获取key），最终你所需要的数据库连接是通过你给于的key去获取，覆写determineCurrentLookupKey方法给它。

     可以看到AbstractRoutingDataSource是实现了InitializingBean这个接口的，它的作用就是在初始化AbstractRoutingDataSource时去执行afterPropertiesSet方法（其中初始化顺序为：构造器>afterPropertiesSet>init）

     afterPropertiesSet所做事情就是把targetDataSources（依赖注入）的值转换为DataSource对象保存到resolvedDataSources中，其中key值为DataSource唯一标识。

     可以看到有一个变量是resolvedDefaultDataSource，这就是一个默认使用的库了，没有key对应，当拿不到Key是使用resolvedDefaultDataSource，AbstractRoutingDataSource会获取resolvedDefaultDataSource对应的数据库连接，就是下图中的代码（其中lenientFallback 默认值为true， lenientFallback 宽大处理，当lenientFallback为true时，即使key对应的dataSource不存在，也会使用默认的数据库resolvedDefaultDataSource）

Object lookupKey = determineCurrentLookupKey(); //需要ReadWriteDataSourceConfig覆写的方法
DataSource dataSource =  this .resolvedDataSources.get(lookupKey);
if  (dataSource ==  null  && ( this .lenientFallback || lookupKey ==  null )) {
    dataSource =  this .resolvedDefaultDataSource;
}

2.getConnection获取对应数据库的连接

@Override
public  Connection getConnection()  throws  SQLException {
    return  determineTargetDataSource().getConnection();
}

 可以看到AbstractRoutingDataSource实现了getConnection方法，其中调用了determineTargetDataSource().getConnetion()，下面是determineTargetDataSource方法的实现。

/**
 * Retrieve the current target DataSource. Determines the
 * {@link #determineCurrentLookupKey() current lookup key}, performs
 * a lookup in the {@link #setTargetDataSources targetDataSources} map,
 * falls back to the specified
 * {@link #setDefaultTargetDataSource default target DataSource} if necessary.
 * @see #determineCurrentLookupKey()
 */
protected  DataSource determineTargetDataSource() {
    Assert.notNull( this .resolvedDataSources,  "DataSource router not initialized" );
    Object lookupKey = determineCurrentLookupKey();
    DataSource dataSource =  this .resolvedDataSources.get(lookupKey);
    if  (dataSource ==  null  && ( this .lenientFallback || lookupKey ==  null )) {
        dataSource =  this .resolvedDefaultDataSource;
    }
    if  (dataSource ==  null ) {
        throw  new  IllegalStateException( "Cannot determine target DataSource for lookup key ["  + lookupKey +  "]" );
    }
    return  dataSource;
}

这个方法就是为了动态获取数据库，其中determineCurrentLookupKey就是动态获取key，这是一个抽象方法，需要我们的应用程序去实现，返回它对应数据库的key，然后从resolvedDataSources获取对应的DataSource，然后获取对应connetion（假如DataSource使用的是DruidDataSource，getConnetion的最终实现是在DruidDataSource.class中）

/**
 * Determine the current lookup key. This will typically be
 * implemented to check a thread-bound transaction context.
 * Allows for arbitrary keys. The returned key needs
 * to match the stored lookup key type, as resolved by the
 * {@link #resolveSpecifiedLookupKey} method.
 */
protected  abstract  Object determineCurrentLookupKey();

3.总结

所以，要实现读写分离，只需继承AbstractRoutinDataSource，覆写determineCurrentLookupKey方法，在配置中配置数据源和对应的key即可实现。

配置与实现：

1.xml中配置多数据源

我们默认为使用写库，当标记了自定义注解DBReadOnly时使用读库（为了方便这里三个库都连的是同一个数据库）

 折叠源码

"mysql_master"  parent= "dataSource" >
    "url"  value= "${test.jdbc.url}"  />
    "username"  value= "${test.jdbc.username}"  />
    "password"  value= "${test.jdbc.password}"  />


"mysql_slave1"  parent= "dataSource" >
    "url"  value= "${test.jdbc.url}"  />
    "username"  value= "${test.jdbc.username}"  />
    "password"  value= "${test.jdbc.password}"  />


"mysql_slave2"  parent= "dataSource" >
    "url"  value= "${test.jdbc.url}"  />
    "username"  value= "${test.jdbc.username}"  />
    "password"  value= "${test.jdbc.password}"  />

"dataSource"  class = "com.alibaba.druid.pool.DruidDataSource"
    init-method= "init"  destroy-method= "close" >
    "filters"  value= "mergeStat"  />
    "maxActive" >
        30

    "initialSize" >
        5

    "maxWait" >
        60000

    "minIdle" >
        1

    "timeBetweenEvictionRunsMillis" >
        600000

    "minEvictableIdleTimeMillis" >
        300000

    "validationQuery" >
        SELECT  1

    "testWhileIdle" >
        true

    "testOnBorrow" >
        false

    "testOnReturn" >
        false

    "connectionProperties"  value= "druid.stat.slowSqlMillis=200"  />
    "poolPreparedStatements" >
        false

    "removeAbandoned"  value= "false"  />
    "useGlobalDataSourceStat"  value= "false"  />


"mysqlDataSource"  class =  "cn.test.test.datasource.ReadWriteDataSourceConfig" >
    "defaultTargetDataSource"  ref= "mysql_master" />
    "targetDataSources"  >

            "read_mysql_slave1"   value-ref= "mysql_slave1" />
            "read_mysql_slave2"   value-ref= "mysql_slave2" />




"sqlSessionFactory"  class = "org.mybatis.spring.SqlSessionFactoryBean" >
    "dataSource"  ref= "mysqlDataSource"  />
    "typeAliasesPackage"  value= "cn.test.test.bean"  />
    "mapperLocations"
        value= "classpath:cn/test/test/dao/mysql/**/*.xml"  />
    "configLocation"  value= "classpath:mybatis-config.xml" />


class = "org.mybatis.spring.mapper.MapperScannerConfigurer" >
    "sqlSessionFactoryBeanName"  value= "sqlSessionFactory"  />
    "basePackage"  value= "cn.test.test.dao.mysql"  />


"transactionManager"
    class = "org.springframework.jdbc.datasource.DataSourceTransactionManager" >
    "dataSource"  ref= "mysqlDataSource"  />
    "mysql"  />


"transactionManager" >

其中ReadWriteDataSourceConfig就是我们去继承于AbstractRoutingDataSource的类，上述将2个slave通过key-value依赖注入于targetDataSources属性中

2.配置类实现

 折叠源码

public  class  ReadWriteDataSourceConfig  extends  AbstractRoutingDataSource {

    private  static  final Test Logger logger = TestLogger.getInstance(ReadWriteDataSourceConfig. class );

    /**
     * @see org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource#determineCurrentLookupKey()
     */
    @Override
    protected  Object determineCurrentLookupKey() {
        return  HoldDataSourceKey.getRead();
    }

    enum  ReadKey {
        read_mysql_slave1, read_mysql_slave2;
    }

    static  class  HoldDataSourceKey {
        private  static  final  ThreadLocal holder =  new  ThreadLocal<>();

        public  static  void  setRead() {
            ReadKey[] keys = ReadKey.values();
            holder.set(keys[ new  Random().nextInt(keys.length)]);
        }

        public  static  String getRead() {
            logger.infoLog( "所使用的dataSource`s key = {}" , String.valueOf(holder.get()));
            return  holder.get() ==  null  ?  null  : holder.get().toString();
        }

        public  static  void  reset() {
            holder.set( null );
        }

    }

}

其中determineCurrentLookupKey方法就是AbstractRoutingDataSource中的抽象方法，目的是返回对应数据源的key，其中内部枚举类ReadKey的值要和xml中配置的key一一对应，HoldDataSourceKey类就时为了获取对应的key，如果是读库， 会随机分配一个slaveKey，现在基本操作都已完成，就差一个aop去拦截需要使用读库的方法了。

3.aop拦截访问读库请求

 

通过aop拦截标有注解DBReadOnly的操作

ps：@DBReadOnly最好是注在相关业务的外层service上，并处于同一事物中，不然可能会出现多次查询查询到不同的Slave，Slave之间也有延迟，导致数据不同步，或者数据不存在等等问题。

 折叠源码

@Target ({ ElementType.METHOD })
@Retention (RetentionPolicy.RUNTIME)
public  @interface  DBReadOnly {
}

 折叠源码

@Component
@Aspect
public  class  ReadWriteAspect  implements  Ordered {
    private  static  final  TestLogger  logger = TestLogger .getInstance(ReadWriteAspect. class );

    @Override
    public  int  getOrder() {
        return  1 ;
    }

    @Around ( "@annotation(cn.test.test.datasource.annotation.DBReadOnly)" )
    public  Object around(ProceedingJoinPoint pjp) {
        Object result =  null ;
        try  {
            HoldDataSourceKey.setRead();
            result = pjp.proceed();
            HoldDataSourceKey.reset();
        }  catch  (Throwable e) {
            logger.errorLog( "get datasource  key fail!" , e);
        }  finally  {
            HoldDataSourceKey.reset();
        }
        return  result;
    }

}

4.运行

在下面方法上中加@DBReadOnly，调用该方法

 折叠源码

    @DBReadOnly
    @Override
    public  UserPayWayConfig queryByUserId(Integer userId, Integer type) {
        return  userPayWayConfigMapper.queryByUserId(userId, type);
    }




2017 - 12 - 28  16 : 06 : 25.820  INFO  itpsgf1tHHPCkFLYmsHIbG ReadWriteDataSourceConfig 所使用的dataSource`s key =read_mysql_slave2

看到调用获取的key是read_mysql_slave2 ，获取的也是read_mysql_slave2 的DataSource，数据库的读写分离在这里就完成了。

缺陷与不足：

       最大的缺陷就是继承AbstractRoutingDataSource不能实现多数据库之间的读写分离，比如使用了sqlserver、mysql，它是无法做到同时使用读/写库的，因为获取Key的方法determineCurrentLookupKey是没有上下文的，无法确定该操作是操作sqlserver还是mysql，那么它就无法返回对应数据源的key了。

所以，要实现数据库的读写分离。。。还是去继承AbstractDataSource吧，实现原理和AbstractRoutingDataSource实现差不多，就是将单例的bean变为多例的class。

但是，如果只是使用单一数据库，继承这个类还是相对来说比较简单的。