报错信息：

No thread-bound request found: Are you referring to request attributes outside of an actual web request, or processing a request outside of the originally receiving thread? If you are actually operating within a web request and still receive this message, your code is probably running outside of DispatcherServlet/DispatcherPortlet: In this case, use RequestContextListener or RequestContextFilter to expose the current request.

 

场景：在Mq的监听中，去调用其他的微服务，在对Feign进行拦截的时候报错



在链路拦截日志的RequestInterceptor中，我们可以看到通过下面方法，没有取得request的信息

RequestContextHolder.currentRequestAttributes()





 通过源码可以查看到是从当前ThreadLocal 中获取上下文的RequestAtrributes

 



 当拿不到request时，创建NonWebRequestAttributes来实现RequestAttributes，然后加一个非空判断绕过强转的地方，这样就能正常的调用其他服务了


@Component
public class LogFeignInterceptor implements RequestInterceptor {
    public LogFeignInterceptor() {
    }

    public void apply(RequestTemplate requestTemplate) {
        HttpServletRequest httpRequest = this.getHttpServletRequestSafely();
        if (null != httpRequest && null != httpRequest.getAttribute("X-Request-No")) {
            requestTemplate.header("X-Request-No", new String[]{httpRequest.getAttribute("X-Request-No").toString()});
        }

    }

    public HttpServletRequest getHttpServletRequestSafely() {
        try {
            RequestAttributes requestAttributesSafely = this.getRequestAttributesSafely();
            return requestAttributesSafely instanceof NonWebRequestAttributes ? null : ((ServletRequestAttributes)requestAttributesSafely).getRequest();
        } catch (Exception var2) {
            return null;
        }
    }

    public RequestAttributes getRequestAttributesSafely() {
        Object requestAttributes = null;

        try {
            requestAttributes = RequestContextHolder.currentRequestAttributes();
        } catch (IllegalStateException var3) {
            requestAttributes = new NonWebRequestAttributes();
        }

        return (RequestAttributes)requestAttributes;
    }
}

需求描述
spring cloud 项目中feign 整合 hystrix经常使用，但是最近发现hystrix功能强大，但是对我们来说有些大材小用。

首先我只需要他的一个熔断作用，就是说请求超时、异常了返回 FeignClient注解中配置的fallback，不需要非阻塞操作、也不需要重试，hystrix 调用feign时候做了线程池隔离处理，这样增加了项目复杂度（线程池参数配置、线程少了请求服务直接拒绝，多了线程得管理。。。）

目前feign 超时之后是直接抛异常的，这样的话虽然是及时熔断了，但是正常的程序逻辑不走了配置的fallback也没有作用，这个配置项得配合 hystrix 才行。

我需要的是这样的效果
  try{
     feign.api();
  }catch(){
 	return fallback();
 }

但是每个feign调用都手动加上try..catch 实在是太low了，最好能写个类似切面一样的玩意。
这时候就想到了 hystrix,既然人家框架已经做了，我直接看下代码，copy不完了么
源码学习
前两天发布了一篇文章也是关于feign、hystrix 调用集成的

基于之前的分析关键代码 HystrixInvocationHandler (feign.hystrix)
@Override
  public Object invoke(final Object proxy, final Method method, final Object[] args)
      throws Throwable {
    .............
	 // setterMethodMap 封装 hystrixCommand 配置信息（超时时间、是否重试.....）
    HystrixCommand<Object> hystrixCommand = new HystrixCommand<Object>(setterMethodMap.get(method)) {
      @Override
      protected Object run() throws Exception {
        ....
        HystrixInvocationHandler.this.dispatch.get(method).invoke(args);
      	....
      }

      @Override
      protected Object getFallback() {
        .........
      }
    };

   ......
    return hystrixCommand.execute();
  }

按照之前分析源码方式，直接看哪里被调用了就可以看到， hystrix 实际上自己封装了一个 feign.Builer 类名是 feign.hystrix.HystrixFeign.Builder  用的是建造者模式，生成的类是在调用服务时用到

看到 关键的 build() 方法
Feign build(final FallbackFactory<?> nullableFallbackFactory) {
      super.invocationHandlerFactory(new InvocationHandlerFactory() {
        // 重新定义一个 InvocationHandler 实现 类似 aop效果
        @Override public InvocationHandler create(Target target,
            Map<Method, MethodHandler> dispatch) {
          return new HystrixInvocationHandler(target, dispatch, setterFactory, nullableFallbackFactory);
        }
      });
      super.contract(new HystrixDelegatingContract(contract));
      return super.build();
    }

