Spring Cloud (二、服务注册与发现)

于 2024-08-16 16:31:11 发布
阅读量465 收藏 10
点赞数 5
分类专栏： # Spring Cloud 文章标签： spring cloud 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FuTian0715/article/details/140981524
版权

Spring Cloud

1、Eureka

什么是服务治理？
Spring Cloud 封装了 Netflix 公司开发的 Eureka 模块来实现服务治理，在传统的rpc远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，所以需要使用服务治理，管理服务于服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。

什么是服务注册与发现？
Eureka采用了CS的设计架构，Eureka Server 作为服务注册功能的服务器，它是服务注册中心。而系统中的其他微服务，使用 Eureka的客户端连接到 Eureka Server并维持心跳连接。这样系统的维护人员就可以通过 Eureka Server 来监控系统中各个微服务是否正常运行。
在服务注册与发现中，有一个注册中心。当服务器启动的时候，会把当前自己服务器的信息 比如 服务地址通讯地址等以别名方式注册到注册中心上。另一方（消费者|服务提供者），以该别名的方式去注册中心上获取到实际的服务通讯地址，然后再实现本地RPC调用RPC远程框架，RPC远程框架核心设计思想：注册中心，因为使用注册中心管理每个服务与服务之间的一个依赖关系(服务治理概念)。在任何rpc远程框架中，都会有一个注册中心(存放服务地址相关信息(接口地址))

下左图是Eureka系统架构，右图是Dubbo的架构，请对比

在这里插入图片描述

Eureka包含两个组件：Eureka Server和Eureka Client

Eureka Server提供服务注册服务
各个微服务节点通过配置启动后，会在EurekaServer中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观看到。

EurekaClient通过注册中心进行访问
是一个Java客户端，用于简化Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除（默认90秒）

1.1、单机Eureka构建步骤

  1. 建module
    在这里插入图片描述

  2. 改POM

    <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>
    <parent>
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>cloud2020</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>cloud-eureka-server7001</artifactId>

    <dependencies>
        <!--eureka-server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!--boot web actuator-->
        <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.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </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>
    </dependencies>

</project>

  3. 写YML

    server:
  port: 7001

eureka:
  instance:
    hostname: localhost #eureka服务端的实例名称
  client:
    #false表示不向注册中心注册自己。
    register-with-eureka: false
    #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址。
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

  4. 主启动

    package com.atguigu.springcloud;

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

@SpringBootApplication
@EnableEurekaServer
public class EurekaMain7001 {

    public static void main(String[] args) {

        SpringApplication.run(EurekaMain7001.class, args);

    }

}

  5. 测试
    在这里插入图片描述
    访问：http://localhost:7001/
    在这里插入图片描述

    我的MySQL安装到虚拟机的CentOS7上了，这里不知道为什么会将VMware Virtual Ethernet Adapter for VMnet1的网址放到实例信息（Instance Info）里，"EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE."红字这一段是Eureka自我保护机制，具体之后再介绍。

  6. 将其他项目注册进EurekaClient端，cloud-provider-payment8001 成为服务提供者provider，cloud-consumer-order80 成为服务消费者consumer。

    • 两个模块的POM分别要添加EurekaClient依赖：

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

    • 两个模块的YML要分别加上Eureka配置：

      eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url: 
      defaultZone: http://localhost:7001/eureka

      注意：模块的YML文件里一定要配置好Spring.application.name 对应的是Eureka的Application
      在这里插入图片描述

      两个模块分别是

      server:
	port: 8001

spring:
	application:
		name: cloud-payment-service

      server:
	port: 80

spring:
	application:
		name: cloud-order-service

    • 两个模块的启动类上分别要加入 @EnableEurekaClient 注释

      package com.atguigu.springcloud;

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

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

      package com.atguigu.springcloud;

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

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

  7. 再次测试
    先启动 cloud-eureka-server7001 再启动 cloud-provider-payment8001 和 cloud-consumer-order80
    在这里插入图片描述

