手把手教你快速将Spring cloud开发框架的系统SAAS化

69 阅读 0 评论 46 点赞

我是靠谱客的博主风中毛巾，最近开发中收集的这篇文章主要介绍手把手教你快速将Spring cloud开发框架的系统SAAS化，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Spring cloud 使用feign+mybatie-plus的dynamic-datasource来实现动态数据源切换

接上一篇手把手教你快速将DUBBO开发框架的系统SAAS化文章，再来对一些springcloud的项目进行SAAS改造，
众所周知的是spring cloud基于springboot 做业务微服务，eurka做服务发现，zuul做网关，config做配置管理等组件构建了一套在7层上通讯的完整架构，各个微服务之间由feign（http协议的封装）+ribbon（负载均衡）来完成服务与服务之间的调用。

几个关键的技术点：
1 com.alibaba.ttl.TransmittableThreadLocal
2 com.baomidou.dynamic.datasource.DynamicRoutingDataSource
3 OkHttpClient，okhttp3.Interceptor
4 org.springframework.web.filter.OncePerRequestFilter

Step 1 在请求中携带租户标识

package cn.mwcare.framework.config.openfeign.okhttp;

import java.io.IOException;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;

import com.alibaba.ttl.TransmittableThreadLocal;

import lombok.extern.java.Log;
import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import org.springframework.util.StringUtils;

/**
*

@author arthur

*/
@Log
public class OkHttpLogInterceptor implements Interceptor {
private final String TENANTPREFIX = “tenantPrefix”;
private final String TENANTPREFIX_DEFAULT = “master”;

private static final String TX_XID = "TX_XID";
@Autowired
ApplicationContext context;
static TransmittableThreadLocal<String> contextparam = new TransmittableThreadLocal<>();
private static String tenantPrefixtx = null;
// 提供线程局部变量set方法
public static void setTenantPrefix(String tenantPrefix) {
tenantPrefixtx = tenantPrefix;
contextparam.copy(tenantPrefixtx);
contextparam.set(tenantPrefixtx);
}
// 提供线程局部变量get方法
public static String getTenantPrefix() {
return contextparam.get();
}
/**
* 清空 threadLocal 保存的对象
*
* @return
*/
public static void clear() {
contextparam.remove();
}
@Override
public Response intercept(Chain chain) throws IOException {
// 这个chain里面包含了request和response，所以你要什么都可以从这里拿
Request request = chain.request();
// 如果存在 tenantDomain 添加请求头
String tenantPrefix = tenantPrefixtx;
Request.Builder requestBuilder = request.newBuilder();
if (tenantPrefix != null) {
requestBuilder.addHeader(TENANTPREFIX, tenantPrefix.toString());
OkHttpLogInterceptor.clear();
} else {
requestBuilder.addHeader(TENANTPREFIX, TENANTPREFIX_DEFAULT);
OkHttpLogInterceptor.clear();
}
// for hystrix 线程池 模式 传递 XID
String tx_xid = request.header(TX_XID);
if (StringUtils.isEmpty(tx_xid)) {
if (TransmittableThreadLocalContext.get(TX_XID) != null) {
String xid = TransmittableThreadLocalContext.get(TX_XID).toString();
requestBuilder.addHeader(TX_XID, xid);
}
}
request = requestBuilder.build();
// 请求发起的时间
long t1 = System.nanoTime();
log.info(String.format("发送请求 %s on %s%n%s", request.url(), chain.connection(), request.headers()));
Response response = chain.proceed(request);
// 收到响应的时间
long t2 = System.nanoTime();
// 这里不能直接使用response.body().string()的方式输出日志
// 因为response.body().string()之后，response中的流会被关闭，程序会报错，我们需要创建出一
// 个新的response给应用层处理
ResponseBody responseBody = response.peekBody(1024 * 1024);
String jsonResponseBody = responseBody.string();
/*
* Result rs = JSON.parseObject(jsonResponseBody, Result.class); if (500 ==
* rs.getCode()) { throw new RenException(rs.getMsg(), rs.getCode()); }
*/
log.info(String.format("接收响应: [%s] %n返回json:【%s】 %.1fms%n%s", response.request().url(), jsonResponseBody,
(t2 - t1) / 1e6d, response.headers()));
return response;
}

}

