Spring + iBatis 的多库横向切分简易解决思路

原文地址：http://www.iteye.com/topic/781317

1.引言

   笔者最近在做一个互联网的“类SNS”应用，应用中用户数量巨大（约4000万）左右，因此，简单的使用传统单一数据库存储肯定是不行的。

   参考了业内广泛使用的分库分表，以及使用DAL数据访问层等的做法，笔者决定使用一种最简单的数据源路由选择方式来解决问题。

   严格的说，目前的实现不能算是一个解决方案，只能是一种思路的简易实现，笔者也仅花了2天时间来完成（其中1.5天是在看资料和Spring/ibatis的源码）。这里也只是为各位看官提供一个思路参考，顺便给自己留个笔记

2.系统的设计前提
   我们的系统使用了16个数据库实例（目前分布在2台物理机器上，后期将根据系统负荷的增加，逐步移库到16台物理机器上）。16个库是根据用户的UserID进行简单的hash分配。这里值得一说的是，我们既然做了这样的横向切分设计，就已经考虑了系统需求的特性，

• 1.不会发生经常性的跨库访问。
• 2.主要的业务逻辑都是围绕UserID为核心的，在一个单库事务内即可完成。

   在系统中，我们使用Spring和iBatis。Spring负责数据库的事务管理AOP，以及Bean间的IOC。选择iBatis的最大原因是对Sql的性能优化，以及后期如果有分表要求的时，可以很容易实现对sql表名替换。


3.设计思路
   首先，要说明一下笔者的思路，其实很简单，即“在每次数据库操作前，确定当前要选择的数据库对象”而后就如同访问单库一样的访问当前选中的数据库即可。

   其次，要在每次DB访问前选择数据库，需要明确几个问题，1.iBatis在什么时候从DataSource中取得具体的数据库Connection的，2.对取得的Connection，iBatis是否进行缓存，因为在多库情况下Connection被缓存就意味着无法及时改变数据库链接选择。3.由于我们使用了Spring来管理DB事务，因此必须搞清Spring对DB Connction的开关拦截过程是否会影响多DataSource的情况。

   幸运的是，研究源码的结果发现，iBatis和Spring都是通过标准的DataSource接口来控制
Connection的，这就为我们省去了很多的麻烦，只需要实现一个能够支持多个数据库的DataSource，就能达到我们的目标。

4.代码与实现
多数据库的DataSource实现：MultiDataSource.class

Java代码  

