SpringCloud Alibaba学习04-服务容错

四、服务容错

4.1 高并发带来的问题

在微服务架构中，我们将业务拆分成一个个的服务，服务与服务之间可以相互调用，但由于网络原因或自身原因，服务并不能保证服务的100%可用，若单个服务出现问题，
调用这个服务就会出现网络延迟，此时若有大量的请求涌入，就会形成任务堆积，导致服务瘫痪。

4.2 常见容错方案和思路

要防止雪崩的扩散，我们就要做好服务的容错。容错说白了就是保护自己不被猪队友拖垮的一些措施。

4.2.1 隔离

它是只讲系统按照一定的原则划分为若干个服务模块，各个模块之间相对独立，无强依赖。当有故障发生是，能将问题和影响隔离在某个模块内部，而不扩散分线，不波及其他模块，
不影响整体的系统服务。常见的隔离方式有：线程池隔离和信号量隔离

4.2.2 超时

在上游服务调用下游服务时，设置一个最大响应时间，若超过这个时间，下游未作出反应，就断开请求，释放线程

4.2.3 限流

限流就是限制系统的输入和输出流量已达到保护系统的目的。为了保证系统的稳定运行，一旦打到需要限制的阈值就需要限制流量并采取少量措施以完成限制流量的目的

4.2.4 熔断

在互联网系统中，当下游服务因访问压力过大而响应变慢或失败，上游服务为了保护系统整体的可用性，可以暂时切断对下游服务的调用。这种
牺牲局部，保全整体的措施就叫做熔断

4.2.4.1 熔断d三种状态

• 熔断关闭状态：服务没有故障时，熔断器所处的状态，对调用方的调用不做任何限制
• 熔断开启状态：后续对该服务接口的调用不在经过网络，而是直接执行本地的fallback方法
• 版熔断状态：尝试恢复服务调用，允许有限的流量调用该服务，并监控调用成功率，若成功率达到预期，则说明服务已恢复，进入熔断关闭状态，否则进入熔断关闭状态

4.2.5 降级

降级就是微服务提供一个托底方案，一旦服务无法正常调用，就是用托底方案

4.3 常见容错组件

4.3.1 Hystrix

Hystrix是由Netflix开源的一个延迟和容错库，用户隔离访问远程系统、服务或者第三方库，防止级联失败，从而提升系统的可用性与容错性

4.3.2 Resilience4j

Resilience4j是一款非常轻量、简单，并且文档非常清晰、丰富的熔断工具，这也是Hystrix官方推荐的替代产品，不仅如此，Resilience4j还原生支持SpringBoot1.x/2.x，而且监控也支持和
promethus等多款主流产品进行整合

4.3.3 Sentinel

Sentinel是阿里巴巴开源的一款断路器实现，本身在阿里内部已被大规模使用，非常稳定

4.3.4 三个组件对比

4.4 Sentinel入门

4.4.1 什么是Sentinel

Sentinel(分布式系统的流量防卫兵)是阿里巴巴开源的一款断路器实现，它以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性，
Sentinel分为两个部分：核心库（java客户端）和控制台（Dashboard）

4.4.1.1 Sentinel特征

• 丰富的应用场景： Sentinel承接了阿里巴巴近10年的双十一大促流量的核心场景，例如秒杀、消息削峰填谷、集群流量控制、试试熔断下游不可用应用等。
• 完备的实时监控： Sentinel提供了试试的监控功能。通过控制台可以看到接入应用的单台机器秒级数据，甚至500台一下规模的集群汇总运行情况。
• 广泛的开源生态： 提供了开箱即用的与其他开源框架库的整合模块
• 完善的SPI扩展点： 提供简单易用、完善的SPI扩展接口。可以通过实现扩展接口来快速的定制逻辑。如定制规则管理、老师陪动态数据源等。

4.4.2 微服务集成sentinel

4.4.2.1 在上游微服务（shop-order）中添加依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    <version>2.1.0.RELEASE</version>
</dependency>

