咸鱼翻身记

springCloud之Nacos

2024/1/11 Nacos

Nacos 是阿里的一个开源产品，它是针对微服务架构中的 服务发现、配置管理、服务治理 的综合性解决方案

Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您实现动态服务发现、服务配置管理、服务及流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。Nacos 是构建以“服务”为中心的现代应用架构(例如微服务范式、云原生范式)的服务基础设施。

Nacos 的四大特性：

  • 服务发现与服务健康检查
  • 动态配置管理
  • 动态DNS服务
  • 服务和元数据管理

# 入门基操

# 1、使用方式

Nacos的使用方式也极其简单，以下为 windows下安装方式

  • 点击下载地址 下载最新稳定版本

    https://github.com/alibaba/nacos/releases

链接：https://pan.baidu.com/s/1jjW_MGVfNukDN9ds4AKd0Q?pwd=f9hv 
提取码：f9hv
    1
    2
    3
    4

  • 配置鉴定密钥

    参考官方文档：https://nacos.io/zh-cn/docs/v2/guide/user/auth.html

conf 目录下修改application.properties文件(2.2.0.1后版本需要)

application.properties文件因为在2.2.0之后的版本是没有给配置默认token.secret.key的需要自己手动添加密钥,可以到官网使用公开的密钥(缺乏安全性)    SecretKey012345678901234567890123456789012345678901234567890123456789

也可以自定义密钥
推荐将配置项设置为Base64编码的字符串，且原始密钥长度不得低于32字符
VGhpc0lzTXlDdXN0b21TZWNyZXRLZXkwMTIzNDU2Nzg=
    1
    2
    3
    4
    5
    6
    7
    8
    9

  • 开启鉴权（可以开启或关闭）

    #参考官方文档：https://nacos.io/zh-cn/docs/v2/guide/user/auth.html
#修改application.properties文件
nacos.core.auth.enabled=true
nacos.core.auth.system.type=nacos
nacos.core.auth.server.identity.key=authKey
nacos.core.auth.server.identity.value=nacosSecurty
    1
    2
    3
    4
    5
    6

  • 配置数据库

    在application.properties文件中还可以配置你自己的数据库，便于持久化管理（去掉下面的注释）

spring.sql.init.platform=mysql
db.num=1
db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=nacos
db.password.0=nacos

如果使用自己的数据库就要创建数据库需要执行 conf/mysql-schema.sql
    1
    2
    3
    4
    5
    6
    7
    8
    9

  • 启动服务器

    两种方式
1、nacos\bin 目录下通过cmd窗口输入
startup.cmd -m standalone  （-m是模式的意思，切换成standalone）

2、点击startup.cmd（需要修改文件中的方式）
#集群方式
set MODE="cluster"
#单机方式
set MODE="standalone"
    1
    2
    3
    4
    5
    6
    7
    8
    9

  • 通过浏览器访问 http://127.0.0.1:8848/nacos 打开 nacos控制台登录页面，默认用户名密码皆为：nacos，登录成功后便可访问主页面。

# 2、扩展使用

# 发布配置

我们可以通过 地址 的方式发布配置：http://127.0.0.1:8848/nacos/v1/cs/configs，使用 postman 进行测试：

# 获取配置

我们可以通过 地址 的方式获取配置：http://127.0.0.1:8848/nacos/v1/cs/configs，使用 postman 进行测试：

# 发布服务

我们可以通过 地址 进行服务注册：http://127.0.0.1:8848/nacos/v1/ns/instance，使用 postman 进行测试：

# 服务发现

我们可以通过 地址 发现服务：http://127.0.0.1:8848/nacos/v1/ns/instance/list，使用 postman 进行测试：

# 配置管理

在上述中我们已经知道Nacos其中的一个功能便是用于配置中心。配置中心是在微服务架构中，当系统从一个单体应用被拆分为分布式系统上一个个服务节点时，配置文件也必须随着迁移而分割，这样配置就分散了，而且各个配置中也存在互相冗余的部分。

配置中心所担任的角色：

配置中心将配置从各应用中剥离出来，对配置进行统一管理，应用自身不需要自己去管理配置

从图中我们总结流程如下：

  • 用户在配置中心更新配置信息
  • A 服务和 B 服务及时得到配置更新通知，从配置中心获取更新

# 1、发布配置

  • 步骤1中我们可以创建命名空间，命名空间（NameSpace）是用于隔离多个环境的（如开发、测试、生产），而每个应用在不同环境的同一配置（如数据库配置）的值是不一样的。
  • 步骤2中我们可以切换不同命名空间来发布不同配置，命名空间下类似 UUID 的一串便是每个命名空间的唯一ID。
  • 步骤3中我们可以点击发布配置，其中 DataId 和 group 是必填项