1.2、集群Eureka构建步骤

  1. 集群原理说明
    在这里插入图片描述

    • 先启动Eureka注册中心。
    • 启动服务端服务。
    • 服务端服务将自身信息注册进Eureka。
    • 消费端服务在调用接口时，去注册中心获取实际的RPC远程调用地址。
    • 消费端获取调用地址后，底层实际是利用HttpClient技术实现远程调用。
    • 消费端获得服务地址后会缓存在本地jvm内存中，默认每间隔30秒更新一次服务调用地址。

    注册中心如果只有一个，故障会导致整个服务环境无法使用，解决办法：搭建Eureka注册集群，实现负载均衡和故障容错。

  2. EurekaServer 集群环境构建步骤

    • 新建模块cloud-eureka-server7002
      参考新建cloud-eureka-server7001
    • 修改POM文件
      与cloud-eureka-server7001一致
    • 修改映射
      C:\Windows\System32\drivers\etc路径下的hosts文件，添加两行
      127.0.0.1 eureka7001.com
      127.0.0.1 eureka7002.com
    • 写YML
      server:
  port: 7001


eureka:
  instance:
    hostname: eureka7001.com #eureka服务端的实例名称
  client:
    register-with-eureka: false     #false表示不向注册中心注册自己。
    fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      defaultZone: http://eureka7002.com:7002/eureka/

      server:
  port: 7002


eureka:
  instance:
    hostname: eureka7002.com #eureka服务端的实例名称
  client:
    register-with-eureka: false     #false表示不向注册中心注册自己。
    fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/
    • 主启动
      参考cloud-eureka-server7001
    • 测试

  3. 将支付服务8001微服务发布到上面2台Eureka集群配置中

    server:
  port: 8001
spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包 com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.92.88:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root
    druid:
      validation-query: select 1
      test-while-idle: true

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      #defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版

  4. 将订单服务80微服务发布到上面2台Eureka集群配置中

    server:
  port: 80

spring:
  application:
    name: cloud-order-service

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      #defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版

  5. 测试01
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  6. 支付服务提供者8001集群环境构建

    • 新建cloud-provider-payment8002
    • 修改POM，与8001一致
    • 修改YML，注意端口号为8002
    • 主启动，修改启动类
    • 业务类，复制8001的业务类
    • controller，复制8001的controller，修改一下两个模块的代码，获取yml文件里配置的端口，并在log中打出来。
      package com.atguigu.springcloud.controller;


import com.atguigu.springcloud.service.PaymentService;
import entities.CommResult;
import entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

@RestController
@Slf4j
public class PaymentController {

    @Autowired
    private PaymentService paymentService;

    @Value("${server.port}")
    private String serverPort;

