SpringCloud

SpringCloud

SpringCloud的pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zhiyou100</groupId>
    <artifactId>SpringCloudParent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
    	<!-- springcloud的子模块 -->
        <module>springcloud-eureka-server7000</module>
        <module>springcloud-provider-user8001</module>
    </modules>
    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
        <relativePath/>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
    </properties>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
    <dependencies>
         <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-test</artifactId>
              <scope>test</scope>
         </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

不需要配置文件,不需要src

Eureka

eureka-server的pom依赖

 <!-- 导入自己的springcloud父项目,不要springboot项目,也不要有关于springCloud版本的设置 -->
 <parent>
      <groupId>com.zhiyou100</groupId>
      <artifactId>springcloud-parent</artifactId>
      <version>1.0-SNAPSHOT</version>
   </parent>
 <dependencies>
 <!-- Eureka的服务端依赖 -->
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
      </dependency>
   </dependencies>

eureka-server的application.properties文件

#端口
server.port=7000
#应用名,用于注册到Eureka中
spring.application.name=eureka-server
#设置为本地访问其他服务 可以设置为
# eureka.instance.hostname= ${spring.cloud.client.ipAddress}
eureka.instance.hostname=localhost

#通过eureka.client.registerWithEureka：false和fetchRegistry：false来表明自己是一个eureka server.
#registerWithEureka表示是否注册自身到eureka服务器
eureka.client.register-with-eureka=false
#fetchRegistry表示是否从eureka服务器获取注册信息。
eureka.client.fetch-registry=false
#模块在eureka服务中显示的路径
eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/

eureka-server服务开启

在启动类上添加一个@EnableEurekaServer注解开启服务

eureka-client客户端的pom依赖

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

eureka-client客户端的配置文件

#端口
server.port=8001
#spring.application.name非常重要，服务直接的调用是根据这个name值来相互调用的
spring.application.name=server-user

#提交到这个注册中心
eureka.client.service-url.defaultZone=http://localhost:7000/eureka/

eureka-client客户端开启

在启动类上添加@EnableEurekaClient注解开启客户端

微服务info内容详细信息

1.微服务添加actuator依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2.父工程添加build和plagin

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <configuration>
                <delimiters>
                    <delimit>$</delimit>
                </delimiters>
            </configuration>
        </plugin>
     </plugins>
</build>

3.微服务yml 添加info节点

info:
  app.name: user-server
  company.name: www.zhiyou100.com
  build.artifactId: @project.artifactId@
  build.version: @project.version@

Ps:$ 符号中未生效,应该改为@

Eureka 服务发现(熟悉即可)

微服务中使用服务发现的api

package com.zhiyou100.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @Author QiuShiju
 * @Date 2019/10/2
 * @Desc
 */
@RestController
public class UserController {

    @Autowired
    private DiscoveryClient client;

    @RequestMapping(value="/user/discovery",method = RequestMethod.GET)
    public Object discovery(){
        List<String> list = client.getServices();
        System.out.println(list);
        System.out.println("---------------");
        // 根据spring.application.name 去找的
        List<ServiceInstance> srvList = client.getInstances("server-user");
        for(ServiceInstance instance : srvList){
            System.out.println("服务主机: "+instance.getHost());
            System.out.println("服务id  :"+instance.getServiceId());
            System.out.println("服务端口:"+instance.getPort());
            System.out.println("服务地址:"+instance.getUri());

        }
        return this.client;
    }
}

开启服务发现

在启动类上添加@EnableDiscoveryClient注解开去服务发现

Ribbon(瑞笨)

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端的负载均衡的工具

服务间的访问(调用/通信)

UserController

@RestController
public class UserController {

    @RequestMapping(value = "/user/callDept",method = RequestMethod.GET)
    public Object userCallDept(){
        System.out.println("user : user访问Dept");
        return null;
    } 
}

DeptController

@RestController
public class DeptController {

    @RequestMapping(value = "/dept/beCall",method = RequestMethod.GET)
    public Object beCall() {
        System.out.println("dept : 被访问了");
        return "{\"code\":\"200\"}";
    }
}

User模块Spring中注入RestTemplate

在User模块添加一个ConfigBean类

