通过BeanFactotyPostProcessor动态修改@FeignClient的path

最近项目有个需求，要在启动后，动态修改@FeignClient的请求路径，网上找到的基本都是在@FeignClient里使用${…}，通过配置文件来定义Feign的接口路径，这并不能满足我们的需求

由于某些特殊原因，我们的每个接口都有一个interfacePath，定义在接口上的自定义注解中
也就是说@FeignClient定义的接口继承自其他模块，而其他模块的接口上有个自定义注解，描述了该接口的interfacePath，如下：

@FeignClient(value = "x-module")
public interface XXXService extends XApi{
}

@XXXMapping("/member")
public interface XApi {

所以我们需要在每个@FeignClient中将这个@XXXMapping的值添加到path属性，作为跨服务调用的前缀，如果要手动处理每个@FeignClient前缀，未免太不友好，我们希望这个能由程序自动处理

首先看下@FeignClient扫描的过程，看看有没有合适的时机来处理这个问题

使用Feign的项目，一般会在启动类添加注解@EnableFeignClients，先点进这个注解看下

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({FeignClientsRegistrar.class})
public @interface EnableFeignClients {String[] value() default {};String[] basePackages() default {};Class<?>[] basePackageClasses() default {};Class<?>[] defaultConfiguration() default {};Class<?>[] clients() default {};
}

它通过@Import注解导入了一个类FeignClientsRegistrar

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

这个类实现了ImportBeanDefinitionRegistrar接口，这个接口用于在Spring容器初始化过程中，向容器注册一些BeanDefinition，这属于Spring源码的范畴这里就不再赘述，直接看它的registerBeanDefinitions方法实现

    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {this.registerDefaultConfiguration(metadata, registry);this.registerFeignClients(metadata, registry);}

只有两行代码，看名字第二行是注册FeignClient，那么我们的@FeignClient基本可以确定是这行代码在处理了，点进去

这个方法比较长，这里就只贴些关键代码

	LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet();Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());............ClassPathScanningCandidateComponentProvider scanner = this.getScanner();scanner.setResourceLoader(this.resourceLoader);scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));Set<String> basePackages = this.getBasePackages(metadata);Iterator var8 = basePackages.iterator();while(var8.hasNext()) {String basePackage = (String)var8.next();candidateComponents.addAll(scanner.findCandidateComponents(basePackage));}Iterator var13 = candidateComponents.iterator();while(var13.hasNext()) {BeanDefinition candidateComponent = (BeanDefinition)var13.next();if (candidateComponent instanceof AnnotatedBeanDefinition) {AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition)candidateComponent;AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();Assert.isTrue(annotationMetadata.isInterface(), "@FeignClient can only be specified on an interface");Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(FeignClient.class.getCanonicalName());String name = this.getClientName(attributes);this.registerClientConfiguration(registry, name, attributes.get("configuration"));this.registerFeignClient(registry, annotationMetadata, attributes);}}............

先定义了一个扫描器，通过@FeignClient过滤出一组BeanDefinition，也就是上面的candidateComponents，然后遍历，其中有一行代码

Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(FeignClient.class.getCanonicalName());

