【源码】Spring Cloud —— Hystrix：HystrixCommandAspect AbstractCommand HystrixCircuitBreaker

前言

Hystrix，以类似 断路器 的机制保证失效服务的隔离，同时提供 快速失败、服务降级 等功能，spring-cloud-netflix-hystrix 对其进行适配

本章节结合部分源码了解 Hystrix 的实现

版本

hystrix：1.5.18

HystrixCommandAspect

Hystrix 的实现使用到了 命令设计模式，命令模式 将 命令者、命令、命令 的实现解耦开来

Hystrix 借助 Aspect（切面），将服务的调用封装成对应的 命令，它们可以拥有自己的 线程资源 以实现 资源隔离

HystrixCommandAspect

// 是个 Aspect，可以被 spring-aop 解析
@Aspect
public class HystrixCommandAspect {

    private static final Map<HystrixPointcutType, MetaHolderFactory> META_HOLDER_FACTORY_MAP;

    /**
     * 静态块维护解析 @HystrixCommand 和 @HystrixCollapser 
     *      对应的 MetaHolder 的 MetaHolderFactory
     */
    static {
        META_HOLDER_FACTORY_MAP = ImmutableMap.<HystrixPointcutType, MetaHolderFactory>builder()
                .put(HystrixPointcutType.COMMAND, new CommandMetaHolderFactory())
                .put(HystrixPointcutType.COLLAPSER, new CollapserMetaHolderFactory())
                .build();
    }

    // @HystrixCommand 切点
    @Pointcut("@annotation(com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand)")
    public void hystrixCommandAnnotationPointcut() {
    }

    // HystrixCollapser 切点
    @Pointcut("@annotation(com.netflix.hystrix.contrib.javanica.annotation.HystrixCollapser)")
    public void hystrixCollapserAnnotationPointcut() {
    }

    @Around("hystrixCommandAnnotationPointcut() || hystrixCollapserAnnotationPointcut()")
    public Object methodsAnnotatedWithHystrixCommand(final ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取切点方法
        Method method = getMethodFromTarget(joinPoint);
        Validate.notNull(method, "failed to get method from joinPoint: %s", joinPoint);
        
        // 不能同时注解 @HystrixCommand 和 @HystrixCollapser
        if (method.isAnnotationPresent(HystrixCommand.class) && method.isAnnotationPresent(HystrixCollapser.class)) {
            throw new IllegalStateException("method cannot be annotated with HystrixCommand and HystrixCollapser " +
                    "annotations at the same time");
        }
        
        // 获取注解对应 MetaHolderFactory
        MetaHolderFactory metaHolderFactory = META_HOLDER_FACTORY_MAP.get(HystrixPointcutType.of(method));
        
        // 解析对应的 MetaHolder
        MetaHolder metaHolder = metaHolderFactory.create(joinPoint);
        
        // 构建对应的 HystrixInvokable（命令）
        HystrixInvokable invokable = HystrixCommandFactory.getInstance().create(metaHolder);
        
        // 命令类型
        ExecutionType executionType = metaHolder.isCollapserAnnotationPresent() ?
                metaHolder.getCollapserExecutionType() : metaHolder.getExecutionType();

        /**
         * 根据不同的命令类型，执行命令，返回结果
         */
        Object result;
        try {
            if (!metaHolder.isObservable()) {
                result = CommandExecutor.execute(invokable, executionType, metaHolder);
            } else {
                result = executeObservable(invokable, executionType, metaHolder);
            }
        } catch (HystrixBadRequestException e) {
            
            // ...
            
        }
        return result;
    }	

	// ...

}

HystrixCommandAspect 是一个 Aspect，拦截对应的方法，生成对应的 HystrixInvokable（命令），方法的执行委托给 命令 的执行

可以理解为，Hystrix 对所有注解了 @HystrixCommand 和 @HystrixCollapser 的方法进行代理，将其行为委托给基于切点方法构造的 HystrixInvokable

ExecutionType

public enum ExecutionType {

    // 异步
    ASYNCHRONOUS,

    // 同步
    SYNCHRONOUS,

    // 响应式（异步回调）
    OBSERVABLE;

