2. 程式人生 > >Spring+Mybatis透明實現讀寫分離

Spring+Mybatis透明實現讀寫分離

阿新 • • 發佈：2019-02-10

背景

網上有好多讀寫分離的實踐，所應對的業務場景也不一樣，本方法參考了網上好多方法，最終實現為快速應對中小型網際網路產品的讀寫分離。

資料庫環境：

1臺master；多臺slaver

適用框架：

spring+mybatis

操作資料庫的簡單原理：

mybatis最終是要通過sqlsessionfactory獲取資料連線，建立sqlsession並提交到資料庫的。所以我們入手的地方有兩點：
1. 通過建立多種sqlsessionfactory比如masterFactory，slaverFactory來實現讀寫分離。
2. 讓sqlsessionfactory直接可以動態獲取到只讀或者寫的資料來源。

解決方案：

通過擴充套件spring的AbstractRoutingDataSource及DataSourceTransactionManager來實現透明的讀寫分離。該類充當了DataSource的路由中介, 能有在執行時, 根據某種key值來動態切換到真正的DataSource上。

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {
    private Map<Object, Object> targetDataSources;
    private
 
 Object defaultTargetDataSource;
    private boolean lenientFallback = true;
    private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
    private Map<Object, DataSource> resolvedDataSources;
    private DataSource resolvedDefaultDataSource;
    //我們可以看到，它繼承了AbstractDataSource，而AbstractDataSource不就是javax.sql.DataSource的子類，
 

    //So我們可以分析下它的getConnection方法：
    @Override
    public Connection getConnection() throws SQLException {
        return determineTargetDataSource().getConnection();
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return determineTargetDataSource().getConnection(username, password);
    }
    /**
    上面這段原始碼的重點在於determineCurrentLookupKey()方法，這是AbstractRoutingDataSource類中的一個抽象方法，
    它的返回值是你所要用的資料來源dataSource的key值，有了這個key值，
    resolvedDataSource（這是個map,由配置檔案中設定好後存入的）就從中取出對應的DataSource，如果找不到，就用配置預設的資料來源。
    **/
    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;
    }
}

實現

現在我們需要做的就是重寫determineTargetDataSource()，獲取我們需要的資料來源。

1 我們自己的動態資料來源

public class DynamicDataSource extends AbstractRoutingDataSource {

    Logger logger = LoggerFactory.getLogger(DynamicDataSource.class);

    private AtomicInteger counter = new AtomicInteger();

    private DataSource master;

    private List<DataSource> slaves;

    @Override
    protected Object determineCurrentLookupKey() {
        //do nothing
        return null;
    }

    @Override
    public void afterPropertiesSet() {
        //do nothing
    }

    /**
     * 根據標識獲取資料來源
     * @return
     */
    @Override
    protected DataSource determineTargetDataSource() {
        DataSource dataSource = null;
        if (DateSourceHolder.isMaster())
            dataSource = master;
        else if (DateSourceHolder.isSlave()){
            int count = counter.getAndIncrement();
            if (count > 1000000)
                counter.set(0);
            //簡單輪循
            int sequence = count%slaves.size();
            dataSource = slaves.get(sequence);
        }else
            dataSource = master;

        //純粹為了除錯列印，線上需要註釋掉
        /*
        if (dataSource instanceof org.apache.tomcat.jdbc.pool.DataSource){
            org.apache.tomcat.jdbc.pool.DataSource ds = (org.apache.tomcat.jdbc.pool.DataSource) dataSource;
            String jdbcUrl = ds.getUrl();
            int maxWait = ds.getMaxWait();
            logger.debug(">>>>>>>DataSource>>>>>>use jdbc maxWait :"+maxWait+"; url : "+jdbcUrl);
        }
        */

        return dataSource;
    }

    public DataSource getMaster() {
        return master;
    }

    public void setMaster(DataSource master) {
        this.master = master;
    }

    public List<DataSource> getSlaves() {
        return slaves;
    }

    public void setSlaves(List<DataSource> slaves) {
        this.slaves = slaves;
    }
}

2 資料來源控制器

public class DateSourceHolder {

    private static final String MASTER = "master";
    private static final String SLAVE  = "slave";

    private static final ThreadLocal<String> dataSource = new ThreadLocal<>();
    private static final ThreadLocal<DataSource> masterLocal = new ThreadLocal<>();
    private static final ThreadLocal<DataSource> slaveLocal = new ThreadLocal<>();

    private static void setDataSource(String dataSourceKey){
        dataSource.set(dataSourceKey);
    }