spring 动态代理我这里不多说了，核心就是 InvocationHandler (如果是jdk动态代理的话)，那么 feign 这里也是，我们看看feign 调用声明是个接口，实际上是spring 动态代理生成了代理类，调用方法时实际调用的是  java.lang.reflect.InvocationHandler#invoke
方案构想
那么我们只需要借鉴下 hystrix 的方式，自己实现一个feign.build ，将 InvocationHandler 换成自己的，

然后在我们自己的 InvocationHandler 中调用feign 官方的 InvocationHandler 就行,也就是 feign.hystrix.HystrixInvocationHandler#invoke这个方法中的this.dispatch.get(method).invoke(args);这个代码
方案具体代码实现
方案一
自己实现
import feign.Feign;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;

/**
 * 自定义feign 构建
 * @author hgf
 */
public class CusFeignBuilder extends Feign.Builder{

    public CusFeignBuilder() {

        this.invocationHandlerFactory((target, dispatch) -> {
            Class<?> type = target.type();
            FeignClient annotation = type.getAnnotation(FeignClient.class);

            // 构造 fallback 实例
            Object fallBackObj = null;
            if (annotation != null && !annotation.fallback().equals(void.class)) {

                try {
                    fallBackObj = annotation.fallback().newInstance();
                } catch (InstantiationException | IllegalAccessException e) {
                    e.printStackTrace();
                }
            }

            return new CusFeignInvocationHandler(target, dispatch, fallBackObj);
        });
    }


}


import feign.Feign;
import feign.InvocationHandlerFactory;
import feign.Target;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FeignClient;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import static com.eco.common.utils.Md5Util.logger;
import static feign.Util.checkNotNull;

/**
 * 自定义的feign调用
 */
@Slf4j
public class CusFeignInvocationHandler implements InvocationHandler {
    private final Target target;
    private final Map<Method, InvocationHandlerFactory.MethodHandler> dispatch;
    private final Object fallbackObj;
    private final Map<String, Method> fallbackMethodMap = new ConcurrentHashMap<>();

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



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


    @Override
    public boolean equals(Object obj) {
        if (obj instanceof CusFeignInvocationHandler) {
            CusFeignInvocationHandler other = (CusFeignInvocationHandler) obj;
            return target.equals(other.target);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return target.hashCode();
    }

    @Override
    public String toString() {
        return target.toString();
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        try {
            return feignInvoke(proxy, method, args);
        } catch (Throwable throwable) {


            String configKey = Feign.configKey(target.type(), method);

            logger.error("{} 请求 出现异常 ==> {}", configKey, throwable.getMessage());


            try {
                return getFallbackReturn(method, args, throwable);
            } catch (Throwable e) {
                throw throwable;
            }
        }
    }

    /**
     * 反射调用 {@link FeignClient#fallback()}生成失败返回值
     * @param method            当前feign方法
     * @param args              参数
     * @param throwable         异常
     */
    public Object getFallbackReturn(Method method, Object[] args, Throwable throwable) throws Throwable {
        if (fallbackObj == null) {
            throw new RuntimeException("fallbackObj is null");

        }

        String configKey = Feign.configKey(target.type(), method);


        Method fallbackMethod = fallbackMethodMap.get(configKey);
        if (fallbackMethod == null) {

            Class<?> declaringClass = method.getDeclaringClass();

            FeignClient annotation = declaringClass.getAnnotation(FeignClient.class);
            if (annotation == null) {
                throw new RuntimeException("FeignClient annotation not found");
            }

            // 失败返回
            Class<?> fallback = annotation.fallback();

            fallbackMethod = fallback.getMethod(method.getName(), method.getParameterTypes());

            fallbackMethodMap.put(configKey, fallbackMethod);
        }


        if (fallbackMethod == null) {
            throw new RuntimeException("fallbackMethodMap not found");

        }
        return fallbackMethod.invoke(fallbackObj, args);
    }
}

然后在 spring 容器中注册这个bean就行
@Bean
    CusFeignBuilder cusFeignBuilder(){
        return new CusFeignBuilder();
    }

方案二
集成 sentinel ,今天写博客再回头看源码时候才发现的

加入依赖
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

配置开启
feign.sentinel.enabled=true

手动实现feign 接口，将实体类注册到 spring 中
@Component
public class DeviceApiFallBack implements DeviceApi{
	 @Override
        public ServerResponse<String> login(String appId) {
            return ServerResponse.createByErrorMessage("请求失败");
        }
}

其实看代码知道原理一样，无非实现方式不一样
两个方案其实都行，方案一自己实现代码量多，方案二sentinel 官方实现，但是需要引入依赖，增加复杂度，而且 接口实现需要注册到spring 中
目前我选的还是方案一，简单

记一次多线程异步调取Feign接口失败问题及其解决
在一次线上环境中反馈短信和消息没有发出去，我赶紧排查问题，前面说下我的业务场景：发短信和发消息都是使用多线程异步执行，通过调取Feign来调取push服务的推送接口来进行推送，因为要快速反馈给用户消息，正好前一段时间学会用CompletableFuture，正想小试牛刀的我，依然决然采用之来实现异步推送，本来用起来还蛮好的，简单易懂方便，而且支持线程窃取等一系列功能，简直是如获至宝，但是今天线上突然出现了以下错误，泼了我一脸冷水：
Task java.util.concurrent.FutureTask@68bb4099 rejected from java.util.concurrent.ThreadPoolExecutor@f8b8538[Running, pool size = 10, active threads = 10, queued tasks = 20, completed tasks = 693]

开始一度以为是CompletableFuture的锅，但是经过我百度了会，发现其实我错怪了CompleteFuture了，一开始还去看CompleteFuture的源码，了解到CompletableFuture用的是ForkJoinPool的线程池，默认线程数是系统机的cpu核心数，但这个错误为啥报的是active threads=10,这个我就郁闷了，而且CompletableFuture默认会给每个工作线程分配独立的队列，应该不会出现并发调直接拒绝我的任务的问题啊！思前想后我还是想不通，后来索性把堆栈打出来了，我这才知道是Hystrix的问题：
java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@6900a95d rejected from java.util.concurrent.ThreadPoolExecutor@5d2de59a[Running, pool size = 10, active threads = 10, queued tasks = 20, completed tasks = 54]
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
	at java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:112)
	at com.netflix.hystrix.strategy.concurrency.HystrixContextScheduler$ThreadPoolWorker.schedule(HystrixContextScheduler.java:172)
	at com.netflix.hystrix.strategy.concurrency.HystrixContextScheduler$HystrixContextSchedulerWorker.schedule(HystrixContextScheduler.java:106)
	at rx.internal.operators.OperatorSubscribeOn.call(OperatorSubscribeOn.java:50)
	at rx.internal.operators.OperatorSubscribeOn.call(OperatorSubscribeOn.java:30)
	at rx.internal.operators.OnSubscribeLift.call(OnSubscribeLift.java:48)
	at rx.internal.operators.OnSubscribeLift.call(OnSubscribeLift.java:30)
	at rx.Observable.unsafeSubscribe(Observable.java:10327)
	....

