SpringCloud学习笔记（五）（狂神视频笔记）

最新推荐文章于 2024-10-09 11:50:38 发布
最新推荐文章于 2024-10-09 11:50:38 发布
阅读量109 收藏 1
点赞数 1
文章标签： spring java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hexinqiong/article/details/116399814
版权

SpringCloud（五）

6、Ribbon：负载均衡（基于客户端）

6.1 负载均衡以及Ribbon

  1. Ribbon是什么？

    • Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。
    • 简单地说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon的客户端组件提供一系列完整的配置项，如：连接超时、重试等。简单地说，就是在配置文件中列出 LoadBalancer（简称LB：负载均衡）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随即连接等等）去连接这些机器。我们也容易使用该Ribbon实现自定义的负载均衡算法！

  2. Ribbon能干啥？

    • LB，即负载均衡（LoadBalancer），在微服务或分布式集群中经常使用的一种应用。

    • 负载均衡简单的说就是将用户的请求平摊到多个服务器上，从而达到系统的HA（高用）。

    • 常见的负载均衡软件有Nginx、Lvs等等。

    • Dubbo、SpringCloud中军给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义。

    • 负载均衡简单分类：

      • 集中式LB

        即在服务的提供方和消费方之间使用独立的LB设备，如Nginx：反向代理服务器，由该设备负责把访问请求通过某种策略转发至服务的提供方！

      • 进程式LB

        • 将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。
        • Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。

6.2集成Ribbon

  • springcloud-consumer-dept-80向pom.xml中添加Ribbon和Eureka依赖

        <!-- Ribbon -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-ribbon</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>

    <!--eureka-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>

  • 在application.yaml文件中配置Eureka

    # Eureka配置
eureka:
  client:
    register-with-eureka: false # 不向 Eureka注册自己
    service-url: # 从三个注册中心中随机取一个去访问
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

  • 在主启动类加上@EnableEurekaClient注解，开启Eureka

    @SpringBootApplication
@EnableEurekaClient //开启Eureka 客户端
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

  • 自定义Spring配置类：ConfigBean.java 配置负载均衡实现RestTemplate

    @Configuration
public class ConfigBean {   //Cofiguration -- spring applicationContext.xml

    @LoadBalanced //配置负载均衡实现RestTemplate
    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }   
}

  • 修改controller：DeptConsumerController.java

    //Ribbon:我们这里的地址，应该是一个变量，通过服务名来访问
//private static final String REST_URL_PREFIX = "http://localhost:8001";
private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

6.3 使用Ribbon实现负载均衡

流程图：

在这里插入图片描述

  1. 新建两个服务提供者的Moudle：springcloud-provider-dept-8003，springcloud-provider-dept-8002

  2. 参照springcloud-provider-dept-8001 依次为另外两个Moudle添加pom.xml依赖，resources下的mybatis和application.yaml配置Java代码。

  3. 启动所有服务器进行测试（根据自身电脑配置决定启动服务的个数），访问http://eureka7001.com:7002/查看结果

    在这里插入图片描述

    测试访问http://localhost/consumer/dept/list 这时候随机访问的是服务提供者8003

    在这里插入图片描述

    再次访问http://localhost/consumer/dept/list 这时候随机的是服务提供者8001

    在这里插入图片描述

    以上这种每次访问http://localhost/consumer/dept/list随机访问集群中某个服务提供者，这种情况叫做轮询，轮询算法在SpringCloud中可以自定义。

  4. 如何切换或自定义规则呢？

    在springcloud-provider-dept-80模块下的ConfigBean中进行配置，切换使用不同的规则

    @Configuration
public class ConfigBean {//@Configuration -- spring  applicationContext.xml

    /**
     * IRule:
     * RoundRobinRule 轮询策略
     * RandomRule 随机策略
     * AvailabilityFilteringRule ： 会先过滤掉，跳闸，访问故障的服务~，对剩下的进行轮询~
     * RetryRule ： 会先按照轮询获取服务~，如果服务获取失败，则会在指定的时间内进行，重试
     */
    @Bean
    public IRule myRule() {
        return new RandomRule();//使用随机策略
        //return new RoundRobinRule();//使用轮询策略
        //return new AvailabilityFilteringRule();//使用轮询策略
        //return new RetryRule();//使用轮询策略
    }
}

    也可以自定义规则，在myRule包下自定义一个配置类MyRule.java，注意：该包不要和主启动类所在的包同级，要跟启动类所在包同级：

    在这里插入图片描述

    MyRule.java

    @Configuration
