2. 程式人生 > >Spring配置動態數據源-讀寫分離和多數據源

Spring配置動態數據源-讀寫分離和多數據源

阿新 • • 發佈：2017-05-20
brush ride 常開 resolve ttr 表達 customer 事務管理 cda

　　在現在互聯網系統中，隨著用戶量的增長，單數據源通常無法滿足系統的負載要求。因此為了解決用戶量增長帶來的壓力，在數據庫層面會采用讀寫分離技術和數據庫拆分等技術。讀寫分離就是就是一個Master數據庫，多個Slave數據庫，Master數據庫負責數據的寫操作，slave庫負責數據讀操作，通過slave庫來降低Master庫的負載。因為在實際的應用中，數據庫都是讀多寫少（讀取數據的頻率高，更新數據的頻率相對較少），而讀取數據通常耗時比較長，占用數據庫服務器的CPU較多，從而影響用戶體驗。我們通常的做法就是把查詢從主庫中抽取出來，采用多個從庫，使用負載均衡，減輕每個從庫的查詢壓力。同時隨著業務的增長，會對數據庫進行拆分，根據業務將業務相關的數據庫表拆分到不同的數據庫中。不管是讀寫分離還是數據庫拆分都是解決數據庫壓力的主要方式之一。本篇文章主要講解Spring如何配置讀寫分離和多數據源手段。

1.讀寫分離 　

　　具體到開發中，如何方便的實現讀寫分離呢?目前常用的有兩種方式：

  1. 第一種方式是最常用的方式，就是定義2個數據庫連接，一個是MasterDataSource,另一個是SlaveDataSource。對數據庫進行操作時，先根據需求獲取dataSource,然後通過dataSource對數據庫進行操作。這種方式配置簡單，但是缺乏靈活新。
  2. 第二種方式動態數據源切換，就是在程序運行時，把數據源動態織入到程序中，從而選擇讀取主庫還是從庫。主要使用的技術是：annotation，Spring AOP ，反射。下面會詳細的介紹實現方式。　

　　在介紹實現方式之前，先準備一些必要的知識，spring的AbstractRoutingDataSource類。AbstractRoutingDataSource這個類是spring2.0以後增加的，我們先來看下AbstractRoutingDataSource的定義：

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {}

　　AbstractRoutingDataSource繼承了AbstractDataSource並實現了InitializingBean，因此AbstractRoutingDataSource會在系統啟動時自動初始化實例。

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {
	private Map<Object, Object> targetDataSources;
	private Object defaultTargetDataSource;
	private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
	private Map<Object, DataSource> resolvedDataSources;
	private DataSource resolvedDefaultDataSource;
        ...
}

　　AbstractRoutingDataSource繼承了AbstractDataSource ，而AbstractDataSource 又是DataSource 的子類。DataSource 是javax.sql 的數據源接口，定義如下：

public interface DataSource  extends CommonDataSource,Wrapper {
  Connection getConnection() throws SQLException;
  Connection getConnection(String username, String password)
    throws SQLException;
}

　　DataSource接口定義了2個方法，都是獲取數據庫連接。我們在看下AbstractRoutingDataSource如何實現了DataSource接口：

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

public Connection getConnection(String username, String password) throws SQLException {
	return determineTargetDataSource().getConnection(username, password);
}

　　很顯然就是調用自己的determineTargetDataSource() 方法獲取到connection。determineTargetDataSource方法定義如下：

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;
}

　　我們最關心的還是下面2句話：　

Object lookupKey = determineCurrentLookupKey();
DataSource dataSource = this.resolvedDataSources.get(lookupKey);

　　determineCurrentLookupKey方法返回lookupKey,resolvedDataSources方法就是根據lookupKey從Map中獲得數據源。resolvedDataSources 和determineCurrentLookupKey定義如下：

private Map<Object, DataSource> resolvedDataSources;
protected abstract Object determineCurrentLookupKey()

