Nacos学习笔记，及demo实现

Nacos

Nacos 简介

简介

Nacos是针对微服务架构中的服务发现、配置管理、服务治理的综合性解决方案。

特性

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

安装

1. 下载压缩包

   官方git-releases

2. 解压

3. 启动服务

   • Windows

     进入bin目录启动startup.cmd

   • Linux

     进入bin目录执行命令

     sh shtartup.sh -m standalone
     

4. 访问 http://localhost:8848/nacos/index.html

   默认用户名：nacos，默认密码：nacos

5. 外部mysql数据库支持

   1. 安装mysql数据库（5.6.5+）

   2. 创建数据库nacos_config，数据库初始化文件：nacos/conf/nacos-mysql.sql

   3. 修改nacos/conf/application.properties文件，增加mysql数据源配置

      spring.datasource.platform=mysql
      
      db.num=1
      db.url.0=jdbc:mysql://localhost:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true
      db.user=root
      db.password=123456
      

Nacos 配置管理

Nacos 配置管理 - 基础应用

Nacos 配置管理模型

对于Nacos配置管理，通过Namespace、group、Data ID来定位到一个配置集。

• 配置集 (Data ID)

  一个配置文件通常就是一个配置集

• 配置项

  配置集中的包含的一个个配置内容就是配置项

• 配置分组 (Group)

  不同配置分组下可以有相同的配置集

• 命名空间 (Namespace)

  可用于进行不同环境的配置隔离。不同命名空间可以有相同的配置分组或配置集。

Nacos 配置管理 - Java实现

1. 新建maven项目。

2. 增加maven依赖

   <dependency>
       <groupId>com.alibaba.nacosgroupId>
       <artifactId>nacos-clientartifactId>
       <version>1.2.1version>
   dependency>
   

3. 创建类，根据信息获取配置

   public static void main(String[] args) throws NacosException {
       //nacos url
       String serverAddr = "127.0.0.1:8848";
       //DataId
       String dataId = "db.properties";
       //group
       String group = "DEFAULT_GROUP";
       //namespace
       String namespace = "bfb75518-0f3d-47b1-b520-a27d21206013";
       //属性
       Properties properties = new Properties();
       properties.put("serverAddr", serverAddr);
       //指定命名空间，若不指定则默认public
       //properties.put("namespace", namespace);
       //获取配置
       ConfigService configService = NacosFactory.createConfigService(properties);
       String config = configService.getConfig(dataId, group, 5000);
       System.out.println(config);
   }
   

4. 监听配置修改

       configService.addListener(dataId, group, new Listener() {
           public Executor getExecutor() {
               return null;
           }
   
           public void receiveConfigInfo(String s) {
               System.out.println(s);
           }
       });
   

Nacos 配置管理 - 分布式系统应用

单一配置文件实现

1. 创建父工程

   pom.xml

   
   <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.0modelVersion>
   
       <groupId>com.mervyngroupId>
       <artifactId>nacos_configartifactId>
       <version>1.0-SNAPSHOTversion>
       <packaging>pompackaging>
   
       <properties>
           <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
           <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
           <java.version>1.8java.version>
       properties>
   
       <dependencyManagement>
           <dependencies>
               <dependency>
                   <groupId>com.alibaba.cloudgroupId>
                   <artifactId>spring-cloud-alibaba-dependenciesartifactId>
                   <version>2.1.0.RELEASEversion>
                   <type>pomtype>
                   <scope>importscope>
               dependency>
               <dependency>
                   <groupId>org.springframework.cloudgroupId>
                   <artifactId>spring-cloud-dependenciesartifactId>
                   <version>Greenwich.RELEASEversion>
                   <type>pomtype>
                   <scope>importscope>
               dependency>
               <dependency>
                   <groupId>org.springframework.bootgroupId>
                   <artifactId>spring-boot-dependenciesartifactId>
                   <version>2.1.3.RELEASEversion>
                   <type>pomtype>
                   <scope>importscope>
               dependency>
           dependencies>
       dependencyManagement>
   
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.bootgroupId>
                   <artifactId>spring-boot-maven-pluginartifactId>
               plugin>
           plugins>
       build>
   project>
   

2. 创建子工程 service1、service2

   pom.xml

   <dependencies>
       <dependency>
           <groupId>com.alibaba.cloudgroupId>
           <artifactId>spring-cloud-starter-alibaba-nacos-configartifactId>
       dependency>
       <dependency>
           <groupId>org.springframework.bootgroupId>
           <artifactId>spring-boot-starter-webartifactId>
       dependency>
   dependencies>
   

