SpringCloud之服务注册中心

本是古典 何须时尚 2023-07-25 09:44 184阅读 0赞

前言

之前springcloud的家族如下图所示，因为微服务的引入，以及流量的增加，导致了微服务出现了一下的一些技术，主要分为服务注册与发现，服务调用，服务熔断，服务网关，服务配置，而这些对应的落地的技术就是下图了。
在这里插入图片描述
而现在由于部分功能的停更，其中Eureka官宣2.x版本不再开源，所以部分厂就要么使用下面的zookeeper，consul，以及阿里的nacos，以及服务调用中不推荐使用Ribbon以及Feign，而推荐使用LoadBalancer以及OpenFeign，服务降级中的豪猪哥Hystrix已经停止开发，官网推荐使用reilience4j，而国内则推荐使用阿里的sentinel，服务网关Zuul则是公司内部问题，准备出的Zuul2迟迟未上线，所以推荐使用Spring自己出的gateway，服务配置则不推荐使用Config了，推荐使用Nacos，服务总线，也从Bus转换到Nacos。
在这里插入图片描述

CAP原理

在这里插入图片描述

  • C（一致性）：所有的节点上的数据时刻保持同步
  • A（可用性）：每个请求都能接受到一个响应，无论响应成功或失败
  • P（分区容错）：系统应该能持续提供服务，即使系统内部有消息丢失（分区）

高可用、数据一致是很多系统设计的目标，但是分区又是不可避免的事情：

  • CA without P：如果不要求P（不允许分区），则C（强一致性）和A（可用性）是可以保证的。但其实分区不是你想不想的问题，而是始终会存在，因此CA的系统更多的是允许分区后各子系统依然保持CA。
  • CP without A：如果不要求A（可用），相当于每个请求都需要在Server之间强一致，而P（分区）会导致同步时间无限延长，如此CP也是可以保证的。很多传统的数据库分布式事务都属于这种模式。
  • AP wihtout C：要高可用并允许分区，则需放弃一致性。一旦分区发生，节点之间可能会失去联系，为了高可用，每个节点只能用本地数据提供服务，而这样会导致全局数据的不一致性。现在众多的NoSQL都属于此类。

服务注册中心

本节内容则主要讲解服务注册中心中的Eureka,Zookeeper,Consul,Nacos如何配置开发，以及他们之间的区别，如果选择他们。

Eureka

新建一个工程，在工程下面建立一个子模块，EurekaMain7001，其中pom如下：
其中加入spring-cloud-starter-netflix-eureka-server包。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>springcloud2020</artifactId>
  7.         <groupId>com.atguigu.springcloud</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>cloud-eureka-server7001</artifactId>
  13.     <dependencies>
  14.         <!--eureka-server-->
  15.         <dependency>
  16.             <groupId>org.springframework.cloud</groupId>
  17.             <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  18.         </dependency>
  19.         <!--boot web actuator-->
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-starter-web</artifactId>
  23.         </dependency>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-actuator</artifactId>
  27.         </dependency>
  28.         <!--一般通用配置-->
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-devtools</artifactId>
  32.             <scope>runtime</scope>
  33.             <optional>true</optional>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>org.projectlombok</groupId>
  37.             <artifactId>lombok</artifactId>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>org.springframework.boot</groupId>
  41.             <artifactId>spring-boot-starter-test</artifactId>
  42.             <scope>test</scope>
  43.         </dependency>
  44.         <dependency>
  45.             <groupId>junit</groupId>
  46.             <artifactId>junit</artifactId>
  47.         </dependency>
  48.     </dependencies>
  50. </project>

启动类如下：
主要加上@EnableEurekaServer注解。

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
  5. /** * ${description} * * @author Fjj * @date 2020/3/15 12:02 */
  6. @SpringBootApplication
  7. @EnableEurekaServer
  8. public class EurekaMain7001 { 
  10.     public static void main(String[] args) { 
  11.             SpringApplication.run(EurekaMain7001.class, args);
  12.         }
  13. }

application.yml文件如下：
主要配置端口，实例名，以及service-url。

  1. server:
  2.   port: 7001
  4. eureka:
  5.   instance:
  6.     hostname: eureka7001.com #eureka服务端的实例名称
  7.   client:
  8.     register-with-eureka: false     #false表示不向注册中心注册自己。
  9.     fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
  10.     service-url:
  11.       #集群指向其它eureka
  12.       #      defaultZone: http://eureka7002.com:7002/eureka/
  13.       #单机就是7001自己
  14.       defaultZone: http://eureka7001.com:7001/eureka/