    @PostMapping(value = "/payment/create")
    public CommResult create(@RequestBody Payment payment) {

        int result = paymentService.create(payment);
        log.info("*************插入结果：" + result);

        if (result > 0) {
            return new CommResult(200, "插入数据库成功, serverPort:" + serverPort, result);
        } else {
            return new CommResult(444, "插入数据库失败, serverPort:" + serverPort, null);
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommResult getPaymentById(@PathVariable("id") Long id) {

        Payment payment = paymentService.getPaymentById(id);
        log.info("*************查询结果：" + payment);

        if (payment != null) {
            return new CommResult(200, "查询成功, serverPort:" + serverPort, payment);
        } else {
            return new CommResult(444, "没有对应记录，查询失败，ID:" + id + ", serverPort:" + serverPort, null);
        }
    }
}
    • 测试
      通过 http://localhost/consumer/payment/get/31 进行查询，发现结果一直都是
      {
  "code": 200,
  "message": "查询成功, serverPort:8001",
  "data": {
    "id": 31,
    "serial": "尚硅谷001"
  }
}
      这是因为在 cloud-consumer-order80 项目的 OrderController.java 中 访问地址已经默认写死为 “http://localhost:8001”
      应该修改为 Eureka 中的Application的名字 CLOUD-PAYMENT-SERVICE
      修改完毕后再测试，还是报错：
      在这里插入图片描述
      这是因为没有开启负载均衡导致，使用@LoadBalanced注解赋予RestTemplate负载均衡的能力。

  7. 负载均衡
    修改消费端cloud-consumer-order80模块的 ApplicationContextConfig.java 启用负载均衡

    package com.atguigu.springcloud.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ApplicationContextConfig {

    @Bean
    @LoadBalanced //使用@LoadBalanced注解赋予RestTemplate负载均衡的能力
    public RestTemplate getRestTemplate() {

        return new RestTemplate();

    }

}

  8. 测试02
    在这里插入图片描述
    在这里插入图片描述

1.3、actuator微服务信息完善

当前问题：
在这里插入图片描述
需要Status中的名称进行修改，不暴露主机名称，另外左下角需要显式IP信息。

修改服务端 cloud-provider-payment8001 cloud-provider-payment8002 两个模块的YML

server:
  port: 8001
spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包 com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.92.88:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root
    druid:
      validation-query: select 1
      test-while-idle: true

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      #defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版
  instance:
    instance-id: payment8001
    prefer-ip-address: true     #访问路径可以显示IP地址

修改完毕，重启后的效果：
在这里插入图片描述

1.4、服务发现Discovery

对于注册进eureka里面的微服务，可以通过服务发现来获得该服务的信息

  1. 修改修改cloud-provider-payment8001和8002的Controller
    package com.atguigu.springcloud.controller;


import com.atguigu.springcloud.service.PaymentService;
import entities.CommResult;
import entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@Slf4j
public class PaymentController {

    @Autowired
    private PaymentService paymentService;

    @Value("${server.port}")
    private String serverPort;

    @Autowired
    private DiscoveryClient discoveryClient;

    @Value("${spring.application.name}")
    private String instance;

    @PostMapping(value = "/payment/create")
    public CommResult create(@RequestBody Payment payment) {

        int result = paymentService.create(payment);
        log.info("*************插入结果：" + result);

        if (result > 0) {
            return new CommResult(200, "插入数据库成功, serverPort:" + serverPort, result);
        } else {
            return new CommResult(444, "插入数据库失败, serverPort:" + serverPort, null);
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommResult getPaymentById(@PathVariable("id") Long id) {

        Payment payment = paymentService.getPaymentById(id);
        log.info("*************查询结果：" + payment);

        if (payment != null) {
            return new CommResult(200, "查询成功, serverPort:" + serverPort, payment);
        } else {
            return new CommResult(444, "没有对应记录，查询失败，ID:" + id + ", serverPort:" + serverPort, null);
        }
    }

    @GetMapping(value = "/payment/discovery")
    public Object discovery() {

        List<String> services = discoveryClient.getServices();

        for (String service : services) {
            log.info(service);
        }

        List<ServiceInstance> instances = discoveryClient.getInstances(instance);

        for (ServiceInstance serviceInstance : instances) {
            log.info(serviceInstance.getServiceId() + "\t" + serviceInstance.getHost() + "\t" + serviceInstance.getPort() + "\t" + serviceInstance.getUri());
        }

        return discoveryClient;
    }
}
  2. 修改主启动类
    package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient
public class PaymentMain8002 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8002.class, args);
    }
}
  3. 测试
    在这里插入图片描述
    在这里插入图片描述

1.5、Eureka自我保护

概述
保护模式主要用于一组客户端和Eureka Server之间存在网络分区场景下的保护。一旦进入保护模式，
Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的数据，也就是不会注销任何微服务。

如果在Eureka Server的首页看到以下这段提示，则说明Eureka进入了保护模式：
EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE
在这里插入图片描述
为什么会产生Eureka自我保护机制？
为了防止EurekaClient可以正常运行，但是 与 EurekaServer网络不通情况下，EurekaServer不会立刻将EurekaClient服务剔除

什么是自我保护模式？
默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒）。但是当网络分区故障发生(延时、卡顿、拥挤)时，微服务与EurekaServer之间无法正常通信，以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。Eureka通过“自我保护模式”来解决这个问题——当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故障），那么这个节点就会进入自我保护模式。

在这里插入图片描述

在自我保护模式中，Eureka Server会保护服务注册表中的信息，不再注销任何服务实例。
它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。一句话讲解：好死不如赖活着

综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务（健康的微服务和不健康的微服务都会保留）也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮、稳定。

怎么禁用自我保护机制

使用eureka.server.enable-self-preservation = false 可以禁用自我保护模式

修改EurekaServer模块的YML文件

eureka:
  server:
    #关闭自我保护机制，保证不可用服务被及时踢除
       enable-self-preservation: false

修改Eureka客户端模块的YML文件，修改心跳间隔时间和接受心跳等待超时时间