public class MyRule {
    @Bean
    public IRule myRule(){
        return new MyRandomRule();//默认是轮询RandomRule,现在自定义为自己的
    }
}

    主启动类开启负载均衡并指定自定义的MyRule配置类

    //Ribbon 和 Eureka 整合以后，客户端可以直接调用，不用关心IP地址和端口号
@SpringBootApplication
@EnableEurekaClient
//在微服务启动的时候就能加载自定义的Ribbon类(自定义的规则会覆盖原有默认的规则)
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = MyRule.class)//开启负载均衡,并指定自定义的规则
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class, args);
    }
}

    自定义的规则（这里我们参考Ribbon中默认的规则代码自己稍微改动）：MyRandomRule.java

    public class MyRandomRule extends AbstractLoadBalancerRule {

    /**
     * 每个服务访问5次则换下一个服务(总共3个服务)
     * <p>
     * total=0,默认=0,如果=5,指向下一个服务节点
     * index=0,默认=0,如果total=5,index+1
     */
    private int total = 0;//被调用的次数
    private int currentIndex = 0;//当前是谁在提供服务

    //@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers();//获得当前活着的服务
            List<Server> allList = lb.getAllServers();//获取所有的服务

            int serverCount = allList.size();
            if (serverCount == 0) {
                /*
                 * No servers. End regardless of pass, because subsequent passes
                 * only get more restrictive.
                 */
                return null;
            }

            //int index = chooseRandomInt(serverCount);//生成区间随机数
            //server = upList.get(index);//从或活着的服务中,随机获取一个

            //=====================自定义代码=========================

            if (total < 5) {
                server = upList.get(currentIndex);
                total++;
            } else {
                total = 0;
                currentIndex++;
                if (currentIndex > upList.size()) {
                    currentIndex = 0;
                }
                server = upList.get(currentIndex);//从活着的服务中,获取指定的服务来进行操作
            }
            
            //======================================================
            
            if (server == null) {
                /*
                 * The only time this should happen is if the server list were
                 * somehow trimmed. This is a transient condition. Retry after
                 * yielding.
                 */
                Thread.yield();
                continue;
            }
            if (server.isAlive()) {
                return (server);
            }
            // Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }
        return server;
    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // TODO Auto-generated method stub
    }
}

7、Feign：负载均衡（基于服务端）

7.1 Feign简介

Feign是声明式Web Service客户端，它让为服务之间的调用变得简单，类似controller调用service。SpringCloud集成了Ribbon和Eureka，可以使用Feign提供负载均衡的http客户端。

只需要创建一个接口，然后添加注解即可~

Feign，主要是社区版，大家都习惯面向接口编程。这个是很多开发人员的规范。调用微服务访问两种方法：

  1. 微服务名字【ribbon】
  2. 接口和注解【feign】
  • Feign能干什么？
    • Feign旨在使编写Java Http客户端变得更容易。
    • 前面在使用Ribbon + RestTemplate时利用RestTemplate对Http请求进行封装处理，形成了一套模板化的调用方法。但是在实际的开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一个客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步的封装，由它来帮助我们定义和实现依赖服务接口的定义，在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它（类似以前Dao接口上标注Mapper注解，现在是一个微服务接口上边==上面标注一个Feign注解），即可完成对服务提供方的接口绑定，简化了使用Spring Cloud Ribbon时，自动封装服务调用客户端的开发量。
  • Feign默认集成了Ribbon
    • 利用Ribbon维护了MicroServiceCloud-Dept的服务列表信息，并且通过轮询实现了客户端的负载均衡，而与Ribbon不同的是，通过Feign只需要定义服务绑定接口且以声明式的方法，优雅而简单的实现了服务调用。

7.2 Feign的使用步骤

  1. 创建springcloud-consumer-fdept-feign模块

    在这里插入图片描述

    拷贝springcloud-consumer-dept-80模块下的pom.xml，resource，以及java代码到springcloud-consumer-feign模块，并添加feign依赖。

    <!--Feign的依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-feign</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

    通过Ribbon实现：原来的controller：DeptConsumerController.java

    @RestController
