1、動態數據源：

　 ?在一個項目中，有時候需要用到多個數據庫，比如讀寫分離，數據庫的分布式存儲等等，這時我們要在項目中配置多個數據庫。

2、原理：

　 ? (1)、spring?單數據源獲取數據連接過程：

　　　　DataSource --> SessionFactory --> Session
　　　　DataSouce ? 實現javax.sql.DateSource接口的數據源，
　　　　DataSource ?注入SessionFactory，
　　　　從sessionFactory 獲取?Session，實現數據庫的 CRUD。

　　(2)、動態數據源切換：　　

　　　　動態數據源原理之一：實現?javax.sql.DataSource接口， 封裝DataSource, 在 DataSource 配置多個數據庫連接,這種方式只需要一個dataSouce，就能實現多個數據源，最理想的實現，但是需要自己實現DataSource,自己實現連接池，對技術的要求較高，而且自己實現的連接池在性能和穩定性上都有待考驗。

　　　　動態數據源原理之二：配置多個DataSource, SessionFactory注入多個DataSource,實現SessionFactory動態調用DataSource，這種方式需要自己實現SessesionFactory,第三方實現一般不支持注入多個DataSource。

　　　　動態數據源原理之三：配置多個DataSource, 在DataSource和SessionFactory之間插入?RoutingDataSource路由,即 DataSource --> RoutingDataSource -->?SessionFactory --> Session,?在SessionFactory調用時在?RoutingDataSource 層實現DataSource的動態切換, spring提供了 AbstratRoutingDataSource抽象類, 對動態數據源切換提供了很好的支持, 不需要開發者實現復雜的底層邏輯, 推薦實現方式。

　　　　動態數據源原理之四：配置多個SessionFactory,這種實現對技術要求最低,但是相對切換數據源最不靈活。　　

3、實現：

　　這里我們使用原理三以讀寫分離為例，具體實現如下：

　　步驟一：配置多個DateSource,使用的基于阿里的 DruidDataSource

1 <!-- 引入屬性文件，方便配置內容修改 --> 2 <context:property-placeholder location="classpath:jdbc.properties" /> 3 4 5 <!-- 數據庫鏈接(主庫) --> 6 <bean id="dataSourceRW" class="com.alibaba.druid.pool.DruidDataSource" 7 destroy-method="close"> 8 <!-- 基本屬性 url、user、password --> 9 <property name="url" value="${jdbc_url}" /> 10 <property name="username" value="${jdbc_username}" /> 11 <property name="password" value="${jdbc_password}" /> 12 13 <!-- 配置初始化大小、最小、最大 --> 14 <property name="initialSize" value="${druid_initialSize}" /> 15 <property name="minIdle" value="${druid_minIdle}" /> 16 <property name="maxActive" value="${druid_maxActive}" /> 17 18 <!-- 配置獲取連接等待超時的時間 --> 19 <property name="maxWait" value="${druid_maxWait}" /> 20 21 <property name="validationQuery" value="SELECT 'x'" /> 22 <property name="testWhileIdle" value="true" /> 23 24 <!-- 打開PSCache，并且指定每個連接上PSCache的大小 --> 25 <property name="poolPreparedStatements" value="true" /> 26 <property name="maxPoolPreparedStatementPerConnectionSize" 27 value="100" /> 28 29 <!-- 密碼加密 --> 30 <property name="filters" value="config" /> 31 <property name="connectionProperties" value="config.decrypt=true" /> 32 </bean> 33 34 35 <!-- 數據庫鏈接(只讀庫) --> 36 <bean id="dataSourceR" class="com.alibaba.druid.pool.DruidDataSource" 37 destroy-method="close"> 38 <!-- 基本屬性 url、user、password --> 39 <property name="url" value="${jdbc_url_read}" /> 40 <property name="username" value="${jdbc_username_read}" /> 41 <property name="password" value="${jdbc_password_read}" /> 42 43 <!-- 配置初始化大小、最小、最大 --> 44 <property name="initialSize" value="${druid_initialSize}" /> 45 <property name="minIdle" value="${druid_minIdle}" /> 46 <property name="maxActive" value="${druid_maxActive}" /> 47 48 <!-- 配置獲取連接等待超時的時間 --> 49 <property name="maxWait" value="${druid_maxWait}" /> 50 51 <property name="validationQuery" value="SELECT 'x'" /> 52 <property name="testWhileIdle" value="true" /> 53 54 <!-- 打開PSCache，并且指定每個連接上PSCache的大小 --> 55 <property name="poolPreparedStatements" value="true" /> 56 <property name="maxPoolPreparedStatementPerConnectionSize" 57 value="100" /> 58 59 <!-- 密碼加密 --> 60 <property name="filters" value="config" /> 61 <property name="connectionProperties" value="config.decrypt=true" /> 62 </bean> View Code

