阿里云rds数据库迁移实战（多数据源）

　　由于某几个业务表数据量太大，数据由业务写，数据部门读。

　　写压力不大，读却很容易导致长时间等待问题（读由单独系统进行读），导致连接被占用，从而容易并发稍稍增长导致全库卡死！

　　于是，就拆库呗。

　　业务系统拆分就不要做了（微服务化），没那工夫。

　　直接原系统拆两个数据源出来，对某几个高压力表的写就单独用这个数据源，从而减轻压力。

所以，分库工作就变为了两个步骤：

　　1. 两个数据源读写业务；

　　2. 将新数据库写动作同步回读库；

　　再由于方便性，数据库也是使用阿里的rds数据库，一个变为两个！

　　代码上做两个数据源很简单，尤其是在原有代码就写得比较清晰的情况下；

如下是使用springboot和mybatis做的多数据源配置：

　　1. 配置多个数据源类；

　　2. 启用mybatis多数据源，加载不同配置bean；

　　3. 根据扫描路径区别使用的数据源；

　　4. 根据扫描路径将需要拆分的表与原表区别；

　　5. 测试时可使用同同机器上多库形式运行，上线后为多实例同库运行；

　　6. 验证功能可用性；如有问题，及时修改；

　　具体配置如下：

// 原数据源配置
@Configuration
@MapperScan(basePackages = MainDataSourceConfig.SCAN_BASE_PACKAGE, sqlSessionFactoryRef = "sqlSessionFactory")
public class MainDataSourceConfig {

    public static final String SCAN_BASE_PACKAGE = "com.xxx.dao.mapper.main";

    /**
     * xml 配置文件扫描路径
     */
    public static final String SCAN_XML_MAPPER_LOCATION = "classpath:mybatis/mappers/mysql/main/**/*Mapper.xml";

    //jdbcConfig
    @Value("${jdbc.main.url}")
    private String jdbcUrl;
    @Value("${jdbc.main.driver}")
    private String driverName;
    @Value("${pool.main.maxPoolSize}")
    private int maxPoolSize;
    @Value("${jdbc.main.username}")
    private String jdbcUserName;
    @Value("${jdbc.main.password}")
    private String jdbcPwd;
    @Value("${pool.main.maxWait}")
    private int jdbcMaxWait;
    @Value("${pool.main.validationQuery}")
    private String validationQuery;

    @Bean(name = "druidDataSource")
    @Primary
    public DruidDataSource druidDataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setUrl(jdbcUrl);
        ds.setDriverClassName(driverName);
        ds.setMaxActive(maxPoolSize);
        ds.setUsername(jdbcUserName);
        ds.setPassword(jdbcPwd);
        ds.setRemoveAbandoned(true);
        ds.setMaxWait(jdbcMaxWait);
        ds.setValidationQuery(validationQuery);
        return ds;
    }

    @Bean(name = "dataSourceTransactionManager")
    @Primary
    public DataSourceTransactionManager dataSourceTransactionManager(){
        DataSourceTransactionManager dm = new DataSourceTransactionManager();
        dm.setDataSource(druidDataSource());
        return dm;
    }

    @Bean(name="sqlSessionFactory")
    @Primary
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] mapperXmlResource = resolver.getResources(SCAN_XML_MAPPER_LOCATION);
        sqlSessionFactory.setDataSource(druidDataSource());
        sqlSessionFactory.setMapperLocations(mapperXmlResource);
        return sqlSessionFactory.getObject();
    }

}

// 新数据源配置，仅仅改了下配置名，但是还不得不另一个配置类
@Configuration
@MapperScan(basePackages = ExtraDataSourceConfig.SCAN_BASE_PACKAGE, sqlSessionFactoryRef = "sqlSessionFactoryExt")
public class ExtraDataSourceConfig {

    public static final String SCAN_BASE_PACKAGE = "com.xxx.dao.mapper.ext";

    /**
     * xml 配置文件扫描路径
     */
    public static final String SCAN_XML_MAPPER_LOCATION = "classpath:mybatis/mappers/mysql/ext/**/*Mapper.xml";

    //jdbcConfig
    @Value("${jdbc.ext.url}")
    private String jdbcUrl;
    @Value("${jdbc.ext.driver}")
    private String driverName;
    @Value("${pool.ext.maxPoolSize}")
    private int maxPoolSize;
    @Value("${jdbc.ext.username}")
    private String jdbcUserName;
    @Value("${jdbc.ext.password}")
    private String jdbcPwd;
    @Value("${pool.ext.maxWait}")
    private int jdbcMaxWait;
    @Value("${pool.ext.validationQuery}")
    private String validationQuery;