public class DeptConsumerController {

    /**
     * 理解：消费者，不应该有service层~
     * RestTemplate .... 供我们直接调用就可以了！ 注册到Spring中
     * (地址：url, 实体：Map ,Class<T> responseType)
     * <p>
     * 提供多种便捷访问远程http服务的方法，简单的Restful服务模板~
     */
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 服务提供方地址前缀
     * <p>
     * Ribbon:我们这里的地址，应该是一个变量，通过服务名来访问
     */
//    private static final String REST_URL_PREFIX = "http://localhost:8001";
    private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

    /**
     * 消费方添加部门信息
     * @param dept
     * @return
     */
    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept) {
        // postForObject(服务提供方地址(接口),参数实体,返回类型.class)
        return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
    }

    /**
     * 消费方根据id查询部门信息
     * @param id
     * @return
     */
    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        // getForObject(服务提供方地址(接口),返回类型.class)
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
    }

    /**
     * 消费方查询部门信息列表
     * @return
     */
    @RequestMapping("/consumer/dept/list")
    public List<Dept> list() {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
    }
}

    通过Feign实现：改造后controller：DeptConsumerController.java

    @RestController
public class DeptConsumerController {

    @Autowired
    private DeptClientService deptClientService;

    /**
     * 消费方添加部门信息
     * @param dept
     * @return
     */
    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept) {
        return deptClientService.addDept(dept);
    }

    /**
     * 消费方根据id查询部门信息
     * @param id
     * @return
     */
    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
       return deptClientService.queryById(id);
    }

    /**
     * 消费方查询部门信息列表
     * @return
     */
    @RequestMapping("/consumer/dept/list")
    public List<Dept> list() {
        return deptClientService.queryAll();
    }
}

    Feign和Ribbon二者对比，前者显现出面向接口编程特点，代码看起来更清爽，而且Feign调用方式更符合我们之前做SSM或者SpringBoot项目时，Controller层调用Service层的编程习惯！

    主配置类：

    @SpringBootApplication
@EnableEurekaClient
// feign客户端注解,并指定要扫描的包以及配置接口DeptClientService
@EnableFeignClients(basePackages = {"com.kuang.springcloud"})
// 切记不要加这个注解，不然会出现404访问不到
//@ComponentScan("com.kuang.springcloud")
public class FeignDeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(FeignDeptConsumer_80.class, args);
    }
}

  2. 改造springcloud-api模块

    pom.xml添加feign依赖

    <!--Feign的依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-feign</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

    新建service包，并新建DeptClientService.java接口，

    // @FeignClient:微服务客户端注解,value:指定微服务的名字,这样就可以使Feign客户端直接找到对应的微服务
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
public interface DeptClientService {

    @GetMapping("/dept/get/{id}")
    public Dept queryById(@PathVariable("id") Long id);

    @GetMapping("/dept/list")
    public Dept queryAll();

    @GetMapping("/dept/add")
    public Dept addDept(Dept dept);
}

7.3 Feign和Ribbon如何选择？

根据个人习惯而定，如果喜欢REST风格使用Ribbon；如果喜欢社区版的面向接口风格使用Feign。

Feign本质上也是实现了Ribbon，只不过后者是在调试方法上，为了满足一些开发者习惯的接口调用习惯！

下面我们关闭springcloud-consumer-dept-80这个服务消费方，换用springcloud-consumer-dept-feign（端口号还是80）来代替：（依然可以正常访问，就是调用方式相比于Ribbon变化了）

在这里插入图片描述

8、Hystrix：服务熔断

分布式系统面临的问题

复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免失败！

8.1 服务雪崩

​ 多个微服务之间调用的时候，假设为服务A调用微服务B和微服务C，微服务B和微服务C又调用其他的微服务，这就是所谓的“扇出”，如果扇出的链路上某个微服务的调用响应时间过长，或者不可用，对微服务A的调用就会占用越来越多的系统资源，进而引起系统崩溃，所谓的“雪崩效应”。

在这里插入图片描述

