SpringCloud整合常见服务注册中心

注册中心原理

在微服务架构下，主要有三种角色：服务提供者（RPC Server）、服务消费者（RPC Client）和服务注册中心（Registry），三者的交互关系请看下面这张图，我来简单解释一下。

• RPC Server 提供服务，在启动时，根据服务发布文件 server.xml 中的配置的信息，向 Registry 注册自身服务，并向
  Registry 定期发送心跳汇报存活状态。

• RPC Client 调用服务，在启动时，根据服务引用文件 client.xml 中配置的信息，向 Registry 订阅服务，把 Registry 返回的服务节点列表缓存在本地内存中，并与 RPC Sever 建立连接。

• 当 RPC Server 节点发生变更时，Registry 会同步变更，RPC Client 感知后会刷新本地内存中缓存的服务节点列表。

• RPC Client 从本地缓存的服务节点列表中，基于负载均衡算法选择一台 RPC Sever 发起调用。

---

Eureka服务注册与发现

1. 生成EurekaServer端服务注册中心

1.1 引入pom依赖

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

1.2 配置文件的编写

server:
  port: 7001

eureka:
  instance:
    hostname: localhost     # eureka服务端地址
  client:
    registerWithEureka: false     # false表示不向注册中心注册自己
    fetch-registry: false           # false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/  # 设置与Eureka Server交互的服务注册地址

1.3 在主方法里开启EurekaServer支持

1.4 启动并访问http://localhost/7001
如果出现如下界面则表示配置成功：

2. 生成EurekaClient服务提供者

2.1 引入pom依赖

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

2.2 配置文件的编写

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驱动包
    url: jdbc:mysql://localhost:3306/springcloud_study?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root

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

eureka:
  client:
    registerWithEureka: true                               # false表示不向注册中心注册自己
    fetch-registry: true       # 是否从EurakaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true
    service-url:
      defaultZone: http://localhost:7001/eureka

2.3 在主方法里开启EurekaClient支持

2.4 启动并访问http://localhost/7001,如下图：

2.5 再创建一个相同的provider（除端口号），做个provider集群：
切记一定要用相同的服务名，一会儿来做负载均衡。
在controller层加点代码（请求时可以显示当前服务的端口号）:

import com.coderzpw.springcloud.entities.CommonResult;
import com.coderzpw.springcloud.entities.Payment;
import com.coderzpw.springcloud.service.PaymentService;
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 {
    @Value("${server.port}")
    private String serverPort;

    @Autowired
    private PaymentService paymentService;

    @PostMapping("/payment/create")
    public CommonResult create(@RequestBody Payment payment){
        System.out.println(payment.toString());
        int result = paymentService.create(payment);

        log.info("***** 插入结果 *****"+result);
        if (result>0){
            return new CommonResult(200,"插入数据成功--"+serverPort,result);
        }else{
            return new CommonResult(444,"插入数据失败",null);
        }
    }

    @GetMapping("/payment/get/{id}")
    public CommonResult create(@PathVariable("id") Long id){
        Payment payment = paymentService.getPaymentById(id);
        log.info("***** 插入结果 *****"+payment);
        if (payment!=null){
            return new CommonResult(200,"查询数据成功--"+serverPort,payment);
        }else{
            return new CommonResult(444,"没有对应记录，查询ID"+id,null);
        }
    }
}

3. 生成EurekaClient服务消费者

其他配置跟privider提供者相似，不做详细描述

一些重要细节代码如下：
3.1 配置类代码：

 package com.coderzpw.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 getRestTemplate() {
        return new RestTemplate();
    }

}

切记这里getRestTemplate()方法上必须要加个@LoadBalanced注解，才能实现负载均衡

3.2 controller层代码：

import com.coderzpw.springcloud.entities.CommonResult;
import com.coderzpw.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@Slf4j
public class OrderController {
    public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/consumer/payment/create")
    public CommonResult<Payment> create(Payment payment) {
        System.out.println(payment.toString());
        return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResult.class);
    }

    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
        return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
    }
}

切记 public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE"; 这个URL是一个动态的，CLOUD-PAYMENT-SERVICE是一个服务名，直接访问服务名，然后Eureka内置的Ribbon会自动实现负载均衡及服务分发

3.3 显示访问效果：
第一次访问：

再一次访问：

这样就实现了provider服务提供者的负载均衡

---

Zookeeper服务注册与发现

1. 启动zookeeper服务

2. 创建服务提供者

2.1 引入pom依赖

<!--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>
        <!--添加对应自己的zookeeper版本-->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.10</version>
            <!--排除zookeeper自带的slf4j-log4j12 否者可能报错-->
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

2.2 写yml配置

server:
  port: 8002    # 8002表示注册到zookeeper服务器服务提供者端口号


# 服务别名--- 注册zookeeper到注册中心名称
spring:
  application:
    name: cloud-provider-payment
  cloud:
    zookeeper:
      connect-string: 192.168.198.140:2181

2.3 编写启动类

2.4 启动主方法并查看zookeeper的node节点信息

3. 思考：服务节点是临时的还是持久的呢？

测试：
当我关掉springboot服务项目后查看zookeeper服务节点

结论：
服务注册到zookeeper上的节点是临时节点！！

4. 创建服务消费者

这里消费者跟服务提供者配置类似，所以不做过多描述

---

Consul服务注册与发现

consul的下载安装这里不做过多描述。consul一般用的是exe版，下载安装比较简单

1. 启动Consul

1.1 打开终端，进入当前目录

consul --version			# 查看consul版本
consul agent -dev			# 启动consul服务

1.2. 启动之后，可以访问Consul的服务界面：Http://localhost:8500

2. 创建服务提供者

2.1 引入pom依赖

<!--SpringCloud Consul-Server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-discovery</artifactId>
        </dependency>

2.2 写yml配置

server:
  port: 8006

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

2.3 编写启动类

2.4 查看consul的服务界面

3. 创建服务消费者

这里消费者跟服务提供者配置类似，所以不做过多描述

---

三个注册中心的异同点

CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性、可用性和分区容错性这三个需求，因此，根据CAP原理将NoSql数据库分为了满足CA原则、满足CP原则和满足AP原则三大类：
C: Consistency （强一致性）
A: Availability （可用性）
P: Partition tolerance （区分容错性）