4.4.2.2. 安装Sentinel控制台

sentinel提供一个轻量级的控制台，他提供机器发现、单机资源实时监控以及规则管理等功能

1. 下载jar包，解压到文件夹，下载地址
2. 启动控制台

java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard.jar

3. 访问localhost:8080，默认用户名和密码都是sentinel

4. 修改shop-order在里面加入有关控制台的配置

spring:
    cloud:
        sentinel:
          transport:
            port: 9999 # 跟控制台交流的端口，随意指定一个未使用的端口即可
            dashboard: localhost:8080 # 指定控制台服务的地址

注：sentinel控制台本质就是一个Springboot编写的程序，需要将我们的微服务程序注册到控制台上，即在微服务中指定控制台的地址，并且还要开一个跟控制台传递数据的端口，控制台也可以通过此端口调用微服务中的 监程序获取未付的各种信息

4.4.3 实现一个接口的限流

1. 在order微服务中添加测试方法

@GetMapping("/order/sayHello")
public String sayHello(){
    return "sayHello";
}

2. 通过控制台为sayHello方法添加一个流控规则
   

3. 设置每秒允许两个通过
   

4. 访问并观察结果
   

4.5 Sentinel的概念和功能

4.5.1 基本概念

• 资源

资源是Sentinel的关键概念，它可以四java应用程序中的任何内容，可以是一个服务，也可以是一个方法，甚至可以是一段代码。上面的sayHello就是一个资源

• 规则

作用在资源之上，定义以什么样的方式保护资源，主要包括流量控制规则、熔断降级规则以及系统保护规则，如上面的流控规则

4.5.2 重要功能

sentinel主要功能就是容错，主要体现为以下三个

• 流量控制

根据系统的处理能力对流量进行控制。sentinel作为一个调配器，可以根据需要把随机的请求调整成合适的形状

• 熔断降级

当检测到调用链中某个资源出现不稳定的表现，例如请求响应时间长或异常比例升高的时候，则对这个资源的调用进行限制，让请求快速失败，避免影响到其他的资源而导致级联故障

sentinel采取两种手段进行容错：

1.通过并发线程数进行限制

2.通过响应时间对资源进行降级

• 系统负载保护

sentinel提供系统维度的自适应保护能力。当系统负载较高时，若还持续让请求进入可能会导致系统崩溃，无法响应。在集群环境下，会把本应这台机器承载的流量转发到其他的机器上去。

4.6 Sentinel规则

4.6.1 流控规则

流量控制，其原理是监控应用流量的QPS（每秒查询率）或并发线程数等指标，当打到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用

4.6.1.1 流控规则-QPS

• 第一步：点击簇点链路，我们就可以看到访问过的接口地址，然后点击对应的流控按钮，进入流控规则配置页，新增流控规则界面如下：
  

• 第二步：配置每秒允许两次请求
  

4.6.1.2 流控规则-并发线程数

• 第一步：与上面一样，在第二步时选择线程数，再设置允许的线程数即可

4.6.2 流控模式

Sentinel共有三种流控模式，分别是：直接，关联，链路

1.直接：接口达到限流条件是，开启限流

2.关联：当关联的资源达到限流条件时，开启限流，该模式适合做应用让步

3.链路：当某个接口过来的资源达到限流条件时，开启限流

4.6.2.1 直接流控

直接流控是最简单的模式，当指定的接口打到限流条件时开启限流。上面案列使用的就是直接流控模式。

4.6.2.2 关联流控

关联流控模式指的是当指定接口关联的接口打到限流条件时，开启对指定接口开启限流。

• 第一步：配置限流规则，将流控模式设置为关联，关联资源设置为/order/prod/1
  

4.6.2.2 链路流控

链路流控指定是当从某个接口过来的资源达到限流条件时，开启限流。它的功能有点类似于针对来源配置项，区别在于：针对来源是针对上级微服务，而链路流控是针对上级接口，也就是说它的粒度更细

