Feign的异步调用或者MQ调用与Security的问题处理；

两大踩坑点：

　　一：部分框架自带有查询当前登录人的信息工具，无需各种本地线程栈ThreadLocals取Request啥的折磨自己；

　　二：Security自带有uri匹配的工具，没事多翻翻源码，原创方法的执行效率可能并不高；

package com.*.server.order.config;

import com.*.common.core.utils.*Util;
import com.*.common.core.utils.StringUtils;
import com.*.common.redis.service.RedisService;
import com.*.common.security.starter.configure.*CloudResourceServerConfigure;
import com.*.common.security.starter.properties.*CloudSecurityProperties;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.ObjectUtils;

import java.lang.reflect.Field;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 功能描述：Feign调用异常
 *
 * @author 唐泽齐
 */
@Slf4j
@Configuration
@Order(Integer.MAX_VALUE)
public class FeignConfiguration implements RequestInterceptor {

    @Autowired
    private RedisService redisService;
    private static String[] patterns;

    @Autowired
    public void init(*CloudResourceServerConfigure *CloudResourceServerConfigure) {
        try {
            log.warn("初始化FeignConfiguration");
            Field field = *CloudResourceServerConfigure.class.getDeclaredField("properties");
            field.setAccessible(true);
            *CloudSecurityProperties properties = (*CloudSecurityProperties) field.get(*CloudResourceServerConfigure);
            patterns = properties.getAnonUris().split(",");
        } catch (Exception e) {
            patterns = new String[]{};
        }
    }

    @Override
    public void apply(RequestTemplate template) {
        Map<String, Collection<String>> headers = template.headers();
        String currentTokenValue = *Util.getCurrentTokenValue();
        if (StringUtils.isEmpty(currentTokenValue) && !checkLogin(template.url())) {
            log.info("为" + template.url() + "填充Token:" + redisService.get("admin_token"));
            template.header("Authorization", "bearer " + redisService.get("admin_token"));
            template.header("GatewayToken", Collections.singleton("bGVjaHVhbmc6Z2F0ZXdheToxMjM0NTY="));
        }
    }

    //判断当前请求是否本身就不需要登录
    private boolean checkLogin(String uri) {
        if (ObjectUtils.isEmpty(patterns)) {
            return false;
        }

        //创建uri新对象
        String finalUri = uri + "";
        //补充 “/”
        if (!uri.startsWith("/")) {
            finalUri += "/";
        }
        // 过滤 “？”之后的
        if (uri.indexOf("?") >= 0) {
            finalUri = finalUri.substring(0, finalUri.indexOf("?"));
        }
        // 原子化 返回结果
        AtomicBoolean mustLogin = new AtomicBoolean(false);
        String finalUri1 = finalUri;
        // 另开 方法，增加 逃逸度
        Arrays.stream(patterns).forEach(p -> {
            //使用 AntPathMatcher 检查
            if (new AntPathMatcher().match(p, uri)) {
                mustLogin.set(true);
                return;
            }
//                //自己写检验方法
//                if(!doCheck(p,finalUri1)) {
//                    mustLogin.set(true);
//                    return;
//                };
        });
        return mustLogin.get();
    }

    private boolean doCheck(String check, String uri) {
        //是否忽略登录
        boolean result = true;
        try {
            Iterator<String> ic = Arrays.stream(check.split("/")).iterator();
            Iterator<String> iu = Arrays.stream(uri.split("/")).iterator();
            for (; ic.hasNext(); ) {
                if (!iu.hasNext()) {
                    result = false;
                    break;
                }
                String c = ic.next();
                String u = iu.next();
                // 处理 /**
                if (c.equals("**") && !ic.hasNext()) {
                    result = true;
                    break;
                }
                // 处理 /*
                if (c.equals("*") && !ic.hasNext() && !iu.hasNext()) {
                    result = true;
                    break;
                }
                // 处理 /**/
                if (c.equals("**") && ic.hasNext() && iu.hasNext()) {
                    String nextp = ic.next();
                    while (iu.hasNext()) {
                        if (nextp.equals(iu.next())) {
                            break;
                        }
                    }
                    continue;
                }
                //处理 /*/
                if (c.equals("*") && ic.hasNext() && iu.hasNext()) {
                    continue;
                }
                if (!c.equals(u)) {
                    result = false;
                    break;
                }
            }
        } catch (Exception e) {
            log.warn("检查异常，过滤当前规则。check：" + check + " ===> uri:" + uri, e);
            result = false;
        }
        return result;
    }

}