springcloud+nacos实现灰度发布

weixin_421811422023-08-21 14:28

灰度发布

gateway网关实现灰度路由

灰度发布实体

package com.scm.boss.common.bean;

import lombok.Data;
import lombok.experimental.Accessors;

import java.io.Serializable;

/**
 * 灰度发布实体
 */
@Data
@Accessors(chain = true)
public class GrayBean implements Serializable {

    private static final long serialVersionUID = 1L;


    /**
     * 版本
     */
    private String preVersion;
}

灰度发布上下文信息

package com.scm.boss.common.utils;

import com.scm.boss.common.bean.GrayBean;

/**
 * 灰度信息上下文
 */
public class CurrentGrayUtils {

    private final static InheritableThreadLocal<GrayBean> CURRENT_GRE = new InheritableThreadLocal<>();


    public static GrayBean getGray() {
        GrayBean grayBean = CURRENT_GRE.get();
        return grayBean;
    }

    public static void setGray(GrayBean grayBean) {
        if(grayBean == null){
            clear();
        }else {
            CURRENT_GRE.set(grayBean);
        }
    }

    public static void clear() {
        CURRENT_GRE.remove();
    }

}

灰度过滤器设置灰度上下文信息

package com.scm.gateway.common.config;

import com.scm.boss.common.bean.GrayBean;
import com.scm.boss.common.constants.CommonConstants;
import com.scm.boss.common.utils.CurrentGrayUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.web.server.ServerWebExchange;
 
import reactor.core.publisher.Mono;

/**
 * 灰度发布版本标识过滤器
 */
@Slf4j
public class GrayFilter implements GlobalFilter, Ordered {
 
	@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		HttpHeaders httpHeaders = exchange.getRequest().getHeaders();
		String grayVersion = httpHeaders.getFirst(CommonConstants.GRAY_VERSION);
		if (StringUtils.isNotBlank(grayVersion)) {
			GrayBean grayBean = new GrayBean();
			grayBean.setPreVersion(grayVersion);
			CurrentGrayUtils.setGray(grayBean);
			//请求头添加灰度版本号，用于灰度请求
			exchange.getRequest().mutate()
					.header(CommonConstants.GRAY_VERSION, grayVersion)
					.build();
		}
		return chain.filter(exchange);
	}

	@Override
	public int getOrder() {
		return Integer.MIN_VALUE;
	}
}

灰度路由规则

package com.scm.gateway.common.config;

import com.alibaba.cloud.nacos.ribbon.NacosServer;
import com.google.common.base.Optional;
import com.netflix.loadbalancer.Server;
import com.netflix.loadbalancer.ZoneAvoidanceRule;
import com.scm.boss.common.bean.GrayBean;
import com.scm.boss.common.constants.CommonConstants;
import com.scm.boss.common.exception.ApiException;
import com.scm.boss.common.utils.CurrentGrayUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
public class GateWayGrayRouteRule extends ZoneAvoidanceRule {

    @Override
    public Server choose(Object key) {
        Optional<Server> server;
        try {
            // 根据灰度路由规则，过滤出符合规则的服务 this.getServers()
            // 再根据负载均衡策略，过滤掉不可用和性能差的服务，然后在剩下的服务中进行轮询  getPredicate().chooseRoundRobinAfterFiltering()
            server = getPredicate()
                    .chooseRoundRobinAfterFiltering(this.getServers(), key);
            //获取请求头中的版本号
            GrayBean grayBean = CurrentGrayUtils.getGray();
            if (null != grayBean && !StringUtils.isEmpty(grayBean.getPreVersion())) {
                log.info("灰度路由规则过滤后的服务实例：{}", server.isPresent() ? server.get().getHostPort() : null);
            }
        } finally {
            CurrentGrayUtils.clear();
        }

        return server.isPresent() ? server.get() : null;
    }