    @Bean(name = "druidDataSourceExt")
    public DruidDataSource druidDataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setUrl(jdbcUrl);
        ds.setDriverClassName(driverName);
        ds.setMaxActive(maxPoolSize);
        ds.setUsername(jdbcUserName);
        ds.setPassword(jdbcPwd);
        ds.setRemoveAbandoned(true);
        ds.setMaxWait(jdbcMaxWait);
        ds.setValidationQuery(validationQuery);
        return ds;
    }

    @Bean(name = "dataSourceTransactionManagerExt")
    public DataSourceTransactionManager dataSourceTransactionManager(){
        DataSourceTransactionManager dm = new DataSourceTransactionManager();
        dm.setDataSource(druidDataSource());
        return dm;
    }

    @Bean(name="sqlSessionFactoryExt")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] mapperXmlResource = resolver.getResources(SCAN_XML_MAPPER_LOCATION);
        sqlSessionFactory.setDataSource(druidDataSource());
        sqlSessionFactory.setMapperLocations(mapperXmlResource);
        return sqlSessionFactory.getObject();
    }

}

　　然后，将需要分离的表操作转移到相应的包路径下，即可实现多数据源操作了！

而多数据源配置对于基于xml配置spring来说，可能更加直观更加简单，甚至xml文件都不用分离！

    <!-- 原数据源配置 -->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.main.url}" />
        <property name="username" value="${jdbc.main.username}" />
        <property name="password" value="${jdbc.main.password}" />
        <property name="maxActive" value="${jdbc.main.maxActive}" />
        <property name="maxWait" value="${jdbc.main.maxWait}" />
    </bean>
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation" value="classpath:mybatis-config.xml" />
        <property name="mapperLocations">
            <list>
                <value>classpath:mybatis/mappers/mysql/main/**/*Mapper.xml</value>
            </list>
        </property>
    </bean>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager" />
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
      <property name="basePackage" value="com.xxx.dao.automapper.main" />
      <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

    <!-- 第二个数据源的配置 -->
    <bean name="dataSourceExt" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.ext.url}" />
        <property name="username" value="${jdbc.ext.username}" />
        <property name="password" value="${jdbc.ext.password}" />
        <property name="maxActive" value="${jdbc.ext.maxActive}" />
        <property name="maxWait" value="${jdbc.ext.maxWait}" />
    </bean>
    <bean id="sqlSessionFactoryExt" class="org.mybatis.spring.SqlSessionFactoryBean">
      <property name="dataSource" ref="dataSourceExt" />
      <property name="configLocation" value="classpath:config/mybatis-config.xml" />
      <property name="mapperLocations">
          <list>
            <value>classpath:mybatis/mappers/mysql/ext/**/*Mapper.xml</value>
          </list>
      </property>
    </bean>
    <bean id="transactionManagerExt" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSourceExt" />
    </bean>
    <tx:annotation-driven transaction-manager="transactionManagerExt" />
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactoryExt"/>
        <property name="basePackage" value="com.xxx.dao.automapper.ext"/>
    </bean>

　　所以，还是那句话：不是所有听起来好的东西就一定是好，在这里转换为不是所有听起来方便的东西用起来就一定方便！

代码ok后，还剩下一个问题：独立后的写动作同步问题！

　　如果是自行搭建的mysql服务，我们很自然地考虑使用binlog同步（主从）来做！具体配置方法也不复杂，自行查找资料即可！

　　如果使用阿里云服务，则不是binlog那样的配置了（但其实质仍然是对binlog的订阅写）。不过倒也都是页面操作！（网上不一定好找资料，但是官网上一定是最全的）

要进行数据库迁移，大体步骤分为：

　　1. 先要将现有数据迁移到新实例上；

　　2. 将部分新数据写入新实例（部分数据仍直接写现有实例，做到业务剥离的同时还可以减少数据同步的开销）；

　　3. 将新实例数据同步回原实例库；

DTS服务（数据传输服务），专门用于做数据迁移和数据同步！

　　其打开方式为：

　　1. 自然是花钱买服务了，买好后才能进入操作页面；这里服务要分两个：一是新实例rds数据库，二是新实例同步回原实例的同步服务；

　　2. 设置ip白名单，以使mysql可访问；

　　3. 创建高权限用户，如root，以使后续可高权限操作mysql，同步时可使用该账号或者另用一个普通读写账号；

　　4. 将全量数据刷入新实例，这里可以选择阿里云免费的数据库迁移服务，也可以自己将数据dump下来，然后自行导致新库；（不过服务既然是免费的，那为啥不用呢！）