    /**
     * 命令的类型取决于切点方法的返回值
     * Future -> ASYNCHRONOUS
     * Observable -> OBSERVABLE
     * 其他 -> SYNCHRONOUS
     */
    public static ExecutionType getExecutionType(Class<?> type) {
        if (Future.class.isAssignableFrom(type)) {
            return ExecutionType.ASYNCHRONOUS;
        } else if (Observable.class.isAssignableFrom(type)) {
            return ExecutionType.OBSERVABLE;
        } else {
            return ExecutionType.SYNCHRONOUS;
        }
    }
}

构造命令的类型取决于切点方法的返回值：

• ASYNCHRONOUS：异步， 命令的返回值为 Future，可使用 Future#get 方法 阻塞式 获取执行结果
• OBSERVABLE：响应式，可获取发射执行结果的 Observable，进行订阅，订阅对应的异步回调方法
• SYNCHRONOUS：同步，同步获取对应的结果

整体上，命令的结果都基于 AbstractCommand#toObservable 方法，将对应的 Observable 转换成 Future，又或者直接 Future#get 同步返回结果，以满足对应的 命令类型

因此，整个命令的封装基于 rxjava 实现：

• rx，响应式编程思想，异步式回调，通过 Observer 订阅 Ovservable 的方式，无需类似 Future#get 方法阻塞式等待结果返回，而是回调式异步获取结果
• rxjava，rx 思想的 java 实现

更多关于 rxjava 的内容，传送门：

【从零学 RxJava】RxJava 1 Hot Observable & Cold Observable、Subject

AbstractCommand#toObservable

	public Observable<R> toObservable() {
        final AbstractCommand<R> _cmd = this;

        // terminate 回调
        final Action0 terminateCommandCleanup = new Action0() {

            // ...

        };

        // unsubscribe 回调
        final Action0 unsubscribeCommandCleanup = new Action0() {

            // ...

        };

        // 定义 Func0 创建对应的 Observale
        final Func0<Observable<R>> applyHystrixSemantics = new Func0<Observable<R>>() {
            @Override
            public Observable<R> call() {
                if (commandState.get().equals(CommandState.UNSUBSCRIBED)) {
                    return Observable.never();
                }
                return applyHystrixSemantics(_cmd);
            }
        };

        final Func1<R, R> wrapWithAllOnNextHooks = new Func1<R, R>() {

            // ...

        };

        // OnComplete 回调
        final Action0 fireOnCompletedHook = new Action0() {

            // ...

        };

        return Observable.defer(new Func0<Observable<R>>() {
            @Override
            public Observable<R> call() {

                // ...

                final boolean requestCacheEnabled = isRequestCachingEnabled();
                final String cacheKey = getCacheKey();

                /**
                 * 如果配置允许缓存，试图获取，默认 false
                 */
                if (requestCacheEnabled) {
                    HystrixCommandResponseFromCache<R> fromCache = (HystrixCommandResponseFromCache<R>) requestCache.get(cacheKey);
                    if (fromCache != null) {
                        isResponseFromCache = true;
                        return handleRequestCacheHitAndEmitValues(fromCache, _cmd);
                    }
                }

                /**
                 * defer 操作符会为每一个订阅者
                 *      返回一个全新的 Obervable
                 * 对应的 Obervable 由 applyHystrixSemantics
                 *      函数创建
                 */
                Observable<R> hystrixObservable =
                        Observable.defer(applyHystrixSemantics)
                                .map(wrapWithAllOnNextHooks);

                Observable<R> afterCache;

                /**
                 * 如果允许缓存，缓存对应的 Observable
                 */
                if (requestCacheEnabled && cacheKey != null) {

                    // ...

                } else {
                    afterCache = hystrixObservable;
                }

                // 生命周期回调设置
                return afterCache
                        .doOnTerminate(terminateCommandCleanup)
                        .doOnUnsubscribe(unsubscribeCommandCleanup)
                        .doOnCompleted(fireOnCompletedHook);
            }
        });
    }

该方法主要：

• 缓存相关，试图从缓存获取以及对生成的 Observable 进行缓存
• 生命周期相关，定义了部分 生命周期回调，比如 doOnTerminate doOnUnsubscribe doOnCompleted
• 对应的 Observable 由 applyHystrixSemantics 函数创建，该函数委托方法 applyHystrixSemantics 创建，此处用到 defer 操作符，可以为每个 订阅者 创建一个全新的 Observable

