Spring cloud Feign 深度学习与应用详解

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
  </dependency>
  
  <dependency>
  <groupId>io.github.openfeign</groupId>
  <artifactId>feign-httpclient</artifactId>
  </dependency>

 @EnableFeignClients
  public class App {  
}

@FeignClient(value="wl-service")
public interface WlFeignClient {
  @RequestMapping(method = RequestMethod.GET, value= "/stores")
  List<Store> getStores();
 
  @RequestMapping(method = RequestMethod.POST, value= "/stores/{storeId}", consumes = "application/json")
  Store update(@PathVariable("storeId") Long storeId, Store store);

hystrix:
   command:
    default:
     circuitBreaker：
      # 是否开启熔断(默认true)
      enabled: true
      # 熔断生效至少请求数量(默认20),当同一HystrixCommand请求数量低于此值时,熔断不会开启
      requestVolumeThreshold：20
      # 失败次数超过比例才开启熔断
      errorThresholdPercentage: 50
    # 强制开启熔断
      #forceOpen： true
      # 强制关闭熔断
      #forceClosed: true
     execution:
      isolation:
       # THREAD:单独开启线程执行;SEMAPHORE:在调用线程上执行(由于我们现有框架中FeignUserContextInterceptor中使用了ThreadLocal,所以必须使用第二种方式)
18.       strategy: SEMAPHORE
19.       thread:
20.        # 执行超时时间(这个时间设置很重要,因为HystrixCommand会包装RibbonClient实例,那么这个时间就必须要大于ribbion timeout * retry,后面Ribbon章节会介绍)
        timeoutInMilliseconds: 2000
       semaphore:
        # 由于我们使用SEMAPHORE模式,当每个feign并发发起请求超过此值时,请求会被拒绝,直接调用降级方法,异常信息关键字:could not acquire a semaphore for execution
        maxConcurrentRequests: 1000
     fallback:
      isolation:
       semaphore:
        # 由于我们使用SEMAPHORE模式，当每个feign并发发起请求调用降级方法超过此值,调用降级方法会被拒绝,直接抛出异常,异常信息关键字:fallback execution rejected
        maxConcurrentRequests: 1000

/**
 * 服务发现模式
 */
@FeignClient(name = "eureka-client",fallback = OpenFeignFallbackServiceImpl.class)//eureka-client工程的服务名称
public interface OpenFeignService {
  @GetMapping("/name")//这里的请求路径需要和eureka-client中的请求路径一致
  public String test();//这里的方法名需要和eureka-client中的方法名一致
 }

/**
 * 服务发现-对应后备模式的方法定义
 */
@Service
public class OpenFeignFallbackServiceImpl implements OpenFeignService{
  @Override
  public String test() {
    return "调用服务失败！";
  }

/**
 * 声明调用客户端
 */
@FeignClient(name = "wl-sku", url = "${wl.url}", path = "wl", fallbackFactory = WlSkuFeignFallbackFactory.class)
public interface WlSkuFeign {

