Feign针对每个接口单独设置超时

于 2025-06-22 15:58:05 发布
阅读量586 收藏 6
点赞数 3
CC 4.0 BY-SA版权
分类专栏： # spring-framework Java中间件 文章标签： java Feign 单个接口超时
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/demon7552003/article/details/148828524

背景

Feign可以通过配置文件来定义调用服务器端REST API的超时设置，可以指定全局超时，也可以指定声明@FeignClient的单个Client，但是不可以设置Client中的每个接口方法的超时。由于项目中部分接口需要较大的超时，如果通过单独定义一个额外的Client，则需要调整大量代码，那能否通过底层框架解决呢。

Feign原理

Spring Cloud Open Feign 针对每个@FeignClient声明的每个接口，通过动态代理生成一个代理类，InvocationHandler的实现类为feign.ReflectiveFeign.FeignInvocationHandler。

static class FeignInvocationHandler implements InvocationHandler {

    private final Target target;
    private final Map<Method, MethodHandler> dispatch;

    FeignInvocationHandler(Target target, Map<Method, MethodHandler> dispatch) {
      this.target = checkNotNull(target, "target");
      this.dispatch = checkNotNull(dispatch, "dispatch for %s", target);
    }

    @Override
    public Object invoke(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);
    }

dispatch的MethodHandler具体实现为SynchronousMethodHandler

final class SynchronousMethodHandler implements MethodHandler {
    public Object invoke(Object[] argv) throws Throwable {
        RequestTemplate template = buildTemplateFromArgs.create(argv);
            //每次调用，如果Feign的接口方法，有Options 参数，则单独设置超时。
        Options options = findOptions(argv);
        Retryer retryer = this.retryer.clone();
        while (true) {
          try {
            return executeAndDecode(template, options);
          } catch (RetryableException e) {
            try {
              retryer.continueOrPropagate(e);
            } catch (RetryableException th) {
              Throwable cause = th.getCause();
              if (propagationPolicy == UNWRAP && cause != null) {
                throw cause;
              } else {
                throw th;
              }
            }
            if (logLevel != Logger.Level.NONE) {
              logger.logRetry(metadata.configKey(), logLevel);
            }
            continue;
          }
        }
  }
}

Sentinel的扩展

Sentinel对Feign进行了扩展，以便进行埋点。

public class SentinelInvocationHandler implements InvocationHandler {
    private final Target<?> target;

	private final Map<Method, MethodHandler> dispatch;

	private FallbackFactory fallbackFactory;

	private Map<Method, Method> fallbackMethodMap;
    
@Override
	public Object invoke(final Object proxy, final Method method, final Object[] args)
			throws Throwable {
		// ......
		Object result;
		MethodHandler methodHandler = this.dispatch.get(method);
		// only handle by HardCodedTarget
		if (target instanceof Target.HardCodedTarget) {
			Target.HardCodedTarget hardCodedTarget = (Target.HardCodedTarget) target;
			MethodMetadata methodMetadata = SentinelContractHolder.METADATA_MAP
					.get(hardCodedTarget.type().getName()
							+ Feign.configKey(hardCodedTarget.type(), method));
			// resource default is HttpMethod:protocol://url
			if (methodMetadata == null) {
				result = methodHandler.invoke(args);
			}
			else {
				String resourceName = methodMetadata.template().method().toUpperCase()
						+ ":" + hardCodedTarget.url() + methodMetadata.template().path();
				Entry entry = null;
				try {
					ContextUtil.enter(resourceName);
					entry = SphU.entry(resourceName, EntryType.OUT, 1, args);
                    //调用的是  SynchronousMethodHandler 方法。
					result = methodHandler.invoke(args);
				}
				catch (Throwable ex) {
					// fallback handle
					if (!BlockException.isBlockException(ex)) {
						Tracer.traceEntry(ex, entry);
					}
					if (fallbackFactory != null) {
						try {
							Object fallbackResult = fallbackMethodMap.get(method)
									.invoke(fallbackFactory.create(ex), args);
							return fallbackResult;
						}
						catch (IllegalAccessException e) {
							// shouldn't happen as method is public due to being an
							// interface
							throw new AssertionError(e);
						}
						catch (InvocationTargetException e) {
							throw new AssertionError(e.getCause());
						}
					}
					else {
						// throw exception if fallbackFactory is null
						throw ex;
					}
				}
				finally {
					if (entry != null) {
						entry.exit(1, args);
					}
					ContextUtil.exit();
				}
			}
		}
		else {
			// other target type using default strategy
			result = methodHandler.invoke(args);
		}

		return result;
	}    
}

启用Sentinel Feign

feign:
  sentinel:
    enabled: true

解决方案

既然底层是通过额外的参数进行了超时设置，那么是否可以通过对bean实现代理解决呢?

可以通过BeanPostProcessor的实现进行操作。

源码

DynamicTimeoutFeginInvocationHandler

代理接口实现：

package com.jurassic.cloud.sample.config;

import feign.Request;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.web.bind.annotation.RequestMapping;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

/**
 * @author lihz
 * @date 2024/11/10
 */
