spring-cloud-gray-example // 父工程
   kerwin-common // 項(xiàng)目公共模塊
   kerwin-gateway // 微服務(wù)網(wǎng)關(guān)
   kerwin-order // 訂單模塊
      order-app // 訂單業(yè)務(wù)服務(wù)
   kerwin-starter // 自定義springboot starter模塊
      spring-cloud-starter-kerwin-gray // 灰度發(fā)布starter包 (核心代碼都在這里)
   kerwin-user // 用戶模塊
      user-app // 用戶業(yè)務(wù)服務(wù)
      user-client // 用戶client（Feign和DTO）

public class GrayFlagRequestHolder {
    /**
     * 標(biāo)記是否使用灰度版本
     * 具體描述請(qǐng)查看 {@link com.kerwin.gray.enums.GrayStatusEnum}
     */
    privatestaticfinal ThreadLocal<GrayStatusEnum> grayFlag = new ThreadLocal<>();
    public static void setGrayTag(final GrayStatusEnum tag) {
        grayFlag.set(tag);
    }
    public static GrayStatusEnum getGrayTag() {
        return grayFlag.get();
    }
    public static void remove() {
        grayFlag.remove();
    }
}

public class GrayGatewayBeginFilter implements GlobalFilter, Ordered {
    @Autowired
    private GrayGatewayProperties grayGatewayProperties;
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        GrayStatusEnum grayStatusEnum = GrayStatusEnum.ALL;
        // 當(dāng)灰度開關(guān)打開時(shí)才進(jìn)行請(qǐng)求頭判斷
        if (grayGatewayProperties.getEnabled()) {
            grayStatusEnum = GrayStatusEnum.PROD;
            // 判斷是否需要調(diào)用灰度版本
            if (checkGray(exchange.getRequest())) {
                grayStatusEnum = GrayStatusEnum.GRAY;
            }
        }
        GrayFlagRequestHolder.setGrayTag(grayStatusEnum);
        ServerHttpRequest newRequest = exchange.getRequest().mutate()
                .header(GrayConstant.GRAY_HEADER, grayStatusEnum.getVal())
                .build();
        ServerWebExchange newExchange = exchange.mutate()
                .request(newRequest)
                .build();
        return chain.filter(newExchange);
    }

    /**
     * 校驗(yàn)是否使用灰度版本
     */
    private boolean checkGray(ServerHttpRequest request) {
        if (checkGrayHeadKey(request) || checkGrayIPList(request) || checkGrayCiryList(request) || checkGrayUserNoList(request)) {
            returntrue;
        }
        returnfalse;
    }

    /**
     * 校驗(yàn)自定義灰度版本請(qǐng)求頭判斷是否需要調(diào)用灰度版本
     */
    private boolean checkGrayHeadKey(ServerHttpRequest request) {
        HttpHeaders headers = request.getHeaders();
        if (headers.containsKey(grayGatewayProperties.getGrayHeadKey())) {
            List<String> grayValues = headers.get(grayGatewayProperties.getGrayHeadKey());
            if (!Objects.isNull(grayValues)
                    && grayValues.size() > 0
                    && grayGatewayProperties.getGrayHeadValue().equals(grayValues.get(0))) {
                returntrue;
            }
        }
        returnfalse;
    }

    /**
     * 校驗(yàn)自定義灰度版本IP數(shù)組判斷是否需要調(diào)用灰度版本
     */
    private boolean checkGrayIPList(ServerHttpRequest request) {
        List<String> grayIPList = grayGatewayProperties.getGrayIPList();
        if (CollectionUtils.isEmpty(grayIPList)) {
            returnfalse;
        }
        String realIP = request.getHeaders().getFirst("X-Real-IP");
        if (realIP == null || realIP.isEmpty()) {
            realIP = request.getRemoteAddress().getAddress().getHostAddress();
        }
        if (realIP != null && CollectionUtils.contains(grayIPList.iterator(), realIP)) {
            returntrue;
        }
        returnfalse;
    }

    /**
     * 校驗(yàn)自定義灰度版本城市數(shù)組判斷是否需要調(diào)用灰度版本
     */
    private boolean checkGrayCiryList(ServerHttpRequest request) {
        List<String> grayCityList = grayGatewayProperties.getGrayCityList();
        if (CollectionUtils.isEmpty(grayCityList)) {
            returnfalse;
        }
        String realIP = request.getHeaders().getFirst("X-Real-IP");
        if (realIP == null || realIP.isEmpty()) {
            realIP = request.getRemoteAddress().getAddress().getHostAddress();
        }
        // 通過(guò)IP獲取當(dāng)前城市名稱
        // 這里篇幅比較長(zhǎng)不具體實(shí)現(xiàn)了,想要實(shí)現(xiàn)的可以使用ip2region.xdb,這里寫死cityName = "本地"
        String cityName = "本地";
        if (cityName != null && CollectionUtils.contains(grayCityList.iterator(), cityName)) {
            returntrue;
        }
        returnfalse;
    }

    /**
     * 校驗(yàn)自定義灰度版本用戶編號(hào)數(shù)組（我們系統(tǒng)不會(huì)在網(wǎng)關(guān)獲取用戶編號(hào)這種方法如果需要可以自己實(shí)現(xiàn)一下）
     */
    private boolean checkGrayUserNoList(ServerHttpRequest request) {
        List<String> grayUserNoList = grayGatewayProperties.getGrayUserNoList();
        if (CollectionUtils.isEmpty(grayUserNoList)) {
            returnfalse;
        }
        returnfalse;
    }

    @Override
    public int getOrder() {
        // 設(shè)置過(guò)濾器的執(zhí)行順序，值越小越先執(zhí)行
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

public class GrayGatewayAfterFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 請(qǐng)求執(zhí)行完必須要remore當(dāng)前線程的ThreadLocal
        GrayFlagRequestHolder.remove();
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        // 設(shè)置過(guò)濾器的執(zhí)行順序，值越小越先執(zhí)行
        return Ordered.LOWEST_PRECEDENCE;
    }
}