    private  static String getDataSource(){
        return dataSource.get();
    }

    public static boolean isMaster(){
        return getDataSource() == MASTER;
    }

    public static boolean isSlave(){
        return getDataSource() == SLAVE;
    }

    public static void setSlave(DataSource dataSource){
        slaveLocal.set(dataSource);
    }

    public static void setMaster(DataSource dataSource){
        masterLocal.set(dataSource);
    }

    public static void setMaster(){
        setDataSource(MASTER);
    }

    public static void setSlave(){
        setDataSource(SLAVE);
    }

    public static void clearDataSource(){
        dataSource.remove();
        masterLocal.remove();
        slaveLocal.remove();
    }

}

3 擴充套件事務處理器

public class DynamicDataSourceTransactionManager extends DataSourceTransactionManager {

    @Override
    protected void doBegin(Object transaction, TransactionDefinition definition) {
        boolean readOnly = definition.isReadOnly();//獲取當前事務切點的方法的讀寫屬性（在spring的xml或者事務註解中的配置）
        if (readOnly)
            DateSourceHolder.setSlave();
        else
            DateSourceHolder.setMaster();
        super.doBegin(transaction, definition);
    }

    @Override
    protected void doCleanupAfterCompletion(Object transaction) {
        super.doCleanupAfterCompletion(transaction);
        DateSourceHolder.clearDataSource();
    }
}

4 配置檔案（部分）

<!-- 讀取配置檔案等等掃描  略...-->
<!--abstract資料來源配置 -->
    <bean id="abstractDataSource" abstract="true">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

  <!--tomcat jdbc pool資料來源配置 -->
    <bean id="dataSourceMaster" name="dataSourceMaster" class="org.apache.tomcat.jdbc.pool.DataSource"
        destroy-method="close">
        <property name="poolProperties">
            <bean class="org.apache.tomcat.jdbc.pool.PoolProperties" parent="abstractDataSource">
                <property name="url" value="${jdbc.url}" />
                <property name="maxWait" value="${tomcat.jdbc.maxWait}" /> <!-- 除錯讀寫用，線上不需要-->
            </bean>
        </property>
    </bean>
    <bean id="dataSourceSlaver1" name="dataSourceSlaver1" class="org.apache.tomcat.jdbc.pool.DataSource"
          destroy-method="close">
        <property name="poolProperties">
            <bean class="org.apache.tomcat.jdbc.pool.PoolProperties" parent="abstractDataSource">
                <property name="url" value="${jdbc.slaver1.url}" />
                <property name="maxWait" value="${tomcat.jdbc.slaver1.maxWait}" /><!-- 除錯讀寫用，線上不需要-->
            </bean>
        </property>
    </bean>
    <bean id="dataSourceSlaver2" name="dataSourceSlaver2" class="org.apache.tomcat.jdbc.pool.DataSource"
          destroy-method="close">
        <property name="poolProperties">
            <bean class="org.apache.tomcat.jdbc.pool.PoolProperties" parent="abstractDataSource">
                <property name="url" value="${jdbc.slaver2.url}" />
                <property name="maxWait" value="${tomcat.jdbc.slaver2.maxWait}" />
            </bean>
        </property>
    </bean>

    <bean id="dataSource" class="cn.com.demo.dao.core.DynamicDataSource">
        <property name="master" ref="dataSourceMaster"></property>
        <property name="slaves">
            <list>
                <ref bean="dataSourceSlaver1"></ref>
                <ref bean="dataSourceSlaver2"></ref>
            </list>
        </property>
    </bean>
  <!-- mybatis -->
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    <property name="mapperLocations" >
        <value>classpath*:cn/com/demo/dao/mapper/xml/**/*Mapper.xml</value>
    </property>
    <property name="typeAliasesPackage" value="cn.com.demo.dao.entity" />
    <property name="plugins">
       <array>
           <bean class="com.github.pagehelper.PageHelper">
               <property name="properties">
                   <value>
                       dialect=mysql
                       offsetAsPageNum=true
                       rowBoundsWithCount=true
                       pageSizeZero=true
                       reasonable=true
                   </value>
               </property>
           </bean>
       </array>
   </property>
  </bean>
  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    <property name="basePackage" value="cn.com.demo.dao.mapper" />
  </bean>

    <!-- 事務管理器 -->
    <bean id="transactionManager"
    class="cn.com.demo.dao.core.DynamicDataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
  </bean>
    <!-- 宣告式事務 -->
  <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="query*" read-only="true" /> <!-- 在擴充套件的事務管理器中就可以獲取到readOnly屬性了 -->
        <tx:method name="get*" read-only="true" />
        <tx:method name="select*" read-only="true" />
        <tx:method name="*" propagation="REQUIRED" rollback-for="Exception"/>
    </tx:attributes>
  </tx:advice>
    <aop:config>
    <aop:pointcut expression="execution(* cn.com.demo.service..*(..))"
      id="ops" />
    <aop:advisor advice-ref="txAdvice" pointcut-ref="ops" />
  </aop:config>