也就是从 controller–> service 是使用feign完成的远程调用,这个时候 OkHttpLogInterceptor.setTenantPrefix(“System”);
在intercept 方法中 requestBuilder.addHeader(TENANTPREFIX, tenantPrefix.toString()); 这个时候feign调用的http请求头中完成了参数的上下文传递。

Step 2 在服务中加载多数据源

package cn.mwcare.framework.dynamicdatasources;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import com.alibaba.druid.filter.Filter;
import com.alibaba.druid.wall.WallConfig;
import com.alibaba.druid.wall.WallFilter;
import com.alibaba.druid.wall.WallFilterMBean;
import com.baomidou.dynamic.datasource.DynamicRoutingDataSource;
import com.baomidou.dynamic.datasource.creator.DruidDataSourceCreator;
import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DataSourceProperty;
import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.druid.DruidConfig;
import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.druid.DruidStatConfig;
import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.druid.DruidWallConfig;

import cn.mwcare.tenant.application.service.client.TenantServiceClient;
import cn.mwcare.tenant.domain.repository.entity.SysTenantAppDbEntity;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.sql.DataSource;

/**

初始化该服务的数据源
@author arthur

*/
@Component(“dynamicRoutingDataSourceConfig”)
@Slf4j
public class DynamicRoutingDataSourceConfig implements ApplicationRunner { // implements ApplicationListener {
@Value("${spring.application.name}")
private String APP_ID;

@Autowired(required = false)
TenantServiceClient tenantServiceClient;
@Autowired
private DruidDataSourceCreator druidDataSourceCreator;
@Autowired
DynamicRoutingDataSource ds;
@Override
public void run(ApplicationArguments args) {

// Thread.sleep(2000l);
DynamicRoutingDataSourceConfig.addCheckDS(APP_ID, null, tenantServiceClient, druidDataSourceCreator, ds);

}
public static boolean addCheckDS(String appId, String tenantPrifx, TenantServiceClient tenantServiceClient, DruidDataSourceCreator druidDataSourceCreator, DynamicRoutingDataSource ds) {
boolean ishavaDatasour = false;
try {
if (!StringUtils.isEmpty(tenantPrifx) && tenantPrifx.equals("master")) {
log.info("Ds {} is exits ,unnecessary check -------!!!", tenantPrifx);
return true;
}
List<SysTenantAppDbEntity> tenantConfigEntities = tenantServiceClient.findTenantMysqlDbData(appId);
for (SysTenantAppDbEntity entity : tenantConfigEntities) {
String beanKey = entity.getTenantPrefix();
if (!StringUtils.isEmpty(tenantPrifx) && tenantPrifx.equals(beanKey)) {
ishavaDatasour = true;
}
DataSourceVO dto = new DataSourceVO();
dto.setPoolName(beanKey);
dto.setDriverClassName(entity.getDbDriverClassName());
dto.setUrl(entity.getDbUrl());
dto.setUsername(entity.getDbUserName());
dto.setPassword(entity.getDbPassWord());
DataSourceProperty dataSourceProperty = new DataSourceProperty();
BeanUtils.copyProperties(dto, dataSourceProperty);
dataSourceProperty.setLazy(false);
dataSourceProperty.setDruid(DynamicRoutingDataSourceConfig.initDruidConfig());
DataSource dataSource = druidDataSourceCreator.createDataSource(dataSourceProperty);
ds.addDataSource(beanKey, dataSource);
System.out.println("add tenant app datasource : {" + beanKey + "},{" + appId + "} sucess!!!");
}
return ishavaDatasour;
} catch (Exception e) {
if (log.isErrorEnabled()) {
System.out.println("get dynamic other datasource is null pleas check APP : {" + appId + "} tenant datasources config!!!! reason: {" + e.getMessage() + "}");
}
log.warn("get dynamic other datasource is null pleas check APP : {} tenant datasources config!!!! reason: {}", appId, e.getMessage());
}
return ishavaDatasour;
}
public static DruidConfig initDruidConfig() {
DruidConfig dcf = new DruidConfig();
dcf.setInitialSize(20);
dcf.setMaxActive(1000);
dcf.setMinIdle(150);
dcf.setMaxWait(60000);
dcf.setPoolPreparedStatements(true);
dcf.setUseGlobalDataSourceStat(true);
dcf.setMaxPoolPreparedStatementPerConnectionSize(20);
dcf.setTimeBetweenEvictionRunsMillis(600000L);
dcf.setMinEvictableIdleTimeMillis(1800000L);
dcf.setInitConnectionSqls("SET NAMES utf8mb4");
dcf.setTestWhileIdle(true);
dcf.setTestOnBorrow(true);
dcf.setTestOnReturn(false);
dcf.setRemoveAbandoned(true);
dcf.setRemoveAbandonedTimeoutMillis(120);
dcf.setLogAbandoned(true);
DruidStatConfig dsc = new DruidStatConfig();
dsc.setLogSlowSql(true);
dsc.setMergeSql(false);
dsc.setSlowSqlMillis(3000L);
dcf.setStat(dsc);
DruidWallConfig wallconfig = new DruidWallConfig();
wallconfig.setMultiStatementAllow(true);
dcf.setWall(wallconfig);
return dcf;
}

}