　　5. 设置单向同步，从新实例到原实例，此时是不会有数据同步的，因为没有新写入；

　　6. 数据刷入，同步设置完成后，就可以发布新代码了，此时最好将前端入口停止，否则可能出现数据错乱问题；

　　7. 发布代码后，需要自行验证。此时，先选择一台机器进行验证，可以选择两种方式验证：一是自行调用关键接口进行验证；二是将该机器绑定eip外网，使用该外网进行页面访问验证（更完整的验证）；验证的方向主要有两个：1. 接口正常响应，没有错误发生（此处应该要有监控设施，否则只能凭感觉）；2. 数据有没有正常同步（一般同步都是秒级的）；

　　8. 将代码发布到集群中，观察各机器运行情况！此处主要查看数据库连接情况，是否存在连接失败情况，应用监控是主要手段，也可以通过mysql的show full processlist; 进行查看应用连接db情况；

　　9. 观察正常后，此时可以将前端应用入口打开，此时如有条件，应限制ip访问，使变更进行充分测试无误；

　　10. 一切无误后，完全开放访问服务；监控用户数据，迁移完成；

至此，整个迁移就完成了，其实思路是很简单的，关键是要小心操作。一个不小心的操作，就可能带来很大的隐患，毕竟，数据无小事！请保持对数据和代码的敬畏！

临了临了，附几个操作的贴心小技巧，避免入坑！

　　1. 买rds数据库时，尽量买与原实例相同的区域（大区和可用区都相同），否则后期在做同步的时候会花更多的钱，因为跨区的网络通信会让你支付更多；

　　2. 新实例数据库容量可以稍微降配以节省钱，因为毕竟你是将原来的部分功能拆分出来的，没必要一开始就为全部将来买单；

　　3. 买同步服务时，注意几点：1. 按量计算（按小时）比预付费（包月）更贵，但是也更容易订制化，如果仅仅操作两个rds间同步，且短时间内不会下线服务，则建议选择预付费包月形式；2. 将区域选择正确，比如同区域同步将更便宜；3. 能单向同步就不要双向同步了，便宜的同时，也减小了误操作带来的影响；4. 同步性能一般小流量选择small即可，高配的同步用不上关键是贵；

　　4. 同步服务尽早开启，但是后期对于账号密码的变更，一定要及时更改同步配置，否则将带来数据一致性问题；（人工发现往往较晚，尽量设置监控报警）

　　5. 数据库白名单中，需要加入阿里云数据传输服务的白名单，否则无法检查数据库响应性及同步作业；

　　6. 选择同步对象时，尽量以库作为单位！如果选择以表为同步单位，将存在后续新增表时，不会同步回原实例情况。如果实在不能以库作为单位，在后续迭代时，一定记得添加此处同步表；（关注点太多，麻烦）

　　7. 后期做数据变更时，注意操作对象所属实例，别一顿操作猛如虎，然后没什么卵用，因为我们只是选择了单向同步；

　　8. 自己可以不定期地做checksum检查，以确认同步功能正常工作；（checksum table test）

　　9. 代码上分库一定要做准确了，因为这里可能是一定时间内的唯一可信参考资料；（简单但是关键）

最后，我还想说下使用别人服务和自己动手的一些个人感觉：

　　1. 使用自己搭建的服务，最大的好处在于可以做任意的改变不受限，而且不需要付出额外的可见费用；

　　2. 使用自己的服务的可能坏处是：如果你不是这方面的专家，往往会被自己埋下的各种坑难住；遇到问题没能力处理；考虑方面不周全，容易引发安全问题；对未来的因素没办法考虑，使后期运作困难；如果你是专家，那多半这些都不是事儿；

　　3. 使用别人的服务，最大的好处就是简单易用，且有人维护；这些服务往往都是一路填坑过来的，时间越久往往越可靠（百年老字号最佳，哈哈）；安全性、扩展性、性能调优、高可用等等；

　　4. 使用别人的服务，其坏处主要是钱的问题，这个自不必说。还有个不是钱的问题的坏处，那就是你不能随意订制你想要的功能了，你的能力被别人限制住了，这个可能促使你转场到自己提供服务；另外，各家提供的服务都不一样，不像自己搭建的服务，网上会有各种资料可查，所以有一定的学习成本，具体取决于官方设计与官方文档的完整性（当然一般都会很简单）；其实还有一个，就不说了，懂的都懂；

好了，借着数据库迁移的小事，扯了这些淡。只当是抛砖引玉了！欢迎指教！