3. bootstrap.yml 配置

   选择bootstrap.yml而非application.yml是因为bootstrap.yml启动优先级高于application.yml

   server:
     port: 56010 #启动端口 命令行注入
   
   spring:
     application:
       name: service1
     cloud:
       nacos:
         config:
           server-addr: 127.0.0.1:8848 # 配置中心地址
           file‐extension: yaml # dataId = application.name + file-extension = service1.yaml 与nacos发布的配置相同
           namespace: bfb75518-0f3d-47b1-b520-a27d21206013 # 命名空间 - 测试环境
           group: TEST_GROUP # 测试组
   

4. 创建Springboot启动类

   package com.mervyn.nacos.service1;
   
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.beans.factory.annotation.Value;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.context.ConfigurableApplicationContext;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @SpringBootApplication
   @RestController
   public class Service1Bootstrap {
       public static void main(String[] args) {
           SpringApplication.run(Service1Bootstrap.class, args);
       }
   
       //通过value注解读取配置信息，但无法动态更新配置的修改
       @Value("${common.name}")
       private String config1;
   
       //配置文件上下文，实现动态获取配置更新
       @Autowired
       private ConfigurableApplicationContext applicationContext;
   
       @GetMapping("/configs")
       public String getConfigs() {
           //读取配置信息
   //        return config1;
           return applicationContext.getEnvironment().getProperty("comman.name");
       }
   }
   

自定义扩展 dataId

应用于一个微服务不止一个配置文件。

bootstrap.yml

# config external configuration
# 1、Data Id 在默认的组 DEFAULT_GROUP,不支持配置的动态刷新
ext-config[0]:
data-id: ext-config-common01.properties

# 2、Data Id 不在默认的组，不支持动态刷新
ext-config[1]:
data-id: ext-config-common02.properties
group: GLOBALE_GROUP

# 3、Data Id 既不在默认的组，也支持动态刷新
ext-config[2]:
data-id: ext-config-common03.properties
group: REFRESH_GROUP
refresh: true

自定义共享 dataId

该方法仅支持加载DEFAULT_GROUP中的配置，故不推荐使用

bootstrap.yml

shared-dataids: ext-config-common01.properties,ext-config-common02.properties,ext-config-common03.properties
refreshable-dataids: ext-config-common03.properties

配置优先级

上述三种配置方式：

A. spring.cloud.nacos.config.shared-dataids
B. spring.cloud.nacos.config.ext-config[n].data-id
C. 通过application.name和file-extension自动生成的dataId

优先级为 C > B > A。

B方式中多个配置优先级为：n越大，优先级越高。

Nacos 集群部署

1. 安装3个以上 Nacos

2. 修改配置文件

   各 Nacos 配置文件conf/application.properties中server.port修改为不同端口

3. 修改集群配置

   各 Nacos 修改cluster.conf.example改为cluster.conf

   并修改内容为

   #ip:port
   127.0.0.1:8848
   127.0.0.1:8849
   127.0.0.1:8850
   

4. 分别执行各 Nacos 下的 startup

   startup -m cluster
   

5. 应用配置

   spring:
     application:
       name: applicationName
     cloud:
       nacos:
         config:
           server-addr: 127.0.0.1:8848, 127.0.0.1:8849, 127.0.0.1:8850 # 配置集群地址
   

Nacos 服务发现

Nacos 服务发现 - 快速入门

1. 创建父工程

   pom.xml

   
   <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.0modelVersion>
   
       <groupId>com.mervyngroupId>
       <artifactId>nacos_discoveryartifactId>
       <version>1.0-SNAPSHOTversion>
       <packaging>pompackaging>
   
       <properties>
           <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
           <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
           <java.version>1.8java.version>
       properties>
   
       <dependencyManagement>
           <dependencies>
               <dependency>
                   <groupId>com.alibaba.cloudgroupId>
                   <artifactId>spring-cloud-alibaba-dependenciesartifactId>
                   <version>2.1.0.RELEASEversion>
                   <type>pomtype>
                   <scope>importscope>
               dependency>
               <dependency>
                   <groupId>org.springframework.cloudgroupId>
                   <artifactId>spring-cloud-dependenciesartifactId>
                   <version>Greenwich.RELEASEversion>
                   <type>pomtype>
                   <scope>importscope>
               dependency>
               <dependency>
                   <groupId>org.springframework.bootgroupId>
                   <artifactId>spring-boot-dependenciesartifactId>
                   <version>2.1.3.RELEASEversion>
                   <type>pomtype>
                   <scope>importscope>
               dependency>
           dependencies>
       dependencyManagement>
   
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.bootgroupId>
                   <artifactId>spring-boot-maven-pluginartifactId>
               plugin>
           plugins>
       build>
   project>
   