​ 对于高流量的应用来说，单一的后端依赖可能会导致所有服务器上的所有资源都在几十秒内饱和。比失败更糟糕的是，这些应用程序还可能导致服务之间的延迟增加，备份队列，线程和其他系统资源紧张，导致整个系统发生更多的级联故障，这些都表示需要对故障和延迟进行隔离和管理，以达到单个依赖关系的失败而不影响整个应用程序或系统运行。

我们需要，弃车保帅！

8.2 什么是Hystrix？

​ Hystrix是一个应用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时，异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整个体系服务失败，避免级联故障，以提高分布式系统的弹性。

​ “断路器”本身是一个开关装置，当某个服务单元发生故障后，通过断路器的故障监控（类似于熔断保险丝），向调用方返回一个服务预期的，可处理的备选响应（FallBack），而不是长时间的等待或者抛出调用方法无法处理的异常，这样就可以保证了服务调用方的线程不会被长时间，不必要的占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩。

在这里插入图片描述

8.3 Hystrix能干嘛？

  • 服务降级
  • 服务熔断
  • 服务限流
  • 接近实时的监控
  • …

当一切正常时，请求流可以如下所示：

在这里插入图片描述

当许多后端系统中有一个潜在阻塞服务时，他可以阻止整个用户请求：

在这里插入图片描述

​ 随着大容量通信量的增加，单个后端依赖项的潜在性会导致所有服务器上的所有资源在几秒钟内饱和。

​ 应用程序中通过网络或客户端库可能导致网络请求的每个点都是潜在故障来源。比失败更糟糕的是，这些应用程序还可能导致服务之间的延迟增加，从而备份队列、线程和其他系统资源，从而导致更多跨系统的级联故障。

在这里插入图片描述

​ 当使用Hystrix包装每个基础依赖项时，上面的图表中所示的体系结构会发生类似于以下关系图的变化。每个依赖项是相互隔离的，限制在延迟发生时它可以填充的资源中，并包含在回退逻辑中，该逻辑决定在依赖项中发生任何类型的故障时要做出什么样的响应：

在这里插入图片描述

官网资料： https://github.com/Netflix/Hystrix/wiki

8.4 服务熔断

  • 什么是服务熔断？

    ​ 熔断机制是赌赢雪崩效应的一种微服务链路保护机制。

    ​ 当扇出链路的某个微服务不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回错误的相应信息。检测到该节点微服务调用响应正常后恢复链路。在SpringCloud框架里熔断机制通过Hystrix实现。Hystrix会监控微服务间的调用情况，当失败的调用到一定阈值缺省是5秒内20次调用失败，就会启动熔断机制。熔断机制的注解是：@HystrixCommand。

    服务熔断解决如下问题：

    • 当所依赖的对象不稳定时，能够起到快速失败的目的；
    • 快速失败后，能够根据一定的算法动态试探所依赖对象是否恢复。

  • 入门案例

    新建springcloud-provider-dept-hystrix-8001模块并拷贝springcloud-provider-dept-8001内的pom.xml、resources和java代码进行初始化并调整。

    导入hystrix依赖

    <!--导入Hystrix依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

    调整yaml配置文件

    server:
  port: 8001

#mybatis配置
mybatis:
  type-aliases-package: com.kuang.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml


#spring的配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456


#Eureka的配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance: 
    instance-id: springcloud-provider-dept-hystrix-8001 # 修改eureka上的默认描述信息！


#info配置
info:
  app.name: kuangshen-springcloud
  company.name: blog.kuangstudy.com

    perfer-ip-address: false

    在这里插入图片描述

    perfer-ip-address: true

    在这里插入图片描述

    修改controller

    /**
 * @Auther: csp1999
 * @Date: 2020/05/17/22:06
 * @Description: 提供Restful服务
 */
@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;

    /**
     * 根据id查询部门信息
     * 如果根据id查询出现异常,则走hystrixGet这段备选代码
     * @param id
     * @return
     */
    @HystrixCommand(fallbackMethod = "hystrixGet")
    @RequestMapping("/dept/get/{id}")//根据id查询
    public Dept get(@PathVariable("id") Long id){
        Dept dept = deptService.queryById(id);
        if (dept==null){
            throw new RuntimeException("这个id=>"+id+",不存在该用户，或信息无法找到~");
        }
        return dept;
    }

    /**
     * 根据id查询备选方案(熔断)
     * @param id
     * @return
     */ 
    public Dept hystrixGet(@PathVariable("id") Long id){
        return new Dept().setDeptno(id)
                .setDname("这个id=>"+id+",没有对应的信息,null---@Hystrix~")
                .setDb_source("在MySQL中没有这个数据库");
    }
}

    为主启动类添加熔断支持注解@EnableCircuitBreaker

    @SpringBootApplication
