Spring Cloud快速入门

Spring Cloud快速入门

一、基础概念

1、微服务架构

---

微服务架构4个核心问题？

1. 服务很多，客户端该怎么访问？
2. 这么多服务？服务之间如何通信？
3. 这么多服务？如何治理？
4. 服务挂了怎么办？

---

解决方案

Spring Cloud 生态！ SpringBoot

1. Spring Cloud NetFlix：一站式解决方案！

   1. API网关：zuul组件
   2. 通信：Feign —HttpClient— Http的通讯方式，同步，阻塞
   3. 服务器注册发现：Eureka
   4. 熔断机制：Hystrix

2. Apache Dubbo Zookeeper：半自动，需要整合别人的（异步，RPC）

   1. API：没有，找第三方组件（zuul），或者自己实现
   2. 通信：Dubbo
   3. 服务器注册发现：Zookeeper
   4. 熔断机制：借助别人的

Dubbo这个方案并不完善。。。。

3. Spring Cloud Alibaba：一站式解决方案！更简单了

---

新概念：服务网格~Server

2、微服务技术栈

3、什么是Spring Cloud?

• SpringCloud,基于SpringBoot提供了一套微服务解决方案，包括服务注册与发现，配置中心，全链路监控，服务网关，负载均衡，熔断器等组件，除了基于NetFlix的开源组件做高度抽象封装之外，还有一些选型中立的开源组件
• SpringCloud利用SpringBoot的开发便利性，巧妙地简化了分布式系统基础设施的开发，SpringCloud为开发人员提供了快速构建分布式系统的一些工具，包括配置管理，服务发现，断路器，路由，微代理，事件总线，全局锁，决策竟选，分布式会话等等，他们都可以用SpringBoot的开发风格做到一键启动和部署。
• SpringBoot并没有重复造轮子，它只是将目前各家公司开发的比较成熟，经得起实际考研的服务框架组合起来通过SpringBoot风格进行再封装，屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂，易部署和易维护的分布式系统开发工具包
• SpringCloud 是 分布式微服务架构下的一站式解决方案，是各个微服务架构落地技术的集合体，俗称微服务全家桶

4、Spring Cloud和Spring Boot的联系？

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

5、比较成熟的互联网架构

二、Rest环境搭建

1、搭建提供者

1.1、创建一个父工程

pom.xml

配置打包方式pom

<!--打包方式-->
<packaging>pom</packaging>

配置坐标

<properties>
	<maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <junit.version>4.12</junit.version>
    <log4j.version>1.2.17</log4j.version>
    <lombok.version>1.16.18</lombok.version>
</properties>

<dependencyManagement>
    <dependencies>
        <!--springcloud依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Greenwich.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!--springboot依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.1.4.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>


        <!--数据库-->
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.16</version>
        </dependency>
        <!--mybaits-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>

        <!--日志和测试-->
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
        <!--log4j-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <!--logback-core-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.3</version>
        </dependency>
    </dependencies>
</dependencyManagement>

1.2、创建一个springcloud-api模块

添加坐标

<dependencies>
	<!--当前Module自己需要的依赖，如果父依赖中配置了版本，这里直接引入即可-->
	 <dependency>
	     <groupId>org.projectlombok</groupId>
	     <artifactId>lombok</artifactId>
	 </dependency>
</dependencies>