　　看到以上定義，我們是不是有點思路了，resolvedDataSources是Map類型，我們可以把MasterDataSource和SlaveDataSource存到Map中。通過寫一個類DynamicDataSource繼承AbstractRoutingDataSource，實現其determineCurrentLookupKey() 方法，該方法返回Map的key，master或slave。 

public class DynamicDataSource extends AbstractRoutingDataSource{
    @Override
    protected Object determineCurrentLookupKey() {
        return DatabaseContextHolder.getCustomerType(); 
    }
}

　　定義DatabaseContextHolder

public class DatabaseContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();   
    public static void setCustomerType(String customerType) {  
        contextHolder.set(customerType);  
    }  
    public static String getCustomerType() {  
        return contextHolder.get();  
    }  
    public static void clearCustomerType() {  
        contextHolder.remove();  
    }  
}

　　從DynamicDataSource 的定義看出，他返回的是DynamicDataSourceHolder.getDataSouce()值，我們需要在程序運行時調用DynamicDataSourceHolder.putDataSource()方法，對其賦值。下面是我們實現的核心部分，也就是AOP部分，DataSourceAspect定義如下:

@Aspect
@Order(1)
@Component
public class DataSourceAspect {
    @Before(value = "execution(* com.netease.nsip.DynamicDataSource.dao..*.insert*(..))"
            + "||execution(* com.netease.nsip.DynamicDataSource.dao..*.add*(..))"
            + "[email protected] * *(..)")
    public Object before(ProceedingJoinPoint joinPoint) throws Throwable {
        DatabaseContextHolder.setCustomerType("master");
        Object object = joinPoint.proceed();
        DatabaseContextHolder.setCustomerType("slave");
        return object;
    }
}

　　為了方便測試，我定義了2個數據庫，Master庫和Slave庫，兩個庫中person表結構一致，但數據不同，properties文件配置如下：

#common
db-driver=com.mysql.jdbc.Driver

#master 
master-url=jdbc:mysql://127.0.0.1:3306/master?serverTimezone=UTC
master-user=root
master-password=root

#salve
slave-url=jdbc:mysql://127.0.0.1:3306/slave?serverTimezone=UTC
slave-user=root
slave-password=root

　　Spring中的xml定義如下：

<!-- 配置數據源公共參數 -->
	<bean name="baseDataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>${db-driver}</value>
		</property>
	</bean>

	<!-- 配置主數據源 -->
	<bean name="masterDataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="url">
			<value>${master-url}</value>
		</property>
		<property name="username">
			<value>${master-user}</value>
		</property>
		<property name="password">
			<value>${master-password}</value>
		</property>
	</bean>

	<!--配置從數據源 -->
	<bean name="slavueDataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="url">
			<value>${slave-url}</value>
		</property>
		<property name="username">
			<value>${slave-user}</value>
		</property>
		<property name="password">
			<value>${slave-password}</value>
		</property>
	</bean>

	<bean id="dataSource"
		class="com.netease.nsip.DynamicDataSource.commom.DynamicDataSource">
		<property name="targetDataSources">
			<map key-type="java.lang.String">
				<entry key="master" value-ref="masterDataSource" />
				<entry key="slave" value-ref="slavueDataSource" />
			</map>
		</property>
		<property name="defaultTargetDataSource" ref="slavueDataSource" />
	</bean>

	<!-- 配置SqlSessionFactoryBean -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="configLocation" value="classpath:SqlMapConfig.xml" />
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 持久層訪問模板化的工具，線程安全,構建sqlSessionFactory -->
	<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg index="0" ref="sqlSessionFactory" />
	</bean>

	<!-- 事務管理器 -->
	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<tx:annotation-driven transaction-manager="txManager"
		proxy-target-class="true" order="200" />

	<!-- 回滾方式 -->
	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<tx:method name="*" rollback-for="Throwable" />
		</tx:attributes>
	</tx:advice>

	<!-- [email protected] -->
	<aop:config>
		<aop:pointcut id="transactionPointcutType"
			expression="@within(org.springframework.transaction.annotation.Transactional)" />
		<aop:pointcut id="transactionPointcutMethod"
			expression="@annotation(org.springframework.transaction.annotation.Transactional)" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcutType" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcutMethod" />
	</aop:config>

