自定义基于Hystrix的Feign全局断路器扩展

在使用Feign的时候，每一个Feign接口都需要定义fallback或者fallbackFactory来处理熔断，遇到庞大的系统时工作量不小，所以需要定义全局的熔断器以便减轻业务开发负担， 我的思路就是使用动态代理（cglib）来代理各个Feign处理熔断。
首先需要了解Feign集成Hystrix以及自动配置过程：

1. FeignAutoConfiguration自动配置类

    @Configuration
    @ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
    protected static class HystrixFeignTargeterConfiguration {

        @Bean
        @ConditionalOnMissingBean
        public Targeter feignTargeter() {
            return new HystrixTargeter();
        }

    }

    @Configuration
    @ConditionalOnMissingClass("feign.hystrix.HystrixFeign")
    protected static class DefaultFeignTargeterConfiguration {

        @Bean
        @ConditionalOnMissingBean
        public Targeter feignTargeter() {
            return new DefaultTargeter();
        }

    }

a. 如果存在'feign.hystrix.HystrixFeign'类，就使用HystrixTargeter，否则使用DefaultTargeter

2. HystrixTargeter类

    @Override
    public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
            FeignContext context, Target.HardCodedTarget<T> target) {
        if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {
            return feign.target(target);
        }
        feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;
        SetterFactory setterFactory = getOptional(factory.getName(), context,
                SetterFactory.class);
        if (setterFactory != null) {
            builder.setterFactory(setterFactory);
        }
        Class<?> fallback = factory.getFallback();
        if (fallback != void.class) {
            return targetWithFallback(factory.getName(), context, target, builder,
                    fallback);
        }
        Class<?> fallbackFactory = factory.getFallbackFactory();
        if (fallbackFactory != void.class) {
            return targetWithFallbackFactory(factory.getName(), context, target, builder,
                    fallbackFactory);
        }

        return feign.target(target);
    }

a. 通过以上代码可以看出，优先使用Feign主动配置的fallback和fallbackFactory。
b. 如果没配置的话，调用HystrixFeign.Builder的target(Target<T> target)方法，即不降级处理。

3. HystrixFeign.Builder类

 public static final class Builder extends Feign.Builder {

    private Contract contract = new Contract.Default();
    private SetterFactory setterFactory = new SetterFactory.Default();

    /**
     * Allows you to override hystrix properties such as thread pools and command keys.
     */
    public Builder setterFactory(SetterFactory setterFactory) {
      this.setterFactory = setterFactory;
      return this;
    }

    /**
     * @see #target(Class, String, Object)
     */
    public <T> T target(Target<T> target, T fallback) {
      return build(fallback != null ? new FallbackFactory.Default<T>(fallback) : null)
          .newInstance(target);
    }

    /**
     * @see #target(Class, String, FallbackFactory)
     */
    public <T> T target(Target<T> target, FallbackFactory<? extends T> fallbackFactory) {
      return build(fallbackFactory).newInstance(target);
    }

    // ...........

    @Override
    public Feign build() {
      return build(null);
    }

    /** Configures components needed for hystrix integration. */
    Feign build(final FallbackFactory<?> nullableFallbackFactory) {
      super.invocationHandlerFactory(new InvocationHandlerFactory() {
        @Override
        public InvocationHandler create(Target target,
                                        Map<Method, MethodHandler> dispatch) {
          return new HystrixInvocationHandler(target, dispatch, setterFactory,
              nullableFallbackFactory);
        }
      });
      super.contract(new HystrixDelegatingContract(contract));
      return super.build();
    }

a. HystrixFeign.Builder继承了Feign.Builder类，并且target(Target<T> target)方
法继承自父类Feign.Builder
b. 父类Feign.Builder中target(Target<T> target)调用的是build().newInstance(target)方法，子类HystrixFeign.Builder重写了build()方法。
c. 最终创建Feign实例的是子类的build(final FallbackFactory<?> nullableFallbackFactory)方法。
d. 通过build(final FallbackFactory<?> nullableFallbackFactory)，最后实例化HystrixInvocationHandler处理熔断。

在了解完具体过程之后，我们只需要将自定义的全局熔断器FallbackFactory传递给build(final FallbackFactory<?> fallbackFactory)就可以了，顺着这个思路想到了如下方案：
1>. 首先想到的是继承HystrixFeign.Builder重写build()，但是HystrixFeign.Builder类使用final关键字修饰，此方案行不通。
2>. 通过参考Spring Cloud Alibaba中的熔断器Sentinel与Feign集成方式（com.alibaba.cloud.sentinel.feign.SentinelFeign），自定义Feign.Builder子类重写target(Target<T> target)方法，默认使用自定义的FallbackFactory来处理熔断。

具体实现代码如下：
1>. 自定义Feign熔断代理Fallback。

@Slf4j
public class XcloudFeignFallback<T> implements org.springframework.cglib.proxy.MethodInterceptor {

    private Class<T> targetType;
    private String targetName;
    private Throwable cause;

    public XcloudFeignFallback(Class<T> targetType, String targetName, Throwable cause) {
        this.targetType = targetType;
        this.targetName = targetName;
        this.cause = cause;
    }

    @Nullable
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        FeignException exception = (FeignException) cause;

        log.error("XcloudFeignFallback:[{}.{}] serviceId:[{}] message:[{}]",  targetType.getName(), method.getName(),
                                                                              targetName, exception.contentUTF8());
        //  告警代码实现 ......

        return null;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        XcloudFeignFallback<?> that = (XcloudFeignFallback<?>) o;
        return targetType.equals(that.targetType);
    }

    @Override
    public int hashCode() {
        return Objects.hash(targetType);
    }
}