    /**
     * 灰度路由过滤服务实例
     *
     * 如果设置了期望版本， 则过滤出所有的期望版本 ，然后再走默认的轮询 如果没有一个期望的版本实例，则不过滤，降级为原有的规则，进行所有的服务轮询。（灰度路由失效） 如果没有设置期望版本
     * 则不走灰度路由，按原有轮询机制轮询所有
     */
    protected List<Server> getServers() {
        // 获取spring cloud默认负载均衡器
        // 获取所有待选的服务
        List<Server> allServers = getLoadBalancer().getReachableServers();
        if (CollectionUtils.isEmpty(allServers)) {
            log.error("没有可用的服务实例");
            throw new ApiException("没有可用的服务实例");
        }
        //获取请求头中的版本号
        GrayBean grayBean = CurrentGrayUtils.getGray();
        // 如果没有设置要访问的版本，则不过滤，返回所有，走原有默认的轮询机制
        if (null == grayBean || StringUtils.isEmpty(grayBean.getPreVersion())
                || !CommonConstants.GRAY_VERSION_VALUE.equals(grayBean.getPreVersion())) {
            //这里需要过滤掉灰度服务实例
            List<Server> list = allServers.stream().filter(f -> {
                // 获取服务实例在注册中心上的元数据
                Map<String, String> metadata = ((NacosServer) f).getMetadata();
                // 如果注册中心上服务的版本标签和期望访问的版本一致，则灰度路由匹配成功
                if (null != metadata && StringUtils.isNotBlank(metadata.get(CommonConstants.GRAY_VERSION))
                        && CommonConstants.GRAY_VERSION_VALUE.equals(metadata.get(CommonConstants.GRAY_VERSION))) {
                    return false;
                }
                return true;
            }).collect(Collectors.toList());

            return list;
        }

        // 开始灰度规则匹配过滤
        List<Server> filterServer = new ArrayList<>();
        for (Server server : allServers) {
            // 获取服务实例在注册中心上的元数据
            Map<String, String> metadata = ((NacosServer) server).getMetadata();
            // 如果注册中心上服务的版本标签和期望访问的版本一致，则灰度路由匹配成功
            if (null != metadata && grayBean.getPreVersion().equals(metadata.get(CommonConstants.GRAY_VERSION))) {
                filterServer.add(server);
            }
        }
        // 如果没有匹配到期望的版本实例服务，为了保证服务可用性，让灰度规则失效，走原有的轮询所有可用服务的机制
        if (CollectionUtils.isEmpty(filterServer)) {
            log.error("灰度路由规则失效，没有找到期望的版本实例");
            throw new ApiException("灰度路由规则失效，没有找到期望的版本实例");
        }
        return filterServer;
    }
}

gateway网关需要引入的pom

 <dependencies>
        <!-- Nacos注册中心 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- Nacos配置中心 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

        <!-- gateway -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <dependency>
            <groupId>com.scm</groupId>
            <artifactId>scm-common-boss</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-netflix-ribbon</artifactId>
        </dependency>
    </dependencies>

常量

package com.scm.boss.common.constants;

public interface CommonConstants {
	 /**
	     * 灰度请求头参数
	     */
	    String GRAY_VERSION = "grayVersion";
	    /**
	     * 灰度版本值
	     */
	    String GRAY_VERSION_VALUE = "V1";
    }

微服务feign调用灰度

服务路由规则

package com.scm.cloud.config;

import com.alibaba.cloud.nacos.ribbon.NacosServer;
import com.google.common.base.Optional;
import com.netflix.loadbalancer.Server;
import com.netflix.loadbalancer.ZoneAvoidanceRule;
import com.scm.boss.common.bean.GrayBean;
import com.scm.boss.common.constants.CommonConstants;
import com.scm.boss.common.exception.ApiException;
import com.scm.boss.common.utils.CurrentGrayUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.context.annotation.Scope;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
/**
 * 灰度路由规则，需要是多例每一个服务单独一个实例，否则会出现服务乱调用问题
 */
@Scope("prototype")
public class GrayRouteRule extends ZoneAvoidanceRule {

    @Override
    public Server choose(Object key) {
        // 根据灰度路由规则，过滤出符合规则的服务 this.getServers()
        // 再根据负载均衡策略，过滤掉不可用和性能差的服务，然后在剩下的服务中进行轮询  getPredicate().chooseRoundRobinAfterFiltering()
        Optional<Server> server = getPredicate()
                .chooseRoundRobinAfterFiltering(this.getServers(), key);
        //获取请求头中的版本号
        GrayBean grayBean = CurrentGrayUtils.getGray();
        if (null != grayBean && !StringUtils.isEmpty(grayBean.getPreVersion())) {
            log.info("灰度路由规则过滤后的服务实例：{}", server.isPresent() ? server.get().getHostPort() : null);
        }
        return server.isPresent() ? server.get() : null;
    }

