[享学Feign] 十二、Feign通过feign-hystrix模块使其拥有熔断、降级能力

public interface SetterFactory {

	// 根据目标target代理以及方法本身，生成一个用于熔断对象的HystrixCommand.Setter配置
	HystrixCommand.Setter create(Target<?> target, Method method);
}

final class Default implements SetterFactory {

    @Override
    public HystrixCommand.Setter create(Target<?> target, Method method) {
		// target的name属性之前一直没用到过，这里是唯一使用的地方。作为groupKey，代表着配置的分组
		// 因为target是类级别的，所以这里认为一个类里面的所有方法属于同一个组
      String groupKey = target.name();
		// 使用configKey作为唯一键，和method绑定
      String commandKey = Feign.configKey(target.type(), method);

	 // 创建一个setter，放置进去了groupKey和commandKey，从而可以快速的加载到配置
      return HystrixCommand.Setter
          .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey))
          .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey));
    }

}

private SetterFactory setterFactory = new SetterFactory.Default();

// 它是个泛型接口
public interface FallbackFactory<T> {

	// 根据异常的原因，返回一个实例（注意是一个实例哦）
	// 比如遇上NOP就返回null之类的降级方案
	T create(Throwable cause);
}

final class Default<T> implements FallbackFactory<T> {
	
	// 这里说得很清楚，使用jul完全仅是为了不增加外部依赖，它也知道juc不好。。。
    // jul to not add a dependency
    final Logger logger;
    // 实例对象，并不是接口哦
    // 比如接口A#a方法需要回滚，就会找到实例T的同名的a方法
    // 所以fallabck的方法签名，需要和接口的一毛一样（类名不一样）
    final T constant;
	
	... // 省略构造器
    @Override
    public T create(Throwable cause) {
      // 记录日志，fallabck的原因："fallback due to: " + cause.getMessage()
	  // 返回返回这个常量
      return constant;
    }
    ...
}

public final class HystrixDelegatingContract implements Contract {

  // 目标Contract 
  private final Contract delegate;
  // 唯一构造器
  public HystrixDelegatingContract(Contract delegate) {
    this.delegate = delegate;
  }

  // 唯一接口方法
  @Override
  public List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType) {
  	// 重要：先让代理完全解析完成
  	List<MethodMetadata> metadatas = this.delegate.parseAndValidatateMetadata(targetType);

	// 在加入hystrix自己的逻辑
	for (MethodMetadata metadata : metadatas) {
		Type type = metadata.returnType();
		// ParameterizedType -> 参数化类型（泛型返回值）
		if(type instanceof ParameterizedType && ((ParameterizedType) type).getRawType().equals(HystrixCommand.class)){
			Type actualType = resolveLastTypeParameter(type, HystrixCommand.class);
			metadata.returnType(actualType);
		} else if( ... ) ...

		// 加工处理后的returnType是剥出来的，所以能被正确的解码了
		return metadatas;
	}
  }
}

final class HystrixInvocationHandler implements InvocationHandler {

 // 这两参数同FeignInvocationHandler 
  private final Target<?> target;
  private final Map<Method, MethodHandler> dispatch;

	// 本类独有的三大参数
  // 降级策略工厂。可以为null
  private final FallbackFactory<?> fallbackFactory; 
  // 每个方法对应的降级时候执行的方法
  private final Map<Method, Method> fallbackMethodMap;
  // 每个方法对应的com.netflix.hystrix.HystrixCommand.Setter配置
  // 比如超时时间、恢复时间等等参数的配置
  private final Map<Method, Setter> setterMethodMap;

  //唯一构造器，对以上属性进行赋值
  //重点是对fallbackMethodMap和setterMethodMap的赋值
  // 分别交给toFallbackMethod()和toSetters()方法完成

  // 仅仅对Method执行了一句：method.setAccessible(true);而已
  // key和value完全相同的Method对象：可知：回退方法的方法签名请保持和原方法一模一样才行
  static Map<Method, Method> toFallbackMethod(Map<Method, MethodHandler> dispatch) {
    Map<Method, Method> result = new LinkedHashMap<Method, Method>();
    for (Method method : dispatch.keySet()) {
      method.setAccessible(true);
      result.put(method, method);
    }
    return result;
  }

  // 为每个Method方法，使用SetterFactory创建了一个Setter配置实例
  // 此key将和Method方法强相关
  static Map<Method, Setter> toSetters(SetterFactory setterFactory,
                                       Target<?> target,
                                       Set<Method> methods) {
    Map<Method, Setter> result = new LinkedHashMap<Method, Setter>();
    for (Method method : methods) {
      method.setAccessible(true);
      result.put(method, setterFactory.create(target, method));
    }
    return result;
  }
  ...
}