　　步驟二：配置?DynamicDataSource

1 <!-- 動態數據源 --> 2 <bean id="dynamicDataSource" class="base.dataSource.DynamicDataSource"> 3 <!-- 通過key-value關聯數據源 --> 4 <property name="targetDataSources"> 5 <map> 6 <entry value-ref="dataSourceRW" key="dataSourceRW"></entry> 7 <entry value-ref="dataSourceR" key="dataSourceR"></entry> 8 </map> 9 </property> 10 <!-- 默認的DataSource配置--> 11 <property name="defaultTargetDataSource" ref="dataSourceR" /> 12 </bean> View Code 1 package base.dataSource; 2 3 import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource; 4 5 public class DynamicDataSource extends AbstractRoutingDataSource{ 6 7 @Override 8 protected Object determineCurrentLookupKey() { 9 return DBContextHolder.getDbType(); 10 } 11 } View Code

　　DynamicDataSource 繼承了spring 的?AbstractRoutingDataSource 抽象類 實現determineCurrentLookupKey()方法

　　determineCurrentLookupKey()方法在 SessionFactory 獲取 DataSoure時被調用，AbstractRoutingDataSource?代碼：

1 // 2 // Source code recreated from a .class file by IntelliJ IDEA 3 // (powered by Fernflower decompiler) 4 // 5 6 package org.springframework.jdbc.datasource.lookup; 7 8 import java.sql.Connection; 9 import java.sql.SQLException; 10 import java.util.HashMap; 11 import java.util.Iterator; 12 import java.util.Map; 13 import java.util.Map.Entry; 14 import javax.sql.DataSource; 15 import org.springframework.beans.factory.InitializingBean; 16 import org.springframework.jdbc.datasource.AbstractDataSource; 17 import org.springframework.jdbc.datasource.lookup.DataSourceLookup; 18 import org.springframework.jdbc.datasource.lookup.JndiDataSourceLookup; 19 import org.springframework.util.Assert; 20 21 public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean { 22 private Map<Object, Object> targetDataSources; 23 private Object defaultTargetDataSource; 24 private boolean lenientFallback = true; 25 private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup(); 26 private Map<Object, DataSource> resolvedDataSources; 27 private DataSource resolvedDefaultDataSource; 28 29 public AbstractRoutingDataSource() { 30 } 31 32 public void setTargetDataSources(Map<Object, Object> targetDataSources) { 33 this.targetDataSources = targetDataSources; 34 } 35 36 public void setDefaultTargetDataSource(Object defaultTargetDataSource) { 37 this.defaultTargetDataSource = defaultTargetDataSource; 38 } 39 40 public void setLenientFallback(boolean lenientFallback) { 41 this.lenientFallback = lenientFallback; 42 } 43 44 public void setDataSourceLookup(DataSourceLookup dataSourceLookup) { 45 this.dataSourceLookup = (DataSourceLookup)(dataSourceLookup != null?dataSourceLookup:new JndiDataSourceLookup()); 46 } 47 48 public void afterPropertiesSet() { 49 if(this.targetDataSources == null) { 50 throw new IllegalArgumentException("Property \'targetDataSources\' is required"); 51 } else { 52 this.resolvedDataSources = new HashMap(this.targetDataSources.size()); 53 Iterator var1 = this.targetDataSources.entrySet().iterator(); 54 55 while(var1.hasNext()) { 56 Entry entry = (Entry)var1.next(); 57 Object lookupKey = this.resolveSpecifiedLookupKey(entry.getKey()); 58 DataSource dataSource = this.resolveSpecifiedDataSource(entry.getValue()); 59 this.resolvedDataSources.put(lookupKey, dataSource); 60 } 61 62 if(this.defaultTargetDataSource != null) { 63 this.resolvedDefaultDataSource = this.resolveSpecifiedDataSource(this.defaultTargetDataSource); 64 } 65 66 } 67 } 68 69 protected Object resolveSpecifiedLookupKey(Object lookupKey) { 70 return lookupKey; 71 } 72 73 protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException { 74 if(dataSource instanceof DataSource) { 75 return (DataSource)dataSource; 76 } else if(dataSource instanceof String) { 77 return this.dataSourceLookup.getDataSource((String)dataSource); 78 } else { 79 throw new IllegalArgumentException("Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource); 80 } 81 } 82 83 public Connection getConnection() throws SQLException { 84 return this.determineTargetDataSource().getConnection(); 85 } 86 87 public Connection getConnection(String username, String password) throws SQLException { 88 return this.determineTargetDataSource().getConnection(username, password); 89 } 90 91 public <T> T unwrap(Class<T> iface) throws SQLException { 92 return iface.isInstance(this)?this:this.determineTargetDataSource().unwrap(iface); 93 } 94 95 public boolean isWrapperFor(Class<?> iface) throws SQLException { 96 return iface.isInstance(this) || this.determineTargetDataSource().isWrapperFor(iface); 97 } 98 99 protected DataSource determineTargetDataSource() { 100 Assert.notNull(this.resolvedDataSources, "DataSource router not initialized"); 101 Object lookupKey = this.determineCurrentLookupKey(); 102 DataSource dataSource = (DataSource)this.resolvedDataSources.get(lookupKey); 103 if(dataSource == null && (this.lenientFallback || lookupKey == null)) { 104 dataSource = this.resolvedDefaultDataSource; 105 } 106 107 if(dataSource == null) { 108 throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]"); 109 } else { 110 return dataSource; 111 } 112 } 113 114 protected abstract Object determineCurrentLookupKey(); 115 } View Code AbstractRoutingDataSource?兩個主要變量：
　　targetDataSources 初始化了 DataSource 的map集合, defaultTargetDataSource 初始化默認的DataSource 并實現了 DataSource的 getConnection() 獲取數據庫連接的方法,該方法從determineTargetDataSource()獲取　　DataSource, determineTargetDataSource() 調用了我們 DynamicDataSource?中實現的 determineCurrentLookupKey() 方法獲取DataSource(determineCurrentLookupKey()方法返回的只是我們初始化的DataSource Ma　　p集合key值, 通過key獲取DataSource的方法這里不做贅述，感興趣自己研究下),determineTargetDataSource()的主要邏輯是獲取我們切換的DataSource, 如果沒有的話讀取默認的DataSource。