  instance:
  #Eureka客户端向服务端发送心跳的时间间隔，单位为秒(默认是30秒)
    lease-renewal-interval-in-seconds: 1
  #Eureka服务端在收到最后一次心跳后等待时间上限，单位为秒(默认是90秒)，超时将剔除服务
    lease-expiration-duration-in-seconds: 2

2、Zookeeper

zookeeper是一个分布式协调工具，可以实现注册中心功能

2.1、Zookeeper安装、配置、启动

Zookeeper下载地址：https://zookeeper.apache.org/releases.html#download
在这里插入图片描述
在这里插入图片描述
安装：

tar -zxcf zookeeper-3.4.9.tar.gz -C /opt/

在/opt/zookeeper-3.4.9/目录下新建zkData目录并修改配置文件：

cd /opt/zookeeper-3.4.9
mkdir zkData
cd /opt/zookeeper-3.4.9/conf
cp zoo_sample.cfg zoo_sample.cfg.bak
mv zoo_sample.cfg.bak zoo.cfg
vim zoo.cfg

dataDir=/opt/zookeeper-3.4.9/zkData

启动服务端之前需要关闭Linux防火墙

启动zookeeper的服务端：

cd /opt/zookeeper-3.4.9/bin
./zkServer.sh start

在这里插入图片描述

启动zookeeper的客户端：

cd /opt/zookeeper-3.4.9/bin
./zkCli.sh

在这里插入图片描述
退出客户端：

[zk: localhost:2181(CONNECTED) 0] quit

在这里插入图片描述
查看zookeeper状态：

cd /opt/zookeeper-3.4.9/bin
./zkServer.sh status

在这里插入图片描述
配置文件解读：
在这里插入图片描述

2.2、新建 cloud-provider-payment8004 模块，将此模块注册进zookeeper

  1. 新建cloud-provider-payment8004

  2. 改POM文件

    <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>
    <parent>
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>cloud2020</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>cloud-provider-payment8004</artifactId>

    <dependencies>
        <!-- SpringBoot整合zookeeper客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
            <!--先排除自带的zookeeper3.5.3-->
            <exclusions>
                <exclusion>
                    <groupId>org.apache.zookeeper</groupId>
                    <artifactId>zookeeper</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--添加zookeeper3.4.9版本-->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.9</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </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.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </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>
    </dependencies>

</project>

  3. 写YML

    server:
  port: 8004
spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包 com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.92.88:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root
    druid:
      validation-query: select 1
      test-while-idle: true
  cloud:
    zookeeper:
      connect-string: 192.168.92.88:2181 #虚拟机安装的CentOS7对应网卡配置的地址

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

  4. 启动类

    package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

  5. Controller

    package com.atguigu.springcloud.controller;


import com.atguigu.springcloud.service.PaymentService;
import entities.CommResult;
import entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.UUID;

@RestController
@Slf4j
public class PaymentController {

    @Autowired
    private PaymentService paymentService;

    @Value("${server.port}")
    private String serverPort;

    @Autowired
    private DiscoveryClient discoveryClient;

    @Value("${spring.application.name}")
    private String instance;

