spring AbstractRoutingDataSource 实现读写分离

spring有提供AbstractRoutingDataSource类来实现数据源的动态切换，用来实现读写分离也自然没什么问题了。

实现原理：扩展Spring的AbstractRoutingDataSource抽象类（该类充当了DataSource的路由中介, 能有在运行时, 根据某种key值来动态切换到真正的DataSource上。）

    

从AbstractRoutingDataSource的源码中：

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean

 

    我们可以看到，它继承了AbstractDataSource，而AbstractDataSource是javax.sql.DataSource的子类，我们可以分析下它的getConnection方法：

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

 

    获取连接的方法中，重点是determineTargetDataSource()方法，看源码：

/** 
     * Retrieve the current target DataSource. Determines the 
     * {@link #determineCurrentLookupKey() current lookup key}, performs 
     * a lookup in the {@link #setTargetDataSources targetDataSources} map, 
     * falls back to the specified 
     * {@link #setDefaultTargetDataSource default target DataSource} if necessary. 
     * @see #determineCurrentLookupKey() 
     */  
    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;  
    }

 

    上面这段源码的重点在于determineCurrentLookupKey()方法，这是AbstractRoutingDataSource类中的一个抽象方法，而它的返回值是你所要用的数据源dataSource的key值，有了这个key值，resolvedDataSource（这是个map,由配置文件中设置好后存入的）就从中取出对应的DataSource，如果找不到，就用配置默认的数据源。

扩展AbstractRoutingDataSource类，并重写其中的determineCurrentLookupKey()方法，来实现数据源的切换：

实战：

1. 扩展AbstractRoutingDataSource，传递不同数据源
   

2. package org.scf.db;

3. 
   

4. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

5. 
   

6. /**

7.  * 扩展spring route data source

8.  * @author scf

9.  *

10.  */

11. public class DynamicDataSource extends AbstractRoutingDataSource{

12. 
    

13. @Override

14. protected Object determineCurrentLookupKey() {

15. return CustomerContextHolder.getCustomerType();

16. }

17. 
    

18. }

19. package org.scf.db;

20. 
    

21. public class CustomerContextHolder {

22. public static final String DATA_SOURCE_READ = "dataSourceRead";

23.     

24.     public static final String DATA_SOURCE_WRITE = "dataSourceWrite";

25.      

26.     private static ThreadLocal<String> contextHolder = new ThreadLocal<String>();

27.      

28.     public static void setCustomerType(String customerType) {

29.         contextHolder.set(customerType);

30.     }

31.     public static String getCustomerType() {

32.         return contextHolder.get();

33.     }

34.     public static void clearCustomerType() {

35.         contextHolder.remove();

36.     }

37. }

38. 配置spring文件

39. <?xml version="1.0" encoding="UTF-8"?>

40. <beans xmlns="http://www.springframework.org/schema/beans"

41.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

42.        xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"

43.        xmlns:aop="http://www.springframework.org/schema/aop"

44.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

45.        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

46.        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd   

47.        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

48. 
    

49.     <!-- 定义受环境影响易变的变量 -->

50.     <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

51.         <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE"/>

52.         <property name="ignoreResourceNotFound" value="true"/>

53.         <property name="locations">

54.             <list>

55.                 <!-- 标准配置 -->

56.                 <value>classpath:application.properties</value>

57.             </list>

58.         </property>

59.     </bean>

60.     

61.     <bean id="dataSourceWrite" class="org.apache.commons.dbcp.BasicDataSource">

62.          <property name="driverClassName" value="${jdbc.driver.write}"/>

63.         <property name="url" value="${jdbc.url.write}"/>

64.         <property name="username" value="${jdbc.username.write}"/>

65.         <property name="password" value="${jdbc.password.write}"></property>

66.     </bean>

67.     

68.     <bean id="dataSourceRead" class="org.apache.commons.dbcp.BasicDataSource">

69.         <property name="driverClassName" value="${jdbc.driver.read}"/>

70.         <property name="url" value="${jdbc.url.read}"/>

71.         <property name="username" value="${jdbc.username.read}"/>

72.         <property name="password" value="${jdbc.password.read}"></property>

