spring cloud

AVICCI

于 2024-07-23 00:31:35 发布

阅读量548

点赞数 16

本文链接：https://blog.csdn.net/AVICCI/article/details/140622625

版权

1、学习前言

1.1、文章大纲

spring cloud五大组件

服务注册与发现 eureka
负载均衡
- 客户端负载均衡 ribbon
- 服务端负载均衡 feign(也是依赖于ribbon，只是将调用方式RestTemplete更改成Service接口)
熔断器 hystrix
服务网关 zuul
分布式配置 spring cloud config

2、微服务

2.1、什么是微服务

什么是微服务

微服务(Microservice Architecture) 是近几年流行的一种架构思想，关于它的概念很难一言以蔽之。

究竟什么是微服务呢？我们在此引用ThoughtWorks 公司的首席科学家 Martin Fowler 于2014年提出的一段话：

原文：Microservices

汉化：https://www.cnblogs.com/liuning8023/p/4493156.html

就目前而言，对于微服务，业界并没有一个统一的标准的定义
但通常而言，微服务架构是一种架构模式，或者说是一种架构风格，将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值，服务之间采用轻量级的通信机制(HTTP)互相沟通，每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应该根据业务上下文，选择合适的语言，工具(如：Maven)对其进行构建，可以有一个非常轻量级的集中式管理来协调这些服务，可以使用不同的语言来编写服务，也可以使用不同的数据存储。

再从技术维度角度理解：

微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底地去耦合，每一个微服务提供单个业务功能的服务，一个服务做一件事情，从技术角度看就是一种小而独立的处理过程，类似进程的概念，能够自行单独启动或销毁，拥有自己独立的数据库。

2.2、微服务的优缺点

优点

每个服务足够内聚，足够小，代码容易理解，这样能聚焦一个指定的业务功能或业务需求；
开发简单，开发效率高，一个服务可能就是专一的只干一件事；
微服务能够被小团队单独开发，这个团队只需2-5个开发人员组成；
微服务是松耦合的，是有功能意义的服务，无论是在开发阶段或部署阶段都是独立的；
微服务能使用不同的语言开发；
易于和第三方集成，微服务允许容易且灵活的方式集成自动部署，通过持续集成工具，如jenkins，Hudson，bamboo；
微服务易于被一个开发人员理解，修改和维护，这样小团队能够更关注自己的工作成果，无需通过合作才能体现价值；
微服务允许利用和融合最新技术；
微服务只是业务逻辑的代码，不会和HTML，CSS，或其他的界面混合;
每个微服务都有自己的存储能力，可以有自己的数据库，也可以有统一的数据库

缺点

开发人员要处理分布式系统的复杂性；
多服务运维难度，随着服务的增加，运维的压力也在增大；
系统部署依赖问题；
服务间通信成本问题；
数据一致性问题；
系统集成测试问题；
性能和监控问题；

3、spring cloud入门概述

3.1、spring cloud是什么？

spring官网：Spring | Home

3.2、spring cloud和springboot的关系

SpringBoot专注于开发单个个体微服务；
SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务，整合并管理起来，为各个微服务之间提供：配置管理、服务发现、断路器、路由、为代理、事件总栈、全局锁、决策竞选、分布式会话等等集成服务；
SpringBoot可以离开SpringCloud独立使用，开发项目，但SpringCloud离不开SpringBoot，属于依赖关系；
SpringBoot专注于快速、方便的开发单个个体微服务，SpringCloud关注全局的服务治理框架；

3.3、springcloud与dobbo对比

	Dubbo	SpringCloud
服务注册中心	Zookeeper	Spring Cloud Netfilx Eureka
服务调用方式	RPC	REST API
服务监控	Dubbo-monitor	Spring Boot Admin
熔断器	不完善	Spring Cloud Netfilx Hystrix
服务网关	无	Spring Cloud Netfilx Zuul
分布式配置	无	Spring Cloud Config
服务跟踪	无	Spring Cloud Sleuth
消息总栈	无	Spring Cloud Bus
数据流	无	Spring Cloud Stream
批量任务	无	Spring Cloud Task

最大区别：Spring Cloud 抛弃了Dubbo的RPC通信，采用的是基于HTTP的REST方式

严格来说，这两种方式各有优劣。虽然从一定程度上来说，后者牺牲了服务调用的性能，但也避免了上面提到的原生RPC带来的问题。而且REST相比RPC更为灵活，服务提供方和调用方的依赖只依靠一纸契约，不存在代码级别的强依赖，这个优点在当下强调快速演化的微服务环境下，显得更加合适。

3.4、springcloud能干嘛?

Distributed/versioned configuration 分布式/版本控制配置
Service registration and discovery 服务注册与发现
Routing 路由
Service-to-service calls 服务到服务的调用
Load balancing 负载均衡配置
Circuit Breakers 断路器
Distributed messaging 分布式消息管理

3.5、springcloud下载

官网：Spring Cloud

自学参考：

SpringCloud Netflix 中文文档：https://springcloud.cc/spring-cloud-netflix.html
SpringCloud 中文API文档(官方文档翻译版)：https://springcloud.cc/spring-cloud-dalston.html
SpringCloud中文网：https://springcloud.cc

4、springcloud rest学习环境搭建：服务提供者+服务消费者

1、新建一个数据库db-01，再新建一张表dept

create table dept
(
    dept_no   bigint auto_increment comment '部门编号'
        primary key,
    dept_name varchar(60) null comment '部门名称',
    db_source varchar(60) null comment '数据源'
)
    comment '部门表';

初始化表数据

insert into dept(dept_name, db_source) VALUE
    ('开发部门',database()),
    ('运营部门',database()),
    ('销售部门',database()),
    ('财务部门',database()),
    ('人事部门',database());

2、新建项目

代码见：springcloud-01: 狂神说java-springcloud--springcloud rest学习环境搭建：服务提供者+服务消费者

import com.zyy.dept.entity.Dept;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;