@Configuration//设置该类是配置类
public class ConfigBean{
    @Bean// 注入到spring容器中
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

User模块使用RestTemplate,访问Dept服务

@AutoWired
RestTemplate restTemplate;

api:

getForObject(String url,Object.class);   get方式访问url指定的微服务,Object.class 返回的数据类型
getForEntry(String url,Object.class)
getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables) 
这三个参数分别代表 REST请求地址、HTTP响应转换被转换成的对象类型、请求参数
postForObject(String url,Object.class)
postForEntry(String url,Object.class)

注意 : 调用方调用时要使用@RequestBody注解解析参数

多个服务: 服务名不变,端口改变 主机名称改变

eureka.instance.instance-id=xxxx   #这个主机名要改变

开启调用多个服务开启负载均衡

调用方导入pom依赖

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

开启负载均衡

@Configuration//设置该类是配置类
public class ConfigBean{
    @Bean// 注入到spring容器中
    @LoadBalanced  // 开启负载均衡
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

注意:

在调用方不能再使用ip+端口号来调用服务,应该使用服务名来调用服务

Ribbon核心组件IRule

关于Ribbon中对于IRule的实现，总共有如下几种，其简略说明也附注如下：

RoundRobinRule: 轮询
RandomRule：随机
AvailabilityFilteringRule：会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，还有并发的连接数超过阈值的服务，然后对剩余的服务列表按照轮询策略进行访问
WeightedResponseTimeRule：根据平均响应时间计算所有服务的权重，响应时间越快服务权重越大，被选中的概率越高。刚启动时如果统计信息不足，则使用RoundRobinRule策略，等统计信息足够，会切换到WeightedResponseTimeRule
RetryRule: 先按照RoundRobinRule的策略获取服务，如果获取服务失败，则在指定时间内会进行重试，获取可用服务
BestAvailableRule: 会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务
ZoneAvoidanceRule: 默认规则，符合判断server所在区域的性能和server的可用性选择服务器

@Configuration//设置该类是配置类
public class ConfigBean{
    @Bean// 注入到spring容器中
    @LoadBalanced  // 开启负载均衡
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
    @Bean
    public IRule irule(){
        // 轮播
        // return new RoundRobinRule();
        //随机
    	return new RandomRule();
    }
}

Ribbon自定义请求规则

创建自定义配置类实现IRule接口

package com.zhiyou100.config;

import com.netflix.loadbalancer.BaseLoadBalancer;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.Server;

import java.util.List;
import java.util.Random;

public class RibbonConfig implements IRule{
    // 注入负载均衡属性
    ILoadBalancer balancer = new BaseLoadBalancer();

    /**
     *  制定负载均衡规则
     *  dept 1号服务  10%访问率
     *  dept 2号服务  20%访问率
     *  dept 3号服务  30%访问率
     *  dept 4号服务  40%访问率
     */

    @Override
    public Server choose(Object key) {
        // 获得所有服务
        List<Server> allServers = balancer.getAllServers();
        Random random = new Random();
        final int number = random.nextInt(10);// 0-9
        if (number < 1) { // 0
            return findServer(allServers,8002); //dept 1号服务
        }
        if (number < 3) { // 1 2
            return findServer(allServers,8003);//dept 2号服务
        }
        if (number < 6) { // 3 4 5
            return findServer(allServers,8004);//dept 3号服务
        }
        // 6 7 8 9
        return findServer(allServers,8005);//dept 4号服务
    }

    private Server findServer(List<Server> allServers, int port) {
        for (Server server : allServers) {
            if (server.getPort() == port) {
                return server;
            }
        }
        System.out.println("NULL port="+port);
        return null;
    }


    @Override
    public void setLoadBalancer(ILoadBalancer iLoadBalancer) {
        this.balancer = iLoadBalancer;
    }

    @Override
    public ILoadBalancer getLoadBalancer() {
        return balancer;
    }
}

主启动类使用自定义规则

@Configuration//设置该类是配置类
public class ConfigBean{
    @Bean// 注入到spring容器中
    @LoadBalanced  // 开启负载均衡
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
    @Bean
    public IRule irule(){
        //使用自己指定规则的类
    	return new RibbonConfig();
    }
}

Feign(非ing)介绍

声明性REST客户端：Feign
Feign是一个声明式的Web服务客户端。这使得Web服务客户端的写入更加方便 要使用Feign创建一个界面并对其进行注释。它具有可插入注释支持，包括Feign注释和JAX-RS注释。Feign还支持可插拔编码器和解码器。Spring Cloud增加了对Spring MVC注释的支持，并使用Spring Web中默认使用的HttpMessageConverters。Spring Cloud集成Ribbon和Eureka以在使用Feign时提供负载均衡的http客户端。

