OpenFeign的使用和Hystrix断路器

最新推荐文章于 2024-07-17 15:56:57 发布
最新推荐文章于 2024-07-17 15:56:57 发布
阅读量712 收藏
点赞数
分类专栏： 框架结构 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XinRu_0126/article/details/112849467
版权

一.使用Open Feign

1.新建一个消费者模块，feign自带负载均衡配置，所以不用手动配置。
2.导入相关依赖。

<dependencies>
    <!-- Open Feign -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <!-- eureka Client -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <groupId>com.krisswen.cloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

3.编写相关的.yml的配置文件

server:
  port: 80
spring:
  application:
    name: cloud-consumer-feign-service
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

4.编写启动类，启动类名称要见名知意。

@SpringBootApplication
@EnableFeignClients //开启使用feign客户端的功能
public class CustomerFeignMain80 {
    public static void main(String[] args) {
        SpringApplication.run(CustomerFeignMain80.class,args);
    }
}

5.编写feign的客户端，在跟启动类同级的目录下建一个client的目录用于创建客户端。

@FeignClient(value = "cloud-payment-service") //标识当前接口就是一个feign客户端,并且指定调用哪一个微服务
public interface PaymentFeignService {
    @GetMapping("payment/{id}")
    public CommonResult<Payment> findPaymentById(@PathVariable("id") Long id);
}

6.编写Controller层

@RestController
public class CustomerFeignController {

    @Autowired
    PaymentFeignService paymentFeignService;

    @GetMapping("consumer/feign/payment/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
        return paymentFeignService.getPaymentById(id);
    }
}

二.超时控制

手动模拟出现超时时间。
1.在提供方8001的Controller里面定义一个方法

//故意模拟服务超时
@GetMapping("payment/timeout")
    public String testTimeOut(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "这是一个模拟超时的服务......";
    }

2.在feign的客户端里面定义两个没有方法体的方法：

	@GetMapping("payment/{id}")
    public CommonResult<Payment> findPaymentById(@PathVariable("id") Long id);

    @GetMapping("payment/timeout")
    public String testTimeOut();

3.在Controller层里面的类中定义下列方法，

	//@SuppressWarnings("all")该注解在类可以自动注入的压制误报
	@Autowired
    OrderFeignClient orderFeignClient;

    @GetMapping("order/feign/{id}")
    public CommonResult<Payment> findById(@PathVariable("id") Long id){
        CommonResult<Payment> commonResult = this.orderFeignClient.findPaymentById(id);
        return commonResult;
    }

    //调用超时的服务
    @GetMapping("order/feign/timeout")
    public String testTimeOut(){
        return this.orderFeignClient.testTimeOut();
    }

4.测试
4.1首先我们直接访问8001服务中的testTimeOut方法，
4.2然后通过feign客户端类访问
5.为了避免出现调用超时的情况，我们需要在消费者的配置文件里面配置超时时间(注意！有的电脑只用配置ribbon就能使用，大部分电脑都需要二者都要配置，极少数的只用配置ribbon即可。)

feign:
  client:
    config:
      default:
        readTimeout: 5000
        connectTimeout: 5000
ribbon: #设置Feign客户端调用超时时间
  ReadTimeOut: 5000 #指的是建立连接所需要的的时间
  ConnectTimeOut: 5000 #指的是建立连接之后，服务器读取资源需要的时间

Open Feign日志打印

1.在消费方编写一个配置类

@Configuration
public class FeignConfig {
    @Bean
    Logger.Level feignLoggerLevel(){
        return Logger.Level.FULL;
    }
}

2.在yml的配置文件中添加

logging:
  level:
    com.baidu.service.PaymentFeignService: debug

注意！“com.baidu.service.PaymentFeignService”该路径以自己包下路径为主
3.启动测试，并查看控制台是否打印。

Hystrix断路器

1.新建一个提供者子模块
2.引入pom文件

<dependencies>
    <!-- hystrix -->
<!--
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>
-->
    <!--eureka-client-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <groupId>com.krisswen.cloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

注意，hystrix依赖先注释，待进行熔断操作时再放开加载
3.编写yml配置文件

server:
  port: 8001
spring:
  application:
    name: cloud-payment-service  #服务名称
eureka:
  client:
    # 注册进 Eureka 的服务中心
    register-with-eureka: true
    # 检索 服务中心 的其它服务
    fetch-registry: true
    service-url:
      # 设置与 Eureka Server 交互的地址
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

