第三节：Spring Cloud 核心组件（一）

原创 于 2020-09-04 01:11:20 发布 · 172 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#springcloud #项目

本文详细介绍了Eureka作为微服务注册中心的作用与搭建步骤，包括服务注册、发现、状态监控，以及如何构建高可用的EurekaServer集群。同时，讲解了服务提供者与消费者的集成过程，和Eureka与Ribbon结合实现的负载均衡策略。

此博客用于个人学习，来源于网上，对知识点进行一个整理。

1. Eureka 注册中心：

微服务项目需要解决的第一问题，服务的管理。

  1. 问题分析：

    在刚才的案例中，itcast-service-provider 对外提供服务，需要对外暴露自己的地址。而 consumer（调用者）需要记录服务提供者的地址。将来地址出现变更，还需要及时更新。这在服务较少的时候并不觉得有什么，但是在现在日益复杂的互联网环境，一个项目肯定会拆分出十几，甚至数十个微服务。此时如果还人为管理地址，不仅开发困难，将来测试、发布上线都会非常麻烦，这与 DevOps 的思想是背道而驰的。

  2. Eureka做什么？

    Eureka 就好比是滴滴，负责管理、记录服务提供者的信息。服务调用者无需自己寻找服务，而是把自己的需求告诉 Eureka，然后 Eureka 会把符合你需求的服务告诉你。同时，服务提供方与 Eureka 之间通过“心跳”机制进行监控，当某个服务提供方出现问题，Eureka自然会把它从服务列表中剔除。

    这就实现了服务的自动注册、发现、状态监控。

1.1 基本架构：

在这里插入图片描述

  • Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址。
  • 提供者：启动后向 Eureka 注册自己信息（地址，提供什么服务）。
  • 消费者：向 Eureka 订阅服务，Eureka 会将对应服务的所有提供者地址列表发送给消费者，并且定期更新。
  • 心跳(续约)：提供者定期通过 http 方式向 Eureka 刷新自己的状态。

1.2 搭建步骤：

1.2.1 搭建 EurekaServer：

使用 spring 提供的快速搭建工具，选择依赖：EurekaServer（服务注册中心依赖），Eureka Discovery（服务提供方和服务消费方）。因为，对于 eureka 来说：服务提供方和服务消费方都属于客户端。

pom.xml：

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

    <groupId>cn.itcast.eureka</groupId>
    <artifactId>itcast-eureka</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>itcast-eureka</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RC2</spring-cloud.version>
    </properties>

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

    </dependencies>

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

</project>

编写 application.yml 配置：

server:
  port: 10086 # 端口
spring:
  application:
    name: eureka-server # 应用名称，会在Eureka中显示
eureka:
  client:
    service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
      defaultZone: http://127.0.0.1:${server.port}/eureka

修改引导类，在类上添加 @EnableEurekaServer 注解：

@SpringBootApplication
@EnableEurekaServer // 声明当前springboot应用是一个eureka服务中心
public class ItcastEurekaApplication {

    public static void main(String[] args) {
        SpringApplication.run(ItcastEurekaApplication.class, args);
    }
}
1.2.2 注册到 Eureka：

注册服务，就是在服务上添加 Eureka 的客户端依赖，客户端代码会自动把服务注册到 EurekaServer 中。修改 itcast-service-provider 工程：

  1. 在 pom.xml 中，添加 springcloud 的相关依赖。
  2. 在 application.yml 中，添加 springcloud 的相关依赖。
  3. 在引导类上添加注解，把服务注入到 eureka 注册中心。

pom.xml：参照 itcast-eureka，先添加 SpringCloud 依赖，还有 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.itcast.service</groupId>
    <artifactId>itcast-service-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>itcast-service-provider</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>

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

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

application.yml：

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: root
    driverClassName: com.mysql.jdbc.Driver
  application:
    name: service-provider # 应用名称，注册到eureka后的服务名称
mybatis:
  type-aliases-package: cn.itcast.service.pojo
eureka:
  client:
    service-url: # EurekaServer地址
      defaultZone: http://127.0.0.1:10086/eureka

注意：添加了 spring.application.name 属性来指定应用名称，将来会作为应用的 id 使用。

引导类：通过添加 @EnableDiscoveryClient 来开启Eureka客户端功能。

@SpringBootApplication
@EnableDiscoveryClient
public class ItcastServiceProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(ItcastServiceApplication.class, args);
    }
}
1.2.3 从 Eureka 获取服务：

接下来修改 itcast-service-consumer，尝试从 EurekaServer 获取服务。方法与消费者类似，只需要在项目中添加 EurekaClient 依赖，就可以通过服务名称来获取信息了。

pom.xml：

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

    <groupId>cn.itcast.service</groupId>
    <artifactId>itcast-service-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>itcast-service-consumer</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Eureka客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>

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

    <!-- SpringCloud的依赖 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.SR2</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

修改配置文件：

server:
  port: 80
spring:
  application:
    name: service-consumer
eureka:
  client:
    service-url:
      defaultZone: http://localhost:10086/eureka