1. import java.io.PrintWriter;  
2. import java.sql.Connection;  
3. import java.sql.SQLException;  
4. import java.util.ArrayList;  
5. import java.util.Collection;  
6. import java.util.HashMap;  
7. import java.util.Map;  
8.   
9. import javax.sql.DataSource;  
10.   
11. import org.apache.log4j.Logger;  
12.   
13. import com.xxx.sql.DataSourceRouter.RouterStrategy;  
14.   
15. /** 
16.  * 复合多数据源（Alpha） 
17.  * @author linliangyi2005@gmail.com 
18.  * Jul 15, 2010 
19.  */  
20. public class MultiDataSource implements DataSource {  
21.       
22.     static Logger logger = Logger.getLogger(MultiDataSource.class);  
23.       
24.     //当前线程对应的实际DataSource  
25.     private ThreadLocal<DataSource> currentDataSourceHolder = new ThreadLocal<DataSource>();  
26.     //使用Key-Value映射的DataSource  
27.     private Map<String , DataSource> mappedDataSources;  
28.     //使用横向切分的分布式DataSource  
29.     private ArrayList<DataSource> clusterDataSources;  
30.       
31.     public MultiDataSource(){  
32.         mappedDataSources = new HashMap<String , DataSource>(4);  
33.         clusterDataSources = new ArrayList<DataSource>(4);  
34.     }  
35.       
36.     /** 
37.      * 数据库连接池初始化 
38.      * 该方法通常在web 应用启动时调用 
39.      */  
40.     public void initialMultiDataSource(){  
41.         for(DataSource ds : clusterDataSources){  
42.             if(ds != null){  
43.                 Connection conn = null;  
44.                 try {  
45.                     conn = ds.getConnection();                    
46.                 } catch (SQLException e) {  
47.                     e.printStackTrace();  
48.                 } finally{  
49.                     if(conn != null){  
50.                         try {  
51.                             conn.close();  
52.                         } catch (SQLException e) {  
53.                             e.printStackTrace();  
54.                         }  
55.                         conn = null;  
56.                     }  
57.                 }  
58.             }  
59.         }  
60.         Collection<DataSource> dsCollection = mappedDataSources.values();  
61.         for(DataSource ds : dsCollection){  
62.             if(ds != null){  
63.                 Connection conn = null;  
64.                 try {  
65.                     conn = ds.getConnection();  
66.                 } catch (SQLException e) {  
67.                     e.printStackTrace();  
68.                 } finally{  
69.                     if(conn != null){  
70.                         try {  
71.                             conn.close();  
72.                         } catch (SQLException e) {  
73.                             e.printStackTrace();  
74.                         }  
75.                         conn = null;  
76.                     }  
77.                 }  
78.             }  
79.         }  
80.     }  
81.     /** 
82.      * 获取当前线程绑定的DataSource 
83.      * @return 
84.      */  
85.     public DataSource getCurrentDataSource() {  
86.         //如果路由策略存在，且更新过，则根据路由算法选择新的DataSource  
87.         RouterStrategy strategy = DataSourceRouter.currentRouterStrategy.get();  
88.         if(strategy == null){  
89.             throw new IllegalArgumentException("DataSource RouterStrategy No found.");  
90.         }         
91.         if(strategy != null && strategy.isRefresh()){             
92.             if(RouterStrategy.SRATEGY_TYPE_MAP.equals(strategy.getType())){  
93.                 this.choiceMappedDataSources(strategy.getKey());  
94.                   
95.             }else if(RouterStrategy.SRATEGY_TYPE_CLUSTER.equals(strategy.getType())){  
96.                 this.routeClusterDataSources(strategy.getRouteFactor());  
97.             }             
98.             strategy.setRefresh(false);  
99.         }  
100.         return currentDataSourceHolder.get();  
101.     }  
102.   
103.     public Map<String, DataSource> getMappedDataSources() {  
104.         return mappedDataSources;  
105.     }  
106.   
107.     public void setMappedDataSources(Map<String, DataSource> mappedDataSources) {  
108.         this.mappedDataSources = mappedDataSources;  
109.     }  
110.   
111.     public ArrayList<DataSource> getClusterDataSources() {  
112.         return clusterDataSources;  
113.     }  
114.   
115.     public void setClusterDataSources(ArrayList<DataSource> clusterDataSources) {  
116.         this.clusterDataSources = clusterDataSources;  
117.     }  
118.       
119.     /** 
120.      * 使用Key选择当前的数据源 
121.      * @param key 
122.      */  
123.     public void choiceMappedDataSources(String key){  
124.         DataSource ds = this.mappedDataSources.get(key);  
125.         if(ds == null){  
126.             throw new IllegalStateException("No Mapped DataSources Exist!");  
127.         }  
128.         this.currentDataSourceHolder.set(ds);  
129.     }  
130.       
131.     /** 
132.      * 使用取模算法，在群集数据源中做路由选择 
133.      * @param routeFactor 
134.      */  
135.     public void routeClusterDataSources(int routeFactor){  
136.         int size = this.clusterDataSources.size();  
137.         if(size == 0){  
138.             throw new IllegalStateException("No Cluster DataSources Exist!");  
139.         }  
140.         int choosen = routeFactor % size;  
141.         DataSource ds = this.clusterDataSources.get(choosen);  
142.         if(ds == null){  
143.             throw new IllegalStateException("Choosen DataSources is null!");  
144.         }  
145.         logger.debug("Choosen DataSource No." + choosen+ " : " + ds.toString());  
146.         this.currentDataSourceHolder.set(ds);  
147.     }  
148.   
149.     /* (non-Javadoc) 
150.      * @see javax.sql.DataSource#getConnection() 
151.      */  
152.     public Connection getConnection() throws SQLException {  
153.         if(getCurrentDataSource() != null){  
154.             return getCurrentDataSource().getConnection();  
155.         }  
156.         return null;  
157.     }  
158.   
159.     /* (non-Javadoc) 
160.      * @see javax.sql.DataSource#getConnection(java.lang.String, java.lang.String) 
161.      */  
162.     public Connection getConnection(String username, String password)  
163.             throws SQLException {  
164.         if(getCurrentDataSource() != null){  
165.             return getCurrentDataSource().getConnection(username , password);  
166.         }  
167.         return null;  
168.     }  
169.   
170.     /* (non-Javadoc) 
171.      * @see javax.sql.CommonDataSource#getLogWriter() 
172.      */  
173.     public PrintWriter getLogWriter() throws SQLException {  
174.         if(getCurrentDataSource() != null){  
175.             return getCurrentDataSource().getLogWriter();  
176.         }  
177.         return null;  
178.     }  
179.   
180.     /* (non-Javadoc) 
181.      * @see javax.sql.CommonDataSource#getLoginTimeout() 
182.      */  
183.     public int getLoginTimeout() throws SQLException {  
184.         if(getCurrentDataSource() != null){  
185.             return getCurrentDataSource().getLoginTimeout();  
186.         }  
187.         return 0;  
188.     }  
189.   
190.     /* (non-Javadoc) 
191.      * @see javax.sql.CommonDataSource#setLogWriter(java.io.PrintWriter) 
192.      */  
193.     public void setLogWriter(PrintWriter out) throws SQLException {  
194.         if(getCurrentDataSource() != null){  
195.             getCurrentDataSource().setLogWriter(out);  
196.         }  
197.     }  
198.   
199.     /* (non-Javadoc) 
200.      * @see javax.sql.CommonDataSource#setLoginTimeout(int) 
201.      */  
202.     public void setLoginTimeout(int seconds) throws SQLException {  
203.         if(getCurrentDataSource() != null){  
204.             getCurrentDataSource().setLoginTimeout(seconds);  
205.         }  
206.     }  
207.   
208.     /* (non-Javadoc) 
209.      * 该接口方法since 1.6 
210.      * 不是所有的DataSource都实现有这个方法 
211.      * @see java.sql.Wrapper#isWrapperFor(java.lang.Class) 
212.      */  
213.     public boolean isWrapperFor(Class<?> iface) throws SQLException {  
214.           
215. //      if(getCurrentDataSource() != null){  
216. //          return getCurrentDataSource().isWrapperFor(iface);  
217. //      }  
218.         return false;  
219.     }  
220.   
221.     /* (non-Javadoc) 
222.      * 该接口方法since 1.6 
223.      * 不是所有的DataSource都实现有这个方法 
224.      * @see java.sql.Wrapper#unwrap(java.lang.Class) 
225.      */  
226.     public <T> T unwrap(Class<T> iface) throws SQLException {  
227. //      if(getCurrentDataSource() != null){  
228. //          return getCurrentDataSource().unwrap(iface);  
229. //      }  
230.         return null;  
231.     }  

这个类实现了DataSource的标准接口，而最核心的部分是getConnection()方法的重载。下面具体阐述：

• 1.实例变量 clusterDataSources 是一个DataSource 的 ArrayList它存储了多个数据库的DataSource实例，我们使用Spring的IOC功能，将多个DataSource注入到这个list中。
• 2.实例变量 mappedDataSources 是一个DataSource 的Map，它与clusterDataSources 一样用来存储多个数据库的DataSource实例，不同的是，它可以使用key直接获取DataSource。我们一样会使用Spring的IOC功能，将多个DataSource注入到这个Map中。
• 3.实例变量currentDataSourceHolder ，他是一个ThreadLocal变量，保存与当前线程相关的且已经取得的DataSource实例。这是为了在同一线程中，多次访问同一数据库时，不需要再重新做路由选择。
• 4.当外部类调用getConnection()方法时，方法将根据上下文的路由规则，从clusterDataSources 或者 mappedDataSources 选择对应DataSource，并返回其中的Connection。

（PS：关于DataSource的路由选择规则，可以根据应用场景的不同，自行设计。笔者这里提供两种简单的思路，1.根据HashCode,在上述例子中可以是UserId，进行取模运算，来定位数据库。2.根据上下文设置的关键字key，从map中选择映射的DataSource）


5.将MultiDataSource与Spring，iBatis结合
    在完成了上述的编码过程后，就是将这个MultiDataSource与现有Spring和iBatis结合起来配置。

STEP 1。配置多个数据源
笔者这里使用了C3P0作为数据库连接池，这一步和标准的Spring配置一样，唯一不同的是，以前只配置一个，现在要配置多个

Xml代码  

1. <!-- jdbc连接池-1-->  
2. <bean    id="c3p0_dataSource_1"  class="com.mchange.v2.c3p0.ComboPooledDataSource"   destroy-method="close">     
3.     <property name="driverClass">     
4.         <value>${jdbc.driverClass}</value>     
5.     </property>     
6.     <property name="jdbcUrl">     
7.         <value>${mysql.url_1}</value>     
8.        </property>     
9.     <property name="user">     
10.         <value>${jdbc.username}</value>     
11.     </property>     
12.     <property name="password">     
13.         <value>${jdbc.password}</value>     
14.     </property>      
15.     <!--连接池中保留的最小连接数。-->     
16.     <property name="minPoolSize">     
17.            <value>${c3p0.minPoolSize}</value>     
18.        </property>      
19.     <!--连接池中保留的最大连接数。Default: 15 -->     
20.        <property name="maxPoolSize">     
21.         <value>${c3p0.maxPoolSize}</value>     
22.     </property>     
23.     <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->     
24.        <property name="initialPoolSize">     
25.         <value>${c3p0.initialPoolSize}</value>     
26.     </property>   
27.     <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->     
28.        <property name="idleConnectionTestPeriod">     
29.            <value>${c3p0.idleConnectionTestPeriod}</value>     
30.        </property>     
31.    </bean>   
32.      
33. <!------------- jdbc连接池-2------------------->  
34. <bean    id="c3p0_dataSource_2"  class="com.mchange.v2.c3p0.ComboPooledDataSource"   destroy-method="close">     
35.     <property name="driverClass">     
36.         <value>${jdbc.driverClass}</value>     
37.     </property>     
38.     <property name="jdbcUrl">     
39.         <value>${mysql.url_2}</value>     
40.        </property>     
41.     <property name="user">     
42.         <value>${jdbc.username}</value>     
43.     </property>     
44.     <property name="password">     
45.         <value>${jdbc.password}</value>     
46.     </property>      
47.     <!--连接池中保留的最小连接数。-->     
48.     <property name="minPoolSize">     
49.            <value>${c3p0.minPoolSize}</value>     
50.        </property>      
51.     <!--连接池中保留的最大连接数。Default: 15 -->     
52.        <property name="maxPoolSize">     
53.         <value>${c3p0.maxPoolSize}</value>     
54.     </property>     
55.     <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->     
56.        <property name="initialPoolSize">     
57.         <value>${c3p0.initialPoolSize}</value>     
58.     </property>   
59.     <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->     
60.        <property name="idleConnectionTestPeriod">     
61.            <value>${c3p0.idleConnectionTestPeriod}</value>     
62.        </property>     
63.    </bean>  
64.   
65.    <!------------- 更多的链接池配置------------------->  
66.    ......  

STEP 2。将多个数据源都注入到MultiDataSource中

Xml代码  

1.    <bean id="multiDataSource"    class="com.xxx.sql.MultiDataSource">  
2.     <property name="clusterDataSources">  
3.         <list>  
4.             <ref bean="c3p0_dataSource_1" />  
5.             <ref bean="c3p0_dataSource_2" />  
6.             <ref bean="c3p0_dataSource_3" />  
7.             <ref bean="c3p0_dataSource_4" />  
8.             <ref bean="c3p0_dataSource_5" />  
9.             <ref bean="c3p0_dataSource_6" />  
10.             <ref bean="c3p0_dataSource_7" />  
11.             <ref bean="c3p0_dataSource_8" />  
12.         </list>  
13.     </property>  
14.     <property name="mappedDataSources">  
15.         <map>  
16.             <entry key="system" value-ref="c3p0_dataSource_system" />  
17.         </map>  
18.     </property>  
19. </bean>  

STEP 3。像使用标准的DataSource一样，使用MultiDataSource

Xml代码  

1. <!--  iBatis Client配置 将 MultiDataSource 与iBatis Client 绑定-->  
2. <bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">  
3.         <property name="configLocation" value="classpath:SqlMapConfig.xml"/>  
4.     <property name="dataSource" ref="multiDataSource"></property>  
5. </bean>  
6.   
7. <!-- jdbc事务管理配置 将 MultiDataSource 与事务管理器绑定-->  
8. <bean id="jdbc_TransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
9.     <property name="dataSource" ref="multiDataSource"></property>  
10. </bean>  

至此，我们的程序就可以让Spring来管理多库访问了，但请注意，数据库事务仍然限于单库范围（之前已经说过，这里的应用场景不存在跨库的事务）。


6.Java代码使用例子
首先要说明的是，这里我们只是提供了一个简单的使用范例，在范例中，我们还必须手动的调用API，以确定DataSource的路由规则，在实际的应用中，您可以针对自己的业务特点，对此进行封装，以实现相对透明的路由选择

Java代码  

1. public boolean addUserGameInfo(UserGameInfo userGameInfo){  
2.     //1.根据UserGameInfo.uid 进行数据源路由选择  
3.     DataSourceRouter.setRouterStrategy(  
4.             RouterStrategy.SRATEGY_TYPE_CLUSTER ,  
5.             null,  
6.             userGameInfo.getUid());  
7.       
8.     //2.数据库存储  
9.     try {  
10.         userGameInfoDAO.insert(userGameInfo);  
11.         return true;  
12.     } catch (SQLException e) {  
13.         e.printStackTrace();  
14.         logger.debug("Insert UserGameInfo failed. " + userGameInfo.toString());  
15.     }  
16.     return false;  
17. }  

OK，我们的多库横向切分的实验可以暂告一个段落。实际上，要实现一个完整的DAL是非常庞大的工程，而对我们推动巨大的，可能只是很小的一个部分，到处都存在着8-2法则，要如何选择，就看各位看官了！！