SpringCloud-1.服务注册与发现（Eureka/Zookeeper/Consul）

最新推荐文章于 2022-12-28 12:41:51 发布
最新推荐文章于 2022-12-28 12:41:51 发布
阅读量579 收藏
点赞数
分类专栏： SpringCloud 文章标签： spring cloud eureka java-consul
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62427168/article/details/126441434
版权

目录

一、服务治理、服务注册与发现的概念

二、Eureka 的服务注册与发现

2.1 单机构建

2.1.1 新建maven子工程-cloud-eureka-server7001

2.1.2 Client端-修改cloud-provider-payment8001、cloud-consumer-order80

2.2 集群构建

2.2.1 集群原理

2.2.2 EurekaServer集群环境构建

2.2.3 服务提供者-cloud-provider-payment集群环境搭建

2.3 可选项（主机名称:服务名称修改、访问信息有IP信息提示）

2.4 服务发现Discovery

2.5 Eureka 的自我保护机制

三、Zookeeper服务注册与发现

3.1 Zookeeper服务器的部署

3.2 创建服务提供者

3.2 创建消费者

四、Consul服务注册与发现

4.1 介绍与配置

4.2 创建服务提供者

4.3 创建服务消费者

五、三个注册中心对比

一、服务治理、服务注册与发现的概念

        1.服务治理

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

        2.服务注册与发现
        在服务注册与发现中，有一个注册中心。当服务器启动的时候，会把当前自己服务器的信息 (如服务地址\通讯地址等)以别名方式注册到注册中心上。另一方（消费者|服务提供者）以该别名的方式去注册中心上获取到实际的服务通讯地址，然后再实现本地RPC调用RPC远程调用

        框架核心设计在于注册中心，因为要使用注册中心管理每个服务与服务之间的依赖关系(服务治理概念)。在任何rpc远程框架中，都会有一个注册中心(存放服务地址相关信息(接口地址))

        3.Eureka举例

        它采用了CS的设计架构，Eureka Server 作为服务注册功能的服务器，是服务注册中心。而系统中的其他微服务，使用 Eureka的客户端（Eureka Client）连接到 Eureka Server并维持心跳连接。这样系统的维护人员就可以通过 Eureka Server 来监控系统中各个微服务是否正常运行。

        Eureka包含两个组件：Eureka Server和Eureka Client
        1.Eureka Server提供服务注册服务
        各个微服务节点通过配置启动后，会在EurekaServer中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观看到。
        2.EurekaClient通过注册中心进行访问
        是一个Java客户端，用于简化Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除（默认90秒）

        这样的心跳检测机制就好比房东与租客的关系。

        租客需要按时交租金。如果哪段时间太忙忘记交了，房东没有那么绝情：“可以理解你，那就给你往后拖几天吧！千万记得交房租！” 如果租客这几天及时补交了，那没事；如果还是没有交，房东就说：“已经给过你机会了，你不把握我也没办法，房子我收回了！”最终房东把租客赶出去了......

        下左图是Eureka系统架构，右图是Dubbo的架构，他们都是类似的：

二、Eureka 的服务注册与发现

2.1 单机构建

2.1.1 新建maven子工程-cloud-eureka-server7001

        1.改POM

    <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>

        2. 写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/

        3. 主启动类

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

         4.测试

        输入：http://localhost:7001/

        结果：

2.1.2 Client端-修改cloud-provider-payment8001、cloud-consumer-order80

        1.改POM

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

        2.改YML

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

        3.主启动类

                添加注解：

@EnableEurekaClient

        4.测试

                注：先启动server，再启动client

                输入：http://localhost:7001/

                结果：

         可以看到，application的名字就是在client的yml文件中定义的spring.application.name属性

2.2 集群构建

2.2.1 集群原理

        微服务RPC远程服务调用最核心的是高可用性。试想假如只有一个注册中心，如果它出故障了那就呵呵(￣▽￣)"了，会导致整个微服务环境不可用，所以要搭建Eureka注册中心集群 ，实现负载均衡+故障容错。

2.2.2 EurekaServer集群环境构建

        1.新建cloud-eureka-server7002 子工程，拷贝cloud-eureka-server7001的内容。

        2.修改Windows的映射配置：

C:\Windows\System32\drivers\etc\hosts

                注意要把文件修改的权限开启！添加这两个映射配置：