2. 创建子工程 - 服务生产者

   1. pom.xml

      <dependencies>
          <dependency>
              <groupId>com.alibaba.cloudgroupId>
              <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
          dependency>
      
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-webartifactId>
          dependency>
      
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-openfeignartifactId>
          dependency>
      dependencies>
      

   2. application.yml

      server:
        port: 56010
      spring:
        application:
          name: quickstart-provider # 不支持_下划线
        cloud:
          nacos:
            discovery:
              server-addr: 127.0.0.1:8848
      logging:
        level:
          root: info
          org.springframework: info
      

   3. 创建controller提供接口

      @RestController
      public class ProviderController {
      
          private static final Logger LOG = LoggerFactory.getLogger(ProviderController.class);
      
          @GetMapping("/service")
          public String service() {
              LOG.info("provider service");
              return "provider service";
          }
      }
      

   4. 创建启动程序

      @SpringBootApplication
      //开启feign远程链接
      @EnableFeignClients
      //是一个注册发现客户端
      @EnableDiscoveryClient
      public class NacosProviderApp {
      
          public static void main(String[] args) {
              SpringApplication.run(NacosProviderApp.class, args);
          }
      
      }
      

3. 创建子工程 - 服务消费者

   1. pom.xml 同上

   2. application.yml

      server:
        port: 56020
      spring:
        application:
          name: quickstart-consumer
        cloud:
          nacos:
            discovery:
              server-addr: 127.0.0.1:8848
      

   3. 创建 服务生产者的客户端 接口

      @FeignClient(name = "quickstart-provider")
      public interface ProviderClient {
      
          @GetMapping("/service")
          public String service();
      
      }
      

   4. 创建 服务消费者 功能实现

      @RestController
      public class ConsumerController {
      
          @Autowired
          private ProviderClient providerClient;
      
          @GetMapping("service")
          public String service() {
              String providerResult = providerClient.service();
              return "consumer invoke | " + providerResult;
          }
      
      }
      

   5. 创建 服务消费者 启动类

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

4. 多实例负载均衡

   1. 修改生产者配置文件中的端口为动态端口

      server:
        port: ${port:56010} # 需传参，若没有传参则默认56010
      

   2. 修改启动配置

      vm options中添加-Dport=56010

      复制一个启动实例，添加-Dport=56011

   3. 启动2个生产者，和消费者，发现以轮询的方式自动切换调用两个服务实例。（Ribbon客户端负载均衡）

Nacos 服务发现 - 基础应用

Nacos 服务发现数据模型

• 命名空间

  不同环境的隔离

• 服务

  提供给客户端的接口，通过预定义的接口网络访问

• 服务名

  服务的唯一标识，通过该标识定位到指定服务

• 实例

  一个服务名可以拥有多个实例，通过负载均衡算法动态调用不同示例

• 元信息

  配置实例的具体信息，如服务版本、权重、负载均衡策略等

• 集群

  服务实例的集合

通过namespace、cluster-name等配置指定该服务的命名空间、集群等。

spring:
  application:
    name: quickstart-consumer
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: bfb75518-0f3d-47b1-b520-a27d21206013
        cluster-name: DEFAULT

Spring Cloud Alibaba 综合集成框架实现

架构说明

nacos-micro-service 整体父工程

|–api-gateway API网关，端口：56010

|–application-1 应用1，端口：56020

|–service-1 服务1父工程

| |–service-1-api 服务1API

| |–service-1-server 服务1实现，端口：56030

|–service-2 服务2父工程

| |–service-2-api 服务2API

| |–service-2-server 服务2实现，端口：56040

组件说明

API网关：系统统一入口，屏蔽架构内部结构，统一安全拦截，采用Zuul实现。
application-1 ：应用1，模拟应用，提供http接口服务。
service-1 ：微服务1，模拟微服务，提供dubbo接口服务。
service-2 ：微服务2，模拟微服务，提供dubbo接口服务。

