hystrix文档翻译之如何使用

Posted 2020-10-18 zwh1988

Hello World!

　　使用HystrixCommand实现“Hello World”。

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() {
        // a real example would do work like a network call here
        return "Hello " + name + "!";
    }
}

　　使用HystrixObservableCommand实现“Hello World”。

public class CommandHelloWorld extends HystrixObservableCommand<String> {
    private final String name;
    public CommandHelloWorld(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> observer) {
                try {
                    if (!observer.isUnsubscribed()) {
                        // a real example would do work like a network call here
                        observer.onNext("Hello");
                        observer.onNext(name + "!");
                        observer.onCompleted();
                    }
                } catch (Exception e) {
                    observer.onError(e);
                }
            }
         } ).subscribeOn(Schedulers.io());
    }
}

同步执行

　　使用HystrixCommand的execute方法同步执行。

String s = new CommandHelloWorld("World").execute();

　　HystrixObservableCommand没有execute方法，但如果你确定Observable只会返回一个单一结果，你可以使用.toBlocking().toFuture().get()方法。

异步执行

　　使用HystrixCommand的queue()方法实现异步：

Future<String> fs = new CommandHelloWorld("World").queue();

　　通过get方式获得结果

String s = fs.get();

　　HystrixObservableCommand没有queue方法，但如果你确定Observable只会返回一个单一结果，你可以使用.toBlocking().toFuture()方法。

响应执行

　　通过下面两个方法可以获取Observable对象。

• observe，返回一个Observable并且立即执行命令，因为observe方法内部使用了一个RepaySubject，所以也会接受到监听以前命令返回的结果。
• toObservable，返回一个Observable但不回立即执行，当监听该对象时才执行。

Observable<String> ho = new CommandHelloWorld("World").observe();
// or Observable<String> co = new CommandHelloWorld("World").toObservable();
ho.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
         // value emitted here
    }
});

　　使用单元测试执行

@Test
public void testObservable() throws Exception {

    Observable<String> fWorld = new CommandHelloWorld("World").observe();
    Observable<String> fBob = new CommandHelloWorld("Bob").observe();

    // blocking
    assertEquals("Hello World!", fWorld.toBlockingObservable().single());
    assertEquals("Hello Bob!", fBob.toBlockingObservable().single());

    // non-blocking 
    // - this is a verbose anonymous inner-class approach and doesn‘t do assertions
    fWorld.subscribe(new Observer<String>() {

        @Override
        public void onCompleted() {
            // nothing needed here
        }

        @Override
        public void onError(Throwable e) {
            e.printStackTrace();
        }

        @Override
        public void onNext(String v) {
            System.out.println("onNext: " + v);
        }

    });

    // non-blocking
    // - also verbose anonymous inner-class
    // - ignore errors and onCompleted signal
    fBob.subscribe(new Action1<String>() {

        @Override
        public void call(String v) {
            System.out.println("onNext: " + v);
        }

    });
}

响应式命令

　　除了使用上面的方式来获取Observable对象，还可以通过HystrixObservableCommand来创建一个Observable对象。HystrixObservableCommand可以创建一个返回多个值的Observable对象。HystrixObservableCommand使用consruct方法来执行命令而不是run方法。通过一下两种方式来获取Observable对象：

• observe，返回一个Observable并且立即执行命令，因为observe方法内部使用了一个RepaySubject，所以也会接受到监听以前命令返回的结果。
• toObservable，返回一个Observable但不回立即执行，当监听该对象时才执行。

降级

　　通过添加fallback方法可以让命令执行异常时执行降级措施。你会为大多数的hystrix 命令实现降级方法，除了一下的情况：

• 命令执行写操作

　　如果hystrix命令是被设计成一个写操作而非读操作（HystrixCommand命令返回void或者HystrixObservableCommand返回一个空的Observable对象）。那么没有什么实现fallback方法。如果写出错了，应该把异常抛出给调用方。

• 执行批量计算

　　如果hystrix命令使用了缓存、或者批量、或者离线技术，也应该把异常抛给调用方，让调用放过处理而不是降级。

　　无论你的命令是否有fallback，hystrix状态和熔断器状态都会更新。