fegin token

1.前端token透传

servlet线程中获取token fegin请求时封装进去 

/**
 * feign配置token
 */
@Configuration
public class FeignRequestInterceptor implements RequestInterceptor {

   @Override
   public void apply(RequestTemplate requestTemplate) {
      // 这里可以添加feign请求的全局参数

      ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
      if(attributes==null || attributes.getRequest()==null){
         return;
      }
      HttpServletRequest request = attributes.getRequest();
      requestTemplate.header("token", request.getHeader("token"));
      requestTemplate.header("feignClient", "ifaas-community-sec");
   }
}

2. 拦截403权限异常 根据用户名密码登录缓存token重试 

@Slf4j
@Configuration
public class FeignTokenAutoConfig {

    @Autowired
    private AuthorityService authorityService;

    @Bean
    public RequestInterceptor requestInterceptor() {
        return template -> {
            if (matchUrl(template.url())) {
                return;
            }
            template.header("token", authorityService.getCacheToken());
        };
    }

    private boolean matchUrl(String url){
        Pattern pattern = Pattern.compile("^*/oauth/token*$");
        Matcher matcher =pattern.matcher(url);
        return matcher.find();
    }

    @Bean
    public Retryer retryer() {
        return new Retryer(){
            int tryTimes;

            @Override
            public void continueOrPropagate(RetryableException e) {
                if (this.tryTimes++ >= 1) {
                    throw e;
                }
                if (e instanceof MyRetryException && e.getClass().equals(MyRetryException.class)) {
                    return;
                }
                throw e;
            }

            @Override
            public Retryer clone() {
                this.tryTimes = 0;
                return this;
            }
        };
    }

    @Bean
    public ErrorDecoder errorDecoder() {
        return (methodKey, response) -> {
            FeignException exception = FeignException.errorStatus(methodKey, response);
            if (response.status() == HttpStatus.UNAUTHORIZED.value()) {
                authorityService.resetToken();
                return new MyRetryException( exception.getMessage(), exception, null);
            }
            return exception;
        };
    }

    static class MyRetryException extends RetryableException {
        public MyRetryException(String message, Throwable cause, Date retryAfter) {
            super(message, cause,retryAfter);
        }
    }
}

在需要重试的客户端加配置

@FeignClient(value ="test", url = "${test.url.prefix}", configuration = FeignTokenAutoConfig.class, fallback = TestClientCall.class)

3.在servlet线程中 另起一个线程  丢失token 为线程池设置taskDecorator

@Configuration
@EnableAsync
@Slf4j
public class ThreadPoolConfig {

    /**
     * 定义线程池大小，默认是是当前核数*2+1
     */
    @Value("${service.thread.num:0}")
    private Integer threadCoreNum;

    public static final String ASYNC_EXECUTOR_NAME = "asyncExecutor";

    /**
     * 业务线程通用线程池
     * @return
     */
    @Bean(name = ASYNC_EXECUTOR_NAME)
    public ThreadPoolTaskExecutor serviceThreadPoolTaskExecutor() {
        log.info("<<<<<<<<<开始初始化AsyncService线程池");
        if(threadCoreNum==0){
            threadCoreNum = Runtime.getRuntime().availableProcessors() * 2+1;
        }
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数
        executor.setCorePoolSize(threadCoreNum);
        // 最大线程数
        executor.setMaxPoolSize(500);
        // 任务拒绝处理策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 子线程名字前缀
        executor.setThreadNamePrefix("AsyncService");
        // 当调用shutdown时，先执行完当前任务
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setTaskDecorator(new ContextCopyingDecorator());
        executor.initialize();
        return executor;
    }
}

/**
 * 将请求上下文拷贝到子线程中
 */
public class ContextCopyingDecorator implements TaskDecorator {
    @Override
    public Runnable decorate(Runnable runnable) {
        RequestAttributes context = RequestContextHolder.currentRequestAttributes();
        return () -> {
            try {
                RequestContextHolder.setRequestAttributes(context);
                runnable.run();
            } finally {
                RequestContextHolder.resetRequestAttributes();
            }
        };
    }
}

4.使用threadLocal 跟线程绑定 使用完销毁

public abstract class CommonThreadPool {

    /** 
    * token 
    */
   public static ThreadLocal<String> tokenThreadLocal = new ThreadLocal<>();

   /**
    * userInfo 
    */
   private static final ThreadLocal<UserInfo> USER_INFO = new NamedThreadLocal<>("userInfo");
   /**
     * 线程池
     */
   private static ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("service-threadpool-%d").build();
    public static final ExecutorService executorService = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors() + 1
         ,2*Runtime.getRuntime().availableProcessors() + 1,10,TimeUnit.MINUTES
         , new LinkedBlockingQueue<>(GlobalConsts.threadBlockingQueue),threadFactory);

   /**
    * 等待线程池中单个线程结束
    */
   public static Object waitTillThreadFinish(Future<?> thread) {
      try {
         return thread.get();
      } catch (InterruptedException | ExecutionException e) {
         e.printStackTrace();
      }
      return Optional.ofNullable(null);
   }


   public static UserInfo getUserInfo() {
      return USER_INFO.get();
   }
   public static void setUserInfo(UserInfo userInfo){
      USER_INFO.set(userInfo);
   }
   public static void removeUserInfo(){
      USER_INFO.remove();
   }

}

@Configuration
public class CommonConfigurerAdapter extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new SearchContextHandlerInterceptor());
    }
    public static class SearchContextHandlerInterceptor extends HandlerInterceptorAdapter {
        /**
         * 在DispatcherServlet完全处理完请求后被调用，可用于清理资源等
         */
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
            //清除userInfo信息
            CommonThreadPool.removeUserInfo();
            //清除token信息
            tokenThreadLocal.remove();
        }
    }
}

使用方式

1.设置跟线程绑定的变量 

 tokenThreadLocal.set("token")  或者 CommonThreadPool.setUserInfo(userInfo)  

2.取出和线程相关变量使用

CommonThreadPool.executorService .submit(() -> {

     tokenThreadLocal.get("token") ; 或 getUserInfo();

});

3.清除threadLocal变量

tokenThreadLocal.remove()或CommonThreadPool.removeUserInfo();