1.SpringCloud快速开发入门

1.1 搭建和配置一个服务提供者

我们知道，SpringCloud构建微服务是基于SpringBoot开发的。

1、创建一个SpringBoot工程（SpringBoot的Web工程），并且添加SpringBoot的相关依赖；

2、创建服务提供者的访问方法，也就是后续消费者如何访问提供者；

Spring Cloud是基于rest的访问，所以我们添加一个Controller，在该Controller中提供一个访问入口：

@RestController
public class HelloController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String hello() {
        return "Hello Spring Cloud";
    }
}

3、启动运行该SpringBoot程序，访问该controller；

1.2 搭建和配置一个服务消费者

服务消费者也是一个SpringBoot项目，服务消费者主要用来消费服务提供者提供的服务；

1、创建一个SpringBoot工程（SpringBoot的Web工程），并且添加SpringBoot的相关依赖；

2、定义自定义类RestTemplateConfig类，也可以在启动类中添加RestTemplate实例

@Configuration
 public class RestTemplateConfig {
   @Bean
   public RestTemplate restTemplate(){
     return new RestTemplate();
   }
 }

3、开发一个消费者方法，去消费服务提供者提供的服务，这个消费者方法也是一个Controller

 \* SpringCloud的消费者端，消费者就是一个普通的SpringBoot的web工程 
 \* 使用Http协议访问服务提供者
  
@RestController
public class TestController {
    @Autowired
    private RestTemplate restTemplate;
    @RequestMapping("/test")
    public Object test(){
        //访问远程的SpringCloud的服务
        //参数1 为服务器的地址以及服务器的请求名
        //参数2 用于指定返回的数据类型是字符格式
        //.getBody()方法的作用是获取响应的主体内容（服务端返回的具体JSON数据）
        return restTemplate.getForEntity("http://localhost:8081/test",String.class).getBody()+"  -----SpringCloud的消费者";
    }
}

4、启动该SpringBoot程序，测试服务消费者调用服务提供者；

RestTemplate概述

RestTemplate 是 Spring 提供的一个调用 Restful 服务的抽象层，它简化了 Restful 服务的通信方式，隐藏了不必要的一些细节，让我们更加优雅地在应用中调用 Restful 服务。我们在项目中经常要使用第三方的 Rest API 服务，比如短信、快递查询、天气预报等等。这些第三方只要提供了 Rest Api ，你都可以使用 RestTemplate 来调用它们。只要你的项目使用了 Spring MVC 就已经集成了RestTemplate 。但是通常情况下该类不会自动被注入 Spring IoC容器，需要手动实例化。

2. 走进服务注册中心Eureka

在微服务架构中，服务注册与发现是核心组件之一，手动指定每个服务是很低效的，Spring Cloud提供了多种服务注册与发现的实现方式，例如：Eureka、Consul、Zookeeper。

Spring Cloud支持得最好的是Eureka，其次是Consul，再次是Zookeeper。

2.1Eureka基本概念

什么是服务注册？

服务注册：将服务所在主机、端口、版本号、通信协议等信息登记到注册中心上；

什么是服务发现？

服务发现：服务消费者向注册中心请求已经登记的服务列表，然后得到某个服务的主机、端口、版本号、通信协议等信息，从而实现对具体服务的调用；

Eureka是什么？

Eureka来源于古希腊词汇，意为“发现了”。在软件领域， Eureka 是 Netflix 在线影片公司开源的一个服务注册与发现的组件，和其他Netflix 公司的服务组件（例如负载均衡、熔断器、网关等）一起，被Spring Cloud 社区整合为Spring Cloud Netflix 模块。Eureka 是Netflix 贡献给Spring Cloud的一个框架！

Eureka 采用了C-S（客户端/服务端）的设计架构，也就是Eureka由两个组件组成：Eureka服务端和Eureka客户端。Eureka Server 作为服务注册的服务端，它是服务注册中心，而系统中的其他微服务，使用 Eureka 的客户端连接到 Eureka Server服务端，并维持心跳连接，Eureka客户端是一个Java客户端，用来简化与服务器的交互、负载均衡，服务的故障切换等；

有了Eureka注册中心，系统的维护人员就可以通过 Eureka Server 来监控系统中各个微服务是否正常运行。

2.2 Eureka与Zookeeper的比较

著名的CAP理论指出，一个分布式系统不可能同时满足C(一致性)、A(可用性)和P(分区容错性)。

由于分区容错性在是分布式系统中必须要保证的，因此我们只能在A和C之间进行权衡，在此Zookeeper保证的是CP, 而Eureka则是AP。

