本系列筆記涉及到的代碼在GitHub上，地址：https://github.com/zsllsz/cloud

本文涉及知識點：

• springCloud簡介；

• 注冊中心eureka；

• 注冊中心zookeeper；

歡迎大家關(guān)注我的公眾號 javawebkf，目前正在慢慢地將簡書文章搬到公眾號，以后簡書和公眾號文章將同步更新，且簡書上的付費文章在公眾號上將免費。

一、什么是springCloud？

1、springCloud介紹：

• 我們可以買華為手機(jī)，聯(lián)想電腦，蘋果平板，小愛同學(xué)……等各個不同的品牌的產(chǎn)品，但是因為品牌不同，這些產(chǎn)品之間要通信是比較困難的；但是你可以全都選擇小米的產(chǎn)品，這就是雷布斯一直在搞的生態(tài)系統(tǒng)。而springCloud就是這樣的一個生態(tài)系統(tǒng)，提供web開發(fā)的全套服務(wù)。

• 當(dāng)我們開發(fā)微服務(wù)應(yīng)用時，我們可以選擇spring開發(fā)應(yīng)用，選擇dubbo做服務(wù)的調(diào)用，選擇zookeeper做服務(wù)的注冊與發(fā)現(xiàn)，選擇activemq做消息中間件……但是這些技術(shù)雖然可以組合起來用，并且也能達(dá)到很好的效果，但是它們是不同廠商的產(chǎn)品，兼容性和協(xié)調(diào)性方面可能并不完美，我們有更優(yōu)的選擇，那就是選擇springCloud生態(tài)系統(tǒng)，它集成20多種技術(shù)，對微服務(wù)開發(fā)提供了全套支持！

2、springCloud中的常用技術(shù)：
springCloud全家桶中我們常用的技術(shù)有如下幾種：

• 服務(wù)的注冊與發(fā)現(xiàn)：eureka停更了，不過仍可以使用。可以使用zookeeper，推薦Nacos，可以完美替代eureka；
• 服務(wù)的負(fù)載與調(diào)用：目前在用的是Ribbon + OpenFeign，還有處于萌芽狀態(tài)的LoadBalancer，掛了的feign。
• 服務(wù)的熔斷降級：hystrix掛了，國內(nèi)推薦使用Alibaba Sentinel；
• 服務(wù)網(wǎng)關(guān)：zuul掛了，推薦使用spring的gateway；
• 服務(wù)分布式配置：springCloud config掛了，現(xiàn)在主流是Nacos；
• 服務(wù)總線：Bus掛了，也被Nacos替代；
• 服務(wù)開發(fā)：springBoot

3、技術(shù)選型：
springCloud這么多技術(shù)，每種技術(shù)的版本如何選擇？可以訪問https://start.spring.io/actuator/info，會返回一個json串，里面會說明springCloud版本與其他各技術(shù)的版本支持。本文涉及到的項目各技術(shù)版本如下：

• springCloud：Hoxton.SR1
• springBoot：2.2.2
• springCloud alibaba：2.1.0
• java：java8
• maven：3.5及以上
• mysql：5.7及以上

二、項目搭建

1、 新建父工程：
新建一個maven聚合工程，名為cloud，然后在pom.xml中定義一些依賴的版本。pom.xml文件內(nèi)容如下：

<?xml version="1.0" encoding="UTF-8"?>
<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>

    <groupId>com.zhu.springCloud</groupId>
    <artifactId>cloud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!-- 表示該工程是一個父工程 -->
    <packaging>pom</packaging>

    <name>Maven</name>
    <url>http://maven.apache.org/</url>
    <inceptionYear>2001</inceptionYear>

    <!--統(tǒng)一管理jar包版本 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>12</maven.compiler.source>
        <maven.compiler.target>12</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <lombok.version>1.18.10</lombok.version>
        <log4j.version>1.2.17</log4j.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.16</druid.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>

    <!--子模塊繼承之后，提供作用：鎖定版本+子module不用寫groupId和version -->
    <!-- 只是聲明依賴，不會引入具體依賴 -->
    <dependencyManagement><!--定義規(guī)范，但不導(dǎo)入 -->
        <dependencies>
            <dependency>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-project-info-reports-plugin</artifactId>
                <version>3.0.0</version>
            </dependency>
            <!--spring boot 2.2.2 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud Hoxton.SR1 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud 阿里巴巴 -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.1.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--mysql -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
                <scope>runtime</scope>
            </dependency>
            <!-- druid -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <!--mybatis -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.spring.boot.version}</version>
            </dependency>
            <!--junit -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!--log4j -->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!--熱啟動插件 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