4.6.3 流控效果

• 快速失败（默认） ：直接失败，抛出异常，不做任何额外的处理，是最简单的效果
• Warm Up ：他从开始阈值到最大QPS阈值会有一个缓冲阶段，一开始的阈值是最大QPS的1/3，然后慢慢增长，直到最大，适用于突然增大的流量转换为缓步增长的场景
• 排队等待 ：让请求以均匀的速度通过，单机阈值为每秒通过数量，其余的排队等待；它还会让设置一个超时时间，当请求超过超时时间还未处理，则会被丢弃

4.6.4 降级（熔断）规则

降级规则就是设置当满足什么条件时，对服务进行降级。

• Sentinel提供了如下三个衡量条件

1. 慢调用比例：当资源的平均响应时间查过阈值（以ms为单位）之后，资源进入准降级状态。若接下来1s内只需进入5个请求，他们的RT都持续超过这个阈值，name杰西莱的时间窗口（以s为单位）之内，就会对这个方法进行服务降级
   注：Sentinel默认统计的RT上限是4900ms，超出此阈值都会算作4900ms。若需要变更上限，可以通过情动配置项：-Dcsp.sentinel.statistic.max.rt=xxx来配置
2. 异常比例：当资源的每秒异常总数占通过量的比值超过阈值后，资源进入降级状态，即在接下的时间窗口（单位：s）之内，对这个方法的调用都会自动返回。异常比率的阈值返回是[0.0,1.0]
3. 当资源近1分钟的异常数目超过阈值后会进行服务降级。注意由于统计时间窗口是分钟级别的，若时间窗口小于60s，则结束熔断状态后人可能在进入熔断状态

4.6.4 热点规则

热点参数流控规则是一种更细粒度的流控规则，它允许讲规则具体到参数上

4.6.4.1 热点规则简单使用

1. 编写代码

@RestController
@Slf4j
public class OrderController {
 //省略上面的代码   
    
 @GetMapping("/order/sayHello2")
 @SentinelResource("sayHello2")//这里必须使用这个注解标识，否则热点规则不生效
 public String sayHello2(String name,Integer age){
  return name + age;
 }
}

2. 配置热点规则
   

3. 进一步细化热点规则，配置name参数为lisi时不限流
   

4.6.5 授权规则

很多时候，我们需要根据调用来源来判断该次请求是否允许放行，这时可以使用sentinel的来源访问控制的功能。来源访问控制根据资源的请求来源（origin）限制资源是否通过

• 若配置白名单，则只有请求来源位于白名单内是才可以通过
• 若配置和名单，则请求来源位于黑名单时不通过，其余的请求通过
  

4.6.5.1 授权规则实现

Sentinel提供了RequestOriginParser接口来处理来源，只要Sentinel保护的接口资源被访问，sentinel就会调用RequestOriginParser的实现类区解析访问来源

1. 自定义来源处理规则

package com.lm.shoporder.config;

import com.alibaba.csp.sentinel.adapter.servlet.callback.RequestOriginParser;
import com.alibaba.csp.sentinel.util.StringUtil;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;

@Component
public class RequestOriginParserDefinition implements RequestOriginParser {
    //定义区分来源：本质是通过request域获取到来源标识
    @Override
    public String parseOrigin(HttpServletRequest request) {
        String serverName = request.getParameter("serverName");
        if(StringUtil.isEmpty(serverName)){
            throw new RuntimeException("ServerName is empty");
        }
        return serverName;
    }
}

2. 配置允许访问的白名单，这里设置只允许serverName=app的客户端访问
   

3. 访问浏览器

• http://localhost:8091/order/sayHello2?serverName=PC 不允许通过
• http://localhost:8091/order/sayHello2?serverName=app 允许通过
  

4.6.6 系统规则