73.     </bean>

74.     

75.     <!-- 动态数据源 -->

76.     <bean id="dynamicDataSource" class="org.scf.db.DynamicDataSource">

77.         <property name="targetDataSources">

78.             <map key-type="java.lang.String">

79.                 <entry value-ref="dataSourceRead" key="dataSourceRead"></entry>

80.                 <entry value-ref="dataSourceWrite" key="dataSourceWrite"></entry>

81.             </map>

82.         </property>

83.         <property name="defaultTargetDataSource" ref="dataSourceWrite">

84.         </property>

85.     </bean>

86. 
    

87.     <!-- 启用aop -->

88.     <aop:aspectj-autoproxy/>

89. 
    

90.     <!-- 启用 annotation -->

91.     <context:annotation-config/>

92. 
    

93.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

94.         <property name="dataSource">

95.             <!-- 默认是写数据源，程序中将其改为读数据源 -->

96.             <ref bean="dynamicDataSource"/>

97.         </property>

98.     </bean>

99.     

100.     <bean id="db" class="org.scf.db.TemplateManager"></bean>

101. 
     

102. </beans>  

     建立模板接口

103. package org.scf.db;

104. 
     

105. import java.util.List;

106. import java.util.Map;

107. 
     

108. import org.springframework.jdbc.core.JdbcTemplate;

109. 
     

110. public interface DBManager {

111. public JdbcTemplate getTemplate();

112. 
     

113.    /**

114.     * 插入/更新/删除

115.     *

116.     * @param sql

117.     * @param args

118.     * @return 本次更新影响的行数

119.     */

120.    public int update(String sql, Object[] args);

121.    

122.    /**

123.     * 查询列表

124.     *

125.     * @param sql

126.     * @param args

127.     * @return 查询的数据列表

128.     */

129.    public List<Map<String, Object>> queryForList(String sql, Object[] args);

130. }

131. package org.scf.db;

132. 
     

133. import java.util.List;

134. import java.util.Map;

135. 
     

136. import org.springframework.beans.factory.annotation.Autowired;

137. import org.springframework.jdbc.core.JdbcTemplate;

138. import org.springframework.stereotype.Component;

139. 
     

140. @Component

141. public class TemplateManager implements DBManager{

142. @Autowired

143.    private JdbcTemplate template;

144. 
     

145.    public JdbcTemplate getTemplate() {

146.        return template;

147.    }

148. 
     

149.    /**

150.     * 插入/更新/删除

151.     *

152.     * @param sql

153.     * @param args

154.     * @return 本次更新影响的行数

155.     */

156.    @Override

157.    public int update(String sql, Object[] args) {

158.        int result = -1;

159.        result = template.update(sql, args);

160.        return result;

161.    }

162.    

163.    /**

164.     * 查询列表

165.     *

166.     * @param sql

167.     * @param args

168.     * @return 查询的数据列表

169.     */

170.    @Override

171.    public List<Map<String, Object>> queryForList(String sql, Object[] args) {

172.     CustomerContextHolder.setCustomerType(CustomerContextHolder.DATA_SOURCE_READ);//切换数据源,默认是写连接池，此处修改成读连接池

173.        List<Map<String, Object>> result = null;

174.        result = template.queryForList(sql, args);

175.        return result;

176.    }

177. }

178. 测试

179. package org.scf.test;

180. 
     

181. import static org.junit.Assert.*;

182. 
     

183. import java.util.List;

184. 
     

185. import org.junit.Test;

186. import org.scf.db.DBManager;

187. import org.springframework.context.ApplicationContext;

188. import org.springframework.context.support.ClassPathXmlApplicationContext;

189. 
     

190. 
     

191. public class RouteTestJ {

192. ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

193. DBManager db  = (DBManager)context.getBean("db");

194. @Test

195. public void insertTest(){//写连接池

196. String sql = "insert into scfTest values (4)";

197. db.update(sql, null);

198. }

199. @Test

200. public void searchTest(){//读连接池

201. String sql = "select id from scfTest";

202. List list = db.queryForList(sql, null);

203. System.out.println(list.size());

204. }

205. }

转载于:https://blog.51cto.com/luzhishen/1651847