父工程就是這樣，只有個pom文件。

2、新建數(shù)據(jù)庫：
數(shù)據(jù)庫只有一張表，如下：

payment表

3、在父工程下新建名為cloud-api-commons的moudle，定義一些公用的類：

• 首先修改pom：

<?xml version="1.0"?>
<project
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
    xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.zhu.springCloud</groupId>
        <artifactId>cloud</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>cloud-api-commons</artifactId>

    <url>http://maven.apache.org</url>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <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>cn.hutool</groupId>
          <artifactId>hutool-all</artifactId>
          <version>5.1.0</version>
        </dependency>
    </dependencies>
</project>

• 寫一個Payment類對應(yīng)數(shù)據(jù)表：

package com.zhusl.springcloud.entities;

import java.io.Serializable;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {

    private static final long serialVersionUID = 1L;
    
    private Long id;
    private String serial;
}

• 寫一個JsonResult類，用來封裝返回結(jié)果：

package com.zhusl.springcloud.common;
import lombok.Data;
@Data
public class JsonResult<T> {
    private Integer code;
    private String message;
    private T data;
    public JsonResult(Integer code, String message) {
        this(code, message, null);
    }
    public JsonResult(Integer code, String message, T data) {
        super();
        this.code = code;
        this.message = message;
        this.data = data;
    }
    public JsonResult() {
        super();
    }
}

然后這個通用工程也就完成了，將其maven install一下。

4、在父工程下新建名為cloud-provider-payment8001的moudle，充當(dāng)支付服務(wù)：

• 修改pom：

<?xml version="1.0"?>
<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.zhu.springCloud</groupId>
        <artifactId>cloud</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>cloud-provider-payment8001</artifactId>
    <dependencies>
        <dependency>
            <groupId>com.zhu.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>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <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>
        </dependency>
    </dependencies>
</project>

• 寫yml文件，配置數(shù)據(jù)庫，mybatis等信息：

server:
  port: 8001

spring:
  application:
    name: cloud-payment-service #提交到注冊中心的微服務(wù)名稱
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/db2020?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123
    
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.zhusl.springcloud.entities

• 寫主啟動類：

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

• 寫業(yè)務(wù)類：
  dao：

@Mapper
public interface PaymentDao {
    public int create(Payment payment);
    public Payment getPaymentById(@Param("id") Long id);
}

