对Feign的请求url 重写

需求：对当前请求的 url 重新构建

debug feign 的执行可知，重写 LoadBalancerFeignClient 类中的 execute 方法即可控制当前请求的url

代码分析

当引入 spring-cloud-sleuth-stream 时， seluth也重写了feign 的 feign.Client 查看 TraceFeignClientAutoConfiguration 类，

        @Configuration
	@ConditionalOnProperty(name = "spring.sleuth.feign.processor.enabled", matchIfMissing = true)
	protected static class FeignBeanPostProcessorConfiguration {

		@Bean
		FeignContextBeanPostProcessor feignContextBeanPostProcessor(BeanFactory beanFactory) {
			return new FeignContextBeanPostProcessor(beanFactory);// 对 FeignContext 进行了重新包装 
		}
	}

@Bean  // 对 LoadBalancerFeignClient bean 的包装类
TraceFeignObjectWrapper traceFeignObjectWrapper(BeanFactory beanFactory) {
   return new TraceFeignObjectWrapper(beanFactory);
}

@Bean // 对 feign.Client 的所有方法进行拦截，如果 执行的 bean 不是 TraceFeignClient ，则返 TraceFeignClient bean,执行该类中的方法，该类也实现了 feign的 Client 接口
TraceFeignAspect traceFeignAspect(BeanFactory beanFactory) {
   return new TraceFeignAspect(beanFactory);
}

　　

final class FeignContextBeanPostProcessor implements BeanPostProcessor {

	private final BeanFactory beanFactory;
	private TraceFeignObjectWrapper traceFeignObjectWrapper;

	FeignContextBeanPostProcessor(BeanFactory beanFactory) {
		this.beanFactory = beanFactory;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		if (bean instanceof FeignContext && !(bean instanceof TraceFeignContext)) { //如果bean 是 FeignContext，则返回 TraceFeignContext 的bean
			return new TraceFeignContext(getTraceFeignObjectWrapper(), (FeignContext) bean); 
		}
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
		return bean;
	}

	private TraceFeignObjectWrapper getTraceFeignObjectWrapper() {
		if (this.traceFeignObjectWrapper == null) {
　　　　　　　　　　　　　　// 查看 TraceFeignObjectWrapper 类
			this.traceFeignObjectWrapper = this.beanFactory.getBean(TraceFeignObjectWrapper.class);
		}
		return this.traceFeignObjectWrapper;
	}
}

　　

查看 TraceFeignObjectWrapper 类，代码如下：

final class TraceFeignObjectWrapper {

	private final BeanFactory beanFactory;

	private CachingSpringLoadBalancerFactory cachingSpringLoadBalancerFactory;
	private SpringClientFactory springClientFactory;

	TraceFeignObjectWrapper(BeanFactory beanFactory) {
		this.beanFactory = beanFactory;
	}

	Object wrap(Object bean) {
		if (bean instanceof Client && !(bean instanceof TraceFeignClient)) {
			if (bean instanceof LoadBalancerFeignClient) { //如果 bean 是 LoadBalancerFeignClient 的 bean，则返回  TraceLoadBalancerFeignClient 的 bean
				LoadBalancerFeignClient client = ((LoadBalancerFeignClient) bean);
				return new TraceLoadBalancerFeignClient(
						client.getDelegate(), factory(),
						clientFactory(), this.beanFactory);
			}
			return new TraceFeignClient(this.beanFactory, (Client) bean);
		}
		return bean;
	}

	CachingSpringLoadBalancerFactory factory() {
		if (this.cachingSpringLoadBalancerFactory == null) {
			this.cachingSpringLoadBalancerFactory = this.beanFactory
					.getBean(CachingSpringLoadBalancerFactory.class);
		}
		return this.cachingSpringLoadBalancerFactory;
	}

	SpringClientFactory clientFactory() {
		if (this.springClientFactory == null) {
			this.springClientFactory = this.beanFactory
					.getBean(SpringClientFactory.class);
		}
		return this.springClientFactory;
	}
}

　　

当请求执行时，查看 LoadBalancerFeignClient类可知如图所示， delegate 显示为TraceFeignClient 的bean ，说明feign 的 负载均衡客户端现在用的是 TraceLoadBalancerFeignClient

查看 AbstractLoadBalancerAwareClient 类，获取当前server 的ip，端口，请求url，如图所示

 feign 的默认 Client 为 Default 类，根据请求服务的ip，端口和url ，发起请求，所以最终请求的执行，如下面所示

由上面的流程可知，引入sleuth 时,sleuth 中的feign相关类重写了 feign 的负载均衡类，所以要关闭 这个功能，当 配置文件中有 spring.sleuth.feign.enabled=false 时，则

sleuth 重写 feign 负载均衡器 ，则不生效。

