【2.1】Java微服务:详解Hystrix

这篇具有很好参考价值的文章主要介绍了【2.1】Java微服务:详解Hystrix。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

 ✅作者简介:大家好,我是 Meteors., 向往着更加简洁高效的代码写法与编程方式,持续分享Java技术内容。
🍎个人主页:Meteors.的博客
💞当前专栏: Java微服务
✨特色专栏: 知识分享
🥭本文内容:【2.1】Java微服务:详解Hystrix
📚 ** ps **  : 阅读这篇文章如果有问题或者疑惑,欢迎各位在评论区提问或指出!

 -----------------------------------------------------       目录       ---------------------------------------------------------

目录

 一、基本介绍

1. 基本介绍

2. 实现原理

二、相关功能

1. 请求缓存

概述

缺点

Redis的方式

1) 导入依赖

2) 添加配置文件

3) 增加Redis 配置

4)增加缓存注解

5) 接口实现类增加缓存注解

6)结果

2. 请求合并实现

1). pom文件添加依赖

2). 在实现类进行请求合并

3)开启熔断注解

4)模拟同时发起多个请求

3.线程池隔离

1)介绍

2)优点

3)缺点

4)代码示例

4. 信号量隔离

1)介绍

2)代码示例

3) 线程池颗粒与信号隔离对比

5.服务熔断

1)介绍

2)调用

 其他

 参考文献:


---------------------------------------------------------------------------------------------------------------------------------

 一、基本介绍

1. 基本介绍

Hystix是一个延迟和容错库,旨在隔离对远程系统、服务和第三方库的访问点,停止级联故障,并在不可避免发生故障的复杂分布式系统中实现快速恢复。主要靠Spring的AOP实现


2. 实现原理

  • 正常情况下,断路器关闭,服务消费者正常请求微服务
  • 一段时间内,失败率达到一定阈值,断路器将断开,此时不在请求服务提供者,而只是快速失败的方法(断路方法)
  • 断路器打开一段时间,自动进入“半开”状态,此时,断路器可允许一个请求方法服务提供者,如果请求调用成功,则关闭断路器,否则将保持断路器打开状态

断路器hystrix是保证了局部发生的错误,不会错扩展到整个系统, 从而保证系统 的即便出现局部问题也不会造成系统雪崩

二、相关功能

1. 请求缓存

概述

Hystirx为了降低访问服务的评率,支持将一个q8ingqiu与返回接口做缓存处理。如果再次请求的URL没有变化,nameHystrix不会请求服务,而是直接从请求中将结果放回。这样可以大大降低访问服务的压力。

缺点

  • 本地缓存,集群模式下缓存无法同步
  • 不支持第三方缓存容器,如Redis、MemCache

(现在一般都是使用Redis集成方案)

Redis的方式

1) 导入依赖
        <!--  spring boot data redis 依赖  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--  commons-pool2 对象池依赖 1  -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
2) 添加配置文件
  # redis缓存
  redis:
    timeout: 10000 #设置连接超时时间
    host: 127.0.0.1
    port: 6379
    database: 0
    lettuce:
      pool:
        max-active: 8 # 最大连接数,默认8
        max-wait: 10000 # 最大连接阻塞时间,单位毫秒,默认-1
        max-idle: 200 #最大空闲连接,默认8
        min-idle: 5 #最小空闲连接默认 0
3) 增加Redis 配置
package cn.itmeteors.order.config;

/**
 * Redis 配置类
 */

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@Configuration
public class RedisConfig {

    // 重写 RedisTemplate 序列化
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 为 String 类型 key 设置序列化器
        template.setKeySerializer(new StringRedisSerializer());
        // 为 String 类型 value 设置序列化器
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 为 Hash 类型 key 设置序列化器
        template.setHashKeySerializer(new StringRedisSerializer());
        // 为 Hash 类型 value 设置序列化器
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    // 重写 Cache 序列化
    @Bean
    public RedisCacheManager redisCacheManager(RedisTemplate redisTemplate) {
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisTemplate.getConnectionFactory());
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                // 设置默认过期时间 30 min
                .entryTtl(Duration.ofMinutes(30))
                // 设置 key 和 value 的序列化
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getKeySerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getValueSerializer()));
        return new RedisCacheManager (redisCacheWriter, redisCacheConfiguration);
    }

}
4)增加缓存注解