数据库

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for dept
-- ----------------------------
DROP TABLE IF EXISTS `dept`;
CREATE TABLE `dept`  (
  `deptno` bigint(0) NOT NULL AUTO_INCREMENT,
  `dname` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `db_source` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`deptno`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;


insert into dept(dname, db_source) values('开发部', DATABASE());
insert into dept(dname, db_source) values('人事部', DATABASE());
insert into dept(dname, db_source) values('财务部', DATABASE());
insert into dept(dname, db_source) values('市场部', DATABASE());
insert into dept(dname, db_source) values('运维部', DATABASE());

pojo

@Data
@NoArgsConstructor
public class Dept implements Serializable {
    
     // Dept 实体类  orm 类表关系映射
    // 主键
    private Long deptno;
    private String dname;
    // 这个数据存在在哪个数据库的字段~微服务，一个服务对应一个数据库，同一个信息被存在不同的数据库
    private String dbSource;
    public Dept(String dname){
    
    
        this.dname = dname;
    }
}

1.3、创建一个springcloud-provider-dept-8001

坐标

 <dependencies>
  	<dependency>
        <!--我们需要拿到实体类，所以要配置api moudle-->
        <groupId>com.lzy</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>lzy.springcloud.test</scope>
    </dependency>
    <!--数据库-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-core</artifactId>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--jetty-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
    <!--热部署-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>

application.yaml

server:
  port: 8001
#mybaits-plus
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      id-type: ASSIGN_ID
  type-aliases-package: com.lzy.springcloud.pojo

  #spring的配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: lige0612

mapper

service

public interface DeptService extends IService<Dept> {
    
    
}

@Service
public class DeptServiceImpl extends ServiceImpl<DeptMapper, Dept> implements DeptService {
    
    
}

controller

// 提供Resultful服务
@RestController
@RequestMapping("/dept")
public class DeptController {
    
    
    @Autowired
    private DeptService deptService;
    @PostMapping("/add")
    public boolean addDept(@RequestBody Dept dept){
    
    
        return deptService.save(dept);
    }

    @GetMapping("/get/{id}")
    public Dept get(@PathVariable("id") Long id){
    
    
        LambdaQueryWrapper<Dept> lqw = new LambdaQueryWrapper<>();
        lqw.eq(Dept::getDeptno, id);
        return deptService.getOne(lqw);
    }

    @GetMapping("/list")
    public List<Dept> list(){
    
    
        return deptService.list();
    }
}

主启动器

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

然后可以启动一下，试一试接口能不能正常工作，注意是get还是post请求

2、搭建消费者

创建springcloud-consumer-dept-80

坐标

 <dependencies>
   <!--实体类-->
    <dependency>
        <groupId>com.lzy</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>

application.yaml

server:
  port: 80

Config

@Configuration
public class ConfigBean {
    
    
    @Bean
    public RestTemplate getRestTemplate(){
    
    
        return new RestTemplate();
    }
}

controller

@RestController
@RequestMapping("/consumer/dept")
public class DeptConsumerController {
    
    
    // 消费者不应该有service层~
    // RestTemplate..供我们直接调用
    @Autowired
    private RestTemplate restTemplate;
    // 固定前缀
    private static final String REST_URL_PREFIX = "http://localhost:8001";

    @GetMapping("/get/{id}")
    public Dept get(@PathVariable("id") Long id){
    
    
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
    }

    @PostMapping("/add")
    public boolean add(Dept dept){
    
    
        return Boolean.TRUE.equals(restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class));
    }

    @GetMapping("/list")
    public List list(){
    
    
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
    }
}

主启动器

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

3、总结

• 这里我们可以发现，整个代码就很干净，耦合度很低，可扩展性强，易维护
• api中提供实体类，provider中提供服务（也就是server什么的东西），consumer中就只是负责消费（调用provider中的东西）
• 中间的通信，目前采用的是Resultful风格的RestTemplate，相对于之前用的Zookeeper+Dubbo方式更加简洁一些

三、Eureka服务注册与发现

1、什么是Eureka

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

2、原理

• 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是一个ava客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的，使用轮询负载算法的负载均衡器。在应用启动后，将会向EurekaServer发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除掉 (默认周期为90秒)

3、三大角色

• Eureka Server: 提供服务的注册于发现。zookeeper
• Service Provider: 将自身服务注册到Eureka中，从而使消费方能够找到。
• Service Consumer: 服务消费方从Eureka中获取注册服务列表，从而找到消费服务。

4、搭建EurekaService端

创建springcloud-eureka-7001
坐标

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

application.yaml

server:
  port: 7001
# EurekaService_7001
eureka:
  instance:
    hostname: localhost #Eureka服务端的实例名字
  client:
    register-with-eureka: false # 表示是否向Eureka注册中心注册自己
    fetch-registry: false # fetch-registry如果为false，则表示自己为注册中心
    service-url:  # 监控页面~
      defaultZone: http://${
    
    eureka.instance.hostname}:${
    
    server.port}/eureka/

5、搭建EurekaClient

在provider中配置

坐标

<!--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:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/

主启动器

加上 @EnableEurekaClient 注解

这样将server端和client端启动起来，访问localhost:7001 就会看到下面，注册信息

然后有点小配置

# Eureka的配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: springcloud-provider-dept-8001 # 修改Eureka上面的默认描述信息！
# info配置
info:
  app.name: lzy
  company.name: blog.lzy.com

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

这样你点击默认描述信息那里就会看到下面

查看注册的一些信息

在controller中能看，别的方式估计也可以

// 获取一些配置的信息，得到具体的微服务
@Autowired
private DiscoveryClient discoveryClient;