@RestController

@RequestMapping("/consumer")
public class DeptControllerController {

    private final RestTemplate restTemplate;


    public DeptControllerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    /**
     * http://localhost:8001/dept/addDept
     */
    private static final String REST_URL_PREFIX = "http://localhost:8001";


    @RequestMapping(value = "/getAll", method = RequestMethod.GET)
    public List<Dept> getAll() {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/getAll", List.class);
    }

    @RequestMapping(value = "/get/{deptNo}", method = RequestMethod.GET)
    public Dept getByNo(@PathVariable long deptNo) {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + deptNo, Dept.class);
    }

    @RequestMapping(value = "/addDept", method = RequestMethod.POST)
    public Boolean addDept(@RequestBody Dept dept) {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/addDept", Boolean.class, dept);
    }
}

消费者，可以直接通过RestTemplate访问服务提供者暴露的接口

5、Eureka服务注册中心

5.1、什么是Eureka

Netflix在涉及Eureka时，遵循的就是API原则
Eureka是Netflix的有个子模块，也是核心模块之一。Eureka是基于REST的服务，用于定位服务，以实现云端中间件层服务发现和故障转移，服务注册与发现对于微服务来说是非常重要的，有了服务注册与发现，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务调用的配置文件了，功能类似于Dubbo的注册中心，比如Zookeeper

5.2、原理解释

Eureka基础的架构

Springcloud 封装了Netflix公司开发的Eureka模块来实现服务注册与发现 (对比Zookeeper)
Eureka采用了C-S的架构设计，EurekaServer作为服务注册功能的服务器，他是服务注册中心
而系统中的其他微服务，使用Eureka的客户端连接到EurekaServer并维持心跳连接。这样系统的维护人员就可以通过EurekaServer来监控系统中各个微服务是否正常运行，Springcloud 的一些其他模块 (比如Zuul) 就可以通过EurekaServer来发现系统中的其他微服务，并执行相关的逻辑
Eureka 包含两个组件：Eureka Server 和 Eureka Client
Eureka Server 提供服务注册，各个节点启动后，会在EurekaServer中进行注册，这样Eureka Server中的服务注册表中将会储存所有服务节点的信息，服务节点的信息可以在界面中直观的看到
Eureka Client 是一个Java客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的，使用轮询负载算法的负载均衡器。在应用启动后，将会向EurekaServer发送心跳 (默认周期为30秒) 。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除掉 (默认周期为90s)

三大角色

Eureka Server：提供服务的注册与发现
Service Provider：服务生产方，将自身服务注册到Eureka中，从而使服务消费方能够找到
Service Consumer：服务消费方，从Eureka中获取注册服务列表，从而找到消费服务

5.3、构建步骤

eureka-server

新建模块springcloud-eureka-7001

导包

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.zyy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-eureka-7001</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
    </dependencies>
    
</project>

配置文件application.yaml

server:
  port: 7001

eureka:
  instance:
    hostname: localhost
  client:
    # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    register-with-eureka: false
    # fetch-registry如果为false,则表示自己为注册中心,客户端的化为 ture
    fetch-registry: false
    #            this.serviceUrl.put("defaultZone", "http://localhost:8761/eureka/");
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;


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

启动服务，浏览器打开：http://localhost:7001/

eureka-client

调整之前的服务提供者模块springcloud-provider-dept-8001

导入eureka依赖

        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

application.yaml中新增eureka配置

# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/

启动类添加@EnableEurekaClient注解

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

启动eurake服务端口，在启动服务提供者，然后打开访问监控页http://localhost:7001/,如下：

修改application和status中的信息，修改配置如下：

eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: dept-provider:8001
    
spring:
  # 应用名
  application:
    name: dept-provider

结果如下：

如果此时停掉springcloud-provider-dept-8001 等30s后监控会开启保护机制：

配置关于服务加载的监控信息

pom.xml中添加依赖

        <!--     actuator完善监控信息   -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

application.yaml中添加配置

info:
  app.name: zyy-springcloud
  company.name: 中国有家公司

点击status下面地址仍然404的话，加上如下配置

management:
  endpoints:
    web:
      exposure:
        include: "*"

如下：

eureka自我保护机制：好死不如赖活着

一句话总结就是：某时刻某一个微服务不可用，eureka不会立即清理，依旧会对该微服务的信息进行保存！

默认情况下，当eureka server在一定时间内没有收到实例的心跳，便会把该实例从注册表中删除（默认是90秒），但是，如果短时间内丢失大量的实例心跳，便会触发eureka server的自我保护机制，比如在开发测试时，需要频繁地重启微服务实例，但是我们很少会把eureka server一起重启（因为在开发过程中不会修改eureka注册中心），当一分钟内收到的心跳数大量减少时，会触发该保护机制。可以在eureka管理界面看到Renews threshold和Renews(last min)，当后者（最后一分钟收到的心跳数）小于前者（心跳阈值）的时候，触发保护机制，会出现红色的警告：EMERGENCY!EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT.RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEGING EXPIRED JUST TO BE SAFE.从警告中可以看到，eureka认为虽然收不到实例的心跳，但它认为实例还是健康的，eureka会保护这些实例，不会把它们从注册表中删掉
该保护机制的目的是避免网络连接故障，在发生网络故障时，微服务和注册中心之间无法正常通信，但服务本身是健康的，不应该注销该服务，如果eureka因网络故障而把微服务误删了，那即使网络恢复了，该微服务也不会重新注册到eureka server了，因为只有在微服务启动的时候才会发起注册请求，后面只会发送心跳和服务列表请求，这样的话，该实例虽然是运行着，但永远不会被其它服务所感知。所以，eureka server在短时间内丢失过多的客户端心跳时，会进入自我保护模式，该模式下，eureka会保护注册表中的信息，不在注销任何微服务，当网络故障恢复后，eureka会自动退出保护模式。自我保护模式可以让集群更加健壮
但是我们在开发测试阶段，需要频繁地重启发布，如果触发了保护机制，则旧的服务实例没有被删除，这时请求有可能跑到旧的实例中，而该实例已经关闭了，这就导致请求错误，影响开发测试。所以，在开发测试阶段，我们可以把自我保护模式关闭，只需在eureka server配置文件中加上如下配置即可：eureka.server.enable-self-preservation=false【不推荐关闭自我保护机制】

