如何自定义feign调用实现hystrix超时、异常熔断
更新时间：2021年06月24日 11:48:46 作者：帆影匆匆
这篇文章主要介绍了自定义feign调用实现hystrix超时、异常熔断的操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
需求描述
spring cloud 项目中feign 整合 hystrix经常使用，但是最近发现hystrix功能强大，但是对我们来说有些大材小用。
首先我只需要他的一个熔断作用，就是说请求超时、异常了返回 FeignClient注解中配置的fallback，不需要非阻塞操作、也不需要重试，hystrix 调用feign时候做了线程池隔离处理，这样增加了项目复杂度（线程池参数配置、线程少了请求服务直接拒绝，多了线程得管理。。。）
目前feign 超时之后是直接抛异常的，这样的话虽然是及时熔断了，但是正常的程序逻辑不走了配置的fallback也没有作用，这个配置项得配合 hystrix 才行。
我需要的是这样的效果
try{
feign.api();
}catch(){
return fallback();
}
但是每个feign调用都手动加上try..catch 实在是太low了，最好能写个类似切面一样的玩意。
这时候就想到了 hystrix,既然人家框架已经做了，我直接看下代码，copy不完了么
源码学习
前两天发布了一篇文章也是关于feign、hystrix 调用集成的
基于之前的分析关键代码
HystrixInvocationHandler (feign.hystrix)
@Override
public Object invoke(final Object proxy, final Method method, final Object[] args)
throws Throwable {
.............
// setterMethodMap 封装 hystrixCommand 配置信息（超时时间、是否重试.....）
HystrixCommand<Object> hystrixCommand = new HystrixCommand<Object>(setterMethodMap.get(method)) {
@Override
protected Object run() throws Exception {
....
HystrixInvocationHandler.this.dispatch.get(method).invoke(args);
....
}
@Override
protected Object getFallback() {
.........
}
};
......
return hystrixCommand.execute();
}
按照之前分析源码方式，直接看哪里被调用了就可以看到， hystrix 实际上自己封装了一个 feign.Builer 类名是 feign.hystrix.HystrixFeign.Builder 用的是建造者模式，生成的类是在调用服务时用到
看到 关键的 build() 方法
Feign build(final FallbackFactory<?> nullableFallbackFactory) {
super.invocationHandlerFactory(new InvocationHandlerFactory() {
// 重新定义一个 InvocationHandler 实现 类似 aop效果
@Override public InvocationHandler create(Target target,
Map<Method, MethodHandler> dispatch) {
return new HystrixInvocationHandler(target, dispatch, setterFactory, nullableFallbackFactory);
}
});
super.contract(new HystrixDelegatingContract(contract));
return super.build();
}
spring 动态代理我这里不多说了，核心就是 InvocationHandler (如果是jdk动态代理的话)，那么 feign 这里也是，我们看看feign 调用声明是个接口，实际上是spring 动态代理生成了代理类，调用方法时实际调用的是
java.lang.reflect.InvocationHandler#invoke
方案构想
那么我们只需要借鉴下 hystrix 的方式，自己实现一个feign.build ，将 InvocationHandler 换成自己的，
然后在我们自己的 InvocationHandler 中调用feign 官方的 InvocationHandler 就行,也就是
feign.hystrix.HystrixInvocationHandler#invoke
这个方法中的
this.dispatch.get(method).invoke(args);
这个代码
方案具体代码实现
方案一
自己实现
import feign.Feign;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
/**
* 自定义feign 构建
* @author hgf
*/
public class CusFeignBuilder extends Feign.Builder{
public CusFeignBuilder() {
this.invocationHandlerFactory((target, dispatch) -> {
Class<?> type = target.type();
FeignClient annotation = type.getAnnotation(FeignClient.class);
// 构造 fallback 实例
Object fallBackObj = null;
if (annotation != null && !annotation.fallback().equals(void.class)) {
try {
fallBackObj = annotation.fallback().newInstance();
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
return new CusFeignInvocationHandler(target, dispatch, fallBackObj);
});
}
}
import feign.Feign;
import feign.InvocationHandlerFactory;
import feign.Target;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import static com.eco.common.utils.Md5Util.logger;
import static feign.Util.checkNotNull;
/**
* 自定义的feign调用
*/
@Slf4j
public class CusFeignInvocationHandler implements InvocationHandler {
private final Target target;
private final Map<Method, InvocationHandlerFactory.MethodHandler> dispatch;
private final Object fallbackObj;
private final Map<String, Method> fallbackMethodMap = new ConcurrentHashMap<>();
CusFeignInvocationHandler(Target target, Map<Method, InvocationHandlerFactory.MethodHandler> dispatch, Object fallbackObj) {
this.target = checkNotNull(target, "target");
this.dispatch = checkNotNull(dispatch, "dispatch for %s", target);
this.fallbackObj = fallbackObj;
}
public Object feignInvoke(Object proxy, Method method, Object[] args) throws Throwable {
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();
}
return dispatch.get(method).invoke(args);
}
@Override
public boolean equals(Object obj) {
if (obj instanceof CusFeignInvocationHandler) {
CusFeignInvocationHandler other = (CusFeignInvocationHandler) obj;
return target.equals(other.target);
}
return false;
}
@Override
public int hashCode() {
return target.hashCode();
}
@Override
public String toString() {
return target.toString();
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
return feignInvoke(proxy, method, args);
} catch (Throwable throwable) {
String configKey = Feign.configKey(target.type(), method);
logger.error("{} 请求 出现异常 ==> {}", configKey, throwable.getMessage());
try {
return getFallbackReturn(method, args, throwable);
} catch (Throwable e) {
throw throwable;
}
}
}
/**
* 反射调用 {@link FeignClient#fallback()}生成失败返回值
* @param method 当前feign方法
* @param args 参数
* @param throwable 异常
*/
public Object getFallbackReturn(Method method, Object[] args, Throwable throwable) throws Throwable {
if (fallbackObj == null) {
throw new RuntimeException("fallbackObj is null");
}
String configKey = Feign.configKey(target.type(), method);
Method fallbackMethod = fallbackMethodMap.get(configKey);
if (fallbackMethod == null) {
Class<?> declaringClass = method.getDeclaringClass();
FeignClient annotation = declaringClass.getAnnotation(FeignClient.class);
if (annotation == null) {
throw new RuntimeException("FeignClient annotation not found");
}
// 失败返回
Class<?> fallback = annotation.fallback();
fallbackMethod = fallback.getMethod(method.getName(), method.getParameterTypes());
fallbackMethodMap.put(configKey, fallbackMethod);
}
if (fallbackMethod == null) {
throw new RuntimeException("fallbackMethodMap not found");
}
return fallbackMethod.invoke(fallbackObj, args);
}
}
然后在 spring 容器中注册这个bean就行
@Bean
CusFeignBuilder cusFeignBuilder(){
return new CusFeignBuilder();
}
方案二
集成 sentinel ,今天写博客再回头看源码时候才发现的
加入依赖
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
配置开启
feign.sentinel.enabled=true
手动实现feign 接口，将实体类注册到 spring 中
@Component
public class DeviceApiFallBack implements DeviceApi{
@Override
public ServerResponse<String> login(String appId) {
return ServerResponse.createByErrorMessage("请求失败");
}
}
其实看代码知道原理一样，无非实现方式不一样
两个方案其实都行，方案一自己实现代码量多，方案二sentinel 官方实现，但是需要引入依赖，增加复杂度，而且 接口实现需要注册到spring 中
目前我选的还是方案一，简单。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。
相关文章
springboot cloud使用eureka整合分布式事务组件Seata 的方法
这篇文章主要介绍了springboot cloud使用eureka整合分布式事务组件Seata 的方法 ,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下2021-05-05
Java ProcessBuilder执行多次CMD命令的使用
本文介绍了Java的ProcessBuilder类,该类用于执行外部命令,通过ProcessBuilder,我们可以在Java程序中灵活地执行多次CMD命令,并控制输入输出流以及工作目录等,感兴趣的可以了解一下2024-11-11
这篇文章主要为大家介绍了JAVA中简单的for循环异常踩坑避雷详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-07-07
作者是一个来自河源的大三在校生，以下笔记都是作者自学之路的一些浅薄经验，如有错误请指正，将来会不断的完善笔记，帮助更多的Java爱好者入门2022-03-03
Java中JUC包(java.util.concurrent)下的常用子类
相信大家已经对并发机制中出现的很多的常见知识点进行了总结,下面这篇文章主要给大家介绍了关于Java中JUC包(java.util.concurrent)下的常用子类的相关资料,文中通过图文以及示例代码介绍的非常详细,需要的朋友可以参考下2022-12-12
这篇文章主要介绍了详解Kotlin中的面向对象（二）的相关资料,需要的朋友可以参考下2017-06-06
如何使用Spring+redis实现对session的分布式管理
本篇文章主要介绍了如何使用Spring+redis实现对session的分布式管理，本文主要是在Spring中实现分布式session，采用redis对session进行持久化管理，感兴趣的小伙伴们可以参考一下2018-06-06
Java Swing JRadioButton单选按钮具体使用
这篇文章主要介绍了Java Swing JRadioButton单选按钮具体使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2019-12-12
在web项目中，显示数据一般采用分页显示的，在分页的同时，用户可能还有搜索的需求，也就是模糊查询，所以，我们要在dao写一个可以分页并且可以动态加条件查询的方法。接下来通过本文给大家介绍下2017-02-02
SpringCloud Gateway中断言路由和过滤器的使用详解
这篇文章主要介绍了SpringCloud Gateway中断言路由和过滤器的使用,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2025-04-04
最新评论