    @PostMapping(value = "/payment/create")
    public CommResult create(@RequestBody Payment payment) {

        int result = paymentService.create(payment);
        log.info("*************插入结果：" + result);

        if (result > 0) {
            return new CommResult(200, "插入数据库成功, serverPort:" + serverPort, result);
        } else {
            return new CommResult(444, "插入数据库失败, serverPort:" + serverPort, null);
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommResult getPaymentById(@PathVariable("id") Long id) {

        Payment payment = paymentService.getPaymentById(id);
        log.info("*************查询结果：" + payment);

        if (payment != null) {
            return new CommResult(200, "查询成功, serverPort:" + serverPort, payment);
        } else {
            return new CommResult(444, "没有对应记录，查询失败，ID:" + id + ", serverPort:" + serverPort, null);
        }
    }

    @GetMapping(value = "/payment/discovery")
    public Object discovery() {

        List<String> services = discoveryClient.getServices();

        for (String service : services) {
            log.info(service);
        }

        List<ServiceInstance> instances = discoveryClient.getInstances(instance);

        for (ServiceInstance serviceInstance : instances) {
            log.info(serviceInstance.getServiceId() + "\t" + serviceInstance.getHost() + "\t" + serviceInstance.getPort() + "\t" + serviceInstance.getUri());
        }

        return discoveryClient;
    }
    
    @RequestMapping(value = "/payment/zk")
    public String paymentzk() {

        return "springcloud with zookeeper:" + serverPort + "\t" + UUID.randomUUID().toString();
    }
}

  6. 启动 cloud-provider-payment8004 报错 解决问题

    zookeeper版本冲突问题，排除Springframework自带的版本，添加自己的版本

    <!-- SpringBoot整合zookeeper客户端 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
    <!--先排除自带的zookeeper3.5.3-->
    <exclusions>
        <exclusion>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!--添加zookeeper3.4.9版本-->
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.9</version>
</dependency>

    在这里插入图片描述

    slf4j日志模块报绑定
    排除zookeeper自带的slf4j-log4j12

    <exclusions>
	<exclusion>
		<groupId>org.slf4j</groupId>
		<artifactId>slf4j-log4j12</artifactId>
	</exclusion>
</exclusions>

    在这里插入图片描述

    成功启动：
    在这里插入图片描述
    在这里插入图片描述

    在关闭了 cloud-provider-payment8004 模块一段时间后，在 zookeeper 客户端无法获取到 services 的信息了，这说明 zookeeper 没有使用类似 Eureka 的自我保护机制

2.3、新建 cloud-consumer-zk-order80 模块，将此模块注册进 zookeeper

  1. 新建模块
    cloud-consumer-zk-order80
  2. 改POM
    <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>
    <parent>
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>cloud2020</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>cloud-consumer-zk-order80</artifactId>

    <dependencies>
        <!-- SpringBoot整合zookeeper客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
            <!--先排除自带的zookeeper3.5.3-->
            <exclusions>
                <exclusion>
                    <groupId>org.apache.zookeeper</groupId>
                    <artifactId>zookeeper</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--添加zookeeper3.4.9版本-->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.9</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </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.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </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>
    </dependencies>

</project>
  3. 写YML
    server:
  port: 80
spring:
  application:
    name: cloud-consumer-zk-order80
  cloud:
    zookeeper:
      connect-string: 192.168.92.88:2181
  4. 主启动
    package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class OrderZkMain80 {

    public static void main(String[] args) {

        SpringApplication.run(OrderZkMain80.class, args);

    }

}
  5. 业务类
    com/atguigu/springcloud/config/ApplicationContextConfig.java
    package com.atguigu.springcloud.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ApplicationContextConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {

        return new RestTemplate();

    }

}
    com/atguigu/springcloud/controller/OrderController.java
    package com.atguigu.springcloud.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@Slf4j
public class OrderController {

    public static String PAYENT_URL = "http://cloud-payment-service";

    @Autowired
    private RestTemplate restTemplate;