　　到目前讀寫分離已經配置好了，所有的以insert和add開頭的dao層，以及帶有Transaction註解的會走主庫，其他的數據庫操作走從庫。當然也可以修改切入點表達式讓update和delete方法走主庫。上述方法是基於AOP的讀寫分離配置，下面使用實例結合註解講述多數據源的配置。

2.多數據源配置

　　上面的實例使用AOP來配置讀寫分離，接下來將結合Spring註解配置多數據源，該方法也可以用於配置讀寫分離。先看下annotation的定義：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Profile {
    String value();
}

　　定義MultiDataSourceAspect ，在MultiDataSourceAspect根據註解獲取數據源.

public class MultiDataSourceAspect {
    public void before(JoinPoint joinPoint) throws Throwable {
        Object target = joinPoint.getTarget();  
        String method = joinPoint.getSignature().getName();  
        Class<?>[] classz = target.getClass().getInterfaces();  
  
        Class<?>[] parameterTypes = ((MethodSignature) joinPoint.getSignature()).
                getMethod().getParameterTypes();  
        try {  
            Method m = classz[0].getMethod(method, parameterTypes);  
            if (m != null&&m.isAnnotationPresent(Profile.class)) {  
                Profile data = m  .getAnnotation(Profile.class);  
                DatabaseContextHolder.setCustomerType(data.value());  
            }        
        } catch (Exception e) {  
        }
    }
}　　

　　同樣為了測試，數據源properties文件如下：

#common
db-driver=com.mysql.jdbc.Driver

#master 
account-url=jdbc:mysql://127.0.0.1:3306/master?serverTimezone=UTC
account-user=root
account-password=root

#salve
goods-url=jdbc:mysql://127.0.0.1:3306/slave?serverTimezone=UTC
goods-user=root
goods-password=root

　　Spring的XML文件定義如下：

<!-- 配置數據源公共參數 -->
	<bean name="baseDataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>${db-driver}</value>
		</property>
	</bean>

	<!-- 配置主數據源 -->
	<bean name="accountDataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="url">
			<value>${account-url}</value>
		</property>
		<property name="username">
			<value>${account-user}</value>
		</property>
		<property name="password">
			<value>${account-password}</value>
		</property>
	</bean>

	<!--配置從數據源 -->
	<bean name="goodsDataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="url">
			<value>${goods-url}</value>
		</property>
		<property name="username">
			<value>${goods-user}</value>
		</property>
		<property name="password">
			<value>${goods-password}</value>
		</property>
	</bean>

	<bean id="dataSource"
		class="com.netease.nsip.DynamicDataSource.commom.MultiDataSource">
		<property name="targetDataSources">
			<map key-type="java.lang.String">
				<entry key="goods" value-ref="goodsDataSource" />
				<entry key="account" value-ref="accountDataSource" />
			</map>
		</property>
	</bean>

	<!-- 配置SqlSessionFactoryBean -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="configLocation" value="classpath:multiSqlMapConfig.xml" />
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 持久層訪問模板化的工具，線程安全,構建sqlSessionFactory -->
	<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg index="0" ref="sqlSessionFactory" />
	</bean>


	<!-- 配置AOP -->
	<bean id="multiAspect"
		class="com.netease.nsip.DynamicDataSource.commom.MultiDataSourceAspect" />
	<aop:config>
		<aop:aspect id="datasourceAspect" ref="multiAspect">
			<aop:pointcut
				expression="execution(* com.netease.nsip.DynamicDataSource.dao..*.insert*(..))"
				id="tx" />
			<aop:before pointcut-ref="tx" method="before" />
		</aop:aspect>
	</aop:config>