127.0.0.1  eureka7001.com
127.0.0.1  eureka7002.com

        3.分别修改两个工程的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/

        4.修改两个server-client 的yml配置文件

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  # 集群版
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.测试

                先启动EurekaServer：7001/7002

                再启动服务提供者、消费者

                输入：

                 可正常访问！

2.2.3 服务提供者-cloud-provider-payment集群环境搭建

        1.新建maven子工程

                新建子工程cloud-provider-payment8002，拷贝cloud-provider-payment8001的内容

        2.改YML

                只修改下面的内容，其他不变

server:
  port: 8002

        3.修改两个工程的controller，标识不同的端口

@RestController
@Slf4j
public class PaymentController
{
    @Value("${server.port}")
    private String serverPort;//从yml中取端口

    @Resource
    private PaymentService paymentService;

    @PostMapping(value = "/payment/create")
    public CommonResult create(@RequestBody Payment payment)
    {
        int result = paymentService.create(payment);
        log.info("*****插入操作返回结果:" + result);

        if(result > 0)
        {
            return new CommonResult(200,"插入成功,返回结果"+result+"\t 服务端口："+serverPort,payment);
        }else{
            return new CommonResult(444,"插入失败",null);
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
    {
        Payment payment = paymentService.getPaymentById(id);
        log.info("*****查询结果:{}",payment);
        if (payment != null) {
            return new CommonResult(200,"查询成功"+"\t 服务端口："+serverPort,payment);
        }else{
            return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
        }
    }
}

        4.修改消费者的Controller

                服务访问地址不能写成死的，因为有两个地址...我们交给Eureka处理

//public static final String PAYMENT_URL="http://localhost:8001";
 public static final String PAYMENT_URL="http://CLOUD-PAYMENT-SERVICE";

        5.使用@LoadBalanced注解赋予RestTemplate负载均衡的能力

                如果不用这个注解，每次访问的都是PORT为8001的地址。

                在消费者的配置类中修改

@Configuration
public class ApplicationContextBean
{
    @Bean
    @LoadBalanced //使用@LoadBalanced注解赋予RestTemplate负载均衡的能力
    public RestTemplate getRestTemplate()
    {
        return new RestTemplate();
    }
}

        6.测试

                还是先启动server，再启动client。

                输入：http://localhost/consumer/payment/get/31

                返回正确的结果，并且交替访问8001、8002端口的地址。

2.3 可选项（主机名称:服务名称修改、访问信息有IP信息提示）

        1.修改服务名称

        只需在yml中添加下面属性即可：

eureka:
  instance:
    instance-id: payment8001

         修改之后：

         2.访问信息显示IP地址

        其实就是鼠标移到对应的STATUS上时，浏览器左下角显示的是实际的IP地址，而非localhostxxx...

        还是修改yml文件的属性：

eureka:
  instance:
    instance-id: payment8001
    prefer-ip-address: true     #访问路径可以显示IP地址

        修改之后：

2.4 服务发现Discovery

        什么是服务发现？

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

       1.在Payment的Controller中引入DiscoveryClient 组件，构建一个映射方法打印它的信息

@RestController
@Slf4j
public class PaymentController
{
    @Value("${server.port}")
    private String serverPort;

    @Resource
    private PaymentService paymentService;

    @Resource
    private DiscoveryClient discoveryClient;

... ...

    @GetMapping(value = "/payment/discovery")
    public Object discovery()
    {
        List<String> services = discoveryClient.getServices();
        for(String e:services) log.info(e);
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        for(ServiceInstance instance:instances) log.info(instance.getServiceId()+" , "+instance.getHost()+" , "+instance.getPort()+" , "+instance.getUri());
        return this.discoveryClient;
    }
}

        2.在主启动类上添加注解

@EnableDiscoveryClient //服务发现

        3.测试

        浏览器收到的响应：

{
    "services": [
        "cloud-payment-service"
    ],
    "order": 0
}

        控制台：

cloud-payment-service
CLOUD-PAYMENT-SERVICE , 192.168.80.1 , 8001 , http://192.168.80.1:8001

2.5 Eureka 的自我保护机制

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

        1.为什么会产生Eureka自我保护机制？
        为了防止EurekaClient还可以正常运行，但与 EurekaServer网络不通情况下，EurekaServer不会立刻将EurekaClient服务剔除。

        2.什么是自我保护模式？
        默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒）。但是当网络分区故障发生(延时、卡顿、拥挤)时，微服务与EurekaServer之间无法正常通信，以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。Eureka通过“自我保护模式”来解决这个问题——当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故障），那么这个节点就会进入自我保护模式。
        综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务（健康的微服务和不健康的微服务都会保留）也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮、稳定。

        3.默认该模式是开启的，如何禁用？

                首先在server端设置yml

eureka：
    server：
        enable-self-preservation = false

                然后再client端设置yml

#心跳检测与续约时间
#开发时设置小些，保证服务关闭后注册中心能即使剔除服务
  instance:
  #Eureka客户端向服务端发送心跳的时间间隔，单位为秒(默认是30秒)
    lease-renewal-interval-in-seconds: 1
  #Eureka服务端在收到最后一次心跳后等待时间上限，单位为秒(默认是90秒)，超时将剔除服务
    lease-expiration-duration-in-seconds: 2

三、Zookeeper服务注册与发现

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

        zookeeper中的服务节点都是临时节点，非持久节点！

3.1 Zookeeper服务器的部署

        zookeeper服务器需要部署在Linux服务器上。

        部署前提：操作系统-CentOS7，已安装Java环境（JDK8），已关闭linux防火墙

        1.下载安装包（64位linux版本压缩包）

        2.拷贝 apache-zookeeper-3.5.8-bin.tar.gz 安装包到Linux系统对应目录下，然后解压、重命名

1.# 复制压缩包到 /usr/ 目录下
cp apache-zookeeper-3.5.8-bin.tar.gz /usr/

2.# 跳转到 /usr/ 目录下
cd /usr/

3.# 解压压缩包
tar -zxvf apache-zookeeper-3.5.8-bin.tar.gz

4.# 对解压后的文件夹进行重命名
mv apache-zookeeper-3.5.8-bin zookeeper-3.5.8

        3.修改配置文件

1.#将/usr/zookeeper-3.5.7/conf 路径下的 zoo_sample.cfg 文件重命名为 zoo.cfg
mv zoo_sample.cfg zoo.cfg

2.#打开zoo.cfg文件，修改 dataDir 配置值,将dataDir=/tmp/zookeeper修改为 dataDir=/usr/zookeeper-3.5.7/zkData，然后保存退出
vi zoo.cfg
:wq!

3.#在 /usr/zookeeper-3.5.7/ 这个目录下使用 mkdir zkData 命令创建 zkData 文件夹
mkdir zkData

        4.操作Zookeeper

#要先跳转到zookeeper-3.5.8/bin目录下

#启动zookeeper：
./zkServer.sh start

#查看zookeeper状态：
./zkServer.sh status

#启动zookeeper客户端：
./zkCli.sh

#退出zookeeper客户端：
quit

#停止zookeeper：
./zkServer.sh stop

#登录客户端后，可以查看当前注册了哪些服务
ls /
ls /services

         默认端口号：2181

3.2 创建服务提供者

        1.创建maven子工程，名字：cloud-provider-payment8004

        2.POM 

    <dependencies>
        <!-- SpringBoot整合Web组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!-- SpringBoot整合zookeeper客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zookeeper-discovery</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>

        3.YML

#8004表示注册到zookeeper服务器的支付服务提供者端口号
server:
  port: 8004
#服务别名----注册zookeeper到注册中心名称
spring:
  application:
    name: cloud-provider-payment
  cloud:
    zookeeper:
      connect-string: 192.168.80.128:2181

        4.主启动类

@SpringBootApplication
@EnableDiscoveryClient //该注解用于向使用consul或者zookeeper作为注册中心时注册服务
public class PaymentMain8004
{
    public static void main(String[] args)
    {
        SpringApplication.run(PaymentMain8004.class,args);
    }

}

        5.Controller

@RestController
public class PaymentController
{
    @Value("${server.port}")
    private String serverPort;

    @RequestMapping(value = "/payment/zk")
    public String paymentzk()
    {
        return "springcloud with zookeeper: "+serverPort+"\t"+ UUID.randomUUID().toString();
    }
}

        6.测试

        注：一定要注意idea引入的zookeeper依赖版本和linux中安装的zookeeper版本是否一致！ 

         zookeeper相关依赖修改如下：

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

         在linux中zookeeper客户端查看已注册的服务

[zk: localhost:2181(CONNECTED) 5] ls /
[services, zookeeper]

[zk: localhost:2181(CONNECTED) 6] ls /services
[cloud-provider-payment]

3.2 创建消费者

        1.新建maven子工程，名字：cloud-consumerzk-order80

        2.POM

    <dependencies>
        <!-- SpringBoot整合Web组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- SpringBoot整合zookeeper客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
            <!--先排除自带的zookeeper-->
            <exclusions>
                <exclusion>
                    <groupId>org.apache.zookeeper</groupId>
                    <artifactId>zookeeper</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--添加zookeeper3.5.8版本-->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.5.8</version>
        </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>

        3.YML

server:
  port: 80

spring:
  application:
    name: cloud-consumer-order
  cloud:
  #注册到zookeeper地址
    zookeeper:
      connect-string: 192.168.80.128:2181

        4.主启动类

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

        5.业务类

                配置类：

@Configuration
public class ApplicationContextBean
{
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate()
    {
        return new RestTemplate();
    }
}

                Controller：

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

    @Autowired
    private RestTemplate restTemplate;

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

}