配置完成之后就可以启动了：
会出现如下界面：
在这里插入图片描述
启动完成空白一片，接下来写我们的服务：（这边只演示注册服务，不进行服务调用）

首先创建服务提供者payment8001
下面是主启动类：
主要是加上@EnableEurekaClient以及@EnableDiscoveryClient注解二选一即可，后者可以用于所有的服务注册与发现，前者只能用于Eureka的服务注册与发现。

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  4. import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
  6. /** * ${description} * * @author Fjj * @date 2020/3/9 12:32 */
  7. @SpringBootApplication
  8. //@EnableEurekaClient
  9. @EnableDiscoveryClient
  10. public class PaymentMain01 { 
  12.     public static void main(String[] args) { 
  13.         SpringApplication.run(PaymentMain01.class, args);
  14.     }
  15. }

pom文件需要加上如下：

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  4. </dependency>

application.yml文件如下：
主要配置端口号，服务名称，eureka注册地址eureka-url和发送心跳时间间隔，等待时间间隔。

  1. server:
  2.   port: 8001
  4. spring:
  5.   application:
  6.     name: cloud-payment-service #服务名称
  7.   datasource:
  8.     type: com.alibaba.druid.pool.DruidDataSource  #当前数据源操作类型
  9.     driver-class-name: com.mysql.jdbc.Driver
  10.     url: jdbc:mysql://locahost:3306/cloud2020?characterEncoding=utf8&useSSL=false&useUnicode=true
  11.     username: root
  12.     password: 111111
  13. eureka:
  14.   client:
  15.     #表示向注册中心注册自己 默认为true
  16.     register-with-eureka: true
  17.     #是否从EurekaServer抓取已有的注册信息，默认为true,单节点无所谓,集群必须设置为true才能配合ribbon使用负载均衡
  18.     fetch-registry: true
  19.     service-url:
  20.       # 入驻地址
  21.       defaultZone: http://localhost:7001/eureka/
  22.       #集群版
  23.   #      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/
  24.   #服务名称
  25.   instance:
  26.     instance-id: payment8001
  27.     #访问路径可以显示IP地址
  28.     prefer-ip-address: true
  29.     #Eureka客户端向服务端发送心跳的时间间隔，单位为秒(默认是30秒)
  30.     #    lease-renewal-interval-in-seconds: 1
  31.     #Eureka服务端在收到最后一次心跳后等待时间上限，单位为秒(默认是90秒)，超时将剔除服务
  32. #    lease-expiration-duration-in-seconds: 2
  33. mybatis:
  34.   mapper-locations: classpath:mapper/*.xml type-aliases-package: com.atguigu.springcloud.entities #所有entity别名所在包

接下来启动PaymentMain01主启动类：
可以看到我们的微服务实例已经注册到了Eureka上面了，上面一排红色的字是Eureka的自我保护模式：
自我保护模式：一个微服务不可用了，Eureka不会立马清理，依旧会对该服务的信息进行保存（AP高可用，分区容错），我们的微服务可能并不是挂了，而是网络问题分区问题，导致Eureka接受不到服务的心跳包，而此服务确实正常的，所以Eureka为了高可用不会将服务立马删除。
可以使用eureka.server.enable-self-preservation=false来禁用自我保护模式。
将Eureka工程加上eureka.server.eviction-interval-timer-in-ms
以及服务端加上： lease-renewal-interval-in-seconds: 1 #Eureka客户端向服务端发送心跳的时间间隔，单位为秒(默认是30秒)
lease-expiration-duration-in-seconds: 2 #Eureka服务端在收到最后一次心跳后等待时间上限，单位为秒(默认是90秒)，超时将剔除服务
然后关闭服务，就会发现很快服务就会在Eureka上消失。
在这里插入图片描述
下图是eureka的工作流程图：

  • 服务注册(register)：Eureka Client会通过发送REST请求的方式向Eureka Server注册自己的服务，提供自身的元数据，比如ip地址、端口、运行状况指标的url、主页地址等信息。Eureka Server接收到注册请求后，就会把这些元数据信息存储在一个双层的Map中。
  • 服务续约(renew)：在服务注册后，Eureka Client会维护一个心跳来持续通知Eureka Server，说明服务一直处于可用状态，防止被剔除。Eureka Client在默认的情况下会每隔30秒(eureka.instance.leaseRenewallIntervalInSeconds)发送一次心跳来进行服务续约。
  • 服务同步(replicate)：Eureka Server之间会互相进行注册，构建Eureka Server集群，不同Eureka Server之间会进行服务同步，用来保证服务信息的一致性。
  • 获取服务(get registry)：服务消费者（Eureka Client）在启动的时候，会发送一个REST请求给Eureka Server，获取上面注册的服务清单，并且缓存在Eureka Client本地，默认缓存30秒(eureka.client.registryFetchIntervalSeconds)。同时，为了性能虑，Eureka Server也会维护一份只读的服务清单缓存，该缓存每隔30秒更新一次。
  • 服务调用：服务消费者在获取到服务清单后，就可以根据清单中的服务列表信息，查找到其他服务的地址，从而进行远程调用。Eureka有Region和Zone的概念，一个Region可以包含多个Zone，在进行服务调用时，优先访问处于同一个Zone中的服务提供者。
  • 服务下线(cancel)：当Eureka Client需要关闭或重启时，就不希望在这个时间段内再有请求进来，所以，就需要提前先发送REST请求给Eureka Server，告诉Eureka Server自己要下线了，Eureka Server在收到请求后，就会把该服务状态置为下线（DOWN），并把该下线事件传播出去。
  • 服务剔除(evict)：有时候，服务实例可能会因为网络故障等原因导致不能提供服务，而此时该实例也没有发送请求给Eureka Server来进行服务下线，所以，还需要有服务剔除的机制。Eureka Server在启动的时候会创建一个定时任务，每隔一段时间（默认60秒），从当前服务清单中把超时没有续约（默认90秒，eureka.instance.leaseExpirationDurationInSeconds）的服务剔除。
  • 自我保护：既然Eureka Server会定时剔除超时没有续约的服务，那就有可能出现一种场景，网络一段时间内发生了异常，所有的服务都没能够进行续约，Eureka Server就把所有的服务都剔除了，这样显然不太合理。所以，就有了自我保护机制，当短时间内，统计续约失败的比例，如果达到一定阈值，则会触发自我保护的机制，在该机制下，Eureka Server不会剔除任何的微服务，等到正常后，再退出自我保护机制。自我保护开关(eureka.server.enable-self-preservation: false)
    在这里插入图片描述

Zookeeper

新建一个工程PaymentMain8004：
pom文件：

这边注意zookeeper的版本问题。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>springcloud2020</artifactId>
  7.         <groupId>com.atguigu.springcloud</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>cloud-zookeeper-payment8111</artifactId>
  13.     <dependencies>
  14.         <!-- SpringBoot整合Web组件 -->
  15.         <dependency>
  16.             <groupId>org.springframework.boot</groupId>
  17.             <artifactId>spring-boot-starter-web</artifactId>
  18.         </dependency>
  19.         <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
  20.             <groupId>com.atguigu.springcloud</groupId>
  21.             <artifactId>cloud-api-commons</artifactId>
  22.             <version>${ project.version}</version>
  23.         </dependency>
  24.         <!-- SpringBoot整合zookeeper客户端 -->
  25.         <dependency>
  26.             <groupId>org.springframework.cloud</groupId>
  27.             <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
  28.             <!--先排除自带的zookeeper3.5.3-->
  29.             <exclusions>
  30.                 <exclusion>
  31.                     <groupId>org.apache.zookeeper</groupId>
  32.                     <artifactId>zookeeper</artifactId>
  33.                 </exclusion>
  34.             </exclusions>
  35.         </dependency>
  36.         <!--添加zookeeper3.4.9版本-->
  37.         <dependency>
  38.             <groupId>org.apache.zookeeper</groupId>
  39.             <artifactId>zookeeper</artifactId>
  40.             <version>3.4.9</version>
  41.         </dependency>
  42.         <dependency>
  43.             <groupId>org.springframework.boot</groupId>
  44.             <artifactId>spring-boot-devtools</artifactId>
  45.             <scope>runtime</scope>
  46.             <optional>true</optional>
  47.         </dependency>
  48.         <dependency>
  49.             <groupId>org.projectlombok</groupId>
  50.             <artifactId>lombok</artifactId>
  51.             <optional>true</optional>
  52.         </dependency>
  53.         <dependency>
  54.             <groupId>org.springframework.boot</groupId>
  55.             <artifactId>spring-boot-starter-test</artifactId>
  56.             <scope>test</scope>
  57.         </dependency>
  58.     </dependencies>
  60. </project>

一目了然，服务名称，以及zookeeper注册地址。

  1. #8004表示注册到zookeeper服务器的支付服务提供者端口号
  2. server:
  3.   port: 8004
  6. #服务别名----注册zookeeper到注册中心名称
  7. spring:
  8.   application:
  9.     name: cloud-provider-payment
  10.   cloud:
  11.     zookeeper:
  12.       connect-string: localhost:2181

然后主启动类：

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  6. @SpringBootApplication
  7. @EnableDiscoveryClient //该注解用于向使用consul或者zookeeper作为注册中心时注册服务
  8. public class PaymentMain8004
  9. { 
  10.     public static void main(String[] args) { 
  11.             SpringApplication.run(PaymentMain8004.class, args);
  12.     }
  13. }

启动：
zkCli.cmd -server 127.0.0.1:2181
进入到zk里面，可以查看到刚刚注册进去的节点：
每个服务注册进zookeeper都会生成一个流水号，可以根据这个流水号查看到节点信息。
在这里插入图片描述

接下来我们停止服务，在zookeeper上面一个心跳时间之后会发现服务消失了，也就是说，zookeeper并不像eureka那样有自我保护机制不立即清理，这也就是CP（一致性，分区容错）。

Consul

官网下载
下载完,解压，使用下面命令启动

  1. consul agent -dev

然后打开localhost:8500
在这里插入图片描述
老规矩新建一个module:
pom:
主要引入 spring-cloud-starter-consul-discovery 包

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>springcloud2020</artifactId>
  7.         <groupId>com.atguigu.springcloud</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>cloud-consul-provider8009</artifactId>
  13.     <dependencies>
  14.         <!--SpringCloud consul-server -->
  15.         <dependency>
  16.             <groupId>org.springframework.cloud</groupId>
  17.             <artifactId>spring-cloud-starter-consul-discovery</artifactId>
  18.         </dependency>
  19.         <!-- SpringBoot整合Web组件 -->
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-starter-web</artifactId>
  23.         </dependency>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-actuator</artifactId>
  27.         </dependency>
  28.         <!--日常通用jar包配置-->
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-devtools</artifactId>
  32.             <scope>runtime</scope>
  33.             <optional>true</optional>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>org.projectlombok</groupId>
  37.             <artifactId>lombok</artifactId>
  38.             <optional>true</optional>
  39.         </dependency>
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             <artifactId>spring-boot-starter-test</artifactId>
  43.             <scope>test</scope>
  44.         </dependency>
  45.         <dependency>
  46.             <groupId>cn.hutool</groupId>
  47.             <artifactId>hutool-all</artifactId>
  48.             <version>RELEASE</version>
  49.             <scope>test</scope>
  50.         </dependency>
  51.         <dependency>
  52.             <groupId>cn.hutool</groupId>
  53.             <artifactId>hutool-all</artifactId>
  54.             <version>RELEASE</version>
  55.             <scope>test</scope>
  56.         </dependency>
  57.     </dependencies>
  59. </project>

yml:
其实由其他的配置风格，大概能猜到consul的配置文件应该怎么配

  1. ###consul服务端口号
  2. server:
  3.   port: 8006
  5. spring:
  6.   application:
  7.     name: consul-provider-payment
  8. ####consul注册中心地址
  9.   cloud:
  10.     consul:
  11.       host: localhost
  12.       port: 8500
  13.       discovery:
  14.         #hostname: 127.0.0.1
  15.         service-name: ${ spring.application.name}

主启动类：

  1. package com.atguigu.cloud;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  8. @SpringBootApplication
  9. @EnableDiscoveryClient
  10. public class Cloud8006 { 
  11.     public static void main(String[] args) { 
  12.         SpringApplication.run(Cloud8006.class, args);
  13.     }
  14. }

启动之后就可以看到consul上注册的实例：
在这里插入图片描述
接着将springboot程序停止:
很快在页面上 服务就×了，

consul是CP模式，一致性和分区容错性。
在这里插入图片描述

Nacos

阿里的nacos是集大成者，充当服务注册中心以及配置服务，并且界面清晰支持CP和AP的切换。

下载nacos，nacos文档,以及demo
运行startup.cmd就可以很轻松的启动一个nacos，默认8848端口。
在这里插入图片描述
接下来老规矩新建一个工程：
主启动类加上@EnableDiscoveryClient，用于服务发现

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  6. @SpringBootApplication
  7. @EnableDiscoveryClient
  8. public class NacosProvider { 
  10.     public static void main(String[] args) { 
  11.         SpringApplication.run(NacosProvider.class, args);
  12.     }
  14. }

pom文件主要加上spring-cloud-starter-alibaba-nacos-discovery

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>springcloud2020</artifactId>
  7.         <groupId>com.atguigu.springcloud</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>cloud-nacos-payment9001</artifactId>
  14.     <dependencies>
  15.         <!--SpringCloud ailibaba nacos -->
  16.         <dependency>
  17.             <groupId>com.alibaba.cloud</groupId>
  18.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  19.         </dependency>
  20.         <!-- SpringBoot整合Web组件 -->
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-web</artifactId>
  24.         </dependency>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-actuator</artifactId>
  28.         </dependency>
  29.         <!--日常通用jar包配置-->
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-devtools</artifactId>
  33.             <scope>runtime</scope>
  34.             <optional>true</optional>
  35.         </dependency>
  36.         <dependency>
  37.             <groupId>org.projectlombok</groupId>
  38.             <artifactId>lombok</artifactId>
  39.             <optional>true</optional>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter-test</artifactId>
  44.             <scope>test</scope>
  45.         </dependency>
  46.     </dependencies>
  47. </project>

yaml文件：
其中包括注册地址：本地nacos地址，以及暴露所有端点

  1. server:
  2.   port: 9001
  4. spring:
  5.   application:
  6.     name: nacos-payment-provider
  7.   cloud:
  8.     nacos:
  9.       discovery:
  10.         server-addr: localhost:8848 #配置Nacos地址
  12. management:
  13.   endpoints:
  14.     web:
  15.       exposure:
  16.         include: '*'

然后写一个控制类就可以了：

  1. package com.atguigu.springcloud.controller;
  3. import org.springframework.beans.factory.annotation.Value;
  4. import org.springframework.web.bind.annotation.GetMapping;
  5. import org.springframework.web.bind.annotation.PathVariable;
  6. import org.springframework.web.bind.annotation.RestController;
  8. /** * ${description} * * @author Fjj * @date 2020/4/7 15:40 */
  9. @RestController
  10. public class PaymentController { 
  12.     @Value("${server.port}")
  13.     private String serverPort;
  15.     @GetMapping(value = "/payment/nacos/{id}")
  16.     public String getPayment(@PathVariable("id") Integer id) { 
  17.         return "nacos registty serverPort " + serverPort + "\t id:" + id;
  18.     }
  19. }