@RequiredArgsConstructor
public class DynamicTimeoutFeginInvocationHandler implements InvocationHandler {

    final private Object targetObject;

    final private DynamicTimeoutFeignConfiguration.FeignTimeoutOption timeoutOption;

    private Map<Method, Holder> holders = new HashMap<>(16);

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getDeclaringClass() == Object.class) {
            return method.invoke(targetObject, args);
        }
        if (timeoutOption.getConfig().isEmpty()) {
            return method.invoke(targetObject, args);
        }

        if (holders.containsKey(method)) {
            Holder holder = holders.get(method);
            Object[] newArgs = additionalArgs(args, holder.getOptions());
            return holder.getHandler().invoke(targetObject, method, newArgs);
        }

        RequestMapping annotation = AnnotatedElementUtils.findMergedAnnotation(method, RequestMapping.class);

        if (annotation != null) {
            String[] value = annotation.value();
            for (String s : value) {
                if (timeoutOption.getConfig().containsKey(s)) {
                    DynamicTimeoutFeignConfiguration.FeignTimeoutOptionInfo feignTimeoutOptionInfo = timeoutOption.getConfig().get(s);
                    Request.Options options = new Request.Options(
                            feignTimeoutOptionInfo.getConnectTimeout()
                            , feignTimeoutOptionInfo.getReadTimeout()
                    );

                    InvocationHandler handler = Proxy.getInvocationHandler(targetObject);
                    Object[] newArgs = additionalArgs(args, options);

                    holders.put(method, new Holder(handler, options));

                    return handler.invoke(targetObject, method, newArgs);
                }
            }
        }

        return method.invoke(targetObject, args);
    }

    private Object[] additionalArgs(Object[] args, Request.Options options) {

        int length = args == null ? 0 : args.length;
        Object[] newArgs = new Object[length + 1];
        for (int i = 0; i < length; i++) {
            newArgs[i] = args[i];
        }

        newArgs[newArgs.length - 1] = options;
        return newArgs;
    }

    @AllArgsConstructor
    @Getter
    public static class Holder {
        private InvocationHandler handler;
        private Request.Options options;
    }
}

BeanPostProcessor实现

package com.jurassic.cloud.sample.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.cloud.openfeign.FeignClient;

import java.lang.reflect.Proxy;

/**
 * @author lihz
 * @date 2024/11/10
 */
@Slf4j
public class DynamicTimeoutFeignBeanProcessor implements BeanPostProcessor {
    private DynamicTimeoutFeignConfiguration.FeignTimeoutOption timeoutOption;

    public DynamicTimeoutFeignBeanProcessor(DynamicTimeoutFeignConfiguration.FeignTimeoutOption timeoutOption) {
        this.timeoutOption = timeoutOption;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (hasFeign(bean)) {
            DynamicTimeoutFeginInvocationHandler handler = new DynamicTimeoutFeginInvocationHandler(
                    bean, timeoutOption
            );

            Object o = Proxy.newProxyInstance(bean.getClass().getClassLoader(), bean.getClass().getInterfaces(), handler);
            log.info(beanName + " ... postProcessAfterInitialization ");
            return o;
        }

        return bean;
    }

    private boolean hasFeign(Object bean) {
        for (Class<?> anInterface : bean.getClass().getInterfaces()) {
            if (anInterface.getAnnotation(FeignClient.class) != null) {
                return true;
            }
        }

        return false;
    }
}

自动配置

package com.jurassic.cloud.sample.config;

import feign.Feign;
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cloud.openfeign.FeignAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@ConditionalOnClass(Feign.class)
@Configuration
@EnableConfigurationProperties(DynamicTimeoutFeignConfiguration.FeignTimeoutOption.class)
@AutoConfigureAfter(FeignAutoConfiguration.class)
public class DynamicTimeoutFeignConfiguration {

    @Bean
    public DynamicTimeoutFeignBeanProcessor beanProcessor(FeignTimeoutOption timeoutOption) {
        return new DynamicTimeoutFeignBeanProcessor(timeoutOption);
    }

    @ConfigurationProperties(prefix = "feign.timeout")
    @Getter
    @Setter
    public static class FeignTimeoutOption {
          private Map<String, FeignTimeoutOptionInfo> config = new HashMap<>();
    }

    @Getter
    @Setter
    public static class FeignTimeoutOptionInfo {
        private int connectTimeout;
        private int readTimeout;
    }
}

yaml配置

feign:
  timeout:
    config: 
      "[/T1/timeout]":    # API PATH
        connectTimeout: 1000
        readTimeout: 8000

测试

image-20241111135332827

参考

Sentinel与OpenFeign整合实现熔断降级源码分析

