springCloud --- 初级篇(1)

本系列笔记涉及到的代码在GitHub上，地址：https://github.com/zsllsz/cloud

本文涉及知识点：

  • springCloud简介；

  • 注册中心eureka；

  • 注册中心zookeeper；

欢迎大家关注我的公众号 javawebkf，目前正在慢慢地将简书文章搬到公众号，以后简书和公众号文章将同步更新，且简书上的付费文章在公众号上将免费。

一、什么是springCloud？

1、springCloud介绍：

  • 我们可以买华为手机，联想电脑，苹果平板，小爱同学……等各个不同的品牌的产品，但是因为品牌不同，这些产品之间要通信是比较困难的；但是你可以全都选择小米的产品，这就是雷布斯一直在搞的生态系统。而springCloud就是这样的一个生态系统，提供web开发的全套服务。

  • 当我们开发微服务应用时，我们可以选择spring开发应用，选择dubbo做服务的调用，选择zookeeper做服务的注册与发现，选择activemq做消息中间件……但是这些技术虽然可以组合起来用，并且也能达到很好的效果，但是它们是不同厂商的产品，兼容性和协调性方面可能并不完美，我们有更优的选择，那就是选择springCloud生态系统，它集成20多种技术，对微服务开发提供了全套支持！

2、springCloud中的常用技术：
springCloud全家桶中我们常用的技术有如下几种：

  • 服务的注册与发现：eureka停更了，不过仍可以使用。可以使用zookeeper，推荐Nacos，可以完美替代eureka；
  • 服务的负载与调用：目前在用的是Ribbon + OpenFeign，还有处于萌芽状态的LoadBalancer，挂了的feign。
  • 服务的熔断降级：hystrix挂了，国内推荐使用Alibaba Sentinel；
  • 服务网关：zuul挂了，推荐使用spring的gateway；
  • 服务分布式配置：springCloud config挂了，现在主流是Nacos；
  • 服务总线：Bus挂了，也被Nacos替代；
  • 服务开发：springBoot

3、技术选型：
springCloud这么多技术，每种技术的版本如何选择？可以访问https://start.spring.io/actuator/info，会返回一个json串，里面会说明springCloud版本与其他各技术的版本支持。本文涉及到的项目各技术版本如下：

  • 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文件内容如下：

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

    <!--统一管理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><!--定义规范，但不导入 -->
        <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、新建数据库：
数据库只有一张表，如下：

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类对应数据表：
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类，用来封装返回结果：
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，充当支付服务：

  • 修改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文件，配置数据库，mybatis等信息：
server:
  port: 8001

spring:
  application:
    name: cloud-payment-service #提交到注册中心的微服务名称
  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);
    }
}
  • 写业务类：
    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("========插入结果：=========" + 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("======== 执行操作==========");
        if (payment != null) {
            return new JsonResult<Payment>(200, "success", payment);
        } else {
            return new JsonResult<Payment>(400, "fail", null);
        }
    }
}

这样就搭完了payment服务。

5、在父工程下新建名为cloud-consumer-order80的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-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 #提交到注册中心的微服务名称
  • 主启动类：
@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服务所在的服务器ip和端口，然后通过Spring的restTemplate直接发送post或者get请求，从而达到服务相互调用的目的。有人说，这样就已经达到目的了，服务在不同的服务器，也能相互调用，为什么还要学其他的呢？因为，这样调用不好做服务的协调与管理。需要一个中间商，来维护管理这些服务，做服务的注册与发现。springCloud支持的中间商有很多，如开篇说的eureka、zookeeper和nacos。

三、服务的注册与发现之eureka

eureka虽然停更了，但还是可以了解一下。eureka中有两个概念，一个server和一个client。server是提供服务注册功能的，也就是我们的服务就注册到server中；client可以理解为就是我们需要注册的服务。显然上面的payment8001和order80是我们需要注册的服务。eureka server中存的其实就是一些kv键值对，key是服务的名称，value是服务的调用地址。

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服务端的实例名称
  client:
    register-with-eureka: false # false表示不向服务中心注册自己
    fetch-registry: false # false表示自己就是注册中心，维护服务实例，而不去检索服务
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ # 向eureka查询和注册服务都通过这个地址
  • 主启动类：
@SpringBootApplication
@EnableEurekaServer // 表明这个项目是eureka注册中心
public class EurekaMain7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaMain7001.class, args);
    }
}

然后启动这个项目，访问localhost:7001，可以看到如下画面：

eureka

这仅仅是将注册中心eureka的server搭建好了，但是我们并没有把服务注册进去，接下来我们把payment8001注册进eureka中。

2、将payment8001注册进eureka中：

  • 改pom，payment8001中添加eureka client依赖：
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
  • 改yml，payment8001的yml中添加eureka相关配置：
eureka:
  client:
    register-with-eureka: true # 将自己注册进eureka
    fetch-registry: true # 从eureka抓取自己的注册信息
    service-url:
      defaultZone: http://localhost:7001/eureka   #eureka server所在的主机和端口
  • 主启动类加上如下注解：
@EnableEurekaClient

这样就行了，启动payment8001，再刷新localhost:7001，就会发现eureka中有payment8001这个服务了，如下图：

服务注册成功

3、将order80注册进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 # 将自己注册进eureka，不注册就false
    fetch-registry: true # 从eureka抓取自己的注册信息
    service-url:
      defaultZone: http://localhost:7001/eureka/ #eureka server所在的主机和端口
  • 主启动类添加如下注解：