【2.1】Java微服务:详解Hystrix,微服务,知识分享,java,微服务,hystrix

5) 接口实现类增加缓存注解
    @Cacheable(cacheNames = "orderService:order:select")
    public Order selectOrderById(Long orderId) {    // 调用list
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.利用RestTemplate发起http请求,查询用户
        // 2.1.url路径
        String url = "http://userservice/user/list";
        // 2.2.发送http请求,实现远程调用
        List<User> userList = restTemplate.getForObject(url, List.class);
        assert userList != null;
        order.setUser(userList);
        return order;
    }
6)结果

【2.1】Java微服务:详解Hystrix,微服务,知识分享,java,微服务,hystrix

2. 请求合并实现

1). pom文件添加依赖

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

2). 在实现类进行请求合并

【2.1】Java微服务:详解Hystrix,微服务,知识分享,java,微服务,hystrix

 3)开启熔断注解

@EnableCaching
// 开启熔断器注解 2 选 1,@EnableHystrix 封装了 @EnableCircuitBreaker
// @EnableHystrix
@EnableCircuitBreaker
@EnableFeignClients(clients = UserClient.class,defaultConfiguration = DefaultFeignConfiguration.class)
public class OrderApplication {

4)模拟同时发起多个请求

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.利用RestTemplate发起http请求,查询用户
        // 2.1.url路径
        String url = "http://userservice/user/1";
        String url2 = "http://userservice/user/2";
        String url3 = "http://userservice/user/3";
        String url4 = "http://userservice/user/4";
        String url5 = "http://userservice/user/5";
        // 2.2.发送http请求,实现远程调用
        Future<User> user = (Future<User>) restTemplate.getForObject(url, User.class);
        Future<User> user2 = (Future<User>) restTemplate.getForObject(url2, User.class);
        Future<User> user3 = (Future<User>) restTemplate.getForObject(url3, User.class);
        Future<User> user4 = (Future<User>) restTemplate.getForObject(url4, User.class);
        Future<User> user5 = (Future<User>) restTemplate.getForObject(url5, User.class);
        // 3.封装user到Order
        List<User> userList = new ArrayList<>(1);
        try {
            userList.add(user.get());
            userList.add(user2.get());
            userList.add(user3.get());
            userList.add(user4.get());
            userList.add(user5.get());
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
        order.setUser(userList);
        // 4.返回
        return order;
    }

3.线程池隔离

1)介绍

对调用的接口进行隔离,一个接口因为并发过高瘫痪时,掉用的另一个接口不会瘫痪

2)优点

  • 使用线程池隔离可以安全「隔离依赖的服务」,减少所依赖服务发生故障时的影响面。比如 A 服务发生异常,导致请求大量超时,对应的线程池被打满,这时并不影响 C、D 服务的调用。

  • 当失败的服务再次变得可用时,线程池将清理并立即恢复,而不需要一个长时间的恢复。

  • 独立的线程池「提高了并发性」

3)缺点

  • 请求在线程池中执行,肯定会带来任务调度、排队和上下文切换带来的 CPU 开销。

  • 因为涉及到跨线程,那么就存在 ThreadLocal 数据的传递问题,比如在主线程初始化的 ThreadLocal 变量,在线程池线程中无法获取。

4)代码示例

   // 声明需要服务容错的方法
    // 线程池隔离
    @HystrixCommand(groupKey = "order-userService-listPool",// 服务名称,相同名称使用同一个线程池
            commandKey = "getList",// 接口名称,默认为方法名
            threadPoolKey = "order-userService-listPool",// 线程池名称,相同名称使用同一个线程池
            commandProperties = {
                    // 超时时间,默认 1000ms
                    @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",
                            value = "5000")
            },
            threadPoolProperties = {
                    // 线程池大小
                    @HystrixProperty(name = "coreSize", value = "6"),
                    // 队列等待阈值(最大队列长度,默认 -1)
                    @HystrixProperty(name = "maxQueueSize", value = "100"),
                    // 线程存活时间,默认 1min
                    @HystrixProperty(name = "keepAliveTimeMinutes", value = "2"),
                    // 超出队列等待阈值执行拒绝策略
                    @HystrixProperty(name = "queueSizeRejectionThreshold", value = "100")
            }, fallbackMethod = "selectUserListFallback")
    public List<User> getList() {
        return userMapper.getAll();
    }

    // 托底数据
    private List<User> selectUserListFallback() {
        System.out.println("-----获得托底数据-----");
        return Arrays.asList(
                new User(1L, "A", "地点1"),
                new User(2L, "B", "地点2"),
                new User(3L, "C", "地点3")
        );
    }

