# feign调用如何配置单个接口的超时时间 ## 通过配置文件配置超时时间 ```yaml feign: hystrix: enabled: true client: config: default: readTimeout: 2000 connectTimeout: 2000 xxx-service: readTimeout: 2000 connectTimeout: 2000 ``` 一般常用全局默认的超时和根据服务名设置的超时，但是缺点是一个FeignClient往往有多个方法，而可能某个方法需要较长的超时时间，这种配置的方式就无法满足需求。但是可以通过增加一个FeignClient且只有1个需要单独配置超时方法的接口，加上配置@FeignClient注解的contextId。这样就可以为单个接口配置超时时间。显然这种方式不够优雅。 ## 通过feign动态代理解析参数实现 feign.ReflectiveFeign.FeignInvocationHandler#invoke --> feign.SynchronousMethodHandler FeignInvocationHandler#invoke方法，通过Method的反射，调用方法 ```java @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); } ``` 处理器 feign.SynchronousMethodHandler关于超时时间配置参数的处理 ```java Options findOptions(Object[] argv) { if (argv == null || argv.length == 0) { return this.options; } return Stream.of(argv) .filter(Options.class::isInstance) .map(Options.class::cast) .findFirst() .orElse(this.options); } ``` 因此可知使用方式为 ```java @GetMapping("/hello") String sayHello(Request.Options options); ``` ## 通过自定义注解 ### 启动时配置文件 --> FeignClientProperties --> FeignClientConfiguration --> FeignClientFactoryBean#configureUsingProperties --> feign.Request.Options#Options 根据FeignClientFactoryBean#configureUsingProperties的引用可知，default的配置优先级是低于根据contextId的（也就是服务名）,核心代码如下： ```java //一般会走这个分支的代码 configureUsingConfiguration(context, builder); configureUsingProperties( properties.getConfig().get(properties.getDefaultConfig()), builder); configureUsingProperties(properties.getConfig().get(this.contextId), builder); ``` 超时时间是从config中构建的Options if (config.getConnectTimeout() != null && config.getReadTimeout() != null) { builder.options(new Request.Options(config.getConnectTimeout(), config.getReadTimeout())); } 看不出来启动时内部那里可以扩展，修改单个接口的超时时间配置。因为框架设计超时的配置粒度是服务，并不是服务的接口 ### 运行时自编写一个demo，并进行debug 定位到发送请求的代码feign.Client.Default#convertAndSend，关于超时时间的代码如下： ```java final HttpURLConnection connection = this.getConnection(url); connection.setConnectTimeout(options.connectTimeoutMillis()); connection.setReadTimeout(options.readTimeoutMillis()); ``` ![](C:\Users\damagez\Desktop\feign调用.jpg) 由于项目中刚好接入了sleuth，可以看到多了一个TraceFeignBlockingLoadBalancerClient。其他的则是Feign自身实现的Client。整个栈可以看出Client的嵌套调用，明显就是使用了责任链模式。一个想法就是，我们可以自定义自己的Client，加入调用链中，干涉远程调用时Option的超时时间设置。如何把自己的Client加入到调用链中？可以参考sleuth的实现 TraceFeignBlockingLoadBalancerClient --> TraceFeignObjectWrapper#wrap -->TraceFeignContext#getInstance --> FeignClientFactoryBean#getOptional -->FeignClientFactoryBean#loadBalance --> FeignContext --> FeignContextBeanPostProcessor 通过wrapper，包装是Client的bean ```java if (bean instanceof Client && !(bean instanceof TracingFeignClient)) { if (ribbonPresent && bean instanceof LoadBalancerFeignClient && !(bean instanceof TraceLoadBalancerFeignClient)) { return instrumentedFeignRibbonClient(bean); } if (ribbonPresent && bean instanceof TraceLoadBalancerFeignClient) { return bean; } if (loadBalancerPresent && bean instanceof FeignBlockingLoadBalancerClient && !(bean instanceof TraceFeignBlockingLoadBalancerClient)) { return instrumentedFeignLoadBalancerClient(bean); } if (ribbonPresent && bean instanceof TraceFeignBlockingLoadBalancerClient) { return bean; } return new LazyTracingFeignClient(this.beanFactory, (Client) bean); } ``` 而源头又指向了FeignClientFactoryBean，方法FeignClientFactoryBean#loadBalance通过contextId创建出我们的FeignClient ```java T getTarget() { FeignContext context = this.applicationContext.getBean(FeignContext.class); Feign.Builder builder = feign(context); if (!StringUtils.hasText(this.url)) { if (!this.name.startsWith("http")) { this.url = "http://" + this.name; } else { this.url = this.name; } this.url += cleanPath(); return (T) loadBalance(builder, context, new HardCodedTarget<>(this.type, this.name, this.url)); } ... ``` 在debug中显示FeignContext的运行时类型是TraceFeignContext，是在FeignContextBeanPostProcessor处理FeignContext的bean时进行替换的 ```java @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof FeignContext && !(bean instanceof TraceFeignContext)) { return new TraceFeignContext(traceFeignObjectWrapper(), (FeignContext) bean); } return bean; } ``` 答案已经显而易见了，我们可以学习sleuth，在处理FeignContext时，再进行一次wrapper，通过wrapper植入我们的Client的逻辑。下面就是实际代码环节。 ### 实现注解配置超时时间提供一个FeignOptions注解，可以注解在FeignClient的方法上，配置超时时间 ```java @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface FeignOptions { long connectTimeout(); TimeUnit connectTimeoutUnit() default TimeUnit.MILLISECONDS; long readTimeout(); TimeUnit readTimeoutUnit() default TimeUnit.MILLISECONDS; } ``` 后续就是根据sleuth依葫芦画瓢，提供一个BeanPostProcessor ```java @Order(100) @Component public class FeignOptionsBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware { private BeanFactory beanFactory; @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof FeignContext && !(bean instanceof OptionsFeignContext)) { return new OptionsFeignContext(feignOptionsObjectWrapper(), (FeignContext) bean); } return bean; } @Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { this.beanFactory = beanFactory; } private FeignOptionsObjectWrapper feignOptionsObjectWrapper() { return new FeignOptionsObjectWrapper(this.beanFactory); } } ``` 提供一个自定义的FeignContext ```java public class OptionsFeignContext extends FeignContext { private final FeignOptionsObjectWrapper feignOptionsObjectWrapper; private final FeignContext delegate; public OptionsFeignContext(FeignOptionsObjectWrapper traceFeignObjectWrapper, FeignContext delegate) { this.feignOptionsObjectWrapper = traceFeignObjectWrapper; this.delegate = delegate; } @Override @SuppressWarnings("unchecked") public T getInstance(String name, Class type) { T object = this.delegate.getInstance(name, type); if (object != null) { return (T) this.feignOptionsObjectWrapper.wrap(object); } return null; } @Override @SuppressWarnings("unchecked") public Map getInstances(String name, Class type) { Map instances = this.delegate.getInstances(name, type); if (instances == null) { return null; } Map convertedInstances = new HashMap<>(); for (Map.Entry entry : instances.entrySet()) { convertedInstances.put(entry.getKey(), (T) this.feignOptionsObjectWrapper.wrap(entry.getValue())); } return convertedInstances; } } ``` 提供一个wrapper ```java public class FeignOptionsObjectWrapper { private final BeanFactory beanFactory; public FeignOptionsObjectWrapper(BeanFactory beanFactory) { this.beanFactory = beanFactory; } public Object wrap(Object bean) { if (bean instanceof Client) { return new CustomizeOptionsFeignClient((Client) bean); } return bean; } } ``` 提供一个自定义的FeignClient ```java public class CustomizeOptionsFeignClient implements Client { private Client delegate; private static Map cacheFeignOptionsMap = new ConcurrentHashMap<>(); public CustomizeOptionsFeignClient(Client delegate) { this.delegate = delegate; } @Override public Response execute(Request request, Request.Options options) throws IOException { Method method = request.requestTemplate().methodMetadata().method(); if (method.isAnnotationPresent(FeignOptions.class)) { Request.Options customizeOptions = cacheFeignOptionsMap.computeIfAbsent(method, m -> { FeignOptions feignOptions = method.getAnnotation(FeignOptions.class); return new Request.Options(feignOptions.connectTimeout(), feignOptions.connectTimeoutUnit(), feignOptions.readTimeout(), feignOptions.readTimeoutUnit(), options.isFollowRedirects()); }); return this.delegate.execute(request, customizeOptions); }else { return this.delegate.execute(request, options); } } } ``` 使用 ``` @FeignOptions(connectTimeout = 3000, readTimeout = 3000) @GetMapping("/hello") String sayHello(); ``` ### BUG！！！使用上述的方式会产生一个BUG，具体产生原因为： DefaultFeignLoadBalancerConfiguration#feignClient ```java //默认获得的是FeignBlockingLoadBalancerClient @Bean @ConditionalOnMissingBean public Client feignClient(BlockingLoadBalancerClient loadBalancerClient) { return new FeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient); } ``` FeignClientFactoryBean#getTarget ```java T getTarget() { FeignContext context = this.applicationContext.getBean(FeignContext.class); Feign.Builder builder = feign(context); if (!StringUtils.hasText(this.url)) { if (!this.name.startsWith("http")) { this.url = "http://" + this.name; } else { this.url = this.name; } this.url += cleanPath(); return (T) loadBalance(builder, context, new HardCodedTarget<>(this.type, this.name, this.url)); } if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) { this.url = "http://" + this.url; } //当指定具体url时，不走loadbalance //根据上述代码进行包装之后，类型变成了CustomizeOptionsFeignClient String url = this.url + cleanPath(); Client client = getOptional(context, Client.class); if (client != null) { if (client instanceof LoadBalancerFeignClient) { // not load balancing because we have a url, // but ribbon is on the classpath, so unwrap client = ((LoadBalancerFeignClient) client).getDelegate(); } //问题在于这里，指定url之后，会解包FeignBlockingLoadBalancerClient //但是此时类型为CustomizeOptionsFeignClient，无法进入到if逻辑解包。 //所以执行的时候feign调用还是会去查找注册中心，写死url的一般不会注册到注册中心，所以会调用失败 if (client instanceof FeignBlockingLoadBalancerClient) { // not load balancing because we have a url, // but Spring Cloud LoadBalancer is on the classpath, so unwrap client = ((FeignBlockingLoadBalancerClient) client).getDelegate(); } builder.client(client); } Targeter targeter = get(context, Targeter.class); return (T) targeter.target(this, builder, context, new HardCodedTarget<>(this.type, this.name, url)); } ``` ### 最终代码集合 ```java //注解 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface FeignOptions { long connectTimeout(); TimeUnit connectTimeoutUnit() default TimeUnit.MILLISECONDS; long readTimeout(); TimeUnit readTimeoutUnit() default TimeUnit.MILLISECONDS; } //自定义Client逻辑 public class CustomizeOptionsFeignClient implements Client { private Client delegate; private static Map cacheFeignOptionsMap = new ConcurrentHashMap<>(); public CustomizeOptionsFeignClient(Client delegate) { this.delegate = delegate; } @Override public Response execute(Request request, Request.Options options) throws IOException { Method method = request.requestTemplate().methodMetadata().method(); if (method.isAnnotationPresent(FeignOptions.class)) { Request.Options customizeOptions = cacheFeignOptionsMap.computeIfAbsent(method, m -> { FeignOptions feignOptions = method.getAnnotation(FeignOptions.class); return new Request.Options(feignOptions.connectTimeout(), feignOptions.connectTimeoutUnit(), feignOptions.readTimeout(), feignOptions.readTimeoutUnit(), options.isFollowRedirects()); }); return this.delegate.execute(request, customizeOptions); }else { return this.delegate.execute(request, options); } } } //注册Bean @Configuration public class FeignOptionsConfig { @Bean public Client feignClient(BlockingLoadBalancerClient loadBalancerClient) { return new FeignBlockingLoadBalancerClient(new CustomizeOptionsFeignClient(new Client.Default(null, null)), loadBalancerClient); } } ``` ### 扩展总结由于FeignClient是通过FeignClientFactoryBean生成的，所以BeanPostProcessor无法控制FeignClient。而只能在框架内部寻找扩展点。既然是扩展点，那一定是交给Spring管理的才能进行扩展。FeignClientFactoryBean聚合了ApplicationContext，内部也通过容器去getBean。所有通过getBean的，就都是可以扩展的地方。这也是为什么sleuth框架选择了扩展点为FeignContext，具体代码参考FeignClientFactoryBean#getTarget ```java T getTarget() { FeignContext context = this.applicationContext.getBean(FeignContext.class); ... } ``` 后面发现，不仅仅有这种方式，超时配置可以在很多地方配置，只是配置的优先级不一样。比如，通过hystrix也可以实现超时时间的配置。