@GetMapping("/info")
public Object discovery(){
    
    
    // 获取微服务列表的清单
    List<String> services = discoveryClient.getServices();
    System.out.println("Discovery => services" + services);
    // 得到一个具体的微服务信息，通过微服务的获取到信息
    List<ServiceInstance> instances = discoveryClient.getInstances("SPRINGCLOUD-PROVIDER-DEPT");
    for (ServiceInstance instance : instances) {
    
    
        System.out.println(instance.getHost() + "\t" + instance.getPort() + "\t" + instance.getUri() + "\t" + instance.getServiceId());
    }
    return this.discoveryClient;
}

主启动器中加@EnableEurekaClient注解
当访问的时候，就可以打印出消息了

6、自我保护机制

一句话总结: 某时刻某一个微服务不可以用了，eureka不会立刻清理，依旧会对该微服务的信息进行保存!

• 默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例(默认90秒)。但是当网络分区故障发生时，微服务与Eureka之间无法正常通行，以上行为可能变得非常危险了因为微服务本身其实是健康的，此时本不应该注销这个服务。Eureka通过 自我保护机制来解决这个问题–当EurekaServer节点在短时间内丢失过多客户端时(可能发生了网络分区故障)，那么这个节点就会进入自我保护模式。一旦进入该模式，EurekaServer就会保护服务注册表中的信息，不再删除服务注册表中的数据(也就是不会注销任何微服务)。当网络故障恢复后，该EurekaServer节点会自动退出自我保护模式。
• 在自我保护模式中，EurekaServer会保护服务注册表中的信息，不再注销任何服务实例。当它收到的心跳数重新恢复到闻值以上时，该EurekaServer节点就会自动退出自我保护模式。它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。一句话: 好死不如赖活着
• 综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务(健康的微服务和不健康的微服务都会保留)，也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮和稳定
• 在SpringCloud中，可以使用eureka.server.enable-self-preservation = false 禁用自我保护模式[不推荐关闭自我保护机制]

7、集群配置

搭建三个Eureka服务（复制改一改就可以了）

修改hosts文件

配置集群
7001

server:
  port: 7001
# EurekaService_7001
eureka:
  instance:
    hostname: eureka7001 #Eureka服务端的实例名字
  client:
    register-with-eureka: false # 表示是否向Eureka注册中心注册自己
    fetch-registry: false # fetch-registry如果为false，则表示自己为注册中心
    service-url:  # 监控页面~
      # 单机
      # defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      # 集群
        defaultZone: http://eureka7002:7002/eureka/, http://eureka7003:7003/eureka/

7002

server:
  port: 7002
# EurekaService_7001
eureka:
  instance:
    hostname: eureka7002 #Eureka服务端的实例名字
  client:
    register-with-eureka: false # 表示是否向Eureka注册中心注册自己
    fetch-registry: false # fetch-registry如果为false，则表示自己为注册中心
    service-url:  # 监控页面~
      # 单机
      # defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      # 集群
      defaultZone: http://eureka7001:7001/eureka/, http://eureka7003:7003/eureka/

7003

server:
  port: 7003
# EurekaService_7001
eureka:
  instance:
    hostname: eureka7003 #Eureka服务端的实例名字
  client:
    register-with-eureka: false # 表示是否向Eureka注册中心注册自己
    fetch-registry: false # fetch-registry如果为false，则表示自己为注册中心
    service-url:  # 监控页面~
      # 单机
      # defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      # 集群
      defaultZone: http://eureka7001:7001/eureka/, http://eureka7002:7002/eureka/

配置服务端

server:
  port: 8001
#mybaits-plus
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      id-type: ASSIGN_ID
  type-aliases-package: com.lzy.springcloud.pojo

  #spring的配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: lige0612

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

将项目都启动起来，访问各自的监控页面，ok！

8、对比Zookeeper

8.1、CAP原则

• C（Consistency）强一致性
• A（Availablity）可用性
• P（Partition tolerance）分区容错性

8.2、作为服务注册中心，Eureka比Zookeeper好在哪里?

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

• Zookeeper保证的是CP
• Eureka保证的是AP

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

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

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

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

四、Ribbon

1、什么是ribbon？

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

2、Ribbon能干嘛？

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

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

• 负载均衡简单分类

  • 集中式LB
    • 即在服务的消费方和提供方之间使用独立的LB设施，如Nginx，由该设施负责把访问请求通过某种策略发至服务的提供方
  • 进程式LB
    • 将LB逻辑集成到消费方，消费方从服务注册中心，获知哪些地址可用，然后自己再从这些地址中选出一个合适的服务器
    • Ribbon就属于进程内LB，它只是一个类库，继承与消费方进程，消费方通过它来获取到服务方的地址

3、使用Ribbon

