SpringCloud+Feign+Hystrix统一FallbackFactory降级处理
SpringCloud+Feign+Hystrix统一FallbackFactory降级处理
- 需求背景
- 源码分析
- 开始编码、改造
-
- 1、自定义FallbackFactory
- 2、覆盖框架源代码：feign.hystrix.HystrixInvocationHandler
- 3、创建统一FallbackFactory处理类：FeignFallbackFactory
- 4、使用
- 备注
需求背景
当使用Spring cloud使用Feign、Hystrix相关技术时候，每个接口类使用@FeignClient注解同时需要要指定fallbackFactory、或者fallback进行降级处理，有些时候我们需要一个统一的处理机制，不想写那么多的FallbackFactory。
源码分析
我们的应用程序中通过引用注解@EnableFeignClients，其通过import导入FeignClientsRegistrar，该类会扫描classpath下面所有@FeignClient注解的接口并且注入到IOC容器，如下：
class FeignClientsRegistrar
implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
// patterned after Spring Integration IntegrationComponentScanRegistrar
// and RibbonClientsConfigurationRegistgrar
// 其他省略代码...
public void registerFeignClients(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
ClassPathScanningCandidateComponentProvider scanner = getScanner();
scanner.setResourceLoader(this.resourceLoader);
Set<String> basePackages;
Map<String, Object> attrs = metadata
.getAnnotationAttributes(EnableFeignClients.class.getName());
AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
FeignClient.class);
final Class<?>[] clients = attrs == null ? null
: (Class<?>[]) attrs.get("clients");
if (clients == null || clients.length == 0) {
scanner.addIncludeFilter(annotationTypeFilter);
basePackages = getBasePackages(metadata);
}
else {
final Set<String> clientClasses = new HashSet<>();
basePackages = new HashSet<>();
for (Class<?> clazz : clients) {
basePackages.add(ClassUtils.getPackageName(clazz));
clientClasses.add(clazz.getCanonicalName());
}
AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
@Override
protected boolean match(ClassMetadata metadata) {
String cleaned = metadata.getClassName().replaceAll("\\$", ".");
return clientClasses.contains(cleaned);
}
};
scanner.addIncludeFilter(
new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
}
for (String basePackage : basePackages) {
Set<BeanDefinition> candidateComponents = scanner
.findCandidateComponents(basePackage);
for (BeanDefinition candidateComponent : candidateComponents) {
if (candidateComponent instanceof AnnotatedBeanDefinition) {
// verify annotated class is an interface
AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
Assert.isTrue(annotationMetadata.isInterface(),
"@FeignClient can only be specified on an interface");
Map<String, Object> attributes = annotationMetadata
.getAnnotationAttributes(
FeignClient.class.getCanonicalName());
String name = getClientName(attributes);
registerClientConfiguration(registry, name,
attributes.get("configuration"));
registerFeignClient(registry, annotationMetadata, attributes);
}
}
}
}
private void registerFeignClient(BeanDefinitionRegistry registry,
AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
String className = annotationMetadata.getClassName();
BeanDefinitionBuilder definition = BeanDefinitionBuilder
.genericBeanDefinition(FeignClientFactoryBean.class);
validate(attributes);
definition.addPropertyValue("url", getUrl(attributes));
definition.addPropertyValue("path", getPath(attributes));
String name = getName(attributes);
definition.addPropertyValue("name", name);
String contextId = getContextId(attributes);
definition.addPropertyValue("contextId", contextId);
definition.addPropertyValue("type", className);
definition.addPropertyValue("decode404", attributes.get("decode404"));
definition.addPropertyValue("fallback", attributes.get("fallback"));
definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
String alias = contextId + "FeignClient";
AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
boolean primary = (Boolean) attributes.get("primary"); // has a default, won't be
// null
beanDefinition.setPrimary(primary);
String qualifier = getQualifier(attributes);
if (StringUtils.hasText(qualifier)) {
alias = qualifier;
}
BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
new String[] { alias });
BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}
// 其他省略代码...
}
在FeignAutoConfiguration中，定义了Bean HystrixTargeter，该类设置了接口与fallbackFactory的关系并最终在HystrixInvocationHandler类中完成绑定，关键就是在这里了，这个一个JDK的动态代理类。
final class HystrixInvocationHandler implements InvocationHandler {
// 其他省略代码...
@Override
public Object invoke(final Object proxy, final Method method, final Object[] args)
throws Throwable {
// early exit if the invoked method is from java.lang.Object
// code is the same as ReflectiveFeign.FeignInvocationHandler
if ("equals".equals(method.getName())) {
try {
Object otherHandler =
args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
return equals(otherHandler);
} catch (IllegalArgumentException e) {
return false;
}
} else if ("hashCode".equals(method.getName())) {
return hashCode();
} else if ("toString".equals(method.getName())) {
return toString();
}
HystrixCommand<Object> hystrixCommand =
new HystrixCommand<Object>(setterMethodMap.get(method)) {
@Override
protected Object run() throws Exception {
try {
return HystrixInvocationHandler.this.dispatch.get(method).invoke(args);
} catch (Exception e) {
throw e;
} catch (Throwable t) {
throw (Error) t;
}
}
@Override
protected Object getFallback() {
if (fallbackFactory == null) {
return super.getFallback();
}
try {
Object fallback = ((ExtFallbackFactory)fallbackFactory).create(method, getExecutionException());
Object result = fallbackMethodMap.get(method).invoke(fallback, args);
// 其他省略代码...
}
};
// 其他省略代码...
}
}
可以看到如果指定了fallback，优先fallback回调，可以看到下面代码调用fallbackFactory.create进行降级回调。
Object fallback = ((ExtFallbackFactory)fallbackFactory).create(method, getExecutionException());
Object result = fallbackMethodMap.get(method).invoke(fallback, args);
FallbackFactory仅仅提供了一个T create(Throwable cause);方法，仅仅通过cause无法解析出更好的信息出来，另外FallbackFactory的泛型必须和接口匹配，否则会报错
开始编码、改造
1、自定义FallbackFactory
- 定义一个抽象类实现接口FallbackFactory，覆盖调原来的create(Throwable)方法，自定义一个抽象方法，如下
public abstract class ExtFallbackFactory<T> implements FallbackFactory<T> {
@Override
public T create(Throwable cause) {
// donothing
return null;
}
// 需要method获取对应的接口class
public abstract T create(Method method, Throwable cause);
}
2、覆盖框架源代码：feign.hystrix.HystrixInvocationHandler
复制框架原有的feign.hystrix.HystrixInvocationHandler源码，Copy放到我们应用服务的src/main目录下对应的目录下（feign.hystrix），达到覆盖原有代码的目的，具体改动如下：
//注释掉原有的
//Object fallback = ((ExtFallbackFactory)fallbackFactory).create(getExecutionException());
//这里改成我们自己的
Object fallback = ((ExtFallbackFactory)fallbackFactory).create(method, getExecutionException());
3、创建统一FallbackFactory处理类：FeignFallbackFactory
@Slf4j
@Component
public class FeignFallbackFactory<T> extends ExtFallbackFactory<T> {
private static final ThrowableAnalyzer THROWABLE_ANALYZER = new DefaultThrowableAnalyzer();
@Override
public T create(Method method, Throwable cause) {
return createFallbackService(cause, method.getDeclaringClass());
}
private T createFallbackService(Throwable ex, Class<?> targetClass) {
Throwable[] causeChain = THROWABLE_ANALYZER.determineCauseChain(ex);
RetryableException ase1 = (RetryableException) THROWABLE_ANALYZER.getFirstThrowableOfType(RetryableException.class, causeChain);
log.error("服务出错了", ex);
if (ase1 != null) {
return toResponse("服务[{}]接口调用超时！", ase1.request());
}
FeignException ase2 = (FeignException) THROWABLE_ANALYZER.getFirstThrowableOfType(FeignException.class, causeChain);
if (ase2 != null) {
return toResponse("服务[{}]接口调用出错了！", ase2.request());
}
// 创建一个JDK代理类
return ProxyUtil.newProxyInstance((proxy, method, args) -> XCloudResponse.failed(ex.getMessage()), targetClass);
}
private T toResponse(String respMsg, Request request) {
Target<?> target = request.requestTemplate().feignTarget();
Class<?> targetClazz = target.type();
String serviceName = target.name();
return ProxyUtil.newProxyInstance((proxy, method, args) -> XCloudResponse.failed(StrUtil.format(respMsg, serviceName)), targetClazz);
}
}
4、使用
在Feign接口上添加注解，指定FallbackFactory，如下：
@FeignClient(value = "${serviceName}", fallbackFactory = FeignFallbackFactory.class)
备注
类ProxyUtil是hutool工具包的，用于创建动态代理类
类XCloudResponse是自定义封装的，如下
@Getter
@ToString
public class XCloudResponse<T> implements Serializable {
/**
* 状态码
*/
private int code;
/**
* 响应消息
*/
private String msg;
/**
* 消息负载
*/
private T payload;
public XCloudResponse() {
}
public XCloudResponse(int code, String message, T payload) {
this.code = code;
this.msg = message;
this.payload = payload;
}
public static <T> XCloudResponse<T> failed(String message) {
return failed(BAD_REQUEST, message);
}
// 此处省略代码....
}