    /**
     * 灰度路由过滤服务实例
     *
     * 如果设置了期望版本， 则过滤出所有的期望版本 ，然后再走默认的轮询 如果没有一个期望的版本实例，则不过滤，降级为原有的规则，进行所有的服务轮询。（灰度路由失效） 如果没有设置期望版本
     * 则不走灰度路由，按原有轮询机制轮询所有
     */
    protected List<Server> getServers() {
        // 获取spring cloud默认负载均衡器
        // 获取所有待选的服务
        List<Server> allServers = getLoadBalancer().getReachableServers();
        if (CollectionUtils.isEmpty(allServers)) {
            log.error("没有可用的服务实例");
            throw new ApiException("没有可用的服务实例");
        }

        //获取请求头中的版本号
        GrayBean grayBean = CurrentGrayUtils.getGray();
        // 如果没有设置要访问的版本，则不过滤，返回所有，走原有默认的轮询机制
        if (null == grayBean || StringUtils.isEmpty(grayBean.getPreVersion())
                || !CommonConstants.GRAY_VERSION_VALUE.equals(grayBean.getPreVersion())) {
            //这里需要过滤掉灰度服务实例
            List<Server> list = allServers.stream().filter(f -> {
                // 获取服务实例在注册中心上的元数据
                Map<String, String> metadata = ((NacosServer) f).getMetadata();
                // 如果注册中心上服务的版本标签和期望访问的版本一致，则灰度路由匹配成功
                if (null != metadata && StringUtils.isNotBlank(metadata.get(CommonConstants.GRAY_VERSION))
                        && CommonConstants.GRAY_VERSION_VALUE.equals(metadata.get(CommonConstants.GRAY_VERSION))) {
                    return false;
                }
                return true;
            }).collect(Collectors.toList());
            return list;
        }

        // 开始灰度规则匹配过滤
        List<Server> filterServer = new ArrayList<>();
        for (Server server : allServers) {
            // 获取服务实例在注册中心上的元数据
            Map<String, String> metadata = ((NacosServer) server).getMetadata();
            // 如果注册中心上服务的版本标签和期望访问的版本一致，则灰度路由匹配成功
            if (null != metadata && grayBean.getPreVersion().equals(metadata.get(CommonConstants.GRAY_VERSION))) {
                filterServer.add(server);
            }
        }
        // 如果没有匹配到期望的版本实例服务，为了保证服务可用性，让灰度规则失效，走原有的轮询所有可用服务的机制
        if (CollectionUtils.isEmpty(filterServer)) {
            log.error("灰度路由规则失效，没有找到期望的版本实例，version={}", grayBean.getPreVersion());
            throw new ApiException("灰度路由规则失效，没有找到期望的版本实例");
        }
        return filterServer;
    }
}

需要传递灰度版本号，所以需要把灰度版本请求参数传递下去，以及解决Hystrix的线程切换导致参数无法传递下的问题

使用TransmittableThreadLocal可以跨线程传递

package com.scm.cloud.config;

import com.scm.cloud.security.DefaultSecurityInterceptor;
import com.scm.cloud.security.SecurityInterceptor;
import com.scm.cloud.webmvc.WebMvcCommonConfigurer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.PostConstruct;

/**
 * 配置
 * @date 2023/7/13 18:12
 * @author luohao
 */
@Configuration
@Slf4j
public class CommonConfiguration {

    /**
     * 低优先级
     */
    private final static int LOWER_PRECEDENCE = 10000;

    /**
     * 使用TransmittableThreadLocal可以跨线程传递
     */
    @PostConstruct
    public void init(){
        new GlobalHystrixConcurrencyStrategy();
    }


    @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcCommonConfigurer();
    }

    /**
     * 优先级
     * @return
     */
    @Bean
    @ConditionalOnMissingBean
    @Order(value = LOWER_PRECEDENCE)
    public SecurityInterceptor securityInterceptor(){
        return new DefaultSecurityInterceptor();
    }

}

bean重复则覆盖

package com.scm.cloud.config;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.env.EnvironmentPostProcessor;
import org.springframework.core.env.ConfigurableEnvironment;

/**
 * @author xiewu
 * @date 2022/12/29 10:41
 */
public class EnvironmentPostProcessorConfig implements EnvironmentPostProcessor {

    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        application.setAllowBeanDefinitionOverriding(true);
    }
}

feign调用拦截器

package com.scm.cloud.config;