4.编写启动类

@SpringBootApplication
//@DiscoveryClient
public class HystrixPaymentApplication {
    public static void main(String[] args) {
        SpringApplication.run(HystrixPaymentApplication.class,args);
    }
}

5.编写service

@Service
public class PaymentService {

    /**
     * 可以正常访问的方法
     * @param id
     * @return
     */
    public String paymentInfo_Ok(Integer id){
        return "线程池：" + Thread.currentThread().getName() + "  ，paymentInfo_OK，id:" + id;
    }

    /**
     超时访问的方法
     */
    public String paymentInfo_Timeout(Integer id){
        int interTime = 3;
        try{
            TimeUnit.SECONDS.sleep(interTime);
        }catch (Exception e){
            e.printStackTrace();
        }
        return "线程池：" + Thread.currentThread().getName() + "  ，paymentInfo_Timeout，id:" + id + "耗时" + interTime + "秒钟";
    }
}

6编写Controller层

@RestController
@Slf4j
public class PaymentController {

    @Autowired
    PaymentService paymentService;

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/payment/hystrix/{id}")
    public String paymentInfo_OK(@PathVariable("id")Integer id){
        log.info("paymentInfo_OKKKKOKKK");
        return paymentService.paymentInfo_Ok(id);
    }

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_Timeout(@PathVariable("id")Integer id){
        log.info("paymentInfo_timeout");
        return paymentService.paymentInfo_Timeout(id);
    }
}
// localhost:8001/payment/hystrix/1   localhost:8001/payment/hystrix/timeout/1

7.启动测试，查看两个方法都是否能被正常访问

localhost:8001/payment/hystrix/1
localhost:8001/payment/hystrix/timeout/1

模拟高并发

1.要有一个JMeter压力测试其。
2.有压缩包，直接解压，双击/bin/jmeter.bat即可启动。
3.进入内部，左上方操作"测试计划–>添加–>线程(用户)–>线程组"。
4.编写线程组名称，下方输入线程数，时间(秒)，循环次数
5.设置http请求，ctrl+s保存当前线程。
6.分别访问service服务里面的两个方法。
7.定义hystrix消费方的模块。
8.引入依赖

<dependencies>
    <!-- hystrix -->
   <!-- <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>-->
    <!-- OpenFeign -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <!--eureka-client-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <groupId>com.krisswen.cloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

9.编写yml配置文件

server:
  port: 80
spring:
  application:
    name: cloud-customer-feign-hystrix-service
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

10.编写启动类

@SpringBootApplication
//@DiscoveryClient
@EnableFeignClients //开启Feign客户端
public class HystrixOrderApplication80 {
    public static void main(String[] args) {
        SpringApplication.run(HystrixOrderApplication80.class,args);
    }
}

11.编写feign客户端

@Component
@FeignClient(value = "cloud-payment-service")
public interface OrderService {

    @GetMapping("/payment/hystrix/{id}")
    public String paymentInfo_OK(@PathVariable("id")Integer id);

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_Timeout(@PathVariable("id")Integer id);
}

12.编写Controller

@RestController
@Slf4j
public class OrderController {

    @Autowired
    OrderService orderService;

    @GetMapping("/consumer/payment/hystrix/{id}")
    public String paymentInfo_OK(@PathVariable("id")Integer id){
        log.info("paymentInfo_OKKKKOKKK");
        return orderService.paymentInfo_OK(id);
    }

    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    public String paymentInfo_Timeout(@PathVariable("id")Integer id){
        log.info("paymentInfo_timeout");
        return orderService.paymentInfo_Timeout(id);
    }
}

13.启动测试，使用jmeter压测攻击模拟高并发。

局部服务降级(提供方)

1.再8001服务的提供方，放开Hysetix依赖

<!-- hystrix -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

2.对8001的service进行重新配置

@Service
public class PaymentService {

    /**
     * 可以正常访问的方法
     * @param id
     * @return
     */
    public String paymentInfo_Ok(Integer id){
        return "线程池：" + Thread.currentThread().getName() + "  ，paymentInfo_OK，id:" + id;
    }

