2. 程式人生 > >Spring MVC+jdbcTemplate+MySql實現讀寫分離

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

阿新 • • 發佈：2018-11-16

現如今，資料庫讀寫分離已經不在是新鮮的話題，很多資料統計網站 、訪問量高的網站都會使用這項技術。解決網站響應慢、伺服器承載壓力過大的方案其實有很多，而讀寫分離只是其中一種實現方案。有的時候讀寫分離並不能完美解決。此文章記錄了筆者使用@Aspect註解方式實現Spring MVC+jdbcTemplate+MySql實現讀寫分離的過程。
既然要讀寫分離，那麼資料庫至少就要又兩個，一個主資料庫，負責讀寫，多個重資料庫，負責讀取。
既然是讀寫分離，為什麼主資料庫還要負責讀和寫呢？
在實際的應用場景種，
一、我寫入資料的同時往往要讀取一些基礎資料。
二、資料在寫入之後要讀取出相關資訊，讀寫分離再及時，也會產生延遲，這樣程式上就會異常了。
所以，主資料庫不僅需要寫入的能力，還要有讀取的能力。

筆者實用MySql資料庫，jdbc.properties配置如下

mysqlM.url=jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf8
mysqlM.username=root
mysqlM.password=root

mysqlC.url=jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf8
mysqlC.username=root
mysqlC.password=root

mysql.driverClassName
 
=com.mysql.jdbc.Driver
mysql.filters=stat
mysql.maxActive=20
mysql.initialSize=1
mysql.maxWait=60000
mysql.minIdle=10
mysql.maxIdle=15
mysql.timeBetweenEvictionRunsMillis=60000
mysql.minEvictableIdleTimeMillis=300000
mysql.validationQuery=SELECT 'x'
mysql.testWhileIdle=true
mysql.testOnBorrow=false
mysql.testOnReturn
 
=false
mysql.maxOpenPreparedStatements=20
mysql.removeAbandoned=true
mysql.removeAbandonedTimeout=1800
mysql.logAbandoned=true

其中，mysqlM是主資料庫，mysqlC是重資料庫。
spring-dao.xml配置如下

<!-- 資料庫基本資訊配置 -->
    <bean id="parentDataSource" class="com.alibaba.druid.pool.DruidDataSource" abstract="true">
        <property name="driverClassName" value="${mysql.driverClassName}" />
        <property name="filters" value="${mysql.filters}" />
        <property name="maxActive" value="${mysql.maxActive}" />
        <property name="initialSize" value="${mysql.initialSize}" />
        <property name="maxWait" value="${mysql.maxWait}" />
        <property name="minIdle" value="${mysql.minIdle}" />
        <property name="timeBetweenEvictionRunsMillis" value="${mysql.timeBetweenEvictionRunsMillis}" />
        <property name="minEvictableIdleTimeMillis" value="${mysql.minEvictableIdleTimeMillis}" />
        <property name="validationQuery" value="${mysql.validationQuery}" />  
        <property name="testWhileIdle" value="${mysql.testWhileIdle}" />  
        <property name="testOnBorrow" value="${mysql.testOnBorrow}" />  
        <property name="testOnReturn" value="${mysql.testOnReturn}" />  
        <property name="maxOpenPreparedStatements" value="${mysql.maxOpenPreparedStatements}" />
        <property name="removeAbandoned" value="${mysql.removeAbandoned}" />
        <property name="removeAbandonedTimeout" value="${mysql.removeAbandonedTimeout}" />
        <property name="logAbandoned" value="${mysql.logAbandoned}" />
        <property name="poolPreparedStatements" value="false" />
    </bean>
    <!-- 主資料庫 -->
    <bean id="dataSourceM" parent="parentDataSource">
         <property name="url" value="${mysqlM.url}" />  
         <property name="username" value="${mysqlM.username}" />
         <property name="password" value="${mysqlM.password}" />
    </bean>
    <!-- 從資料庫 -->
    <bean id="dataSourceC" parent="parentDataSource">
         <property name="url" value="${mysqlC.url}" />
         <property name="username" value="${mysqlC.username}" />
         <property name="password" value="${mysqlC.password}" />
    </bean>
    <!-- 啟用CGliB -->
    <aop:aspectj-autoproxy/>
    <!--切面注入spring自定義標籤-->
    <bean id="dsChangeAspect" class="com.org.util.DataSourceAspect"/>
    <!--動態資料來源、主從庫選擇-->
    <bean id="dynamicDataSource" class="com.org.util.DynamicDataSource">
        <property name="master" ref="dataSourceM"/>
        <property name="slaves">
            <list>
                <ref bean="dataSourceC"/>
            </list>
        </property>
    </bean>
    <!-- 配置Jdbc模板 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dynamicDataSource"></property>
    </bean>
    <!-- 配置事務管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" p:dataSource-ref="dataSourceM" />
    <!-- 啟用基於註解的事務管理 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" />
            <tx:method name="get*" propagation="REQUIRED" read-only="true" />
            <tx:method name="add*" propagation="NESTED" isolation="REPEATABLE_READ" />
            <tx:method name="init*" propagation="NESTED" isolation="REPEATABLE_READ" />
            ....
        </tx:attributes>
    </tx:advice>