    @RequestMapping(value = "/consumer/payment/zk")
    public Object getpaymentzk() {
        return restTemplate.getForObject(PAYENT_URL + "/payment/zk", String.class);
    }
}
  6. 验证测试
    在这里插入图片描述
    在这里插入图片描述

3、Consul

官网：https://developer.hashicorp.com/consul

3.1、Consul简介

  1. Consul 是什么
    Consul 是一套开源的分布式服务发现和配置管理系统，由 HashiCorp 公司用 Go 语言开发。
    提供了微服务系统中的服务治理、配置中心、控制总线等功能。这些功能中的每一个都可以根据需要单独使用，也可以一起使用以构建全方位的服务网格，总之Consul提供了一种完整的服务网格解决方案。
    它具有很多优点。包括： 基于 raft 协议，比较简洁； 支持健康检查, 同时支持 HTTP 和 DNS 协议 支持跨数据中心的 WAN 集群 提供图形界面 跨平台，支持 Linux、Mac、Windows
  2. Consul 能干什么
    服务发现，提供HTTP和DNS两种发现方式。
    健康监测，支持多种方式，HTTP、TCP、Docker、Shell脚本定制化监控。
    KV存储，Key、Value的存储方式
    多数据中心，Consul支持多数据中心
    可视化Web界面。
  3. 下载地址
    https://www.consul.io/downloads.html
  4. 如何使用
    https://www.springcloud.cc/spring-cloud-consul.html

3.2、Consulan安装及运行

安装说明地址：https://learn.hashicorp.com/consul/getting-started/install.html

下载 consul_1.6.1_windows_386 解压后执行，在 Consul.exe 目录执行cmd，然后执行命令consul --version
在这里插入图片描述
启动consul，命令：consul agent -dev
通过以下地址可以访问Consul的首页：http://localhost:8500
在这里插入图片描述

3.3、新建 服务提供者模块 cloud-provider-payment8006 和 服务消费者模块 cloud-consumer-consul-order80 并注册进Consul

  1. 建模块
    在这里插入图片描述

  2. 改POM
    cloud-provider-payment8006-pom.xml

    <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>
    <parent>
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>cloud2020</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>cloud-provider-payment8006</artifactId>

    <dependencies>
        <!--SpringCloud consul-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-discovery</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.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </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>
    </dependencies>
</project>

    cloud-consumer-consul-order80-pom.xml

    <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>
    <parent>
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>cloud2020</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>cloud-consumer-consul-order80</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-discovery</artifactId>
        </dependency>
        <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </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.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </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>
    </dependencies>
</project>

  3. 写YML
    cloud-provider-payment8006-application.yml

    server:
  port: 8006

spring:
  application:
    name: cloud-payment-service
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: ${spring.application.name}

    cloud-consumer-consul-order80-application.yml

    server:
  port: 80

spring:
  application:
    name: cloud-consumer-consul-order80
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: ${spring.application.name}

  4. 主启动
    PaymentMain8006.java

    package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class PaymentMain8006 {

    public static void main(String[] args) {

        SpringApplication.run(PaymentMain8006.class,args);

    }

}

    OrderConsulMain80.java

    package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class OrderConsulMain80 {

    public static void main(String[] args) {

        SpringApplication.run(OrderConsulMain80.class, args);

    }

}

  5. 业务类
    PaymentController.java

    package com.atguigu.springcloud.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

@RestController
public class PaymentController {

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/payment/consul")
    public String paymentInfo()
    {
        return "springcloud with consul: "+serverPort+"\t\t"+ UUID.randomUUID().toString();
    }

}

    ApplicationContextConfig.java

    package com.atguigu.springcloud.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ApplicationContextConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {

        return new RestTemplate();

    }

}

    OrderConsulController.java

    package com.atguigu.springcloud.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class OrderConsulController
{
    public static final String INVOKE_URL = "http://cloud-payment-service";; //consul-provider-payment

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping(value = "/consumer/payment/consul")
    public String paymentInfo()
    {
        String result = restTemplate.getForObject(INVOKE_URL+"/payment/consul", String.class);
        System.out.println("消费者调用支付服务(consule)--->result:" + result);
        return result;
    }
}