完成上面三个步骤后我们便可以看到生成了一条刚刚配置过的信息

# 2、获取配置

然后我们在项目中便可读取配置中的内容，步骤如下：

  • 在 pom 文件中引入 nacos-client包：

    <dependency>
    <groupId>com.alibaba.nacos</groupId>
    <artifactId>nacos-client</artifactId>
    <version>1.1.3</version>
</dependency>
    1
    2
    3
    4
    5

  • 通过 nacos-client 包下提供的 API，来获取配置：

    public static void main(String[] args) throws NacosException {
    //使用nacos client远程获取nacos服务上的配置信息
    //nacos server地址
    String serverAddr = "127.0.0.1:8848";
    //data id
    String dataId = "application-dev.properties";
    //group
    String group = "DEFAULT_GROUP";

    //namespace
    String namespace = "dfa1c276-69f7-47d6-9903-6850b9c248f7";
    Properties properties =new Properties();
    properties.put("serverAddr",serverAddr);
    properties.put("namespace",namespace);
    
    //获取配置
    ConfigService configService = NacosFactory.createConfigService(properties);
    
    // String dataId, String group, long timeoutMs
    String config = configService.getConfig(dataId, group, 5000);
    System.out.println(config);
}
/* OUTPUT:
spring.datasource.mysql.driverClassName = com.mysql.cj.jdbc.Driver
*/
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25

  • 配置的管理模型如下图所示：

    • 命名空间（NameSpace）

      命名空间（NameSpace）用于不同环境（开发环境、测试环境和生产环境）的配置隔离。不同的命名空间下，可以存在相同名称的配置分组（Group）或配置集。

    • 配置分组（Group）

      配置分组是对配置集进行分组，不同的配置分组下可以有相同的配置集（DateId）。默认的配置分组名称为 DEFAULT_GROUP。用于区分不同的项目或应用。

    • 配置集（DataId）

      在系统中，一个配置文件通常就是一个 配置集，一个配置集可以包含了系统的各种配置信息，例如一个配置集可能包含了数据源、线程池、日志级别等配置项。每个配置集都可以定义一个有意义的名称。

# 3、分布式配置

在了解通过 Nacos 集中管理多个服务的配置之前，我们先大概了解下以下概念：

# 传统单体架构

所有功能模块打包到一起并放在一个 web 容器中运行，所有功能模块使用同一个数据库。

特点：

  • 开发效率高
  • 容易测试
  • 容易部署

缺点：

  • 复杂性会逐渐变高，维护性逐渐变差
  • 版本迭代逐渐变慢
  • 阻碍技术创新
  • 无法按需伸缩

# 微服务架构

微服务简单来说就是将一个项目拆分成多个服务。每一个微服务都是完整的应用，都有自己的业务逻辑和数据库。每一个业务模块都是用独立的服务完成，这种微服务架构模式也影响了应用和数据库之间的关系，不像传统多个业务模块共享一个数据库，微服务加购每个服务都有自己的数据库。

优点：

  • 分而治之，职责单一
  • 可伸缩
  • 局部容易修改、替换、部署，有利于持续集成和快速迭代
  • 不会受限于任何技术栈

# Nacos

  • 「步骤1 - 发布配置」

    我们在Nacos主页中创建两个配置文件：

    service_a.properties：

    service_b.properties：

  • 「步骤2 - 创建父工程」

    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>cbuc.life</groupId>
    <artifactId>nacos-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <packaging>pom</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56

  • 「步骤3 - 创建子模块」service-a

    pom.xml 如下：

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         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>cbuc-life</groupId>
        <artifactId>nacos-config</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath/>
    </parent>

    <artifactId>service-a</artifactId>

    <dependencies>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

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

    </dependencies>

</project>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30

    bootstrap.yml如下：

    server:
  port: 8081

spring:
  application:
    # 应用名称
    name: service_a
  cloud:
    nacos:
      config:
        # 配置中心地址
        server-addr: 127.0.0.1:8848
        # 配置文件格式（spring.application.name + file-extension = service_a.properties）
        file-extension: properties
        #指定具体的namespace
        namespace: dfa1c276-69f7-47d6-9903-6850b9c248f7
        group: TEST_GROUP
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

  • 「步骤4 - 创建子模块」service-b

    pom.xml 如下：

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         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>cbuc-life</groupId>
        <artifactId>nacos-config</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath/>
    </parent>

    <artifactId>service-b</artifactId>

    <dependencies>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

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

    </dependencies>

</project>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30

    bootstrap.yml如下：

    server:
  port: 8081