  /**
   * 基于商品编码获取商品销售属性明细
   *
   * @param relationId 参数编码
   * @return 
   */
  @RequestMapping(method = RequestMethod.GET, path = "/item/{relation_id}")
  ResponseBody<GoodsItemDto, EmptyMeta> getItemDetail(@PathVariable("relation_id") Integer relationId);
}

/**
 * 申明后备模式
 *
 */
@Component
public class WlSkuFeignFallbackFactory implements FallbackFactory<WlSkuFeign> {
  @Override
  public WlSkuFeign create(Throwable cause) {
    return relationId -> {
      ErrorLogger.getInstance().log("商品sku getItemDetail降级服务", cause);
      return ResponseBody.fallback(cause, new Error("getItemDetail", "商品服务不可用"));
    };
  }
}

# 全局统一配置
hystrix:
 command:
  default:
   execution:
    isolation:
     # 更改为THREAD,其余SEMAPHORE开头的配置可以去掉
     strategy: THREAD
     thread:
      # 默认1000
      timeoutInMilliseconds: 2000
 threadpool:
  default:
   # 这个属性很重要,默认false。当false时:maximumSize=coreSize,当true时:取值Math.max(maximumSize,coreSize),所以如果想设置最大数,必须设置为true
   allowMaximumSizeToDivergeFromCoreSize: false
   # 默认10
   coreSize: 10
   maximumSize： 10
   # 默认1M,线程池内超过coreSize的线程允许最大空闲时间
   keepAliveTimeMinutes: 1
   # 等待队列,默认-1即SynchronousQueue,直接交由线程池拒绝或者等待
   maxQueueSize： -1
   # 默认5,这个值的出现是因为线程池的queueSize无法动态变更,所以用这个值可以动态变更来前置检测是否拒绝,当maxQueueSize为-1或者0时,这个检测直接通过后交由线程池自己处理,当maxQueueSize大于0时,由queueSize<queueSizeRejectionThreshold来决定是否拒绝请求,所以如果设置maxQueueSize,最终队列拒绝效果是以此值为准
   queueSizeRejectionThreshold: 5

ribbon:
 # 默认相同的route不重试,可以避免一些各种重试引起的问题，简单化(但服务提供方还是应该尽量保证幂等性)
 MaxAutoRetries: 0
 # 默认只重试不同route一次
 MaxAutoRetriesNextServer: 1
 # 由于在前面feign文档中已经讲到使用自己配置的HttpClient连接池,所以不需要配置ribbon连接池相关的任何属性(因为考虑到每个服务提供方的不同，后期可能会更改回来使用ribbon连接池方式)
 # 默认5000
 ReadTimeout: 5000
 # 默认2000
 ConnectTimeout： 2000

#  NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #配置规则 随机
#  NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule #配置规则 轮询
#  NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RetryRule #配置规则 重试
#  NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule #配置规则 响应时间权重
 NFLoadBalancerRuleClassName: com.netflix.loadbalancer.BestAvailableRule #配置规则 最空闲连接策
 # 后续可能会自定义一些负载均衡策略,通过这里来设置
 # ribbon子容器饥饿加载,避免偶尔因为服务重启后第一次发起请求时延迟加载耗时造成fallback,但是会增加系统启动时间(新版才支持)
 eager-load:
  enabled: true
  clients:
   - a
   - b
   - c

#一个客户端远程多个微服务，可针对单个微服务做特殊配置
# ribbon客户端名称(即feign客户端名称)
<clientName>:
 ribbon:
  listOfServers: www.baidu.com
  xxx: xxx

@Component
public class WlFeignFallback implements WlFeign {
@Override
public ResponseBody<List<Object>, EmptyMeta> getTest() {
return ResponseBody.fail(new Error("xx", "xx"));
 }
}

/**
 * feign全局配置
 *
 * @Configuration 加上为全局，不加为自定义
 */
@Configuration
public class FeignConfiguration {
  /**
   * feign日志
   */
  @Profile({"self", "local", "dev"})
  @Bean
  public Logger.Level level() {
    return Logger.Level.FULL;
  }

  /**
   * http请求时长,最好小于hystrix时长
   */
  @Bean
  public Request.Options options() {
    return new Request.Options(2000, 3500);
  }