7K字解析！Feign的超时时间如何设置，我研究了4种情况
wdj_yyds的博客
08-15 1722
单独使用Feign时：通过和方法参数SpringCloud环境下单独使用Feign：方法参数、配置文件、声明OptionsBean跟Ribbon配合使用：通过Ribbon的超时参数设置跟Hystrix配合使用：修改默认的超时时间，尽量符合 Hystrix超时时间 >= (连接超时时间 + 读超时时间) * 重试次数。
开发技术-FeignClient 对单个接口设置超时时间
JustDI0209的博客
03-20 1520
FeignClient 调用某个接口，3s 没有结果就需要停止，处理后续业务。FeignClient 自定义 name 属性。
feign客户端请求服务超时时间设置
dzhou1991的博客
10-23 1904
注意，a服务调用b服务，在a服务配置超时设置；在使用 Feign 客户端时，可以通过配置来设置服务端的超时时间。Feign 提供了多种方式来配置超时时间，包括全局配置和针对特定客户端的配置。
单独某个设置feign接口的超时时间
qq_43432057的博客
05-22 3379
1.在配置文件里配置：hystrix:enabled: true feign: httpclient.enable: false okhttp.enable: true # 开启熔断 hystrix: enabled: true hystrix: command: default: # 全局超时设置 execution: isolation: thread: timeoutInMilli
openfeign指定单个接口或者服务超时时间
liouwb的博客
06-07 3994
【代码】openfeign指定单个接口或者服务超时时间。
Feign配置某一接口的超时时间
weixin_42889176的博客
04-18 1392
Feign配置某一接口的超时时间
Feign 每个方法单独设置超时时间
06-06
可以通过 Feign 的 `Request.Options` 对象来设置每个方法的超时时间，具体实现可参考以下代码： ```java public interface MyFeignClient { @RequestLine("GET /users/{id}") @Headers("Content-Type: ...
FeignClient 每个接口超时时间单独设置
05-31
可以使用@FeignClient注解中的configuration属性，指定一个Feign的配置类，然后在该配置类中自定义Feign的超时时间配置。...然后在@FeignClient注解中指定了该配置类，从而实现了每个接口超时时间单独设置的效果。
怎么用feign远程调用别人的接口_Feign - HTTP接口调用- 单独使用 - 实战
weixin_39582569的博客
02-05 1866
目录疯狂创客圈 Java 分布式聊天室【 亿级流量】实战系列之 -26【 博客园 总入口 】写在前面? 大家好，我是作者尼恩。目前和几个小伙伴一起，组织了一个高并发的实战社群【疯狂创客圈】。正在开始高并发、亿级流程的 IM 聊天程序 学习和实战? 在疯狂创客圈的 亿级流程的 IM 聊天程序 学习项目中，短连接Web服务器和长连接IM服务器之间，是相互配合的。在分布式集群的环境下，用户首先通过短连接...
feign 设置单独配置失效
最新发布
Heihei 's note
03-10 854
BUG处理，为feign客户端单独设置了配置，但是并不生效，分析以及解决问题。
Feign如何设置超时时间，不同情况下还真不一样
m0_46995061的博客
02-16 3407
今天给大家扒了扒在不同使用条件下Feign的超时时间设置，总结起来大致如下：单独使用Feign时：通过和方法参数SpringCloud环境下单独使用Feign：方法参数、配置文件、声明OptionsBean跟Ribbon配合使用：通过Ribbon的超时参数设置跟Hystrix配合使用：修改默认的超时时间，尽量符合 Hystrix超时时间 >= (连接超时时间 + 读超时时间) * 重试次数。
springcloud设置feign单个接口超时时间
紫月7575的博客
09-30 485
springcloud设置feign单个接口超时时间
Hystrix Feign Ribbon设置单独接口的超时时间
weixin_40757126的博客
04-12 3018
3）、若设置了Feign 和 Ribbon 的超时时间只会有一个生效，规则：如果没有设置过 Feign 超时，也就是等于默认值的时候，就会读取 Ribbon 的配置，使用 ribbon 的超时时间和重试设置。2）、若设置了Hystrix的超时时间，不设置Feign 和 Ribbon 的超时时间，则以hystrix的超时时间为准，而Ribbon重试机制不会触发。1）、若只设置了Hystrix的超时时间，不设置Feign 和 Ribbon 的超时时间，则可以用以下方式设置单个接口超时时间。
FeignClient 超时设置
suk_java的博客
07-12 2872
FeignClient 超时设置
feign 针对某一个特定接口设置超时时间
Cyms,BgXmSfXtsj !!!! Battle Each Moment !!!!
12-26 234
服务消费者需要传多一个 options参数，就是 new Request.Options(connectTimeout, readTimeout)详情见： https://blog.csdn.net/sinat_32502451/article/details/136884349。如果是当前feign所有接口的超时配置，需要在 @FeignClient 的 configuration 属性中设置。服务消费者需要传多一个 options参数，就可以设置特定接口的超时时间。跟其他的生产者接口一样格式。
feign设置超时时间
Cyms,BgXmSfXtsj !!!! Battle Each Moment !!!!
03-20 1124
调用 feign ，会调用 FeignClientFactoryBean 类的 feign() 方法，再用 configureFeign() 配置 feign。feign的 本质是 调用 http请求，如果不设置超时时间，请求长时间连接着，占用系统资源，影响用户体验。feign设置超时时间，可以通过 Request.Options 来设置。
feign的超时时间怎么配置？
qq_21277357的博客
03-09 304
2.可以通过代码设置Request.Options的超时时间。1.可以在配置文件进行配置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值