基于spring通过多数据源实现多租户应用

背景

将您的 web 应用程序转化为多租户 SaaS 解决方案，介绍了将传统应用转化为saas服务时，需要实现的多租户模型。

多租户模型.gif

简单来说就是以上三种：

 

• 1.租户使用独立的一套应用服务和数据库服务。
  实现思路：每个租户有一个独立的二级域名。通过二级域名访问单独的应用或应用集群，应用访问该租户独立的数据库实例。

• 2.租户合用一组应用服务和单独的数据库服务。
  实现思路：租户在注册时，会分配一个租户编码。当租户通过统一的域名访问系统时，应用会根据用户的会话ID或Token信息，感知用户的租户编码，并根据租户编码，将租户对应的数据源绑定到当前请求中。

• 3.租户合用一组应用服务和单独的数据库服务。
  实现思路：租户在注册时，会分配一个租户编码。当租户通过统一的域名访问系统时，应用会根据用户的会话ID或Token信息，感知用户的租户编码，并根据租户编码，在数据库找到对应的单独表，或是作为条件过滤租户数据。

方案从1到3，数字越大资源使用率越高，但不同的实现方式还是要根据团队的实现情况及应用的特点出发来选择具体的实现方式。
比如：一个web应用，以前是为用户本地部署的方案来开发的。 现在要将该应用部署在公有云上，实现多租户的应用。如果选择1，应用基本不同改动，只是部署起来就会痛苦一些。如果选择3，应用就得做大的修改。所以折中一下，所以选择了方案2。方案2对应用最大的改造就是要实现一个多数据源，通过租户编码加载到对应的数据源。（注：我们建立了一个主数据，通过租户登录的二级域名建立了与租户编码的映射关系。）
下面主要是讲解一下如何在spring中实现多数据源的创建与绑定的关系。

实现

获取租户编码

继承一个org.springframework.web.servlet.handler.HandlerInterceptorAdapter类，拦截所有请求，通过请求的域名地址中获取对应的租户编码。并设置到当前线程的变量中（ThreadLocal)。

 

import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class GoingRestInterceptor extends HandlerInterceptorAdapter {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
...
initTenantCodeInServlet(request);
...

public void initTenantCodeInRest(String path) {
        path = path.replaceAll("http://www.", "").replaceAll("https://www.", "").replaceAll("http://", "").replaceAll("https://", "");
        String[] arr = path.split("/");
        String post = arr[0];
        System.out.println("--=-=-=-=post="+post);
        String[] postArray = post.split("\\.");
        String tenantCode = "";
        if(postArray.length == 3){
            if(StringUtils.isEmpty(postArray[0])){
                throw new BaseException("域名异常");
            }else{
                tenantCode = postArray[0];
            }
        }
        //GoingRequestContext是一个基于ThreadLocal的实现类
        GoingRequestContext.setTenantCode(tenantCode);      
    }

}

编写完成以后，在springmvc的配置中配置该拦截器。

 

    <mvc:interceptors>
        <bean class="GoingRestInterceptor" />
    </mvc:interceptors>

动态路由数据源

根据请求上下文中的租户编码获取对应的数据源。

继承org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource类，实现一个动态数据源类DynamicDataSource，替换原有的数据源实现类。

 

import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

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

public class MultiDataSrouce extends AbstractRoutingDataSource {
        // 保存动态创建的数据源
    private static final Map<String, DataSource> targetDataSource = new HashMap<String, DataSource>();

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        // TODO Auto-generated method stub
        return null;
    }

@Override
    protected DataSource determineTargetDataSource() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    protected String determineCurrentLookupKey() {
        // TODO Auto-generated method stub
        return null;        
    }

}

在该子类中，重载父类的determineCurrentLookupKey方法，通过当前线程中的租户编码作为查询数据源的关键字。

 

    @Override
    protected String determineCurrentLookupKey() {
        return GoingRequestContext.getTenantCode();
    }

在该子类中，重载父类的determineTargetDataSource方法，实现动态获取数据源的逻辑。

 

    @Override
    protected DataSource determineTargetDataSource() {
        // 根据数据库选择方案，拿到要访问的数据库
        String dataSourceName = determineCurrentLookupKey();
        // 根据数据库名字，从已创建的数据库中获取要访问的数据库
        DataSource dataSource = (DataSource) targetDataSource.get(dataSourceName);
        if (null == dataSource) {
            // 从已创建的数据库中获取要访问的数据库，如果没有则创建一个
            dataSource = this.selectDataSource(dataSourceName);
        }
        return dataSource;
    }

其中selectDataSource方法的实现如下：

 

    /**
     * 该方法为同步方法，防止并发创建两个相同的数据库 使用双检锁的方式，防止并发
     * 
     * @param dsName
     * @return
     */
    private synchronized DataSource selectDataSource(String dsName) {
        // 再次从数据库中获取，双检锁
        DataSource obj = (DataSource) this.targetDataSource.get(dsName);
        if (null != obj) {
            return obj;
        }
        // 为空则创建数据库
        DataSource dataSource = this.findAndCreateDataSource(dsName);
        if (null != dataSource) {
            // 将新创建的数据库保存到map中
            this.targetDataSource.put(dsName, dataSource);
            return dataSource;
        } else {
            throw new BaseException("没有相关租户");//创建数据源失败
        }
    }

其中的findAndCreateDataSource方法的实现为：

 

    /**
     * 查询对应数据库的信息
     * 
     * @param dsName
     * @return
     */
     public DataSource findAndCreateDataSource(String dsName) {
        //找到租户的数据源配置信息
        HashMap<String, Datasource> map = FrameworkGlobalMap.getDatasources();
        Datasource datasource = map.get(dsName);
        if (datasource == null) {
            return null;
        } 
        DataSourceCreator dataSourceCreator = GoingInstanceFactory.getInstance(DataSourceCreator.class);
        dataSourceCreator.createC3p0DataSource(datasource);
        DataSource dataSource = (DataSource)GoingInstanceFactory.getInstance(dsName);
        return dataSource;
    }

其中的DataSourceCreator是一个动态创建数据源的实现类,主要的方法实现如下所示：

 

    public void createC3p0DataSource(Datasource datasource) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(ComboPooledDataSource.class);
        builder.addPropertyValue("driverClass", datasource.getDriverClass());
        builder.addPropertyValue("jdbcUrl", datasource.getJdbcUrl());
        LogUtils.getSingleton().debug(datasource.getJdbcUrl());
        builder.addPropertyValue("user", datasource.getUser());
        builder.addPropertyValue("password", datasource.getPassword());
        if (datasource.getIdleConnectionTestPeriod() != null)
            builder.addPropertyValue("idleConnectionTestPeriod", datasource.getIdleConnectionTestPeriod());
        if (datasource.getInitialPoolSize() != null)
            builder.addPropertyValue("initialPoolSize", datasource.getInitialPoolSize());
        if (datasource.getMaxIdleTime() != null)
            builder.addPropertyValue("maxIdleTime", datasource.getMaxIdleTime());
        if (datasource.getMaxPoolSize() != null)
            builder.addPropertyValue("maxPoolSize", datasource.getMaxPoolSize());
        if (datasource.getMinPoolSize() != null)
            builder.addPropertyValue("minPoolSize", datasource.getMinPoolSize());
        this.beanFactory.registerBeanDefinition(datasource.getDatasourceName(), builder.getBeanDefinition());
    }

最后在spring的配置中替换原有datasource:

 

    <bean id="dataSource" class="DynamicDataSource">
        <property name="masterDataSource" ref="masterDataSource"/>
    </bean>