调用流程

所有访问系统的请求都要经过网关，网关转发Http请求至application-1，application-1使用dubbo调用service1完
成自身业务，而后sevice1调用service2完成自身业务。至此，完成所有组件贯穿。
架构中application与sevice的区别是什么？

• service提供了基础服务功能；application组装基础服务功能，提供给用户直接可用的业务。
• service服务粒度小、功能基础，不易发生改变；application提供上游业务功能，紧贴业务需求，容易发生改
  变。
• 形成service支撑application的整体架构，增加多变的application甚至不需要变动service。

具体实现

1. 创建父工程nacos-micro-service继承nacos_discovery工程。

2. 实现application-1

   1. 创建工程，继承nacos-micro-service工程

   2. 初始化pom.xml依赖

      <dependencies>
          <dependency>
              <groupId>com.alibaba.cloudgroupId>
              <artifactId>spring-cloud-starter-alibaba-nacos-configartifactId>
          dependency>
          <dependency>
              <groupId>com.alibaba.cloudgroupId>
              <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-webartifactId>
          dependency>
      dependencies>
      

   3. 配置bootstrap.yml

      server:
        port: 56020 #启动端口 命令行注入
        servlet:
          context-path: /application1  # 上下文路径
      
      spring:
        application:
          name: application1
        main:
          allow-bean-definition-overriding: true # Spring Boot 2.1 需要设定
        cloud:
          nacos:
            discovery:
              server-addr: localhost:8848
              namespace: 5dad70eb-7acf-4cfd-acda-e4ab672ddd7a
              cluster-name: DEFAULT
            config:
              server-addr: localhost:8848 # 配置中心地址
              file-extension: yaml
              namespace: 5dad70eb-7acf-4cfd-acda-e4ab672ddd7a # 开发环境
              group: NACOS_MICROSERVICE_GROUP # xx业务组
      

   4. 创建Application1Controller.java

      package com.mervyn.microservice.application1.controller;
      
      import org.springframework.web.bind.annotation.GetMapping;
      import org.springframework.web.bind.annotation.RestController;
      
      @RestController
      public class Application1Controller {
      
          @GetMapping("/service")
          public String service() {
              return "test";
          }
      
      }
      

   5. 创建Application1Bootstrap.java启动类

      package com.mervyn.microservice.application1;
      
      import org.springframework.boot.SpringApplication;
      import org.springframework.boot.autoconfigure.SpringBootApplication;
      import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
      
      @SpringBootApplication
      @EnableDiscoveryClient
      public class Application1Bootstrap {
      
          public static void main(String[] args) {
              SpringApplication.run(Application1Bootstrap.class, args);
          }
      
      }
      

   6. 测试是否成功

      启动项目，访问 http://localhost:56020/application1/service 测试成功实现application1，并暴露http接口。