    /**
     超时访问的方法
     */
    @HystrixCommand(fallbackMethod = "timeoutHandler",commandProperties = {
            //设置峰值，超过 3 秒，就会调用兜底方法，这个时间也可以由feign控制
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "3000")
    })
    public String paymentInfo_Timeout(Integer id){
        int interTime = 5;
        //int i = 10/0;
        try{
            TimeUnit.SECONDS.sleep(interTime);
        }catch (Exception e){
            e.printStackTrace();
        }
        return "线程池：" + Thread.currentThread().getName() + "  ，paymentInfo_Timeout，id:" + id + "耗时" + interTime + "秒钟";
    }
   // 定义服务出现异常之后，兜底的方法
    public String timeoutHandler(Integer id){
        return "服务异常，请重试......";
    }
}

3.在启动类上开启服务熔断的注解

@EnableCircuitBreaker //开启服务熔断

4.启动8001服务测试。
5.改动服务方里面的代码进行测试。

局部服务降级(消费方)

1.将服务提供方关于所有服务降级的设置全部去掉
2.在消费放引入hystrix依赖(放开注释即可)

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

3.在启动类上开启服务熔断

@EnableCircuitBreaker//开启熔断器

4.在Controller编写降级逻辑

@RestController
@Slf4j
@SuppressWarnings("all")
public class OrderController {
    @Autowired
    OrderService orderService;
    @GetMapping("/consumer/payment/hystrix/{id}")
    public String paymentInfo_OK(@PathVariable("id")Integer id){
        log.info("paymentInfo_OKKKKOKKK");
        return orderService.paymentInfo_OK(id);
    }
    @HystrixCommand(fallbackMethod = "handeException", commandProperties = {
            //设置峰值，超过 1.5 秒，就会调用兜底方法
            @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds", value = "1500")
    })
    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    public String paymentInfo_Timeout(@PathVariable("id")Integer id){
        log.info("paymentInfo_timeout");
        return orderService.paymentInfo_Timeout(id);
    }

    public String handeException(Integer id){
        return "服务调用异常，请稍后再试.....";
    }
}

5.启动测试。
6.修改，然后再启动测试看是成功。