import com.scm.boss.common.bean.CurrentUserBean;
import com.scm.boss.common.bean.DealerApiDetailBean;
import com.scm.boss.common.bean.GrayBean;
import com.scm.boss.common.constants.CommonConstants;
import com.scm.boss.common.utils.CurrentGrayUtils;
import com.scm.boss.common.utils.CurrentUserUtils;
import com.scm.boss.common.utils.CurrentDealerApiDetailUtils;
import feign.Feign;
import feign.Logger;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import feign.codec.Encoder;
import feign.form.spring.SpringFormEncoder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
import org.springframework.cloud.openfeign.FeignAutoConfiguration;
import org.springframework.cloud.openfeign.support.SpringEncoder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Scope;


@ConditionalOnClass(Feign.class)
@AutoConfigureBefore(FeignAutoConfiguration.class)
@Slf4j
@Configuration
public class FeignConfig {

    @Bean
    public RequestInterceptor requestInterceptor() {
        return new RequestInterceptor() {
            @Override
            public void apply(RequestTemplate requestTemplate) {
                GrayBean grayBean = CurrentGrayUtils.getGray();
                if (null != grayBean) {
                    requestTemplate.header(CommonConstants.GRAY_VERSION, grayBean.getPreVersion());
                }

                DealerApiDetailBean dealerApiDetailBean = CurrentDealerApiDetailUtils.getDealerApiConditionNull();
                if (dealerApiDetailBean != null){
                    requestTemplate.header(CommonConstants.DEALER_ID, dealerApiDetailBean.getDealerId());
                    requestTemplate.header(CommonConstants.DEALER_PROJECT_ID, dealerApiDetailBean.getDealerProjectId());
                }
                CurrentUserBean currentUser = CurrentUserUtils.getCurrentUserConditionNull();
                if (currentUser == null){
                    return;
                }
                requestTemplate.header(CommonConstants.SUPPLIER_ID, currentUser.getSupplierId() == null ? null : currentUser.getId().toString());
                requestTemplate.header(CommonConstants.ACCOUNT_NO, currentUser.getAccountNo());
                requestTemplate.header(CommonConstants.REQUEST_SOURCE, currentUser.getType());
                requestTemplate.header(CommonConstants.ID, currentUser.getId() == null ? null : currentUser.getId().toString());
            }
        };
    }


    /**
     * Feign 客户端的日志记录，默认级别为NONE
     * Logger.Level 的具体级别如下：
     * NONE：不记录任何信息
     * BASIC：仅记录请求方法、URL以及响应状态码和执行时间
     * HEADERS：除了记录 BASIC级别的信息外，还会记录请求和响应的头信息
     * FULL：记录所有请求与响应的明细，包括头信息、请求体、元数据
     */
    @Bean
    Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }

    /**
     * Feign支持文件上传
     *
     * @param messageConverters
     * @return
     */
    @Bean
    @Primary
    @Scope("prototype")
    public Encoder multipartFormEncoder(ObjectFactory<HttpMessageConverters> messageConverters) {
        return new SpringFormEncoder(new SpringEncoder(messageConverters));
    }
}

Hystrix并发策略

package com.scm.cloud.config;

import com.netflix.hystrix.strategy.HystrixPlugins;
import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy;
import com.netflix.hystrix.strategy.eventnotifier.HystrixEventNotifier;
import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher;
import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
import com.scm.boss.common.bean.CurrentUserBean;
import com.scm.boss.common.bean.DealerApiDetailBean;
import com.scm.boss.common.bean.GrayBean;
import com.scm.boss.common.utils.CurrentGrayUtils;
import com.scm.boss.common.utils.CurrentUserUtils;
import com.scm.boss.common.utils.CurrentDealerApiDetailUtils;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;

@Slf4j
public class GlobalHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {

    private HystrixConcurrencyStrategy delegate;