4. 信号量隔离

1)介绍

每次调用线程,当前请求通过计数信号量进行限制,当信号量大于了最大请求数 maxConcurrentRequests 时,进行限制,调用 fallback 接口快速返回。信号量的调用是同步的,也就是说,每次调用都得阻塞调用方的线程,直到结果返回。这样就导致了无法对访问做超时(只能依靠调用协议超时,无法主动释放)

2)代码示例

// 声明需要服务容错的方法
    // 信号量隔离
    @HystrixCommand(commandProperties = {
            // 超时时间,默认 1000ms
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",
                    value = "5000"),
            // 信号量隔离
            @HystrixProperty(name = HystrixPropertiesManager.EXECUTION_ISOLATION_STRATEGY,
                    value = "SEMAPHORE"),
            // 信号量最大并发,调小一些方便模拟高并发
            @HystrixProperty(name = HystrixPropertiesManager.EXECUTION_ISOLATION_SEMAPHORE_MAX_CONCURRENT_REQUESTS,
                    value = "6")
    }, fallbackMethod = "selectUserListFallback")
    public List<User> getList() {
        return userMapper.getAll();
    }

    // 托底数据
    private List<User> selectUserListFallback() {
        System.out.println("-----获得托底数据-----");
        return Arrays.asList(
                new User(1L, "A", "地点1"),
                new User(2L, "B", "地点2"),
                new User(3L, "C", "地点3")
        );
    }

3) 线程池颗粒与信号隔离对比

隔离方式 是否支持超时 是否支持熔断 隔离原理 是否是异步调用 资源消耗
线程池隔离 支持 支持 每个服务单独用线程池 支持同步或异步
信号量隔离 不支持 支持 通过信号量的计数器 同步调用,不支持异步

5.服务熔断

1)介绍

服务熔断是一种机制,用于在出现服务故障、超时或异常情况时,阻止请求继续发送到故障的服务上。当达到一定的失败阈值时,熔断器会打开,后续的请求将被快速失败,而不再去调用故障的服务。当故障情况得到修复后,熔断器会尝试关闭,恢复对服务的正常调用。

2)调用

在上面的代码执行fallbackMethod就会执行服务熔断

 其他

除了上述功能,Hystrix还有实时监控、指标收集、恢复等功能,这里会留到后面的时候进行更新,大家如果现在要学习的话,可以从官网或其它地方得到相关的介绍和代码

 参考文献:

GitHub - Netflix/Hystrix: Hystrix is a latency and fault tolerance library designed to isolate points of access to remote systems, services and 3rd party libraries, stop cascading failure and enable resilience in complex distributed systems where failure is inevitable.Hystrix is a latency and fault tolerance library designed to isolate points of access to remote systems, services and 3rd party libraries, stop cascading failure and enable resilience in complex distributed systems where failure is inevitable. - GitHub - Netflix/Hystrix: Hystrix is a latency and fault tolerance library designed to isolate points of access to remote systems, services and 3rd party libraries, stop cascading failure and enable resilience in complex distributed systems where failure is inevitable.https://github.com/Netflix/Hystrix

 最后,

后续文章会陆续更新,希望文章对你有所帮助..!文章来源地址https://www.toymoban.com/news/detail-638095.html