注册进来的微服务，获取一些消息

服务提供者的启动类增加方法

import com.zyy.dept.entity.Dept;
import com.zyy.dept.service.DeptService;
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.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
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;

/**
 * <p>
 * 部门表 前端控制器
 * </p>
 *
 * @author zyy
 * @since 2023-02-07
 */
@RestController
@RequestMapping("/dept")
public class DeptController {

    //...
    @Autowired
    private DiscoveryClient discoveryClient;

    //...

    @RequestMapping(value = "/get/discovery", method = RequestMethod.GET)
    public Object getDiscovery() {
        List<String> services = discoveryClient.getServices();
        System.out.println("discoveryClient=====services：" + services);
        List<ServiceInstance> instances = discoveryClient.getInstances("DEPT-PROVIDER");
        for (ServiceInstance in : instances) {
            System.out.println(in.getHost() + "\t" //主机名称
                    + in.getPort() + "\t" //端口号
                    + in.getUri() + "\t" //uri
                    + in.getServiceId()); //服务id
        }
        return this.discoveryClient;
    }

}

在主启动类加入@EnableDiscoveryClient

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;

@SpringBootApplication
/**
 * 开启Eureka客户端注解，在服务启动后自动向注册中心注册服务
 */
@EnableEurekaClient
/**
 * @EnableEurekaClient 开启服务发现客户端的注解，可以用来获取一些配置的信息，得到具体的微服务
 */
@EnableDiscoveryClient
public class SpringBootDeptApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDeptApplication.class, args);
    }
}

请求接口，显示如下：

控制台打印如下：

5.4、Eureka:集群环境配置

初始化

新建springcloud-eureka-7002、springcloud-eureka-7003模块，同springcloud-eureka-7001

pom添加包依赖（7002、7003）

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
    </dependencies>

添加配置项（7003改一下端口即可）

server:
  port: 7002

eureka:
  instance:
    hostname: localhost
  client:
    # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    register-with-eureka: false
    # fetch-registry如果为false,则表示自己为注册中心,客户端的化为 ture
    fetch-registry: false
    #            this.serviceUrl.put("defaultZone", "http://localhost:8761/eureka/");
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

启动类（7003改类名和main方法即可）

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;


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

集群成员互相关联

配置一些自定义本机名字，找到本机hosts文件并打开

路径C:\Windows\System32\drivers\etc

在hosts文件最后加上，要访问的本机名称，默认是localhost

修改application.yaml的配置，如图为springcloud-eureka-7001配置，springcloud-eureka-7002/springcloud-eureka-7003同样分别修改为其对应的名称即可

在集群中使springcloud-eureka-7001关联springcloud-eureka-7002、springcloud-eureka-7003

完整的springcloud-eureka-7001下的application.yaml如下

server:
  port: 7001

eureka:
  instance:
    hostname: eureka7001
  client:
    # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    register-with-eureka: false
    # fetch-registry如果为false,则表示自己为注册中心,客户端的化为 ture
    fetch-registry: false
    #            this.serviceUrl.put("defaultZone", "http://localhost:8761/eureka/");
    service-url:
      defaultZone: http://eureka7002:7002/,http://eureka7003:7003/

同时在集群中使springcloud-eureka-7002关联springcloud-eureka-7001、springcloud-eureka-7003

完整的springcloud-eureka-7002下的application.yaml如下

server:
  port: 7002

eureka:
  instance:
    hostname: eureka7002
  client:
    # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    register-with-eureka: false
    # fetch-registry如果为false,则表示自己为注册中心,客户端的化为 ture
    fetch-registry: false
    #            this.serviceUrl.put("defaultZone", "http://localhost:8761/eureka/");
    service-url:
      defaultZone: http://eureka7001:7001/,http://eureka7003:7003/

springcloud-eureka-7003配置方式同理可得.

通过springcloud-provider-dept-8001下的yml配置文件，修改Eureka配置：配置服务注册中心地址

# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  instance:
    instance-id: dept-provider:8001

这样模拟集群就搭建好了，就可以把一个项目挂载到三个服务器上了

5.5、对比和zookeeper区别

ACID是什么

A (Atomicity) 原子性
C (Consistency) 一致性
I (Isolation) 隔离性
D (Durability)持久性

CAP是什么

C (Consistency) 强一致性
A (Availability) 可用性
P (Partition tolerance) 分区容错性

CAP的三进二：CA、CP、AP

CAP理论的核心

一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求
根据CAP原理，将NoSQL数据库分成了满足CA原则、满足CP原则、满足AP原则三大类
- CA：单点集群，满足一致性和可用性的系统，通常可拓展性较差
- CP：满足一致性，分区容错的系统，通常性能不是特别高
- AP：满足可用性，分区容错的系统，通常可能对一致性要求低一些

作为分布式服务注册中心，Eureka比Zookeeper好在哪里？

CAP理论指出，一个分布式系统不可能同时满足C (一致性) 、A (可用性) 、P (容错性)，由于分区容错性P再分布式系统中是必须要保证的，因此我们只能再A和C之间进行权衡。

Zookeeper 保证的是 CP —> 满足一致性，分区容错的系统，通常性能不是特别高
Eureka 保证的是 AP —> 满足可用性，分区容错的系统，通常可能对一致性要求低一些

Zookeeper保证的是CP