    public GlobalHystrixConcurrencyStrategy() {
        this.delegate = HystrixPlugins.getInstance().getConcurrencyStrategy();
        if (this.delegate instanceof GlobalHystrixConcurrencyStrategy) {
            return;
        }
        HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance().getEventNotifier();
        HystrixPropertiesStrategy propertiesStrategy = HystrixPlugins.getInstance().getPropertiesStrategy();
        HystrixCommandExecutionHook commandExecutionHook = HystrixPlugins.getInstance().getCommandExecutionHook();
        HystrixMetricsPublisher metricsPublisher = HystrixPlugins.getInstance().getMetricsPublisher();

        HystrixPlugins.reset();

        HystrixPlugins.getInstance().registerMetricsPublisher(metricsPublisher);
        // Registers existing plugins except the new MicroMeter Strategy plugin.
        HystrixPlugins.getInstance().registerConcurrencyStrategy(this);
        HystrixPlugins.getInstance().registerEventNotifier(eventNotifier);
        HystrixPlugins.getInstance().registerPropertiesStrategy(propertiesStrategy);
        HystrixPlugins.getInstance().registerCommandExecutionHook(commandExecutionHook);
        log.info("Construct HystrixConcurrencyStrategy:[{}] for application,",GlobalHystrixConcurrencyStrategy.class.getName());
    }

    @Override
    public <T> Callable<T> wrapCallable(Callable<T> callable) {
        final CurrentUserBean user = CurrentUserUtils.getCurrentUserConditionNull();
        final DealerApiDetailBean dealerApiDetailBean = CurrentDealerApiDetailUtils.getDealerApiConditionNull();
        final GrayBean grayBean = CurrentGrayUtils.getGray();

        if (callable instanceof HeaderCallable) {
            return callable;
        }
        Callable<T> wrappedCallable = this.delegate != null
                ? this.delegate.wrapCallable(callable) : callable;
        if (wrappedCallable instanceof HeaderCallable) {
            return wrappedCallable;
        }
        return new HeaderCallable<T>(wrappedCallable,user,dealerApiDetailBean, grayBean);
    }
}

Hystrix并发参数线程中传递参数

package com.scm.cloud.config;

import com.scm.boss.common.bean.CurrentUserBean;
import com.scm.boss.common.bean.DealerApiDetailBean;
import com.scm.boss.common.bean.GrayBean;
import com.scm.boss.common.utils.CurrentGrayUtils;
import com.scm.boss.common.utils.CurrentUserUtils;
import com.scm.boss.common.utils.CurrentDealerApiDetailUtils;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;

@Slf4j
public class HeaderCallable<V> implements Callable<V> {

    private final Callable<V> delegate;
    private final CurrentUserBean currentUserBean;
    private final DealerApiDetailBean dealerApiDetailBean;
    private final GrayBean grayBean;

    public HeaderCallable(Callable<V> delegate, CurrentUserBean currentUserBean, DealerApiDetailBean dealerApiDetailBean, GrayBean grayBean) {
        this.delegate = delegate;
        this.currentUserBean = currentUserBean;
        this.dealerApiDetailBean = dealerApiDetailBean;
        this.grayBean = grayBean;
    }

    @Override
    public V call() throws Exception {
        try {
            CurrentUserUtils.setCurrentUser(currentUserBean);
            CurrentDealerApiDetailUtils.setDealerApi(dealerApiDetailBean);
            CurrentGrayUtils.setGray(grayBean);
            return this.delegate.call();
        } catch (Exception e) {
            //这里无法抓取到delegate.call()方法的异常，因为是线程池异步请求的
            throw e;
        } finally {
            CurrentUserUtils.clear();
            CurrentGrayUtils.clear();
            CurrentDealerApiDetailUtils.clear();
        }
    }
}

LoadBalancerFeignClient

package com.scm.cloud.config;

import feign.Client;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
import org.springframework.cloud.openfeign.ribbon.CachingSpringLoadBalancerFactory;
import org.springframework.cloud.openfeign.ribbon.LoadBalancerFeignClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class PersonBeanConfiguration {

    /**
     * 创建FeignClient
     */
    @Bean
    @ConditionalOnMissingBean
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
                              SpringClientFactory clientFactory) {
        return new LoadBalancerFeignClient(new Client.Default(null, null),
                cachingFactory, clientFactory);
    }
}

拦截器HandlerInterceptor

package com.scm.cloud.webmvc;

import com.alibaba.fastjson.JSONArray;
import com.scm.boss.common.bean.CurrentUserBean;
import com.scm.boss.common.bean.DealerApiDetailBean;
import com.scm.boss.common.bean.GrayBean;
import com.scm.boss.common.bean.RouteAttrPermVO;
import com.scm.boss.common.constants.CommonConstants;
import com.scm.boss.common.constants.PlatformTypeEnum;
import com.scm.boss.common.constants.UserTypeEnum;
import com.scm.boss.common.utils.CurrentDealerApiDetailUtils;
import com.scm.boss.common.utils.CurrentGrayUtils;
import com.scm.boss.common.utils.CurrentUserUtils;
import com.scm.boss.common.utils.FieldListUtils;
import com.scm.redis.template.RedisRepository;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.HandlerMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 拦截器
 * @date 2023/7/13 18:09
 * @author luohao
 */