Zookeeper保证CP(不平等）

在ZooKeeper中，当master节点因为网络故障与其他节点失去联系时，剩余节点会重新进行leader选举，但是问题在于，选举leader需要一定时间, 且选举期间整个ZooKeeper集群都是不可用的，这就导致在选举期间注册服务瘫痪。在云部署的环境下，因网络问题使得ZooKeeper集群失去master节点是大概率事件，虽然服务最终能够恢复，但是在选举时间内导致服务注册长期不可用是难以容忍的。

Eureka保证AP（平等，可用性）

Eureka优先保证可用性，Eureka各个节点是平等的，某几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而Eureka的客户端在向某个Eureka注册或时如果发现连接失败，则会自动切换至其它节点，只要有一台Eureka还在，就能保证注册服务可用(保证可用性)，只不过查到的信息可能不是最新的(不保证强一致性)。

所以Eureka在网络故障导致部分节点失去联系的情况下，只要有一个节点可用，那么注册和查询服务就可以正常使用，而不会像zookeeper那样使整个注册服务瘫痪，Eureka优先保证了可用性。

2.3 搭建与配置Eureka服务注册中心

Spring Cloud要使用Eureka注册中心非常简单和方便，Spring Cloud中的Eureka服务注册中心实际上也是一个Spring Boot工程，我们只需通过引入相关依赖和注解配置就能让Spring Boot构建的微服务应用轻松地与Eureka进行整合。

具体步骤如下：

1、创建一个SpringBoot项目02-springcloud-eureka-server，并且添加SpringBoot的相关依赖；

2、添加eureka的依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.8</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.powernode</groupId>
    <artifactId>springcloud-eureka-server</artifactId>
    <version>1.0.0</version>
    <name>002-springcloud-eureka-server</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2021.0.1</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>
    <!--必须添加Maven的依赖管理器，否则eureka无法被识别-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

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

4.application.yml文件

server:
  port: 9100
spring:
  application:
    name: eureka-server
eureka:
  client:
    register-with-eureka: false #    不需要作为服务器注册自己
    fetch-registry: false  #    不去拉取其他

5.在Spring Boot的入口类上添加一个@EnableEurekaServer注解，用于开启Eureka注册中心服务端

2.6.启动与测试Eureka服务注册中心

1、启动SpringBoot程序；

2、启动成功之后，通过在浏览器地址栏访问我们的注册中心；浏览器输入

http://localhost:9100 来测试Eureka是否启动
在这里插入图片描述

2.7 向Eureka服务注册中心注册服务

创建服务提供者项目，并将该服务提供者注册到Eureke注册中心，步骤如下：

1、在该服务提供者中添加eureka的依赖，因为服务提供者向注册中心注册服务，需要连接eureka，所以需要eureka客户端的支持；

 <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2021.0.1</spring-cloud.version>
    </properties>
    <dependencies>
    
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

2、设置服务提供者的application.properties文件，配置服务名称和注册中心地址

#指定服务名字 这个名称将在服务消费者时被调用
spring.application.name=002-provider
#指定eureka的访问地址
eureka.client.service-url.defaultZone=http://localhost:9100/eureka
#设置端口
server.port=8081

3、激活Eureka中的EnableEurekaClient功能：

在Spring Boot的入口函数处，通过添加@EnableEurekaClient注解来表明自己是一个eureka客户端，让我的服务消费者可以使用eureka注册中心

4、编写控制器提供服务

//自定义控制器类对外提供服务

@RestController
public class ProviderController {
    @GetMapping("/hello")
    public String hello(){
        return "hello,服务提供者向注册中心注册服务";
    }
}

5、启动服务提供者SpringBoot程序的main方法运行；

6、启动运行之后，通过在浏览器地址栏访问我们之前搭建好的eureka注册中心，就可以看到有一个服务已经注册成功了

2.8 从Eureka服务注册中心发现与消费服务

我们已经搭建一个服务注册中心，同时也向这个服务注册中心注册了服务，接下来我们就可以发现和消费服务了，这其中服务的发现由eureka客户端实现，而服务的消费由Ribbon实现，也就是说服务的调用需要eureka客户端和Ribbon两者配合起来才能实现；

Eureka客户端是什么？

Eureka客户端是一个Java客户端，用来连接Eureka服务端，与服务端进行交互、负载均衡，服务的故障切换等；

Ribbon是什么？

Ribbon是一个基于HTTP 和 TCP 的客户端负载均衡器，当使用Ribbon对服务进行访问的时候，它会扩展Eureka客户端的服务发现功能，实现从Eureka注册中心中获取服务端列表，并通过Eureka客户端来确定服务端是否己经启动。Ribbon在Eureka客户端服务发现的基础上，实现了对服务实例的选择策略，从而实现对服务的负载均衡消费。

接下来我们来让服务消费者去消费服务：

我们前面搭建了服务消费者项目，接下来我们就可以使用该服务消费者通过注册中心去调用服务提供者，步骤如下：

1、在该消费者项目中添加eureka的依赖，因为服务消费者从注册中心获取服务，需要连接eureka，所以需要eureka客户端的支持；

 <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR3</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

2.配置服务的名称和注册中心的地址：

#指定服务的名称 即使是服务的消费者也会将自己注册到注册中心
server:
  port: 9002
spring:
  application:
    name: consumer
eureka:
  client:
    service-url:
      defaultZone: http://localhost:9100/eureka

3、激活Eureka中的EnableEurekaClient功能：

在Spring Boot的入口函数处，通过添加@EnableEurekaClient注解来表明自己是一个eureka客户端，让我的服务消费者可以使用eureka注册中心；

4、服务的发现由eureka客户端实现，而服务的真正调用由ribbon实现，所以我们需要在调用服务提供者时使用ribbon来调用,需要在RestTemplate上添加注解@LoadBalanced

  @Bean
  @LoadBalanced //如果不加该注解，运行时报位置主机异常java.net.UnknownHostException
  public RestTemplate restTemplate(){
        return  new RestTemplate();
  }

5、调用服务

加入了ribbon的支持，那么在调用时，即可改为使用服务名称来访问：

   @Autowired
    private RestTemplate restTemplate;
    @GetMapping("/test")
    public String test(){
        //提供者服务的名称
        String serviceName="http://02-provider/hello";
        String result=restTemplate.getForEntity(serviceName,String.class).getBody();
        return "消费者通过Eureka调用远程服务--"+result;
    }

7、完成上面的步骤后，我们就可以启动消费者的SpringBoot程序，main方法运行；

8、启动成功之后，通过在浏览器地址栏访问我们的消费者，看是否可以正常调用远程服务提供者提供的服务；

2.9服务端常用配置

server:
    port: 8761
spring:
    application:
        name: eureka-server
eureka:
    client:
        service-url:    #eureka服务端和客户端的交互地址,集群用,隔开
            defaultZone: http://localhost:8761/eureka
        fetch-registry: true   #是否拉取服务列表
        register-with-eureka: true     #是否注册自己（单机eureka一般关闭注册自己,集群注意打开）
    server:
        eviction-interval-timer-in-ms: 30000    #清除无效节点的频率(毫秒)--定期删除
        enable-self-preservation: true      #server的自我保护机制，避免因为网络原因造成误剔除,生产环境建议打开
        renewal-percent-threshold: 0.85     #85%，如果在一个机房的client端，15分钟内有85%的client没有续约，那么则可能是网络原因，认为服务实例没有问题，不会剔除他们，宁可放过一万，不可错杀一个，确保高可用
    instance:
        hostname: localhost # 服务主机名称
        instance-id: ${eureka.instance.hostname}:${spring.application.name}:${server.port}  # 实例id
        prefer-ip-address: true  # 服务列表以ip的形式展示
        lease-renewal-interval-in-seconds: 10  # 表示eureka client发送心跳给server端的频率
        lease-expiration-duration-in-seconds: 20  #表示eureka server至上一次收到client的心跳之后，等待下一次心跳的超时时间，在这个时间内若没收到下一次心跳，则将移除该实例

2.10客户端常用配置

server:
    port: 8080
spring:
    application:
        name: eureka-client
eureka:
    client:
        service-url:    #eureka服务端和客户端的交互地址,集群用,隔开
            defaultZone: http://localhost:8761/eureka
        register-with-eureka: true  #注册自己
        fetch-registry: true    #拉取服务列表
        registry-fetch-interval-seconds: 5 # 表示eureka-client间隔多久去拉取服务注册信息
    instance:
        hostname: localhost # 服务主机名称
        instance-id: ${eureka.instance.hostname}:${spring.application.name}:${server.port}  # 实例id
        prefer-ip-address: true  # 服务列表以ip的形式展示
        lease-renewal-interval-in-seconds: 10  # 表示eureka client发送心跳给server端的频率
        lease-expiration-duration-in-seconds: 20  #表示eureka server至上一次收到client的心跳之后，等待下一次心跳的超时时间，在这个时间内若没收到下一次心跳，则将移除该实例

3Eureka集群

3.1. Eureka注册中心高可用集群概述

在微服务架构的这种分布式系统中，我们要充分考虑各个微服务组件的高可用性问题，不能有单点故障，由于注册中心eureka本身也是一个服务，如果它只有一个节点，那么它有可能发生故障，这样我们就不能注册与查询服务了，所以我们需要一个高可用的服务注册中心，这就需要通过注册中心集群来解决。

在这里插入图片描述

eureka服务注册中心它本身也是一个服务，它也可以看做是一个提供者，又可以看做是一个消费者，我们之前通过配置：

eureka.client.register-with-eureka=false 让注册中心不注册自己，但是我们可以向其他注册中心注册自己；

Eureka Server的高可用实际上就是将自己作为服务向其他服务注册中心注册自己，这样就会形成一组互相注册的服务注册中心，进而实现服务清单的互相同步，往注册中心A上注册的服务，可以被复制同步到注册中心B上，所以从任何一台注册中心上都能查询到已经注册的服务，从而达到高可用的效果。

3.2 Eureka注册中心高可用集群搭建

Eureka注册中心高可用集群就是各个注册中心相互注册

1.创建2个SpringBoot 的Eureka的服务端项目：

03-eureka-cluster-9100

03-eureka-cluster-9200

2.设置9100,9200服务器的配置内容

server:
  port: 9001
spring:
  application:
    name: provider
eureka:
  client:
    service-url:
      defaultZone: http://eureka9100:9100/eureka, http://eureka9200:9200/eureka

server:
  port: 9200
spring:
  application:
    name: eureka9200
eureka:
  client:
    service-url:
      defaultZone: http://eureka9100:9100/eureka   #9200作为9100的客户端
    register-with-eureka: false
    fetch-registry: false
  instance:
    hostname: eureka9200   #机器名

3.在本地hosts文件配置

C:\Windows\System32\drivers\etc\hosts,添加如下映射

127.0.0.1 eureka9100

127.0.0.1 eureka9200

4.分别启动9100和9200，观察服务注册信息

3.3 Eureka注册中心高可用集群测试

1.创建生产者项目003-provider

2.设置提供者配置信息

spring.application.name=03-provider
#将服务同时注册到多个注册中心,其实当Eureka注册中心实现集群以后，那么将服务注册到任意一个Eureka的注册中心后，数据服务都会
#同步到其他的Eureka注册中心，但是实际应用时还是建议将服务分别注册到全部的Eureka集群的所有服务中，这个防止某个Eureka出现故障后服务仍然可以注册成功
eureka.client.service-url.defaultZone=http://eureka9100:9100/eureka/,http://eureka9200:9200/eureka/
#指定Tomcat的端口号
server.port=8081

3.创建消费者项目003-consumer

4.设置消费者配置信息

spring.application.name= 03-consumer
#将服务同时注册到多个注册中心,其实当Eureka注册中心实现集群以后，那么将服务注册到任意一个Eureka的注册中心后，数据服务都会#同步到其他的Eureka注册中心，但是实际应用时还是建议将服务分别注册到全部的Eureka集群的所有服务中，这个防止某个Eureka出现故障后服务仍然可以注册成功
eureka.client.service-url.defaultZone=http://eureka9100:9100/eureka/,http://eureka9200:9200/eureka/
#指定Tomcat的端口号
server.port=8080

启动服务提供者服务，然后观察注册中心页面，可以看到服务会在两个注册中心上都注册成功；

4. Eureka概念的理解

4.1 服务的注册

当项目启动时（eureka的客户端），就会向eureka-server发送自己的元数据（原始数据）（运行的ip，端口port，健康的状态监控等，因为使用的是http/ResuFul请求风格），eureka-server会在自己内部保留这些元数据(内存中)。（有一个服务列表）（restful风格，以http动词的请求方式，完成对url资源的操作）

4.2 服务的续约

项目启动成功了，除了向eureka-server注册自己成功，还会定时的向eureka-server汇报自己心跳，表示自己还活着。（修改一个时间）

4.3 服务的下线（主动下线）

当项目关闭时，会给eureka-server报告，说明自己要下机了。

4.4 服务的剔除（被动下线，主动剔除）

当项目超过了指定时间没有向eureka-server汇报自己，那么eureka-server就会认为此节点死掉了，会把它剔除掉，也不会放流量和请求到此节点了。


启动服务提供者服务，然后观察注册中心页面，可以看到服务会在两个注册中心上都注册成功；

# 4. Eureka概念的理解

## 4.1 服务的注册

当项目启动时（eureka的客户端），就会向eureka-server发送自己的**元数据（原始数据）**（运行的ip，端口port，健康的状态监控等，因为使用的是http/ResuFul请求风格），eureka-server会在自己内部保留这些元数据(内存中)。（有一个服务列表）（restful风格，以http动词的请求方式，完成对url资源的操作）

## 4.2 服务的续约

项目启动成功了，除了向eureka-server注册自己成功，还会**定时**的向eureka-server汇报自己心跳，表示自己还活着。（修改一个时间）

## 4.3 服务的下线（主动下线）

当项目关闭时，会给eureka-server报告，说明自己要下机了。

## 4.4 服务的剔除（被动下线，主动剔除）

当项目超过了指定时间没有向eureka-server汇报自己，那么eureka-server就会认为此节点死掉了，会把它剔除掉，也不会放流量和请求到此节点了。