【微服务】Eureka（服务注册，服务发现）

1.基本介绍

1.学前说明

2.当前架构分析

1.示意图

2.问题分析

3.引出Eureka

1.项目架构分析

2.上图解读

2.创建单机版的Eureka

1.创建 e-commerce-eureka-server-9001 子模块

2.检查父子pom.xml

1.子 pom.xml

2.父 pom.xml

3.pom.xml 引入依赖

    <dependencies>

        <!-- 引入 eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <!-- 使用版本仲裁 -->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <!-- 公共模块的jar包 -->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>e_commerce_center-common-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

4.application.yml 配置eureka服务

server:
  port: 9001
eureka: # 配置eureka-server
  instance:
    hostname: localhost # 服务实例名
  client: # 因为以后可能有其他的eureka服务端，那是这个eureka服务就会既是客户端又是服务端，所以在这里配置一下作为客户端的配置
    register-with-eureka: false # 不向注册中心注册自己
    fetch-registry: false # 自己就是注册中心，所以不需要去发现服务
    service-url:
      # 这里使用了${}来动态获取主机和端口
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka # 交互模块，查询服务和注册服务都需要依赖这个地址（就是注册这个）

1
2
3
4
5
6
7
8
9
10
11
12

5.com/sun/springcloud/EurekaApplication.java 编写启动类运行测试

package com.sun.springcloud;

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

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/3/24 19:38
 * @Version 1.0
 */
@EnableEurekaServer // 作为eureka服务端启动
@SpringBootApplication
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

6.会员中心模块作为Eureka Client示意图

7.member-service-provider-10001 模块作为Eureka Client

1.pom.xml引入Eureka 客户端依赖

        <!-- 引入eureka的客户端场景启动器 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <!-- 使用版本仲裁 -->
        </dependency>
1
2
3
4
5
6

2.application.yml 配置Eureka Client

server:
  port: 10001 # 配置服务端口
spring:
  application:
    name: member-service-provider-10001 # 配置服务的名称，名字任意这里与项目名保持一致
eureka: # eureka客户端配置
  client:
    register-with-eureka: true # 将自己注册到eureka服务
    fetch-registry: true # 发现服务功能，如果是集群，必须要能发现服务才能配合ribben进行负载均衡
    service-url:
      defaultZone: http://localhost:9001/eureka #表示自己要注册到哪个服务
1
2
3
4
5
6
7
8
9
10
11

3.修改启动类添加注解

8.测试

1.先启动Eureka 服务端，再启动Eureka 客户端