@EnableEurekaClient // EnableEurekaClient 客户端的启动类，在服务启动后自动向注册中心注册服务
@EnableDiscoveryClient // 服务发现~
@EnableCircuitBreaker // 添加对熔断的支持注解
public class HystrixDeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(HystrixDeptProvider_8001.class,args);
    }
}

    测试：

    使用熔断后，当访问一个不存在的id时，前台页展示数据如下：

    在这里插入图片描述

    而不使用熔断的springcloud-provider-dept-8001模块访问相同地址会出现下面的状况：

    在这里插入图片描述

    因此，为了避免因某个微服务后台出现异常或错误而导致整个应用或网页报错，使用熔断是必要的。

8.5 服务降级

什么是服务降级？

​ 服务降级是指当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理，或换种简单的方式处理，从而释放服务器资源以保证核心业务正常运作或高效运作。说白了，就是尽可能的把系统资源让给优先级高的服务。

​ 资源有限，而请求是无限的。如果在并发高峰期，不做服务降级处理，一方面肯定会影响整体服务的性能，严重的话可能会导致宕机某些重要的服务不可用。所以，一般在高峰期，为了保证核心功能服务的可用性，都要对某些服务降级处理。比如在双11活动时，把交易无关的服务通通降级，如查看蚂蚁森林，查看历史订单等等。

​ 降级的方式可以根据业务来，可以延迟服务，比如延迟给用户增加积分，只是放到一个缓存中，等服务平稳之后再执行；或者在粒度范围内关闭服务，比如关闭相关文章的推荐。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MXSFnxXp-1620106023612)(D:\桌面\001\idea笔记\idea图片\服务降级.png)]

由上图可得，当某一时间内服务A的访问量暴增，而B和C的访问量较少，为了缓解A服务的压力，这时候需要B和C暂时关闭一些服务功能，去承担A的部分服务，从而为A分担压力，叫做服务降级。

服务降级需要考虑的问题：

  1. 哪些服务是核心服务，哪些服务是非核心服务
  2. 哪些服务可以支持降级，哪些服务不能支持降级，降级策略是什么
  3. 除服务降级之外是否存在更复杂的业务放通场景，策略是什么？

自动降级分类

  1. 超时降级：主要配置好超时时间和超时重试次数和机制，并使用异步机制探测回复情况
  2. 失败次数降级：主要是一些不稳定的api，当失败调用次数达到一定阈值自动降级，同样要使用异步机制探测回复情况
  3. 故障降级：比如要调用的远程服务挂掉了（网络故障、DNS故障、http服务返回错误的状态码、rpc服务抛出异常），则可以直接降级。降级后的处理方案有：默认值（比如库存服务挂了，返回默认现货）、兜底数据（比如广告挂了，返回提前准备好的一些静态页面）、缓存（之前暂存的一些数据）
  4. 限流降级：秒杀或者抢购一些限购商品时，此时可能会因为访问量太大而导致系统崩溃，此时会使用限流来进行限制访问量，当达到限流阈值，后续请求会被降级；降级后的处理方案可以使：排队页面（将用户导流到排队页面等一会重试）、无货（直接告知用户没有货了）、错误页（如活动太火爆了，稍后重试）。

入门案例

在springcloud-api模块下的service包中新建降级配置类DeptClientServiceFailBackFactory.java

@Component
public class DeptClientServiceFallBackFactory implements FallbackFactory {

    @Override
    public DeptClientService create(Throwable cause) {
        return new DeptClientService() {
            @Override
            public Dept queryById(Long id) {
                return new Dept()
                        .setDeptno(id)
                        .setDname("id=>" + id + "没有对应的信息，客户端提供了降级的信息，这个服务现在已经被关闭")
                        .setDb_source("没有数据~");
            }
            @Override
            public List<Dept> queryAll() {
                return null;
            }

            @Override
            public Boolean addDept(Dept dept) {
                return false;
            }
        };
    }
}