mapper.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhusl.springcloud.dao.PaymentDao">
   <resultMap type="com.zhusl.springcloud.entities.Payment" id="PaymentMap">
      <id column="id" property="id" jdbcType="BIGINT"/>
      <result column="serial" property="serial" jdbcType="VARCHAR"/>
   </resultMap>
   <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
      insert into payment(serial) values(#{serial});
   </insert>
   <select id="getPaymentById" parameterType="Long" resultMap="PaymentMap">
      select * from payment where id=#{id};
   </select>
</mapper>

service：

@Service
public class PaymentServiceImpl implements PaymentService {
    @Autowired
    private PaymentDao paymentDao;
    @Override
    public int create(Payment payment) {
        return paymentDao.create(payment);
    }
    @Override
    public Payment getPaymentById(Long id) {
        return paymentDao.getPaymentById(id);
    }
}

controller：

@RestController
@RequestMapping("/payment")
@Slf4j
public class PaymentController {
    @Autowired
    private PaymentService paymentService;
    @PostMapping("/create")
    public JsonResult<Payment> create(@RequestBody Payment payment){
        int result = paymentService.create(payment);
        log.info("========插入結(jié)果：=========" + result);
        if (result > 0) {
            return new JsonResult<Payment>(200, "success", null);
        } else {
            return new JsonResult<Payment>(400, "fail", null);
        }
    }

    @GetMapping("/{id}")
    public JsonResult<Payment> getPaymentById(@PathVariable("id") Long id){
        Payment payment = paymentService.getPaymentById(id);
        log.info("======== 執(zhí)行操作==========");
        if (payment != null) {
            return new JsonResult<Payment>(200, "success", payment);
        } else {
            return new JsonResult<Payment>(400, "fail", null);
        }
    }
}

這樣就搭完了payment服務(wù)。

5、在父工程下新建名為cloud-consumer-order80的moudle，充當(dāng)訂單服務(wù)：

• pom文件：

<?xml version="1.0"?>
<project
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
    xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.zhu.springCloud</groupId>
        <artifactId>cloud</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>cloud-consumer.order80</artifactId>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.zhu.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>
        </dependency>
    </dependencies>
</project>

• yml文件：

server:
  port: 80

spring:
  application:
    name: cloud-order-service #提交到注冊中心的微服務(wù)名稱

• 主啟動類：

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

• 配置類，配置restTemplate：

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

• controller：

@RestController
@RequestMapping("/consumer")
public class OrderController {
    private static final String PAYMENT_URL = "http://localhost:8001";
    @Autowired
    private RestTemplate restTemplate;

    @SuppressWarnings("unchecked")
    @GetMapping("/payment/create")
    public JsonResult<Payment> create(Payment payment){
        return restTemplate.postForObject(PAYMENT_URL + "/payment/create", payment, JsonResult.class);
    }
    
    @SuppressWarnings("unchecked")
    @GetMapping("/payment/get/{id}")
    public JsonResult<Payment> getPayment(@PathVariable("id") Long id){
        return restTemplate.getForObject(PAYMENT_URL + "/payment/" + id, JsonResult.class);
    }
}

這里直接寫payment服務(wù)所在的服務(wù)器ip和端口，然后通過Spring的restTemplate直接發(fā)送post或者get請求，從而達(dá)到服務(wù)相互調(diào)用的目的。有人說，這樣就已經(jīng)達(dá)到目的了，服務(wù)在不同的服務(wù)器，也能相互調(diào)用，為什么還要學(xué)其他的呢？因為，這樣調(diào)用不好做服務(wù)的協(xié)調(diào)與管理。需要一個中間商，來維護(hù)管理這些服務(wù)，做服務(wù)的注冊與發(fā)現(xiàn)。springCloud支持的中間商有很多，如開篇說的eureka、zookeeper和nacos。

三、服務(wù)的注冊與發(fā)現(xiàn)之eureka

eureka雖然停更了，但還是可以了解一下。eureka中有兩個概念，一個server和一個client。server是提供服務(wù)注冊功能的，也就是我們的服務(wù)就注冊到server中；client可以理解為就是我們需要注冊的服務(wù)。顯然上面的payment8001和order80是我們需要注冊的服務(wù)。eureka server中存的其實就是一些kv鍵值對，key是服務(wù)的名稱，value是服務(wù)的調(diào)用地址。

1、在父工程下新建名為cloud-eureka-server7001的moudle，作為eureka的server：

• pom文件：

<?xml version="1.0"?>
<project
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
    xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.zhu.springCloud</groupId>
        <artifactId>cloud</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>cloud-eureka-server7001</artifactId>
    <name>cloud-eureka-server7001</name>
    <url>http://maven.apache.org</url>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <!-- eureka server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>com.zhu.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>
        </dependency>
    </dependencies>
</project>

• 寫yml：

server:
  port: 7001

eureka:
  instance:
    hostname: localhost #eureka服務(wù)端的實例名稱
  client:
    register-with-eureka: false # false表示不向服務(wù)中心注冊自己
    fetch-registry: false # false表示自己就是注冊中心，維護(hù)服務(wù)實例，而不去檢索服務(wù)
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ # 向eureka查詢和注冊服務(wù)都通過這個地址

• 主啟動類：

@SpringBootApplication
@EnableEurekaServer // 表明這個項目是eureka注冊中心
public class EurekaMain7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaMain7001.class, args);
    }
}

然后啟動這個項目，訪問localhost:7001，可以看到如下畫面：

eureka

這僅僅是將注冊中心eureka的server搭建好了，但是我們并沒有把服務(wù)注冊進(jìn)去，接下來我們把payment8001注冊進(jìn)eureka中。

2、將payment8001注冊進(jìn)eureka中：

• 改pom，payment8001中添加eureka client依賴：

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

• 改yml，payment8001的yml中添加eureka相關(guān)配置：

eureka:
  client:
    register-with-eureka: true # 將自己注冊進(jìn)eureka
    fetch-registry: true # 從eureka抓取自己的注冊信息
    service-url:
      defaultZone: http://localhost:7001/eureka   #eureka server所在的主機(jī)和端口

• 主啟動類加上如下注解：

@EnableEurekaClient

這樣就行了，啟動payment8001，再刷新localhost:7001，就會發(fā)現(xiàn)eureka中有payment8001這個服務(wù)了，如下圖：

服務(wù)注冊成功

3、將order80注冊進(jìn)eureka：

• 改pom，添加eureka client的依賴：

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

• 改yml，添加eureka配置：