　　dao層接口定義如下：

public interface IAccountDao {
    @Profile("account")
    public boolean insert(Accounts accounts);
}

public interface IGoodsDao {
    @Profile("goods")
    public boolean insert(Goods goods);  
}

　　Spring配置多數據源的主要方式如上所示，在實例中為了方便數據源的選擇都在dao進行。而在日常開發的過程中事務通常在Service層，而事務又和數據源綁定，所以為了在Service層使用事務可以將數據源的選擇在service層進行。

Spring配置動態數據源-讀寫分離和多數據源

相關推薦

Spring配置動態數據源-讀寫分離和多數據源

brush ride 常開 resolve ttr 表達 customer 事務管理 cda 　　在現在互聯網系統中，隨著用戶量的增長，單數據源通常無法滿足系統的負載要求。因此為了解決用戶量增長帶來的壓力，在數據庫層面會采用讀寫分離技術和數據庫拆分等技術。讀寫分離就是就是一

Spring + Mybatis項目實現數據庫讀寫分離

eterm nec trac vid () lose classpath mls exc 主要思路：通過實現AbstractRoutingDataSource類來動態管理數據源，利用面向切面思維，每一次進入service方法前，選擇數據源。 1、首先pom.xml中添加as

java實現mysql數據庫讀寫分離之定義多數據源方式

修改 protect frame auto ret 更新數據 logs cannot initial 該示例是基於spring提供的AbstractRoutingDataSource，實現了一個動態數據源的功能，在spring配置中定義多個數據庫分為主、從數據庫，實現效

配置數據庫讀寫分離服務器

數據庫配置一主一從 主從同步結構，並在客戶端測試配置master51> grant all on webdb.* to webuser@"%" identified by " 123456"; 裝包rpm -ivh maxscale-2.1.2-1.r

LINUX——關於mysql中較詳細的，數據庫的主從配置，自動備份以及讀寫分離的使用

rep lock ast name ocs lib .cn ket ger 1.主從簡介數據在企業中是非常重要的一部分，存儲數據的數據庫多種多用樣，但卻都存在著一種隱患·數據庫數據丟失·數據庫訪問人數較多時，一臺數據庫無法保證服務質量2.主從的作用·實時災備，用於故障切換·

Spring+MyBatis實現數據庫讀寫分離方案

enabled nco put cdata nproxy log4j equals end aso 方案1通過MyBatis配置文件創建讀寫分離兩個DataSource，每個SqlSessionFactoryBean對象的mapperLocations屬性制定兩個讀寫數據源

yii2的數據庫讀寫分離配置

查看 www all local 數據庫同步 主從同步配置 服務器組 timeout lan 簡介 數據庫讀寫分離是在網站遇到性能瓶頸的時候最先考慮優化的步驟，那麽yii2是如何做數據庫讀寫分離的呢？本節教程來給大家普及一下yii2的數據庫讀寫分離配置。 兩個服務器的數據同

elasticsearch 冷熱數據的讀寫分離

prop 掛載 res arc ima 支持 enable hot ear 步驟 一、冷熱分離集群配置 比如三個機器共六個node的es集群。 每個機器上各掛載一個ssd 和 一個sata。每個機器需要啟動兩個es進程、每個進程對應不同類型的磁盤。 關鍵配置： node

mysql+proxysql+keepalived實現高可用的數據庫讀寫分離

mysql讀寫分離 主從復制 proxysql前言 為了降低一臺數據庫的IO，遠程連接數據庫的時候，可以實現讀寫分離進行調度。這裏就出現了一個單點，所以必須要做一個高可用。當然數據庫服務器也需要做主從復制。實驗結構 說明：上圖的拓撲只是整個架構中的一個小部分，其余功能的實現此圖並未規