註解：
1、<aop:aspectj-autoproxy/>
spring預設是不開啟Aspect（自定義標籤注入）模式的，需要手動開啟。
2、<bean id="dsChangeAspect" class="com.org.util.DataSourceAspect"/>
自定義類：DataSourceAspect，目的是建立自定義標籤、繫結標籤實現方法。程式碼如下：

package com.org.util;

import java.lang.reflect.Method;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
/**
 * 有{@DataSourceChange}註解的方法，呼叫時會切換到指定的資料來源
 * @author zbr
 * @date 2016年12月28日
 */
@Aspect
public class DataSourceAspect {
    @Pointcut(value = "@annotation(com.org.util.DataSourceChange)")
    private void changeDS() {
    }

    @Around(value = "changeDS() ", argNames = "pjp")
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        Object retVal = null;
        MethodSignature ms = (MethodSignature) pjp.getSignature();
        Method method = ms.getMethod();
        DataSourceChange annotation = method.getAnnotation(DataSourceChange.class);
        boolean selectedDataSource = false;
        try {
            if (null != annotation) {
                selectedDataSource = true;
                if (annotation.slave()) {
                    DynamicDataSource.useSlave();
                } else {
                    DynamicDataSource.useMaster();
                }
            }
            retVal = pjp.proceed();
        } catch (Throwable e) {
            throw e;
        } finally {
            if (selectedDataSource) {
                DynamicDataSource.reset();
            }
        }
        return retVal;
    }
}

DataSourceChange 類

package com.org.util;

import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSourceChange {
    boolean slave() default false;
}

3、com.org.util.DynamicDataSource
自定義類DynamicDataSource，動態資料來源、主從庫選擇。這一切都要靠spring的AbstractRoutingDataSource，所以我們要繼承AbstractRoutingDataSource。其實可以想一下，如果我們自己要實現讀寫分離，我們自己的思路是什麼。
問題一、什麼時候使用主庫，什麼時候使用重庫。
問題二、什麼時候去切換資料庫。
第一個問題其實很好解釋，主重的選擇完全靠人為來決定，我們給方法、類或者介面加上自定義標籤後，我們的程式就能判斷出你期望使用的資料來源。
第二個問題、很多人都會想到是在dao層查詢的時候去選擇dataSource,沒錯，spring也是這麼想的，所以它提供了我們一個類：AbstractRoutingDataSource。
方法1：afterPropertiesSet，資料來源初始化
方法2：determineCurrentLookupKey，翻譯過來的意思是：根據key來選擇資料來源，就是說我們要訪問資料庫前，AbstractRoutingDataSource中的determineCurrentLookupKey方法，幫我們去選擇dataSource，我們需要告訴spring我們要使用哪個資料來源，也就是Key。

package com.org.util;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;

import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 動態資料來源
 * 配置主從資料來源後，根據選擇，返回對應的資料來源。多個從庫的情況下，會平均的分配從庫，用於負載均衡。
 * @author zbr
 * @date 2016年12月28日
 */
public class DynamicDataSource extends AbstractRoutingDataSource{
    private static final Logger LOGGER = LoggerFactory.getLogger(DynamicDataSource.class);

    private DataSource master; // 主庫，只允許有一個
    private List<DataSource> slaves; // 從庫，允許有多個
    private AtomicLong slaveCount = new AtomicLong();
    private int slaveSize = 0;

    private Map<Object, Object> dataSources = new HashMap<Object, Object>();

    private static final String DEFAULT = "master";//主資料庫的Key
    private static final String SLAVE = "slave";//重資料庫的key