2>. 自定义全局熔断FallbackFactory实现类。

@AllArgsConstructor
public class GlobalFallbackFactory<T> implements FallbackFactory<T> {

    /* 被代理目标对象 */
    private Target<T> target;

    @Override
    public T create(Throwable cause) {
        // 获取@FeignClient注解的接口类型
        Class<T> targetType = target.type();
        String targetName = target.name();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetType);
        enhancer.setUseCache(true);
        enhancer.setCallback(new XcloudFeignFallback<>(targetType, targetName, cause));
        return (T) enhancer.create();
    }
}

3>. 自定义Feign.Builder，重写target(Target<T> target)，处理全局熔断。

public final class XcloudFeign {


    private XcloudFeign() {}


    public static Builder builder() {
        return new Builder();
    }


    public static final class Builder extends Feign.Builder implements ApplicationContextAware {

        private Contract contract = new Contract.Default();

        private SetterFactory setterFactory = new SetterFactory.Default();

        private ApplicationContext applicationContext;

        private FeignContext feignContext;

        @Override
        public Feign.Builder invocationHandlerFactory(InvocationHandlerFactory invocationHandlerFactory) {
            throw new UnsupportedOperationException();
        }

        @Override
        public Builder contract(Contract contract) {
            this.contract = contract;
            return this;
        }

        public Builder setterFactory(SetterFactory setterFactory) {
            this.setterFactory = setterFactory;
            return this;
        }

        @Override
        public <T> T target(Target<T> target) {
            // 自定义熔断器
            return (T) this.target(target, new GlobalFallbackFactory(target));
        }

        /**
         * @see #target(Class, String, Object)
         */
        public <T> T target(Target<T> target, T fallback) {
            return build(fallback != null ? new FallbackFactory.Default<T>(fallback) : null).newInstance(target);
        }

        /**
         * @see #target(Class, String, FallbackFactory)
         */
        public <T> T target(Target<T> target, FallbackFactory<? extends T> fallbackFactory) {
            return build(fallbackFactory).newInstance(target);
        }

