使用spring的动态路由实现数据库读写分离【数据库读写分离(二) 】

使用spring的动态路由实现数据库读写分离

Spring2.0.1以后的版本已经支持配置多数据源，并且可以在运行的时候动态加载不同的数据源。通过继承AbstractRoutingDataSource就可以实现多数据源的动态转换。目前做的项目就是需要访问2个数据源，每个数据源的表结构都是相同的，所以要求数据源的变动对于编码人员来说是透明，也就是说同样SQL语句在不同的环境下操作的数据库是不一样的。具体的流程如下：

1.建立一个获得和设置上下文的类

[java] view plaincopy

1. package com.lvye.base.dao.impl.jdbc;  
2. /** 
3.  *连接哪个数据源的环境变量 
4.  */  
5. public class JdbcContextHolder {  
6.     private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();    
7.     public static void setJdbcType(String jdbcType) {    
8.         contextHolder.set(jdbcType);  
9.     }    
10.     public static void setSlave(){  
11.         setJdbcType("slave");  
12.     }  
13.     public static void setMaster(){  
14.         clearJdbcType();  
15.     }  
16.     public static String getJdbcType(){    
17.         return (String) contextHolder.get();   
18.     }    
19.     public static void clearJdbcType() {    
20.         contextHolder.remove();    
21.     }    
22. }  

2.建立动态数据源类，这个类必须继承AbstractRoutingDataSource

[java] view plaincopy

1. package com.lvye.base.dao.impl.jdbc;  
2. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;    
3. public class DynamicDataSource extends AbstractRoutingDataSource{  
4.     /*(non-Javadoc) 
5.      *@see org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource#determineCurrentLookupKey() 
6.      *@author wenc 
7.      */  
8.      @Override  
9.      protected Object determineCurrentLookupKey() {  
10.         return JdbcContextHolder.getJdbcType();  
11.      }  
12. }  

这个类实现了determineCurrentLookupKey方法，该方法返回一个Object，一般是返回字符串。该方法中直接使用了JdbcContextHolder.getJdbcType();方法获得上下文环境并直接返回。

3.编写spring的配置文件配置数据源

[html] view plaincopy

1. <beans>  
2.     <bean id="master" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
3.         <property name="driverClass">  
4.             <value>com.mysql.jdbc.Driver</value>  
5.         </property>  
6.         <property name="jdbcUrl">  
7.             <value>jdbc:mysql://192.168.18.143:3306/wenhq?useUnicode=true&characterEncoding=utf-8</value>  
8.         </property>  
9.         <property name="user">  
10.             <value>root</value>  
11.         </property>  
12.         <property name="password">  
13.             <value></value>  
14.         </property>  
15.     </bean>  
16.     <bean id="slave" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
17.         <property name="driverClass">  
18.             <value>com.mysql.jdbc.Driver</value>  
19.         </property>  
20.         <property name="jdbcUrl">  
21.             <value>jdbc:mysql://192.168.18.144:3306/ wenhq?useUnicode=true&characterEncoding=utf-8</value>  
22.         </property>  
23.         <property name="user">  
24.             <value>root</value>  
25.         </property>  
26.         <property name="password">  
27.             <value></value>  
28.         </property>  
29.     </bean>  
30.     <bean id="mySqlDataSource" class="com.lvye.base.dao.impl.jdbc.DynamicDataSource">   
31.         <property name="targetDataSources">   
32.             <map>   
33.                 <entry key="slave" value-ref="slave"/>   
34.             </map>   
35.         </property>   
36.         <property name="defaultTargetDataSource" ref="master"/>   
37.     </bean>   
38.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
39.         <property name="dataSource" ref="mySqlDataSource" />  
40.     </bean>  
41.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
42.         <property name="dataSource" ref="mySqlDataSource" />  
43.     </bean>  
44. </beans>  

在这个配置中可以看到首先配置两个真实的数据库连接，使用的msyql数据库；master和slave是按照mysql配置的主从关系的数据库，数据会自动实时同步mySqlDataSource会根据上下文选择不同的数据源。在这个配置中第一个property属性配置目标数据源，<entry key="slave" value-ref=" slave"/>中key的值必须要和JdbcContextHolder类中设置的参数值相同，如果有多个值，可以配置多个<entry>标签。第二个property属性配置默认的数据源，我们一般默认为主数据库。有些朋友喜欢使用hibernate，只需要把上面的jdbcTemplate替换为hibernate的就可以了。

4.多数据库连接配置完毕，简单测试

[java] view plaincopy

1. public void testSave() throws Exception{    
2.     jdbcContextHolder.setSlave();//设置从数据源    
3.     Test test = new Test();    
4.     test.setTest("www.wenhq.com.cn");               
5.     mydao.save(test);//使用dao保存实体             
6.      jdbcContextHolder.setMaster();//设置主数据源  
7.     mydao.save(test);//使用dao保存实体到另一个库中             
8. }    

5.实现读写分离，上面的测试通过了，现在就简单了我的程序是使用jdbc实现的保存数据，只是使用了c3p0的数据库连接池而已。把所有访问数据库的方法包装一下，统一调用。把执行更新的sql发送到主数据库了

[java] view plaincopy

1. public void execute(String sql) {  
2.     JdbcContextHolder.setMaster();  
3.     log.debug("execute-sql:" + sql);  
4.     jdbcTemplate.execute(sql);  
5. }      

把查询的发送到从数据库，需要注意的是像LAST_INSERT_ID这类的查询需要特殊处理，必须发送到主数据库，建议增加专门的方法，用于获取自增长的主键。

[java] view plaincopy

1. public List findObject(String queryString, Class clazz) {  
2.     JdbcContextHolder.setSlave();  
3.     log.debug("findObject-sql:" + queryString);  
4.     List list = jdbcTemplate.queryForList(queryString);  
5.     try {  
6.         list = StringBase.convertList(list, clazz);// 将List转化为List<clazz>  
7.     } catch (Exception e) {  
8.         log.error("List convert List<Object> error:" + e);  
9.     }  
10.     AbstractRoutingDataSourcereturn list;  
11. }