5 應用

public interface ProductService {
    //匹配到*事務切點，會用master資料來源
    Long addProduct(ProductAddDTO productAddDTO,CompanyUser com);
    /**
    簡單的執行流程：
    1.匹配到query*事務切點，我們擴充套件的事務管理器會獲取到read-only="true"屬性
    2. 呼叫DateSourceHolder.setSlave();
    3. SQLSessionFactory會呼叫determineTargetDataSource()方法獲取資料來源，
        在方法中通過 if (DateSourceHolder.isSlave())  dataSource = slaves.get(sequence);
        將datasource設定為只讀資料來源。
    4. 最終service呼叫mapper操作資料庫，mapper執行的時候用到的sqlSession中的connection即動態獲取的只讀資料來源。
    **/
    Map<String,Object> queryUserGroups(Long id);
}

至此，讀寫分離就配置完了，還是開頭說的，這種配置只使用1+N的中小專案中。大型專案可能需要N+N的配置。有機會我們在一起研究。
本文側重配置，描述偏少，見諒。如有問題，及時反饋。

相關推薦

Spring+Mybatis透明實現讀寫分離

背景 網上有好多讀寫分離的實踐，所應對的業務場景也不一樣，本方法參考了網上好多方法，最終實現為快速應對中小型網際網路產品的讀寫分離。 資料庫環境： 1臺master；多臺slaver 適用框架： spring+mybatis 操作資料庫的簡單原理

Spring+SpringMVC+MyBatis+MySQL 實現讀寫分離

簡介 主從複製實現後，主庫資料只能夠寫入資料，讀資料只能夠從庫資料完成。此時程式碼部分就需要實現讀寫分離；就需要配置多個數據源；而以前配置的DataSource 只能夠從單一的URL中獲取連線。在Spring 中提供了一個AbstractRoutingDataSource 類來

Spring Boot + Mybatis 多資料來源配置實現讀寫分離

本文來自網易雲社群作者：王超應用場景：專案中有一些報表統計與查詢功能，對資料實時性要求不高，因此考慮對報表的統計與查詢去操作slave db，減少對master的壓力。根據網上多份資料測試發現總是使用master資料來源，無法切換到slave，經過多次除錯修改現已完美通過，現

使用spring實現讀寫分離

item ger [] 依據 sign batis repl arch 定義 1. 背景 我們一般應用對數據庫而言都是“讀多寫少”，也就說對數據庫讀取數據的壓力比較大，有一個思路就是說采用數據庫集群的方案， 其中一個是主庫，負責寫入數據，我們稱之為：寫庫； 其它都是從庫，

Spring動態數據源實現讀寫分離