spring:
  application:
    # 应用名称
    name: service_b
  cloud:
    nacos:
      config:
        # 配置中心地址
        server-addr: 127.0.0.1:8848
        # 配置文件格式（spring.application.name + file-extension = service_a.properties）
        file-extension: properties
        #指定具体的namespace
        namespace: dfa1c276-69f7-47d6-9903-6850b9c248f7
        group: TEST_GROUP
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

    工程目录结构如下：

    ConfigController如下：

    @RestController
public class ConfigController {
    @Autowired
    ConfigurableApplicationContext configurableApplicationContext;

    @GetMapping("getConfigs")
    public String getConfigs() {
        return configurableApplicationContext.getEnvironment().getProperty("spring.datasource.mysql.url");
    }
}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    service-a运行结果为：

    service-b运行结果为：

    可以看到通过以上步骤成功获取到了我们在nacos中创建配置文件的内容。

    其中我们需要注意关键的步骤为：

    • 引入 spring-cloud-alibaba-dependencies 和 spring-cloud-starter-alibaba-nacos-config 的 jar包。
    • 我们在 resources 下创建的配置文件必须是 bootstrap 而不能是 application
    • bootstrap.yml中的配置

  • bootstrap.yml另有玄机?

    我们在上面看到配置核心点在于：

    spring:
  application:
    name: service_a
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848                     # 配置中心地址
        # spring.application.name + file-extension = service_a.properties
        file-extension: properties                      # dataid名称的后缀
        namespace: dfa1c276-69f7-47d6-9903-6850b9c248f7 # 指定具体的namespace
        group: TEST_GROUP
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    这个是读取指定配置组下的指定配置，我们都知道开发讲究高内聚低耦合，如果有相同的配置项我们可以独立抽取成一个文件，这样我们就得引入多个配置文件，当然nacos也是支持的，配置如下：

    spring:
  application:
    name: service_a
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848                     # 配置中心地址
        # spring.application.name + file-extension = service_a.properties
        file-extension: properties                      # dataid名称的后缀
        namespace: dfa1c276-69f7-47d6-9903-6850b9c248f7 # 指定具体的namespace
        group: TEST_GROUP
        # 通过 ext-config 来配合使用
        ext-config[0]:
          data-id: service-common_1.properties
        ext-config[1]:
          data-id: service-common_2.properties
          group: GLOBALE_GROUP
        ext-config[2]:
          data-id: service-common_3.properties
          group: REFRESH_GROUP
          refresh: true  #动态刷新配置
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21

    注意ext-config 得从 0 开始，其中 「refresh」 标签用来实现动态刷新，就是配置文件修改后，项目不用重启也能实时读取最新的配置文件。

    可能你会觉得通过 ext-config 有点麻烦，需要写那么多，为了简化我们还可以使用 shared-dataids 和 refreshable-dataids 实现同上一样的功能，如下：

    spring:
  application:
    name: service_a
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848                     # 配置中心地址
        # spring.application.name + file-extension = service_a.properties
        file-extension: properties                      # dataid名称的后缀
        namespace: dfa1c276-69f7-47d6-9903-6850b9c248f7 # 指定具体的namespace
        group: TEST_GROUP
        
        shared-dataids: service-common_1.properties,service-common_2.properties,service-common_3.properties
        refreshable-dataids: service-common_3.properties
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

    通过 shared-dataids 来支持多个共享 Data Id 的配置，多个之间用逗号隔开。通过 refreshable-dataids 来支持哪些共享配置的 Data Id 在配置变化时，应用中是否可动态刷新，感知到最新的配置值，多个 Data Id 之间用逗号隔开。如果没有明确配置，默认情况下所有共享配置的 Data Id 都不支持动态刷新。

  • 配置项的优先级

    #方式1
file-extension: properties                      # dataid名称的后缀
namespace: dfa1c276-69f7-47d6-9903-6850b9c248f7 # 指定具体的namespace
group: TEST_GROUP

#方式2
ext-config[0]:
data-id: service-common_1.properties
ext-config[1]:
data-id: service-common_2.properties
group: GLOBALE_GROUP
ext-config[2]:
data-id: service-common_3.properties
group: REFRESH_GROUP
refresh: true  #动态刷新配置

#方式3
shared-dataids: service-common_1.properties,service-common_2.properties,service-common_3.properties
refreshable-dataids: service-common_3.properties
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19

    以上我们了解到了 nacos 有三种配置方式，其中优先级：

    方式1 > 方式2（内部比较：n越大，优先级越高） > 方式3

# 服务发现

# 1、什么是服务发现

在微服务架构中，整个系统会按职责划分为多个服务，通过服务之间且做来实现业务目标。这样在我们的代码中免不了要进行服务间的远程调用，服务的消费方要调用服务的生产方，为了完成这一次请求，消费方需要知道服务生产方的网络位置（「IP地址和端口号」）

# 服务发现中心对比

