Stream + Nacos

父工程准备

工程编码

注解生效激活

Java 编译版本 8

File Type 过滤

pom.xml

父工程创建完成执行 mvn:install 将父工程发布到仓库方便子工程继承

<groupId>com</groupId>
<artifactId>cloud</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>

<!-- 统一管理jar包版本 -->
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <junit.version>4.12</junit.version>
    <log4j.version>1.2.17</log4j.version>
    <lombok.version>1.16.18</lombok.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不用写version和groupId -->
<dependencyManagement>
    <dependencies>
        <!-- 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 alibaba 2.1.0.RELEASE -->
        <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>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.spring.boot.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </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>

SpringCloud Stream消息驱动

1、概述

什么是SpringCloudStream？

一句话，屏蔽底层消息中间件的差异，降低切换成本，统一消息的编程模型

官方定义 Spring Cloud Stream 是一个构建消息驱动微服务的框架。 应用程序通过 inputs 或者 outputs 来与 Spring Cloud Stream中binder对象交互。通过我们配置来binding（绑定） ，而 Spring Cloud Stream 的 binder对象负责与消息中间件交互

所以，我们只需要搞清楚如何与 Spring Cloud Stream 交互就可以方便使用消息驱动的方式。 通过使用 Spring Integration 来连接消息代理中间件以实现消息事件驱动。Spring Cloud Stream 为一些供应商的消息中间件产品提供了个性化的自动化配置实现，引用了发布-订阅、消费组、分区的三个核心概念。目前仅支持RabbitMQ、Kafka

Spring Cloud Stream是用于构建与共享消息传递系统连接的高度可伸缩的事件驱动微服务框架，该框架提供了一个灵活的编程模型，它建立在已经建立和熟悉的Spring熟语和最佳实践上，包括支持持久化的发布/订阅、消费组以及消息分区这三个核心概念

官网：

https://spring.io/projects/spring-cloud-stream#overview

https://cloud.spring.io/spring-cloud-static/spring-cloud-stream/3.0.1.RELEASE/reference/html/

Spring Cloud Stream中文指导手册：

https://m.wang1314.com/doc/webapp/topic/20971999.html

为什么用？

比方说我们用到了RabbitMQ和Kafka，由于这两个消息中间件的架构上的不同，像RabbitMQ有exchange，kafka有Topic和Partitions分区， 这些中间件的差异性导致我们实际项目开发给我们造成了一定的困扰，我们如果用了两个消息队列的其中一种，后面的业务需求，我想往另外一种消息队列进行迁移，这时候无疑就是一个灾难性的，一大堆东西都要重新推倒重新做，因为它跟我们的系统耦合了，这时候springcloud Stream给我们提供了一种解耦合的方式。

stream凭什么可以统一底层差异？

在没有绑定器这个概念的情况下，我们的SpringBoot应用要直接与消息中间件进行信息交互的时候，由于各消息中间件构建的初衷不同，它们的实现细节上会有较大的差异性。通过定义绑定器作为中间层，完美地实现了应用程序与消息中间件细节之间的隔离。通过向应用程序暴露统一的Channel通道，使得应用程序不需要再考虑各种不同的消息中间件实现。通过定义绑定器Binder作为中间层，实现了应用程序与消息中间件细节之间的隔离。

Binder ：

Stream对消息中间件的进一步封装，可以做到代码层面对中间件的无感知，甚至于动态的切换中间件（rabbitmq切换为kafka），使得微服务开发的高度解耦，服务可以关注更多自己的业务流程。通过定义绑定器Binder作为中间层，实现了应用程序与消息中间件细节之间的隔离。Binder可以生成Binding，Binding用来绑定消息容器的生产者和消费者，它有两种类型，INPUT和OUTPUT，INPUT对应于消费者，OUTPUT对应于生产者。

Spring Cloud Stream标准流程套路

• Binder

  很方便的连接中间件，屏蔽差异

• Channel

  通道，是队列Queue的一种抽象，在消息通讯系统中就是实现存储和转发的媒介，通过Channel对队列进行配置

• Source和Sink

  简单的可理解为参照对象是Spring Cloud Stream自身，从Stream发布消息就是输出，接受消息就是输入

编码 API 和常用注解

2、案例

2.1 消息驱动之生产者

pom.xml

<parent>
    <artifactId>cloud</artifactId>
    <groupId>com</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>cloud-stream-rabbitmq-provider8801</artifactId>

<dependencies>
    <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.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-stream-rabbit</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>
        <scope>test</scope>
    </dependency>
</dependencies>

配置文件

server:
  port: 8801