在consumer中操作
坐标

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

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

applicaiton.yaml

server:
  port: 80
# Eureka
eureka:
  client:
    fetch-registry: true # 不向Eureka注册自己
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/, http://eureka7003:7003/eureka/

主启动类

// Ribbon 和 Eureka 整合以后，客户端可以直接使用，不用关心IP地址和端口号
@SpringBootApplication
@EnableEurekaClient
public class DeptConsumer_80 {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(DeptConsumer_80.class, args);
    }
}

RestTemplate

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

修改地址

这样当我们去访问http://localhost/consumer/dept/list就可以显示

但是这里显示的是Db01，看不出来它是怎么搞的负载均衡，所以要搭建一个服务提供集群，再建两个服务提供者，两个数据库，修改配置

配置好后，我们看就能发现有三个服务了

这样就可以看到轮询的负载均衡了

4、负载均衡算法

• AbstractLoadBalancerRule：会先过滤掉，跳闸，访问故障的服务~对剩下的进行轮询
• RoundRobinRule：轮询算法
• RandomRule：随机算法
• RetryRule：会先按照轮询获取服务~，如果服务获取失败，则会在指定的时间进行

自定义负载均衡算法

@Configuration
public class LRule {
    
    
    @Bean
    public IRule myRule(){
    
    
        return new RandomRule();
    }
}

public class MyRule extends AbstractLoadBalancerRule {
    
    
    // 每个服务，访问5次就，访问下一个服务
    private int total = 0; // 被调用的次数
    private int currentIndex = 0; // 当前是谁提供的服务


    @SuppressWarnings({
    
    "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
    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;
                }

//                int index = this.chooseRandomInt(serverCount);
//                server = (Server)upList.get(index);
                // ===== ===== ===== ===== ===== ===== ===== =====
                if(total < 5){
    
    
                    server = upList.get(currentIndex);
                    total++;
                }else{
    
    
                    total = 0;
                    currentIndex ++;
                    if(currentIndex > upList.size()){
    
    
                        currentIndex = 0;
                    }
                    upList.get(currentIndex);
                }

                // ===== ===== ===== ===== ===== ===== ===== =====

                if (server == null) {
    
    
                    Thread.yield();
                } else {
    
    
                    if (server.isAlive()) {
    
    
                        return server;
                    }

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

            return server;
        }
    }

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

    public Server choose(Object key) {
    
    
        return this.choose(this.getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    
    
    }
}

主启动类

这样启动了以后就可以去试试，看看是不是每个访问5下，切换到下一个服务，从这里面学到了，要会看源码，然后仿照的去写

五、Feign

1、简介

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

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

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

1. 微服务名字 [ribbon]
2. 接口和注解 [feign ]

2、Feign能干什么?

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

3、使用Feign

先搞一个80端的Feign
坐标

 <dependencies>
   <!--实体类-->
    <dependency>
        <groupId>com.lzy</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>

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

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

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

controller

@RestController
@RequestMapping("/consumer/dept")
public class DeptConsumerController {
    
    

    @Autowired
    private DeptClientService deptClientService;

    @GetMapping("/get/{id}")
    public Dept get(@PathVariable("id") Long id){
    
    
        return this.deptClientService.queryById(id);
    }

    @PostMapping("/add")
    public boolean add(Dept dept){
    
    
        return this.deptClientService.add(dept);
    }

    @GetMapping("/list")
    public List<Dept> list(){
    
    
        return this.deptClientService.queryAll();
    }
}

主启动类

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {
    
    "com.lzy.springcloud"})
public class FeignDeptConsumer_80 {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(FeignDeptConsumer_80.class, args);
    }
}

然后在api的那个类中，搞一个server

这里坐标也要配置

<dependencies>
  <!--当前Module自己需要的依赖，如果父依赖中配置了版本，这里直接引入即可-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

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

server

@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
public interface DeptClientService {
    
    
    @GetMapping("/dept/list")
    public List<Dept> queryAll();

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

    @PostMapping("/dept/add")
    public boolean add(Dept dept);
}

      和上面使用Ribbon感觉是一样的，使用Ribbon的时候，也不能这么说，之前的那种方式，我觉得也是把server层相当于放到了消费者里面了，通过统一配置服务的名字和请求url，用RestTemplate去Eureka中去获取服务，现在使用了Feign，他还是用的Ribbon的负载均衡，但是请求方式变了，现在api层，搞一个service的接口，把你要用的接口都写好，使用Feign配置好服务的名字，用GetMapper/PostMapper替代使用RestTemplate，也就是相当于把服务先搞到了api层，然后在消费者层，你只需要像之前一样把api的server注入到里面，然后通过server去调用对应的方法即可，我觉得这样也不错，两种方式各有优劣