2.访问(http://localhost:9001/) 进入Eureka 服务端

9.服务消费模块作为Eureka Client示意图

10.member-service-consumer-81 模块作为Eureka Client

1.pom.xml 引入Eureka 客户端依赖

        <!-- 引入eureka的客户端场景启动器 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <!-- 使用版本仲裁 -->
        </dependency>
1
2
3
4
5
6

2.application.yml 配置Eureka Client

server:
  port: 81 # 监听81端口
spring:
  application:
    name: member-service-consumer-81
eureka: # eureka客户端配置
  client:
    register-with-eureka: true # 将自己注册到eureka服务
    fetch-registry: true # 发现服务功能，如果是集群，必须要能发现服务才能配合ribben进行负载均衡
    service-url:
      defaultZone: http://localhost:9001/eureka #表示自己要注册到哪个服务
1
2
3
4
5
6
7
8
9
10
11

3.修改启动类添加注解

11.测试

1.先启动Eureka 服务端，再启动Eureka 客户端

2.访问(http://localhost:9001/) 进入Eureka 服务端

12.梳理Service Consumer Service Provider Eureka Server 维护机制

• 简单来说Eureka就两个功能，发现服务，注册服务！
• 基本流程就是会员中心启动之后将自己的信息注册到Eureka Server（注册服务），服务消费者启动之后通过Eureka Server来发现服务（发现服务），得到会员中心的调用地址，然后通过rpc远程调用

13.Eureka自我保护模式

1.基本介绍

2.小结

• 服务在注册之后会不断地向服务端发送心跳，正常情况下如果90s内没有心跳，则服务端会认为这个客户端down掉了，就会清除记录
• 但是一旦自我保护机制开启，即使90s内没有心跳，也不会请求记录

3.禁用自我保护模式

1.服务端配置

server:
  port: 9001
eureka: # 配置eureka-server
  instance:
    hostname: localhost # 服务实例名
  client: # 因为以后可能有其他的eureka服务端，那是这个eureka服务就会既是客户端又是服务端，所以在这里配置一下作为客户端的配置
    register-with-eureka: false # 不向注册中心注册自己
    fetch-registry: false # 自己就是注册中心，所以不需要去检索服务
    service-url:
      # 这里使用了${}来动态获取主机和端口
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka # 交互模块，查询服务和注册服务都需要依赖这个地址（就是注册这个）
  server:
    enable-self-preservation: false # 关闭自我保护机制
    eviction-interval-timer-in-ms: 2000 # 两秒内收不到心跳包，就会超时
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.客户端配置

server:
  port: 10001 # 配置服务端口
spring:
  application:
    name: member-service-provider-10001 # 配置服务的名称，名字任意这里与项目名保持一致
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    # 别忘记创建数据库之后修改数据库名称
    url: 
    username: 
    password: 
mybatis:
  mapper-locations: classpath:mapper/*.xml # 扫描所有Mapper.xml
  type-aliases-package: com.sun.springcloud.entity # 扫描所有实体类，可以直接使用类名来标识
eureka: # eureka客户端配置
  client:
    register-with-eureka: true # 将自己注册到eureka服务
    fetch-registry: true # 发现服务功能，如果是集群，必须要能发现服务才能配合ribben进行负载均衡
    service-url:
      defaultZone: http://localhost:9001/eureka #表示自己要注册到哪个服务
  instance:
    lease-renewal-interval-in-seconds: 1 # 客户端向服务端发送的心跳间隔，默认30s
    lease-expiration-duration-in-seconds: 2 # 服务端收到最后一次心跳后等待的时间上限，默认90s
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.启动后访问http://localhost:9001/

4.关闭掉客户端

3.搭建Eureka多服务集群

1.示意图

2.创建e-commerce-eureka-server-9002子模块作为第二个Eureka服务

3.pom.xml 引入依赖（跟9001子模块的一样）

    <dependencies>

        <!-- 引入 eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <!-- 使用版本仲裁 -->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <!-- 公共模块的jar包 -->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>e_commerce_center-common-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

4.application.yml 配置

server:
  port: 9002
eureka: # 配置eureka-server
  instance:
    hostname: eureka9002.com # 服务实例名
  client: # 因为以后可能有其他的eureka服务端，那是这个eureka服务就会既是客户端又是服务端，所以在这里配置一下作为客户端的配置
    register-with-eureka: false # 不向注册中心注册自己
    fetch-registry: false # 自己就是注册中心，所以不需要去检索服务
    service-url:
      # 注册到9001server
      defaultZone: http://eureka9001.com:9001/eureka/ # 交互模块，查询服务和注册服务都需要依赖这个地址（就是注册这个）

1
2
3
4
5
6
7
8
9
10
11
12

5.修改9001模块的 application.yml 配置完成两个服务相互注册

server:
  port: 9001
eureka: # 配置eureka-server
  instance:
    hostname: eureka9001.com # 服务实例名
  client: # 因为以后可能有其他的eureka服务端，那是这个eureka服务就会既是客户端又是服务端，所以在这里配置一下作为客户端的配置
    register-with-eureka: false # 不向注册中心注册自己
    fetch-registry: false # 自己就是注册中心，所以不需要去检索服务
    service-url:
      # 注册到9002server
      defaultZone: http://eureka9002.com:9002/eureka/ # 交互模块，查询服务和注册服务都需要依赖这个地址（就是注册这个）

1
2
3
4
5
6
7
8
9
10
11
12

6.编写启动类

package com.sun.springcloud;

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

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/3/25 9:36
 * @Version 1.0
 */
@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication9002 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication9002.class, args);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7.配置Hosts运行Eureka

1.解释

• 由于上面配置的两个Eureka服务使用的是域名eureka9001.com和eureka9002.com
• 所以需要配置hosts文件

2.hosts文件所在位置

3.修改Hosts文件

• 这样eureka9002.com和eureka9001.com都表示127.0.0.1了
• 如果这里不能直接修改就把文件复制一份在别的地方修改一下然后覆盖这个文件即可
• 注意：你如果现在开的代理服务器，hosts文件是不生效的！

4.启动这两个服务，访问测试

8.Eureka多个服务端互相注册配置文件理解

1.服务端一（eureka9001.com:9001）

server:
  port: 9001
eureka: # 配置eureka-server
  instance:
    hostname: eureka9001.com # 服务实例名（只有服务端才配置，就是ip）
  client: #	服务端和客户端都需要配置
    register-with-eureka: false # 不向注册中心注册自己
    fetch-registry: false # 自己就是注册中心，所以不需要去检索服务
    service-url:
      # 注册地址（如果只有一个服务端，就填写自己的服务地址加上/eureka/）这里注册到eureka9002.com:9002
      defaultZone: http://eureka9002.com:9002/eureka/ # 交互模块，查询服务和注册服务都需要依赖这个地址（就是注册这个）

1
2
3
4
5
6
7
8
9
10
11
12

2.服务端二（eureka9002.com:9002）

server:
  port: 9002
eureka: # 配置eureka-server
  instance:
    hostname: eureka9002.com # 服务实例名（只有服务端才配置，就是ip）
  client: #	服务端和客户端都需要配置
    register-with-eureka: false # 不向注册中心注册自己
    fetch-registry: false # 自己就是注册中心，所以不需要去检索服务
    service-url:
      # 注册地址（如果只有一个服务端，就填写自己的服务地址加上/eureka/）这里注册到eureka9001.com:9001
      defaultZone: http://eureka9001.com:9001/eureka/ # 交互模块，查询服务和注册服务都需要依赖这个地址（就是注册这个）

1
2
3
4
5
6
7
8
9
10
11
12

4.将客户端注册到Eureka服务集群

1.示意图

2.修改81客户端的application.yml

server:
  port: 81 # 监听81端口
spring:
  application:
    name: member-service-consumer-81
eureka: # eureka客户端配置
  client:
    register-with-eureka: true # 将自己注册到eureka服务
    fetch-registry: true # 发现服务功能，如果是集群，必须要能发现服务才能配合ribben进行负载均衡
    service-url:
      # 需要注册到两个服务，则只需要用逗号间隔
      defaultZone: http://eureka9001.com:9001/eureka/, http://eureka9002.com:9002/eureka/
1
2
3
4
5
6
7
8
9
10
11
12

3.修改10001客户端的application.yml

server:
  port: 10001 # 监听10001端口
spring:
  application:
    name: member-service-provider-10001 # 配置服务的名称，名字任意这里与项目名保持一致
eureka: # eureka客户端配置
  client:
    register-with-eureka: true # 将自己注册到eureka服务
    fetch-registry: true # 发现服务功能，如果是集群，必须要能发现服务才能配合ribben进行负载均衡
    service-url:
      # 需要注册到两个服务，则只需要用逗号间隔
      defaultZone: http://eureka9001.com:9001/eureka/, http://eureka9002.com:9002/eureka/  #表示自己要注册到哪个服务
1
2
3
4
5
6
7
8
9
10
11
12

5.启动四个服务

6.测试访问

7.Eureka多个客户端注册多个服务端配置文件理解

1.客户端一（端口81）

server:
  port: 81 # 监听81端口
spring:
  application:
    name: member-service-consumer-81 # 客户端服务名称
eureka: # eureka客户端配置
  client:
    register-with-eureka: true # 将自己注册到eureka服务
    fetch-registry: true # 发现服务功能，如果是集群，必须要能发现服务才能配合ribben进行负载均衡
    service-url:
      # 需要注册到两个服务，则只需要用逗号间隔
      defaultZone: http://eureka9001.com:9001/eureka/, http://eureka9002.com:9002/eureka/
1
2
3
4
5
6
7
8
9
10
11
12

2.客户端二（端口10001）

server:
  port: 10001 # 监听10001端口
spring:
  application:
    name: member-service-provider-10001 # 客户端服务名称
eureka: # eureka客户端配置
  client:
    register-with-eureka: true # 将自己注册到eureka服务
    fetch-registry: true # 发现服务功能，如果是集群，必须要能发现服务才能配合ribben进行负载均衡
    service-url:
      # 需要注册到两个服务，则只需要用逗号间隔
      defaultZone: http://eureka9001.com:9001/eureka/, http://eureka9002.com:9002/eureka/  #表示自己要注册到哪个服务
1
2
3
4
5
6
7
8
9
10
11
12

5.搭建会员中心服务提供方集群

1.示意图

2.基本说明

3.创建 member-service-provider-10002 子模块与10001功能完全一致

4.打开10001模块的文件夹，复制main目录下的文件夹

5.打开10002模块的文件夹，将刚才复制的内容粘贴到main目录下

6.打开idea查看10002模块

7.将10001模块的pom.xml文件依赖粘贴到10002模块（刷新maven）

8.修改10002模块application.yml 的端口为10002

9.修改10002和10001模块的主启动类名称

10.启动所有服务进行测试

11.统一10001服务和10002服务的注册名并启动测试

6.服务消费方（81模块）使用Eureka服务集群

1.示意图

2.修改com/sun/springcloud/controller/MemberConsumerController.java 的前缀为服务提供者在Eureka服务端的key

3.修改com/sun/springcloud/config/CustomizationBean.java 增加调用时负载均衡注解

4.修改两个服务提供方的信息，以便区分

member-service-provider-10001

member-service-provider-10002

5.启动测试

1.启动全部服务

2.查看注册情况

3.postman测试两个服务提供方是否正常

member-service-provider-10001

member-service-provider-10002

4.发送请求到服务提供方 member-service-consumer-81

1.第一次请求

2.第二次请求

7.DiscoveryClient获取服务注册信息

1.示意图

2.需求分析

3.代码实现

1.com/sun/springcloud/controller/MemberConsumerController.java 服务消费者调用DiscoveryClient

1.以接口的形式注入DiscoveryClient

2.编写一个接口完成服务发现

    /**
     * 服务消费方通过eureka服务集群来获取到服务提供方的服务
     *
     * @return
     */
    @GetMapping("/member/consumer/discovery")
    public Object discovery() {
        // 获取所有服务id
        List<String> services = discoveryClient.getServices();
        for (String service : services) {
            log.info("服务名小写={}", service);
            // 获取当前服务id对应的实例（可能有多个）
            List<ServiceInstance> instances = discoveryClient.getInstances(service);
            for (ServiceInstance instance : instances) {
                log.info("id={}, host={}, port={}, uri={}", service, instance.getHost(), instance.getPort(), instance.getUri());
            }
        }
        return services;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.在启动类使用@EnableDiscoveryClient启动服务发现

4.启动所有服务进行测试

5.注意事项

8.小结

1.项目完整文件目录

2.项目架构图