接着启动这个工程：
访问 nacos的界面 http://localhost:8848/nacos/index.html
可以看到刚的nacos-payment-provider已经注册到nacos上面了，可以看到nacos比Eureka和zookeeper能够更清晰的看到服务的信息。
在这里插入图片描述
下面是nacos的整个流程图：
有兴趣可以结合源码看看。
在这里插入图片描述
下面是一些注册中心的比较：
一般来说，如果不需要存储服务级别的信息且服务实例是通过nacos-client注册，并能够保持心跳上报，那么就可以选择AP模式。当前主流的服务如Spring Cloud 和 Dubbo服务，都适用于AP模式，AP模式为了服务的可能性而减弱了一致性，因此AP模式下只支持注册临时实例。

如果需要在服务级别编辑或者存储配置信息，那么CP是必须的，K8S服务和DNS服务则适用于CP模式。CP模式下支持注册持久化实例，此时则是以Raft协议为集群运行模式，该模式下注册实例之前必须先注册服务，如果服务不存在，则会返回错误。

只有Nacos是支持CP和AP之间的切换的

  1. curl -X PUT `$NACOS_SERVER:8848/nacos/v1/ns/operator/switches?entry=serverMode&value=CP'

在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，184人围观）

还没有评论，来说两句吧...

相关阅读