public class GrayGatewayExceptionHandler implements WebExceptionHandler, Ordered {
    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
        // 請(qǐng)求執(zhí)行完必須要remore當(dāng)前線程的ThreadLocal
        GrayFlagRequestHolder.remove();
        ServerHttpResponse response = exchange.getResponse();
        if (ex instanceof ResponseStatusException) {
            // 處理 ResponseStatusException 異常
            ResponseStatusException responseStatusException = (ResponseStatusException) ex;
            response.setStatusCode(responseStatusException.getStatus());
            // 可以根據(jù)需要設(shè)置響應(yīng)頭等
            return response.setComplete();
        } else {
            // 處理其他異常
            response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
            // 可以根據(jù)需要設(shè)置響應(yīng)頭等
            return response.setComplete();
        }
    }

    @Override
    public int getOrder() {
        // 設(shè)置過(guò)濾器的執(zhí)行順序，值越小越先執(zhí)行
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

public abstractclass AbstractGrayLoadBalancerRule extends AbstractLoadBalancerRule {
    @Autowired
    private GrayVersionProperties grayVersionProperties;

    @Value("${spring.cloud.nacos.discovery.metadata.version}")
    private String metaVersion;

    /**
     * 只有已啟動(dòng)且可訪問的服務(wù)器，并對(duì)灰度標(biāo)識(shí)進(jìn)行判斷
     */
    public List<Server> getReachableServers() {
        ILoadBalancer lb = getLoadBalancer();
        if (lb == null) {
            returnnew ArrayList<>();
        }
        List<Server> reachableServers = lb.getReachableServers();

        return getGrayServers(reachableServers);
    }

    /**
     * 所有已知的服務(wù)器，可訪問和不可訪問，并對(duì)灰度標(biāo)識(shí)進(jìn)行判斷
     */
    public List<Server> getAllServers() {
        ILoadBalancer lb = getLoadBalancer();
        if (lb == null) {
            returnnew ArrayList<>();
        }
        List<Server> allServers = lb.getAllServers();
        return getGrayServers(allServers);
    }

    /**
     * 獲取灰度版本服務(wù)列表
     */
    protected List<Server> getGrayServers(List<Server> servers) {
        List<Server> result = new ArrayList<>();
        if (servers == null) {
            return result;
        }
        String currentVersion = metaVersion;
        GrayStatusEnum grayStatusEnum = GrayFlagRequestHolder.getGrayTag();
        if (grayStatusEnum != null) {
            switch (grayStatusEnum) {
                case ALL:
                    return servers;
                case PROD:
                    currentVersion = grayVersionProperties.getProdVersion();
                    break;
                case GRAY:
                    currentVersion = grayVersionProperties.getGrayVersion();
                    break;
            }
        }

        for (Server server : servers) {
            NacosServer nacosServer = (NacosServer) server;
            Map<String, String> metadata = nacosServer.getMetadata();
            String version = metadata.get("version");
            // 判斷服務(wù)metadata下的version是否于設(shè)置的請(qǐng)求版本一致
            if (version != null && version.equals(currentVersion)) {
                result.add(server);
            }
        }
        return result;
    }
}

@SuppressWarnings("all")
publicclass GrayMvcHandlerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String grayTag = request.getHeader(GrayConstant.GRAY_HEADER);
        // 如果HttpHeader中灰度標(biāo)記存在，則將灰度標(biāo)記放到holder中，如果需要就傳遞下去
        if (grayTag!= null) {
            GrayFlagRequestHolder.setGrayTag(GrayStatusEnum.getByVal(grayTag));
        }
        returntrue;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        GrayFlagRequestHolder.remove();
    }
}

