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();
  }