###全集配置（设置熔断超时时间）
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=10000
###局部配置
hystrix.command.hello.execution.isolation.thread.timeoutInMilliseconds=10000

public class CommandHelloWorld extends HystrixCommand<String> {
    private final String name;
    public CommandHelloWorld(String name) {
        super(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"));
        this.name = name;
    }
    @Override
    protected String run() throws Exception {
        int i = 1/0;
        return "Hello " + name + "!";
    }
    /**
     * 降级
     * 
     */
    @Override
    protected String getFallback() {
        return "faild";
    }
}
public class ObservableCommandHelloWorld extends HystrixObservableCommand<String> {
    private final String name;
    public ObservableCommandHelloWorld(String name) {
        super(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"));
        this.name = name;
    }
    @Override
    protected Observable<String> construct() {
        return Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                try {
                    if(!subscriber.isUnsubscribed()) {
                        subscriber.onNext("Hello");
                        int i = 1 / 0; //模拟异常
                        subscriber.onNext(name + "!");
                        subscriber.onCompleted();
                    }
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        }).subscribeOn(Schedulers.io());
    }
    /**
     * 服务降级
     */
    @Override
    protected Observable<String> resumeWithFallback() {
        return Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                try {
                    if (!subscriber.isUnsubscribed()) {
                        subscriber.onNext("失败了！");
                        subscriber.onNext("找大神来排查一下吧！");
                        subscriber.onCompleted();
                    }
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        }).subscribeOn(Schedulers.io());
    }
}
public class CommandHelloWorldTest {
    @Test
    public void testAll() {
        //同步
        new CommandHelloWorld("World").execute();
        //异步
        Future<String> fWorld = new CommandHelloWorld("World").queue();
        //代码1，Hot Observable不论 “事件源” 是否有“订阅者”都会在创建后对事件进行发布。每一个“订阅者”都有可能从“事件源”的中途开始的，并可能只是看到了整个操作的局部过程
        Observable<String> ho = new CommandHelloWorld("World").observe();
        ho.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                System.out.println("call:" + s);
            }
        });
        //代码2，Cold Observable在没有 “订阅者” 的时候并不会发布，而是进行等待，知道有 “订阅者” 之后才发布事件
        Observable<String> co = new CommandHelloWorld("World").toObservable();
        System.out.println(co.toBlocking().single());       
        
        Observable<String> observable= new ObservableCommandHelloWorld("World").observe();
        Iterator<String> iterator = observable.toBlocking().getIterator();
         while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

@HystrixCommand(fallbackMethod = "error")
public String hello() {
    return restTemplate.getForEntity("http://serviceName/hello", String.class).getBody();
}
public String error() {
    //多级降级
    return new FirstLevelFallbackCommand(tag).execute();
}
/**
 * LAZY参数表示使用toObservable()方式执行
 */
@HystrixCommand(observableExecutionMode = ObservableExecutionMode.LAZY, fallbackMethod = "toObserbableError") 
public Observable<String> getUserByName(final String name) {
    return Observable.create(new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {
            try {
                if(!subscriber.isUnsubscribed()) {
                    subscriber.onNext("找到");
                    subscriber.onNext(name);
                    int i = 1/0; 抛异常，模拟服务降级
                    subscriber.onNext("了");
                    subscriber.onCompleted();
                }
            } catch (Exception e) {
                subscriber.onError(e);
            }
        }
    });
}
private static class FirstLevelFallbackCommand extends HystrixCommand<String> { 
    private String tag; 
    public FirstLevelFallbackCommand(String tag) { 
	super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("FirstLevelFallbackCommand")));
	this.tag = tag;
    } 
    @Override
    protected String run() throws Exception {
      if ("error".equals(tag)) {
        throw new Exception("一级降级失败，二级降级处理");
      }
      return "成功";
    } 
    @Override
    protected String getFallback() {
      // 实际项目中，通常会在这里做残缺降级。
      System.out.println("二级降级执行成功");
      return "成功";
    } 
}

public R execute() {
    return queue().get();// 利用queue()拿到Future, 执行 get()同步等待拿到执行结果
}
public Future<R> queue() {
    // 实现为 toObservable().toBlocking().toFuture()
    final Future<R> delegate = toObservable().toBlocking().toFuture();
    return delegate;
}
//利用toObservable()得到Observable并直接订阅它,立即执行命令
public Observable<R> observe() {
    ReplaySubject<R> subject = ReplaySubject.create();
    final Subscription sourceSubscription = toObservable().subscribe(subject);
    ...
}