断路器，AOP实现断路器模式 ------------Hystrix

断路器：https://martinfowler.com/bliki/CircutiBreaker.html

核心思想：

　　在断路器对象中封装受保护的方法调用。

　　该断路器监控调用和断路情况

　　调用失败触发阈值后，后续调用直接由短路器返回错误，不再执行实际调用。

理解：

　　客户端通过circuit breaker调用服务提供者，正常的时候可以调用。如果服务提供方出现了问题，发生了超时， 前几次可以超时处理， 到达一个阀值可以通过断路器进行处理， 就不再向服务方发起请求。

　　

import lombok.extern.slf4j.Slf4j;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.stereotype.Component;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.atomic.AtomicInteger;

@Aspect

@Component

@Slf4j

public class CircuitBreakerAspect {

    // 阀值

    private static final Integer THRESHOLD = 3;

    //记录失败的次数

    private Map<String, AtomicInteger> counter = new ConcurrentHashMap<>();

    // 记录被保护的次数

    private Map<String, AtomicInteger> breakCounter = new ConcurrentHashMap<>();

    /**

     *

     * @param pjp 程序连接点

     * @return

     * @throws Throwable

     */

    @Around("execution(* 拦截的区域")

    public Object doWithCircuitBreaker(ProceedingJoinPoint pjp) throws Throwable {

        // 获取当前执行的方法

        String signature = pjp.getSignature().toLongString();

        log.info("Invoke {}", signature);

        Object retVal;

        try {

            if (counter.containsKey(signature)) {

                // 失败次数达到预制，如果保护次数没到，返回null

                if (counter.get(signature).get() > THRESHOLD &&

                        breakCounter.get(signature).get() < THRESHOLD) {

                    log.warn("Circuit breaker return null, break {} times.",

                            breakCounter.get(signature).incrementAndGet());

                    return null;

                }

            } else {

                counter.put(signature, new AtomicInteger(0));

                breakCounter.put(signature, new AtomicInteger(0));

            }

            retVal = pjp.proceed();

            counter.get(signature).set(0);

            breakCounter.get(signature).set(0);

        } catch (Throwable t) {

            log.warn("Circuit breaker counter: {}, Throwable {}",

                    counter.get(signature).incrementAndGet(), t.getMessage());

            breakCounter.get(signature).set(0);

            throw t;

        }

        return retVal;

    }

}

Hystrix

Hystrix [hɪst'rɪks]，中文含义是豪猪，因其背上长满棘刺，从而拥有了自我保护的能力。本文所说的Hystrix是Netflix开源的一款容错框架，同样具有自我保护能力。为了实现容错和自我保护，下面我们看看Hystrix如何设计和实现的。

Hystrix设计目标：

• 对来自依赖的延迟和故障进行防护和控制——这些依赖通常都是通过网络访问的
• 阻止故障的连锁反应
• 快速失败并迅速恢复
• 回退并优雅降级
• 提供近实时的监控

实现了断路服务器模式

在需要服务熔断的方法上添加@HystrixCommand注解， fallbackMethod指定熔断的地址，默认情况下@HystrixCommand是在另外一个线程执行的。可以做一些超时的处理。

@HystrixProperty（name="excution.isolation.strategy",value="SEMAPHORE")设置为信号

　　

Hystrix配置项参考：

Spring cloud 支持

　　spring-cloud-starter-netfixi-hystrix

　　@EnableCircuitBreaker

Feign支持

　　feign.hystrix.enable=true

　　@FeignClient

　　　　fallback / fallbackFactory

简单示例：

　　pom引入

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>

        </dependency>

　　application.properties

feign.client.config.default.connect-timeout=500
feign.client.config.default.read-timeout=500

#开启feign支持

feign.hystrix.enabled=true

#cousul连接配置

spring.cloud.consul.host=localhost
spring.cloud.consul.port=8500
spring.cloud.consul.discovery.prefer-ip-address=true

bootstarp.properties

spring.application.name=name-service

开启注解：

@EnableDiscoveryClient // 注册发现服务
@EnableFeignClients // feign的支持
@EnableCircuitBreaker  // feignClient的演示

　　//Spring  cloud 支持

    @PostMapping("/order")

    @HystrixCommand(fallbackMethod = "fallbackCreateOrder")

    public CoffeeOrder createOrder() {

     /*业务代码*/

        return order;

    }

    public CoffeeOrder fallbackCreateOrder() {

        log.warn("Fallback to NULL order.");

        return null;

    }

//FeignClient 的支持

import org.springframework.cloud.openfeign.FeignClient;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestParam;

import java.util.List;

@FeignClient(name = "waiter-service", contextId = "coffee",

        qualifier = "coffeeService", path="/coffee",

        fallback = FallbackCoffeeService.class)

// 如果用了Fallback，不要在接口上加@RequestMapping，path可以用在这里

public interface TestService {

    @GetMapping("/{id}")

    Product getById(@PathVariable Long id);

}

/*实现TestService*/

import lombok.extern.slf4j.Slf4j;

import org.springframework.stereotype.Component;

import java.util.Collections;

import java.util.List;

@Slf4j

@Component

public class FallbackTestService implements TestService{

    @Override

    public Product getById(Long id) {

        /**发送了垄断的逻辑代码*/

        return null;

    }

}

/**Controller调用*/

    @GetMapping("testGetById")

    public  String  testGetById() {

            TestService.getById((long) 1);

        return "";

    }