Two call processors of feign

1. Feign The two call processors
   1. FeignInvocationHandler
   2. HystrixInvocationHandler
   3. How to use HystrixFeign
   4. summary

Feign The two call processors

feign The calling processor has a default FeignInvocationHandler

and HystrixInvocationHandler, In this article, we will explain these two classes in detail

FeignInvocationHandler

Feign Execution flow of remote call ： call FeignInvocationHandler Of invoke Method

@Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {      if ("equals".equals(method.getName())) {        try {          Object              otherHandler =              args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;          return equals(otherHandler);        } catch (IllegalArgumentException e) {          return false;        }      } else if ("hashCode".equals(method.getName())) {        return hashCode();      } else if ("toString".equals(method.getName())) {        return toString();      }      return dispatch.get(method).invoke(args);    }

Called in this method SynchronousMethodHandler Method processor invoke Method ：dispatch.get(method).invoke(args);

SynchronousMethodHandler Of invoke In the method, we use RestTemplate Complete the remote call and get the result of the call

FeignInvocationHandler There is no abnormal fuse detection and recovery mechanism , either Http Connection pool .

HystrixInvocationHandler

HystrixInvocationHandler Of invoke Method creation HystrixCommand example ,HystrixCommand Of getFallback() Call in method @FeignClient In the annotations fallback Class specified on property to fail back , Execute the processing of business fallback .

      @Override      protected Object getFallback() {        if (fallbackFactory == null) {          return super.getFallback();        }        try {          Object fallback = fallbackFactory.create(getExecutionException());          Object result = fallbackMethodMap.get(method).invoke(fallback, args);          if (isReturnsHystrixCommand(method)) {            return ((HystrixCommand) result).execute();          } else if (isReturnsObservable(method)) {            // Create a cold Observable            return ((Observable) result).toBlocking().first();          } else if (isReturnsSingle(method)) {            // Create a cold Observable as a Single            return ((Single) result).toObservable().toBlocking().first();          } else if (isReturnsCompletable(method)) {            ((Completable) result).await();            return null;          } else {            return result;          }        } catch (IllegalAccessException e) {          // shouldn't happen as method is public due to being an interface          throw new AssertionError(e);        } catch (InvocationTargetException e) {          // Exceptions on fallback are tossed by Hystrix          throw new AssertionError(e.getCause());        }      }

Feign Of JDK The dynamic proxy instance is through Feign.Builder Of target（） Method to complete ,target The first step of the method is through its own build() Method construction RefectiveFeign example , And then call RefectiveFeign Of newInstance() Method to create a real instance , about RefectiveFeign The role of , We explained in detail in our last article , I won't go into that here .

How to use HystrixFeign

stay FeignClientsConfiguration We can see in class HystrixFeign replace feign.Feign Conditions

  @Configuration  @ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })  protected static class HystrixFeignConfiguration {    @Bean    @Scope("prototype")    @ConditionalOnMissingBean    @ConditionalOnProperty(name = "feign.hystrix.enabled")    public Feign.Builder feignHystrixBuilder() {      return HystrixFeign.builder();    }  }

There are in the classpath HystrixCommand Classes and HystrixFeign class , And the configuration file has feign.hystrix.enabled, When these two conditions are met, you can use HystrixFeign Replace the original Feign, Yes , It's so easy to use

summary

This article mainly introduces Feign The two call processors ,FeignInvocationHandler and HystrixInvocationHandler,FeignInvocationHandler There is no exception recovery mechanism for the processor ,HystrixInvocationHandler Call handling supports fusing and exception handling ,getFallback() Handle the business processing that failed the call , In addition, you can configure feign.hystrix.enabled Give Way HystrixFeign To replace feign.Feign