六、Hystrix服务熔断

1、服务雪崩

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

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

2、什么是Hystrix

• Spring Cloud Hystrix 是一款优秀的服务容错与保护组件，也是 Spring Cloud 中最重要的组件之一。

• Spring Cloud Hystrix 是基于 Netflix 公司的开源组件 Hystrix 实现的，它提供了熔断器功能，能够有效地阻止分布式微服务系统中出现联动故障，以提高微服务系统的弹性。Spring Cloud Hystrix 具有服务降级、服务熔断、线程隔离、请求缓存、请求合并以及实时故障监控等强大功能。

Hystrix [hɪst’rɪks]，中文含义是豪猪，豪猪的背上长满了棘刺，使它拥有了强大的自我保护能力。而 Spring Cloud Hystrix 作为一个服务容错与保护组件，也可以让服务拥有自我保护的能力，因此也有人将其戏称为“豪猪哥”。

在微服务系统中，Hystrix 能够帮助我们实现以下目标：

• 保护线程资源：防止单个服务的故障耗尽系统中的所有线程资源。
• 快速失败机制：当某个服务发生了故障，不让服务调用方一直等待，而是直接返回请求失败。
• 提供降级（FallBack）方案：在请求失败后，提供一个设计好的降级方案，通常是一个兜底方法，当请求失败后即调用该方法。
• 防止故障扩散：使用熔断机制，防止故障扩散到其他服务。
• 监控功能：提供熔断器故障监控组件 Hystrix Dashboard，随时监控熔断器的状态。

3、服务熔断Demo

新建一个hystrix的provider

坐标

<dependencies>
	 <dependency>
        <!--我们需要拿到实体类，所以要配置api moudle-->
        <groupId>com.lzy</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>lzy.springcloud.test</scope>
    </dependency>
    <!--数据库-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-core</artifactId>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--jetty-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>

    <!--热部署-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
    <!--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>
    <!--完善监控信息-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--hystrix-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-hystrix</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
</dependencies>

controller
注解@HystrixCommand

// 提供Resultful服务
@RestController
@RequestMapping("/dept")
public class DeptController {
    
    
    @Autowired
    private DeptService deptService;

    @GetMapping("/get/{id}")
    @HystrixCommand(fallbackMethod = "get_Hystrix")
    public Dept get(@PathVariable("id") Long id){
    
    
        LambdaQueryWrapper<Dept> lqw = new LambdaQueryWrapper<>();
        lqw.eq(Dept::getDeptno, id);
        Dept one = deptService.getOne(lqw);
        if(one == null){
    
    
            throw new RuntimeException("id=>" + id + "不存在该用户，或者信息无法找到~");
        }
        return one;
    }

    public Dept get_Hystrix(@PathVariable("id") Long id){
    
    
        Dept dept = new Dept();
        dept.setDeptno(id);
        dept.setDname("id=>" + id + "没有对应的信息，null--@Hystrix");
        dept.setDbSource("no this database in MySQL");
        return dept;
    }
}

主启动类

@SpringBootApplication
@EnableEurekaClient // 自动注册到Eureka
@EnableDiscoveryClient // 服务发现
@EnableCircuitBreaker // 添加对熔断的支持
public class DeptProviderHystrix_8001 {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(DeptProviderHystrix_8001.class, args);
    }
}

启动注册集群和刚整好的项目，访问，当出错的时候，就会自动跳转到我们预先搞的处理错误的方法里面，兜底

4、服务降级Demo

4.1、Feign风格

api端

DeptClientServiceFallbackFactory

// 降级~
@Component
public class DeptClientServiceFallbackFactory implements FallbackFactory {
    
    
    @Override
    public DeptClientService create(Throwable throwable) {
    
    
        return new DeptClientService() {
    
    
            @Override
            public List<Dept> queryAll() {
    
    
                return null;
            }
            @Override
            public Dept queryById(Long id) {
    
    
                Dept dept = new Dept();
                dept.setDeptno(id);
                dept.setDname("id=>" + id + "没有对应的信息，客户端提供了降级的信息，这个服务现在已经被关闭了");
                dept.setDbSource("没有数据！");
                return dept;
            }
            @Override
            public boolean add(Dept dept) {
    
    
                return false;
            }
        };
    }
}

DeptClientService

@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT", fallbackFactory = DeptClientServiceFallbackFactory.class)
public interface DeptClientService {
    
    
    @GetMapping("/dept/list")
    public List<Dept> queryAll();

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