spring:
  application:
    name: cloud-stream-provider
  cloud:
    stream:
      binders: # 在此处配置要绑定的rabbitmq的服务信息；
        defaultRabbit: # 表示定义的名称，用于于binding整合
          type: rabbit # 消息组件类型
          environment: # 设置rabbitmq的相关的环境配置
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings: # 服务的整合处理
        output: # 这个名字是一个通道的名称
          destination: studyExchange # 表示要使用的Exchange名称定义
          content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain”
          binder: {defaultRabbit} # 设置要绑定的消息服务的具体设置

eureka:  
  client: # 客户端进行Eureka注册的配置
    service-url: 
      defaultZone: http://localhost:7001/eureka 
   instance: 
     lease-renewal-interval-in-seconds: 2 # 设置心跳的时间间隔（默认是30秒） 
     lease-expiration-duration-in-seconds: 5 # 如果现在超过了5秒的间隔（默认是90秒） 
     instance-id: send-8801.com  # 在信息列表时显示主机名称 
     prefer-ip-address: true     # 访问的路径变为IP地址

启动类

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

业务类

发送消息接口

public interface IMessageProvider {
    public String send();
}

发送消息接口实现类

import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Source;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.MessageChannel;
import javax.annotation.Resource;
import java.util.UUID;

@EnableBinding(Source.class) // 可以理解为是一个消息的发送管道的定义
public class MessageProviderImpl implements IMessageProvider {
    @Resource
    private MessageChannel output; // 消息的发送管道

    @Override
    public String send() {
        String serial = UUID.randomUUID().toString();
        this.output.send(MessageBuilder.withPayload(serial).build()); // 创建并发送消息
        System.out.println("***serial: " + serial);
        return serial;
    }
}

Controller

@RestController
public class SendMessageController {
    @Resource
    private IMessageProvider messageProvider;

    @GetMapping(value = "/sendMessage")
    public String sendMessage() {
        return messageProvider.send();
    }
} 

测试

1. 启动 7001eureka

2. 启动 rabbitmq

   访问 http://localhost:15672/

   用户、密码：guest

3. 启动 cloud-stream-rabbitmq-provider8801

4. 访问

   http://localhost:8801/sendMessage

2.2 消息驱动之消费者

pom.xml

<parent>
    <artifactId>cloud</artifactId>
    <groupId>com</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>cloud-stream-rabbitmq-consumer8802</artifactId>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-stream-rabbit</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>
        <scope>test</scope>
    </dependency>
</dependencies>

配置文件

server:
  port: 8802

spring:
  application:
    name: cloud-stream-consumer
  cloud:
    stream:
      binders: # 在此处配置要绑定的rabbitmq的服务信息；
        defaultRabbit: # 表示定义的名称，用于于binding整合
          type: rabbit # 消息组件类型
          environment: # 设置rabbitmq的相关的环境配置
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings: # 服务的整合处理
        input: # 这个名字是一个通道的名称
          destination: studyExchange # 表示要使用的Exchange名称定义
          content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain”
          binder: {defaultRabbit} # 设置要绑定的消息服务的具体设置

eureka:
  client: # 客户端进行Eureka注册的配置
    service-url:
      defaultZone: http://localhost:7001/eureka
   instance:
     lease-renewal-interval-in-seconds: 2 # 设置心跳的时间间隔（默认是30秒）
     lease-expiration-duration-in-seconds: 5 # 如果现在超过了5秒的间隔（默认是90秒）
     instance-id: receive-8802.com  # 在信息列表时显示主机名称
     prefer-ip-address: true     # 访问的路径变为IP地址

启动类

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

业务类

controller

@Component
@EnableBinding(Sink.class)
public class ReceiveMessageListener {
    @Value("${server.port}")
    private String serverPort;

    @StreamListener(Sink.INPUT)
    public void input(Message message) {
        System.out.println("消费者1号，------->接收到的消息：" + message.getPayload() + "\t port: " + serverPort);
    }
}

测试

8801 发送 8802 接收消息

访问 http://localhost:8801/sendMessage

3、分组消费与持久化

3.1 搭建 cloud-stream-rabbitmq-consumer8803

依照8802，clone出来一份运行8803

pom.xml 文件与 8802 一模一样

配置文件

server:
  port: 8803

spring:
  application:
    name: cloud-stream-consumer
  cloud:
    stream:
      binders: # 在此处配置要绑定的rabbitmq的服务信息；
        defaultRabbit: # 表示定义的名称，用于于binding整合
          type: rabbit # 消息组件类型
          environment: # 设置rabbitmq的相关的环境配置
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings: # 服务的整合处理
        input: # 这个名字是一个通道的名称
          destination: studyExchange # 表示要使用的Exchange名称定义
          content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain”
          binder: {defaultRabbit} # 设置要绑定的消息服务的具体设置