当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的注册信息，但不能接收服务直接down掉不可用。也就是说，服务注册功能对可用性的要求要高于一致性。但zookeeper会出现这样一种情况，当master节点因为网络故障与其他节点失去联系时，剩余节点会重新进行leader选举。问题在于，选举leader的时间太长，30-120s，且选举期间整个zookeeper集群是不可用的，这就导致在选举期间注册服务瘫痪。在云部署的环境下，因为网络问题使得zookeeper集群失去master节点是较大概率发生的事件，虽然服务最终能够恢复，但是，漫长的选举时间导致注册长期不可用，是不可容忍的。

Eureka保证的是AP

Eureka看明白了这一点，因此在设计时就优先保证可用性。Eureka各个节点都是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而Eureka的客户端在向某个Eureka注册时，如果发现连接失败，则会自动切换至其他节点，只要有一台Eureka还在，就能保住注册服务的可用性，只不过查到的信息可能不是最新的，除此之外，Eureka还有自我保护机制，如果在15分钟内超过85%的节点都没有正常的心跳，那么Eureka就认为客户端与注册中心出现了网络故障，此时会出现以下几种情况：

Eureka不会从注册列表中移除因为长时间没收到心跳而应该过期的服务
Eureka仍然能够接受新服务的注册和查询请求，但是不会被同步到其他节点上 (即保证当前节点依然可用)
当网络稳定时，当前实例新的注册信息会被同步到其他节点中

因此，Eureka可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像zookeeper那样使整个注册服务瘫痪

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

6.1、负载均衡及ribbon

ribbon是什么？

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

ribbon能干嘛？

LB，即负载均衡 (LoadBalancer) ，在微服务或分布式集群中经常用的一种应用
负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA (高用)
常见的负载均衡软件有 Nginx、Lvs 等等
Dubbo、SpringCloud 中均给我们提供了负载均衡，SpringCloud 的负载均衡算法可以自定义
负载均衡简单分类
- 集中式LB
  
  即在服务的提供方和消费方之间使用独立的LB设施，如Nginx(反向代理服务器)，由该设施负责把访问请求通过某种策略转发至服务的提供方
- 进程式 LB
  
  将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器
  
  Ribbon 就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址

6.2、集成ribbon

springcloud-consumer-dept-80添加依赖

        <!--Ribbon-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <!--Eureka: Ribbon需要从Eureka服务中心获取要拿什么-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

配置eureka

# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
#    不向eureka注册自己
    register-with-eureka: false
#    检索服务选项，当设置为True(默认值)时，会进行服务检索,注册中心不负责检索服务
#    fetch-registry: true

启动类加上@EnableEurekaClient注解

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

配置类加@LoadBalanced注解

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;

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

修改controller

import com.zyy.dept.entity.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController

@RequestMapping("/consumer")
public class DeptControllerController {

    private RestTemplate restTemplate;

    public DeptControllerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    /**
     * http://localhost:8001/dept/addDept
     */
//    private static final String REST_URL_PREFIX = "http://localhost:8001";
    private static final String REST_URL_PREFIX = "http://DEPT-PROVIDER";


    @RequestMapping(value = "/getAll", method = RequestMethod.GET)
    public List<Dept> getAll() {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/getAll", List.class);
    }

    @RequestMapping(value = "/get/{deptNo}", method = RequestMethod.GET)
    public Dept getByNo(@PathVariable long deptNo) {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + deptNo, Dept.class);
    }

    @RequestMapping(value = "/addDept", method = RequestMethod.POST)
    public Boolean addDept(@RequestBody Dept dept) {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/addDept", Boolean.class, dept);
    }
}

这里直接用的在eureka注册的服务名

验证一下，可以正常调用（调用不了，可以排查一下是否是包冲突引起的）

6.3、使用ribbon实现负载均衡

在新建两个数据库，并建表，初始化表数据(db-02同下)

-- 创建数据库
CREATE DATABASE `db-03`  DEFAULT CHARACTER SET utf8 ;

-- 使用数据库
USE `db-03`;

-- 创建表

DROP TABLE IF EXISTS `dept`;

CREATE TABLE `dept` (
  `dept_no` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '部门编号',
  `dept_name` VARCHAR(60) DEFAULT NULL COMMENT '部门名称',
  `db_source` VARCHAR(60) DEFAULT NULL COMMENT '数据源',
  PRIMARY KEY (`dept_no`)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='部门表';

-- 初始化数据表
INSERT INTO dept(dept_name, db_source) VALUE
    ('开发部门',DATABASE()),
    ('运营部门',DATABASE()),
    ('销售部门',DATABASE()),
    ('财务部门',DATABASE()),
    ('人事部门',DATABASE());

在新建两个服务提供者springcloud-provider-dept-8002、springcloud-provider-dept-8003

和springcloud-provider-dept-8001都一样，修改一下配置项即可

改了端口号，数据库连接串，注册到eureka的实例名

# 端口号
server:
  port: 8002

# 配置mybatis

mybatis:
  mapper-locations: classpath:com/zyy/dept/mapper/*.xml
  config-location: classpath:com/zyy/dept/mybatis-config.xml

spring:
  # spring数据源配置
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://localhost:3306/db-02?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456
  # 应用名
  application:
    name: dept-provider

# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  instance:
    instance-id: dept-provider:8002

management:
  endpoints:
    web:
      exposure:
        include: "*"

info:
  app.name: zyy-springcloud
  company.name: 中国有家公司

启动这三个服务，均注册到eureka中
再次请求消费方的查询接口

再查一次

再查一下

发现有时候很多时候查的数据库都不一样

每次都随机访问集群中某个服务提供者，这种情况叫做轮询，轮询算法在SpringCloud中可以自定义。

如何切换规则呢？

在springcloud-consumer-dept-80模块下的配置类BeanConfig.java，配置不同的规则

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RoundRobinRule;
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;

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

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

重启服务，便可验证

如何自定义规则

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

自定义规则类（规则：每个服务访问5次，然后换下一个服务）MyRandomRule.java

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;

public class MyRandomRule extends AbstractLoadBalancerRule {

    /**
     * 每个服务访问5次则换下一个服务
     */
    private int total = 0;//被调用的次数
    private int currentIndex = 0;//当前是谁在提供服务


    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) {

    }

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

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        } else {
            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) {
                    return null;
                }

                if (total < 5) {
                    server = upList.get(currentIndex);
                    total++;
                } else {
                    total = 0;
                    currentIndex++;
                    if (currentIndex >= upList.size()) {
                        currentIndex = 0;
                    }
                }
                if (server == null) {
                    Thread.yield();
                } else {
                    if (server.isAlive()) {
                        return server;
                    }

                    server = null;
                    Thread.yield();
                }
            }

            return server;
        }
    }
}

