springCloud组件之Hystrix

男娘i 2024-04-01 08:51 13阅读 0赞

#### springCloud组件之Hystrix ####

*  背景
 *   *  SpringBoot使用Hystrix
     *  Feign使用Hystrix

## 背景 ##

最近在研究sentinel，但是在sentinel之前，大多数使用的熔断降级肯定还是Hystrix。  
hystrix是Netlifx开源的一款容错框架，防雪崩利器，具备服务降级，服务熔断，依赖隔离，监控(Hystrix Dashboard)等功能

> 雪崩的含义是指微服务调用链因为一个服务故障，导致整个调用链路异常。

![在这里插入图片描述][e29e4ce400c541dbb4495ee52e79fa13.png]  
接下来使用先加入Maven依赖  
注：**早期比较流行的是Hystrix框架，但目前国内实用最广泛的还是阿里巴巴的Sentinel框架，两种框架的隔离策略不一致，Hystrix主要以线程池隔离为主，sentinel则以信号量隔离为主，正是因为线程池隔离，则导致了Feign使用会有一系列问题，以下会提供解决方案。**

<dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
      <version>2.1.3.RELEASE</version>
    </dependency>

然后在启动类上加入注解：@EnableCircuitBreaker

### SpringBoot使用Hystrix ###

接口端的使用简单一些。

@ApiOperation("服务降级使用")
        @GetMapping("hystrix_demote")
        @HystrixCommand(fallbackMethod = "hystrixFallback", commandProperties = {
        
                @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
        })
        public String hystrixDemote(Integer num) throws InterruptedException {
        
            if (num == 1) {
        
                Thread.sleep(6000);
            }
            return "方法输出内容" + num;
        }

private String hystrixFallback(Integer num) {
        
            return "已经降级了" + num;
        }

@HystrixCommand当方法报错的时候自动返回fallbackMethod指定方法的内容，  
注意方法的返回与参数应当与接口一致。

### Feign使用Hystrix ###

前言，如果对openFeign使用有问题，或者不会使用的，可以访问我的另外一篇文章：  
[SpringCloud使用FeignClient][SpringCloud_FeignClient]

@FeignClient(value = "userService",fallbackFactory = UserFeignFallBackFactory.class)

在原本的Feign的注解中，加入fallbackFactory，指定自己创建的FallBack类。

@Slf4j
    @Component
    public class UserFeignFallBackFactory implements FallbackFactory<UserFeign> {
        
        @Override
        public UserFeign create(Throwable throwable) {
        
            log.error("请求用户中心出错:" + throwable.getMessage());
            return new UserFeign() {
        
                @Override
                public ResponseVO<RegisterPersonalDto> getUserinfo(Integer regId) {
        
                    String message = "获取用户信息失败，服务异常，请联系管理员";
                    log.error(throwable.getMessage());
                    log.error(message);
                    return ResponseUtil.get(1, message, null);
                }
            };
        }
    }

FallBack类实现FallbackFactory接口。重写create方法，对接口进行降级处理。  
但是加入Hystrix之后，会发现，客户端正常请求服务端也会失败，是因为  
**feign的hystrix隔离策略原因导致feign调用线程和主线程隔离了**[官方文档][Link 1]  
Feign远程调用设置configuration后，RequestContextHolder.getRequestAttributes()为空的，因为，Hystrix的默认隔离级别（线程池隔离）,以下附上解决方案。