这里就获取了@FeignClient里定义的各种属性，比如value 、path 、contextId等等
然后调用registerFeignClient方法完成注册，进入这个方法

    private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {String className = annotationMetadata.getClassName();Class clazz = ClassUtils.resolveClassName(className, (ClassLoader)null);ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory ? (ConfigurableBeanFactory)registry : null;String contextId = this.getContextId(beanFactory, attributes);String name = this.getName(attributes);FeignClientFactoryBean factoryBean = new FeignClientFactoryBean();factoryBean.setBeanFactory(beanFactory);factoryBean.setName(name);factoryBean.setContextId(contextId);factoryBean.setType(clazz);factoryBean.setRefreshableClient(this.isClientRefreshEnabled());BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(clazz, () -> {factoryBean.setUrl(this.getUrl(beanFactory, attributes));factoryBean.setPath(this.getPath(beanFactory, attributes));factoryBean.setDecode404(Boolean.parseBoolean(String.valueOf(attributes.get("decode404"))));Object fallback = attributes.get("fallback");if (fallback != null) {factoryBean.setFallback(fallback instanceof Class ? (Class)fallback : ClassUtils.resolveClassName(fallback.toString(), (ClassLoader)null));}Object fallbackFactory = attributes.get("fallbackFactory");if (fallbackFactory != null) {factoryBean.setFallbackFactory(fallbackFactory instanceof Class ? (Class)fallbackFactory : ClassUtils.resolveClassName(fallbackFactory.toString(), (ClassLoader)null));}return factoryBean.getObject();});definition.setAutowireMode(2);definition.setLazyInit(true);this.validate(attributes);AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();beanDefinition.setAttribute("factoryBeanObjectType", className);beanDefinition.setAttribute("feignClientsRegistrarFactoryBean", factoryBean);boolean primary = (Boolean)attributes.get("primary");beanDefinition.setPrimary(primary);String[] qualifiers = this.getQualifiers(attributes);if (ObjectUtils.isEmpty(qualifiers)) {qualifiers = new String[]{contextId + "FeignClient"};}BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, qualifiers);BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);this.registerOptionsBeanDefinition(registry, contextId);}

这个方法虽然长但很清晰，先定义了一个FeignClientFactoryBean，然后生成一个BeanDefinitionBuilder，通过lambda传入了一个InstanceSupplier，其持有了FactoryBean，在InstanceSupplier中，通过设置FactoryBean的url、path属性，确定了@FeignClient请求的路径

我们通过debug观察一下最终生成的BeanDefinition长什么样子，进入registerBeanDefinition方法，先获取了beanName，这个名字就是我们自己接口的全路径名
第二行代码真正地往容器注册了BeanDefinition，在这行打个断点，并设置断点的条件，方便定位到我们的@FeignClient类

可以看到生成的BeanDefinition有个instanceSupplier属性

其内部的AnnotationAttributes就是从@FeignClient注解中解析到的配置，包括value、path等，是 一个Map结构

看到这里，便已经有了大致思路了，这里的InstanceSupplier，持有了从@FeignClinent中解析到的各种属性，并在将来实例化的时候，将这些属性处理为FeignClient的请求路径

那么我们只要在这步之后，实例化之前，将InstanceSupplier持有的属性修改掉，就可以实现动态修改@FeignClient的请求path了

ImportBeanDefinitionRegistrar的处理发生在BeanFactoryPostProcessor的处理流程中，那么我们可以自定义一个BeanFactoryPostProcessor，来获取Feign处理后的BeanDefinition，取其InstanceSupplier，反射修改其属性

自定义一个BeanFactoryPostProcessor

public class FeignClientProcessor implements BeanFactoryPostProcessor, ResourceLoaderAware, EnvironmentAware {private String feignClientPackage;private ResourceLoader resourceLoader;private Environment environment;............

实现ResourceLoaderAware和EnvironmentAware接口 是为了扫描得到加了@FeignClient注解的类，因为Feign注册的BeanDefinition的名字就是我们接口的全路径名，所以可以扫描后到容器里根据类名取，上面看到有Feign扫描的过程，就直接copy过来用了

其中在EnvironmentAware的回调中，设置了一个Feign的扫描路径，因为此时还在Spring容器刷新的早期阶段，通过@Value注解是取不到配置的

	@Overridepublic void setEnvironment(Environment environment) {this.environment = environment;this.feignClientPackage = environment.getProperty("feign.client.package");}

扫描的代码基本上就是Feign的源码，略微修改，扫描的路径是自定义的，而不是从根路径扫，因为我们自己的项目，Feign接口是在指定位置的，然后扫描到的BeanDefinition，转化为类名，这样就得到了所有@FeignClient标注的类名列表