eureka:
  client:
    register-with-eureka: true # 將自己注冊進(jìn)eureka，不注冊就false
    fetch-registry: true # 從eureka抓取自己的注冊信息
    service-url:
      defaultZone: http://localhost:7001/eureka/ #eureka server所在的主機(jī)和端口

• 主啟動類添加如下注解：

@EnableEurekaClient

• 修改controller，將剛才寫的調(diào)用地址換成服務(wù)名稱：
  即把

private static final String PAYMENT_URL = "http://localhost:8001";

換成

private static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";

• 然后啟動order80，刷新eureka頁面，發(fā)現(xiàn)order80已經(jīng)注冊進(jìn)eureka server中去了，如下圖：

服務(wù)注冊成功

• 最后訪問order80的controller，看看能否成功通過eureka調(diào)用到payment8001：

成功調(diào)用服務(wù)

4、eureka集群：
eureka集群原理就是互相注冊，對外表現(xiàn)為一個整體。上面新建了一個cloud-eureka-server7001，端口是7001，現(xiàn)在再建一個名為cloud-eureka-server7002的module，端口為7002。

• 修改host文件，為了避免兩個eureka server的host都寫成localhost，在系統(tǒng)host文件中添加如下內(nèi)容：

127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com

• 修改7001的yml，改成這樣：

server:
  port: 7001
# 集群的寫法
eureka:
  instance:
    hostname: eureka7001.com #eureka服務(wù)端的實例名稱
  client:
    register-with-eureka: false # false表示不向服務(wù)中心注冊自己
    fetch-registry: false # false表示自己就是注冊中心，維護(hù)服務(wù)實例，而不去檢索服務(wù)
    service-url:
      defaultZone: http://eureka7002.com:7002/eureka/ # 把自己注冊到7002中，如果還有7003、7004，則用逗號隔開即可
  server:
    enable-self-preservation: false #關(guān)閉自我保護(hù)
    eviction-interval-timer-in-ms: 2000 #檢測心跳的時間間隔

• 7002的yml：

server:
  port: 7002
  
# 集群的寫法
eureka:
  instance:
    hostname: eureka7002.com #eureka服務(wù)端的實例名稱
  client:
    register-with-eureka: false # false表示不向服務(wù)中心注冊自己
    fetch-registry: false # false表示自己就是注冊中心，維護(hù)服務(wù)實例，而不去檢索服務(wù)
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/ # 把自己注冊到7001，若是集群有三個以上，那么此行的多個url之間用逗號隔開即可
  server:
    enable-self-preservation: false #關(guān)閉自我保護(hù)
    eviction-interval-timer-in-ms: 2000 #檢測心跳的時間間隔

其他的都和7001一樣即可，這樣就完成eureka集群了。

• 修改payment8001和order80中的yml：

把原先的

defaultZone: http://localhost:7001/eureka/

替換成

defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

• 最后訪問一下eureka7002.com:7002和eureka7001.com:7001，可以看到如下畫面：

eureka集群成功

5、payment服務(wù)集群：

• 上面有一個payment8001，我們拷貝一份，命名為cloud-provider-payment8002；
• 將payment8002端口改成8002；
• 在payment8001和payment8002的controller中，都讀取配置文件的端口，返回信息中加上端口，等下order80調(diào)用的時候，就可以清晰地看到是調(diào)用了8001還是8002
• 配置負(fù)載均衡策略。8001和8002的服務(wù)名相同，在order80中去調(diào)用CLOUD-PAYMENT-SERVICE時，它不知道具體是調(diào)8001還是8002，所以在order80的配置類中加上@LoadBalanced注解，如下：

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

@LoadBalanced注解可以理解為輪詢，就是一人一次。

• 訪問order80，看看效果圖：

第一次訪問

第二次訪問

可以看到，第一次調(diào)用的是payment8001，第二次調(diào)用的是payment8002，集群成功了。如果你多次調(diào)用的都是同一個，很有可能是緩存原因，解決辦法我在nginx一文中講過。

6、status配置：

status

在status這里，還顯示了localhost，不想對外顯示localhost，并且當(dāng)我把鼠標(biāo)懸停在cloud-order-service:80，我要顯示服務(wù)所在的主機(jī)的IP。那么只需要在order80項目的yml加上如下配置即可：

instance: #和client對齊
    instance-id: order80
    prefer-ip-address: true #顯示IP信息

7、服務(wù)的發(fā)現(xiàn)：

• 拿payment8001舉例子，在其啟動類上加上如下注解：

@EnableDiscoveryClient // 發(fā)現(xiàn)服務(wù)的注解

• 然后在controller中注入如下內(nèi)容：

@Autowired
private DiscoveryClient discoveryClient;