	<springcloud.cc>
Feign是一个声明式的伪Http客户端，它使得写Http客户端变得更简单。使用Feign，只需要创建一个接口并注解。它具有可插拔的注解特性，可使用Feign 注解和JAX-RS注解。Feign支持可插拔的编码器和解码器。Feign默认集成了Ribbon，并和Eureka结合，默认实现了负载均衡的效果。

简而言之：

Feign 采用的是基于接口的注解
Feign 整合了ribbon，具有负载均衡的能力
整合了Hystrix，具有熔断的能力
	编程式实现
需要以具体代码表达在哪里（where）做什么（what），如何实现（how）
	声明式实现
只需要声明在哪里（where ）做什么（what），而无需关心如何实现（how）
以 Java 中的事务管理为例，在事务中进行操作需要依次执行如下：
1)准备资源
2)开启事务
3)在事务中执行操作
4)提交/回滚事务
5)关闭资源
编程式:在业务层java代码中明确写出以上所有步骤.
声明式:在spring配置文件写各种<bean><tx:><aop:>…
声明式事务：
简化了代码实现
实现了业务代码（CRUD 操作）和功能代码（开关事务、开关资源）的分离

注意,使用Feign就不再使用Ribbon,所以把之间的依赖和@LoadBalance删除

引入依赖

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

服务启动类加注解,开启Feign

在启动类中添加@EnableFeignClients注解开启Feign

使用Feign,不再使用Rest调用,就是正常的Controller调用Service.

具体的Feign的功能在Service中实现

在业务层调用其他服务

@FeignClient("服务名")
public interface XxxService{
    // 要调用的微服务的路径 请求方式,如果返回的是json数据添加属性 produces="application/json;charset=utf-8"
    @RequestMapping(value="/dept/beCall",method = RequestMethod.GET/*,produces="application/json;charset=utf-8"*/)
	Object callDeptFeign();
}

注入解析类,用来解析其他服务返回的json数据

@Configuration  // 有了该注解,该类就相当于是applicationContext.xml
public class ConfigBean {

    // 解决返回参数为[text/plain] 无法转化为json
    @Bean
    public Decoder feignDecoder(){
        MyMessageConverter myMessageConverter = new MyMessageConverter();
        // Java8的lambda表达式。 ->
        ObjectFactory<HttpMessageConverters> objectFactory = () -> new HttpMessageConverters(myMessageConverter);
        return new SpringDecoder(objectFactory);
    }
}

注意参数的解析格式和调用的服务的格式一样

类或map要使用@RequestBody

Hystrix(嗨思坠克斯)