到了这里,关于【2.1】Java微服务:详解Hystrix的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 微服务_Hystrix

    作用:防止服务雪崩 Hystrix是一个由Netflix开源的容错框架,它主要用于分布式系统中的服务间通信。Hystrix通过在调用服务的过程中添加各种容错机制,来保护系统免受服务故障或网络中断的影响,从而提高了系统的可靠性和弹性。Hystrix提供了许多功能,例如超时控制、断路

    2024年02月09日
    浏览(23)
  • 十一、Hystrix服务保护

    目录 服务雪崩相关概念简述 服务的雪崩效应 造成服务雪崩的原因 服务雪崩最终的结果 防止服务雪崩的方法 一、服务降级 1、引入Hystrix 服务保护依赖 2、基于注解@HystrixCommand使用Hystrix 2.1、在需要进行服务保护的方法上添加注解@HystrixCommand,并指定降级方法名称 2.2、编写降

    2024年02月05日
    浏览(24)
  • 服务熔断Hystrix入门

    在微服务架构中,一个请求需要调用多个服务是非常常见的。如客户端访问A服务,而A服务需要调用B服务,B服务需要调用C服务,由于网络原因或者自身的原因,如果B服务或者C服务不能及时响应,A服务将处于阻塞状态,直到B服务C服务响应。此时若有大量的请求涌入,容器的

    2024年02月03日
    浏览(42)
  • JAVA-spring boot 2.4.X报错Unable to find GatewayFilterFactory with name Hystrix

    网关升级spring boot项目后,启动网关报错,具体报错信息如下: 2021-12-06 09:06:25.335 ERROR 45102 --- [oundedElastic-3] reactor.core.publisher.Operators         : Operator called default onErrorDropped reactor.core.Exceptions$ErrorCallbackNotImplemented: java.lang.IllegalArgumentException: Unable to find GatewayFilterFactory with name

    2024年02月14日
    浏览(52)
  • Hystrix入门使用 服务熔断 服务降级 服务雪崩

    hystrix停止更新,理念优秀。 分布式系统面临的问题: 对于复杂的分布式体系,有数十个依赖,依赖不可避免的错误。 服务会出现雪崩, 高可用受到破坏 。 Hystrix就是用于解决分布式系统延迟和容错的开源库。 保证在一个依赖出现问题,不会导致整体的服务失败,避免级联故

    2024年02月07日
    浏览(49)
  • 【Spring Cloud系列】Hystrix应用详解

    在一个分布式系统中,每个服务都可能会调用其它的服务器,服务之间是相互调用相互依赖。假如微服务A调用微服务B和微服务C,微服务B和微服务C又调用其他的微服务。这就是构成所谓“扇出”。 如果扇出的链路上某个微服务的调用响应的时间过长或者不可用,对微服A的调

    2024年02月16日
    浏览(56)
  • 微服务 – Spring Cloud – Hystrix

    hystrix是Netlifx开源的一款容错框架,防雪崩利器,具备服务降级,服务熔断,依赖隔离,监控(Hystrix Dashboard)等功能。 Hystrix is no longer in active development, and is currently in maintenance mode. Hystrix 已经停更 服务降级 服务熔断 服务限流 服务超时 服务宕机(服务崩掉、机房断电、服务故

    2024年02月11日
    浏览(46)
  • SpringCloud(四)Hystrix服务降级、熔断、监控页面

    官方文档:https://cloud.spring.io/spring-cloud-static/spring-cloud-netflix/1.3.5.RELEASE/single/spring-cloud-netflix.html#_circuit_breaker_hystrix_clients 我们知道,微服务之间是可以进行相互调用的,那么如果出现了下面的情况会导致什么问题? 由于位于最底端的服务提供者E发生故障,那么此时会直接导

    2024年02月17日
    浏览(57)
  • 微服务:Springboot集成Hystrix实现熔断、降级、隔离

    在分布式微服务的项目中,常常会有多个服务复用,产生多个服务调用的情况。比如A服务调用B服务,B服务调用C服务。服务调用链路长了必然会增加服务超时的概率,服务的超时阻塞会一直占用线程资源,大量的阻塞会直接消耗完服务线程,严重情况下会导致服务直接宕机从

    2024年02月12日
    浏览(48)
  • 十二、Feign客户端整合Hystrix服务保护

    目录 1、项目pom文件中引入feign客户端依赖 2、编写feign客户端接口,并配置fallback回调方法的类 3、编写controller,使用feign客户端进行RPC远程过程调用

    2024年02月05日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包