• 最后在controller中加一個方法：

@GetMapping("/discovery")
public Object discovery() {
        List<String> services = discoveryClient.getServices();
        for (String string : services) {
            log.info(string);
        }
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        for (ServiceInstance serviceInstance : instances) {
            log.info(serviceInstance.getServiceId() + "\r\n" + serviceInstance.getHost() + "\r\n" + serviceInstance.getPort() + "\r\n" + serviceInstance.getUri());
        }
        return this.discoveryClient;
}

可以自己組裝數(shù)據(jù)返回給前端，這樣別人訪問你/discovery，就可以知道名為CLOUD-PAYMENT-SERVICE的服務(wù)有幾個，端口是什么，ip是什么等信息。

8、eureka自我保護(hù)機(jī)制：
當(dāng)某個服務(wù)不能用了，eureka不會立即清理門戶，依舊會保存該微服務(wù)的信息，這就是eureka自我保護(hù)機(jī)制。如果你想當(dāng)某個服務(wù)不能用了，eureka就立即干掉該服務(wù)的信息，那么在eureka server中加上相關(guān)配置即可。上面的7001和7002都關(guān)閉了自我保護(hù)，它們的yml中最后那段配置就是這個作用。

四、服務(wù)的注冊與發(fā)現(xiàn)之zookeeper

zookeeper與dubbo天生是一對，springCloud也對zookeeper提供了支持。關(guān)于zookeeper，可以參考我zookeeper的文章。下面開始講如何使用zookeeper代替eureka。
1、首先啟動centos上的zookeeper，然后新建名為cloud-provider-payment8004的module：

• 改pom：

和8001的pom基本一致，只需要將eureka的依賴替換成zookeeper的依賴，并且將mybatis和mysql相關(guān)依賴去掉，本項目為了簡單些不再連數(shù)據(jù)庫：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
</dependency>

• 寫yml：

server:
  port: 8004
  
spring:
  application:
    name: cloud-provider-payment
  cloud:
    zookeeper:
      connect-string: 192.168.0.104:2181 #如果zookeeper是集群，這里用逗號隔開就行了

• 主啟動類：

@SpringBootApplication
@EnableDiscoveryClient // 發(fā)現(xiàn)服務(wù)
public class PaymentMain8004 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8004.class, args);
    }
}

• controller：

@RestController
@RequestMapping("/payment")
public class PaymentController {

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

    @GetMapping("/zk")
    public String paymentzk() {
        return "該服務(wù)端口號為：" + port;
    }
}

• 啟動payment8004，如果報錯了，報zookeeper相關(guān)錯誤，很可能是jar包沖突。也就是spring-cloud-starter-zookeeper-discovery中帶的zookeeper的jar包與你服務(wù)器安裝的zookeeper版本不兼容。解決辦法就是排除spring-cloud-starter-zookeeper-discovery自帶的zookeeper的jar包，加上自己需要的zookeeper的jar包。如下：

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
   <exclusions>
      <exclusion>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
      </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.5.5</version>
</dependency>

先來看啟動前我zookeeper下只有activemq和zookeeper兩個節(jié)點：

zookeeper

payment8004成功啟動后，zookeeper下就會多一個節(jié)點，如下：

zookeeper

可以看到多了一個services節(jié)點，并且該節(jié)點下有我們配置的服務(wù)名，說明成功注冊到zookeeper中。值得注意的是，zookeeper里的services節(jié)點是臨時節(jié)點，即如果你把payment8004關(guān)閉，zookeeper在心跳時間內(nèi)沒有收到回應(yīng)，就會把該節(jié)點干掉。

2、新建名為cloud-consumerzk-order80的module，作為消費端：

• pom文件，和8004一樣。
• yml文件，和8004差不多，只是端口變成了80，服務(wù)名變成了cloud-consumerzk-order。
• 主啟動類，和8004的一樣。
• 配置類，配置restTemplate，和consumer-order80的一樣。
• controller，通過restTemplate去調(diào)用payment8004：

@RestController
@RequestMapping("/order")
public class OrderZkController {
    private static final String URL = "http://cloud-provider-payment";
    
    @Autowired
    public RestTemplate restTemplate; 
    
    @GetMapping("/info")
    public String paymentInfo() {
        return restTemplate.getForObject(URL + "/payment/zk", String.class);
    }
}

• 啟動payment8004，再啟動consumerzk-order80，然后在瀏覽器訪問consumerzk-order80的controller，返回如下信息則表示調(diào)用成功：

通過zookeeper調(diào)用成功