对比项目 Nacos Eureka Consul ZooKeeper
一致性协议 支持 AP 和 CP 模型 AP 模型 CP模型 CP模型
健康检查 TCP/HTTP/MYSQL/Client Beat Client Beat TCP/HTTP/gRPC/Cmd Keep Alive
负载均衡器 权重/metadate/Selector Ribbon Fabio -
雪崩保护 有 有 无 无
自动注销实例 支持 支持 不支持 支持
访问协议 HTTP/DNS HTTP HTTP/DNS TCP
监听支持 支持 支持 支持 支持
多数据中心 支持 支持 支持 不支持
跨注册中心同步 支持 不支持 支持 不支持
SpringCloud集成 支持 支持 支持 不支持
Dubbo 集成 支持 不支持 不支持 支持
K8s 集成 支持 不支持 支持 不支持

# 2、服务发现入门

  • 步骤1 - 新建父工程

    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>cbuc.life</groupId>
    <artifactId>nacos-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <modules>
        <module>service-provider</module>
        <module>service-consumer</module>
    </modules>
    <packaging>pom</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59

  • 步骤2 - 新建服务生产者

    pom.xml如下：

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>nacos-service</groupId>
        <artifactId>cbuc.life</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service-provider</artifactId>

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

</project>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32

    application.yml如下：

    server:
  port: 8084

spring: 
  application:
    # 应用名称
    name: service-provider
  cloud:
    nacos:
      discovery:
        # 服务注册地址
        server-addr: 127.0.0.1:8848
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    启动类如下：

    @SpringBootApplication
//服务注册
@EnableDiscoveryClient
//使用Feign
@EnableFeignClients
public class ServiceProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServiceProviderApplication.class,args);
    }
}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    ProviderController.java如下：

    @RestController
public class ProviderController {

    @GetMapping(value = "/getData")
    public String getData() {
        return "provider provider ---";
    }
}
    1
    2
    3
    4
    5
    6
    7
    8

    以上便是生成者的代码，其中关键点在于：

    • 1. 引入 spring-cloud-starter-alibaba-nacos-discovery jar包

    • 2. 在启动类标注 @EnableDiscoveryClient 注解

    • 3. 在 application.yml 中配置nacos服务中心的地址

    • 4. 在 controller 中暴露服务

  • 步骤3 - 新建服务消费者

    pom.xml如下：

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>nacos-service</groupId>
        <artifactId>cbuc.life</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service-consumer</artifactId>

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

</project>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32

    application.yml如下：

    server:
  port: 8083

spring: 
  application:
    # 应用名称
    name: service-consumer
  cloud:
    nacos:
      discovery:
        # 服务注册地址
        server-addr: 127.0.0.1:8848
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    启动类如下：

    @SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class ServiceConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceConsumerApplication.class, args);
    }
}
    1
    2
    3
    4
    5
    6
    7
    8

    ConsumerController.java如下：

    @RestController
public class ConsumerController {

    @GetMapping(value = "/consumer")
    public String consumer() {
        RestTemplate restTemplate = new RestTemplate();
        String forObject = restTemplate.getForObject("http://localhost:8084/getData", String.class);
        return "consumer consumer ---" + forObject;
    }
}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    以上便是消费者的代码，其中关键点在于：

    • 1. 引入 spring-cloud-starter-alibaba-nacos-discovery jar包

    • 2. 在启动类标注 @EnableDiscoveryClient 注解

    • 3. 在 application.yml 中配置nacos服务中心的地址

    • 4. 在 controller 中使用RestTemplate 调用服务。

以上我们可以看到在Nacos中注册了两个服务，分别是 service-provider 和 service-consumer，我们也可以在Nacos控制台看到：

同样，服务注册也支持命名空间的隔离，我们只需在application.yml中添加配置：

server:
  port: 8083

spring:
  application:
    name: service-consumer
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        # 命名空间
        namespace: dfa1c276-69f7-47d6-9903-6850b9c248f7
        cluster-name: DEFAULT
1
2
3
4
5
6
7
8
9
10
11
12
13

# 3、Feign 的使用

Feign是Netflix开发的声明式、模板化的HTTP客户端，Feign可以帮助我们更快捷、优雅地调用HTTP API。

  • 步骤1

    声明 Feign 客户端：

    @FeignClient(value = "service-provider") //生产者名称
public interface ConsumerService {

    @GetMapping("/getData")
    String getDate();
}
    1
    2
    3
    4
    5
    6

  • 步骤2

    在 启动类 添加 @EnableFeignClients 注解

  • 步骤3

    在 controller 层进行调用：

    @RestController
public class ConsumerController {

    @Autowired
    private ConsumerService consumerService;

    @GetMapping("/getData")
    public String getData() {
        String date = consumerService.getDate();
        return "consumer consumer ---" + date;
    }
}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12