        6.测试

        在linux中zookeeper客户端查看已注册的服务

[zk: localhost:2181(CONNECTED) 0] ls /services
[cloud-consumer-order, cloud-provider-payment]

        访问  http://localhost/consumer/payment/zk

springcloud with zookeeper: 8004	77a657cf-6262-4690-9c11-fd2484a9f57f

四、Consul服务注册与发现

4.1 介绍与配置

        Consul 是一套开源的分布式服务发现和配置管理系统，由 HashiCorp 公司用 Go 语言开发。
 
        提供了微服务系统中的服务治理、配置中心、控制总线等功能。这些功能中的每一个都可以根据需要单独使用，也可以一起使用以构建全方位的服务网格，总之Consul提供了一种完整的服务网格解决方案。

        特点：

                1.服务发现-提供HTTP和DNS两种发现方式。

                2.健康检测-支持多种方式，HTTP、TCP、Docker、Shell脚本定制化监控

                3.K-V存储

                4.多数据中心

                5.可视化Web界面

        使用非常简单，是单个exe文件，在其目录内使用控制台启动

#控制台中
consul agent -dev

#终端中
./consul agent -dev

        端口：8500

4.2 创建服务提供者

        1.创建maven子工程-cloud-providerconsul-payment8006

        2.POM

    <dependencies>
        <!--SpringCloud consul-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-discovery</artifactId>
        </dependency>
        <!-- SpringBoot整合Web组件 -->
        <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>
        <!--日常通用jar包配置-->
        <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>