当配置文件中有 ribbon.eureka.enabled=false 属性时，才会使用 ribbon.listOfServers 中配置的信息，所有要 实现 EnvironmentPostProcessor 类，将属性放入 

defaultProperties 配置文件级别中，方便当项目中有相同属性时，覆盖已添加的属性信息

@Slf4j
public class MockEnvironmentPostProcessor implements EnvironmentPostProcessor {

    private static final String PROPERTY_SOURCE_NAME = "defaultProperties";


    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        //获取mock属性配置，并绑定到MockProperties 对象中
        MockProperties target = new MockProperties();
        RelaxedDataBinder binder = new RelaxedDataBinder(target,
                MockProperties.MOCK_PREFIX);
        binder.bind(new PropertySourcesPropertyValues(environment.getPropertySources()));

        boolean enabled = target.isEnabled();
        if (true == enabled) {
            System.out.println("mock server 构建环境属性");
            Map<String, Object> map = new HashMap<>();

            //对单个服务mock的处理
            if (StringUtils.isNotBlank(target.getServices())) {
                String[] services = target.getServices().split(",");
                for (String service : services) {
                    map.put(service.toUpperCase() + ".ribbon.listOfServers", target.getIpAddress());
                    System.out.println(String.format("对[%s]服务配置 mock地址[%s]", service, target.getIpAddress()));
                }
            }

            // 自定义 每个服务的ip地址 服务直连情况
            if (!target.getServicesMap().isEmpty()) {
                Map<String, String> servicesMap = target.getServicesMap();
                for (String key : servicesMap.keySet()) {
                    String ip = servicesMap.get(key);
                    map.put(key.toUpperCase() + ".ribbon.listOfServers", ip);
                    System.out.println(String.format("对[%s]服务配置直连地址[%s]", key, ip));
                }
            }

            // 服务重试切换次数
            map.put("ribbon.MaxAutoRetriesNextServer", 0);
            // 服务重试次数
            map.put("ribbon.MaxAutoRetries", 0);
            // ribbon 连接时间
            map.put("ribbon.connectTimeoutMillis", 10000);
            // ribbon 读取时间
            map.put("ribbon.readTimeoutMillis", 60000);
            // 对所有操作请求都不重试
            map.put("ribbon.OkToRetryOnAllOperations", false);

            //ribbon不使用eureka上的服务信息
            map.put("ribbon.eureka.enabled", false);
            // 关闭 sleuth 对 feign client 的包装
            map.put("spring.sleuth.feign.enabled", false);
            // 设置全局的超时时间 hystrix 熔断超时时间
            map.put("hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds", 60000);
            addOrReplace(environment.getPropertySources(), map);

        }

    }

    private void addOrReplace(MutablePropertySources propertySources,
                              Map<String, Object> map) {
        MapPropertySource target = null;
        if (propertySources.contains(PROPERTY_SOURCE_NAME)) {
            PropertySource<?> source = propertySources.get(PROPERTY_SOURCE_NAME);
            if (source instanceof MapPropertySource) {
                target = (MapPropertySource) source;
                for (String key : map.keySet()) {
                    if (!target.containsProperty(key)) {
                        target.getSource().put(key, map.get(key));
                    }
                }
            }
        }
        if (target == null) {
            target = new MapPropertySource(PROPERTY_SOURCE_NAME, map);
        }
        if (!propertySources.contains(PROPERTY_SOURCE_NAME)) {
            propertySources.addLast(target);
        }
    }
}

　

在 spring.factories 文件中配置　

# Environment Post Processor
org.springframework.boot.env.EnvironmentPostProcessor=
MockEnvironmentPostProcessor

　

继承 LoadBalancerFeignClient 类，重写 　execute 方法

@Slf4j
public class MockLoadBalancerFeignClient extends LoadBalancerFeignClient {

    private MockProperties mockProperties;

    private DiscoveryClient discoveryClient;

    private Client delegate;
    private CachingSpringLoadBalancerFactory lbClientFactory;
    private SpringClientFactory clientFactory;

    public MockLoadBalancerFeignClient(Client delegate,
                                       CachingSpringLoadBalancerFactory lbClientFactory,
                                       SpringClientFactory clientFactory, MockProperties mockProperties, DiscoveryClient discoveryClient) {
        super(delegate, lbClientFactory, clientFactory);
        this.delegate = delegate;
        this.lbClientFactory = lbClientFactory;
        this.clientFactory = clientFactory;

        this.mockProperties = mockProperties;
        this.discoveryClient = discoveryClient;
        log.info("mock feign 负载均衡器初始化");
    }