@Slf4j
public class GlobalHandlerInterceptor implements HandlerInterceptor {

    private RedisRepository redisRepository;

    public GlobalHandlerInterceptor(RedisRepository redisRepository) {
        this.redisRepository = redisRepository;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception
    {
        extractedHeadersGre(request);
        extractedHeaders(request);
        extractedHeadersApi(request);
        extractedPermissionFields(request);
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }

    /**
     * 灰度发布
     * @param request
     */
    private void extractedHeadersGre(HttpServletRequest request) {
        String grayVersion = request.getHeader(CommonConstants.GRAY_VERSION);
        if (StringUtils.isNotBlank(grayVersion)) {
            GrayBean grayBean = new GrayBean();
            grayBean.setPreVersion(grayVersion);
            CurrentGrayUtils.setGray(grayBean);
        }
    }

    /**
     * 第三方经销商调用
     * @param request
     */
    private void extractedHeadersApi(HttpServletRequest request) {
        DealerApiDetailBean dealerApiDetailBean = new DealerApiDetailBean();
        dealerApiDetailBean.setDealerId(request.getHeader(CommonConstants.DEALER_ID))
                .setDealerProjectId(request.getHeader(CommonConstants.DEALER_PROJECT_ID));
        CurrentDealerApiDetailUtils.setDealerApi(dealerApiDetailBean);
    }

    private void extractedHeaders(HttpServletRequest request) {
        CurrentUserBean currentUserBean = new CurrentUserBean();
        currentUserBean.setAccountNo(request.getHeader(CommonConstants.ACCOUNT_NO));
        currentUserBean.setType(request.getHeader(CommonConstants.REQUEST_SOURCE));
        currentUserBean.setStatus(request.getHeader(CommonConstants.STATUS) == null ? null : Integer.valueOf(request.getHeader(CommonConstants.STATUS)));
        currentUserBean.setId(request.getHeader(CommonConstants.ID) == null ? null : Integer.valueOf(request.getHeader(CommonConstants.ID)));
        if (UserTypeEnum.SUPPLIER_USER.getCode().equals(currentUserBean.getType())) {
            currentUserBean.setSupplierId(request.getHeader(CommonConstants.SUPPLIER_ID) == null ? null : Integer.valueOf(request.getHeader(CommonConstants.SUPPLIER_ID)));
        }
        CurrentUserUtils.setCurrentUser(currentUserBean);
    }

    /**
     * 获取接口无权限字段
     * @date 2023/7/13 16:41
     * @author luohao
     */
    private void extractedPermissionFields(HttpServletRequest request){
        String requestMapping = request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE).toString();
        CurrentUserBean currentUser = CurrentUserUtils.getCurrentUser();
        if(Objects.isNull(currentUser) || Objects.isNull(currentUser.getAccountNo())){
            return;
        }
        String key;
        if(currentUser.getType().equals(PlatformTypeEnum.APPLY_CHAIN.getCode().toString())){
            key = CommonConstants.SUPPLY_CHAIN_ATTR;
        }else if(currentUser.getType().equals(PlatformTypeEnum.DEALER.getCode().toString())){
            key = CommonConstants.DEALER_ATTR;
        }else{
            return;
        }
        String redisKey = new StringBuilder(key).append(currentUser.getAccountNo()).toString();
        List<RouteAttrPermVO> spuEditDTO = JSONArray.parseArray(redisRepository.get(redisKey), RouteAttrPermVO.class);
        if(CollectionUtils.isEmpty(spuEditDTO)){
            return;
        }
        List<String> nonPermAttrs = spuEditDTO.stream().filter(i -> i.getUrl().equals(requestMapping)).map(RouteAttrPermVO::getAttrName).collect(Collectors.toList());
        FieldListUtils.setFieldList(nonPermAttrs);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        CurrentUserUtils.clear();
        FieldListUtils.clear();
    }


}

WebMvcConfigurer

package com.scm.cloud.webmvc;

import com.scm.redis.template.RedisRepository;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * WebMvc
 * @date 2023/7/13 18:11
 * @author luohao
 */
public class WebMvcCommonConfigurer implements WebMvcConfigurer {