@EnableEurekaClient
  • 修改controller，将刚才写的调用地址换成服务名称：
    即把
private static final String PAYMENT_URL = "http://localhost:8001";

换成

private static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";
  • 然后启动order80，刷新eureka页面，发现order80已经注册进eureka server中去了，如下图：
服务注册成功
  • 最后访问order80的controller，看看能否成功通过eureka调用到payment8001：
成功调用服务

4、eureka集群：
eureka集群原理就是互相注册，对外表现为一个整体。上面新建了一个cloud-eureka-server7001，端口是7001，现在再建一个名为cloud-eureka-server7002的module，端口为7002。

  • 修改host文件，为了避免两个eureka server的host都写成localhost，在系统host文件中添加如下内容：
127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com
  • 修改7001的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/ # 把自己注册到7002中，如果还有7003、7004，则用逗号隔开即可
  server:
    enable-self-preservation: false #关闭自我保护
    eviction-interval-timer-in-ms: 2000 #检测心跳的时间间隔
  • 7002的yml：
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/ # 把自己注册到7001，若是集群有三个以上，那么此行的多个url之间用逗号隔开即可
  server:
    enable-self-preservation: false #关闭自我保护
    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服务集群：

  • 上面有一个payment8001，我们拷贝一份，命名为cloud-provider-payment8002；
  • 将payment8002端口改成8002；
  • 在payment8001和payment8002的controller中，都读取配置文件的端口，返回信息中加上端口，等下order80调用的时候，就可以清晰地看到是调用了8001还是8002
  • 配置负载均衡策略。8001和8002的服务名相同，在order80中去调用CLOUD-PAYMENT-SERVICE时，它不知道具体是调8001还是8002，所以在order80的配置类中加上@LoadBalanced注解，如下：
@Configuration
public class ApplicationConfig {
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

@LoadBalanced注解可以理解为轮询，就是一人一次。

  • 访问order80，看看效果图：
第一次访问

第二次访问

可以看到，第一次调用的是payment8001，第二次调用的是payment8002，集群成功了。如果你多次调用的都是同一个，很有可能是缓存原因，解决办法我在nginx一文中讲过。

6、status配置：

status

在status这里，还显示了localhost，不想对外显示localhost，并且当我把鼠标悬停在cloud-order-service:80，我要显示服务所在的主机的IP。那么只需要在order80项目的yml加上如下配置即可：

instance: #和client对齐
    instance-id: order80
    prefer-ip-address: true #显示IP信息

7、服务的发现：

  • 拿payment8001举例子，在其启动类上加上如下注解：
@EnableDiscoveryClient // 发现服务的注解
  • 然后在controller中注入如下内容：
@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;
}

可以自己组装数据返回给前端，这样别人访问你/discovery，就可以知道名为CLOUD-PAYMENT-SERVICE的服务有几个，端口是什么，ip是什么等信息。

8、eureka自我保护机制：
当某个服务不能用了，eureka不会立即清理门户，依旧会保存该微服务的信息，这就是eureka自我保护机制。如果你想当某个服务不能用了，eureka就立即干掉该服务的信息，那么在eureka server中加上相关配置即可。上面的7001和7002都关闭了自我保护，它们的yml中最后那段配置就是这个作用。

四、服务的注册与发现之zookeeper

zookeeper与dubbo天生是一对，springCloud也对zookeeper提供了支持。关于zookeeper，可以参考我zookeeper的文章。下面开始讲如何使用zookeeper代替eureka。
1、首先启动centos上的zookeeper，然后新建名为cloud-provider-payment8004的module：

  • 改pom：

和8001的pom基本一致，只需要将eureka的依赖替换成zookeeper的依赖，并且将mybatis和mysql相关依赖去掉，本项目为了简单些不再连数据库：

<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 // 发现服务
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 "该服务端口号为：" + port;
    }
}
  • 启动payment8004，如果报错了，报zookeeper相关错误，很可能是jar包冲突。也就是spring-cloud-starter-zookeeper-discovery中带的zookeeper的jar包与你服务器安装的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两个节点：

zookeeper

payment8004成功启动后，zookeeper下就会多一个节点，如下：

zookeeper

可以看到多了一个services节点，并且该节点下有我们配置的服务名，说明成功注册到zookeeper中。值得注意的是，zookeeper里的services节点是临时节点，即如果你把payment8004关闭，zookeeper在心跳时间内没有收到回应，就会把该节点干掉。

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

  • pom文件，和8004一样。
  • yml文件，和8004差不多，只是端口变成了80，服务名变成了cloud-consumerzk-order。
  • 主启动类，和8004的一样。
  • 配置类，配置restTemplate，和consumer-order80的一样。
  • controller，通过restTemplate去调用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，返回如下信息则表示调用成功：
通过zookeeper调用成功
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
禁止转载，如需转载请通过简信或评论联系作者。
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 219,110评论 6赞 508
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 93,443评论 3赞 395
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 165,474评论 0赞 356
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,881评论 1赞 295
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,902评论 6赞 392
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,698评论 1赞 305
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,418评论 3赞 419
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 39,332评论 0赞 276
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,796评论 1赞 316
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,968评论 3赞 337
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 40,110评论 1赞 351
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,792评论 5赞 346
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,455评论 3赞 331
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 32,003评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 33,130评论 1赞 272
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 48,348评论 3赞 373
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 45,047评论 2赞 355