SSH框架中根据不同的用户切换到对应的数据库

特别是SAAS应用系统，一般的我们会为每个公司客户创建一个对应的数据库，然而我们肯定不会为每个客户部署一台服务器，这样应用系统就存在如何在多个数据库中自动切换的问题；

首先创建我们自己的数据源实现类，如下：

package whf.framework.jdbc;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.jdbc.datasource.DriverManagerDataSource;

import whf.framework.config.Configuration;
import whf.framework.config.PropertiesConfiguration;
import whf.framework.ext.entity.Database;
import whf.framework.ext.service.DatabaseServiceImp;
import whf.framework.log.Log;
import whf.framework.log.LogFactory;
import whf.framework.meta.Meta;
import whf.framework.security.UserContext;
import whf.framework.service.SpringService;
import whf.framework.util.StringUtils;
import whf.framework.util.ThreadContext;
import whf.framework.util.Utils;

/**
* 可以根据上下文,动态分派数据库联接的数据源<br>
* 搜索数据源的顺序:<br>
* 1.线程当前数据源名称(手工输入的,优先级最高)
* 2.从对象定义中获取;
* 3.获取用户当前所在的数据源分支,从UserContext中获取;
* 4.使用缺省
* @author King
*
*/
public class SwitchableDataSource extends SpringService implements DataSource {
private static Log log = LogFactory.getLog(SwitchableDataSource.class);
private Map<String, DataSource> registeredDataSources = Utils.newHashMap();
private static String defaultDataSourceName;
public void setRegisteredDataSources(Map<String, DataSource> registeredDataSource) {
this.registeredDataSources = registeredDataSource;
}

public void setDefaultDataSourceName(String defaultDataSourceName) {
SwitchableDataSource.defaultDataSourceName = defaultDataSourceName;
}
//
private Configuration jdbcConfiguration;
private synchronized void registerDataSource(String dataSourceName) {
if(this.registeredDataSources.containsKey(dataSourceName)) return;
if(this.jdbcConfiguration == null) {
try{
this.jdbcConfiguration = new PropertiesConfiguration(SwitchableDataSource.class.getResource("/conf/jdbc.properties"));;
}catch(Exception e){
throw new RuntimeException(e);
}
}
String driverClassName = this.jdbcConfiguration.getString("jdbc." + dataSourceName + ".driverClassName");
if(StringUtils.isEmpty(driverClassName)) driverClassName = this.jdbcConfiguration.getString("jdbc.driverClassName");
String username = null;
String password = null;
String url = this.jdbcConfiguration.getString("jdbc." + dataSourceName + ".url");
if(!StringUtils.isEmpty(url)) {
username = this.jdbcConfiguration.getString("jdbc." + dataSourceName + ".username");
password = this.jdbcConfiguration.getString("jdbc." + dataSourceName + ".password");
} else {
try{
Database db = DatabaseServiceImp.getDatabaseService().findByCode(dataSourceName);
url = db.getUrl();
username = db.getUsername();
password = db.getPassword();
}catch(Exception e){
throw new RuntimeException(e);
}
}
this.registeredDataSources.put(dataSourceName, new DriverManagerDataSource(driverClassName, url, username, password));
}
public final DataSource getDataSource(String dataSourceName) {
if(!this.registeredDataSources.containsKey(dataSourceName)) {
this.registerDataSource(dataSourceName);
}
return this.registeredDataSources.get(dataSourceName);
}

public final DataSource getDefaultDataSource() {
return this.getDataSource(defaultDataSourceName);
}
private DataSource getCurrentDataSource() {
return this.getDataSource(getCurrentDataSourceName());
}
/**
* @return 获取当前线程的数据源
*/
public final static String getCurrentDataSourceName() {
String dsn = ThreadContext.getCurrentDataSourceName();
Meta meta = ThreadContext.getCurrentMeta();
if(meta != null && StringUtils.isEmpty(dsn)) {
dsn = meta.getBranch();
}
if(StringUtils.isEmpty(dsn)) {
UserContext uc = ThreadContext.getUserContext();
if(uc != null)
dsn = uc.getBranch();
}
if(StringUtils.isEmpty(dsn))
dsn = defaultDataSourceName;
log.debug("DataSourceName: "+dsn + "\n");
return dsn;
}

@Override
public int getLoginTimeout() throws SQLException {
return this.getCurrentDataSource().getLoginTimeout();
}

@Override
public PrintWriter getLogWriter() throws SQLException {
return this.getCurrentDataSource().getLogWriter();
}

@Override
public void setLoginTimeout(int seconds) throws SQLException {
this.getCurrentDataSource().setLoginTimeout(seconds);
}

@Override
public void setLogWriter(PrintWriter out) throws SQLException {
this.getCurrentDataSource().setLogWriter(out);
}

@Override
public Connection getConnection() throws SQLException {
return this.getCurrentDataSource().getConnection();
}

@Override
public Connection getConnection(String username, String password) throws SQLException {
return this.getCurrentDataSource().getConnection(username, password);
}

@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
return this.getCurrentDataSource().isWrapperFor(iface);
}

@Override
public <T> T unwrap(Class<T> iface) throws SQLException {
return this.getCurrentDataSource().unwrap(iface);
}

@Override
public void afterPropertiesSet() throws Exception {
if(StringUtils.isEmpty(defaultDataSourceName))
throw new Exception("Default datasource name can not be empty!");
if(this.registeredDataSources.get(defaultDataSourceName) == null)
throw new Exception("Can not found default datasource for default dataSourceName:" + defaultDataSourceName);
super.afterPropertiesSet();
}
public static void main(String[] args) throws Exception {
System.out.println(SwitchableDataSource.class.getResource("/conf/jdbc.properties"));
}
}

这个数据源切换期可以按照三种方式切换：

1 在线程上下文环境中设置，参考whf.framework.util.ThreadContext.setCurrentDataSourceName, 在具体应用中这个也具有最高优先级，主要满足一些特殊的需要，限定某些操作只能在某个数据库中处理；

2 根据对象配置，如果当前操作的对象必须在某个数据库中，例如一些配置数据，可以限定为从某个自定的数据库中存取；

3 根据当前操作用户；

第二步 部署数据源到Spring

<bean id="dataSource" class="whf.framework.jdbc.SwitchableDataSource">
<property name="defaultDataSourceName">
<value>framework</value>
</property>
<property name="registeredDataSources">
<map>
<entry key="framework">
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>${jdbc.framework.driverClassName}</value>
</property>
<property name="url">
<value>${jdbc.framework.url}</value>
</property>
<property name="username">
<value>${jdbc.framework.username}</value>
</property>
<property name="password">
<value>${jdbc.framework.password}</value>
</property>
</bean>
</entry>
<entry key="monica">
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>${jdbc.monica.driverClassName}</value>
</property>
<property name="url">
<value>${jdbc.monica.url}</value>
</property>
<property name="username">
<value>${jdbc.monica.username}</value>
</property>
<property name="password">
<value>${jdbc.monica.password}</value>
</property>
</bean>
</entry>
</map>
</property>
</bean>


其中参数使用Spring的properties设置，如

<bean id="jdbcConfiguration" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location"
value="classpath:conf/jdbc.properties" />
</bean>

最后就是调用

首先用户的数据库是需要可识别的，因此用户必须有一个（用户所属组织）参数，用以识别对应的数据库；在用户登录时，需要三个参数：所属组织，用户名，密码

ok，上述已经完成；

完整代码参考：[url]http://whfframework.googlecode.com/svn/trunk/[/url]