原来是com.netflix.hystrix下面爆出来的错，o(╥﹏╥)o，找了好久，终于找到了，好了，知道了问题所在，我们开始分析为啥会报这错。之后发现一旦并发量大的时候，就会报，我一想这不就是hystrix熔断机制吗？自己然后查了下资料，发现hystrix调用其他服务的时候核心最大Threadsize=10，如果核心线程达到最大线程则直接拒绝，而且默认没有队列，可能hystrix是为了快速调用才这么设计，但根据我的业务此涉及不太靠谱，所以我就想着直接扩大线程数，但是最大线程数也不能乱调，大了会增加线程上下文切换，小了效率又不高，导致又会拒绝我的任务执行，后来查了下官网，有了如下解决方法，不多说直接贴出一下配置：
hystrix:
  threadpool:
    default:
      coreSize: 16//并发执行的最大线程数，默认10，我这里用cpu核心数
      maxQueueSize: 1000//BlockingQueue的最大队列数，默认值-1
      queueSizeRejectionThreshold: 800 //即使maxQueueSize没有达到，达到queueSizeRejectionThreshold该值后，请求也会被拒绝，默认值5

配置直接放在application.yml中，这样遇到某些场景远程调用并发多的时候可以采用以上配置，但这个配置也不能乱用，因为加了队列，这就意味着你的熔断门槛就比较高了，所以各位同学一定要根据自己的业务场景来设置。

微服务中尝试使用多线程访问其他服务，通过服务接口调用失败，



通过Debug模式，跟随子线程调用链，发现处理服务发送时的请求头设置中，

ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder
        .getRequestAttributes();

HttpServletRequest request = attributes.getRequest();

获取的request为null，



通过度娘几番查找，找到一篇文章解决request为null的问题，

https://blog.csdn.net/schcilin/article/details/92403362

通过文章发现，在Spring cloud微服务中，feign开启了熔断器(hystrix)：feign.hystrix.enabled=ture,并且使用默认的信号隔离级别，、HttpServletRequest对象在父线程与子线程是相互独立的，不共享的。所以子线程中使用父线程的HttpServletRequest数据为null。

在我的测试代码中使用feign API接口前调用

RequestContextHolder.setRequestAttributes(RequestContextHolder.getRequestAttributes(), true);

来设置将父线程的HttpServletRequest对象设置共享，