    @PostMapping("/dept/add")
    public boolean add(Dept dept);
}

api这里的feign中集成了Hystrix，也就是说在客户端做了一个服务降级

feign的80的客户端里面的application.yaml， 开启hystrix

server:
  port: 80
# Eureka
eureka:
  client:
    fetch-registry: true # 不向Eureka注册自己
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/, http://eureka7003:7003/eureka/

feign:
  hystrix:
    enabled: true

启动Eureka集群，然后启动没有服务熔断的8001的provider，启动feign的80客户端，一开始我们能正常访问，但是当你某个业务并发量太大，为了不让其崩掉，我们需要先手动停掉其他的服务，把资源都供并发量大的服务去，所以现在当我们把8001服务停掉，再去访问的时候，就会出现降级的提示

服务熔断和服务降级降级的区别

1. 触发原因不一样，服务熔断由链路上某个服务引起的，服务降级是从整体的负载考虑
2. 所在地不同，熔断是处在服务提供那里的，降级是在客户端那里的
3. 实现方式不一样，服务熔断一般是自我熔断恢复，服务降级相当于人工控制

服务熔断：应对雪崩效应的链路自我保护机制。可看作降级的特殊情况

服务降级：系统有限的资源的合理协调

4.2、RestTemplate风格

修改一下没有feign的80客户端
依赖

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

做一个降级方法

@RestController
@RequestMapping("/consumer/dept")
public class DeptConsumerController {
    
    
    // 消费者不应该有service层~
    // RestTemplate..供我们直接调用
    @Autowired
    private RestTemplate restTemplate;
    // 固定前缀
    // private static final String REST_URL_PREFIX = "http://localhost:8001";
    // 通过Ribbon去实现的时候，我们这里的地址，应该是一个变量，通过服务名来访问
    private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

    @HystrixCommand(fallbackMethod = "getProductFallBack")
    @GetMapping("/get/{id}")
    public Dept get(@PathVariable("id") Long id){
    
    
        Dept forObject = restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
        if( forObject == null){
    
    
            throw new RuntimeException("id=>" + id + "不存在该用户，或者信息无法找到~");
        }
        return forObject;
    }

    public Dept getProductFallBack(@PathVariable("id") Long id){
    
    
        Dept dept = new Dept();
        dept.setDeptno(id);
        dept.setDname("id=>" + id + "没有对应的信息，客户端提供了降级的信息，这个服务现在已经被关闭了");
        dept.setDbSource("没有数据！");
        return dept;
    }
}

配置

hystrix:
  command:
    default:
      execution:
        isolation:
          strategy: ExecutionIsolationStrategy.SEMAPHORE #信号量隔离
          thread:
            timeoutInMilliseconds: 2000 # 默认的连接超时时间1秒,若1秒没有返回数据,自动的触发降级逻辑

主启动类

// Ribbon 和 Eureka 整合以后，客户端可以直接使用，不用关心IP地址和端口号
@SpringBootApplication
@EnableCircuitBreaker
// @RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = MyRule.class)
public class DeptConsumer_80 {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(DeptConsumer_80.class, args);
    }
}

测试一下，当将provider停掉以后，弹出我们降级后的方法，和Feign差不多

这里我尝试了一下同时启用服务熔断和服务降级，当我们请求本身发生错误的时候，就会触发服务端的熔断机制，如果是服务端关闭了也是出现了错误的时候，就自动触发的服务降级，我咋感觉有点像那个鲁棒性，程序更加健壮了

服务熔断：服务端~ 某个服务超时或者异常，引起熔断~ 保险丝~
服务降级：客户端~ 从整体网站请求负载考虑~，当某个服务熔断或者关闭之后，服务将不再被调用，此时在客户端就可以准备一个FallbackFactory，返回一个默认的值（缺省值），整体的服务水平下降，但是还能用

5、Dashboard流监控

创建一个监控的服务

坐标

<dependencies>
    <!--实体类-->
    <dependency>
        <groupId>com.lzy</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>

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

    <!--Eureka-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
    <!--Hystrix-->
    <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-hystrix-dashboard</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
</dependencies>

主启动类

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

然后在集成了Hystrix的provider中的主启动器上加一个Bean

@SpringBootApplication
@EnableEurekaClient // 自动注册到Eureka
@EnableDiscoveryClient // 服务发现
@EnableCircuitBreaker // 添加对熔断的支持
public class DeptProviderHystrix_8001 {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(DeptProviderHystrix_8001.class, args);
    }

    // 增加一个Servlet
    @Bean
    public ServletRegistrationBean hystrixMetricsStreamServlet(){
    
    
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
        registrationBean.addUrlMappings("/actuator/hystrix.stream");
        return registrationBean;
    }
}