在启动类开启 Eureka 客户端：

@SpringBootApplication
@EnableDiscoveryClient // 开启Eureka客户端
public class ItcastServiceConsumerApplication {

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

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

修改 UserController 代码，用 DiscoveryClient 类的方法，根据服务名称，获取服务实例：

@Controller
@RequestMapping("consumer/user")
public class UserController {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient; // eureka客户端，可以获取到eureka中服务的信息

    @GetMapping
    @ResponseBody
    public User queryUserById(@RequestParam("id") Long id){
        // 根据服务名称，获取服务实例。有可能是集群，所以是service实例集合
        List<ServiceInstance> instances = discoveryClient.getInstances("service-provider");
        // 因为只有一个Service-provider。所以获取第一个实例
        ServiceInstance instance = instances.get(0);
        // 获取ip和端口信息，拼接成服务地址
        String baseUrl = "http://" + instance.getHost() + ":" + instance.getPort() + "/user/" + id;
        User user = this.restTemplate.getForObject(baseUrl, User.class);
        return user;
    }
}

1.3 Eureka 的原理及配置：

1.3.1 基础架构：

Eureka架构中的三个核心角色：

  • 服务注册中心

    Eureka的服务端应用，提供服务注册和发现功能，就是刚刚我们建立的 itcast-eureka。

  • 服务提供者

    提供服务的应用，可以是 SpringBoot 应用，也可以是其它任意技术实现，只要对外提供的是 Rest 风格服务即可。本例中就是我们实现的 itcast-service-provider。

  • 服务消费者

    消费应用从注册中心获取服务列表，从而得知每个服务方的信息，知道去哪里调用服务方。本例中就是我们实现的 itcast-service-consumer。

1.3.2 高可用的 Eureka Server：

Eureka Server 即服务的注册中心，在刚才的案例中，我们只有一个 EurekaServer，事实上 EurekaServer 也可以是一个集群，形成高可用的 Eureka 中心。

  1. 服务同步：

    多个 Eureka Server 之间也会互相注册为服务，当服务提供者注册到 Eureka Server 集群中的某个节点时，该节点会把服务的信息同步给集群中的每个节点，从而实现数据同步。因此，无论客户端访问到 Eureka Server 集群中的任意一个节点，都可以获取到完整的服务列表信息。

  2. 动手搭建高可用的 EurekaServer：

    假设要运行两个EurekaServer的集群，端口分别为：10086和10087。

    1）启动第一个 eurekaServer，我们修改原来的 EurekaServer 配置：

    server:
  port: 10086 # 端口
spring:
  application:
    name: eureka-server # 应用名称，会在Eureka中显示
eureka:
  client:
    service-url: # 配置其他Eureka服务的地址，而不是自己，比如10087
      defaultZone: http://127.0.0.1:10087/eureka

    2）启动第二个 eurekaServer，再次修改 itcast-eureka 的配置：

    server:
  port: 10087 # 端口
spring:
  application:
    name: eureka-server # 应用名称，会在Eureka中显示
eureka:
  client:
    service-url: # 配置其他Eureka服务的地址，而不是自己，比如10087
      defaultZone: http://127.0.0.1:10086/eureka

    3）客户端注册服务到集群：

    因为 EurekaServer 不止一个，因此注册服务的时候，service-url 参数需要变化：

    eureka:
  client:
    service-url: # EurekaServer地址,多个地址以','隔开
      defaultZone: http://127.0.0.1:10086/eureka,http://127.0.0.1:10087/eureka

    所谓的高可用注册中心，其实就是把 EurekaServer 自己也作为一个服务进行注册，这样多个 EurekaServer 之间就能互相发现对方，从而形成集群。

1.3.3 服务提供者：

服务提供者要向 EurekaServer 注册服务，并且完成服务续约等工作。

  1. 服务注册：

    服务提供者在启动时，会检测配置属性中的：eureka.client.register-with-eureka=true 参数是否正确，事实上默认就是 true。如果值确实为 true，则会向 EurekaServer 发起一个 Rest 请求，并携带自己的元数据信息，Eureka Server 会把这些信息保存到一个双层 Map 结构中。

    • 第一层 Map 的 Key 就是服务 id，一般是配置中的 spring.application.name 属性。
    • 第二层 Map 的 key 是服务的实例id。一般 host+ serviceId + port，例如：locahost:service-provider:8081。
    • 值则是服务的实例对象，也就是说一个服务，可以同时启动多个不同实例，形成集群。

  2. 服务续约：

    在注册服务完成以后，服务提供者会维持一个心跳（定时向EurekaServer发起Rest请求），告诉EurekaServer：“我还活着”。这个我们称为服务的续约（renew）；

    有两个重要参数可以修改服务续约的行为：