在DynamicDataSource中我們定義了一個線程變量DBContextHolder來存放我們切換的DataSource, 防止其它線程覆蓋我們的DataSource。 1 package base.dataSource; 2 3 /** 4 * 5 * @author xiao 6 * @date 下午3:27:52 7 */ 8 public final class DBContextHolder { 9 10 /** 11 * 線程threadlocal 12 */ 13 private static ThreadLocal<String> contextHolder = new ThreadLocal<>(); 14 15 private static String DEFAUL_DB_TYPE_RW = "dataSourceKeyRW"; 16 17 /** 18 * 獲取本線程的dbtype 19 * @return 20 */ 21 public static String getDbType() { 22 String db = contextHolder.get(); 23 if (db == null) { 24 db = DEFAUL_DB_TYPE_RW;// 默認是讀寫庫 25 } 26 return db; 27 } 28 29 /** 30 * 31 * 設置本線程的dbtype 32 * 33 * @param str 34 */ 35 public static void setDbType(String str) { 36 contextHolder.set(str); 37 } 38 39 /** 40 * clearDBType 41 * 42 * @Title: clearDBType 43 * @Description: 清理連接類型 44 */ 45 public static void clearDBType() { 46 contextHolder.remove(); 47 } 48 } View Code

　　至此我們獲取DataSource的邏輯已完成, 接下來我們要考慮 設置DataSource, 即為DBContextHolder, set值。我們在代碼中調用DBContextHolder.set()來設置DataSource,理論上可以在代碼的任何位置設置, 不過為了統一規范，我們通過aop來實現,此時我們面臨的問題,在哪一層切入, 方案一: 在dao層切入,dao封裝了數據庫的CRUD,在這一層切入控制最靈活,但是我們一般在service業務層切入事務,如果在dao層切換數據源,會遇到事務無法同步的問題,雖然有分布式事務機制,但是目前成熟的框架很難用,如果使用過 就會知道分布式事務是一件非常惡心的事情,而且分布式事務本就不是一個好的選擇。方案二: 在service業務層切入,可以避免事務問題,但也相對影響了數據源切換的靈活性,這里要根據實際情況靈活選擇,我們采用的在service業務層切入,具體實現如下:

步驟三：實現aop

1 package base.dataSource.aop; 2 3 import java.util.Map; 4 5 import org.aspectj.lang.JoinPoint; 6 import org.springframework.core.Ordered; 7 8 import base.dataSource.DBContextHolder; 9 10 /** 11 * 動態數據源切換aop 12 * @author xiao 13 * @date 2015年7月23日下午4:17:13 14 */ 15 public final class DynamicDataSourceAOP implements Ordered{ 16 17 18 /** 19 * 方法, 數據源應映射規則map 20 */ 21 Map<String, String> methods; 22 23 /** 24 * 默認數據源 25 */ 26 String defaultDataSource; 27 28 29 public String getDefaultDataSource() { 30 return defaultDataSource; 31 } 32 33 public void setDefaultDataSource(String defaultDataSource) { 34 if(null == defaultDataSource || "".equals(defaultDataSource)){ 35 throw new NullPointerException("defaultDataSource Must have a default value"); 36 } 37 this.defaultDataSource = defaultDataSource; 38 } 39 40 public Map<String, String> getMethods() { 41 return methods; 42 } 43 44 public void setMethods(Map<String, String> methods) { 45 this.methods = methods; 46 } 47 48 /** 49 * before 數據源切換 50 * 51 * @param pjp 52 * @throws Throwable 53 */ 54 public void dynamicDataSource(JoinPoint pjp) throws Throwable { 55 DBContextHolder.setDbType(getDBTypeKey(pjp.getSignature().getName())); 56 } 57 58 private String getDBTypeKey(String methodName) { 59 methodName = methodName.toUpperCase(); 60 for (String method : methods.keySet()) { 61 String m = method.toUpperCase(); 62 /** 63 * 忽略大小寫 64 * method 如果不包含 '*', 則以方法名匹配 method 65 * method 包含 '*', 則匹配以 method 開頭, 或者 等于method 的方法 66 */ 67 if (!method.contains("*") 68 && m.equals(methodName) 69 || methodName 70 .startsWith(m.substring(0, m.indexOf("*") - 1)) 71 || methodName.equals(m.substring(0, m.indexOf("*") - 1))) { 72 return methods.get(method); 73 } 74 } 75 return defaultDataSource; 76 } 77 78 //設置AOP執行順序, 這里設置優于事務 79 @Override 80 public int getOrder() { 81 return 1; 82 } 83 } View Code

這里有一個小知識點,aop實現類實現了orderd接口,這個接口有一個方法getOrder(),返回aop的執行順序,就是在同一個切點如果切入了多個aop,則按order從小到大執行,這里我們設置優于事務aop,因為事務是　基于dataSource的,即先切換數據源,在開啟事務,否則可能會存在切換了已開啟了事務的數據源,導致事務不生效。

步驟四：配置aop切面

1 <!-- 數據源讀寫分離 aop --> 2 <bean id="dynamicDataSourceAOP" class="base.dataSource.aop.DynamicDataSourceAOP"> 3 <property name="methods"> 4 <map> 5 <entry key="select*" value="dataSourceKeyR" /> 6 <entry key="get*" value="dataSourceKeyR" /> 7 <entry key="find*" value="dataSourceKeyR" /> 8 <entry key="page*" value="dataSourceKeyR" /> 9 <entry key="query*" value="dataSourceKeyRW" /> 10 </map> 11 </property> 12 <property name="defaultDataSource" value="dataSourceKeyRW"/> 13 </bean> 14 15 16 <aop:config> 17 <!-- 切點 管理所有Service的方法 --> 18 <aop:pointcut 19 expression="execution(* com.b2c.*.service.*Service.*(..))" 20 id="transactionPointCut" /> 21 <!-- 進行事務控制 Advisor --> 22 <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointCut" /> 23 24 <!-- 動態數據源aop, aop:advisor配置一定要在 aop:aspect之前，否則報錯 --> 25 <aop:aspect ref="dynamicDataSourceAOP"> 26 <aop:before method="dynamicDataSource" pointcut-ref="transactionPointCut" /> 27 </aop:aspect> 28 29 </aop:config> View Code

至此全部完成, 另外這只是個人觀點,有更好的想法歡迎交流指正。

?

　　

轉載于:https://www.cnblogs.com/darkwind/p/5414228.html

總結

以上是生活随笔為你收集整理的spring 动态数据源的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。