    private static final ThreadLocal<LinkedList<String>> datasourceHolder = new ThreadLocal<LinkedList<String>>() {
        @Override
        protected LinkedList<String> initialValue() {
            return new LinkedList<String>();
        }

    };
    /**
     * 初始化
     */
    @Override
    public void afterPropertiesSet() {
        if (null == master) {
            throw new IllegalArgumentException("主資料庫載入失敗！");
        }
        dataSources.put(DEFAULT, master);
        if (null != slaves && slaves.size() > 0) {
            for (int i = 0; i < slaves.size(); i++) {
                dataSources.put(SLAVE + (i + 1), slaves.get(i));
            }
            slaveSize = slaves.size();
        }
        this.setDefaultTargetDataSource(master);
        this.setTargetDataSources(dataSources);
        super.afterPropertiesSet();
    }
    /**
     * 選擇使用主庫，並把選擇放到當前ThreadLocal的棧頂
     */
    public static void useMaster() {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("資料來源使用:" + datasourceHolder.get());
        }
        LinkedList<String> m = datasourceHolder.get();
        m.offerFirst(DEFAULT);
    }
    /**
     * 選擇使用從庫，並把選擇放到當前ThreadLocal的棧頂
     */
    public static void useSlave() {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("資料來源使用:" + datasourceHolder.get());
        }
        LinkedList<String> m = datasourceHolder.get();
        m.offerFirst(SLAVE);
    }
    /**
     * 重置當前棧
     */
    public static void reset() {
        LinkedList<String> m = datasourceHolder.get();
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("重置資料來源 {}", m);
        }
        if (m.size() > 0) {
            m.poll();
        }
    }
    /**
     * 如果是選擇使用從庫，且從庫的數量大於1，則通過取模來控制從庫的負載,
     * 計算結果返回AbstractRoutingDataSource
     */
    @Override
    protected Object determineCurrentLookupKey() {
        LinkedList<String> m = datasourceHolder.get();
        String key = m.peekFirst() == null ? "" : m.peekFirst();
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("當前資料來源:" + key);
        }
        if (null != key) {
            if (DEFAULT.equals(key)) {
                return key;
            } else if (SLAVE.equals(key)) {
                if (slaveSize > 1) {
                    long c = slaveCount.incrementAndGet();
                    c = c % slaveSize;
                    return SLAVE + (c + 1);
                } else {
                    return SLAVE + "1";
                }
            }
            return null;
        } else {
            return null;
        }
    }
    public DataSource getMaster() {
        return master;
    }
    public List<DataSource> getSlaves() {
        return slaves;
    }
    public void setMaster(DataSource master) {
        this.master = master;
    }
    public void setSlaves(List<DataSource> slaves) {
        this.slaves = slaves;
    }
}

以上就是讀寫分離的基本配置。

在我們需要讀取重資料庫的方法上加入註解：@DataSourceChange(slave = true)

在程式中斷點一下，可以看到每個類的先後執行順序。
多個數據庫之間的建立關係，後續會補上。

相關推薦

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

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

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

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

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

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

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

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

Mysql 實現讀寫分離-Atlas中介軟體

Mysq主從同步原理： Mysql 之間資料複製的基礎是二進位制日誌檔案(bin log file) Slave 資料庫作為slave通過一個 I/O執行緒與主伺服器保持通訊，並監控master的二進位制日誌檔案的變化，如果發現，master二進位制檔案發生變化，則會把變

Mysql實現讀寫分離

amoeba 實現 mysql 讀寫分離 Amoeba 其實是一個代理,接收所有請求,將其分類,根據我們寫在 xml 檔案裡的規則,將其投放出去,比如讀寫分離,將所有的寫操作投放給 master,將所有的讀操作投放給 slave,最後再由他返回給使用者.

mysql實現讀寫分離中介軟體MySQL Proxy

MySQL Proxy是一個處於你的client端和MySQL server端之間的簡單程式，它可以監測、分析或改變它們的通訊。它使用靈活，沒有限制，常見的用途包括：負載平衡，故障、查詢分析，查詢過濾和修改等等。 MySQL Proxy就是這麼一箇中間層代理，簡單的說，MySQL Proxy就是一個連線池，

spring MVC、mybatis配置讀寫分離，ReplicationDriver（轉載）

讀寫 就是 actor 只讀 完成後 方法 -o pass 執行 環境： 3臺數據庫機器，一個master，二臺slave，分別為slave1，slave2 2.要實現的目標： ①使數據寫入到master ②讀數據時，從slave1和s

Spring Boot2(四)：使用Spring Boot多資料來源實現讀寫分離

前言 實際業務場景中，不可能只有一個庫，所以就有了分庫分表，多資料來源的出現。實現了讀寫分離，主庫負責增改刪，從庫負責查詢。這篇文章將實現Spring Boot如何實現多資料來源，動態資料來源切換，讀寫分離等操作。 程式碼部署 快速新建專案spring-boot專案 1、新增maven依賴 <depen

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

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

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

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

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

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

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

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

使用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

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

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

mysql+mysql_proxy實現讀寫分離

mysql-_proxymysql讀寫分離需要基於主從架構實現 mysql主從配置：http://hongchen99.blog.51cto.com/12534281/1917137 mysql-proxy：用於實現mysql主從分離，基於主從架構讀寫分離存在的最大問題就是主從同步延遲 安裝my

使用spring實現讀寫分離

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

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

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

Mysql主從配置，實現讀寫分離

windows安裝 建議 xid 分布式 唯一標識 -1 在線下載 命令 進行 大型網站為了軟解大量的並發訪問，除了在網站實現分布式負載均衡，遠遠不夠。到了數據業務層、數據訪問層，如果還是傳統的數據結構，或者只是單單靠一臺服務器扛，如此多的數據庫連接操作，數據庫必然會崩潰，