3. 实现service-1

   1. 定义service-1-api接口工程

      1. 创建服务接口

         package com.mervyn.microservice.service1.api;
         
         public interface ConsumerService {
         
             public String service();
         }
         

   2. 实现service-1-server

      1. 初始化pom.xml依赖

         <dependencies>
             <dependency>
                 <groupId>com.mervyngroupId>
                 <artifactId>service-1-apiartifactId>
                 <version>1.0-SNAPSHOTversion>
             dependency>
             <dependency>
                 <groupId>com.alibaba.cloudgroupId>
                 <artifactId>spring-cloud-starter-alibaba-nacos-configartifactId>
             dependency>
             <dependency>
                 <groupId>com.alibaba.cloudgroupId>
                 <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
             dependency>
             <dependency>
                 <groupId>com.alibaba.cloudgroupId>
                 <artifactId>spring-cloud-starter-dubboartifactId>
             dependency>
         dependencies>
         

      2. 实现Dubbo服务

         package com.mervyn.microservice.service1.service;
         
         import com.mervyn.microservice.service1.api.ConsumerService;
         
         @org.apache.dubbo.config.annotation.Service
         public class ConsumerServiceImpl implements ConsumerService {
             public String service() {
                 return "Consumer invoke ";
             }
         }
         

         用@org.apache.dubbo.config.annotation.Service标注Dubbo服务，避免与Spring中的Service冲突或混淆。

      3. 配置bootstrap.yml

         server:
           port: ${port:56030} #启动端口 命令行注入
         
         spring:
           application:
             name: service1
           main:
             allow-bean-definition-overriding: true # Spring Boot 2.1 需要设定
           cloud:
             nacos:
               discovery:
                 server-addr: 127.0.0.1:8848
                 namespace: 5dad70eb-7acf-4cfd-acda-e4ab672ddd7a
                 cluster-name: DEFAULT
               config:
                 server-addr: 127.0.0.1:8848 # 配置中心地址
                 file-extension: yaml
                 namespace: 5dad70eb-7acf-4cfd-acda-e4ab672ddd7a # 开发环境
                 group: NACOS_MICROSERVICE_GROUP # xx业务组
         dubbo:
           scan:
             # dubbo 服务扫描基准包
             base-packages: com.mervyn.microservice
           protocol:
             # dubbo 协议
             name: dubbo
             # dubbo 协议端口
             port: ${dubbo_port:20881}
           registry:
             address: nacos://localhost:8848
           application:
             qos-enable: false #dubbo运维服务是否开启
           consumer:
             check: false  #启动时就否检查依赖的服务
         

         • dubbo.scan.base-packages为扫描基准包，此包下的所有标注为@org.apache.dubbo.config.annotation.Service的服务暴露为 Dubbo 服务。
         • dubbo.protocolDubbo 服务暴露的协议。
         • dubbo.registry Dubbo 服务注册中心配置。

      4. 创建启动类

         package com.mervyn.microservice.service1;
         
         import org.springframework.boot.SpringApplication;
         import org.springframework.boot.autoconfigure.SpringBootApplication;
         import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
         
         @SpringBootApplication
         @EnableDiscoveryClient
         public class Service1Bootstrap {
             public static void main(String[] args) {
                 SpringApplication.run(Service1Bootstrap.class, args);
             }
         }
         

         启动后，可在 Nacos 服务列表中看到Dubbo服务。

4. 实现application-1调用service-1

   1. application-1的pom.xml中增加service-1-api包和Dubbo包

      <dependency>
          <groupId>com.mervyngroupId>
          <artifactId>service-1-apiartifactId>
          <version>1.0-SNAPSHOTversion>
      dependency>
      <dependency>
          <groupId>com.alibaba.cloudgroupId>
          <artifactId>spring-cloud-starter-dubboartifactId>
      dependency>
      

   2. 修改Application1Controller.java实现调用

      @RestController
      public class Application1Controller {
      	//注入dubbo服务类
          @org.apache.dubbo.config.annotation.Reference
          private ConsumerService consumerService;
          
          @GetMapping("/service")
          public String service() {
              String service = consumerService.service();
              return "test | "+service;
          }
      
      }
      

   3. 启动应用，访问 http://localhost:56020/application1/service

5. 实现service-1调用service-2

   1. 实现service-2，同上 实现service-1步骤
   2. 实现service-1调用service-2，同上实现application-1调用service-1步骤

6. 搭建网关

   1. 添加依赖

      <dependencies>
          <dependency>
              <groupId>com.alibaba.cloudgroupId>
              <artifactId>spring-cloud-starter-alibaba-nacos-configartifactId>
          dependency>
          <dependency>
              <groupId>com.alibaba.cloudgroupId>
              <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-openfeignartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-webartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-netflix-zuulartifactId>
          dependency>
      dependencies>
      

   2. 配置网关bootstrap.yml

      server:
        port: 56010 #启动端口 命令行注入
      
      spring:
        application:
          name: api-gateway
        main:
          allow-bean-definition-overriding: true # Spring Boot 2.1 需要设定
        cloud:
          nacos:
            discovery:
              server-addr: localhost:8848
              namespace: 5dad70eb-7acf-4cfd-acda-e4ab672ddd7a
              cluster-name: DEFAULT
            config:
              server-addr: localhost:8848 # 配置中心地址
              file-extension: yaml
              namespace: 5dad70eb-7acf-4cfd-acda-e4ab672ddd7a # 开发环境
              group: NACOS_MICROSERVICE_GROUP # xx业务组
      

   3. Nacos 添加 Zuul 配置

      zuul:
        routes:
          application1:
            stripPrefix: false
            path: /application1/**
      

      将所有/application1/路径的请求转发到application1服务。

   4. 创建启动类

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

   5. 启动网关服务，访问 http://localhost:56010/application1/service

代码地址

Nacos - demo

参考资料

Spring Cloud Alibaba Nacos配置中心与服务发现 - 黑马程序员