多租户个性化服务路由
1、场景描述
1）不同租户访问同一个地址，tenant100租户有一个个性化服务service-b-100，在API层需要将其路由到service-b-100服务，其它租户则路由到service-b，达到个性化需求。
2）在服务间，service-a调用service-b，tenant100租户访问时需要调用他的个性化服务service-b-100。
例如图1所示：
图1
2、解决方案
设计一张个性化服务表存储租户的个性化服务，如果租户没有个性化服务，则走通用服务，可能需要一个个性化配置页面。路由(path)是租户访问的服务路由；服务名(serviceName)代表某类服务，通常这个服务可以有多个版本或者个性化服务；每个版本或者个性化服务都有一个唯一的服务ID(serviceId)，并且这个服务会注册到Eureka；租户ID(tenantId)则关联了个性化服务。具体如图2所示：
图2
个性化需求的最终目标是找到租户的个性化服务ID，在保证程序代码不变，低侵入性的情况下， 在API层，可以通过路由+租户ID找到服务ID；在服务间调用时，可以通过服务名+租户ID找到服务ID。API层，就算有个性化服务，版本升级，但配置依然保持不变；服务间FeignClient调用，服务名保持不变。
3、API层解决方案
通过查看Zuul的相关源码发现，ZuulHandlerMapping在处理路由映射的时候，会通过路由定位器DiscoveryClientRouteLocator获取配置的路由，从配置ZuulProperties获取路由列表ZuulRoute，即配置的zuul.routes，最终目的也是获取路由对应的服务ID。具体如图3所示：
图3
同时，会从Eureka获取服务列表，并转换成路由映射。具体如图4和图5所示：
图4
图5
所以，我们只需要在获取路由这一步将路由对应的服务ID更改成租户的个性化服务ID即可。注意这里获取的服务ID要将其看成服务名，因为一个服务名会对应多个服务ID。
自定义DiscoveryClientRouteLocator，覆盖locateRoutes方法，核心是customLocateRoutes将从配置文件获取的路由服务与当前租户的个性化路由服务做对比，如果某个路由存在个性化服务，则将个性化服务ID替换成之前的服务ID即可。
/**
* 自定义路由定位器
*/
public class CustomDiscoveryClientRouteLocator extends DiscoveryClientRouteLocator {
private DiscoveryClient discovery;
private ZuulProperties properties;
public CustomDiscoveryClientRouteLocator(String servletPath, DiscoveryClient discovery, ZuulProperties properties) {
super(servletPath, discovery, properties);
this.discovery = discovery;
this.properties = properties;
}
public CustomDiscoveryClientRouteLocator(String servletPath, DiscoveryClient discovery, ZuulProperties properties, ServiceRouteMapper serviceRouteMapper) {
super(servletPath, discovery, properties, serviceRouteMapper);
this.discovery = discovery;
this.properties = properties;
}
/**
* 覆盖获取路由的方法
*/
@Override
protected LinkedHashMap locateRoutes() {
LinkedHashMap routesMap = new LinkedHashMap();
// ****** 只改这一处 ****** //
routesMap.putAll(customLocateRoutes());
// 其它代码不变 复制即可
}
/**
* 获取当前租户的个性化服务，如果从配置文件获取的服务和租户的服务ID不同，则替换成个性化服务.
*/
protected Map customLocateRoutes() {
// 获取当前用户的(特定)路由信息
List tenantRoutes = getCurrentTenantRoute();
HashMap tenantRouteMap = new HashMap<>();
tenantRoutes.forEach(tenantRoute -> {
tenantRouteMap.put(tenantRoute.getPath(), tenantRoute);
});
LinkedHashMap routesMap = new LinkedHashMap<>();
for (ZuulProperties.ZuulRoute route : this.properties.getRoutes().values()) {
if (tenantRouteMap.containsKey(route.getPath())) {
TenantRoute tenantRoute = tenantRouteMap.get(route.getPath());
// 对于某个路由，如/iam/**，如果服务ID不一样，则将个性化服务ID添加进去.
if (!org.apache.commons.lang.StringUtils.equalsIgnoreCase(tenantRoute.getServiceId(), route.getServiceId())) {
routesMap.put(route.getPath(), new ZuulProperties.ZuulRoute(route.getPath(), tenantRoute.getServiceId()));
continue;
}
}
routesMap.put(route.getPath(), route);
}
return routesMap;
}
/**
* 模拟获取当前租户的个性化服务
*/
public List getCurrentTenantRoute() {
List routes = new ArrayList<>();
routes.add(new TenantRoute("/iam/**", "iam-service", "iam-service-100", "tenant100"));
return routes;
}
/**
* 租户路由
*/
class TenantRoute {
private String path;
private String serviceName;
private String serviceId;
private String tenantId;
public TenantRoute(String path, String serviceName, String serviceId, String tenantId) {
this.path = path;
this.serviceName = serviceName;
this.serviceId = serviceId;
this.tenantId = tenantId;
}
// getter/setter
}
} 同时将其注册成Bean，覆盖默认的DiscoveryClientRouteLocator
@Bean
public DiscoveryClientRouteLocator discoveryRouteLocator(DiscoveryClient discovery, ServiceRouteMapper serviceRouteMapper) {
return new CustomDiscoveryClientRouteLocator(this.server.getServletPrefix(), discovery, this.zuulProperties, serviceRouteMapper);
}测试可以看出已经更改成个性化服务了，但是我们的配置文件并没有做任何改动。
测试如图6所示：
4、服务间调用解决方案
服务间调用方式
- RestTemplate：实现HTTP调用，参数列表比较长。
- Ribbon：实现客户端负载均衡，添加@LoadBalanced注解让RestTemplate整合
Ribbon，使其具备负载均衡的能力。
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}- Feign：声明式、模板化的HTTP客户端，帮助我们更加快捷、优雅地调用HTTP API。
- RPC：基于TCP的远程过程调用，这种方式可确保调用性能更加高效，能支持更高的并发量。
这里主要研究了Feign调用的服务个性化。通过查看Feign的相关源码发现，在启动程序的时候，会扫描根路径下有@FeignClient注解的接口，并为其生成代理对象，放入Spring容器中。这个代理类就是feign.Target的实现类feign.Target.HardCodedTarget，Target封装了服务名和地址，这种类型的地址(http://service-id)就是用来做负载均衡的，即请求服务，而不是具体的某个IP地址。
具体如图7所示：
图7
feign.SynchronousMethodHandler是具体的执行处理器，封装了Target和Client，在executeAndDecode方法里，通过client发起负载均衡请求。核心关注的是Request request = targetRequest(template)，在调用client.execute之前，会先通过targetRequest生成feign.Request对象。
具体如图8所示：
图8
在targetRequest方法里，首先应用所有的RequestInterceptor拦截器对RequestTemplate做处理，比如在Header中加入一些信息等。然后调用target.apply对地址做处理，注意此时RequestTemplate中的地址是不带服务上下文地址的，即http://file-service。
具体如图9所示：
在apply方法中，判断RequestTemplate的url是否带有http，如果没有，则将服务上下文地址拼接到地址前面。具体如图10所示：
通过以上分析不难发现，我们只需要更改apply的行为，在这一步将个性化服务ID替换成通用服务ID即可。但是我们无法直接扩展Target并修改apply方法，但可以通过一种变相的方法达到这个目的。通过拦截器，在进入apply方法之前，将个性化服务上下文(比如http://file-service-100)拼接到RequestTemplate.url前，这样apply方法里就不会做处理了。
*首先开发一个存储当前请求服务名称的ThreadLocal
/**
* 存储当前线程请求服务的服务名称
*/
public class ServiceThreadLocal {
private static ThreadLocal serviceNameLocal = new ThreadLocal<>();
public static void set(String serviceName) {
serviceNameLocal.set(serviceName);
}
public static String get() {
String serviceName = serviceNameLocal.get();
serviceNameLocal.remove();
return serviceName;
}
} 开发@FeignClient的切面AOP，拦截到Feign请求时，将服务名放入ThreadLocal中。
@Aspect
@Component
public class FeignClientAspect {
/**
* 拦截 *FeignClient 结尾的接口的所有方法
* 这里无法直接通过注解方式拦截 @FeignClient 注解的接口，因为 FeignClient 只有接口，没有实现(生成的是代理类)
*/
@Before("execution(* *..*FeignClient.*(..))")
public void keepServiceName(JoinPoint joinPoint) {
Type type = joinPoint.getTarget().getClass().getGenericInterfaces()[0];
Annotation annotation = ((Class)type).getAnnotation(FeignClient.class);
if (annotation != null && annotation instanceof FeignClient) {
FeignClient feignClient = (FeignClient) annotation;
// 将服务名放入ThreadLocal中
String serviceName = feignClient.value();
if (StringUtils.isEmpty(serviceName)) {
serviceName = feignClient.name();
}
ServiceThreadLocal.set(serviceName);
}
}
}- 开发RequestInterceptor处理RequestTemplate
/**
* 拦截feign请求，根据服务名称和租户ID动态更改路由
*/
@Component
public class FeignRouteInterceptor implements RequestInterceptor {
@Override
public void apply(RequestTemplate template) {
// 当前租户ID
String currentTenantId = "tenant100";
// 获取当前请求的服务名称
String serviceName = ServiceThreadLocal.get();
// 根据租户ID和服务名称获取真正要请求的服务ID
String serviceId = getCurrentTenantServiceId(currentTenantId, serviceName);
// 核心代码
if (StringUtils.isNotBlank(serviceId)) {
String url;
// 拼接http://
if (!StringUtils.startsWith(serviceId, "http")) {
url = "http://" + serviceId;
} else {
url = serviceId;
}
// 将真正要请求的服务上下文路径拼接到url前
if (!StringUtils.startsWith(template.url(), "http")) {
template.insert(0, url);
}
}
}
/**
* 模拟 根据租户ID和服务名称获取服务ID
*/
public String getCurrentTenantServiceId(String tenantId, String serviceName) {
List tenantRoutes = getCurrentTenantRoute(tenantId);
for (TenantRoute tenantRoute : tenantRoutes) {
if (StringUtils.equalsIgnoreCase(serviceName, tenantRoute.getServiceName())) {
return tenantRoute.getServiceId();
}
}
return serviceName;
}
/**
* 获取租户的个性化服务路由信息
*/
public List getCurrentTenantRoute(String tenantId) {
// 根据tenantId获取个性化服务 一般在登录时就获取出来然后放到ThreadLocal中.
List routes = new ArrayList<>();
routes.add(new TenantRoute("/file/**", "file-service", "file-service-100", "tenant100"));
return routes;
}
/**
* 租户路由信息
*/
class TenantRoute {
private String path;
private String serviceName;
private String serviceId;
private String tenantId;
public TenantRoute(String path, String serviceName, String serviceId, String tenantId) {
this.path = path;
this.serviceName = serviceName;
this.serviceId = serviceId;
this.tenantId = tenantId;
}
// getter/setter
}
} - 测试可以看到RequestTemplate.url已经更改成功了，但是FeignClient的服务名称并没有改变。
具体如图10所示：
图10
通过以上设计方式，在API网关处和Feign调用时做一些处理，达到个性化服务的目的，通过配置页面配置租户的个性化服务，当然，所有的服务都需要注册到Eureka，配置时可以从Eureka拉取服务列表。这样一来，无论是服务多版本，还是定制化服务，都可以在不改代码及配置文件的情况下完成特定服务路由。
5、原文链接地址
https://www.cnblogs.com/chiangchou/p/api.html