系统保护规则是从应用级别的入口流量进行控制，从单台机器的总体Load,RT、入口QBS、CUP使用率和线程数五个维度监控应用数据，让系统尽可能泡在最大吞吐量的同时保证
系统整体的稳定性。系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量（进入应用的流量）

• Load(仅对Linux/Unix-like机器生效)：当系统load1超过阈值，且系统当前的并发线程数超过系统容量时才会触发系统保护，系统容量有系统maxQps*minRt计算得出。设定参考值一般是CPU cores * 2.5。
• RT：当单台机器上所有入口流量的平均RT达到阈值即触发系统保护
• 线程数：当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护
• 入口QPS：当单台机器上所有入口流量的QPS达到阈值即触发系统保护
• CPU使用率：当单台机器上所有入口流量的CPU使用率达到阈值即触发系统保护

4.6.7 触发规则后自定义返回提示

package com.lm.shoporder.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ResponseData {
    private int code;
    private String message;
}

package com.lm.shoporder.config;

import com.alibaba.csp.sentinel.adapter.servlet.callback.UrlBlockHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
import com.alibaba.fastjson.JSON;
import com.lm.shoporder.entity.ResponseData;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

//自定义异常返回
@Component
public class ExceptionHandlerPage implements UrlBlockHandler {
    @Override
    public void blocked(HttpServletRequest httpServletRequest, HttpServletResponse response, BlockException e) throws IOException {
        response.setContentType("application/json;charset=utf-8");
        ResponseData responseData = null;
        if(e instanceof FlowException){//系统限流异常
            responseData = new ResponseData(-1,"接口被限流了");
        }else if(e instanceof DegradeException){
            responseData = new ResponseData(-2,"接口被降级了");
        }else if(e instanceof ParamFlowException){
            responseData = new ResponseData(-3,"接口参数异常");
        }else if(e instanceof AuthorityException){
            responseData = new ResponseData(-4,"接口未被授权");
        }else if(e instanceof SystemBlockException){
            responseData = new ResponseData(-5,"系统负载异常");
        }
        response.getWriter().write(JSON.toJSONString(responseData));
    }
}

4.7 @SentinelResource的使用

在定义了资源点后，我们可以通过Dashboard来设置限流和降级策略来对资源点进行保护。同时还能通过@SentinelResource来指定出现异常是的处理策略
@SentinelResource用于定义资源，并提供可选的异常处理和fallBack配置项。

主要配置参数

属性	作用
valu	资源名称
entryType	entry类型，标记流量的方向，取值IN/OUT,默认OUT
blockHandler	处理BlockException的函数名称，函数要求：1. 必须是public。2. 返回类型参数与原方法一致。3. 默认需和原方法在同一个类中，若要使用其他类的函数，可以配置blockHandlerClass，并指定blockHandlerClass里面的方法
blockHandlerClass	存放blockHandler的类，对应的处理函数必须static修饰
fallback	处理Throwable的函数名称

4.7.1 示例

@RestController
@Slf4j
public class OrderController {

    //省略。。

    @GetMapping("/order/sayHello2")
    @SentinelResource(value = "sayHello2",
            blockHandler = "blockHandler",
            fallback = "fallback"
    )//这里必须使用这个注解标识，否则热点规则不生效
    public String sayHello2(String name,Integer age){
        return name + age;
    }

    /**
     * blockHandler
     * 要求：
     *  1.当前方法的返回值和参数要和原方法一致
     *  2.但是运行在参数列表的最后一个参数后加一个BlockException类型的参数，用来接受原方法中的发生的异常
     * @return
     */
    public String blockHandler(String name, Integer age, BlockException e){
        log.error("触发了BlockException,内容为{}",e);
        return "BlockException";
    }

    /**
     * fallback方法
     * 要求：
     *  1.当前方法的返回值和参数要和原方法一致
     *  2.但是运行在参数列表的最后一个参数后加一个Throwable类型的参数，用来接受原方法中的发生的异常
     * @return
     */
    public String fallback(String name, Integer age, Throwable e){
        log.error("触发了Throwable异常,内容为{}",e);
        return "Throwable";
    }
}