注册bean MyRuleConfig.java

import com.netflix.loadbalancer.IRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


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

}

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

import com.my.MyRuleConfig;
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;


@SpringBootApplication
@EnableEurekaClient
//在微服务启动的时候就能加载自定义的Ribbon类(自定义的规则会覆盖原有默认的规则)
//开启负载均衡,并指定自定义的规则
@RibbonClient(name = "DEPT-PROVIDER", configuration = MyRuleConfig.class)
public class SpringBootConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootConsumerApplication.class, args);
    }
}

7、feign：负载均衡

7.1、feign简介

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

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

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

微服务名字【ribbon】
接口和注解【feign】

feign能干什么？

Feign旨在使编写Java Http客户端变得更容易
前面在使用Ribbon + RestTemplate时，利用RestTemplate对Http请求的封装处理，形成了一套模板化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一个客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步的封装，由他来帮助我们定义和实现依赖服务接口的定义，在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它 (类似以前Dao接口上标注Mapper注解，现在是一个微服务接口上面标注一个Feign注解)，即可完成对服务提供方的接口绑定，简化了使用Spring Cloud Ribbon 时，自动封装服务调用客户端的开发量。

Feign默认集成了Ribbon

利用Ribbon维护了服务提供者的服务列表信息，并且通过轮询实现了客户端的负载均衡，而与Ribbon不同的是，通过Feign只需要定义服务绑定接口且以声明式的方法，优雅而简单的实现了服务调用。

7.2、feign的使用步骤

新建一个模块springcloud-consumer-dept-feign-80

导包

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.zyy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-consumer-dept-feign-80</artifactId>

    <dependencies>

        <dependency>
            <groupId>com.zyy</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--SpringBoot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--Eureka: Ribbon需要从Eureka服务中心获取要拿什么-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

    </dependencies>

</project>

这里加了feign的包

配置文件

server:
  port: 80

# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
#    不向eureka注册自己
    register-with-eureka: false
#    检索服务选项，当设置为True(默认值)时，会进行服务检索,注册中心不负责检索服务
#    fetch-registry: true

新建配置类

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
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;


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

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

新建service（接口）

import com.zyy.dept.entity.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.util.List;

// @FeignClient:微服务客户端注解,value:指定微服务的名字,这样就可以使Feign客户端直接找到对应的微服务
@FeignClient(value = "DEPT-PROVIDER")
public interface DeptFeignService {
    @RequestMapping(value = "/dept/getAll", method = RequestMethod.GET)
    List<Dept> getAll();

    @RequestMapping(value = "/dept/get/{deptNo}", method = RequestMethod.GET)
    Dept getByNo(@PathVariable("deptNo") long deptNo);

    @RequestMapping(value = "/dept/addDept", method = RequestMethod.POST)
    Boolean addDept(@RequestBody Dept dept);
}

新建controller

import com.zyy.dept.entity.Dept;
import com.zyy.dept.service.DeptFeignService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
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;

@RestController
@RequestMapping("/consumer/feign/")
public class DeptFeignController {

    @Autowired
    private DeptFeignService deptService;


    @RequestMapping(value = "/getAll", method = RequestMethod.GET)
    public List<Dept> getAll() {
        return deptService.getAll();
    }

    @RequestMapping(value = "/get/{deptNo}", method = RequestMethod.GET)
    public Dept getByNo(@PathVariable("deptNo") long deptNo) {
        return deptService.getByNo(deptNo);
    }

    @RequestMapping(value = "/addDept", method = RequestMethod.POST)
    public Boolean addDept(@RequestBody Dept dept) {
        return deptService.addDept(dept);
    }
}

添加启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@EnableEurekaClient
//feign客户端注解
@EnableFeignClients(basePackages = {"com.zyy.dept"})
public class SpringBootConsumerFeignApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootConsumerFeignApplication.class, args);
    }
}

启动此服务，调用

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

7.3、feign和ribbon如何选择

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

Feign 本质上也是实现了 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

8.4、服务熔断

什么是服务熔断？

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

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

服务熔断解决如下问题：

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

入门案例

新建一个模块springcloud-provider-dept-hystrix-8001，复制springcloud-provider-dept-8001模块的代码和配置以及pom文件

导包（原有基础新增如下）

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

修改yaml中的eureka.instance.instance-id=dept-hystrix-provider:8000总的如下

# 端口号
server:
  port: 8000

# 配置mybatis