  6. 测试
    在这里插入图片描述
    在这里插入图片描述

4、Eureka、zookeeper、Consul的异同点

CAP理论关注粒度是数据，而不是整体系统设计的策略
C:Consistency（强一致性）
A:Availability（可用性）
P:Partition tolerance（分区容错性）

在这里插入图片描述

在这里插入图片描述

AP架构
当网络分区出现后，为了保证可用性，系统B可以返回旧值，保证系统的可用性。
结论：违背了一致性C的要求，只满足可用性和分区容错，即AP
在这里插入图片描述
CP架构
当网络分区出现后，为了保证一致性，就必须拒接请求，否则无法保证一致性
结论：违背了可用性A的要求，只满足一致性和分区容错，即CP
在这里插入图片描述

UntifA
关注
专栏目录
Spring cloud实现服务注册及发现
08-13
NULL 博文链接：https://hoochiang.iteye.com/blog/2287276
spring cloud nacos服务注册与发现例子
01-21
Spring Cloud Nacos是阿里巴巴提供的一款云原生应用的配置管理和服务发现工具，它结合了Spring Cloud Eureka和Zookeeper的功能，使得在微服务架构中进行服务注册与发现变得更加简单。本示例将深入探讨如何使用Nacos...
「SpringCloud」01 Eureka服务注册与发现
How many ten years in the life time?
08-05 155
SpringCloud封装了Netflix公司开发的Eureka模块来实现服务治理。在传统的RPC远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务与服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。Eureka采用了CS的设计架构，EurekaServer作为服务注册功能的服务器，它是服务注册中心，而系统中的其他微服务，使用Eureka的客户端连接到EurekaServer并维持心跳连接。.....................
深入理解Spring Cloud中的服务发现与注册
最新发布
聚娃科技开发者博客
07-08 807
传统的单体应用程序可能使用硬编码的方式调用其他服务，但在微服务环境中，服务的地址和实例可能动态变化，因此需要一种机制来动态地管理和发现服务。在上述示例中，我们展示了一个简单的RestController，通过Spring Cloud的DiscoveryClient来获取所有注册的服务列表和特定服务的所有实例列表。上面的示例展示了如何使用RestTemplate结合@LoadBalanced注解来实现基于Ribbon的负载均衡客户端，调用注册在Eureka Server上的服务。
SpringCloud服务的注册与发现(一)
热门推荐
程序工厂
08-23 1万+
一、什么是服务注册与发现 Spring Cloud Eureka 模块提供的功能是被动式的服务发现。 服务注册：每个用户去聊天室服务器上注册。 服务发现：这样他的好友们就能看到你,你同时也将获取好友的上线列表. 微服务中，服务就相当于聊天室的用户，而服务注册中心就像聊天室服务器一样。 目前服务发现的解决方案有Eureka，Consul，Zookeeper等等。SpringCloud默认使...
SpringCloud 服务的注册与发现
快乐的小三菊的博客
03-07 1204
服务注册和发现的组件，此篇文章会介绍 Eureka、Zookeeper 和 Consul 分别作为注册中心的使用场景。
微服务之SpringCloud服务注册与发现
Young_深情不及里子的博客
12-28 3597
在分布式微服务架构中，一个应用可能由一组职责单一化的服务组成。这时候就需要一个注册服务的机制，注册某个服务或者某个节点是可用的，还需要一个发现服务的机制来找到哪些服务或者哪些节点还在提供服务。在实际应用中，通常还都需要一个配置文件告诉我们一些配置信息，比如数据连接的地址，redis 的地址等等。但很多时候，我们想要动态地在不修改代码的情况下得到这些信息，并且能很好地管理它们。 有了这些需求，于是发展出了一系列的开源框架，比如 ZooKeeper, Consul 等等。
SpringCloud之服务注册与发现Spring Cloud Eureka实例代码
08-27
主要介绍了SpringCloud之服务注册与发现Spring Cloud Eureka实例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详解springcloud之服务注册与发现
08-27
本文将深入讲解SpringCloud的服务注册与发现机制，以及如何搭建服务中心、注册服务和发现服务。 首先，我们要理解服务注册与发现的重要性。在分布式系统中，服务间的通信需要知道对方的存在和位置，服务注册与发现...
SpringCloud Eureka实现服务注册与发现
08-26
"SpringCloud Eureka实现服务注册与发现" Eureka是基于REST（具像状态传输）的服务，主要用于AWS云中定位服务，以实现中间层服务器的负载平衡和故障转移。Eureka Server是服务注册中心，负责管理服务实例的注册和...
详解使用Spring Cloud Consul实现服务的注册和发现
08-27
Spring Cloud Consul 实现服务注册和发现 在微服务架构中，服务注册和发现是非常重要的组件，能够帮助我们更好地管理和维护服务。Spring Cloud Consul 正是这样一个优秀的服务注册和发现工具。本文将详细介绍如何...
SpringCloud服务注册与发现
superviser3000的博客
04-22 1536
1、介绍 对于微服务的治理而言，其核心就是服务的注册和发现。在SpringCloud 中提供了多种服务注册与发现组件：Eureka,Consul,Zookeeper。官方推荐使用Eureka。 说明：Eureka是Netflix开源的一款提供服务注册和发现的产品，它提供了完整的Service Registry和Service Discovery实现。也是springcloud体系中最重要最核心的组件之一。管理的服务包含了Spring Cloud的其他服务组件如：熔断、负载、降级等。 2、理解 以往服务间资
SpringCloud②
weixin_45988242的博客
02-17 1279
Eureka集群 负载均衡 自我保护 actuator微服务信息完善 Zookeeper安装 注册
第一篇： 服务的注册与发现Eureka
cdy的博客
08-06 318
一、创建服务注册中心 在这里，我还是采用Eureka作为服务注册与发现的组件，至于Consul 之后会出文章详细介绍。 2.1 首先创建一个maven主工程。 首先创建一个主Maven工程，在其pom文件引入依赖，spring Boot版本为2.0.3.RELEASE，Spring Cloud版本为Finchley.RELEASE。这个pom文件作为父pom文件，起到依赖版本控制的作用，其他...
springcloud服务的注册与发现
Klose1123的博客
04-25 153
一、创建服务注册中心 1.首先创建一个maven主工程，然后创建两个module工程，一个作为Eureka Server，一个作为Eureka Client。 右键工程->创建model-> 选择spring initialir 如下图： ...
springcloud 服务注册与发现
zcb1592781470的博客
04-19 513
一.spring cloud简介 spring cloud 为开发人员提供了快速构建分布式系统的一些工具，包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等。 二.创建服务注册中心 需要用的组件是Spring Cloud Netflix的Eureka ,eureka是一个服务注册和发现模块。 创建model工程(eureka server) ...
SpringCloud系列之服务注册与发现
qq_36895020的博客
05-11 996
1.什么是服务注册与发现 服务注册与发现组件、服务提供者、服务消费者这三者之间依赖关系 每个服务在启动的时候会将自己的一些信息(如ip、port、server-name等)注册到注册中心，服务发现这个组件会会存储这些信息。 客户端调用是从注册中心根据server-name获取服务的信息进行通信操作。当然不是每次都是客户端都是从注册中心查询服务信息,客户端它也会缓存这个服务信息到内存中,这...
springcloud Eureka服务注册和发现
H的博客
09-02 7675
1，Eureka基本介绍： Spring Cloud 封装了 Netflix 公司开发的 Eureka 模块来实现服务注册和发现(请对比Zookeeper)。 Eureka 采用了 C-S 的设计架构。Eureka Server 作为服务注册功能的服务器，它是服务注册中心。 而系统中的其他微服务，使用 Eureka 的客户端连接到 Eureka Server并维持心跳连接。这样系统的维护人员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值