Spring Cloud Feign 之Hystrix熔断保护

timg.jpg

Spring Cloud Feign 之Hystrix

迁移到CSDN
环境信息: java 1.8、Spring boot 1.5.10.RELEASE、spring cloud-Edgware.SR3、maven 3.3+

本章节只针对Hystrix在Feign中的简单实用，和一些简单的源码分析，更详细的请参考GitHub官网

Fallback章节已经简单的介绍了Hystrix的熔断保护使用，这章将介绍HystrixCommand、Observable、Single、Completable这四种异步HTTP请求方式。

那么Hystrix为什么可以支持者四种异步HTTP请求方式，其实很简单通过一段源码就可以看出

HystrixDelegatingContract.parseAndValidatateMetadata方法的四个if else判断分别对应四个类

package feign.hystrix;

import static feign.Util.resolveLastTypeParameter;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

import com.netflix.hystrix.HystrixCommand;

import feign.Contract;
import feign.MethodMetadata;
import rx.Completable;
import rx.Observable;
import rx.Single;

/**
 * This special cases methods that return {@link HystrixCommand}, {@link Observable}, or {@link Single} so that they
 * are decoded properly.
 * 
 * 
For example, {@literal HystrixCommand} and {@literal Observable} will decode {@code Foo}.
 */
// Visible for use in custom Hystrix invocation handlers
public final class HystrixDelegatingContract implements Contract {

 
  private final Contract delegate;

  public HystrixDelegatingContract(Contract delegate) {
    this.delegate = delegate;
  }

  @Override
  public List parseAndValidatateMetadata(Class targetType) {
    List metadatas = this.delegate.parseAndValidatateMetadata(targetType);

    for (MethodMetadata metadata : metadatas) {
      Type type = metadata.returnType();

      if (type instanceof ParameterizedType && ((ParameterizedType) type).getRawType().equals(HystrixCommand.class)) {
        Type actualType = resolveLastTypeParameter(type, HystrixCommand.class);
        metadata.returnType(actualType);
      } else if (type instanceof ParameterizedType && ((ParameterizedType) type).getRawType().equals(Observable.class)) {
        Type actualType = resolveLastTypeParameter(type, Observable.class);
        metadata.returnType(actualType);
      } else if (type instanceof ParameterizedType && ((ParameterizedType) type).getRawType().equals(Single.class)) {
        Type actualType = resolveLastTypeParameter(type, Single.class);
        metadata.returnType(actualType);
      } else if (type instanceof ParameterizedType && ((ParameterizedType) type).getRawType().equals(Completable.class)) {
        metadata.returnType(void.class);
      }
    }

    return metadatas;
  }
}

这里使用了委派模式，具体工作给委派对象，实际就是SpringMvcContract，它负责处理spring MVC 注解方式声明的Feign接口，所以需要SpringMvcContract。

HystrixCommand

Hystrix命令模式，在这里不做深度剖析有兴趣的同学可以到GitHub官网查看，只针对对在Feign中是如何使用的。

其实在Feign中使用很简单，HystrixCommand是一个泛型的抽象类，只需在返回类型指定泛型的类型即可

如：HystrixCommand>指定List泛型即可

UserFeign.findAll:

@GetMapping
HystrixCommand> findAll();

是不是很简单,那么HystrixCommand如何使用呢，下面讲一下两个常用方法

HystrixCommand.execute 直接获取请求结果

这种方式跟java.util.concurrent.Future.get()方法使用方式是一样的。

启动FeignApplication服务提供方

运行单元测试UserFeignTest.save保存两条数据。

UserFeignTest.findAll ，直接将结果打印

    @Test
    public void findAll() {
        HystrixCommand> userList = userFeign.findAll();
        //直接获取结果，这块可以处理一些业务逻辑，最后需要userList数据调用execute方法
        System.out.println(userList.execute());
    }

[User{id='1', name='张三1'}, User{id='2', name='张三2'}]

HystrixCommand.observe或toObservable 观察者模式(订阅发布)

observe() 是 Hot observables ，toObservable()是 Cold observables

Hot observables

只有当有订阅者订阅的时候， Cold Observable 才开始执行发射数据流的代码 。

Cold observables

Hot observable 不管有没有订阅者订阅，他们创建后就开始发射数据流。

更多请参考Reactive Execution 或 RxJava 驯服数据流之 hot & cold Observable

Observable> listObservable = userList.observe();//可订阅多次
Observable> listObservable = userList.toObservable();

接下来讲下 Observable使用

Observable观察者模式(订阅发布)

Feign接口的方法返回类型也可以是Observable泛型类型可以是任意类型，我们这里以Observable为例

由于Hystrix是异步，会出现主线程结束后Hystrix线程同时杀死，导致结果无法打印，在订阅之后添加TimeUnit.SECONDS.sleep(2)使主线程睡眠2秒钟。

UserFeign.getUserByID,其他内容省略

@GetMapping("/{id}")
Observable getUserByID(@PathVariable("id") String id);

如果对结果集处理，只需订阅Observable

Observable user = userFeign.getUserByID("1");
user.subscribe(new Observer() {
           /**
             * 数据发射完成时执行与{@link #onError(Throwable)} 它俩只会执行其中一个方法
             */
            @Override
            public void onCompleted() {
                System.out.println("user处理完成");
            }

            /**
             * 发生错误时执行与{@link #onCompleted()} 它俩只会执行其中一个方法
             */
            @Override
            public void onError(Throwable e) {
                System.out.println("user出现异常" + e);
            }

            /**
             * 发射数据流 user
             */
            @Override
            public void onNext(User user) {
                System.out.println("返回数据：" + user);
            }
});

运行单元测试UserFeignTest.getUserByID,输出结果

返回数据：User{id='1', name='张三'}
user处理完成

Single

Observable的订阅者Observer.onNext方法可能执行多次，最后执行Observer.onCompleted,其实在平时开发过程中大多数情况下Observer.onNext只需执行一次就可以获取到全部结果集，Single的订阅者Observer.onNext方法只会执行一次就完成了。接下来简单介绍下Single的使用

UserFeign.getUserByIDSingle 很简单返回类型指定Single泛型是User即可:

@GetMapping("/{id}")
Single getUserByIDSingle(@PathVariable("id") String id);

运行单元测试UserFeignTest.getUserByIDSingle

Single singleUser = userFeign.getUserByIDSingle("1");
singleUser.subscribe(new Observer() {
    @Override
    public void onCompleted() {
        System.out.println("执行完成");
    }
    @Override
    public void onError(Throwable e) {
        System.out.println("执行错误" + e);
    }
    @Override
    public void onNext(User user) {
        System.out.println("返回数据：" + user);
    }
});

输出结果：

返回数据：User{id='1', name='张三'}
执行完成

Single订阅者Observer.onNext方法只会执行一次，其实Observer.onCompleted方法没有什么作用，再加上我们有的时候不需要处理错误Observer.onError，这样我们就可以简化代码了

简化后的代码：

Single singleUser = userFeign.getUserByIDSingle("1");
singleUser.subscribe(System.out::println);

Completable

CompletableHTTP客户端只需知道请求成功或失败，不需要返回的数据时使用。

这里以保存为例UserFeign.save

单元测试UserFeignTest.save

User user = new User();
user.setName("张三4");
Completable completable = userFeign.save(user);
completable.subscribe(new Subscriber