character count 方法 cdata mas ebe aso nds evict 一、創建基於ThreadLocal的動態數據源容器，保證數據源的線程安全性 package com.bounter.mybatis.extension; /** * 基

使用Spring實現讀寫分離（ MySQL實現主從復制）

sign eve replicat win [] 做了 用戶名 指定 ati 1. 背景 我們一般應用對數據庫而言都是“讀多寫少”，也就說對數據庫讀取數據的壓力比較大，有一個思路就是說采用數據庫集群的方案， 其中一個是主庫，負責寫入數據，我們稱之為：寫庫； 其它都是從庫，

使用Spring+MySql實現讀寫分離（二）spring整合多數據庫

ont 依據 xml配置 實現 整合 配置 item 匹配 mic 緊接著上一章，因為現在做的項目還是以spring為主要的容器管理框架，所以寫以下spring如何整合多個數據源。 1. 背景 我們一般應用對數據庫而言都是“讀多寫少”，也就說對數據庫讀取數據的壓力比較大

Spring AOP 實現讀寫分離

靈活 結果 only method 行為 execution adl 數據源 tps 原文地址：Spring AOP 實現讀寫分離 博客地址：http://www.extlight.com 一、前言 上一篇《MySQL 實現主從復制》 文章中介紹了 MySQL 主從復制

Spring MVC+jdbcTemplate+MySql實現讀寫分離

現如今，資料庫讀寫分離已經不在是新鮮的話題，很多資料統計網站 、訪問量高的網站都會使用這項技術。解決網站響應慢、伺服器承載壓力過大的方案其實有很多，而讀寫分離只是其中一種實現方案。有的時候讀寫分離並不能完美解決。此文章記錄了筆者使用@Aspect註解方式實現Spring MVC+jdbc

使用 Spring Aop 與 Mysql 的主從複製功能實現讀寫分離

使用 Spring Aop 與 Mysql 的主從複製功能實現讀寫分離。讀寫分離：將應用程式中對資料庫的寫的操作是一個數據庫；對資料庫讀取資料的是另外一個數據庫。而兩個資料庫的資料需要保證一致。 在應用程式中，可以使用 spring aop 對將要執行的業務方法的特徵進行判斷，如：包含 query、find

MySQL多資料來源 二(基於spring+aop實現讀寫分離)

一，為什麼要進行讀寫分離呢？ 　　因為資料庫的“寫操作”操作是比較耗時的（寫上萬條條資料到Mysql的可能要1分鐘分鐘）。但是資料庫的“讀操作”卻比“寫操作”耗時要少的多（從Mysql的讀幾萬條資料條資料可能只要十秒鐘），而我們在開發過程中大多數也是查詢操作比較多。所以讀寫分離解決的是，資料庫的

使用Spring基於應用層實現讀寫分離

背景 我們一般應用對資料庫而言都是“讀多寫少”，也就說對資料庫讀取資料的壓力比較大，有一個思路就是說採用資料庫叢集的方案， 其中一個是主庫，負責寫入資料，我們稱之為：寫庫； 其它都是從庫，負責讀取資料，我們稱之為：讀庫； 那麼，對我們的要求是： 1、

Spring Boot+Mybatis多資料來源讀寫分離

兩天搭建了一個SpringBoot,Mybatis多資料來源讀寫分離，redis實現session共享的例子。記錄一下～～～ 前提條件：Spring Boot,Mybatis 單資料庫能正常執行 一、Spring Boot整合Mybatis實現讀寫分離（後續會做Mysql

使用Spring實現讀寫分離（ MySQL實現主從複製）

1.  背景 我們一般應用對資料庫而言都是“讀多寫少”，也就說對資料庫讀取資料的壓力比較大，有一個思路就是說採用資料庫叢集的方案， 其中一個是主庫，負責寫入資料，我們稱之為：寫庫； 其它都是從庫，負責讀取資料，我們稱之為：讀庫； 那麼，對我們的要求是： 1、讀庫和寫庫的資

springboot2.x 整合mybatis-plus sharding-jdbc實現讀寫分離

首先，匯入依賴，下面只展示核心依賴 <dependency> <groupId>com.baomidou</groupId> <artifactId>my

SpringBoot2.0.3+Mybatis+Mysql+druid實現讀寫分離+事務

       mysql支援一主多從，即在寫庫的資料庫發生變動時，會同步到所有從庫，只是同步過程中，會有一定的延遲（除非業務中出現，立即寫立即讀，否則稍微的延遲是可以接收的）。        當資料庫有主從之分了，那應用程式碼也應該讀寫分離了。這時候的事務就不像單個數據

使用spring實現讀寫分離（mysql主從複製）五：一主多從的實現

很多實際使用場景下都是採用“一主多從”的架構的，使用輪詢演算法實現，目前只需要修改DynamicDataSource即可。   1.1. 實現 import java.lang.reflect.Field; import java.util.ArrayList; impo

Spring AOP 實現讀寫分離（MySQL實現主從複製）

1、Mysql的主從複製      1.1 mysql主(稱master)從(稱slave)複製的原理 1、master將資料改變記錄到二進位制日誌(binarylog)中,也即是配置檔案log-bin指定的檔案(這些記錄叫做二進位制日誌事件，binary log eve

Spring 簡單實現讀寫分離

讀寫分離，基本原理是讓主資料庫處理事務性增、改、刪操作，而從資料庫處理查詢操作。資料庫複製被用來把事務性操作導致的變更同步到叢集的從資料庫。 一般常用實現方式有以下兩種： 1，主從分離，更新操作主資料庫，查詢操作從資料庫 2，動態資料來源切換。 下面利用

J2EE專案使用自定義註解實現基於SpringMVC + Mybatis + Mysql的讀寫分離

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/