在DeptClientService中指定降级配置类DeptClientServiceFallBackFactory

@Component //注册到spring容器中
//@FeignClient:微服务客户端注解,value:指定微服务的名字,这样就可以使Feign客户端直接找到对应的微服务
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallBackFactory.class)//fallbackFactory指定降级配置类
public interface DeptClientService {

    @GetMapping("/dept/get/{id}")
    public Dept queryById(@PathVariable("id") Long id);

    @GetMapping("/dept/list")
    public List<Dept> queryAll();

    @GetMapping("/dept/add")
    public Boolean addDept(Dept dept);
}

在springcloud-consumer-dept-feign模块中开启降级

server:
  port: 80

# Eureka配置
eureka:
  client:
    register-with-eureka: false # 不向 Eureka注册自己
    service-url: # 从三个注册中心中随机取一个去访问
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

# 开启降级feign.hystrix
feign:
  hystrix:
    enabled: true

8.6 服务熔断和降级的区别

  • 服务熔断——>服务端：某个服务超时或异常，引起熔断，类似于保险丝（自我熔断）
  • 服务降级——>客户端：从整体网站请求负载考虑，当某个服务熔断或者关闭后，服务将不再被调用，此时在客户端，我们可以准备一个FallBackFactory，返回一个默认的值（缺省值）。会导致整体的服务下降，但是好歹能用，比直接挂掉强。
  • 触发的原因不太一样，服务熔断一般是某个服务（下游服务）故障引起的，而服务降级一般是从整体负荷考虑；管理目标的层次不太一样，熔断其实是一个框架级的处理，每个微服务都需要（无层级之分），而降级一般需要对业务有层级之分（比如降级一般是从最外围服务开始的）
  • 实现方式不一样，服务降级具有代码侵入性（由控制器完成/或自动降级），熔断一般称为自我熔断。

熔断，降级，限流：

限流：限制并发的请求访问量，超过阈值则拒绝；

降级：服务分优先级，牺牲非核心服务（不可用），保证核心服务稳定；从整体负荷考虑；

熔断：依赖的下游服务故障触发熔断，避免引发本系统崩溃，系统自动执行和恢复

8.7 Dashboard流监控

新建springcloud-consumer-hystrix-dashboard模块

添加依赖

<!--Hystrix依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>
<!--dashboard依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>
<!--Ribbon-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-ribbon</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>
<!--Eureka-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>
<!--实体类+web-->
<dependency>
    <groupId>com.haust</groupId>
    <artifactId>springcloud-api</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--热部署-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

主启动类

@SpringBootApplication
// 开启Dashboard
@EnableHystrixDashboard
public class DeptConsumerDashboard_9001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumerDashboard_9001.class,args);
    }
}

给springcloud-provider-dept-hystrix-8001模块下的主启动类添加如下代码，添加监控（固定的代码）

@SpringBootApplication
@EnableEurekaClient //EnableEurekaClient 客户端的启动类，在服务启动后自动向注册中心注册服务
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }

    //增加一个 Servlet
    @Bean
    public ServletRegistrationBean hystrixMetricsStreamServlet(){
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
        //访问该页面就是监控页面
        registrationBean.addUrlMappings("/actuator/hystrix.stream");
       
        return registrationBean;
    }
}

访问：http://localhost:9001/hystrix

在这里插入图片描述

进入监控页面：

在这里插入图片描述

效果如下图：

在这里插入图片描述

在这里插入图片描述