mybatis:
  mapper-locations: classpath:com/zyy/dept/mapper/*.xml
  config-location: classpath:com/zyy/dept/mybatis-config.xml

spring:
  # spring数据源配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://localhost:3306/db-01?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456
  # 应用名
  application:
    name: dept-provider

# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  instance:
    instance-id: dept-hystrix-provider:8000
    prefer-ip-address: false

management:
  endpoints:
    web:
      exposure:
        include: "*"

info:
  app.name: zyy-springcloud
  company.name: 中国有家公司

注意：prefer-ip-address，可以让这里显示服务器的ip,而不是localhost

修改controller方法

//...
@RestController
@RequestMapping("/dept")
public class DeptController {
    private final DeptService deptService;

    public DeptController(DeptService deptService) {
        this.deptService = deptService;
    }
    //...
    @RequestMapping(value = "/get/{deptNo}", method = RequestMethod.GET)
    public Dept getByNo(@PathVariable long deptNo) {
        Dept dept = deptService.getByNo(deptNo);
        if (dept == null) {
            throw new RuntimeException("这个deptNo==》" + deptNo + "，不存在该部门信息");
        }
        return dept;
    }
    //...
}

启动服务，输入一个不存在的部门号，直接抛出异常

再次修改controller

//...
@RestController
@RequestMapping("/dept")
public class DeptController {
    private final DeptService deptService;

    public DeptController(DeptService deptService) {
        this.deptService = deptService;
    }
    //...
    @HystrixCommand(fallbackMethod = "hystrixGetByNo")
    @RequestMapping(value = "/get/{deptNo}", method = RequestMethod.GET)
    public Dept getByNo(@PathVariable long deptNo) {
        Dept dept = deptService.getByNo(deptNo);
        if (dept == null) {
            throw new RuntimeException("这个deptNo==》" + deptNo + "，不存在该部门信息");
        }
        return dept;
    }
    public Dept hystrixGetByNo(@PathVariable long deptNo) {
        Dept dept = new Dept();
        dept.setDeptName("这个deptNo不存在");
        return dept;
    }
    //...
}

启动类添加注解@EnableCircuitBreaker

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;

@SpringBootApplication
/**
 * 开启Eureka客户端注解，在服务启动后自动向注册中心注册服务
 */
@EnableEurekaClient
/**
 * @EnableEurekaClient 开启服务发现客户端的注解，可以用来获取一些配置的信息，得到具体的微服务
 */
@EnableDiscoveryClient
/**
 * @EnableCircuitBreaker 添加对熔断的支持注解
 */
@EnableCircuitBreaker
public class SpringBootDeptHystrixApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDeptHystrixApplication.class, args);
    }
}

再次启动服务，输入一个不存在的部门号，如下

8.5、服务降级

什么是服务降级？

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

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

服务降级主要用于什么场景呢？当整个微服务架构整体的负载超出了预设的上限阈值或即将到来的流量预计将会超过预设的阈值时，为了保证重要或基本的服务能正常运行，可以将一些不重要或不紧急的服务或任务进行服务的延迟使用或暂停使用。

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

服务降级需要考虑的问题

那些服务是核心服务，哪些服务是非核心服务
那些服务可以支持降级，那些服务不能支持降级，降级策略是什么

自动降级分类

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

入门案例

修改springcloud-consumer-dept-feign-80模块。在service目录下新增一个DeptClientServiceFallBackFactory.java

import com.zyy.dept.entity.Dept;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;