        3.YML

###consul服务端口号
server:
  port: 8006

spring:
  application:
    name: consul-provider-payment
####consul注册中心地址
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        #hostname: 127.0.0.1
        service-name: ${spring.application.name}

        4.主启动类

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

        5.Controller

@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();
    }
}

        6.测试

4.3 创建服务消费者

        1.创建maven子工程-cloud-consumerconsul-order80

        2.POM

    <dependencies>
        <!--SpringCloud consul-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-discovery</artifactId>
        </dependency>
        <!-- SpringBoot整合Web组件 -->
        <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>
        <!--日常通用jar包配置-->
        <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>

        3.YML

###consul服务端口号
server:
  port: 80

spring:
  application:
    name: cloud-consumer-order
####consul注册中心地址
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        #hostname: 127.0.0.1
        service-name: ${spring.application.name}

        4.主启动类

@SpringBootApplication
@EnableDiscoveryClient //该注解用于向使用consul或者zookeeper作为注册中心时注册服务
public class OrderConsulMain80
{
    public static void main(String[] args)
    {
        SpringApplication.run(OrderConsulMain80.class,args);
    }
}

        5.Bean、Controller

@Configuration
public class ApplicationContextBean
{
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate()
    {
        return new RestTemplate();
    }
}
@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();
    }
}

        6.测试

        访问 http://localhost/consumer/payment/consul

springcloud with consul: 8006	   7d74aeb6-44ac-4ceb-876f-35e720a2d9c9