我叫刘波
关注
狂神说SpringCloud学习笔记
qq_43161404的博客
01-09 2325
前言：B站狂神说Java中SpringBoot笔记，传送门 UP很nice，课程生动形象，欢迎支持。 一、什么是微服务 整体部署：每一个模块的变更很难不影响到其他模块，使得变更周期变得漫长，扩展需要整体扩展，而不能进行部分扩展。 就目前而言，对于微服务，业界并没有一个统一的，标准的定义。 但通常而言，微服务架构是一种架构模式，或者说是一种架构风格，它体长将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值，服务之间采用轻量级的通信机制(HT
SpringCloud学习笔记-狂神说
weixin_44202871的博客
07-17 574
SpringBoot 微服务
spring-cloud Edgware.SR6 之 spring config server 1.4.7 （配置中心）配置机制、开放的接口(控制器)
~~简~~
03-18 245
org.springframework.cloud.config.server.environment.EnvironmentController org.springframework.cloud.config.server.resource.ResourceController . EnvironmentController @RestController @RequestMapping(method = RequestMethod.GET, path = "${spring.cloud.con
SpringCloud之SpringCloud常用的五大组件
啊策策大数据社区
05-10 1794
0.学习目标 了解系统架构的演变 了解RPC与Http的区别 掌握HttpClient的简单使用 知道什么是SpringCloud 独立搭建Eureka注册中心 独立配置Robbin负载均衡 1.系统架构演变 随着互联网的发展，网站应用的规模不断扩大。需求的激增，带来的是技术上的压力。系统架构也因此也不断的演进、升级、迭代。从单一应用，到垂直拆分，到分布式服务，到SOA，以及现在火热的微服务架构，还有在Google带领下来势汹涌的Service Mesh。我们到底是该乘坐微服务的船只驶向远方，还是偏安一
最新定时更新：Spring Cloud 各个版本整理汇总。最新为2022，Kilburn版本
热门推荐
qq120631157的博客
01-21 2万+
Spring Cloud各个版本汇总，A版本到K版本，2020,2021，2022版本
Spring Cloud 升级最新 Finchley 版本，踩了所有的坑！
weixin_30666401的博客
08-09 1135
Spring Boot 2.x 已经发布了很久，现在 Spring Cloud 也发布了 基于 Spring Boot 2.x 的 Finchley 版本，现在一起为项目做一次整体框架升级。 升级前 => 升级后 Spring Boot 1.5.x => Spring Boot 2.0.2 Spring Cloud Edgware SR4 => Spring Cloud Finc...
SpringCloud的版本
weixin_33694620的博客
08-03 567
Spring Cloud 项目目前仍然是快速迭代期，版本变化很快。这里整理一下版本相关的东西，备忘一下。 大版本 版本号规则 Spring Cloud并没有熟悉的数字版本号，而是对应一个开发代号。 Cloud代号Boot版本(train)Boot版本(tested)lifecycle Angle 1.2.x incompatible with 1.3 EOL in July 2017 ...
SpringCloud - 狂神学习笔记
瞅你咋滴。
07-24 501
微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底地去耦合，每一个微服务提供单个业务功能的服务，一个服务做一件事情，从技术角度看就是一种小而独立的处理过程，类似进程的概念，能够自行单独启动或销毁，拥有自己独立的数据库。一个父工程带着多个Moudule子模块MicroServiceCloud父工程(Project)下初次带着3个子模块(Module)microservicecloud-api 【封装的整体entity/接口/公共配置等】
狂神springcloud学习笔记加代码
03-24
狂神springcloud学习笔记加代码 笔记可以看：https://www.kuangstudy.com/bbs/1374942542566551554#header4 视频链接：https://www.bilibili.com/video/BV1jJ411S7xr
xmljava系统源码-spring-cloud-kuang:狂神springcloud笔记+源码+config
06-06
SpringCloud笔记 1、前言 1.1、回顾 回顾之前的知识 JavaSE 数据库 前端 Servlet Http Mybatis Spring SpringMVC SpringBoot Dubbo、Zookeeper、分布式基础 Maven、Git Ajax、Json ... 串一下自己会的东西 数据库 ...
SpringCloud 狂神说 学习笔记
okForrest27的博客
06-17 4460
微服务架构4个核心问题?（从问题入手） 1.服务很多，客户端该怎么访问? 2.这么多服务?服务之间如何通信? 3.这么多服务? 如何治理? 4.服务挂了怎么办? SpringCloud是生态 是一个解决方案 例如小米公司的生态 1.Spring cloud NetFlix 2.Apache Dubbo Zookeeper 3.Spring cloud Alibaba 解决以上四个核心问题 图 SpringCloud NetFlix 本文档主要学习这套解决方案 图 Apache Dubbo Zookeep
SpringCloud第二季5-SpringConfig、Bus
群鸟飞扬
09-22 352
1、目录结构 2、改POM 3、建application.yml 4、主启动类 5、业务类 6、运行代码
SpringCloud的版本对应
William的博客
02-09 4085
1.版本名组成 SpringCloud由于是一系列框架组合，为了避免与包含的自框架版本产生混淆，采 用伦敦地铁站的名称作为版本名，形式为版本名+里程碑号。例如Finchley.M9其中Finchley是版本号，M9就是里程碑版本 2.SpringBoot和SpringCloud的版本对应 Spring Boot Spring Cloud 1.2.x Angel版本 1.3.x ...
Springcloud 版本的那些事
徐小冠
09-04 1万+
今天在使用 maven 进行聚合工程的时候,在pom文件出现一片红,因为这个工程以前用过的所以本地的  Respsitory 中有的 ,各个版本是有的, 后来发现因为是自动生成的 版本 RC1 ,从百度中查询到 版本改为 SR1 ,就可以了,上网上找到,有许多版本.   是如何选择的呢 ,在开发中使用那一版本中这些版本与Springboot 版本有什么依赖关系. 先看一下springc...
RabbitTemplate与AmqpTemplate：Spring AMQP中的消息传递模板
qq_51321722的博客
10-05 598
是Spring AMQP框架的核心接口，它定义了一套标准的AMQP操作，如发送和接收消息、声明队列和交换机等。这个接口是对AMQP协议的抽象，提供了一种面向对象的方式来操作AMQP协议。它基于RabbitMQ的Java客户端库实现，使得开发者可以通过Spring框架的依赖注入和配置机制来简化与AMQP消息队列系统的交互。而则是Spring AMQP为RabbitMQ提供的一个高级消息操作模板。它实现了接口，并添加了一些针对RabbitMQ的特性和优化。不仅提供了与。
【Spring Security】基于SpringBoot3.3.4版本②如何配置免鉴权Path
Java技术栈，分享不断学习、不断超越、不断积累的历程！
10-03 1290
[【Spring Security】基于SpringBoot3.3.4版本①整合JWT的使用教程](https://blog.csdn.net/friendlytkyj/article/details/142679120) 在这篇文章中，详细演示了使用最新版`Spring Boot`，完成一个微服务开发，并使用`Spring Security`组件完成登录认证，同时整合了`JWT`，使用的`RSA`公私钥签名、验签。 接下来继续讲解下一个业务场景：一个真实场景的微服务，难免会有一些请求`Path`不需要任
springboot实战学习（12）(优化更新用户基本信息接口)(Validation实体参数校验)
最新发布
岁岁岁平安的博客
10-09 659
本篇博客主要是对用户模块的更新用户基本信息接口的代码的一个小优化（实体参数校验）。其中用到了Spring Validation参数校验框架提供的一些注解（如@NotNull、@NotEmpty、@Email、@Validated）去完成实体类对象的参数校验以及完成了功能的测试...
Spring
m0_74728220的博客
10-02 1231
不直接创建对象，而是由容器创建，并设定一个或多个标识，需要的时候通过Bean名字从容器中获取，这看上去是类似于EJB的服务查找，但是Spring真正的核心是对于依赖的处理，使用配置的方式注入依赖。以A、B、C三个类为例，B、C都是单例模式的类，A需要调用B、C类的方法，这样A就和B、C形成了依赖，如果B、C交由容器管理，A虽然和容器产生依赖，但是依赖程度降低了。
SpringBoot
2301_78955442的博客
10-03 381
hellos的时候就 return hello worlds。hello的时候就 return hello world。并且在控制台也有相应的输出句子打印出来。1.SpringBoot的创建。springboot启动成功。
狂神springcloud笔记
09-15
根据提供的引用内容，狂神的Spring Cloud笔记中涵盖了在集群中建立关联的步骤，这些步骤包括以下几点： 1. 首先，你需要创建springcloud-eureka-7001、springcloud-eureka-7002和springcloud-eureka-7003模块。 2. 接下来，你需要确保springcloud-eureka-7001与springcloud-eureka-7002、springcloud-eureka-7003建立关联，并且springcloud-eureka-7002与springcloud-eureka-7001、springcloud-eureka-7003也建立关联。这样可以形成一个集群。 通过这些步骤，你可以在Spring Cloud集群中实现服务的注册与发现。希望这些信息对你有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值