Spring Cloud 学习之Eureka(2) —— 集群模式

Spring Cloud 学习之Eureka(1) —— 单机模式

Spring Cloud 学习之Eureka(3) —— 提供安全保障

上一篇博客我们简单使用了Eureka，但是单机模式扛不住互联网的压力，所以，我们可以通过集群部署来分担压力，集群可以分为注册中心集群化和服务集群化。

注册中心集群化

下面我先介绍下注册中心集群化，通俗的讲，注册中心是管理服务的一个平台，一般来说，他不会有太大的压力，但是，为了避免服务器宕机，网络瘫痪等原因，我们还是考虑采用集群模式，来达到高可用的特性，这也符合Eureka的AP特点（CAP定理），这里我们则启动两个注册中心，在上篇博客的基础上，我们对application.yml文件做一些修改，让两个注册中心可以互相注册：

## application-server1.yml

server:
  port: 28080

spring:
  application:
    name: maochd-eureka-server

eureka:
  instance:
    hostname: maochd-eureka-server1
  client:
    service-url:
      defaultZone: http://maochd-eureka-server2:28081/eureka
#    fetch-registry: false
#    register-with-eureka: false



----------------------------------------

## application-server2.yml

server:
  port: 28081

spring:
  application:
    name: maochd-eureka-server

eureka:
  instance:
    hostname: maochd-eureka-server2
  client:
    service-url:
      defaultZone: http://maochd-eureka-server1:28080/eureka
#    fetch-registry: false
#    register-with-eureka: false

这里我们新创建了两个yml文件，运行时我们分别加载两个配置文件即可，可以通过命令行的方式来启动，也可以参考下面的配置，都可以达到同样的效果。

java -jar xxx.jar --spring.profiles.active=server1

 

当你分别启动的时候，可能先启动的会出现异常，那是因为他要注册的注册中心还没启动，当所有的注册中心都启动完成后，异常也就消失了，接下来我们看下控制台

这两幅图都可以看到，两个注册中心已经互相注册成功了，至此，注册中心集群已经搭建完毕了，如果需要加入更多的注册中心，只要在defaultZone中写上集群中所有的注册中心地址即可（自己除外，因为fetch-registry已经实现了自注册）。

生产者服务集群化

完成了注册中心集群，接下来我们来实现服务的集群，这里，我们先实现生产者的集群，由于配置文件除了端口不同，所以我就不创建两个yml了，直接通过传参的方式来启动两个项目，方式和上面相同，yml如下，也做了一些小改动，如下：

server:
  port: 28090

spring:
  application:
    name: maochd-provider

eureka:
  client:
    service-url:
      defaultZone: http://maochd-eureka-server1:28080/eureka, http://maochd-eureka-server2:28081/eureka

我们刷新下注册中心，就可以看到有两个生产者服务了：

生产者集群已经搭建完了，但是消费者是如何调用生产者的呢，我们接下来把消费者也运行起来，上篇中我们用到了负载均衡组件Ribbon，但是单机模式看不出效果，这里我们就可以很直观的看到效果。

首先，我们也修改消费者的配置文件，让他注册到所有的注册中心：

server:
  port: 28100

spring:
  application:
    name: maochd-consumer

eureka:
  client:
    service-url:
      defaultZone: http://maochd-eureka-server1:28080/eureka, http://maochd-eureka-server2:28081/eureka

这时候我们修改生产者中的接口（上篇定义的）：

package com.maochd.springcloud.maochd.provider.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(value = "/provider")
public class ProviderController {

    private static Logger logger = LoggerFactory.getLogger(ProviderController.class);

    @GetMapping(value = "/helloEureka")
    public String helloEureka() {
        logger.error("load balance");
        return "Hello, maochd";
    }
}

我们在这边打上一个log（用error是为了更好区分），我们重启生产者和消费者，等到稳定后，我们刷新注册中心，可以看到生产者消费者都已经注册成功了：

接下来，我们在浏览器上访问消费者接口:

我们再来看下生产者的控制台，在provider1的控制台中打印了日志，说明这次请求是转发给provider1的

我们回到浏览器，刷新一下，

在provider2中也看到了log，说明ribbon确实做了负载均衡的工作，而且默认的方式是轮询，轮流调用。至此，生产者集群就完成了。

消费者服务集群化

但是在实际开发中，一个服务不可能只扮演生产者或消费者的角色，经常是同时扮演两个角色，接下来我将把消费者也做成集群，并且让消费者和生产者的角色存在于两个服务中。

我们这里重点修改生产者服务的代码，让其同时成为消费者，所以我们也需要引入Ribbon组件，只要在pom文件中引入：

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

同时注入

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}

接下来，我们在消费者服务中写一个接口，

@GetMapping(value = "/asProvider")
public String asProvider() {
    logger.error("As provider");
    return "As provider";
}

同时在生产者服务中调用：

@GetMapping(value = "/asProvider")
public String asProvider() {
    return restTemplate
            .getForEntity("http://maochd-consumer/consumer/asProvider", String.class)
            .getBody();
}

这样代码就完成了，我们同时启动生产者服务和消费者服务集群，刷新注册中心可以看到都已经注册成功

接下来我们调用生产者服务的接口，并查看消费者服务的日志，

这里我们可以看到分别访问两个生产者服务接口，都能实现负载均衡，至于之前的接口就不再演示，原理都是相同的，各位可以稍后自己练习时验证。

到这我们初步把注册中心和服务的集群讲完了，基础原理大概就是这样，至于真实场景如何使用集群，请各位根据自己的业务，成本等酌情设计。