4.7.2 Sentinel规则持久化

上述规则配置只存在内存中，不稳定，所以需要将其持久化。
本地文件数据源会定时轮询文件的变更，读取规则。这样我们既可以在应用本地直接修改文件来更新规则，也可以通过sentinel控制台推送规则。以本地数据源为例，推送过程如下所示：

首先Sentinel控制台通过API将规则推送至客户端并更新到内存中，接着注册的写数据源会将新的规则保存到本地的文件中。

1. 编写代码

package com.lm.shoporder.config;

import com.alibaba.csp.sentinel.command.handler.ModifyParamFlowRulesCommandHandler;
import com.alibaba.csp.sentinel.datasource.*;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRuleManager;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;
import com.alibaba.csp.sentinel.transport.util.WritableDataSourceRegistry;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.springframework.beans.factory.annotation.Value;

import java.io.File;
import java.io.IOException;
import java.util.List;

public class FilePersistence implements InitFunc {

    @Value("spring.application.name")
    private String applicationName;

    @Override
    public void init() throws Exception {
        // TIPS: 如果你对这个路径不喜欢，可修改为你喜欢的路径
        String ruleDir = System.getProperty("user.home") + "/sentinel/rules/" + applicationName;
        // 流控规则
        String flowRulePath = ruleDir + "/flow-rule.json";
        // 降级规则
        String degradeRulePath = ruleDir + "/degrade-rule.json";
        // 系统规则
        String systemRulePath = ruleDir + "/system-rule.json";
        // 授权规则
        String authorityRulePath = ruleDir + "/authority-rule.json";
        // 参数热点规则
        String paramFlowRulePath = ruleDir + "/param-flow-rule.json";

        this.mkdirIfNotExits(ruleDir);
        this.createFileIfNotExits(flowRulePath);
        this.createFileIfNotExits(degradeRulePath);
        this.createFileIfNotExits(systemRulePath);
        this.createFileIfNotExits(authorityRulePath);
        this.createFileIfNotExits(paramFlowRulePath);

        // 流控规则
        ReadableDataSource<String, List<FlowRule>> flowRuleRDS = new FileRefreshableDataSource<>(
                flowRulePath,
                flowRuleListParser
        );
        // 将可读数据源注册至FlowRuleManager
        // 这样当规则文件发生变化时，就会更新规则到内存
        FlowRuleManager.register2Property(flowRuleRDS.getProperty());
        WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(
                flowRulePath,
                this::encodeJson
        );
        // 将可写数据源注册至transport模块的WritableDataSourceRegistry中
        // 这样收到控制台推送的规则时，Sentinel会先更新到内存，然后将规则写入到文件中
        WritableDataSourceRegistry.registerFlowDataSource(flowRuleWDS);

        // 降级规则
        ReadableDataSource<String, List<DegradeRule>> degradeRuleRDS = new FileRefreshableDataSource<>(
                degradeRulePath,
                degradeRuleListParser
        );
        DegradeRuleManager.register2Property(degradeRuleRDS.getProperty());
        WritableDataSource<List<DegradeRule>> degradeRuleWDS = new FileWritableDataSource<>(
                degradeRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerDegradeDataSource(degradeRuleWDS);

        // 系统规则
        ReadableDataSource<String, List<SystemRule>> systemRuleRDS = new FileRefreshableDataSource<>(
                systemRulePath,
                systemRuleListParser
        );
        SystemRuleManager.register2Property(systemRuleRDS.getProperty());
        WritableDataSource<List<SystemRule>> systemRuleWDS = new FileWritableDataSource<>(
                systemRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerSystemDataSource(systemRuleWDS);

        // 授权规则
        ReadableDataSource<String, List<AuthorityRule>> authorityRuleRDS = new FileRefreshableDataSource<>(
                authorityRulePath,
                authorityRuleListParser
        );
        AuthorityRuleManager.register2Property(authorityRuleRDS.getProperty());
        WritableDataSource<List<AuthorityRule>> authorityRuleWDS = new FileWritableDataSource<>(
                authorityRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerAuthorityDataSource(authorityRuleWDS);

        // 热点参数规则
        ReadableDataSource<String, List<ParamFlowRule>> paramFlowRuleRDS = new FileRefreshableDataSource<>(
                paramFlowRulePath,
                paramFlowRuleListParser
        );
        ParamFlowRuleManager.register2Property(paramFlowRuleRDS.getProperty());
        WritableDataSource<List<ParamFlowRule>> paramFlowRuleWDS = new FileWritableDataSource<>(
                paramFlowRulePath,
                this::encodeJson
        );
        ModifyParamFlowRulesCommandHandler.setWritableDataSource(paramFlowRuleWDS);
    }

    private Converter<String, List<FlowRule>> flowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<FlowRule>>() {
            }
    );
    private Converter<String, List<DegradeRule>> degradeRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<DegradeRule>>() {
            }
    );
    private Converter<String, List<SystemRule>> systemRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<SystemRule>>() {
            }
    );