AbstractCommand#applyHystrixSemantics

	private Observable<R> applyHystrixSemantics(final AbstractCommand<R> _cmd) {
        
        /**
         * circuitBreaker：断路器的实现
         *      allowRequest：是否允许请求，即断路器是否闭合
         */
        if (circuitBreaker.allowRequest()) {
            // 信号量获取
            final TryableSemaphore executionSemaphore = getExecutionSemaphore();
            final AtomicBoolean semaphoreHasBeenReleased = new AtomicBoolean(false);

            // 信号释放回调
            final Action0 singleSemaphoreRelease = new Action0() {
                @Override
                public void call() {
                    if (semaphoreHasBeenReleased.compareAndSet(false, true)) {
                        // 信号释放
                        executionSemaphore.release();
                    }
                }
            };

            // OnError 回调
            final Action1<Throwable> markExceptionThrown = new Action1<Throwable>() {
               
               // ...
               
            };

            /**
             * 获取信号，并返回对应的 Observable
             */
            if (executionSemaphore.tryAcquire()) {
                try {
                    executionResult = executionResult.setInvocationStartTime(System.currentTimeMillis());
                    return executeCommandAndObserve(_cmd)
                            .doOnError(markExceptionThrown)
                            .doOnTerminate(singleSemaphoreRelease)
                            .doOnUnsubscribe(singleSemaphoreRelease);
                } catch (RuntimeException e) {
                    return Observable.error(e);
                }
            } else {
                // 信号量获取失败回调
                return handleSemaphoreRejectionViaFallback();
            }
        } else {
            // 断路器断开回调处理
            return handleShortCircuitViaFallback();
        }
    }

• 判断是否允许发送请求，这基于 断路器 实现，如果 断路器 打开，则进行对应回调处理（失败或降级）
• 如果 断路器 关闭，则进行请求，先获取 信号，获取失败则处理对应回调
• 获取成功，则由方法 executeCommandAndObserve
  创建对应的 Observable 实现 线程隔离、请求发送 等操作，同时注册了对应的 生命周期回调

HystrixCircuitBreaker

Hystrix 使用断路器，对请求失败达到 阈值 的服务，打开 断路器，断路器有如下状态：

• 闭合，正常发送请求，当请求失败达到 阈值 后，断开
• 断开，此时不进行服务调用，直接返回失败（或者降级处理），并设置一个 重置时间，在该时间后，断路器半开
• 半开，允许发送请求，在调用成功达到一定条件后关闭断路器，否则再次打开

断路器 的逻辑主要由 HystrixCircuitBreaker 实现

public interface HystrixCircuitBreaker {

	// 是否允许请求发送
    public boolean allowRequest();

	// 断路器是否打开
    public boolean isOpen();

	// 断路器半开时关闭
    /* package */void markSuccess();

	// ...

}

定义了三个方法，同时提供了两个内部实现类 HystrixCircuitBreakerImpl 和 NoOpCircuitBreaker，后者空实现，默认可以发送请求，重点关注 HystrixCircuitBreakerImpl

