深入理解feignribbon和hystrix三者的关系及超时配置[转]

Posted 码道简记

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了深入理解feignribbon和hystrix三者的关系及超时配置[转]相关的知识，希望对你有一定的参考价值。

spring cloud中有几个重要的组件，深入理解它们之间的关系才能更好的使用它们：

  • ribbon：实现服务定位和客户端负载均衡；

  • hystrix：实现服务熔断、服务降级、资源隔离等；

  • feign：声明式的http客户端，用于服务之间的http调用。相比于resttemplate，feign与ribbon和hystrix集成更友好，是spring cloud的顶层组件。

上述ribbon和hystrix都是netflix贡献组件，目前它们都处于维护模式，不再增加新特性，将逐渐被spring cloud官方组件取代，例如从Hoxton.M2开始整合spring-cloud-loadbalancer用于替换ribbon，但目前还不成熟，还是老老实实用ribbon，而断路器方面spring cloud抽象了Spring Cloud Circuit Breaker，hystrix只是其中一个实现，还有其他实现可选，例如阿里贡献的sentinel。

三者关系

hystrix和ribbon并没有直接关系。

feign底层默认是通过ribbon进行服务定位和负载均衡，使用feign时你感知不到ribbon的存在，也可以不使用ribbon。如果你使用resttemplate，则需要通过@LoadBalanced使用ribbon。

hystrix有两种使用情况，一种是在controller的handler方法上增加@HystrixCommand注解，作用的是整个handler；另一种情况是调用其他app服务时，也就是@feignclient注解的http客户端，此时调用这个http客户端的handler可不需要hystrix。

总结一下：服务之间的http调用可通过feign实现，feign底层是通过ribbon实现服务发现和负载均衡，不管是否使用feign，ribbon都是必不可少的；feign客户端可选的可启用hystrix支持，hystrix也可以用在服务端整个handler上。

如上所示，app1.controll1.handler1调用app2.controller2.handler2的过程是：

  1. 如果feign.hystrix.enabled=true（默认为false），则feign通过jdk动态代理，将调用封装为HystrixCommand，在hystrix thread pool中执行，否则进入3和4；

  2. hystrix thread pool中执行http调用，还是回调feign接口；

  3. feign扩展了ribbon客户端，使用ribbon的服务定位和负载均衡获得可用服务；

  4. feign扩展的ribbon客户端发起对app2.controller2.handler2的http请求，ribbon可以开启重试，如果请求超时则自动重试。

了解上述关系对于如何设置超时时间至关重要。如果hystrix的超时时间到达，则1就返回fallback了，不会等到4执行完。一般hystrix的超时时间要大于feign的超时时间。

另外上述服务端设置了断路器，实际上客户端可以不用设置。

超时相关配置

feign

官方参考

有两种配置方式：

  1. 属性配置，包括全局和实例；

  2. 代码配置，也包括全局和实例。

优先级：实例>全局，属性>代码

属性总是优先的，可以设置feign.client.default-to-properties为false，使得代码配置优先。

全局属性配置名默认是default，可以设置feign.client.default-config为其他名字。

属性配置

1
2
3
4
5
6
7
8
9
10
11
12
13
 
feign:
  hystrix:
    enabled: true
  client:
    config:
      # 全局配置
      default:
        connectTimeout: 5000
        readTimeout: 5000  
      # 实例配置，feignName即@feignclient中的value，也就是服务名
      feignName:
        connectTimeout: 5000
        readTimeout: 5000

代码配置

全局代码配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
package com.example.microservice2;

import org.springframework.cloud.openfeign.support.SpringMvcContract;
import org.springframework.context.annotation.Bean;
import feign.Request;
import feign.Retryer;

public class FeignClientConfiguration {
    @Bean
    public Request.Options feignRequestOptions() {
        // 默认连接超时10秒，读取超时60秒
        return new Request.Options();
    }

    // 默认重试是关闭的
    @Bean
    public Retryer feignRetry() {
        // 默认重试5次，首次间隔100毫秒，最大间隔1秒
        return new Retryer.Default();
    }
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
package com.example.microservice2;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient //开启注册服务
@EnableFeignClients(defaultConfiguration = FeignClientConfiguration.class) //开启feign消费服务
public class DemoApplication {
	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}
}
实例代码配置
1
2
3
4
5
6
7
8
9
10
11
12
 
package com.example.microservice2;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(value = "microservice1", fallback = HelloServiceHystric.class, configuration = FeignClientConfiguration.class) // 访问微服务1，指定断路器类
public interface HelloService {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    String hello(@RequestParam(value = "name") String name);
}