eureka:
  client: # 客户端进行Eureka注册的配置
    service-url:
      defaultZone: http://localhost:7001/eureka
   instance:
     lease-renewal-interval-in-seconds: 2 # 设置心跳的时间间隔（默认是30秒）
     lease-expiration-duration-in-seconds: 5 # 如果现在超过了5秒的间隔（默认是90秒）
     instance-id: receive-8803.com  # 在信息列表时显示主机名称
     prefer-ip-address: true     # 访问的路径变为IP地址

启动类

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

业务类

@Component
@EnableBinding(Sink.class)
public class ReceiveMessageListener {
    @Value("${server.port}")
    private String serverPort;

    @StreamListener(Sink.INPUT)
    public void input(Message message) {
        System.out.println("消费者2号，------->接收到的消息：" + message.getPayload() + "\t port: " + serverPort);
    }
}

3.2 启动

1. 启动 RabbitMQ
2. 启动服务注册 7001 Eureka
3. 启动 8801 消息生产
4. 启动 8802、8803 消息消费

3.3 问题

1. 有重复消费问题

   1. 当访问 http://localhost:8801/sendMessage 发送信息时，两个消费者同时都收到重复消息

   2. 如何解决

      分组和持久化属性group

   3. 生产实际案例

      比如在如下场景中，订单系统我们做集群部署，都会从RabbitMQ中获取订单信息，那如果一个订单同时被两个服务获取到，那么就会造成数据错误，我们得避免这种情况。

      这时我们就可以使用 Stream 中的消息分组来解决。注意在Stream中处于同一个 group 中的多个消费者是竞争关系，就能够保证消息只会被同一个组中其中一个应用消费一次。不同组可以重复消费 （全面消费），同一组内会发生竞争关系，只有其中一个可以消费。

2. 消息持久化问题

3.4 分组

• 原理 ：

  微服务应用放置于同一个group中，就能够保证消息只会被其中一个应用消费一次。

  不同的组是可以消费的，同一个组内会发生竞争关系，只有其中一个可以消费。

• 不同组情况：修改两个消费者服务的 yml 配置文件，分别定义不同的组名

  group: firstA
  group: secondB
  

  

  结论：重复消费

• 同一组情况：修改 配置文件

  group: firstA
  group: firstA
  

  结论：同一个组的多个微服务实例，每次只会有一个拿到

3.5 消息持久化

停止 8802/8803 服务， 并去除掉 8802 的分组 group: firstA， 但是 8803 的分组 group: firstA 没有去掉

8801先发送 4 条消息到 rabbitmq

先启动 8802 ，无分组属性配置，后台没有打出来消息

再启动 8803 ，有分组属性配置，后台打出来了MQ上的消息

8802 启动后相当于重新订阅了一个新的队列，所以没有消息。8803 则是订阅了之前的队列，之前的队列没有被删除，所以是有消息的

重新启动 8802 不指定分组，没加分组配置启动就会有新的临时队列，在新的队列里面自然消费不到消息

Nacos 注册和配置中心

1、下载

Nacos：Naming Configuration Service

官网下载：https://nacos.io/zh-cn/

选择版本：

GitHub网址：https://github.com/alibaba/Nacos

官网：https://nacos.io/zh-cn/index.html

https://spring-cloud-alibaba-group.github.io/github-pages/greenwich/spring-cloud-alibaba.html#_spring_cloud_alibaba_nacos_discovery

运行：

新版的 Nacos 默认启动方式是集群，需要改成单击才能启动

解压安装包， bin 目录下启动cmd命令窗口，直接运行 bin 目录下的startup.cmd

startup.cmd -m standalone

命令运行成功后直接访问 http://localhost:8848/nacos

默认账号密码都是 nacos

报错

若是启动失败，可删除 bin 目录下的 logs、work 两个目录，再重启 nacos

报错：Consider defining a bean of type ‘com.netflix.client.config.IClientConfig‘ in your configuration

它底层应该是有个扫描代码的方法，错误扫到我们项目中com下发现有“com.netflix.client.config.IClientConfig”类型的 bean，于是报错

于是把 com 改成 阿菲 ，项目就能启动了

2、Nacos作为服务注册中心演示

官方文档：

https://spring-cloud-alibaba-group.github.io/github-pages/greenwich/spring-cloud-alibaba.html#_spring_cloud_alibaba_nacos_config

2.1 服务提供者