  /**
   * 使用默认的不重试机制,单独feign有特殊需求单独配置
   */
  public Retryer retryer() {
    // 最小重试间隔,最大重试间隔,最多尝试次数(包括第一次)
    return new Retryer.Default(100L, 500L, 2);
  }

// 显示指定方法
 @RequestMapping(method = RequestMethod.POST)

// 方式1:使用Map传输
@RequestMapping(path="xxx", method=GET)
ResponseBody<T> test(@RequestParam Map<String, Object> map) {
}
// 方式2:独立设置param
@RequestMapping(path="xxx", method=GET)
ResponseBody<T> test(@RequestParam("aaa") String aa, @RequestParam("bb") int bb) {
}

// 如果接口返回类型是text/html,必须用string接受，然后手动反序列化,如果是applicatin/json,则可以直接用对象接受
@RequestMapping(path="xxx", method=POST, consumes=MediaType.APPLICATION_FORM_URLENCODED_VALUE)
public String test(@RequestBody MultiValueMap<String, String> map) {
}
@RequestMapping(path="xxx", method=POST, consumes=MediaType.APPLICATION_FORM_URLENCODED_VALUE)
public RequestBody test(String content) {
}

#ribbon超时配置为2000，请求超时后，该实例会重试1次，更新实例会重试1次。
service-hi:
ribbon:
ReadTimeout: 2000
ConnectTimeout: 1000
MaxAutoRetries: 1
MaxAutoRetriesNextServer: 1

hystrix:
command:
default:
execution:
timeout:
enabled: true
isolation:
thread:
timeoutInMilliseconds: 8000

<!-- 使用Apache HttpClient替换Feign原生httpclient -->
    <dependency>
      <groupId>org.apache.httpcomponents</groupId>
      <artifactId>httpclient</artifactId>
    </dependency>
    <dependency>
      <groupId>com.netflix.feign</groupId>
      <artifactId>feign-httpclient</artifactId>
      <version>${feign-httpclient}</version>
    </dependency>

@Bean(destroyMethod = "close")
public CloseableHttpClient httpClient() {
  // 最终存活时间还需要看服务端的keep-alive设置,和空闲时间以及间歇的validate是否通过
  PoolingHttpClientConnectionManager pool = new PoolingHttpClientConnectionManager(30, TimeUnit.SECONDS);
  pool.setMaxTotal(2000);
  // 目前只有一个路由,默认等于最大值,根据业务并发量设置
  pool.setDefaultMaxPerRoute(2000);
  // 检查非活动连接,避免服务端重启后或者服务端keep-alive过期主动关闭连接造成失效,对于微服务场景可能还比较普遍,但受限HTTP设计理念,这也并发完全可靠,使用re-try/re-execute机制来弥补,考虑到可能很多Niginx配置为5秒keep-alive
  // TODO 这个值还待商榷
  pool.setValidateAfterInactivity(5 * 1000);
  return HttpClients.custom()
    .setConnectionManager(pool)
    // 连接空闲10s就回收,这个会启动独立线程检测,所以必须声明destroy方法来关闭独立线程
    .evictIdleConnections(10, TimeUnit.SECONDS)
    // 建立连接时间和从连接池获取连接时间,以及数据传输时间
    .setDefaultRequestConfig(RequestConfig.custom()
          // http建立连接超时时间
          .setConnectTimeout(1000)
          // 从连接池获取连接超时时间
          .setConnectionRequestTimeout(3000)
          // socket超时时间
          .setSocketTimeout(10000)
          .build())
        // 自定义重试机制
    .setRetryHandler((exception, executionCount, context) -> {
          // 目前只允许重试一次
          if (executionCount > 1) {
            return false;
          }
          // 如果是服务端主动关闭连接的,数据并没有被服务端接受,可以重试
          if (exception instanceof NoHttpResponseException) {
            return true;
          }
          // 不要重试SSL握手异常
          if (exception instanceof SSLHandshakeException) {
            return false;
          }
          // 超时
          if (exception instanceof InterruptedIOException) {
            return false;
          }
          // 目标服务器不可达
          if (exception instanceof UnknownHostException) {
            return false;
          }
          // SSL握手异常
          if (exception instanceof SSLException) {
            return false;
          }
          HttpClientContext clientContext = HttpClientContext.adapt(context);
          HttpRequest request = clientContext.getRequest();
          String get = "GET";
          // GET方法是幂等的,可以重试
          if (request.getRequestLine().getMethod().equalsIgnoreCase(get)) {
            return true;
          }
          return false;
        })
    // 默认的ConnectionKeepAliveStrategy就是动态根据keep-alive计算的
    .build();
  }