当你启动Eureka集群并且启动监控的服务，访问监控服务的localhost:你设置的端口，就可以看到

然后启动集成Hystrix的provider，访问localhost:你的端口号/actuator/hystrix.stream就可以看到了

把localhost:你的端口号/actuator/hystrix.stream按照下面

最后一边请求你监控的服务，就可以看到监控到的信息了

七、Zuul

1、什么是zuul

• Zuul包含了对请求的路由和过滤两个最主要的功能
• 其中路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础，而过滤器功能则负责对请求的处理过程进行干预，是实现请求校验，服务聚合等功能的基础。Zuul和Eureka进行整合，将Zuul自身注册为Eureka服务治理下的应用，同时从Eureka中获得其他微服务的消息，也即以后的访问微服务都是通过Zuul跳转后获得。
• 注意: Zuul服务最终还是会注册进Eureka
• 提供: 代理 + 路由 + 过滤 三大功能!

2、Demo

新建一个项目算是一个服务zuul
坐标

<dependencies>
    <!--实体类-->
    <dependency>
        <groupId>com.lzy</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-ribbon -->
    <!--Ribbon-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-ribbon</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>

    <!--Eureka-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
    <!--Hystrix-->
    <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-hystrix-dashboard</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zuul</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
</dependencies>

配置文件

server:
  port: 9527
spring:
  application:
    name: springcloud-zuul
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
    instance:
      instance-id: springcloud-zuul-9527 # 修改Eureka上面的默认描述信息！
      prefer-ip-address: true
info:
  app.name: lzy
  company.name: blog.lzy.com