    /**
     * 1. 如果配置 mock全局属性(默认false),则请求的所有服务都走 mock 服务器
     * 2. 请求的服务在mock服务列表中,则请求走mock服务器
     * 3. 请求的服务不在 mock 服务列表中,则先从直连配置获取服务信息，没有则从注册心上获取服务信息,请求转发到注册中心上的服务
     * 4. 请求的服务不在 mock 服务列表中,也没有开启全局 mock 功能,则请求服务走 直连配置和注册中心相结合
     *
     * @param request
     * @param options
     * @return
     * @throws IOException
     */
    @Override
    public Response execute(Request request, Request.Options options) throws IOException {
        String url = request.url();
        URI uri = URI.create(url);
        String clientName = uri.getHost();
        String[] mockServer = mockProperties.getIpAddress().split(":");
        //请求的客户名称转为小写
        clientName = clientName.toUpperCase();
        String newUrl = null;

        // 从全局中获取该服务名称的配置信息
        IClientConfig clientConfig = this.clientFactory.getClientConfig(clientName);
        if (null != clientConfig && mockProperties.getGlobal()) {
            // 配置当前服务的ip地址信息
//            clientConfig.set(CommonClientConfigKey.ListOfServers, mockProperties.getIpAddress());
            // 获取当前服务的负载均衡器，对当前服务的负载均衡器添加服务ip地址信息
            if (this.clientFactory.getLoadBalancer(clientName).getAllServers().isEmpty()) {
                this.clientFactory.getLoadBalancer(clientName).
                        addServers(Arrays.asList(new Server(mockServer[0], Integer.parseInt(mockServer[1]))));
            }

            // 重新构建请求 URL
            newUrl = this.getNewRequestUrl(url, clientName);
            log.info("请求的 {} 服务已开启全局 mock 功能,服务地址：{}", clientName, this.clientFactory.getLoadBalancer(clientName).getAllServers());
        } else {
            //获取 配置 mock 服务的列表
            String services = this.mockProperties.getServices();
            if (StringUtils.isNotBlank(services)) {
                //  配置 mock 服务的列表转为小写
                services = services.toUpperCase();
                // mock 服务列表
                List<String> service = Arrays.asList(services.split(","));
                // 当前服务是否在 mock 服务列表中
                if (service.contains(clientName)) {
                    log.info("请求的 {} 服务在 mock 服务列表中,服务地址：{}", clientName, clientConfig.get(CommonClientConfigKey.ListOfServers));
                    newUrl = this.getNewRequestUrl(url, clientName);
                } else {
                    // 服务直连情况 加 注册中心 处理
                    newUrl = getServiceInfoFromDiscoveryClient(url, clientName, clientConfig);
                }
            } else {
                if (mockProperties.getServicesMap().isEmpty()) {
                    String msg = "没有配置 mock 服务列表，也没有开启全局mock功能,也没有配置服务直连，请检查配置或关闭mock功能";
                    throw new HystrixRuntimeException(HystrixRuntimeException.FailureType.BAD_REQUEST_EXCEPTION, null, msg, null, null);
                }

                // 服务直连情况 加 注册中心 处理
                newUrl = getServiceInfoFromDiscoveryClient(url, clientName, clientConfig);
            }
        }
        return this.getResponse(request, options, newUrl);
    }

    /**
     * 1.如果有服务直接配置，则直接返回url
     * 2.如果不是直连，则从注册中上获取服务信息，并返回url
     *
     * @param url
     * @param clientName
     * @param clientConfig
     * @return
     */
    private String getServiceInfoFromDiscoveryClient(String url, String clientName, IClientConfig clientConfig) {
        String newUrl;

        //服务直连处理
        if (mockProperties.getServicesMap().size() > 0) {
            // 处理一些自定义的服务和ip地址，服务的直连情况
            Set<String> customServiceInfo = mockProperties.getServicesMap().keySet();
            if (customServiceInfo.contains(clientName.toUpperCase())) {
                log.info("请求的 {} 服务在直连列表中,服务地址：{}", clientName, mockProperties.getServicesMap().get(clientName));
                newUrl = url;
                return newUrl;
            }
        }


        if (null == this.discoveryClient) {
            String format = String.format("%s 服务没有配置在mock列表中，并且也没有开启注册中心功能,请检查配置", clientName);
            throw new HystrixRuntimeException(HystrixRuntimeException.FailureType.COMMAND_EXCEPTION, null, format, null, null);
        }

        // 获取 服务名的 服务信息
        List<ServiceInstance> instances = this.discoveryClient.getInstances(clientName);
        String host;
        if (null == instances || instances.isEmpty()) {
            host = String.format("%s 服务没有配置在mock列表中，也没有注册在住册中心上,请检查配置", clientName);
            throw new HystrixRuntimeException(HystrixRuntimeException.FailureType.COMMAND_EXCEPTION, null, host, null, null);
        }

        // 获取 服务在 注册中心的地址信息
        host = instances.get(0).getHost() + ":" + instances.get(0).getPort();
        log.info("请求的 {} 服务在注则中心上,服务地址：{}", clientName, host);
        newUrl = url;

        if (null != clientConfig) {
//            clientConfig.set(CommonClientConfigKey.ListOfServers, host);
            // 获取当前服务的负载均衡器，对当前服务的负载均衡器添加服务ip地址信息
            if (this.clientFactory.getLoadBalancer(clientName).getAllServers().isEmpty()) {
                this.clientFactory.getLoadBalancer(clientName).
                        addServers(Arrays.asList(new Server(instances.get(0).getHost(), instances.get(0).getPort())));
            }

        }
        return newUrl;
    }

