3. nacos服务发现

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

        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        
        <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步骤和创建服务生产者是一样的

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

1. 修改pom文件, 引入服务发现, feign, 和spring boot web
```
<dependencies>
        
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
    </dependencies>
```
2. 添加application.yml配置文件

指定服务端口号, nacos服务的地址
```
server:
  port: 56010
spring:
　application: 
    name: consumer

  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;

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

    public static void main(String[] args) {
        SpringApplication.run(CustomerApplication.class, args); } }
```
4. productor生产者远程代理定义
```
package com.lxl.www.nacos.feign.client;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "productor")
public interface ProductorFeign {

    @GetMapping("/productor/service")
    String service();

}
```
5. 通过feign调用productor的的接口
```
package com.lxl.www.nacos.controller;

import com.lxl.www.nacos.feign.client.ProductorFeign;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/")
public class ConsumerController {
    @Autowired
    private ProductorFeign productorFeign;


    @GetMapping("consumer")
    public String cunsumer() {
        String service = productorFeign.service();
        System.out.println(service);
        return service;
    }

}
```
6. 启动服务, 查看nacos客户端, 并调用接口测试

nacos生产上已经注册发现了两题服务

同时调用接口, 可以获取到productor返回的内容.

4.4 spring cloud的默认负载均衡方式--轮询

我们可以通过启动多个服务的方式, 来测试服务的负载均衡策略.

1. 修改productor的启动端口号为动态端口号. 目的是方便启动的时候动态配置端口号, 启动集群

2. 修改配置, 添加动态端口号

vm options配置中设置动态端口号为-Dport=56010, 56011. 点击复制按钮, 可以增加一个应用, 然后配置参数后, 启动两个应用.

3. 在nacos控制台查看启动效果

我们看到, nacos的productor 有两台服务实例. 点击详情可查看具体的服务实例信息:

4. 调用consumer的接口, 访问productor, 默认采用轮询的负载均衡算法

　　http://localhost:56020/consumer

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

nacos的注册发现是一种三层模型: 即服务--集群--实例.如下图:

nacos最外层是服务. 最里层是多台实例. 多个实例之间组成一个服务集群.

5.1 命名空间

命名空间不仅适用于配置管理, 同样适用于服务发现. namespace的常用场景之一是不同环境的配置隔离.如: 开发, 生成, 测试环境资源的隔离.

productor启动了两个实例, 点击详情进去可以看到他是一个集群. 集群里有两台实例.

5.2 服务.

　　在命名空间下, 有各个服务.比如我们上面定义的是在public命名空间下, 定义了两个服务. 一个是productor, 一个是consumer.

　　服务有服务名和实例. 远程调用的时候, 需要指定服务名.

5.3 实例

　　实例是基于网络协议通讯, 所以必须要有一个ip:端口号

5.4 元信息

　　在及群里点击某一个实例-->编辑, 可以看到如下页面, 可以设置元信息

　　

　　那么元信息是什么呢? 每台服务器都可能会设置自己的个性化的信息. 这就是每台服务器的元数据信息

5.5 实操---指定集群的命名空间为dev

只需要在配置中增加命名空间就可以了.

我们也可以修改集群的名字, 集群的默认名字是DEFAULT. 我们这里将其修改为default. 在控制台dev命名空间下, 可以看到启动了服务customer.

　　

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
相关阅读:
css3
ubuntu /mac 终端命令大全
 MarkDown的语法的简要规则
 向github上传一个项目
 datatable 去掉默认功能
 datatable 自定义筛选
 vuex
es6入门教程
 datatable 指定添加排序,根据列的值来设置颜色
 在ios上块点击出现闪黑底
原文地址：https://www.cnblogs.com/ITPower/p/12651152.html

3. nacos服务发现

nacos基础文章3篇

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

一. nacos服务发现的原理

二. spring cloud服务协作流程

2.1 服务负载均衡 -- Ribbon

服务端负载均衡

客户端负载均衡

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

三. 搭建nacos服务端

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

4.1 搭建父工程.

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

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

2. 添加application.yml配置文件

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

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

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

4.3 创建一个服务消费者.

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

2. 添加application.yml配置文件

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

4. productor生产者远程代理定义

5. 通过feign调用productor的的接口

6. 启动服务, 查看nacos客户端, 并调用接口测试

4.4 spring cloud的默认负载均衡方式--轮询

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

5.1 命名空间

nacos基础文章3篇