public class GrayFeignRequestInterceptor implements RequestInterceptor {

    @Override
    public void apply(RequestTemplate template) {
        // 如果灰度標(biāo)記存在，將灰度標(biāo)記通過(guò)HttpHeader傳遞下去
        GrayStatusEnum grayStatusEnum = GrayFlagRequestHolder.getGrayTag();
        if (grayStatusEnum != null ) {
            template.header(GrayConstant.GRAY_HEADER, Collections.singleton(grayStatusEnum.getVal()));
        }
    }
}

public interface GrayConstant {
    /**
     * 灰度統(tǒng)一請(qǐng)求頭
     */
    String GRAY_HEADER="gray";
}

public enum GrayStatusEnum {
    ALL("ALL","可以調(diào)用全部版本的服務(wù)"),
    PROD("PROD","只能調(diào)用生產(chǎn)版本的服務(wù)"),
    GRAY("GRAY","只能調(diào)用灰度版本的服務(wù)");
    GrayStatusEnum(String val, String desc) {
        this.val = val;
        this.desc = desc;
    }
    private String val;
    private String desc;
    public String getVal() {
        return val;
    }
    public static GrayStatusEnum getByVal(String val){
        if(val == null){
            returnnull;
        }
        for (GrayStatusEnum value : values()) {
            if(value.val.equals(val)){
                return value;
            }
        }
        returnnull;
    }
}

@Data
@Configuration
@RefreshScope
@ConfigurationProperties("kerwin.tool.gray.gateway")
publicclass GrayGatewayProperties {

    /**
     * 灰度開關(guān)（如果開啟灰度開關(guān)則進(jìn)行灰度邏輯處理，如果關(guān)閉則走正常處理邏輯）
     * PS：一般在灰度發(fā)布測(cè)試完成以后會(huì)將線上版本都切換成灰度版本完成全部升級(jí)，這時(shí)候應(yīng)該關(guān)閉灰度邏輯判斷
     */
    private Boolean enabled = false;

    /**
     * 自定義灰度版本請(qǐng)求頭 （通過(guò)grayHeadValue來(lái)匹配請(qǐng)求頭中的值如果一致就去調(diào)用灰度版本,用于公司測(cè)試）
     */
    private String grayHeadKey="gray";

    /**
     * 自定義灰度版本請(qǐng)求頭匹配值
     */
    private String grayHeadValue="gray-996";

    /**
     * 使用灰度版本IP數(shù)組
     */
    private List<String> grayIPList = new ArrayList<>();

    /**
     * 使用灰度版本城市數(shù)組
     */
    private List<String> grayCityList = new ArrayList<>();

    /**
     * 使用灰度版本用戶編號(hào)數(shù)組（我們系統(tǒng)不會(huì)在網(wǎng)關(guān)獲取用戶編號(hào)這種方法如果需要可以自己實(shí)現(xiàn)一下）
     */
    private List<String> grayUserNoList = new ArrayList<>();
}