HystrixInvocationHandler：

  @Override
  public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
  	...// 同FeignInvocationHandler一样，免疫掉equals/hashCode/toString方法

	// FeignInvocationHandler只有一句代码了：return dispatch.get(method).invoke(args);
	// 而这里会用Hystrix命令包装一下：HystrixCommand
	// 让所有的执行都在这里面执行：从而具有降级的能力
	HystrixCommand<Object> hystrixCommand = new HystrixCommand<>(setterMethodMap.get(method)) {
		
          @Override
          protected Object run() throws Exception {
            try {
              return HystrixInvocationHandler.this.dispatch.get(method).invoke(args);
           
            // 若执行目标方法发生异常：比如超时、server端报错等，直接抛出此异常
            // 这样就可以进行fallback程序了
            } catch (Throwable e) {
              throw e;
            } 
          }


		// fallback回退、降级程序
          @Override
          protected Object getFallback() {
          	// 若你没指定fallback，父类就是直接抛出大名鼎鼎的异常
          	// new UnsupportedOperationException("No fallback available.");
          	// 这个异常应该是你经常在控制台看见的：No fallback available.
            if (fallbackFactory == null) {
              return super.getFallback();
            }

			// 若指定了fallbackFactory，那就执行对应的fallabck方法喽
			//根据异常类型，拿到一个fallabck的实例对象，也就是对应接口的fallback实例
			Object fallback = fallbackFactory.create(getExecutionException());

			// 调用fallback 实例的同名、同方法签名的方法，这样就得到一个降级的结果result了
			Object result = fallbackMethodMap.get(method).invoke(fallback, args);

			// 对result结果类型进行兼容
			// 如果是HystrixCommand/Observable类型等等分别怎么执行等等
              if (isReturnsHystrixCommand(method)) {
                return ((HystrixCommand) result).execute();
              } else if (isReturnsObservable(method)) {
              	return ((Observable) result).toBlocking().first();
              } ...
              
              } else if (isReturnsCompletableFuture(method)) {
                return ((Future) result).get();
              } else { // 如果不是这些类型直接返回就好
                return result;
              }
		  }
			
	}
	

	//得到了hystrixCommand 对象，现在就是执行它喽
	// 同时也支持到了返回值类型为HystrixCommand/Observable...等类型
	
	// 若是接口默认方法，直接execute()
	if (Util.isDefault(method)) { 
		return hystrixCommand.execute();
	} else if (isReturnsHystrixCommand(method)) {
		return hystrixCommand;
	} ...
	
	// 绝大部分都是执行此处：不需要类型转化，直接执行
	return hystrixCommand.execute();
  }

public final class HystrixFeign {

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

	// 该构建器继承自feign.Feign.Builder，做出了扩展
  public static final class Builder extends Feign.Builder {

	// 这里显示的写出contract ，是因为下面要代理词默认提取器
    private Contract contract = new Contract.Default();
    private SetterFactory setterFactory = new SetterFactory.Default();
	...

	// 请注意：fallback的类型也是泛型T哦
	// 也就是说：fallback实例也是必须实现目标接口的
	// 若fallback == null，那就是木有回退工厂，那就无法执行回滚，出现你熟悉的"No fallback available."
    public <T> T target(Target<T> target, T fallback) {
      return build(fallback != null ? new FallbackFactory.Default<T>(fallback) : null).newInstance(target);
    }
    // 若你有自己的工厂实现，传入自己的工厂也行（也就是实例通过自己构造，而不是传进来）
    public <T> T target(Target<T> target, FallbackFactory<? extends T> fallbackFactory) {
      return build(fallbackFactory).newInstance(target);
    }
	... // 省略其余多个参数的target方法

	// 请注意：这里复写了父类的build方法，最终采用一个内部方法build来实现了
	// build方法是本类的精髓。因为所有的target方法都调用了此build方法~~~~
    @Override
    public Feign build() {
      return build(null);
    }


    //所有的target方法都调用了此build方法~~~~
	Feign build(final FallbackFactory<?> nullableFallbackFactory) {
		
		// 重要：使用HystrixInvocationHandler代替默认的FeignInvocationHandler
		// 从而让每个方法都具有熔断器的能力
		super.invocationHandlerFactory((target,dispatch) -> new HystrixInvocationHandler(target, dispatch, setterFactory,nullableFallbackFactory));

		// 代理目标提取器，以支持更多类型
		super.contract(new HystrixDelegatingContract(contract));
		// 参数都设置好后，执行父类的构建逻辑~~~
		return super.build();
	}
	...
  }

}

public class DemoClientFallback implements DemoClient {
    @Override
    public String getDemo1(String name) {
        return "this are fallback info...";
    }
}

public class DemoClientFallbackFactory implements FallbackFactory<DemoClient> {

    @Override
    public DemoClient create(Throwable cause) {
        return new DemoClient() {
            @Override
            public String getDemo1(String name) {
                if (cause instanceof HystrixTimeoutException) {
                    return name + "：你执行超时了HystrixTimeoutException";
                } else {
                    return "this are fallback info...";
                }
            }
        };
    }
}

@Test
public void fun1() {
    // 必须使用HystrixFeign哦
    DemoClient client = HystrixFeign.builder()
            // 指定fallback实例为DemoClientFallback
            //.target(DemoClient.class, "http://localhost:8080", new DemoClientFallback());
            .target(DemoClient.class, "http://localhost:8080", new DemoClientFallbackFactory());

    String result = client.getDemo1("YourBatman");
    System.out.println(result);
}

YourBatman：你执行超时了HystrixTimeoutException