hystrix

官方参考

hystrix有四种配置方式：

  1. 全局代码默认属性；

  2. 全局属性配置；

  3. 实例代码配置；

  4. 实例属性配置。

优先级：1<2<3<4

和feign一样，也是属性优先代码，实例优先全局。

属性配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
hystrix:
  command:
    #全局默认配置
    default:
      #线程隔离相关
      execution:
        timeout:
          #是否给方法执行设置超时时间，默认为true。一般我们不要改。
          enabled: true
        isolation:
          #配置请求隔离的方式，这里是默认的线程池方式。还有一种信号量的方式semaphore。
          strategy: THREAD
          thread:
            #方式执行的超时时间，默认为1000毫秒，在实际场景中需要根据情况设置
            timeoutInMilliseconds: 10000
    # 实例配置
    HystrixCommandKey:
      execution:
        timeout:
          enabled: true
        isolation:
          strategy: THREAD
          thread:
            timeoutInMilliseconds: 10000

代码配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 

@RefreshScope // 开启配置更新
@RestController
@Slf4j
public class HelloController {
    @Value("${serviceName}") // 读配置文件的这个属性
    private String serviceName;

    @RequestMapping("/hello")
    @HystrixCommand(fallbackMethod = "helloError", commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "4000") }) // 指定断路器方法，断路器监控用
    public String hello(HttpServletRequest request, @RequestParam(value = "name", defaultValue = "Hugo") String name)
 throws InterruptedException {
        log.info("ServerName:{} time:{}", request.getServerName(),
                DateFormatUtils.format(new Date(), "yyyyMMdd HH:mm:ss"));
        TimeUnit.SECONDS.sleep(4);
        return "hello " + name + ", my name is " + serviceName;
    }

    public String helloError(HttpServletRequest request, String name) {
        return "microservice1 hystrix," + name + "!";
    }
}

feign中的hystrix怎么配置

只能通过属性设置，那么commandkey是什么呢？

1
2
3
4
5
6
7
 
package com.example.microservice2;

@FeignClient(value = "microservice1", fallback = HelloServiceHystric.class, configuration = FeignClientConfiguration.class) // 访问微服务1，指定断路器类
public interface HelloService {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    String hello(@RequestParam(value = "name") String name);
}

上例中默认行为如下，groupkey为"microservice1"，commandkey为"HelloService#hello(String)"，threadpoolkey为null。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public interface SetterFactory {

  /**
 * Returns a hystrix setter appropriate for the given target and method
 */
  HystrixCommand.Setter create(Target<?> target, Method method);

  /**
 * Default behavior is to derive the group key from {@link Target#name()} and the command key from
 * {@link Feign#configKey(Class, Method)}.
 */
  final class Default implements SetterFactory {

    @Override
    public HystrixCommand.Setter create(Target<?> target, Method method) {
      String groupKey = target.name();
      String commandKey = Feign.configKey(target.type(), method);
      return HystrixCommand.Setter
          .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey))
          .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey));
    }
  }
}
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
public abstract class Feign {

  public static String configKey(Class targetType, Method method) {
    StringBuilder builder = new StringBuilder();
    builder.append(targetType.getSimpleName());
    builder.append('#').append(method.getName()).append('(');
    for (Type param : method.getGenericParameterTypes()) {
      param = Types.resolve(targetType, targetType, param);
      builder.append(Types.getRawType(param).getSimpleName()).append(',');
    }
    if (method.getParameterTypes().length > 0) {
      builder.deleteCharAt(builder.length() - 1);
    }
    return builder.append(')').toString();
  }
  
}

所以这样设置：

1
2
3
4
5
6
7
8
9
10
 
hystrix:
  command:
    HelloService#hello(String):
      execution:
        timeout:
          enabled: true
        isolation:
          strategy: THREAD
          thread:
            timeoutInMilliseconds: 10000

也可以改变上述commandkey的默认行为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
package com.example.microservice2;

import java.lang.reflect.Method;

import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandKey;

import org.springframework.context.annotation.Bean;

import feign.Target;
import feign.hystrix.SetterFactory;

public class FeignClientConfiguration {

    @Bean
    public SetterFactory feignHystrixSetter() {
        return new MySetterFactory();
    }
}

