spring cloud 学习笔记 服务注册与发现(二)

前言

服务注册与发现的学习。这个其实是微服务的核心了，因为微服务的一个重要理念就是将项目拆分，达到解耦的地步。那么如何把这些服务联系到一起就很关键。

如果一个服务到另外一个服务通过ip地址之间访问，虽然说没有物理层面的耦合，但是呢，这里面有网络层面的耦合。

比如说一家公司有一个软件，那么这个软件里面有一个企业版，这个企业版是部署到客户那里的话，那么代码就得修改，因为代码里面其实有网络耦合，那么这个这样不仅要另外创建一个分支去修改代码，而且维护相当麻烦。

那么怎么弄呢？才能解决代码层面的网络耦合，这时候服务注册与发现就起到了作用。那么问题就来了，那么我如何知道去访问哪个地址？或者说服务地址如何变成动态的，对吧。

那么这个时候就需要建立另外一个服务，那就是注册与发现服务了。这里其实看一下就好，这里我们自己搭建这个服务，在线上k8服务中，其实是有一套自己的服务注册与发现。

用里面的一句话说就是:

在传统的rpc远程调用框架中（remote precedure call【远程调用】 这里补充说一下，这里的rpc 不是说是直接http这种调用方式，具体的后面会补充一张rpc，然后和这种注册与发现对比，就有一些鲜明的地方），管理每个服务与服务之间的依赖关系比较复杂，

所以就需要管理服务与服务之间的关系，就有了这个服务注册与发现，其实就是服务管理。

这里主要看下具体的概念和思路。

正文

放一下图形:

这里我们看到服务与服务之间还是通过这种远程调用的方式来实现，但是呢，就是说这个service Consumer去访问服务的地址是动态的。

service Provider 会在eureka 中进行注册登记，然后这个service Consumer 会在这个eureka中服务进行subscribe， euraka 会进行通知更新服务地址从而达到解耦的地步。所以说微服务的确会消耗更多的资源。

他们的注册方式是通过http这种无状态的服务，但是当他们注册后呢，会进行心跳检测，进行一个长链接，来确定服务是否存活。

建立一个module，这里引用eureka这个服务组件。

上面

pom 如下:

<?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">
    <parent>
        <artifactId>zhifu</artifactId>
        <groupId>org.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-eureka-server7001</artifactId>
    <dependencies>
        <!--eureka server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!--引入公共的Entity-->
        <dependency>
            <groupId>org.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>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
</project>

上面都做了标注，这里就不过多的解释问题了。就是引用如eureka。

然后就是对eureka进行一个配置，配置文件如下:

server:
  port: 7001
eureka:
  instance:
    hostname: localhost #eureka服务端的实例名称
  client:
    #false表示不向注册中心注册自己
    register-with-eureka: false
    #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZ4 one: http://${eureka.instance.hostname}:${server.port}/eureka/

接下来就是main启动类的构建:

package com.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer
public class EurekaMain7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaMain7001.class,args);
    }
}

然后访问localhost:7001，然后就可以看到注册界面了。

上面我们可以看到是没有服务的，那么现在就需要注册前面的支付服务到里面去。

在支付服务中，添加依赖:

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

然后加上eureka 客户端的配置:

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

加上声明:

@EnableEurekaClient
public class PaymentMain8001 {

那么经过这些配置后，我们启动，看下eureka的服务列表有什么变化吗？

这里我们的服务就发生了变化，那么现在就是一个ok的状态了。

下面的问题就是一个服务的调用过程了。同样，service Consumer同样需要去做出订阅。

订单微服务配置如下:

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

同样进行一个注册进服务中去:

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka

当然我们要启动eureka。

在启动项上加上:

@EnableEurekaClient
public class OrderMain80 {

然后再看下变化:

两个服务都已经注册进去了，那么接下来就是就是服务之间的调用了。

这个怎么调用呢?通过服务域名。

把访问地址换成服务名:

public class OrderController {
    private static final String PAYMENT_URL = "http://cloud-provider-service";

    @Resource
    private RestTemplate restTemplate;

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

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

"message": "I/O error on GET request for "http://cloud-provider-service/payment/get/3": cloud-provider-service; nested exception is java.net.UnknownHostException: cloud-provider-service"

然后就报错了，这里写的是不知名的host cloud-provider-service。

那么如何让我们正确去解析到呢？通过:

这里面还有均衡负载的功能，后面我们通过集群来了解。

然后访问一下就正常了。

好吧，这样就可以访问了，那么问题来了，如何实现高可用呢？

最简单的方式就是集群，这里两个地方是需要集群的，第一个是eureka还有一个是service provider。

eureka 集群:

创建module cloud-eureka-server7002

和7001配置一样。

然后再host 中加入：

127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com

然后分别修改一下他们的配置:

然后重新启动一下，这两个东西。

然后

这样他们就形成了相互守望的情况。这个DS Replicas 表示的是同步给哪台机器的意思。

然后我们可以在支付和订单模块中修改配置：

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

对了，如果想测试是否集群了，defaultZone可以只填写一个，比如说 http://eureka7001.com:7001/eureka，看下另外一个http://eureka7002.com:7002/eureka是否同步了。

那么现在注册订阅服务集群了，那么下面就看下service provider 如何集群吧，这里的service provider 特指支付模块。

建立module cloud-provider-payment8002,和cloud-provider-payment8001一样。

这里模拟我们生产环境中的docker。

我们只需要把原来的端口8001改成8002即可。

这样其实我们就已经集群了。

看到下面有两个:

在我们前面增加了这个LoadBalanced，那么我们的订单服务会根据获取的服务集群均衡负载。

为了方便颜色，把8001和8002返回的结果变动一下。

会根据当前不同的端口，返回不同的信息。

同样调用端口，第一次：

第二次：

然后反复的8001和8002这样下去。

结

下面一章介绍如何自定义均衡负载方式。