五、三个注册中心对比

         什么是CAP？

                C:Consistency（强一致性）

                A:Availability（可用性）

                P:Partition tolerance（分区容错性）

        CAP理论关注粒度是数据，而不是整体系统设计的策略。

        CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求，因此，根据 CAP 原理将 NoSQL 数据库分成了满足 CA 原则、满足 CP 原则和满足 AP 原则三大类：
        CA - 单点集群，满足一致性，可用性的系统，通常在可扩展性上不太强大。
        CP - 满足一致性，分区容忍性的系统，通常性能不是特别高。 

                （当网络分区出现后，为了保证一致性，就必须拒接请求，否则无法保证一致性）


        AP - 满足可用性，分区容忍性的系统，通常可能对一致性要求低一些。

                （当网络分区出现后，为了保证可用性，系统B可以返回旧值，保证系统的可用性。）

 

UndefinedException
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCloud（2）--服务注册与发现（Eureka、Zookeeper、Consul）
MOKE_SPACE
07-10 4048
文章目录服务注册中心Eureka单机版eureka创建Module其他服务注册到eureka集群版eureka集群原理![在这里插入图片描述](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9ody5tb2tlc3BhY2UuY24vaW1hZ2VzLzIwMjAvMDcvMDcvOGM0YzAxMGIxMTM0ZTY0MzVkMWRhNjUxNjhiYzI3YjYucG5n?x-oss-process=image/format,png)构建新erueka项目其他服务注册到
Eureka 服务注册中心入门到掌握
qq_43107323的博客
02-25 462
一、 什么是服务注册中心 服务注册中心是服务实现服务化管理的核心组件,类似于目录服务的作用,主要用来 存储服务信息，譬如提供者 url 串、路由信息等。服务注册中心是 SOA 架构中最基础的设 施之一。 1 服务注册中心的作用 1，服务的注册 2，服务的发现 举例:QQ群里面的群成员就是一个服务的注册;群成员发消息就是服务的发现. 2 常见的注册中心有哪些 1，Dubbo 的注册中心 Zookee...
SpringCloud服务的注册与发现(一)
热门推荐
程序工厂
08-23 1万+
一、什么是服务注册与发现 Spring Cloud Eureka 模块提供的功能是被动式的服务发现。 服务注册：每个用户去聊天室服务器上注册。 服务发现：这样他的好友们就能看到你,你同时也将获取好友的上线列表. 微服务中，服务就相当于聊天室的用户，而服务注册中心就像聊天室服务器一样。 目前服务发现的解决方案有Eureka，Consul，Zookeeper等等。SpringCloud默认使...
微服务之SpringCloud服务注册与发现
Young_深情不及里子的博客
12-28 3306
在分布式微服务架构中，一个应用可能由一组职责单一化的服务组成。这时候就需要一个注册服务的机制，注册某个服务或者某个节点是可用的，还需要一个发现服务的机制来找到哪些服务或者哪些节点还在提供服务。在实际应用中，通常还都需要一个配置文件告诉我们一些配置信息，比如数据连接的地址，redis 的地址等等。但很多时候，我们想要动态地在不修改代码的情况下得到这些信息，并且能很好地管理它们。 有了这些需求，于是发展出了一系列的开源框架，比如 ZooKeeper, Consul 等等。
SpringCloud(9)之@EnableDiscoveryClient 注解如何实现服务注册与发现
jokeMqc的博客
08-05 9049
一、前言 在新的2020年，Eureka社区网站已经公布了对Eureka2.0版本的更新，但是Eureka1.0版本仍然可以使用，那现在主流的服务注册中心看下图： 我们在每个引导类上都使用了@EnableDiscoveryClient这个注解，这个注解的作用是让该服务放注册中心注册和从注册中心获取其他服务。那它内部是如何实现的呢？今天我们就来聊聊@EnableDiscoveryClient注解是如何进行服务注册与服务发现。 二、@EnableDiscoveryClient 是如何实现服务注册 我
史上最简单的 SpringCloud 教程 | 第一篇： 服务的注册与发现Eureka(Finchley版本)
weixin_30525825的博客
07-14 8617
转载请标明出处： 原文首发于：https://www.fangzhipeng.com/springcloud/2018/08/30/sc-f1-eureka/ 本文出自方志朋的博客 一、spring cloud简介 鉴于《史上最简单的Spring Cloud教程》很受读者欢迎，再次我特意升级了一下版本，目前支持的版本为Spring Bo...
eureka使用总结
许诗宇的博客
05-25 3182
目录 Eureka常用配置 Eureka 单节点搭建 eureka多节点 服务注册的配置选项 Eureka单独使用 Rest服务调用 /eureka/status 服务状态 注册到eureka的服务信息查看 注册到eureka的具体的服务查看 服务续约 更改服务状态 删除状态更新 删除服务 元数据 EurekaClient 多网卡选择 Eureka 健康检查 安全配置 Eureka常用配置 服务端配置 eureka: instance: hostn...
springcloud-nacos.7z
03-08
- **服务发现**：SpringCloud通过Eureka、Consul或Zookeeper等组件实现服务之间的互相发现，使得服务消费者能够找到服务提供者。 - **配置管理**：SpringCloud Config提供了集中化的配置管理，允许开发者在运行时...
consul-1.6.1-win-64.zip
04-14
在IT领域，服务注册与发现是微服务架构中的关键组成部分，Consul 正是为此场景提供解决方案。 1. **服务发现**：Consul 提供了服务发现机制，允许微服务之间的动态连接和通信。每个服务都可以注册到 Consul，其他...
详解Spring Cloud Consul 实现服务注册和发现
08-27
详解Spring Cloud Consul 实现服务注册和发现 Spring Cloud Consul 是一个基于 Spring Boot 实现的云应用开发工具，主要用于服务注册和发现。通过 Spring Boot 风格进行再封装屏蔽掉了复杂的配置和实现原理，提供...
spring-cloud-demo.zip
11-30
解压后，首先确保本地已安装并启动了Eureka服务器（服务注册与发现中心），然后启动包含业务服务（如`serviceA`、`serviceB`）的微服务。接着，启动`spring-cloud-demo`，这个项目会自动从Eureka获取服务列表，并...
一、Eureka
Jack方
01-12 1792
Eureka
SpringCloud微服务（二）——Eureka服务注册中心
qq_43409401的博客
11-20 1720
Eureka服务注册中心
Spring Cloud服务注册类配置参数注释
奋斗中的老青年
04-01 395
package org.springframework.cloud.netflix.eureka; import com.netflix.appinfo.EurekaAccept; import com.netflix.discovery.EurekaClientConfig; import com.netflix.discovery.shared.transport.EurekaTranspo...
Eureka 注册中心
qq_45858803的博客
04-15 911
文章目录启动Eureka serve第一步 加入依赖第二步 写主配置第三步 在主启动类的上面加注解第四步启动测试启动 Eereka client第一步加入依赖第二步 写主配置文件第三步 在主启动类上加上以下注解第四步 启动服务 出现下面的界面表示成功同时注册多个 Eureka client显示以下界面表示成功集群Eureka server （相互注册，相互守望）第一步 导入依赖第二步 修改host文件 （防止名字相同无法区分）第三步 修改主配置文件7001第三步 修改从主配置文件7002第四步 在两个主启动
Eureka服务注册与发现
xzy的博客
09-26 623
文章目录Eureka服务注册与发现总体概括思维导图Eureka基础知识什么是服务治理什么是服务注册与发现Eureka两组件单机Eureka构建步骤IDEA生成eurekaServer端服务注册中心建Module写POM写YML主启动测试易错点将之前写的付费模块这个提供者服务模块改一下改POM改YML改主启动类测试将之前写的订单模块这个消费者服务模块改一下改POM改YML改主启动类测试Eureka集群为什么需要使用Eureka集群？集群Eureka构建步骤新建cloud-eureka-server7002改P
通过eureka中心获取所注册的服务的状态
weixin_39272664的博客
07-26 1352
@RestController @RequestMapping("/getservices") public class ServiceController { @Autowired private DiscoveryClient discoveryClient; @GetMapping("/getServicesList") public Object getServicesList() { List<List<ServiceInstan.
linux装eureka服务注册中心
qq_42816056的博客
05-02 2398
1.在eureka_service项目的pom中添加代码 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </depend...
注册中心Eureka 说明
03-15 617
Eureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中，以实现SpringCloud的服务发现功能。 Eureka包含两个组件：Eureka Server和Eureka Client。 ...
SpringCloud-Eureka
最新发布
07-14
总结来说，SpringCloud-Eureka作为一个服务注册与发现组件，核心价值在于简化分布式系统中的服务发现流程，提升服务可用性，并与其他SpringCloud组件协同工作，为开发者提供了一种标准化的方式来构建和管理微服务...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值