    private Converter<String, List<AuthorityRule>> authorityRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<AuthorityRule>>() {
            }
    );

    private Converter<String, List<ParamFlowRule>> paramFlowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<ParamFlowRule>>() {
            }
    );

    private void mkdirIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.mkdirs();
        }
    }

    private void createFileIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.createNewFile();
        }
    }

    private <T> String encodeJson(T t) {
        return JSON.toJSONString(t);
    }

}

2. 添加配置

在resources下创建配置目录META-INF/services，然后添加文件com.alibaba.csp.sentinel.init-InitFunc,后再文件中添加配置类的全路径

4.8 Feign整合Sentinel

1. 引入sentinel依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

2. 在配置文件(application.yaml)中开启Feign对sentinel的支持

feign:
  sentinel:
    enabled: true

3. 创建容错类

package com.lm.shoporder.service.impl;

import com.lm.shopcommon.domain.Product;
import com.lm.shoporder.service.ProductService;
import org.springframework.stereotype.Component;

@Component
public class ProductServiceFallBack implements ProductService {
    @Override
    public Product findProductByPid(Integer pid) {
        Product product = new Product();
        product.setPid(1);
        product.setPname("容错类的数据");
        return product;
    }
}

4. 为被容器的接口指定容错类

import com.lm.shopcommon.domain.Product;
import com.lm.shoporder.service.impl.ProductServiceFallBack;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

//指定要调用的微服务名称
// fallback用于指定容错类，发生容错是会找到容错类的重载方法,执行容错逻辑
@FeignClient(value = "service-product",fallback = ProductServiceFallBack.class)
public interface ProductService {

    @GetMapping("/product/{pid}")//使用springmvc提供的注解指定URI部分
    Product findProductByPid(@PathVariable("pid") Integer pid);

}

4.9 实现FallbackFactory容错获取异常

1. 编写容错类

package com.lm.shoporder.service.impl;
import com.lm.shopcommon.domain.Product;
import com.lm.shoporder.service.ProductService;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;
@Component
public class ProductServiceFallbackFactory implements FallbackFactory<ProductService> {
    @Override
    public ProductService create(Throwable throwable) {
        return new ProductService() {
            @Override
            public Product findProductByPid(Integer pid) {
                //打印异常
                throwable.printStackTrace();
                Product product = new Product();
                product.setPid(1);
                product.setPname("容错类的数据");
                return product;
            }
        };
    }
}

2.修改服务调用接口

//指定fallbackFactory容错类，
@FeignClient(value = "service-product",fallbackFactory = ProductServiceFallbackFactory.class)
public interface ProductService {

    @GetMapping("/product/{pid}")//使用springmvc提供的注解指定URI部分
    Product findProductByPid(@PathVariable("pid") Integer pid);

}