package com.***.***.configuration;
    
    import com.netflix.hystrix.HystrixThreadPoolKey;
    import com.netflix.hystrix.HystrixThreadPoolProperties;
    import com.netflix.hystrix.strategy.HystrixPlugins;
    import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy;
    import com.netflix.hystrix.strategy.concurrency.HystrixRequestVariable;
    import com.netflix.hystrix.strategy.concurrency.HystrixRequestVariableLifecycle;
    import com.netflix.hystrix.strategy.eventnotifier.HystrixEventNotifier;
    import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
    import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher;
    import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
    import com.netflix.hystrix.strategy.properties.HystrixProperty;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.context.annotation.Primary;
    import org.springframework.security.core.context.SecurityContext;
    import org.springframework.security.core.context.SecurityContextHolder;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 此类为解决feign开启hystrix后，客户端的feign配置的服务降级，fallbackFactory，但是一直返回异常的问题
     *  原因：feign的hystrix隔离策略原因导致feign调用线程和主线程隔离了（官方文档：https://github.com/Netflix/Hystrix/wiki/Configuration#executionisolationstrategy）。
     *     Feign远程调用设置configuration后，RequestContextHolder.getRequestAttributes()为空的问题
     *     由于getRequestAttributes为空无法设置远调的token，导致一直都在走fallBackFactory
     * @author sirwsl
     */
    @Component
    @Primary
    @Slf4j
    public class CustomFeignHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {
        
    
        private HystrixConcurrencyStrategy hystrixConcurrencyStrategy;
    
        public CustomFeignHystrixConcurrencyStrategy() {
        
            try {
        
                this.hystrixConcurrencyStrategy = HystrixPlugins.getInstance().getConcurrencyStrategy();
                if (this.hystrixConcurrencyStrategy instanceof CustomFeignHystrixConcurrencyStrategy) {
        
                    return;
                }
                HystrixCommandExecutionHook commandExecutionHook =
                        HystrixPlugins.getInstance().getCommandExecutionHook();
                HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance().getEventNotifier();
                HystrixMetricsPublisher metricsPublisher = HystrixPlugins.getInstance().getMetricsPublisher();
                HystrixPropertiesStrategy propertiesStrategy =
                        HystrixPlugins.getInstance().getPropertiesStrategy();
                this.logCurrentStateOfHystrixPlugins(eventNotifier, metricsPublisher, propertiesStrategy);
                HystrixPlugins.reset();
                HystrixPlugins.getInstance().registerConcurrencyStrategy(this);
                HystrixPlugins.getInstance().registerCommandExecutionHook(commandExecutionHook);
                HystrixPlugins.getInstance().registerEventNotifier(eventNotifier);
                HystrixPlugins.getInstance().registerMetricsPublisher(metricsPublisher);
                HystrixPlugins.getInstance().registerPropertiesStrategy(propertiesStrategy);
            } catch (Exception e) {
        
                log.error("Failed to register Sleuth Hystrix Concurrency Strategy", e);
            }
        }
    
        private void logCurrentStateOfHystrixPlugins(HystrixEventNotifier eventNotifier,
                                                     HystrixMetricsPublisher metricsPublisher, HystrixPropertiesStrategy propertiesStrategy) {
        
            if (log.isDebugEnabled()) {
        
                log.debug("Current Hystrix plugins configuration is [" + "concurrencyStrategy ["
                        + this.hystrixConcurrencyStrategy + "]," + "eventNotifier [" + eventNotifier + "]," + "metricPublisher ["
                        + metricsPublisher + "]," + "propertiesStrategy [" + propertiesStrategy + "]," + "]");
                log.debug("Registering Sleuth Hystrix Concurrency Strategy.");
            }
        }
    
        /**
         * 提供在执行前包装/装饰Callable<T>的机会。
         * 这可用于注入其他行为，如复制线程状态（如ThreadLocal）。
         * 默认实现
         * 无包装的直通。
         * 参数：
         * callable–通过ThreadPoolExecutor执行的callable<T>
         * @param callable
         *            {@code Callable<T>} to be executed via a {@link ThreadPoolExecutor}
         * @return
         * @param <T>
         */
        @Override
        public <T> Callable<T> wrapCallable(Callable<T> callable) {
        
            /**
             * Holder类以线程绑定的RequestAttributes对象的形式公开web请求。如果可继承标志设置为true，则当前线程生成的任何子线程都将继承该请求。
             * 使用RequestContextListener或org.springframework.web.filter。RequestContextFilter以公开当前web请求
             * **********！！！！getRequestAttributes()`方法,相当于直接获取ThreadLocal里面的值
             */
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
            SecurityContext securityContext = SecurityContextHolder.getContext();
           log.info(securityContext.getAuthentication().getDetails().toString());
            return new WrappedCallable<>(callable, requestAttributes);
        }
    
        /**
         *
         根据需要提供ThreadPoolExecutor实例的Factory方法。
         请注意，如果使用ThreadPoolExecutor更改corePoolSize、maximumPoolSite和keepAliveTime的值，则它们的值将在运行时动态设置。
         setCorePoolSize、ThreadPoolExecutor。setMaximumPoolSize和ThreadPoolExecutor。setKeepAliveTime方法。
         默认实现
         使用标准java.util.concurrent.ThreadPoolExecutor实现
         参数：
         threadPoolKey–表示此ThreadPoolExecutor将用于的HystrixThreadPool的HystriexThreadpoolKey。
         corePoolSize–通过属性请求的核心线程数（如果没有设置属性，则为系统默认值）。
         maximumPoolSize–通过属性请求的最大线程数（如果未设置属性，则为系统默认值）。
         keepAliveTime–通过属性请求的线程保持活动时间（如果未设置属性，则为系统默认值）。
         unit–与keepAliveTime workQueue对应的TimeUnit–由getBlockingQueue（int）提供的Blocking队列<Runnable>
         */
        @Override
        public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                                HystrixProperty<Integer> corePoolSize, HystrixProperty<Integer> maximumPoolSize,
                                                HystrixProperty<Integer> keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        
            return this.hystrixConcurrencyStrategy.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime,
                    unit, workQueue);
        }
    
        @Override
        public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                                HystrixThreadPoolProperties threadPoolProperties) {
        
            return this.hystrixConcurrencyStrategy.getThreadPool(threadPoolKey, threadPoolProperties);
        }
    
        /**
         * 工厂方法，提供用于getThreadPool中构造的每个ThreadPoolExecutor的BlockingQueue<Runnable>实例。
         * 注意：提供了maxQueueSize值，因此可以使用任何类型的队列，但通常首选不带队列（只是切换）的SynchronousQueue等实现，因为排队是一种反模式，出于延迟容忍的原因，应有意避免。
         * 默认实现
         * 当maxQueueSize<=0时，实现返回SynchronousQueue；当maxQuueSize>0时，则返回LinkedBlockingQueue。
         * 参数：
         * maxQueueSize–通过属性请求的队列的最大大小（如果没有设置属性，则为系统默认值）。
         * 退货：
         * BlockingQueue<Runnable>的实例
         * @param maxQueueSize
         *            The max size of the queue requested via properties (or system default if no properties set).
         * @return
         */
        @Override
        public BlockingQueue<Runnable> getBlockingQueue(int maxQueueSize) {
        
            return this.hystrixConcurrencyStrategy.getBlockingQueue(maxQueueSize);
        }
    
        /**
         * 方法返回HystrixRequestVariable的实现，该实现的行为类似于ThreadLocal，但其作用域是请求而不是线程。
         * 例如，如果请求以HTTP请求开始，以HTTP响应结束，则HystrixRequestVariable应在开始时初始化，可在请求期间生成的任何和所有线程上使用，然后在HTTP请求完成后清除。
         * 如果实现了此方法，通常还需要实现wrapCallable（Callable），以便将状态从父线程复制到子线程。
         * 参数：
         * rv–HystrixRequestVariableLifecycle以及Hystrix的生命周期实施
         */
        @Override
        public <T> HystrixRequestVariable<T> getRequestVariable(HystrixRequestVariableLifecycle<T> rv) {
        
            return this.hystrixConcurrencyStrategy.getRequestVariable(rv);
        }
    
        static class WrappedCallable<T> implements Callable<T> {
        
            private final Callable<T> target;
            private final RequestAttributes requestAttributes;
    
            public WrappedCallable(Callable<T> target, RequestAttributes requestAttributes) {
        
                this.target = target;
                this.requestAttributes = requestAttributes;
            }
    
            /**
             * feign打开保险丝（hystrix）：feign.hystrix.enabled=true，并使用默认信号隔离级别，
             * *HttpServletRequest对象在父线程中相互独立
             * *和子线程，并且不共享。
             * *因此子线程中使用的父线程的HttpServletRequest数据为空，
             * *当然，不可能获得请求头的令牌信息
             * *在多线程环境中，在请求之前调用，在调用之前设置上下文
             * @return
             * @throws Exception
             */
            @Override
            public T call() throws Exception {
        
                try {
        
                    /**
                     * 将给定的RequestAttributes绑定到当前线程。
                     * 参数：
                     * attributes–要公开的RequestAttributes，或为null以重置线程绑定的上下文inheritable–是否将RequestAttribute公开为子线程的可继承属性（使用InheritableThreadLocal）
                     */
                    RequestContextHolder.setRequestAttributes(requestAttributes,true);
                    return target.call();
                } finally {
        
                    RequestContextHolder.resetRequestAttributes();
                }
            }
        }
    
    }

完结撒花，下一步Sentinel

[e29e4ce400c541dbb4495ee52e79fa13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f53892ad243e4810ae24f38dbb5e6e4e.png
[SpringCloud_FeignClient]: https://blog.csdn.net/luck_sheng/article/details/114529052?spm=1001.2014.3001.5501
[Link 1]: https://github.com/Netflix/Hystrix/wiki/Configuration#executionisolationstrategy