SpringCloud入门，适合微服务初学者
提示：该文章仅供初学者个人学习参考
目录
前言
一、什么是微服务？
二、使用步骤
1.SpringCloud-Api
2.SpringCloud-Eureka
3.SpringCloud-Ribbon
1.SpringCloud-Provider
2.SpringCloud-Consumer
4.SpringCloud-Feign
5.SpringCloud-Hystrix
1.Hystrix服务熔断
2.Hystrix服务降级
3.Hystrix服务监控
总结
前言
Spring Cloud 是一系列框架的有序集合。它利用 Spring Boot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 Spring Boot 的开发风格做到一键启动和部署。Spring 并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过 Spring Boot 风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。对于CAP理论中，SpringCloud遵循着A（可用性）P（分区容忍性）原则。
一、什么是微服务？
维基上对其定义为：一种软件开发技术- 面向服务的体系结构（SOA）架构样式的一种变体，它提倡将单一应用程序划分成一组小的服务，服务之间互相协调、互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务与服务间采用轻量级的通信机制互相沟通（通常是基于HTTP的RESTful API）。每个服务都围绕着具体业务进行构建，并且能够独立地部署到生产环境、类生产环境等。另外，应尽量避免统一的、集中式的服务管理机制，对具体的一个服务而言，应根据上下文，选择合适的语言、工具对其进行构建。
二、使用步骤
1.SpringCloud-Api
首先我们使用RestTempleate模拟Http请求，因此仅需要编写pojo类，在后续使用Feign使用接口方式调用时，再添加相对应的service接口。
package com.springcloud.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* Description: Student类
* Date: 2022/7/6 8:23
*
* @author gaoyu
* @version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
private Integer id;
private String name;
private String gender;
public Student(String name, String gender){
this.name = name;
this.gender = gender;
}
}2.SpringCloud-Eureka
Spring Cloud Eureka 是 Spring Cloud Netflix 微服务套件中的一部分，它基于Netflix Eureka 做了二次封装，主要负责完成微服务架构中的服务治理功能。在这里我们分别搭建三个Eureka服务模拟集群操作，端口号分别为7001、7002、7003。
第一步，我们创建springcloud-eureka-7001 Module，并在该Module中编写application.yml配置。
#配置服务端口号
server:
port: 7001
#配置Eureka服务端
eureka:
instance:
hostname: localhost1 #Eureka服务段的实例名称，在真实的项目中为真实的域名地址
client:
register-with-eureka: false #是否向Eureka服务中心注册自己（因为本身就是服务中心，因此并不需要）
fetch-registry: false #是否需要检索注册信息（因为本身是注册中心，因此也是false）
service-url:
# 单机
# defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
# 集群（关联）
defaultZone: http://localhost2:7002/eureka/,http://localhost3:7003/eureka/第二步，编写springcloud-eureka-7001的启动类。
package com.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
/**
* Description: 配置springcloud-eureka-7001的启动类
* Date: 2022/7/6 19:57
*
* @author gaoyu
* @version 1.0
*/
@EnableEurekaServer //开启EurekaServer自动注解
@SpringBootApplication
public class EurekaServer_7001 {
public static void main(String[] args) {
SpringApplication.run(EurekaServer_7001.class, args);
}
}第三步，重复上述操作创建springcloud-eureka-7002、springcloud-eureka-7002 Module。
server:
port: 7002
spring:
application:
name: localhost2
eureka:
client:
register-with-eureka: false
fetch-registry: false
service-url:
defaultZone: http://localhost1:7001/eureka/,http://localhost3:7003/eureka/
-----------------------------------------------------------------------------------------
package com.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
/**
* Description: 配置springcloud-eureka-7002的启动类
* Date: 2022/7/6 20:12
*
* @author gaoyu
* @version 1.0
*/
@EnableEurekaServer
@SpringBootApplication
public class EurekaServer_7002 {
public static void main(String[] args) {
SpringApplication.run(EurekaServer_7002.class, args);
}
}
-----------------------------------------------------------------------------------------
server:
port: 7003
spring:
application:
name: localhost3
eureka:
client:
register-with-eureka: false
fetch-registry: false
service-url:
defaultZone: http://localhost1:7001/eureka/,http://localhost2:7002/eureka/
-----------------------------------------------------------------------------------------
package com.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
/**
* Description: 配置springcloud-eureka-7003的启动类
* Date: 2022/7/6 20:17
*
* @author gaoyu
* @version 1.0
*/
@EnableEurekaServer
@SpringBootApplication
public class EurekaServer_7003 {
public static void main(String[] args) {
SpringApplication.run(EurekaServer_7003.class, args);
}
}
第四步，在hosts文件中添加本地访问路径，更真实的模拟集群的搭建环境，能够有效提高对Eureka服务集群的理解。hosts文件路径C:\Windows\System32\drivers\etc（注意：该文件默认无法修改，右键点击hosts文件——属性——只读。为了安全起见，在文件修改保存后，将该文件重新设定为“只读”）。
第五步，点击主启动类运行测试，运行成功后在浏览器中分别输入localhost:7001、localhost:7002、localhost:7003进行查看。在此，EurekaServer集群搭建完成。
3.SpringCloud-Ribbon
Spring Cloud Ribbon 是一套基于 Netflix Ribbon 实现的客户端负载均衡和服务调用工具。Ribbon 是 Spring Cloud Netflix 模块的子模块，它是 Spring Cloud 对 Netflix Ribbon 的二次封装。通过它，我们可以将面向服务的 REST 模板（RestTemplate）请求转换为客户端负载均衡的服务调用。同时Ribbon属于进程内负载均衡，将负载均衡逻辑集成到消费方，消费方从服务注册中心获知那些地址可用，然后自己再从这些地址中选择一个合适的服务器。
1.SpringCloud-Provider
SpringCloud-Provider是作为服务的提供方，为服务的消费者提供方法操作。同时为了方便测试Ribbon负载均衡策略，可以选择创建两个完全相同但是只有查询的数据库不同的SpringCloud-Provider（端口号分别为8001和8002，这里只展示8001端口服务提供者的详细代码编写，8002端口查询的数据库为springcloud_my2），默认为轮询策略。（剩余的Dao层、Service层并没有其他的改变，可以自行编写）
server:
port: 8001
mybatis:
config-location: classpath:mybatis/mybatis-config.xml
mapper-locations: classpath:mybatis/mapper/*.xml
type-aliases-package: com.springcloud.pojo
spring:
application:
name: springcloud-provider #服务的唯一标识符，服务的消费者就是根据该标识符去寻找服务的提供者
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/springcloud_my?useUnicode=true&characterEncoding=utf-8
username: root
password: gaoyu520
eureka:
client:
service-url: #将服务注册到eureka中
defaultZone: http://localhost1:7001/eureka/,http://localhost2:7002/eureka/,http://localhost3:7003/eureka/
instance:
instance-id: springcloud-provider-8001 #eureka上的描述信息
prefer-ip-address: true #点击服务路径显示ip地址
info: #添加对该服务提供者的描述信息
app.name: springcloud-provider-8001
company.name: chuanxi
author.name: gaoyu
-----------------------------------------------------------------------------------------
package com.springcloud.controller;
import com.springcloud.pojo.Student;
import com.springcloud.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* Description:
* Date: 2022/7/7 8:06
*
* @author gaoyu
* @version 1.0
*/
@RestController
public class StudentController {
@Autowired
private StudentService studentService;
@PostMapping("student/insert")
public void insertStudent(Student student) {
studentService.insertStudent(student);
}
@GetMapping("student/delete/{id}")
public void deleteStudent(@PathVariable("id") int id) {
studentService.deleteStudent(id);
}
@PostMapping("student/update")
public Student updateStudent(Student student) {
return studentService.updateStudent(student);
}
@GetMapping("student/select/{id}")
public Student selectStudent(@PathVariable("id") int id) {
return studentService.selectStudent(id);
}
@GetMapping("student/selectAll")
public List selectAllStudent() {
return studentService.selectAllStudent();
}
}
-----------------------------------------------------------------------------------------
package com.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
/**
* Description: 配置springcloud-provider-8001的启动类
* Date: 2022/7/6 21:41
*
* @author gaoyu
* @version 1.0
*/
@EnableEurekaClient //开启Eureka客户端自动注解
@EnableDiscoveryClient //开启自动注解，让服务端发现该客户端
@SpringBootApplication
public class Provider_8001 {
public static void main(String[] args) {
SpringApplication.run(Provider_8001.class, args);
}
} 为了方便测试，我们这里只启动一个EurekaServer_7001和Provider_8001两个服务。这里我们仅仅测试查询所有学生的功能，剩余的大家可自行测试。
2.SpringCloud-Consumer
SpringCloud-Consumer作为服务的消费方，同时Ribbon的负载均衡策略也是在Consumer方实现。
server:
port: 80
eureka:
client:
#只是消费方，并不需要像服务中心注册自己（就好比顾客在商店里买东西）
register-with-eureka: false
service-url:
defaultZone: http://localhost1:7001/eureka/,http://localhost2:7002/eureka/,http://localhost3:7003/eureka/
-----------------------------------------------------------------------------------------
package com.springcloud.config;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
/**
* Description: 注入相关的Bean对象
* Date: 2022/7/7 17:13
*
* @author gaoyu
* @version 1.0
*/
@Configuration
public class ConfigBean {
@Bean
@LoadBalanced //配置负载均衡，提供RestTemplate
public RestTemplate restTemplate(){
return new RestTemplate();
}
}
-----------------------------------------------------------------------------------------
package com.springcloud.controller;
import com.springcloud.pojo.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.List;
/**
* Description: 作为消费者提供方法
* Date: 2022/7/7 17:21
*
* @author gaoyu
* @version 1.0
*/
@RestController
public class StudentController {
private static final String REST_URL_PREFIX = "http://springcloud-provider";
@Autowired
private RestTemplate restTemplate;
@RequestMapping("/consumer/student/insert")
public Boolean insertStudent(Student student){
return restTemplate.postForObject(REST_URL_PREFIX + "/student/insert", student, Boolean.class);
}
@RequestMapping("/consumer/student/delete/{id}")
public Boolean deleteStudent(@PathVariable("id") int id){
return restTemplate.postForObject(REST_URL_PREFIX + "/student/delete/" + id, id, Boolean.class);
}
@RequestMapping("/consumer/student/update")
public Boolean updateStudent(Student student){
return restTemplate.postForObject(REST_URL_PREFIX + "/student/update", student, Boolean.class);
}
@RequestMapping("/consumer/student/select/{id}")
public Student selectStudent(@PathVariable("id") int id){
return restTemplate.getForObject(REST_URL_PREFIX + "/student/select/" + id, Student.class);
}
@RequestMapping("/consumer/student/selectAll")
public List selectAllStudent(){
return restTemplate.getForObject(REST_URL_PREFIX + "/student/selectAll", List.class);
}
}
-----------------------------------------------------------------------------------------
package com.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
/**
* Description: 配置springcloud-consumer-80启动器
* Date: 2022/7/7 16:59
*
* @author gaoyu
* @version 1.0
*/
//Ribbon客户端，通过value寻找在eureka中提供方（如果有多个服务提供方，可选择使用RibbonClients）
@RibbonClient(value = "springcloud-provider")
@EnableEurekaClient //启动eureka客户端自动注解
@SpringBootApplication
public class Consumer_80 {
public static void main(String[] args) {
SpringApplication.run(Consumer_80.class, args);
}
}
这里我们打开Eureka-7001、Provider-8001、Provider-8002以及Consumer-80端口进行测试（注意，80端口可能会被SQL Server占用。可在系统内部搜索“IIS”打开后右键点击服务选择停止，该服务每次电脑重新启动时候会自动打开）。这里我们可以看到同样的请求路径，会得到两种结果，这是因为我们在两个服务的提供者中查找的是两个不同的数据库，因此第一次查询会在“springcloud_my”中获取结果，第二次查询会在“springcloud_my2”中获取结果。根据轮询策略，每次服务请求都会在多个服务中依次查询。
4.SpringCloud-Feign
SpringCloud-Feign是一个声明式的伪 Http 客户端，它使得写 Http 客户端变得更简单。使用 Feign，只需要创建一个接口并注解。它具有可插拔的注解特性，Feign 支持可插拔的编码器和解码器。Feign 默认集成了 Ribbon，并和 Eureka 结合，默认实现了负载均衡的效果(所以说服务消费者一般使用Feign)。
第一步，我们在springcloud-api中创建StudentService接口并编写相对应的方法。
package com.springcloud.service;
import com.springcloud.pojo.Student;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import java.util.List;
/**
* Description: 在springcloud-api中编写，通过Feign接口的方式调用服务
* Date: 2022/7/7 21:05
*
* @author gaoyu
* @version 1.0
*/
//Feign客户端通过value在Eureka注册中心查找该服务的提供者
@FeignClient(value = "springcloud-provider")
public interface StudentService {
@PostMapping("student/insert")
public Boolean insertStudent(Student student);
@PostMapping("student/delete/{id}")
public Boolean deleteStudent(@PathVariable("id") int id);
@PostMapping("student/update")
public Boolean updateStudent(Student student);
@GetMapping("student/select/{id}")
public Student selectStudent(@PathVariable("id") int id);
@GetMapping("student/selectAll")
public List selectAllStudent();
} 第二步，我们创建springcloud-consumer-feign-80 Module，并在该Module中配置application.yml文件。
server:
port: 80
eureka:
client:
register-with-eureka: false #作为消费者不需要将信息注册到服务中心
service-url:
defaultZone: http://localhost1:7001/eureka/,http://localhost2:7002/eureka/,http://localhost3:7003/eureka/第三步，在springcloud-consumer-feign-80中编写StudentFeignController类，通过接口的方式去请求服务提供者提供的方法
package com.springcloud.controller;
import com.springcloud.pojo.Student;
import com.springcloud.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* Description: 作为Consumer方，通过接口调用Provider提供的服务
* Date: 2022/7/7 21:23
*
* @author gaoyu
* @version 1.0
*/
@RestController
public class StudentFeignController {
@Autowired
private StudentService service;
@RequestMapping("consumer/student/insert")
public Boolean insertStudent(Student student){
return service.insertStudent(student);
}
@RequestMapping("consumer/student/delete/{id}")
public Boolean deleteStudent(@PathVariable("id") int id){
return service.deleteStudent(id);
}
@RequestMapping("consumer/student/update")
public Boolean updateStudent(Student student){
return service.updateStudent(student);
}
@RequestMapping("consumer/student/select/{id}")
public Student selectStudent(@PathVariable("id") int id){
return service.selectStudent(id);
}
@RequestMapping("consumer/student/selectAll")
public List selectAllStudent(){
return service.selectAllStudent();
}
}
第四步，编写springcloud-consumer-feign-80的启动类。
package com.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* Description: 配置springcloud-consumer-feign-80启动类
* Date: 2022/7/7 21:20
*
* @author gaoyu
* @version 1.0
*/
@EnableFeignClients(basePackages = {"com.springcloud"})
@EnableEurekaClient
@SpringBootApplication
public class ConsumerFeign_80 {
public static void main(String[] args) {
SpringApplication.run(ConsumerFeign_80.class, args);
}
}第五步，这里我们打开Eureka-7001、Provider-8001、Provider-8002以及ConsumerFeign-80端口进行测试，测试结果与使用RestTemplate调用服务方式相同。
5.SpringCloud-Hystrix
Spring Cloud Hystrix 是基于 Netflix 公司的开源组件 Hystrix 实现的，它提供了熔断器功能，能够有效地阻止分布式微服务系统中出现联动故障，以提高微服务系统的弹性。Spring Cloud Hystrix 具有服务降级、服务熔断、线程隔离、请求缓存、请求合并以及实时故障监控等强大功能。
1.Hystrix服务熔断
Hystrix服务熔断机制是为了应对雪崩效应而出现的一种微服务链路保护机制。 当微服务系统中的某个微服务不可用或响应时间太长时，为了保护系统的整体可用性，熔断器会暂时切断请求对该服务的调用，并快速返回一个友好的错误响应。这里我们将创建一个springcloud-provider-hystrix-8001 Module，将原有的spingcloud-provider-8001 Module 复制并粘贴src目录，即在原有的Module上进行修改即可。
第一步，我们在springcloud-provider-hystrix-8001中StudentController添加selectStudent的备选方案selectStudentHystrix，通过@HystrixCommand注解将备选方案与该方法进行绑定。这样，当我们服务的请求抛出错误的时候，页面会展现给用户我们预先设定好的结果以便增强用户的体验感。
package com.springcloud.controller;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.springcloud.pojo.Student;
import com.springcloud.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* Description: 这里通过服务熔断，在服务发生错误的时候调用备选方案执行结果
* Date: 2022/7/7 8:06
*
* @author gaoyu
* @version 1.0
*/
@RestController
public class StudentController {
@Autowired
private StudentService studentService;
@GetMapping("student/select/{id}")
//通过HystrixCommand绑定该服务出现问题后，调用的备选方案
@HystrixCommand(fallbackMethod = "selectStudentHystrix")
public Student selectStudent(@PathVariable("id") int id) {
Student student = studentService.selectStudent(id);
//当返回的结果为空时，系统抛出错误。此时通过服务熔断将调用绑定的备选方案执行
if (student == null){
throw new RuntimeException("id=>" + id + "，不存在该用户，或者信息无法找到~");
}
return student;
}
//备选方法
public Student selectStudentHystrix(@PathVariable("id") int id){
return new Student()
.setId(id)
.setName("id=>" + id + "，没有对应的信息，null--@Hystrix")
.setDb_source("no this database in MySql");
}
}第二步，编写springcloud-provider-hystrix-8001的启动类
package com.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
/**
* Description: 配置springcloud-provider-hystrix-8001的启动类
* Date: 2022/7/6 21:41
*
* @author gaoyu
* @version 1.0
*/
@EnableEurekaClient //开启Eureka客户端自动注解
@EnableCircuitBreaker //添加对熔断的支持
@EnableDiscoveryClient //开启自动注解，让服务端发现该客户端
@SpringBootApplication
public class ProviderHystrix_8001 {
public static void main(String[] args) {
SpringApplication.run(ProviderHystrix_8001.class, args);
}
}
第三步，这里我们打开Eureka-7001、ProviderHystrix-8001以及ConsumerFeign-80端口进行测试，当查找的内容不存在（系统报错的情况下，页面会跳出事先设定好的信息展现给用户）。
2.Hystrix服务降级
Hystrix 提供了服务降级功能，能够保证当前服务不受其他服务故障的影响，提高服务的健壮性。
第一步，我们在springcloud-api中添加StudentService的回调工厂StudentServiceFallbackFactory，并且实现FallbackFactory接口。
package com.springcloud.service;
import com.springcloud.pojo.Student;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Description: 添加服务降级后返回给用户的信息
* Date: 2022/7/10 15:46
*
* @author gaoyu
* @version 1.0
*/
@Component
public class StudentServiceFallbackFactory implements FallbackFactory {
@Override
public Object create(Throwable throwable) {
return new StudentService() {
@Override
public Boolean insertStudent(Student student) {
return null;
}
@Override
public Boolean deleteStudent(int id) {
return null;
}
@Override
public Boolean updateStudent(Student student) {
return null;
}
@Override
public Student selectStudent(int id) {
return new Student()
.setId(id)
.setName("id=>" + id + "没有对应得信息，客户端提供了降级得信息，这个服务现在已经被关闭")
.setDb_source("该服务暂时不提供任何返回数据");
}
@Override
public List selectAllStudent() {
return null;
}
};
}
}
第二步，在原先springcloud-api中StudentService接口上绑定该FallbackFactory。
@FeignClient(value = "springcloud-provider", fallbackFactory = StudentServiceFallbackFactory.class)第三步，在服务消费端springcloud-consumer-feign-80开启服务降级。
feign:
hystrix:
enabled: true第四步，这里我们打开Eureka-7001以及ConsumerFeign-80端口进行测试。此时我们并没有启动服务提供者，但是程序仍然能够正常的运行（当然只是返回了固定的结果，不过也总比直接给用体验“报错”的结果要好的太多）。
3.Hystrix服务监控
Hystrix Dashboard是Hystrix熔断器的一个组件，它向用户提供了相对友好的图形化界面来监控接口访问数据。
第一步，我们创建springcloud-consumer-hystrix-dashboard-6001 Module，并配置application.yml文件（这里只需要配置端口号）。
server:
port: 6001第二步，编写springcloud-consumer-hystrix-dashboard-6001启动类。
package com.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
/**
* Description: 配置启动类
* Date: 2022/7/10 21:35
*
* @author gaoyu
* @version 1.0
*/
@EnableHystrixDashboard
@SpringBootApplication
public class StudentConsumerDashboard_6001 {
public static void main(String[] args) {
SpringApplication.run(StudentConsumerDashboard_6001.class, args);
}
}第三步，在springcloud-provider-hystrix-8001 Module中，将服务注册注入Bean中。
package com.springcloud;
import com.netflix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
/**
* Description: 配置springcloud-provider-hystrix-8001的启动类
* Date: 2022/7/6 21:41
*
* @author gaoyu
* @version 1.0
*/
@EnableEurekaClient //开启Eureka客户端自动注解
@EnableCircuitBreaker //添加对熔断的支持
@EnableDiscoveryClient //开启自动注解，让服务端发现该客户端
@SpringBootApplication
public class ProviderHystrix_8001 {
public static void main(String[] args) {
SpringApplication.run(ProviderHystrix_8001.class, args);
}
@Bean
public ServletRegistrationBean registrationBean(){
ServletRegistrationBean registrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
registrationBean.addUrlMappings("/actuator/hystrix.stream");
return registrationBean;
}
}第四步，启动springcloud-eureka-7001、springcloud-provider-hystrix-8001、springcloud-consumer-hystrix-dashboard-6001、springcloud-consumer-feign-80进行测试。通过发送各种请求来动态的获取服务监控页面的变化。（注意：这里首先要在消费者端向服务端发出请求，否则监控页面将无法显示正常画面，而是一直Loading。。。）
总结
以上就是今天要讲的内容，本文仅仅简单介绍了SpringCloud部分简单的使用，个人也是初学者，编写本篇文章也是为了加强学习SpringCloud。如果哪有错误，也希望大家在底下留言评论。