class MySetterFactory implements SetterFactory {
    @Override
    public HystrixCommand.Setter create(Target<?> target, Method method) {
      String groupKey = target.name();
      String commandKey = target.type().getName();
      return HystrixCommand.Setter
          .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey))
          .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey));
    }    
}

这样commandkey就会变成"com.example.microservice2.HelloService"。

ribbon

官方参考

ribbon只有属性配置，同样存在全局和实例配置，格式如下：

1
 
<clientName>.<nameSpace>.<propertyName>=<value>

nameSpace是可配置的，默认为ribbon。clientName可为远端服务名，即@feignclient的value，空表示全局配置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
# 全局配置
ribbon:
 # 服务最大重试次数,不包含第一次请求，默认0
 MaxAutoRetries: 5
 # 负载均衡切换次数,如果服务注册列表小于 nextServer count 那么会循环请求 A > B >　A，默认1
 MaxAutoRetriesNextServer: 3
 #是否所有操作都进行重试
 OkToRetryOnAllOperations: false
 #连接超时时间，单位为毫秒，默认2秒
 ConnectTimeout: 3000
 #读取的超时时间，单位为毫秒，默认5秒
 ReadTimeout: 3000
# 实例配置
clientName:
  ribbon:
   MaxAutoRetries: 5
   MaxAutoRetriesNextServer: 3
   OkToRetryOnAllOperations: false
   ConnectTimeout: 3000
   ReadTimeout: 3000

超时时间关系

feign超时

feign可以设置自身超时，也可以设置ribbon超时，那么它们的关系是怎么样的？看feign代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public class LoadBalancerFeignClient implements Client {

	static final Request.Options DEFAULT_OPTIONS = new Request.Options();

	IClientConfig getClientConfig(Request.Options options, String clientName) {
		IClientConfig requestConfig;
		if (options == DEFAULT_OPTIONS) {
			requestConfig = this.clientFactory.getClientConfig(clientName);
		}
		else {
			requestConfig = new FeignOptionsClientConfig(options);
		}
		return requestConfig;
	}
}

如果没有设置过feign超时，也就是等于默认值的时候，就会读取ribbon的配置，使用ribbon的超时时间和重试设置。否则使用feign自身的设置。两者是二选一的，且feign优先。

  • 如果设置的feign的超时，则超时时间大概是Retryer.Default.maxAttempts*(ConnectTimeout+ReadTimeout)

  • 如果仅设置了ribbon，则超时时间大概是(ConnectTimeout+ReadTimeout)*(MaxAutoRetries+1)*(MaxAutoRetriesNextServer+1)；

建议使用ribbon超时设置。

feign重试和ribbon重试

feign自身重试目前只有一个简单的实现Retryer.Default，包含三个属性：

  • maxAttempts：重试次数，包含第一次

  • period：重试初始间隔时间，单位毫秒

  • maxPeriod：重试最大间隔时间，单位毫秒

重试间隔算法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
public interface Retryer extends Cloneable {

  class Default implements Retryer {
      
	/**
 * Calculates the time interval to a retry attempt. <br>
 * The interval increases exponentially with each attempt, at a rate of nextInterval *= 1.5
 * (where 1.5 is the backoff factor), to the maximum interval.
 *
 * @return time in nanoseconds from now until the next attempt.
 */
    long nextMaxInterval() {
      long interval = (long) (period * Math.pow(1.5, attempt - 1));
      return interval > maxPeriod ? maxPeriod : interval;
    }
      
  }
}

第一次重试间隔period，第二次period*1.5，第三次period*1.5*1.5，…，最大值不超过maxPeriod。

和ribbon的重试相比：

  • 重试次数包含了首次；

  • 不能设置多实例服务切换；

  • 重试有一个延迟时间。

feign超时和hystrix超时

hystrix的超时时间要大于feign的，否则没有等到feign超时，hystrix就fallback了，特别是重试机制会无法起作用。

  • 本文链接： http://zhongpan.tech/2020/03/23/029-hystrix-ribbon-feign-relationship/


以上是关于深入理解feignribbon和hystrix三者的关系及超时配置[转]的主要内容，如果未能解决你的问题，请参考以下文章

Android 异步消息处理机制 让你深入理解 LooperHandlerMessage三者关系

Android 异步消息处理机制 让你深入理解 LooperHandlerMessage三者关系

Android 异步消息处理机制 让你深入理解 LooperHandlerMessage三者关系

《深入理解Linux内核》软中断/tasklet/工作队列

深入 Hystrix 执行时内部原理

深入浅出Hystrix GO源码 --- 什么是Hystrix