看京東架構師如何解決，數據庫讀寫分離與事務糾纏的坑

Java 架構師 微服務 源碼分析 本篇文章討論在數據庫讀寫分離時使用事務的那些坑：1. 在讀寫分離時會不會造成事務主從切換錯誤一個線程在Serivcie時Select時選擇的是從庫，DynamicDataSourceHolder中ThreadLocal對應線程存儲的是slave，然後調用Ma

ProxySQL+Mysql實現數據庫讀寫分離實戰

until reboot centos7.x orm 有一個 datadir 執行 proc sqlit ProxySQL介紹 ProxySQL是一個高性能的MySQL中間件，擁有強大的規則引擎。具有以下特性：http://www.proxysql.com/ 1、連接池，

Mycat實現Mysql數據庫讀寫分離

測試 9.png http company 分片 col windows版本 更多 win Linux和Windows環境下搭建Mycat數據讀寫分離 前提需要：1.服務器裝有JVM虛擬機，就是JDK。2.兩個Mysql數據庫已經實現主從復制,參考：https://

數據庫讀寫分離

atlas 優化 新的 使用 行數 技術分享 之前 right sql 緣由：對數據庫有頻繁操作，而寫數據本身比讀數據更耗時，則可以設計主從數據庫復制的方式同步數據，主數據庫用來更新數據，從數據庫用來查詢數據庫。 以MySql為例，可以基於sql語句復制在從庫上執行，或基

主從數據庫讀寫分離知識

數據庫數據 場景 nbsp 日誌 details 一致性 數據庫操作 參考 memcache （一）為什麽要實現讀寫分離？ 為了服務器承載更多的用戶？提升了網站的響應速度？分攤數據庫服務器的壓力？就是為了雙機熱備又不想浪費備份服務器？上面這些回答，我認為都不是錯誤的，但也都

mysql配置主從復制，讀寫分離(附amoeba源碼包)

SSM整合系列之 配置多資料來源 利用AOP動態切換資料來源 實現讀寫分離

摘要：在開發的專案中大都都會使用讀寫分離的技術，本人目前開發的專案接觸到的都是主從複製(一主一從)，就是一個Master資料庫，一個Slave資料庫。主庫負責資料插入、更新和實時資料查詢，從庫庫負責非實時資料查詢。在實際專案應用中，都是讀多寫少，而讀取資料通常比較複雜而且耗時，SQL語句

學會數據庫讀寫分離、分表分庫——用Mycat

切換 心跳 native 自動生成 拆分 運行 管理命令 users 業界 系統開發中，數據庫是非常重要的一個點。除了程序的本身的優化，如：SQL語句優化、代碼優化，數據庫的處理本身優化也是非常重要的。主從、熱備、分表分庫等都是系統發展遲早會遇到的技術問題問題。Myca

springboot+mybatis實現數據庫讀寫分離

aspect def con odin scanner config help getconf mine 本文不包含數據庫主從配置。 實現思路：在項目中配置多數據源，通過代碼控制訪問哪一個數據源。 spring-jdbc為我們提供了AbstractRoutingDataSo

大型網站架構演進(5)數據庫讀寫分離

這一 流數據 tar share 讀數 應用 庫服務器 兩個 .com 原文:大型網站架構演進(5)數據庫讀寫分離　　在使用緩存後，使大部分的數據讀操作訪問都可以不通過數據庫就能完成，但是仍有一部分讀操作(包括未命中緩存的，和緩存過期的)和全部的寫操作需要訪問數據庫，當網站

spring + mybatis + mysql(主從) 配置多個resource（讀寫分離）

改造原有的專案 實現讀寫分離 準備工作： 1.需要一個能夠執行的spring + mybatis的專案 2.mysql 主從資料庫 拆分Dao（按照讀寫去拆分） 拆分mapping檔案 新增資料庫配置檔案（jdbc.properties）