    @Resource
    private RedisRepository redisRepository;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new GlobalHandlerInterceptor(redisRepository)).addPathPatterns("/**").excludePathPatterns("/info","/actuator/**");
    }
}

特殊数据权限过滤

package com.scm.cloud.webmvc;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.ObjectSerializer;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializeWriter;
import com.scm.boss.common.utils.FieldListUtils;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

import java.io.IOException;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 特殊数据权限过滤
 * @date 2023/7/12 14:54
 * @author luohao
 */
@Component
@RestControllerAdvice
public class BaseGlobalResponseBodyAdvice implements ResponseBodyAdvice<Object> {

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(final Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        if(ObjectUtils.isEmpty(body)){
            return body;
        }
        List<String> fieldList = FieldListUtils.getFieldList();
        if(CollectionUtils.isEmpty(fieldList)){
            return body;
        }
        SerializeConfig config = new SerializeConfig();
        config.put( Date.class, new DateJsonSerializer());
        return objectEval(JSONObject.parseObject(JSON.toJSONString(body,config)), fieldList);
    }

    /**
     * 权限数据处理
     * @param body
     * @param nonPermAttrs
     * @return
     */
    public Object objectEval(Object body, List<String> nonPermAttrs) {
        if (Objects.nonNull(body) && body instanceof Map) {
            Map<String, Object> map = (Map<String, Object>) body;
            map.keySet().forEach(key -> {
                Object o = map.get(key);
                if (Objects.nonNull(o) && o instanceof Map) {
                    map.put(key, objectEval(o, nonPermAttrs));
                } else if (Objects.nonNull(o) && o instanceof List){
                    map.put(key, objectEval(o, nonPermAttrs));
                }else {
                    List<String> collect = nonPermAttrs.stream().filter(i -> i.equals(key)).collect(Collectors.toList());
                    if (CollectionUtils.isNotEmpty(collect)){
                        map.put(key, null);
                    }
                }
            });
        } else if (Objects.nonNull(body) && body instanceof List) {
            final List<Object> dataList = (List<Object>) body;
            dataList.forEach(i -> objectEval(i,nonPermAttrs));
        }
        return body;
    }
}

class DateJsonSerializer implements ObjectSerializer {

    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
        SerializeWriter out = serializer.getWriter();
        if (object == null) {
            serializer.getWriter().writeNull();
            return;
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        sdf.setTimeZone( TimeZone.getTimeZone("Etc/GMT-8"));
        out.write("\"" + sdf.format( (Date) object ) + "\"");
    }
}

微服务的spring.factories配置

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.scm.cloud.config.FeignConfig,\
com.scm.cloud.config.PersonBeanConfiguration,\
com.scm.cloud.webmvc.BaseGlobalResponseBodyAdvice,\
com.scm.cloud.config.CommonConfiguration,\
com.scm.cloud.config.GrayRouteRule
org.springframework.boot.env.EnvironmentPostProcessor = com.scm.cloud.config.EnvironmentPostProcessorConfig

微服务的pom文件

<dependencies>
        <!-- Nacos注册中心 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- Nacos配置中心 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!-- feign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>com.scm</groupId>
            <artifactId>scm-starter-redis</artifactId>
            <version>${project.version}</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
相关推荐
大数据编程之光19 分钟前
Flink Standalone集群模式安装部署全攻略
java·大数据·开发语言·面试·flink
爪哇学长33 分钟前
双指针算法详解：原理、应用场景及代码示例
java·数据结构·算法
ExiFengs36 分钟前
实际项目Java1.8流处理, Optional常见用法
java·开发语言·spring
paj12345678938 分钟前
JDK1.8新增特性
java·开发语言
捂月44 分钟前
Spring Boot 深度解析：快速构建高效、现代化的 Web 应用程序
前端·spring boot·后端
繁依Fanyi1 小时前
简易安卓句分器实现
java·服务器·开发语言·算法·eclipse
慧都小妮子1 小时前
Spire.PDF for .NET【页面设置】演示：打开 PDF 时自动显示书签或缩略图
java·pdf·.net
m51271 小时前
LinuxC语言
java·服务器·前端
IU宝1 小时前
C/C++内存管理
java·c语言·c++
瓜牛_gn1 小时前
依赖注入注解
java·后端·spring
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10ICLR24大模型提示(1/11) | BadChain：大型语言模型的后门思维链提示