    eureka:
  instance:
    lease-expiration-duration-in-seconds: 90
    lease-renewal-interval-in-seconds: 30
    • lease-renewal-interval-in-seconds：服务续约(renew)的间隔，默认为30秒
    • lease-expiration-duration-in-seconds：服务失效时间，默认值90秒

也就是说，默认情况下每个30秒服务会向注册中心发送一次心跳，证明自己还活着。如果超过90秒没有发送心跳，EurekaServer 就会认为该服务宕机，会从服务列表中移除，这两个值在生产环境不要修改，默认即可。但是在开发时，这个值有点太长了，经常我们关掉一个服务，会发现Eureka依然认为服务在活着。所以我们在开发阶段可以适当调小。

1.3.4 服务消费者：

  1. 获取服务列表：

    当服务消费者启动时，会检测 eureka.client.fetch-registry=true 参数的值，如果为 true，则会拉取 Eureka Server 服务的列表只读备份，然后缓存在本地。并且每隔30秒会重新获取并更新数据。我们可以通过下面的参数来修改。

    eureka:
  client:
    registry-fetch-interval-seconds: 5

    为了开发环境下，能够快速得到服务的最新状态，我们可以将其设置小一点。

1.3.5 失效剔除和自我保护：

  1. 服务下线：

    当服务进行正常关闭操作时，它会触发一个服务下线的 REST 请求给 Eureka Server，告诉服务注册中心：“我要下线了”。服务中心接受到请求之后，将该服务置为下线状态。

  2. 失效剔除：

    有些时候，我们的服务提供方并不一定会正常下线，可能因为内存溢出、网络故障等原因导致服务无法正常工作。Eureka Server 需要将这样的服务剔除出服务列表。因此它会开启一个定时任务，每隔60秒对所有失效的服务（超过90秒未响应）进行剔除。

    可以通过 eureka.server.eviction-interval-timer-in-ms 参数对其进行修改，单位是毫秒，生产环境不要修改。这个会对我们开发带来极大的不变，你对服务重启，隔了60秒 Eureka 才反应过来。开发阶段可以适当调整，比如：10秒。

  3. 自我保护：

    我们关停一个服务，就会在Eureka面板看到一条警告：

    在这里插入图片描述
    这是触发了 Eureka 的自我保护机制。当一个服务未按时进行心跳续约时，Eureka 会统计最近15分钟心跳失败的服务实例的比例是否超过了85%。在生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，因为服务可能没有宕机。Eureka 就会把当前实例的注册信息保护起来，不予剔除。生产环境下这很有效，保证了大多数服务依然可用。

    但是这给我们的开发带来了麻烦， 因此开发阶段我们都会关闭自我保护模式：（itcast-eureka）

    eureka:
  server:
    enable-self-preservation: false # 关闭自我保护模式（缺省为打开）
    eviction-interval-timer-in-ms: 1000 # 扫描失效服务的间隔时间（缺省为60*1000ms）

2.负载均衡 Ribbon：

启动了一个 itcast-service-provider，然后通过 DiscoveryClient 来获取服务实例信息，然后获取 ip 和端口来访问。但是实际环境中，我们往往会开启很多个 itcast-service-provider 的集群。此时我们获取的服务列表中就会有多个，到底该访问哪一个呢？

一般这种情况下我们就需要编写负载均衡算法，在多个实例列表中进行选择。

2.1 启动两个服务实例：

首先参照 itcast-eureka 启动两个 ItcastServiceProviderApplication 实例，一个8081，一个8082。

2.2 开启负载均衡：

因为 Eureka 中已经集成了 Ribbon，所以我们无需引入新的依赖，直接修改代码。

修改 itcast-service-consumer 的引导类，在 RestTemplate 的配置方法上添加 @LoadBalanced 注解：

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}

修改调用方式，不再手动获取ip和端口，而是直接通过服务名称调用：

@Controller
@RequestMapping("consumer/user")
public class UserController {

    @Autowired
    private RestTemplate restTemplate;

    //@Autowired
    //private DiscoveryClient discoveryClient; // 注入discoveryClient，通过该客户端获取服务列表

    @GetMapping
    @ResponseBody
    public User queryUserById(@RequestParam("id") Long id){
        // 通过client获取服务提供方的服务列表，这里我们只有一个
        // ServiceInstance instance = discoveryClient.getInstances("service-provider").get(0);
        String baseUrl = "http://service-provider/user/" + id;
        User user = this.restTemplate.getForObject(baseUrl, User.class);
        return user;
    }

}

2.3 负载均衡策略：

Ribbon 默认的负载均衡策略是简单的轮询，在源码中我们看到拦截中是使用 RibbonLoadBalanceClient 来进行负载均衡的，其中有一个 choose 方法，找到 choose 方法的接口方法，是这样介绍的：

在这里插入图片描述
可以看出默认的策略是轮询的方式，但是可以也可以修改这种策略。

SpringBoot 也帮我们提供了修改负载均衡规则的配置入口，在 itcast-service-consumer 的 application.yml 中添加如下配置：

server:
  port: 80
spring:
  application:
    name: service-consumer
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
service-provider:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

格式是：{服务名称}.ribbon.NFLoadBalancerRuleClassName，值就是 IRule 的实现类。

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值