@Data
@Configuration
@RefreshScope
@ConfigurationProperties("kerwin.tool.gray.version")
public class GrayVersionProperties {
    /**
     * 當(dāng)前線上版本號(hào)
     */
    private String prodVersion;

    /**
     * 灰度版本號(hào)
     */
    private String grayVersion;
}

@Configuration
// 可以通過(guò)@ConditionalOnProperty設(shè)置是否開啟灰度自動(dòng)配置 默認(rèn)是不加載的
@ConditionalOnProperty(value = "kerwin.tool.gray.load",havingValue = "true")
@EnableConfigurationProperties(GrayVersionProperties.class)
public class GrayAutoConfiguration {
    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(value = GlobalFilter.class)
    @EnableConfigurationProperties(GrayGatewayProperties.class)
    static class GrayGatewayFilterAutoConfiguration {
        @Bean
        public GrayGatewayBeginFilter grayGatewayBeginFilter() {
            returnnew GrayGatewayBeginFilter();
        }
        @Bean
        public GrayGatewayAfterFilter grayGatewayAfterFilter() {
            returnnew GrayGatewayAfterFilter();
        }
        @Bean
        public GrayGatewayExceptionHandler grayGatewayExceptionHandler(){
            returnnew GrayGatewayExceptionHandler();
        }
    }

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(value = WebMvcConfigurer.class)
    static class GrayWebMvcAutoConfiguration {
        /**
         * Spring MVC 請(qǐng)求攔截器
         * @return WebMvcConfigurer
         */
        @Bean
        public WebMvcConfigurer webMvcConfigurer() {
            returnnew WebMvcConfigurer() {
                @Override
                public void addInterceptors(InterceptorRegistry registry) {
                    registry.addInterceptor(new GrayMvcHandlerInterceptor());
                }
            };
        }
    }
    @Configuration
    @ConditionalOnClass(value = RequestInterceptor.class)
    static class GrayFeignInterceptorAutoConfiguration {
        /**
         * Feign攔截器
         * @return GrayFeignRequestInterceptor
         */
        @Bean
        public GrayFeignRequestInterceptor grayFeignRequestInterceptor() {
            returnnew GrayFeignRequestInterceptor();
        }
    }
}

kerwin:
  tool:
    gray:
      ## 配置是否加載灰度自動(dòng)配置類，如果不配置那么默認(rèn)不加載
      load:true
      ## 配置生產(chǎn)版本和灰度版本號(hào)
      version:
        prodVersion:V1
        grayVersion:V2

## 配置Ribbon調(diào)用user-app和order-app服務(wù)時(shí)使用我們自定義灰度輪詢算法
user-app:
ribbon:
    NFLoadBalancerRuleClassName:com.kerwin.gray.loadbalancer.GrayRoundRobinRule
order-app:
ribbon:
    NFLoadBalancerRuleClassName:com.kerwin.gray.loadbalancer.GrayRoundRobinRule

kerwin:
  tool:
    gray:
      gateway:
        ## 是否開啟灰度發(fā)布功能
        enabled:true
        ## 自定義灰度版本請(qǐng)求頭
        grayHeadKey:gray
        ## 自定義灰度版本請(qǐng)求頭匹配值
        grayHeadValue:gray-996
        ## 使用灰度版本IP數(shù)組
        grayIPList:
          -'127.0.0.1'
        ## 使用灰度版本城市數(shù)組
        grayCityList:
          -本地