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，上述已经完成；

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