傻洋~胖妞
关注
专栏目录
spring-cloud-starter-openfeig断路器实现
奋斗中的老青年
03-19 538
依赖： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> 相对于Ribbon搭配使用来说，Feign实现...
Hystrix案例
m0_54444927的博客
01-19 200
新建提供者cloud-provider-hystrix-payment8001模块： 引入POM文件 <!--eureka-client--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </depend
Spring-cloud-openfeign-@FeignClient中的configuration属性
最新发布
文天大人
07-17 497
喜欢江浙妹子，热爱湘鄂妹子
微服务之Openfeign,Hystrix
qq_45595142的博客
06-24 3427
Openfeign 算是 Ribbon（负载均衡）和RestTemplate（服务和服务之间调用）的结合体。 客户端使用restTemplate的 getForObject方法去调用服务端的方法 @GetMapping("/consumer/payment/get/{id}") public CommonResult<Payment> getPayment(@PathVariable("id") Long id) { return restTemplate.g
Hystrix与OpenFeign集成（二）
ningmeng666_c的博客
05-22 1800
1.服务熔断的实现 0.服务熔断的实现思路 引入hystrix依赖，并开启熔断器（断路器） 模拟降级方法 进行调用测试 1.项目中引入hystrix 依赖（openFeign依赖中已经依赖了hystrix依赖，但是需要在配置文件中开启hystrix依赖） <!-- 引入hystrix--> <dependency> <groupId>org.springframework.cloud</groupId> &l
spring-cloud系列之——OpenFeign+Hystrix（断路器）
gu_zhang_w的博客
04-06 3670
一、为什么要使用OpenFeign 作为Spring Cloud的子项目之一，Spring Cloud OpenFeign以将OpenFeign集成到Spring Boot应用中的方式，为微服务架构下服务之间的调用提供了解决方案。首先，利用了OpenFeign的声明式方式定义Web服务客户端；其次还更进一步，通过集成Ribbon或Eureka实现负载均衡的HTTP客户端。 二、为什么要使用Hyst...
Hystrix断路器详解
这很张扬的博客
05-20 902
分布式系统面临的问题: 复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免地失败。 服务雪崩： 多个微服务之间调用的时候，假设微服务A调用微服务B和微服务C，微服务B和微服务C又调用其它的微服务，这就是所谓的“扇出”。如果扇出的链路上某个微服务的调用响应时间过长或者不可用，对微服务A的调用就会占用越来越多的系统资源，进而引起系统崩溃，所谓的“雪崩效应”. 对于高流量的应用来说，单一的后端依赖可能会导致所有服务器上的所有资源都在几秒钟内饱和。比失败更糟糕的是，这些应用程序
SpringCloudNetflix中 ：OpenFeign的使用、Hystrix的使用、zuul网关的使用
qqjiayoua的博客
07-22 208
Feign是一个声明式的http客户端，使用Feign可以实现声明式REST调用，它的目的就是让Web Service调用更加简单。），如果参数多了就拼接就非常繁琐，代码不优雅，效率低下。Fegin基于Ribbon进行了封装，把一些负责的url和参数处理细节屏蔽起来 因此使用Fegin服务调用方式来进行远程微服务调用就会显得代码更优雅，效率更高。我们在使用Ribbon作为客户端负载均衡完成订单服务和用户服务的通讯，通过RestTemplate调用其它服务时，所需要的参数须在请求的URL中进行拼接 （
Hystrix断路器的概述与案例使用详解
weixin_62661659的博客
04-25 406
一、Hystrix概述 官网：https://github.com/Netflix/Hystrix/wiki/How-To-Use 1.是什么？ Hystrix是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时、异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性。 “断路器”本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险丝），向调用方返回一个符合预期的、可处理
OpenFeign和Hystrix
weixin_52883641的博客
01-19 1165
学习内容： 一.使用openFeign 1.创建模块 2.导入依赖 <dependencies> <!-- Open Feign --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> &l
Spring Cloud(Finchley版本)系列教程(四) 断路器(Hystrix)
JingLisen的博客
03-20 96
开源的一款容错框架，防雪崩利器，具备服务降级，服务熔断，依赖隔离，监控(Hystrix Dashboard)等功能。hystrix是一个库，通过延迟容忍和容错逻辑，控制分布式服务之间的交互。它通过隔离服务间的访问点、防止级联失败和提供回退选项，保证系统的整体弹性。修改项目端口号为8009，重启项目，调用。一个项目，其余项目都没运行，因此触发了。接口，用于处理调用失败的回调。接口是停掉的，也就成功返回了。，可以看到ping的信息。，并让它注入到容器中。类中的消费接口，增加。注解，并指定回调方法。
OpenFeign+Hystrix 熔断器
m0_56353506的博客
05-31 636
OpenFeign是一个基于Java的声明式HTTP客户端，主要用于简化编写基于RESTful服务的客户端代码。它允许开发人员通过接口和注解的方式来定义和描述RESTful服务的调用，从而避免了手动编写大量的HTTP请求和参数处理代码。声明式RESTful服务调用：通过定义接口和使用注解，开发人员可以方便地描述RESTful服务的调用方式，包括URL、HTTP方法、请求参数等。
在 OpenFeign 中使用 Hystrix
豆恭梓的博客
07-06 394
当有服务调用的时候，才会出现服务雪崩，所以 Hystrix 常和 OpenFeign，Ribbon 一起出现。
OpenFeign+Hystrix
qq_52664268的博客
04-25 287
Component // 将托底类交给spring管理，否则Hystrix无法进行调用@Overridelog.error("此服务不可用!");//托底数据return new User(-1L,"无此用户！用户服务不可用~");
openfeign+hystrix
qiumin的博客
04-08 3999
openfeign+hystrix+eureka+ribbon 服务降级、负载均衡、客户端远程调用、注册中心
openfeign整合hystrix
zj202002的博客
10-21 243
简而言之，一个是工厂 一个是fallback。有两种方案，一定要注意两者的区别，不然会报错。就是降级的类型要选对 工厂对工厂 类对类。
Spring Cloud Learning | 第六篇：在Feign中使用断路器
嵩园
01-22 988
一. 准备工作       在上一篇文章我们已经了解了怎么在Ribbon中使用断路器，而在实际工作中我们更多的是使用Feign，所以我们也需要知道如何在Feign中使用断路器。       首先准备好第四篇文章里的项目工程，同样启动eureka-server和eureka-client工程，端口号分别为8761和8762。 二. 快速入门       Feign是自带断路器的，所以不需要再
OpenFeign的使用--Hystrix的使用--Zuul网关的使用
qq_49195366的博客
10-18 1214
OpenFeign的使用–Hystrix的使用–Zuul网关的使用
SpringBoot集成OpenFeign+ Hystrix
AG.『Feng』的博客
11-05 1149
SpringBoot集成OpenFeign+ Hystrix实现服务熔断
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值