3. nacos服务发现

nacos基础文章3篇

第一篇. nacos初识, 和eureka的比较, 在docker上安装nacos: https://www.cnblogs.com/ITPower/p/12624248.html

第二篇. nacos服务配置中心: https://www.cnblogs.com/ITPower/p/12630193.html

第三篇. nacos服务发现 :https://www.cnblogs.com/ITPower/p/12651152.html

本文讲解以下几个方面的内容:

1. nacos服务发现原理

2. spring cloud服务协作流程

3.搭建nacos服务端

4. 搭建nacos服务发现客户端

5. nacos服务发现的数据模型

一. nacos服务发现的原理

有两个微服务A和B, A调用B, 那么A是如何调用B的呢?我们可以通过http请求,进行调用. 也可以使用rpc进行调用.

不管使用什么方式, A需要知道B的地址和端口号. 那么A是如何知道B的地址和端口好的呢? 如上图:

1. B服务启动的时候, 会注册到服务发现中心, 告诉他,我的ip和端口号是什么?这里应该也是接口调用,通知服务发现中心的.

2. A服务启动的时候, 也会注册的服务发现中心, 告诉他, 我的ip和端口号是什么? 同时, 服务发现中心会告诉我, 当前已注册的服务的ip和端口号. 这里通过一个接口请求和参数返回就可以实现.

3. 拿到了B服务的ip和port, 接下来就可以调用服务B了.

二. spring cloud服务协作流程

我们要基于spring cloud生态环境进行开发. 所以,先来了解spring cloud的服务写作流程

前面注册和发现就都不说了, 上面说过了, 这里多了两个东西, 一个是Ribbon, 另一个是feign.

Ribbon是负载均衡器, Feign是远程调用, 自动进行http请求.

2.1 服务负载均衡 -- Ribbon

客户端Service A 要调用ServiceB的实例1和实例2. 那么到底调用ServiceB的哪个实例呢? 使用Ribbon负载均衡, 要看使用什么样的算法了, 可以使用轮询算法, 或者其他算法, 如加权算法

负载均衡有两种: 服务端负载均衡, 客户端负载均衡

服务端负载均衡

　　　　在负载均衡中维护一个可用的服务实例清单, 当客户端请求来临时, 负载均衡服务器按照某种配置好的规则(负载均衡算法), 从可用服务实例清单中, 选取其一去处理客户端请求, 这就是服务端负载均衡, 例如Nginx. 通过nginx进行负载均衡, 客户端发送请求值Nginx, nginx通过负载均衡算法, 在多个服务器之间选择一个进行访问.

客户端负载均衡

　　　　接下来, 我们要讲的ribbon, 就属于客户端负载均衡, 在ribbon客户端会有一个服务实例地址列表, 在发送请求前, 通过负载均衡算法, 选择一个服务实例, 然后进行访问, 这是客户端负载均衡. 即在客户端进行负载均衡算法分配.

　　　　服务的调用方, 我们就可以理解为是一个客户端.

　　　　负载均衡算法:

　　　　可通过下面的方式, 在spring boot配置中修改默认的负载均衡的策略

account-service.ribbon.NFLoadBalanceRuleClassName=com.netflix.loadBalancer.RandomRule

　　　其中: account-service: 是调用的服务的名称. 后面的组成部分是固定的.

2.2 服务间接口的调用---Feign

　　feign是服务端http接口的调用.

　　feign可以帮助我们更快捷, 优雅的调用httpApi. 原来我们在调用http请求的时候, 需要使用的是RestTemplate, 传输域名和端口号, 进行http调用. 使用feign后, 不用再使用RestTemplate模拟请求了, feign能够通过服务名, 找到对应的接口. 不需要我们在拼接地址+端口了, 提供了简单方便的操作.

　　使用方法:

1. 在Service B定义一个接口

　　2. 声明feign客户端

　　新建一个类, 声明为FeignClient类型的接口. 指定调用的服务名. 然后将指定接口. 这样在调用的时候, 就可以通过服务名, + 接口, 自动找到对应的项目接口了. 　　

三. 搭建nacos服务端

　　这里上一节已经搭建过了(地址: https://www.cnblogs.com/ITPower/articles/12630193.html), 在服务的最后, 我们搭建了nacos的集群

四. 搭建nacos服务发现客户端

　　因为对于服务发现来说, 有很多配置都是公用的, 因此, 我们搭建一个父工程, 将通用的配置都添加到里面取.

4.1 搭建父工程.

创建一个maven工厂, 引入jar包即可. 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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lxl.www</groupId>
    <artifactId>parent-discovery</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- 这是一个父类工程, 所以, 需要设置打包类型为pom -->
    <packaging>pom</packaging>

    <properties>
        <project.build.sourceEncodding>UTF-8</project.build.sourceEncodding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- 这里我们使用的是alibaba的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>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.1.3.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>

    </dependencyManagement>


</project>

4.2 创建一个服务提供者, 也就是生产者.

在父工程下创建一个子工程. 我们要做一下三件事

1. 修改pom文件, 引入服务发现, feign, 和spring boot web

<dependencies>
        <!-- 引入服务发现的包 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!-- 定义接口访问, 引入spring boot web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 服务之间http调用, 引入feign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
    </dependencies>

2. 添加application.yml配置文件

指定服务端口号, nacos服务的地址

server:
  port: 56010
spring:
  application:
    name: productor
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848  #nacos的服务器地址
logging:
  level:
    root: info
    org.springframework: info

3. 定义一个启动类, 用来启动spring boot新项目

需要增加两个引入. 1个启用服务发现, 另一个是启用feign

package com.lxl.www.nacos;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

import javax.swing.*;

@SpringBootApplication
// 引入服务发现
@EnableDiscoveryClient
// 使用feign接口调用
@EnableFeignClients
public class ProductorApplication {

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

4. 定义一个controller, 写一个接口

package com.lxl.www.nacos.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/productor")

public class ProductorController {

    @GetMapping("/service")
    public String service() {
        System.out.println("provider invoke");
        return "provider invoke";
    }

}

5. 启动程序, 在nacos中查看服务注册列表

最终项目结构如下:

4.3 创建一个服务消费者.

其中前3步骤和创建服务生产者是一样的