新建 module：nacos-provider-payment9001

pom.xml

父 pom

<!-- spring cloud alibaba 2.1.0.RELEASE -->
<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>

本模块 pom

<parent>
    <artifactId>cloud</artifactId>
    <groupId>com</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>nacos-provider-payment9001</artifactId>

<dependencies>
    <!-- SpringCloud ailibaba nacos  -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <!--  SpringBoot整合Web组件  -->
    <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>
    <!-- 日常通用jar包配置 -->
    <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>
        <scope>test</scope>
    </dependency>
</dependencies>

配置文件

server: 
  port: 9001
  
spring: 
  application: 
    name: nacos-payment-provider 
  cloud: 
    nacos: 
      discovery: 
        server-addr: localhost:8848 #配置Nacos地址

management: 
  endpoints: 
    web: 
      exposure: 
        include: '*' 

主启动类

@EnableDiscoveryClient
@SpringBootApplication
public class PaymentMain9001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain9001.class, args);
    }
} 

业务类

@RestController
public class PaymentController {
    @Value("${server.port}")
    private String serverPort;

    @GetMapping(value = "/payment/nacos/{id}")
    public String getPayment(@PathVariable("id") Integer id) {
        return "nacos registry, serverPort: " + serverPort + "\t id" + id;
    }
} 

测试

访问：http://localhost:9001/payment/nacos/1

打开 nacos 控制台，nacos服务注册中心+服务提供者9001都OK了

参照 9001 新建 9002 ，为了演示 nacos 的负载均衡

或者取巧不想新建重复体力劳动，直接拷贝虚拟端口映射，如下图所示

2.2 服务消费者

新建 module：nacos-consumer-order83

pom.xml

为什么 nacos 支持负载均衡？因为依赖内部集成了 ribbon

配置文件

server: 
  port: 83

spring: 
  application: 
    name: nacos-order-consumer 
  cloud: 
    nacos: 
      discovery: 
        server-addr: localhost:8848

#消费者将要去访问的微服务名称(注册成功进nacos的微服务提供者)
service-url: 
  nacos-user-service: http://nacos-payment-provider 

主启动类

@EnableDiscoveryClient
@SpringBootApplication
public class OrderNacosMain83 {
    public static void main(String[] args) {
        SpringApplication.run(OrderNacosMain83.class, args);
    }
}

ribbon负载均衡配置类

@Configuration
public class ApplicationContextBean {
    @Bean
    @LoadBalanced  //开启负载均衡
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

业务类

@RestController
public class OrderNacosController {
    @Resource
    private RestTemplate restTemplate;
    @Value("${service-url.nacos-user-service}")
    private String serverURL;

    @GetMapping("/consumer/payment/nacos/{id}")
    public String paymentInfo(@PathVariable("id") Long id) {
        return restTemplate.getForObject(serverURL + "/payment/nacos/" + id, String.class);
    }
}

测试

nacos控制台

浏览器访问：http://localhost:83/consumer/payment/nacos/13

发现 83 访问 9001/9002 ，是轮询负载

2.3 服务注册中心对比

各种注册中心比较

nacos 和 CAP

Nacos 支持AP和CP模式的切换

C 是所有节点在同一时间看到的数据是一致的；

而A的定义是所有的请求都会收到响应。

何时选择使用何种模式？

一般来说，如果不需要存储服务级别的信息且服务实例是通过 nacos-client 注册，并能够保持心跳上报，那么就可以选择AP模式。当前主流的服务如 Spring cloud 和 Dubbo 服务，都适用于AP模式，AP模式为了服务的可能性而减弱了一致性，因此 AP 模式下只支持注册临时实例。

如果需要在服务级别编辑或者存储配置信息，那么 CP 是必须，K8S 服务和DNS服务则适用于CP模式。CP 模式下则支持注册持久化实例，此时则是以 Raft 协议为集群运行模式，该模式下注册实例之前必须先注册服务，如果服务不存在，则会返回错误。

切换需要使用 Curl

curl -X PUT '$NACOS_SERVER:8848/nacos/v1/ns/operator/switches?entry=serverMode&value=CP'

3、Nacos作为服务配置中心演示

3.1 Nacos作为配置中心-基础配置

新建 module：nacos-config-client3377

pom.xml

<parent>
    <artifactId>cloud</artifactId>
    <groupId>com</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>nacos-config-client3377</artifactId>

<dependencies>
    <!-- nacos-config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
    <!-- nacos-discovery -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <!-- 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>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

配置文件

需要配置两个配置文件

Nacos 同 springcloud-config 一样，在项目初始化时，要保证先从配置中心进行配置拉取，拉取配置之后，才能保证项目的正常启动。

springboot 中配置文件的加载是存在优先级顺序的，bootstrap 优先级高于 application

1. bootstrap.yml