	private List<String> scanFeignClient() {ClassPathScanningCandidateComponentProvider scanner = this.getScanner();scanner.setResourceLoader(this.resourceLoader);scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(feignClientPackage);return candidateComponents.stream().map(BeanDefinition::getBeanClassName).collect(Collectors.toList());}private ClassPathScanningCandidateComponentProvider getScanner() {return new ClassPathScanningCandidateComponentProvider(false, this.environment) {protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {boolean isCandidate = false;if (beanDefinition.getMetadata().isIndependent() && !beanDefinition.getMetadata().isAnnotation()) {isCandidate = true;}return isCandidate;}};}

然后针对每个类进行处理
先通过类实现的interface获取自定义注解的接口路径，然后通过类名从容器中获取到Feign处理过的BeanDefinition，取其InstanceSupplier，反射找到存储@FeignClient属性的map，拼接请求前缀作为path添加到map中

	List<String> feignClientList = scanFeignClient();feignClientList.forEach(item -> {GenericBeanDefinition beanDefinition = (GenericBeanDefinition)configurableListableBeanFactory.getBeanDefinition(item);Class<?> clazz = beanDefinition.getBeanClass();Class<?> apiInterface = Arrays.stream(clazz.getInterfaces()).filter(i -> i.getName().startsWith("com.xxx") && i.getName().endsWith("Api")).findAny().orElseThrow(() -> new RuntimeException("基础路径未定义"));XXXMapping annotation = apiInterface.getAnnotation(XXXMapping.class);String interfacePath = annotation.value();Supplier<?> instanceSupplier = beanDefinition.getInstanceSupplier();try {Field[] declaredFields = instanceSupplier.getClass().getDeclaredFields();for (Field field : declaredFields) {if (field.getType().isAssignableFrom(Map.class)) {field.setAccessible(true);Map<String, String> map = (Map)field.get(instanceSupplier);String basePath = map.get("value");map.put("path", basePath + interfacePath);}}} catch (Exception e) {log.error("初始化FeignClient失败：", e);}});

完整代码

@Component
@Log4j2
public class FeignClientProcessor implements BeanFactoryPostProcessor, ResourceLoaderAware, EnvironmentAware {private String feignClientPackage;private ResourceLoader resourceLoader;private Environment environment;@Override@SuppressWarnings("unchecked")public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {List<String> feignClientList = scanFeignClient();feignClientList.forEach(item -> {GenericBeanDefinition beanDefinition = (GenericBeanDefinition)configurableListableBeanFactory.getBeanDefinition(item);Class<?> clazz = beanDefinition.getBeanClass();Class<?> apiInterface = Arrays.stream(clazz.getInterfaces()).filter(i -> i.getName().startsWith("com.aic") && i.getName().endsWith("Api")).findAny().orElseThrow(() -> new RuntimeException("基础路径未定义"));XXXMapping annotation = apiInterface.getAnnotation(XXXMapping.class);String interfacePath = annotation.value();Supplier<?> instanceSupplier = beanDefinition.getInstanceSupplier();try {Field[] declaredFields = instanceSupplier.getClass().getDeclaredFields();for (Field field : declaredFields) {Class<?> type = field.getType();if (type.isAssignableFrom(Map.class)) {field.setAccessible(true);Map<String, String> map = (Map)field.get(instanceSupplier);String basePath = map.get("value");map.put("path", basePath + interfacePath);}}} catch (Exception e) {log.error("初始化FeignClient失败：", e);}});}private List<String> scanFeignClient() {ClassPathScanningCandidateComponentProvider scanner = this.getScanner();scanner.setResourceLoader(this.resourceLoader);scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(feignClientPackage);return candidateComponents.stream().map(BeanDefinition::getBeanClassName).collect(Collectors.toList());}private ClassPathScanningCandidateComponentProvider getScanner() {return new ClassPathScanningCandidateComponentProvider(false, this.environment) {protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {boolean isCandidate = false;if (beanDefinition.getMetadata().isIndependent() && !beanDefinition.getMetadata().isAnnotation()) {isCandidate = true;}return isCandidate;}};}@Overridepublic void setResourceLoader(ResourceLoader resourceLoader) {this.resourceLoader = resourceLoader;}@Overridepublic void setEnvironment(Environment environment) {this.environment = environment;this.feignClientPackage = environment.getProperty("feign.client.package");}
}