HystrixCircuitBreakerImpl

	/* package */static class HystrixCircuitBreakerImpl implements HystrixCircuitBreaker {

        // HystrixCommand 配置
        private final HystrixCommandProperties properties;

        // HystrixCommand 监控指标
        private final HystrixCommandMetrics metrics;

        // 断路器开关
        private AtomicBoolean circuitOpen = new AtomicBoolean(false);

        // 断路器打开时间
        private AtomicLong circuitOpenedOrLastTestedTime = new AtomicLong();

        /**
         * CAS 操作关闭断路器
         */
        public void markSuccess() {
            if (circuitOpen.get()) {
                if (circuitOpen.compareAndSet(true, false)) {
                    metrics.resetStream();
                }
            }
        }

        @Override
        public boolean allowRequest() {
            /**
             * 如果配置强制打开断路器，
             *      返回 false
             */
            if (properties.circuitBreakerForceOpen().get()) {
                return false;
            }

            /**
             * 如果配置强制关闭断路器，返回 true，但会执行 isOpen 方法
             *      以保证强制关闭接触后，断路器状态仍然正确
             *      （失效服务的断路器是开启的）
             */
            if (properties.circuitBreakerForceClosed().get()) {
                isOpen();
                return true;
            }

            /**
             * 如果断路器关闭，返回 true
             * 如果断路器打开，则执行 allowSingleTest，
             *      判断是否超过重置时间，如果是则半开
             */
            return !isOpen() || allowSingleTest();
        }

        /**
         * 如果断开超过设置的 重置时间，则半开
         */
        public boolean allowSingleTest() {
            long timeCircuitOpenedOrWasLastTested = circuitOpenedOrLastTestedTime.get();
            if (circuitOpen.get() && System.currentTimeMillis() > timeCircuitOpenedOrWasLastTested + properties.circuitBreakerSleepWindowInMilliseconds().get()) {
                if (circuitOpenedOrLastTestedTime.compareAndSet(timeCircuitOpenedOrWasLastTested, System.currentTimeMillis())) {
                    return true;
                }
            }
            return false;
        }

        @Override
        public boolean isOpen() {
            // 断路器打开，则直接返回
            if (circuitOpen.get()) {
                return true;
            }

            // 获取服务的健康指标
            HealthCounts health = metrics.getHealthCounts();

            // 请求数不到阈值，返回 false
            if (health.getTotalRequests() < properties.circuitBreakerRequestVolumeThreshold().get()) {
                return false;
            }

            // 失败请求数未达到阈值，返回 false
            if (health.getErrorPercentage() < properties.circuitBreakerErrorThresholdPercentage().get()) {
                return false;
            } else {
                /**
                 * 失败请求达到阈值，打开断路器并更新打开时间
                 *      此处是 CAS 操作，如果竞争失败，其实
                 *      并不影响结果（断路器打开了，时间设置了）
                 *      因此直接返回 true 即可
                 */
                if (circuitOpen.compareAndSet(false, true)) {
                    circuitOpenedOrLastTestedTime.set(System.currentTimeMillis());
                    return true;
                } else {
                    return true;
                }
            }
        }
    }

HystrixCircuitBreakerImpl 的实现并不复杂，因此此处贴出了所有代码以及详细注释，这里再进行简单的总结：

• markSuccess：半开状态下关闭断路器，即对 开关 进行 CAS 关闭操作

• allowRequest：是否允许请求，取决于 断路器 状态

  • 如果配置强制开启 断路器，则返回 false，拒绝发送请求
  • 如果配置强制关闭 断路器，则返回 true，允许发送请求，但是同时也要记录真正的 断路器 状态，在该设置被取消时，可以正确返回 断路器 状态
  • 正常状态下，如果 断路器 关闭，则返回 true，但如果断开，则由 allowSingleTest 方法判断是否需要 半开
  • allowSingleTest：断路器 打开时间超过配置的 重置时间，则 半开，返回 true

• isOpen：如果 断路器 打开，直接返回 true，如果是关闭的，则根据其服务指标，决定是否打开断路器