        /**
         * Like {@link Feign#newInstance(Target)}
         * fallback support.
         * @see #target(Target, Object)
         */
        public <T> T target(Class<T> apiType, String url, T fallback) {
            return target(new Target.HardCodedTarget<T>(apiType, url), fallback);
        }

        /**
         * Same as {@link #target(Class, String, T)}, except you can inspect a source exception before
         * creating a fallback object.
         */
        public <T> T target(Class<T> apiType,
                            String url,
                            FallbackFactory<? extends T> fallbackFactory) {
            return target(new Target.HardCodedTarget<T>(apiType, url), fallbackFactory);
        }

        @Override
        public Feign build() {
            return this.build(null);
        }

        /** Configures components needed for hystrix integration. */
        private Feign build(final FallbackFactory<?> defaultFallbackFactory) {
            super.invocationHandlerFactory(new InvocationHandlerFactory() {
                @Override
                public InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch) {
                    // using reflect get fallback and fallbackFactory properties from
                    // FeignClientFactoryBean because FeignClientFactoryBean is a package
                    // level class, we can not use it in our package
                    Object feignClientFactoryBean = Builder.this.applicationContext.getBean("&" + target.type().getName());

                    Class fallback = (Class) getFieldValue(feignClientFactoryBean, "fallback");
                    Class fallbackFactory = (Class) getFieldValue(feignClientFactoryBean, "fallbackFactory");
                    String beanName = (String) getFieldValue(feignClientFactoryBean, "contextId");
                    if (! StringUtils.hasText(beanName)) {
                        beanName = (String) getFieldValue(feignClientFactoryBean, "name");
                    }

                    // check fallback
                    if (void.class != fallback) {
                        Object fallbackInstance = getFromContext(beanName, "fallback", fallback, target.type());
                        return new HystrixInvocationHandler(target, dispatch, setterFactory, new FallbackFactory.Default(fallbackInstance));
                    }

                    // check fallbackFactory
                    if (void.class != fallbackFactory) {
                        FallbackFactory fallbackFactoryInstance = (FallbackFactory) getFromContext(beanName, "fallbackFactory", fallbackFactory, FallbackFactory.class);
                        return new HystrixInvocationHandler(target, dispatch, setterFactory, fallbackFactoryInstance);
                    }

                    // default fallbackFactory
                    return new HystrixInvocationHandler(target, dispatch, setterFactory, defaultFallbackFactory);
                }

                /* Get fallback or fallbackFactory from Context */
                private Object getFromContext(String name, String type, Class fallbackType, Class targetType) {
                    Object fallbackInstance = feignContext.getInstance(name, fallbackType);
                    if (fallbackInstance == null) {
                        throw new IllegalStateException(String.format("No %s instance of type %s found for feign client %s", type, fallbackType, name));
                    }

                    if (! targetType.isAssignableFrom(fallbackType)) {
                        throw new IllegalStateException(String.format(
                                "Incompatible %s instance. Fallback/fallbackFactory of type %s is not assignable to %s for feign client %s", type, fallbackType, targetType, name));
                    }
                    return fallbackInstance;
                }
            });
            super.contract(new HystrixDelegatingContract(contract));
            return super.build();
        }

        private Object getFieldValue(Object instance, String fieldName) {
            Field field = ReflectionUtils.findField(instance.getClass(), fieldName);
            field.setAccessible(true);
            try {
                return field.get(instance);
            }
            catch (IllegalAccessException e) {
                // ignore
            }
            return null;
        }

        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext = applicationContext;
            feignContext = this.applicationContext.getBean(FeignContext.class);
        }
    }
}

4>. 自定义Feign配置类，初始化自定义的Feign.Builder。

@Configuration
public class DefaultFeignConfiguration {

    @Bean
    @Primary
    @Scope("prototype")
    @ConditionalOnProperty(name = "feign.hystrix.enabled", havingValue = "true")
    public Feign.Builder xcloudFeignHystrixBuilder() {
        return XcloudFeign.builder();
    }
}