@Component
public class DeptClientServiceFallBackFactory implements FallbackFactory {
    @Override
    public DeptFeignService create(Throwable throwable) {

        return new DeptFeignService() {
            @Override
            public List<Dept> getAll() {
                Dept dept = new Dept();
                dept.setDeptName("查询失败~");

                List<Dept> deptList = new ArrayList<>();
                deptList.add(dept);
                return deptList;
            }

            @Override
            public Dept getByNo(long deptNo) {
                Dept dept = new Dept();
                dept.setDeptName("查询" + deptNo + "为空~");
                return dept;
            }

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

再在原来DeptFeignService.java的@FeignClient加上fallbackFactory属性，总的代码如下

import com.zyy.dept.entity.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.util.List;


@FeignClient(value = "DEPT-PROVIDER", fallbackFactory = DeptClientServiceFallBackFactory.class)
public interface DeptFeignService {
    @RequestMapping(value = "/dept/getAll", method = RequestMethod.GET)
    List<Dept> getAll();

    @RequestMapping(value = "/dept/get/{deptNo}", method = RequestMethod.GET)
    Dept getByNo(@PathVariable("deptNo") long deptNo);

    @RequestMapping(value = "/dept/addDept", method = RequestMethod.POST)
    Boolean addDept(@RequestBody Dept dept);
}

配置文件开启服务降级

# 开启服务降级
feign:
  hystrix:
    enabled: true

启动eureka springcloud-eureka-7001，启动服务提供者springcloud-provider-dept-hystrix-8001，在启动上面的客户端服务，正常访问http://localhost/consumer/feign/get/1，如下
然后关闭springcloud-provider-dept-hystrix-8001的服务，再次请求

8.6、熔断、降级、限流的区别

熔断，降级，限流：

熔断（Circuit Breaker）：是一种保护机制，用于防止服务的连锁反应，当服务出现故障或超时等异常情况时，可以快速切断请求，避免故障继续扩大。服务熔断通过在客户端实现断路器，当服务不可用时，断路器可以快速返回一个预定的响应，避免等待超时或请求失败。在服务熔断被打开的情况下，客户端将不再向该服务发送请求，直到服务恢复正常。
限流（Rate Limiting）：是一种控制服务请求量的机制，通过设定阈值，控制系统并发请求数，避免服务被过载，导致系统资源耗尽或性能下降。限流可以采用不同的算法进行实现，例如固定窗口算法、滑动窗口算法等。限流可以在客户端或服务端实现，可以限制请求的数量、速率、大小等。
降级（Degradation）是一种应对系统高负载或者系统异常的策略。当系统遇到高负载或异常时，为了保证核心功能的可用性，服务降级会主动暂停某些非核心功能或服务，以保障核心功能的稳定性和可用性。这样做可以防止整个系统因为某些服务故障而崩溃，同时也可以避免系统负载过高导致性能下降或响应时间过长，从而保障系统的可靠性和稳定性。

服务降级的实现通常需要根据实际业务需求和系统的特点，制定相应的策略和机制。例如，可以根据业务需求和访问量对服务进行分类，将非核心服务或低优先级服务在高负载或异常情况下进行降级处理，或者对服务进行流量控制和限流，以保证系统的稳定性和可用性。

8.6、dashboard流监控

新建一个模板springcloud-consumer-hystrix-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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.zyy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-consumer-hystrix-dashboard</artifactId>


    <dependencies>
        <!--SpringBoot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.zyy</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--Eureka: Ribbon需要从Eureka服务中心获取要拿什么-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>


    </dependencies>

</project>

配置文件
```
server:
  port: 9000
```

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;


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

启动服务，可以看到如下页面

优化springcloud-provider-dept-hystrix-8001模块，新建一个配置类

import com.netflix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.Servlet;


@Configuration
public class ConfigBean {
    @Bean
    public ServletRegistrationBean servletRegistrationBean() {
        ServletRegistrationBean<Servlet> servletRegistrationBean = new ServletRegistrationBean<>(new HystrixMetricsStreamServlet());
        servletRegistrationBean.addUrlMappings("/actuator/hystrix.stream");
        return servletRegistrationBean;

    }
}

启动Eureka服务，再启动springcloud-provider-dept-hystrix-8001的服务，输入http://localhost:8001/actuator/hystrix.stream,如下
打开dashboard监控页面http://localhost:9000/hystrix，输入如下
监控
调用服务http://localhost:8001/dept/get/1，发现监控页面变化

9、zuul路由网关

什么是zuul

zuul包含了对请求的路由（用来跳转的）和过滤两个最主要功能：

其中路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础，而过滤器功能则负责对请求的处理过程进行干预，是实现请求校验，服务聚合等功能的基础。Zuul和Eureka进行整合，将Zuul自身注册为Eureka服务治理下的应用，同时从Eureka中获得其他服务的消息，也即以后的访问微服务都是通过Zuul跳转后获得。

注意：Zuul 服务最终还是会注册进 Eureka

提供：代理 + 路由 + 过滤三大功能！

入门案例

新建模块springcloud-zuul-9257

导包

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.zyy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-zuul-9257</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.zyy</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--导入zuul依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zuul</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <!--Hystrix依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</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>

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

</project>

配置文件

server:
  port: 9257

spring:
  application:
    name: springcloud-zuul

eureka:
  instance:
    instance-id: zull9257
    prefer-ip-address: true
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/

info:
  app.name: zyy-springcloud
  company.name: 中国有家公司

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;


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

修改本地host地址，新增如下
```
127.0.0.1       www.zyy.com
```
启动eureka服务，springcloud-eureka-7001,再启动服务提供者的服务，springcloud-provider-dept-hystrix-8001,最后启动上面的zuul服务

打开eureka页面，发现都注册了
直接调用服务端的接口

可以正常使用
直接调用zuul的服务，加上需要调用服务的应用id

也可以调用
不想直接暴露应用id出去，可以指定一个前缀，可以添加如下配置
```
zuul:
  routes:
    mydept.serviceId: dept-provider
    mydept.path: /mydept/**
```
重启zuul服务，通用指定前缀调用

也可以正常调用，但是这个时候用应用id也还是可以正常调用

在想把直接通过应用id的方式全部取消，配置文件加上zuul.ignored-services

zuul:
  routes:
    mydept.serviceId: dept-provider
    mydept.path: /mydept/**
  ignored-services: "*"

想在调用url加上前缀，配置文件加上zuul.prefix

zuul:
  routes:
    mydept.serviceId: dept-provider
    mydept.path: /mydept/**
  ignored-services: "*"
  prefix: /zyy

10、spring cloud config 分布式配置

Spring Cloud Config为分布式系统中的外部配置提供服务器和客户端支持。使用Config Server，您可以在所有环境中管理应用程序的外部属性。客户端和服务器上的概念映射与Spring Environment和PropertySource抽象相同，因此它们与Spring应用程序非常契合，但可以与任何以任何语言运行的应用程序一起使用。随着应用程序通过从开发人员到测试和生产的部署流程，您可以管理这些环境之间的配置，并确定应用程序具有迁移时需要运行的一切。服务器存储后端的默认实现使用git，因此它轻松支持标签版本的配置环境，以及可以访问用于管理内容的各种工具。很容易添加替代实现，并使用Spring配置将其插入

10.1、概述

分布式系统面临的–配置文件问题

微服务意味着要将单体应用中的业务拆分成一个个子服务，每个服务的粒度相对较小，因此系统中会出现大量的服务，由于每个服务都需要必要的配置信息才能运行，所以一套集中式的，动态的配置管理设施是必不可少的。spring cloud提供了configServer来解决这个问题，我们每一个微服务自己带着一个application.yml，那上百个的配置文件修改起来，令人头疼！

什么是SpringCloud config分布式配置中心？

spring cloud config 为微服务架构中的微服务提供集中化的外部支持，配置服务器为各个不同微服务应用的所有环节提供了一个中心化的外部配置

spring cloud config 分为服务端和客户端两部分

服务端也称为 分布式配置中心，它是一个独立的微服务应用，用来连接配置服务器并为客户端提供获取配置信息，加密，解密信息等访问接口
客户端则是通过指定的配置中心来管理应用资源，以及与业务相关的配置内容，并在启动的时候从配置中心获取和加载配置信息。配置服务器默认采用git来存储配置信息，这样就有助于对环境配置进行版本管理。并且可用通过git客户端工具来方便的管理和访问配置内容

spring cloud config 分布式配置中心能干嘛？

集中式管理配置文件
不同环境，不同配置，动态化的配置更新，分环境部署，比如 /dev /test /prod /beta /release
运行期间动态调整配置，不再需要在每个服务部署的机器上编写配置文件，服务会向配置中心统一拉取配置自己的信息
当配置发生变动时，服务不需要重启，即可感知到配置的变化，并应用新的配置
将配置信息以REST接口的形式暴露

10.2、spring cloud config 分布式配置中心与GitHub整合

由于spring cloud config 默认使用git来存储配置文件 (也有其他方式，比如自持SVN 和本地文件)，但是最推荐的还是git ，而且使用的是 http / https 访问的形式。

入门案例（服务端）

gitee上新建一个仓库my-springcloud-config，然后本地clone下载(仓库：my-springcloud-config: 狂神说java--springcloud--config)

然后创建一个application.yaml，push到远程仓库

spring:
  profiles:
    active: dev
---
spring:
  profiles: dev
  application:
    name: springcloud-config-dev

---
spring:
  profiles: test
  application:
    name: springcloud-config-test

原springcloud项目下新建一个模块springcloud-config-server-3344

导包

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.zyy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-config-server-3344</artifactId>


    <dependencies>
        <!--SpringBoot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
            <version>2.1.1.RELEASE</version>
        </dependency>
    </dependencies>
</project>

配置文件

server:
  port: 3344

spring:
  application:
    name: springcloud-config-server
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/zhayuyao/my-springcloud-config.git

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;


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

启动服务

访问http://localhost:3344/application-dev.yaml

访问http://localhost:3344/application-test.yaml

访问http://localhost:3344/application/test/master

访问http://localhost:3344/master/application-dev.yaml

访问一个不存在的http://localhost:3344/master/application-aa.yaml

客户端

my-springcloud-config下新建一个config-client.yaml，然后push到远程仓库

spring:
  profiles:
    active: dev
---
server:
  port: 8201

spring:
  profiles: dev
  # 应用名
  application:
    name: dept-provider

# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/
  instance:
    instance-id: dept-provider:8000

---
server:
  port: 8202
spring:
  profiles: test
  # 应用名
  application:
    name: dept-provider

# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  instance:
    instance-id: dept-provider:8000

原springcloud项目下新建一个模块springcloud-config-server-3355

导包

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.zyy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-config-server-3355</artifactId>


    <dependencies>
        <!--SpringBoot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
            <version>2.1.1.RELEASE</version>
        </dependency>

    </dependencies>
</project>

添加配置文件bootstrap.yaml

# 系统级别的配置
spring:
  cloud:
    config:
      name: config-client
      profile: dev
      label: master
      uri: http://localhost:3344

添加配置文件application.yaml

# 用户级别的配置
spring:
  application:
    name: springcloud-config-client

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


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

添加controller

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ConfigClientController {
    @Value("${spring.application.name}")
    private String applicationName;

    @Value("${eureka.client.service-url.defaultZone}")
    private String eurekaServer;

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

    @RequestMapping("/config")
    public String getConfig() {

        return "applicationName:" + applicationName + "\n"
                + "eurekaServer:" + eurekaServer + "\n"
                + "port:" + port;
    }
}

先启动springcloud-config-server-3344的服务，在启动上面的服务
调用http://localhost:8201/config接口

小案例

将eureka服务和服务提供者也改造一下

my-springcloud-config下新建一个config-eureka.yaml然后push到远程仓库

spring:
  profiles:
    active: dev
---
spring:
  profiles: dev
  # 应用名
  application:
    name: eureka-config

server:
  port: 7001

eureka:
  instance:
    hostname: eureka7001
  client:
    # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    register-with-eureka: false
    # fetch-registry如果为false,则表示自己为注册中心,客户端的化为 ture
    fetch-registry: false
    #            this.serviceUrl.put("defaultZone", "http://localhost:8761/eureka/");
    service-url:
      defaultZone: http://eureka7002:7002/,http://eureka7003:7003/
---
spring:
  profiles: test
  # 应用名
  application:
    name: eureka-config

server:
  port: 7001

eureka:
  instance:
    hostname: eureka7001
  client:
    # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    register-with-eureka: false
    # fetch-registry如果为false,则表示自己为注册中心,客户端的化为 ture
    fetch-registry: false
    #            this.serviceUrl.put("defaultZone", "http://localhost:8761/eureka/");
    service-url:
      defaultZone: http://eureka7002:7002/,http://eureka7003:7003/

再新建一个config-dept.yaml然后push到远程仓库

spring:
  profiles:
    active: dev
---
# 端口号
server:
  port: 8000

# 配置mybatis

mybatis:
  mapper-locations: classpath:com/zyy/dept/mapper/*.xml
  config-location: classpath:com/zyy/dept/mybatis-config.xml

spring:
  # spring数据源配置
  profiles: dev
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://localhost:3306/db-01?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456
  # 应用名
  application:
    name: dept-provider

# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  instance:
    instance-id: dept-provider:8000

management:
  endpoints:
    web:
      exposure:
        include: "*"

info:
  app.name: zyy-springcloud
  company.name: 中国有家公司

---
# 端口号
server:
  port: 8000

# 配置mybatis

mybatis:
  mapper-locations: classpath:com/zyy/dept/mapper/*.xml
  config-location: classpath:com/zyy/dept/mybatis-config.xml

spring:
  # spring数据源配置
  profiles: test
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://localhost:3306/db-02?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456
  # 应用名
  application:
    name: dept-provider

# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  instance:
    instance-id: dept-provider:8000

management:
  endpoints:
    web:
      exposure:
        include: "*"

info:
  app.name: zyy-springcloud
  company.name: 中国有家公司

启动eureka服务springcloud-config-server-3344

访问http://localhost:3344/master/config-eureka-dev.yaml可以正常获取配置

另外一个也可以正常获取配置
原springcloud项目下新建一个模块springcloud-eureka-config-7001，拷贝springcloud-eureka-7001

导包（原基础上新增依赖包如下）

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
            <version>2.1.1.RELEASE</version>
        </dependency>

原来的配置文件删除，新增一个bootstrap.yaml

spring:
  cloud:
    config:
      uri: http://localhost:3344
      name: config-eureka
      label: master
      profile: dev

启动上面的服务

eureka的服务可以正常打开
原springcloud项目下新建一个模块springcloud-provider-dept-config-8001，拷贝springcloud-provider-dept-8001

导包（原基础上新增依赖包如下）

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
            <version>2.1.1.RELEASE</version>
        </dependency>

原来的配置文件删除，新增一个bootstrap.yaml

spring:
  cloud:
    config:
      uri: http://localhost:3344
      name: config-dept
      label: master
      profile: dev

启动服务

接口正常调用

也注册到eureka服务了

AVICCI

关注

16
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