AbstractCommand#executeCommandAndObserve

	private Observable<R> executeCommandAndObserve(final AbstractCommand<R> _cmd) {

        // ...

        // doOnCompleted 回调
        final Action0 markOnCompleted = new Action0() {

            // ...

        };

        /**
         * 各种失败回调处理
         */
        final Func1<Throwable, Observable<R>> handleFallback = new Func1<Throwable, Observable<R>>() {
            @Override
            public Observable<R> call(Throwable t) {
                Exception e = getExceptionFromThrowable(t);
                executionResult = executionResult.setExecutionException(e);
                if (e instanceof RejectedExecutionException) {
                    
                    // 线程调度失败回调
                    return handleThreadPoolRejectionViaFallback(e);
                } else if (t instanceof HystrixTimeoutException) {
                    
                    // 超时回调
                    return handleTimeoutViaFallback();
                } else if (t instanceof HystrixBadRequestException) {
                    
                    // HystrixBadRequestException 异常回调
                    return handleBadRequestByEmittingError(e);
                } else {
                    if (e instanceof HystrixBadRequestException) {
                        eventNotifier.markEvent(HystrixEventType.BAD_REQUEST, commandKey);
                        return Observable.error(e);
                    }

                    // 降级处理
                    return handleFailureViaFallback(e);
                }
            }
        };

        // doOnEach 回调
        final Action1<Notification<? super R>> setRequestContext = new Action1<Notification<? super R>>() {
            @Override
            public void call(Notification<? super R> rNotification) {
                setRequestContextIfNeeded(currentRequestContext);
            }
        };

        /**
         * executeCommandWithSpecifiedIsolation 方法
         *      创建对应的 Observable，实现 线程隔离、请求发送
         *      等操作
         * 如果需要超时监控，借助 HystrixObservableTimeoutOperator 
         *      转换对应的 Observable
         */
        Observable<R> execution;
        if (properties.executionTimeoutEnabled().get()) {
            execution = executeCommandWithSpecifiedIsolation(_cmd)
                    .lift(new HystrixObservableTimeoutOperator<R>(_cmd));
        } else {
            execution = executeCommandWithSpecifiedIsolation(_cmd);
        }

        // 回调设置
        return execution.doOnNext(markEmits)
                .doOnCompleted(markOnCompleted)
                .onErrorResumeNext(handleFallback)
                .doOnEach(setRequestContext);
    }

此方法主要针对各种异常进行了 回调处理，比如 线程调度异常 服务调用超时 等，同时由 executeCommandWithSpecifiedIsolation 创建对应的 Observable 实现 线程隔离、请求发送 等

对于需要 超时监控 的 Observable，借助 HystrixObservableTimeoutOperator 转换成对应的 Observable

AbstractCommand#executeCommandWithSpecifiedIsolation

	private Observable<R> executeCommandWithSpecifiedIsolation(final AbstractCommand<R> _cmd) {

        // 线程隔离
        if (properties.executionIsolationStrategy().get() == ExecutionIsolationStrategy.THREAD) {
            return Observable.defer(new Func0<Observable<R>>() {
                @Override
                public Observable<R> call() {

                    // ...

                    if (threadState.compareAndSet(ThreadState.NOT_USING_THREAD, ThreadState.STARTED)) {

                        // ...

                        try {

							// ...
                                              
                            // 请求服务
                            return getUserExecutionObservable(_cmd);
                        } catch (Throwable ex) {
                            return Observable.error(ex);
                        }
                    } else {
                       
                       // ...
                       
                    }
                }

                // OnTerminate 回调
            }).doOnTerminate(new Action0() {

                // ...

                // OnUnsubscribe 回调
            }).doOnUnsubscribe(new Action0() {
                
                // ...

                /**
                 * subscribeOn 通过接受一个 Scheduler，来指定
                 *      对数据的处理运行在特定的 Scheduler 上
                 * 此处的 Scheduler 由 threadPool.getScheduler
                 *      方法提供
                 */
            }).subscribeOn(threadPool.getScheduler(new Func0<Boolean>() {
                @Override
                public Boolean call() {
                    return properties.executionIsolationThreadInterruptOnTimeout().get() && _cmd.isCommandTimedOut.get() == TimedOutStatus.TIMED_OUT;
                }
            }));

            // 非线程隔离
        } else {
            
            // ...
            
        }
    }

该方法主要实现服务请求的 线程隔离，它借助 Observable#subscribeOn 实现，subscribeOn 通过接受一个 Scheduler，来指定对数据的处理运行在特定的 Scheduler 上，该 Scheduler 由 threadPool.getScheduler 提供

最后，服务的调用由方法 getUserExecutionObservable 实现，其本质便是返回一个发射服务调用结果的 Observable，不再深究

总结

至此，我们结合部分源码对 Hystrix 的实现及原理做了简单解析，Hystrix 源码大量使用 RxJava，大量的回调方法导致代码十分庞大，是 RxJava 教科书般的使用案例

同时，Hystrix 源码用到了并不常用的设计模式：命令设计模式，将 服务调用 封装成对应的 命令，实现了 命令调用者、命令和命令实现 的解耦

参考

《Spring Cloud 微服务架构进阶》 —— 朱荣鑫 张天 黄迪璇