聊聊spring cloud的HystrixCircuitBreakerConfiguration

@Configuration
public class HystrixCircuitBreakerConfiguration {

    @Bean
    public HystrixCommandAspect hystrixCommandAspect() {
        return new HystrixCommandAspect();
    }

    @Bean
    public HystrixShutdownHook hystrixShutdownHook() {
        return new HystrixShutdownHook();
    }

    @Bean
    public HasFeatures hystrixFeature() {
        return HasFeatures.namedFeatures(new NamedFeature("Hystrix", HystrixCommandAspect.class));
    }

    //FIXME: 2.0.0
    /*@Configuration
    @ConditionalOnProperty(value = "hystrix.metrics.enabled", matchIfMissing = true)
    @ConditionalOnClass({ HystrixMetricsPoller.class, GaugeService.class })
    @EnableConfigurationProperties(HystrixMetricsProperties.class)
    protected static class HystrixMetricsPollerConfiguration implements SmartLifecycle {

        private static Log logger = LogFactory
                .getLog(HystrixMetricsPollerConfiguration.class);

        @Autowired(required = false)
        private GaugeService gauges;

        @Autowired
        private HystrixMetricsProperties metricsProperties;

        private ObjectMapper mapper = new ObjectMapper();

        private HystrixMetricsPoller poller;

        private Set<String> reserved = new HashSet<String>(Arrays.asList("group", "name",
                "type", "currentTime"));

        @Override
        public void start() {
            if (this.gauges == null) {
                return;
            }
            MetricsAsJsonPollerListener listener = new MetricsAsJsonPollerListener() {
                @Override
                public void handleJsonMetric(String json) {
                    try {
                        @SuppressWarnings("unchecked")
                        Map<String, Object> map = HystrixMetricsPollerConfiguration.this.mapper
                                .readValue(json, Map.class);
                        if (map != null && map.containsKey("type")) {
                            addMetrics(map, "hystrix.");
                        }
                    }
                    catch (IOException ex) {
                        // ignore
                    }
                }

            };
            this.poller = new HystrixMetricsPoller(listener,
                    metricsProperties.getPollingIntervalMs());
            // start polling and it will write directly to the listener
            this.poller.start();
            logger.info("Starting poller");
        }

        private void addMetrics(Map<String, Object> map, String root) {
            StringBuilder prefixBuilder = new StringBuilder(root);
            if (map.containsKey("type")) {
                prefixBuilder.append((String) map.get("type"));
                if (map.containsKey("group")) {
                    prefixBuilder.append(".").append(map.get("group"));
                }
                prefixBuilder.append(".").append(map.get("name"));
            }
            String prefix = prefixBuilder.toString();
            for (String key : map.keySet()) {
                Object value = map.get(key);
                if (!this.reserved.contains(key)) {
                    if (value instanceof Number) {
                        String name = prefix + "." + key;
                        this.gauges.submit(name, ((Number) value).doubleValue());
                    }
                    else if (value instanceof Map) {
                        @SuppressWarnings("unchecked")
                        Map<String, Object> sub = (Map<String, Object>) value;
                        addMetrics(sub, prefix);
                    }
                }
            }
        }

        @Override
        public void stop() {
            if (this.poller != null) {
                this.poller.shutdown();
            }
        }

        @Override
        public boolean isRunning() {
            return this.poller != null ? this.poller.isRunning() : false;
        }

        @Override
        public int getPhase() {
            return Ordered.LOWEST_PRECEDENCE;
        }

        @Override
        public boolean isAutoStartup() {
            return true;
        }

        @Override
        public void stop(Runnable callback) {
            if (this.poller != null) {
                this.poller.shutdown();
            }
            callback.run();
        }

    }*/

    /**
     * {@link DisposableBean} that makes sure that Hystrix internal state is cleared when
     * {@link ApplicationContext} shuts down.
     */
    private class HystrixShutdownHook implements DisposableBean {

        @Override
        public void destroy() throws Exception {
            // Just call Hystrix to reset thread pool etc.
            Hystrix.reset();
        }

    }

}

/**
 * AspectJ aspect to process methods which annotated with {@link HystrixCommand} annotation.
 */
@Aspect
public class HystrixCommandAspect {

    private static final Map<HystrixPointcutType, MetaHolderFactory> META_HOLDER_FACTORY_MAP;

    static {
        META_HOLDER_FACTORY_MAP = ImmutableMap.<HystrixPointcutType, MetaHolderFactory>builder()
                .put(HystrixPointcutType.COMMAND, new CommandMetaHolderFactory())
                .put(HystrixPointcutType.COLLAPSER, new CollapserMetaHolderFactory())
                .build();
    }

    @Pointcut("@annotation(com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand)")

    public void hystrixCommandAnnotationPointcut() {
    }

    @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);
        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 = META_HOLDER_FACTORY_MAP.get(HystrixPointcutType.of(method));
        MetaHolder metaHolder = metaHolderFactory.create(joinPoint);
        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) {
            throw e.getCause() != null ? e.getCause() : e;
        } catch (HystrixRuntimeException e) {
            throw hystrixRuntimeExceptionToThrowable(metaHolder, e);
        }
        return result;
    }
    //......
}

    /**
     * {@link DisposableBean} that makes sure that Hystrix internal state is cleared when
     * {@link ApplicationContext} shuts down.
     */
    private class HystrixShutdownHook implements DisposableBean {

        @Override
        public void destroy() throws Exception {
            // Just call Hystrix to reset thread pool etc.
            Hystrix.reset();
        }

    }

    /**
     * Reset state and release resources in use (such as thread-pools).
     * <p>
     * NOTE: This can result in race conditions if HystrixCommands are concurrently being executed.
     * </p>
     */
    public static void reset() {
        // shutdown thread-pools
        HystrixThreadPool.Factory.shutdown();
        _reset();
    }

    /**
     * Reset state and release resources in use (such as threadpools) and wait for completion.
     * <p>
     * NOTE: This can result in race conditions if HystrixCommands are concurrently being executed.
     * </p>
     * 
     * @param time
     *            time to wait for thread-pools to shutdown
     * @param unit
     *            {@link TimeUnit} for <pre>time</pre> to wait for thread-pools to shutdown
     */
    public static void reset(long time, TimeUnit unit) {
        // shutdown thread-pools
        HystrixThreadPool.Factory.shutdown(time, unit);
        _reset();
    }

    /**
     * Reset logic that doesn't have time/TimeUnit arguments.
     */
    private static void _reset() {
        // clear metrics
        HystrixCommandMetrics.reset();
        HystrixThreadPoolMetrics.reset();
        HystrixCollapserMetrics.reset();
        // clear collapsers
        HystrixCollapser.reset();
        // clear circuit breakers
        HystrixCircuitBreaker.Factory.reset();
        HystrixPlugins.reset();
        HystrixPropertiesFactory.reset();
        currentCommand.set(new ConcurrentStack<HystrixCommandKey>());
    }