   # nacos配置
   server:
     port: 3377
   
   spring:
     application:
       name: nacos-config-client
     cloud:
       nacos:
         discovery:
           server-addr: localhost:8848 #Nacos服务注册中心地址
         config:
           server-addr: localhost:8848 #Nacos作为配置中心地址
           file-extension: yaml  #指定yaml格式的配置，注意是yaml不是yml
   
   #   ${spring.application.name}
   #   -${spring.profile.active}
   #   .${spring.cloud.nacos.config.file-extension}
   

2. application.yml

   spring:
     profiles:
       active: dev # 表示开发环境
   

主启动类

@EnableDiscoveryClient
@SpringBootApplication
public class NacosConfigClientMain3377 {
    public static void main(String[] args) {
        SpringApplication.run(NacosConfigClientMain3377.class, args);
    }
}

业务类

@RestController
@RefreshScope //在控制器类加入@RefreshScope注解使当前类下的配置支持Nacos的动态刷新功能。
public class ConfigClientController {
    @Value("${config.info}")
    private String configInfo;

    @GetMapping("/config/info")
    public String getConfigInfo() {
        return configInfo;
    }
}

动态更新

在 controller 类上面使用注解 @RefreshScope

修改下 Nacos 图形界面中的 yaml 配置文件，再次调用查看配置的接口，就会发现配置已经刷新

在Nacos中添加配置信息

Nacos 中的匹配规则：

${spring.application.name}-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}

Nacos 界面配置对应：

Nacos 会记录配置文件的历史版本默认保留30天，此外还有一键回滚功能，回滚操作将会触发配置更新

测试

启动前需要在 nacos客户端-配置管理-配置管理栏目下 有对应的yaml配置文件

运行 nacos-config-client3377 的主启动类

调用接口查看配置信息：访问 http://localhost:3377/config/info

输出结果即为 nacos 配置文件内容

自带动态刷新

修改下 Nacos 中的 yaml 配置文件，再次调用查看配置的接口，就会发现配置已经刷新

3.2 Nacos作为配置中心-分类配置

问题：多项目多环境

问题1：实际开发中，通常一个系统会准备 dev 开发环境、 test测试环境、 prod生产环境。如何保证指定环境启动时服务能正确读取到 Nacos 上相应环境的配置文件呢？

问题2：一个大型分布式微服务系统会有很多微服务子项目，每个微服务项目又都会有相应的开发环境、测试环境、预发环境、正式环境…那怎么对这些微服务配置进行管理呢？

Nacos的图形化管理界面

Namespace+Group+Data ID三者关系？

1. 是什么？

   类似Java里面的package名和类名

   最外层的namespace是可以用于区分部署环境的，Group和DataID逻辑上区分两个目标对象

2. 三者情况

   1. 默认情况：Namespace=public，Group=DEFAULT_GROUP，默认Cluster是DEFAULT
   2. Nacos默认的命名空间是 public。Namespace主要用来实现隔离。比方说我们现在有三个环境：开发、测试、生产环境，我们就可以创建三个Namespace，不同的Namespace之间是隔离的。
   3. Group默认是DEFAULT_GROUP，Group可以把不同的微服务划分到同一个分组里面去
   4. Service就是微服务；一个Service可以包含多个Cluster（集群），Nacos默认Cluster是DEFAULT，Cluster是对指定微服务的一个虚拟划分。比方说为了容灾，将Service微服务分别部署在了杭州机房和广州机房，这时就可以给杭州机房的Service微服务起一个集群名称（HZ），给广州机房的Service微服务起一个集群名称（GZ），还可以尽量让同一个机房的微服务互相调用，以提升性能。 最后是Instance，就是微服务的实例。

DataID方案

指定 spring.profile.active 和 配置文件的 DataID 来使不同环境下读取不同的配置

测试：访问 http://localhost:3377/config/info

Group方案

nacos 图形界面

在 nacos 图形界面控制台上面 新建 Group、新建配置文件 DataID

配置文件修改

在config下增加一条 group 的配置即可。可配置为 DEV_GROUP 或 TEST_GROUP

Namespace方案

nacos 图形界面

新建 dev/test 的 Namespace

注意下面的命名空间ID：

回到 服务管理-服务列表 查看

按照域名配置填写

配置文件修改

在config下增加一条 namespace 的配置即可。配置为 命名空间ID

4、Nacos集群和持久化配置（重要）

nacos 持久化配置解释