    /**
     * 请求响应
     *
     * @param request
     * @param options
     * @param newUrl
     * @return
     * @throws IOException
     */
    private Response getResponse(Request request, Request.Options options, String newUrl) throws IOException {
        //重新构建 request　对象
        Request newRequest = Request.create(request.method(),
                newUrl, request.headers(), request.body(),
                request.charset());

        return super.execute(newRequest, options);
    }

    /**
     * 修改请求 url
     *
     * @param url
     * @param clientName
     * @return
     */
    private String getNewRequestUrl(String url, String clientName) {
        StringBuilder sb = new StringBuilder();
        sb.append(clientName);

        String mockServerUrl = mockProperties.getMockServerUrl();
        if (mockServerUrl.endsWith("/")) {
            sb.append(mockServerUrl);
        } else {
            sb.append(mockServerUrl).append("/");
        }
        sb.append(clientName.toLowerCase());

        String newUrl = url.replaceFirst(clientName, sb.toString());

        log.info("mock 服务重新构建请求 URL 地址：{}", newUrl);
        return newUrl;
    }
}

　　

配置自化配置类

@Slf4j
@ConditionalOnProperty(prefix = MockProperties.MOCK_PREFIX, name = "enabled", havingValue = "true")
@EnableConfigurationProperties(value = {MockProperties.class})
@Configuration
public class MockAutoConfiguration {


    @Bean
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
                              SpringClientFactory clientFactory, @Autowired(required = false) DiscoveryClient discoveryClient, MockProperties mockProperties) {

        return new MockLoadBalancerFeignClient(new Client.Default(null, null),
                cachingFactory, clientFactory, mockProperties, discoveryClient);
    }

    @Bean
    public MockFeignInterceptor mockFeignInterceptor() {
        return new MockFeignInterceptor();
    }
}

　

在 spring.factories 中配置

org.springframework.boot.autoconfigure.EnableAutoConfiguration=
MockAutoConfiguration

　　

自定义相关属性配置和提示，关于mock的属性配置

@ConfigurationProperties(prefix = MockProperties.MOCK_PREFIX, ignoreUnknownFields = true)
public class MockProperties {
    public static final String MOCK_PREFIX = "mock.server";

    /**
     * 开启mock ,true:开启  false：关闭
     */
    @Getter
    @Setter
    private boolean enabled = false;

    /**
     * mock 服务的ip地址或域名 例：10.12.141.146:18081
     */
    @Getter
    @Setter
    private String ipAddress;

    /**
     * 如果每个服务的 mock server 的地址都一样的使用该配置，多个服务以 ,号 隔开 例:order-service,user-service
     */
    @Getter
    @Setter
    private String services;

    /**
     * 如果每个服务的 mock server 地址不一样，使用该配置,key:服务名  value: ip地址 ,例
     */
    @Getter
    @Setter
    private Map<String, String> servicesMap = new ConcurrentHashMap<>();

    /**
     * mock server 服务url
     */
    @Getter
    @Setter
    private String mockServerUrl;


    /**
     * 是否需要所有服务都用 mock
     */


    private boolean global = false;

    public boolean getGlobal() {
        return global;
    }

    public void setGlobal(boolean global) {
        this.global = global;
    }
}

　　

　

Mock server 相关属性

当开启mock 功能时，所有的 feign 请求都会带上请求头： X-Mock-Application: true 

# 开启 mock 功能
mock.server.enabled=true
# mock 服务器ip地址和端口
mock.server.ip-address=123.90.8.1:18820
# mock 服务器的 url
mock.server.mock-server-url=/admin/mock
# mock 服务的列表，这里填写 feign 服务的服务名，多个以 ，号隔开,并大写
mock.server.services=PLATFORM-SERVICE,HELLO-SERVICE-1

如果项目中需要所有服务都要使用 mock 功能，则添加下面的属性

# 开启全局 mock 功能，也就是项目中所有的 feign服务都需要 mock
mock.server.global=true

如果项目中需要服务直连，则添加下面的属性

# user-service 服务的直连ip地址和端口
mock.server.services-map.user-service=192.168.111.10:9010
# cache-service 服务的直连ip地址和端口
mock.server.services-map.cache-service=10.10.90.23:9090

关闭全局 mock 功能
mock.server.global=false