zuul:
  routes:
    mydept.serviceId: springcloud-provider-dept
    mydept.path: /mydept/**
  # ignored-services: springcloud-provider-dept # 不能再使用路径去访问了
  ignored-services: "*"
  prefix: /lzy  # http://www.lzy.com:9527/lzy/mydept/dept/get/1  又加了一个公共前缀

主启动类

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

• 目前是有三种可以访问服务的方式

1. 通过直接访问服务提供者，http://localhost:8001/dept/get/1
2. 通过将服务注册到Eureka中，然后通过Eureka的服务名字，http://localhost/consumer/dept/get/1
   
3. 通过注册Zuul服务，配置Zuul，可以加上一层你设置的路由规则去访问服务
   http://www.lzy.com:9527/lzy/mydept/dept/get/1
   

我感觉加了这层Zuul之后，消费端的请求方式应该也要发生变化，感觉之前那个RestTemplate也可以达到这个效果，不知道后面是不是把这个Zuul和RestTemplate合并到一起

八、Config分布式配置

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

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

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

2、SpringCloud config分布式配置中心能干嘛

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

3、配置Git

1. 下载安装Githttps://blog.csdn.net/qq_35246620/article/details/68951724
2. 在gitee上建立一个仓库，然后本地生成公钥，放到gitee的ssh中，将本地仓库和远程仓库连接起来https://gitee.com/help/articles/4191和https://gitee.com/help/articles/4122
3. 本地创建一个application.yaml，git add . 、git commit -m “first” 、 git push

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

就可以看到了

4、Server连接Git配置

创建一个config的新的项目

坐标

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

    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-config-server -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
        <version>2.1.1.RELEASE</version>
    </dependency>

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

配置文件

server:
  port: 3344
spring:
  application:
    name: springcloud-config-server
    # 连接远程仓库
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/lzy612/springcloud-config.git # 这里要用https
          skip-ssl-validation: true #可以使 Git 服务器 SSL 证书的服务器验证配置失效。

配置连接仓库的地址，我还关了验证SSL证书的配置

主启动类

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

然后通过访问http://localhost:3344/application-test.yaml或者http://localhost:3344/application-dev.yaml就可看到相应的配置文件

`

这个访问地址还支持下面这些风格的访问方式

5、客户端连接服务端

新建一个客户端来读取配置

坐标

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

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

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

上传一个配置文件 config-client.yaml

spring:
  profiles:
    active: dev
---
server:
  port: 8201
spring:
  profiles: dev
  application:
    name: springcloud-provider-dept

# Eureka的配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept-8001 # 修改Eureka上面的默认描述信息！
    prefer-ip-address: true
  
---
server:
  port: 8202
spring:
  profiles: test
  application:
    name: springcloud-provider-dept

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

这里默认是dev的配置

配置文件（bootstrap、application）

bootstrap

# 系统级别的配置
spring:
  cloud:
    config:
      name: config-client # 需要从git上读取的资源名称，不需要后缀
      # 这里拿的就是上面的dev的8201的配置
      uri: http://localhost:3344
      profile: dev
      label: master

application

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

主启动类

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

controller

@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 getInfo(){
    
    
        return "applicationName = " + applicationName + " eurekaServer = " + eurekaServer + " port = " + port;
    }
}

启动config-sever，启动config-client端，访问http://localhost:8201/config，可以看到config-client读取的配置就是你git远端上指定的dev的配置属性的值，这样就简介的实现了配置文件的统一git管理，不用你在本地搞，本地负责的就是取config-server中读取配置好的配置即可

6、测试

现在将我们的一个Eureka和一个prodiver继承上Config

将配置文件上传到git上
config-eureka

spring:
  profiles:
    active: dev

---
server:
  port: 7001
spring:
  profiles: dev
  application:
    name: springcloud-config-eureka

# EurekaService_7001
eureka:
  instance:
    hostname: eureka7001 #Eureka服务端的实例名字
  client:
    register-with-eureka: false # 表示是否向Eureka注册中心注册自己
    fetch-registry: false # fetch-registry如果为false，则表示自己为注册中心
    service-url:  # 监控页面~
      # 单机
      # defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      # 集群
        defaultZone: http://eureka7002:7002/eureka/, http://eureka7003:7003/eureka/

---

server:
  port: 7001
spring:
  profiles: test
  application:
    name: springcloud-config-eureka

# EurekaService_7001
eureka:
  instance:
    hostname: eureka7001 #Eureka服务端的实例名字
  client:
    register-with-eureka: false # 表示是否向Eureka注册中心注册自己
    fetch-registry: false # fetch-registry如果为false，则表示自己为注册中心
    service-url:  # 监控页面~
      # 单机
      # defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      # 集群
        defaultZone: http://eureka7002:7002/eureka/, http://eureka7003:7003/eureka/

config-dept

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

#mybaits-plus
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      id-type: ASSIGN_ID
  type-aliases-package: com.lzy.springcloud.pojo

#spring的配置
spring:
  profiles: dev
  application:
    name: springcloud-config-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: lige0612

# Eureka的配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept-8001 # 修改Eureka上面的默认描述信息！
    prefer-ip-address: true
# info配置
info:
  app.name: lzy
  company.name: blog.lzy.com

---
server:
  port: 8001

#mybaits-plus
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      id-type: ASSIGN_ID
  type-aliases-package: com.lzy.springcloud.pojo

#spring的配置
spring:
  profiles: dev
  application:
    name: springcloud-config-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db02?allowPublicKeyRetrieval=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: lige0612

# Eureka的配置，服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001:7001/eureka/,http://eureka7002:7002/eureka/,http://eureka7003:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept-8001 # 修改Eureka上面的默认描述信息！
    prefer-ip-address: true
# info配置
info:
  app.name: lzy
  company.name: blog.lzy.com

创建一个config版本的Eureka，除了配置文件不复制其他的都复制即可

坐标

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

配置文件
bootstrap

# 系统级别的配置
spring:
  cloud:
    config:
      name: config-eureka # 需要从git上读取的资源名称，不需要后缀
      uri: http://localhost:3344
      profile: dev
      label: master

bootstrap中的profile的值，才是你在git上的config中取的东西，这个找环境配置不是由git上面决定的，是由这里决定的，我尝试了一下，我把git上面的改成dev1,（用的是db01数据库），然后我再本地用的是test，然后访问出来的数据就是db02的，说明了我上述说的应该是对的，当你本地用的是dev的，然后git端修改dev中配置为db03的时候，本地热部署一下，访问的也就是db03了，说明git上那个指定配置的没啥用，还是要看本地用谁才是谁，不过这样总的来说还是突出了一点就是配置文件与程序解耦

application

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

创建一个config版本的provider，除了配置文件不复制其他的都复制即可

坐标

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

配置文件
bootstrap

# 系统级别的配置
spring:
  cloud:
    config:
      name: config-dept # 需要从git上读取的资源名称，不需要后缀
      uri: http://localhost:3344
      profile: dev
      label: master

application

# 用户级别的配置
spring:
  application:
    name: springcloud-config-provider-dept-8001

启动config版本的eureka，启动config的provider，启动config的Server，启动一个80客户端

当你的eureka、provider正常启动，能登录到监控中心即可，访问一下http://localhost/consumer/dept/get/1，成功！