Netflix的创造了Hystrix实现了断路器方案。在微服务架构中，通常有多层服务调用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-majBv85g-1649748881658)(file:///C:/Users/YQL/AppData/Local/Temp/msohtmlclip1/01/clip_image001.png)]

HystrixGraph

图1.微服务图

较低级别的服务中的服务故障可能导致用户级联故障。当对特定服务的呼叫达到一定阈值时（Hystrix中的默认值为5秒内的20次故障），电路打开，不进行通话。在错误和开路的情况下，开发人员可以提供后备。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9A2nJsoP-1649748881659)(file:///C:/Users/YQL/AppData/Local/Temp/msohtmlclip1/01/clip_image002.png)]

HystrixFallback

图2. Hystrix回退防止级联故障

开放式电路会停止级联故障，并允许不必要的或失败的服务时间来愈合。回退可以是另一个Hystrix保护的调用，静态数据或一个正常的空值。回退可能被链接，所以第一个回退使得一些其他业务电话又回到静态数据。

个人理解

在微服务架构中，根据业务来拆分成一个个的服务，服务与服务之间可以相互调用（RPC），在Spring Cloud可以用RestTemplate+Ribbon和Feign来调用。为了保证其高可用，单个服务通常会集群部署。由于网络原因或者自身的原因，服务并不能保证100%可用，如果单个服务出现问题，调用这个服务就会出现线程阻塞，此时若有大量的请求涌入，Servlet容器的线程资源会被消耗完毕，导致服务瘫痪。服务与服务之间的依赖性，故障会传播，会对整个微服务系统造成灾难性的严重后果，这就是服务故障的“雪崩”效应。

为了解决这个问题，业界提出了断路器模型。 用自己的话说就是,当微服务分布式项目的情况下,某一微服务(假设是dept服务)出现故障宕机, 没有熔断机制的话,其他调用该服务的其他微服务(假设是User服务),就会在调用该dept服务时出现阻塞,长时间没有响应的情况。
	有熔断机制的话，如果服务宕机（dept服务宕机），User服务不再调用它，继续干其他事情，不至于一直堵塞。
对于高流量的应用来说，单一的后端依赖可能会导致所有服务器上的所有资源都在几秒钟内饱和。比失败更糟糕的是，这些应用程序还可能导致服务之间的延迟增加，备份队列，线程和其他系统资源紧张，导致整个系统发生更多的级联故障。这些都表示需要对故障和延迟进行隔离和管理，以便单个依赖关系的失败，不能取消整个应用程序或系统。
备注：一般情况对于服务依赖的保护主要有3中解决方案：
（1）熔断模式：这种模式主要是参考电路熔断，如果一条线路电压过高，保险丝会熔断，防止火灾。放到我们的系统中，如果某个目标服务调用慢或者有大量超时，此时，熔断该服务的调用，对于后续调用请求，不在继续调用目标服务，直接返回，快速释放资源。如果目标服务情况好转则恢复调用。


（2）隔离模式：这种模式就像对系统请求按类型划分成一个个小岛的一样，当某个小岛被火烧光了，不会影响到其他的小岛。例如可以对不同类型的请求使用线程池来资源隔离，每种类型的请求互不影响，如果一种类型的请求线程资源耗尽，则对后续的该类型请求直接返回，不再调用后续资源。这种模式使用场景非常多，例如将一个服务拆开，对于重要的服务使用单独服务器来部署，再或者公司最近推广的多中心。


（3）限流模式：上述的熔断模式和隔离模式都属于出错后的容错处理机制，而限流模式则可以称为预防模式。限流模式主要是提前对各个类型的请求设置最高的QPS阈值，若高于设置的阈值则对该请求直接返回，不再调用后续资源。这种模式不能解决服务依赖的问题，只能解决系统整体资源分配问题，因为没有被限流的请求依然有可能造成雪崩效应。

Hystrix能干什么

Hystrix是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时、异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性。
 	“断路器”本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险丝），向调用方返回一个符合预期的、可处理的备选响应（FallBack），而不是长时间的等待或者抛出调用方无法处理的异常，这样就保证了服务调用方的线程不会被长时间、不必要地占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩。
	服务降级
Hystrix服务降级，其实就是线程池中单个线程障处理，防止单个线程请求时间太长，导致资源长期被占有而得不到释放，从而导致线程池被快速占用完，导致服务崩溃。
Hystrix能解决如下问题：
1.请求超时降级，线程资源不足降级，降级之后可以返回自定义数据
2.线程池隔离降级，分布式服务可以针对不同的服务使用不同的线程池，从而互不影响
3.自动触发降级与恢复
4.实现请求缓存和请求合并
	服务熔断
熔断模式：这种模式主要是参考电路熔断，如果一条线路电压过高，保险丝会熔断，防止火灾。放到我们的系统中，如果某个目标服务调用慢或者有大量超时，此时，熔断该服务的调用，对于后续调用请求，不在继续调用目标服务，直接返回，快速释放资源。如果目标服务情况好转则恢复调用。

服务熔断

在服务提供端使用Hystrix熔断

不管消费者使用什么方式调用服务的提供者: 

user服务不管是以rest+ribbon的方式访问dept服务(服务的提供者),

还是以Feign的方式访问dept服务(服务的提供者) 

熔断机制的配置都**可以**如下: 

Ps: **[Feign****中也可以单独设置熔断]**

主启动类加@EnableEurekaClient

修改pom,引入Hystrix坐标

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

主启动类加注解@EnableHystrix,开启Hystrix

报异常处加入Hystrix熔断功能

1. 在抛异常的方法上加上注解@HystrixCommand

2. 在注解上加入fallbackMethod参数,当熔断开启后,去执行另外的方法

3. So easy

   @RestController
   public class DeptController {
   
       @RequestMapping(value = "/dept/beCall",method = RequestMethod.GET)
       @HystrixCommand(fallbackMethod = "beCall_fallbackMethod")
       public Object beCall() {
           System.out.println("dept : 被访问了");
   
           throw new RuntimeException("8003 :dept-hystrix微服务异常");
           //return "{\"code\":\"200\",\"msg\":\"成功\",\"dept\":\"8003\"}";
       }
       /*
        * 熔断开启调用的方法
        */
       public Object beCall_fallbackMethod(){
           return "{\"code\":\"404\",\"msg\":\"失败\"}";
       }
       
   }
   

在消费者端的Feign使用熔断机制

​ 这样在消费端配置的话,服务的提供者(dept服务)就不需要使用使用熔断机制,不再导包以及主启动类添加注解,熔断功能完全有消费端（User服务）实现。

不需要额外的导入坐标,Feign已经集成了熔断功能,直接使用就行。但是在SpringcloudD版本之后，它没有默认打开。需要在配置文件中配置打开它，在配置文件加以下代码：

修改application.properties

# 开启Feign的熔断功能
feign.hystrix.enabled=true

修改@FeignClient注解功能

在业务层的@FeignClient直接中添加参数fallback,参数值是提供熔断之后的回调类
既: 如果该@FeignClient注解下的所有方法只要有异常,就会去执行fallback指定类中的方法

创建fallback指定的类

1.	该类是@FeignClient所在接口的实现类,
2.	该类需要注入Spring ==> 既需要加注解@Component

Feign中提供熔断与服务提供端提供熔断的区别

-既: user服务中的Feign提供熔断功能,与Dept服务中的熔断功能有什么区别?
服务端提供熔断是在方法级上定义熔断后调用的fallback,
Feign是在类级上,直接创建一个实现类,去调用实现类的方法
各有优缺点:
使用Feign: 不管服务中那个方法出现问题,都会返回一个固定的值。
这样减少了在每个方法设置注解以及设置fallbackMethod的工作量，
但是这样就会造成不确定具体哪个方法出现异常
提供端熔断：每个方法需要加注解,并指定fallbackMethod,甚至每个fallbackMethod方法都不一样,但是这样在抛异常返回时,提供的信息更加精确不再千篇一律（一万个异常一个返回值）。

服务监控dashboard

    除了隔离依赖服务的调用以外，Hystrix还提供了准实时的调用监控（Hystrix Dashboard），Hystrix会持续地记录所有通过Hystrix发起的请求的执行信息，并以统计报表和图形的形式展示给用户，包括每秒执行多少请求多少成功，多少失败等。Netflix通过hystrix-metrics-event-stream项目实现了对以上指标的监控。Spring Cloud也提供了Hystrix Dashboard的整合，对监控内容转化成可视化界面。	

搭建dashboard图形界面微服务

引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.zhiyou100</groupId>
   <artifactId>springcloud-dashboard-9000</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>springcloud-dashboard-9000</name>
   <description>Demo project for Spring Boot</description>
   <parent>
      <groupId>com.zhiyou100</groupId>
      <artifactId>springcloud-parent</artifactId>
      <version>1.0-SNAPSHOT</version>
   </parent>
   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

修改配置文件

server.port=9000
spring.application.name=hystrix-dashboard

主启动类添加注解@EnableHystrixDashboard

测试

启动该项目,访问http://localhost:9000/hystrix

使用图形界面监控微服务

https://blog.csdn.net/u013739073/article/details/80627087

修改被监控的微服务

注意: 被监控的微服务一定是具有熔断功能的,且需要有spring-boot-starter-actuator依赖坐标

Pom

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

application.properties

​ management.endpoints.web.exposure.include这个是用来暴露 endpoints 的。由于 endpoints 中会包含很多敏感信息，除了 health 和 info 两个支持 web 访问外，其他的默认不支持 web 访问。 当安装豪猪主页提示的url访问时http://localhost:8003/hystrix.stream 会报错。

所以需要在原来的配置文件中添加如下：

# 开启访问 豪猪信息
management.endpoints.web.exposure.include=hystrix.stream
#management.endpoints.web.exposure.include=*

单独访问该服务费的监控信息

要有spring-boot-starter-actuator依赖坐标**

Pom

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

application.properties

​ management.endpoints.web.exposure.include这个是用来暴露 endpoints 的。由于 endpoints 中会包含很多敏感信息，除了 health 和 info 两个支持 web 访问外，其他的默认不支持 web 访问。 当安装豪猪主页提示的url访问时http://localhost:8003/hystrix.stream 会报错。

所以需要在原来的配置文件中添加如下：

# 开启访问 豪猪信息
management.endpoints.web.exposure.include=hystrix.stream
#management.endpoints.web.exposure.include=*

单独访问该服务费的监控信息

http://localhost:8003/actuator/hystrix.stream