implements ApplicationRunner 表示服务启动后执行 run 方法,
TenantServiceClient tenantServiceClient; 这个接口的服务要优先启动,
整个过程如就是启动服务，从接口获取该服务分配了哪些数据源
ds.addDataSource(beanKey, dataSource);
将数据源加载到ioc容器中

Step3 依据携带的租户标识进行数据源的选择
package cn.mwcare.framework.dynamicdatasources;

import java.io.IOException;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import com.baomidou.dynamic.datasource.DynamicRoutingDataSource;
import com.baomidou.dynamic.datasource.creator.DruidDataSourceCreator;

import cn.mwcare.framework.config.openfeign.okhttp.OkHttpLogInterceptor;
import cn.mwcare.tenant.application.service.client.TenantServiceClient;
import lombok.extern.slf4j.Slf4j;

/**

效验检查请求中的租户标识
@author arthur

*/
@Slf4j
public class CheckDSFilter extends OncePerRequestFilter {

private String APP_ID;
private TenantServiceClient tenantServiceClient;
private DruidDataSourceCreator druidDataSourceCreator;
private ApplicationContext context;
private final String TENANTPREFIX = "tenantPrefix";
private final String TENANTPREFIX_DEFAULT = "master";
public CheckDSFilter(String APP_ID, TenantServiceClient tenantServiceClient, DruidDataSourceCreator druidDataSourceCreator, ApplicationContext context) {
this.APP_ID = APP_ID;
this.tenantServiceClient = tenantServiceClient;
this.druidDataSourceCreator = druidDataSourceCreator;
this.context = context;
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
String tenantPrefix = request.getHeader(TENANTPREFIX);
if (APP_ID.contains("boss")) {
OkHttpLogInterceptor.setTenantPrefix(TENANTPREFIX_DEFAULT);
filterChain.doFilter(request, response);
return;
}
if (StringUtils.isEmpty(tenantPrefix)) {
filterChain.doFilter(request, response);
return;
}

// log.info(“CheckDSFilter -----------------APP_ID:{}----------- tenantPrefix : {}”, APP_ID, tenantPrefix);
// if (log.isErrorEnabled()) {
// System.out.println((“CheckDSFilter -----------------APP_ID:{” + APP_ID + “}----------- tenantPrefix : {” + tenantPrefix + “}”));
// }
try {
DynamicRoutingDataSource ds = context.getBean(DynamicRoutingDataSource.class);
if (tenantPrefix != null && !tenantPrefix.equals(TENANTPREFIX_DEFAULT) && ds.getCurrentDataSources().get(tenantPrefix) == null) {
boolean ishavaDs = DynamicRoutingDataSourceConfig.addCheckDS(APP_ID, tenantPrefix, tenantServiceClient, druidDataSourceCreator, ds);
if (!ishavaDs) {
tenantPrefix = TENANTPREFIX_DEFAULT;
}
}
} catch (Exception e) {
if (log.isErrorEnabled() || !log.isInfoEnabled()) {
System.out.println("!!! check datasource fail ,tenantPrefix is {" + tenantPrefix + "} “);
}
log.warn(”!!! check datasource fail ,tenantPrefix is {} ", tenantPrefix);
}
OkHttpLogInterceptor.setTenantPrefix(tenantPrefix);
filterChain.doFilter(request, response);
}
}