万字长文 | Spring Cloud Alibaba组件之Nacos实战及其客户端服务注册源码解析

# 解压
tar -zxvf nacos-server-2.0.3.tar.gz
# 启动
cd nacos/bin
sh startup.sh -m standalone

[root@localhost ~]# jps
9763 nacos-server.jar
13720 Jps
[root@localhost ~]# ps -ef|grep nacos

<?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.xblzer</groupId>
    <artifactId>SpringCloudAlibabaTest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <!-- 作版本仲裁 -->
    <dependencyManagement>
        <dependencies>
            <!-- Spring Boot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.6.3</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- Spring Cloud -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>2021.0.1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- Spring Cloud Alibaba -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2021.0.1.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

<parent>
    <groupId>com.xblzer</groupId>
    <artifactId>SpringCloudAlibabaTest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath/>
</parent>

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

<modules>
    <module>cloud-nacos-provider</module>
</modules>

server:
  port: 8080

spring:
  application:
    name: cloud-nacos-provider

  cloud:
    nacos:
      discovery:
        server-addr: 192.168.242.129:8848

management:
  endpoint:
    web:
      exposure:
        include: "*"

package com.xblzer.cloudnacosprovider.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 行百里者
 * @date 2022-06-30 18:29
 */
@RestController
public class ProviderController {

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/test-port")
    public String getServerPort() {
        return "Nacos Provider port:" + serverPort;
    }
}

server:
  port: 9080

spring:
  application:
    name: cloud-nacos-consumer

  cloud:
    nacos:
      discovery:
        server-addr: 192.168.242.129:8848

# 消费者要访问的服务提供者-这些服务提供者已注册到nacos
service-url:
  nacos-provider-service: http://cloud-nacos-provider

<!-- 2021.0.1版本移除了netflix ribbon 使用LoadBalancer 必须引入LoadBalancer的依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}

@RestController
public class ConsumerController {

    @Resource
    private RestTemplate restTemplate;

    @Value("${service-url.nacos-provider-service}")
    private String serviceUrl;

    @GetMapping("/comsume")
    public String consume() {
        return restTemplate.getForObject(serviceUrl + "/test-port", String.class);
    }
}

<!-- 引入Nacos config -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

<modules>
    <module>cloud-nacos-provider</module>
    <module>cloud-nacos-consumer</module>
    <module>cloud-nacos-config</module>
</modules>

# nacos配置
server:
  port: 7071

spring:
  application:
    name: nacos-config-client
  cloud:
    nacos:
      discovery:
        # Nacos服务注册中心地址
        server-addr: 192.168.242.129:8848 
      config:
       # Nacos作为配置中心地址
        server-addr: 192.168.242.129:8848 
        # 指定yaml格式的配置
        file-extension: yaml 

server:
  port: 7071

spring:
  application:
    name: cloud-nacos-config

  cloud:
    nacos:
      config:
        group: DEFAULT_GROUP
        server-addr: 192.168.242.129:8848
  config:
    import:
      - nacos:test.yml

${prefix}-${spring.profiles.active}.${file-extension}

# 上传sql脚本文件到MySQL所在的112服务
scp nacos-mysql.sql root@192.168.242.112:/usr/local/sql-scripts/

mysql> create database nacos;
Query OK, 1 row affected (0.03 sec)

mysql> use nacos;

mysql> source /usr/local/sql-scripts/nacos-mysql.sql;

mysql> show tables;
+----------------------+
| Tables_in_nacos      |
+----------------------+
| config_info          |
| config_info_aggr     |
| config_info_beta     |
| config_info_tag      |
| config_tags_relation |
| group_capacity       |
| his_config_info      |
| permissions          |
| roles                |
| tenant_capacity      |
| tenant_info          |
| users                |
+----------------------+
12 rows in set (0.00 sec)

#*************** Config Module Related Configurations ***************#
### If use MySQL as datasource:
spring.datasource.platform=mysql

### Count of DB:
db.num=1

### Connect URL of DB:
db.url.0=jdbc:mysql://192.168.242.112:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=zhangsan
db.password.0=Fawai@kuangtu6

cd /usr/local/nacos/bin
sh shutdown.sh
sh startup.sh -m standalone

mysql> select * from config_info\G
*************************** 1. row ***************************
          id: 1
     data_id: test.yml
    group_id: DEFAULT_GROUP
     content: config:
    info: this is new version!
         md5: 57609a39c0477b74a7e5315c2acd062b
  gmt_create: 2022-07-07 07:22:41
gmt_modified: 2022-07-07 07:22:41
    src_user: NULL
      src_ip: 192.168.242.1
    app_name: 
   tenant_id: 
      c_desc: NULL
       c_use: NULL
      effect: NULL
        type: yaml
    c_schema: NULL
1 row in set (0.00 sec)

cp cluster.conf.example cluster.conf

# ip:port
192.168.242.129:8848
192.168.242.130:8848
192.168.242.131:8848

# 错误为：./configure: error: the HTTP rewrite module requires the PCRE library.

# 安装pcre-devel解决问题
yum -y install pcre-devel

#还有可能出现：./configure: error: the HTTP cache module requires md5 functions from OpenSSL library
# 解决办法：
yum -y install openssl openssl-devel

# 编辑nginx.conf文件
vi /usr/local/nginx/conf/nginx.conf

stream {
      upstream nacos {
        server 192.168.242.129:8848;
        server 192.168.242.130:8848;
        server 192.168.242.131:8848;
      }


     server {
        listen  81;
        proxy_pass nacos;
     }
}

/usr/local/nginx/sbin/nginx

spring:
  application:
    name: cloud-nacos-config

  cloud:
    nacos:
      config:
        group: DEFAULT_GROUP
        server-addr: 192.168.242.112:81
  config:
    import:
      - nacos:test.yml

-Dnacos.standalone=true

@Ignore
public class NamingTest {
    
    @Test
    public void testServiceList() throws Exception {
        // 连接nacos server信息
        Properties properties = new Properties();
        properties.put(PropertyKeyConst.SERVER_ADDR, "127.0.0.1:8848");
        properties.put(PropertyKeyConst.USERNAME, "nacos");
        properties.put(PropertyKeyConst.PASSWORD, "nacos");
        
        //实例信息封装，包括基础信息和元数据信息
        Instance instance = new Instance();
        instance.setIp("1.1.1.1");
        instance.setPort(800);
        instance.setWeight(2);
        Map<String, String> map = new HashMap<String, String>();
        map.put("netType", "external");
        map.put("version", "2.0");
        instance.setMetadata(map);
    
        //通过NacosFactory获取NamingService
        NamingService namingService = NacosFactory.createNamingService(properties);
        //通过namingService注册实例
        namingService.registerInstance("nacos.test.1", instance);
    }
}

Properties properties = new Properties();
properties.put(PropertyKeyConst.SERVER_ADDR, "127.0.0.1:8848");
properties.put(PropertyKeyConst.USERNAME, "nacos");
properties.put(PropertyKeyConst.PASSWORD, "nacos");

Map<String, String> map = new HashMap<String, String>();
map.put("netType", "external");
map.put("version", "2.0");
instance.setMetadata(map);

 /**
     * 获取实例心跳间隙，默认为5s，也就是默认5秒进行一次心跳
     * @return 实例心跳间隙
     */
    public long getInstanceHeartBeatInterval() {
        return getMetaDataByKeyWithDefault(PreservedMetadataKeys.HEART_BEAT_INTERVAL,
                Constants.DEFAULT_HEART_BEAT_INTERVAL);
    }

    /**
     * 获取心跳超时时间，默认为15s，也就是默认15秒收不到心跳，实例将会标记为不健康
     * @return 实例心跳超时时间
     */
    public long getInstanceHeartBeatTimeOut() {
        return getMetaDataByKeyWithDefault(PreservedMetadataKeys.HEART_BEAT_TIMEOUT,
                Constants.DEFAULT_HEART_BEAT_TIMEOUT);
    }

    /**
     * 获取实例IP被删除的时间，默认为30s，也就是30秒收不到心跳，实例将会被移除
     * @return 实例IP被删除的时间间隔
     */
    public long getIpDeleteTimeout() {
        return getMetaDataByKeyWithDefault(PreservedMetadataKeys.IP_DELETE_TIMEOUT,
                Constants.DEFAULT_IP_DELETE_TIMEOUT);
    }

    /**
     * 实例ID生成器，默认为simple
     * @return 实例ID生成器
     */
    public String getInstanceIdGenerator() {
        return getMetaDataByKeyWithDefault(PreservedMetadataKeys.INSTANCE_ID_GENERATOR,
                Constants.DEFAULT_INSTANCE_ID_GENERATOR);
    }

public class PreservedMetadataKeys {

    //心跳超时的key
    public static final String HEART_BEAT_TIMEOUT = "preserved.heart.beat.timeout";
    //实例IP被删除的key
    public static final String IP_DELETE_TIMEOUT = "preserved.ip.delete.timeout";
    //心跳间隙的key
    public static final String HEART_BEAT_INTERVAL = "preserved.heart.beat.interval";
    //实例ID生成器key
    public static final String INSTANCE_ID_GENERATOR = "preserved.instance.id.generator";
}

package com.alibaba.nacos.api.common;

import java.util.concurrent.TimeUnit;

/**
 * Constants.
 *
 * @author Nacos
 */
public class Constants {
    //...略
    
    //心跳超时，默认15s
    public static final long DEFAULT_HEART_BEAT_TIMEOUT = TimeUnit.SECONDS.toMillis(15);
    //ip剔除时间，默认30s未收到心跳则剔除实例
    public static final long DEFAULT_IP_DELETE_TIMEOUT = TimeUnit.SECONDS.toMillis(30);
    //心跳间隔。默认5s
    public static final long DEFAULT_HEART_BEAT_INTERVAL = TimeUnit.SECONDS.toMillis(5);
    //实例ID生成器，默认为simple
    public static final String DEFAULT_INSTANCE_ID_GENERATOR = "simple"; 
    
    //...略
}

//通过NacosFactory获取NamingService
NamingService namingService = NacosFactory.createNamingService(properties);
//通过namingService注册实例
namingService.registerInstance("nacos.test.1", instance);

/**
  * 创建NamingService实例
  * @param properties 连接nacos server的属性
  */
public static NamingService createNamingService(Properties properties) throws NacosException {
    try {
        //通过反射机制来实例化NamingService
        Class<?> driverImplClass = Class.forName("com.alibaba.nacos.client.naming.NacosNamingService");
        Constructor constructor = driverImplClass.getConstructor(Properties.class);
        return (NamingService) constructor.newInstance(properties);
    } catch (Throwable e) {
        throw new NacosException(NacosException.CLIENT_INVALID_PARAM, e);
    }
}

namingService.registerInstance("nacos.test.1", instance);

//服务注册，传递参数服务名称和实例对象
@Override
public void registerInstance(String serviceName, Instance instance) throws NacosException {
    registerInstance(serviceName, Constants.DEFAULT_GROUP, instance);
}

//注册服务
//参数：服务名称，实例分组（默认DEFAULT_GROUP），实例对象
@Override
public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
    //检查实例是否合法：通过服务心跳，如果不合法直接抛出异常
    NamingUtils.checkInstanceIsLegal(instance);
    //通过NamingClientProxy代理来执行服务注册
    clientProxy.registerService(serviceName, groupName, instance);
}

//类NamingUtils工具类下
public static void checkInstanceIsLegal(Instance instance) throws NacosException {
    //心跳超时时间必须小于心跳间隔时间
    //IP剔除的检查时间必须小于心跳间隔时间
    if (instance.getInstanceHeartBeatTimeOut() < instance.getInstanceHeartBeatInterval()
        || instance.getIpDeleteTimeout() < instance.getInstanceHeartBeatInterval()) {
        throw new NacosException(NacosException.INVALID_PARAM,
                                 "Instance 'heart beat interval' must less than 'heart beat timeout' and 'ip delete timeout'.");
    }
}

/**
  * 注册服务
  * @param serviceName 服务名称
  * @param groupName   服务所在组
  * @param instance    注册的实例
  */
@Override
public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
    //这一句话干了两件事：
    //1.getExecuteClientProxy(instance) 判断当前实例是否为瞬时对象，如果是瞬时对象，则返回grpcClientProxy(NamingGrpcClientProxy)，否则返回httpClientProxy(NamingHttpClientProxy)
    //2.registerService(serviceName, groupName, instance) 根据第1步返回的代理类型，执行相应的注册请求
    getExecuteClientProxy(instance).registerService(serviceName, groupName, instance);
}

//...

//返回代理类型
private NamingClientProxy getExecuteClientProxy(Instance instance) {
    //如果是瞬时对象，返回grpc协议的代理，否则返回http协议的代理
    return instance.isEphemeral() ? grpcClientProxy : httpClientProxy;
}

/**
  * 服务注册
  * @param serviceName 服务名称
  * @param groupName   服务所在组
  * @param instance    注册的实例对象
  */
@Override
public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
    NAMING_LOGGER.info("[REGISTER-SERVICE] {} registering service {} with instance {}", namespaceId, serviceName,
                       instance);
    //缓存当前实例，用于将来恢复
    redoService.cacheInstanceForRedo(serviceName, groupName, instance);
    //基于gRPC进行服务的调用
    doRegisterService(serviceName, groupName, instance);
}

public void cacheInstanceForRedo(String serviceName, String groupName, Instance instance) {
    //将Instance实例缓存到ConcurrentMap中
    //缓存实例的key值，格式为 groupName@@serviceName
    String key = NamingUtils.getGroupedName(serviceName, groupName);
    //缓存实例的value值，就是封装的instance实例
    InstanceRedoData redoData = InstanceRedoData.build(serviceName, groupName, instance);
    synchronized (registeredInstances) {
        //registeredInstances是一个 ConcurrentMap<String, InstanceRedoData>，key是NamingUtils.getGroupedName生成的key，value是封装的实例信息
        registeredInstances.put(key, redoData);
    }
}

//NamingGrpcClientProxy.java
public void doRegisterService(String serviceName, String groupName, Instance instance) throws NacosException {
    InstanceRequest request = new InstanceRequest(namespaceId, serviceName, groupName,
                                                  NamingRemoteConstants.REGISTER_INSTANCE, instance);
    requestToServer(request, Response.class);
    redoService.instanceRegistered(serviceName, groupName);
}

//NamingGrpcRedoService.java
public void instanceRegistered(String serviceName, String groupName) {
    String key = NamingUtils.getGroupedName(serviceName, groupName);
    synchronized (registeredInstances) {
        InstanceRedoData redoData = registeredInstances.get(key);
        if (null != redoData) {
            redoData.setRegistered(true);
        }
    }
}

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.alibaba.cloud.nacos.discovery.NacosDiscoveryAutoConfiguration,\
  com.alibaba.cloud.nacos.endpoint.NacosDiscoveryEndpointAutoConfiguration,\
  com.alibaba.cloud.nacos.registry.NacosServiceRegistryAutoConfiguration,\
  com.alibaba.cloud.nacos.discovery.NacosDiscoveryClientConfiguration,\
  com.alibaba.cloud.nacos.discovery.reactive.NacosReactiveDiscoveryClientConfiguration,\
  com.alibaba.cloud.nacos.discovery.configclient.NacosConfigServerAutoConfiguration,\
  com.alibaba.cloud.nacos.loadbalancer.LoadBalancerNacosAutoConfiguration,\
  com.alibaba.cloud.nacos.NacosServiceAutoConfiguration
org.springframework.cloud.bootstrap.BootstrapConfiguration=\
  com.alibaba.cloud.nacos.discovery.configclient.NacosDiscoveryClientConfigServiceBootstrapConfiguration
org.springframework.context.ApplicationListener=\
  com.alibaba.cloud.nacos.discovery.logging.NacosLoggingListener

@Bean
@ConditionalOnBean({AutoServiceRegistrationProperties.class})
public NacosAutoServiceRegistration nacosAutoServiceRegistration(NacosServiceRegistry registry, AutoServiceRegistrationProperties autoServiceRegistrationProperties, NacosRegistration registration) {
    //实例化一个NacosAutoServiceRegistration
    return new NacosAutoServiceRegistration(registry, autoServiceRegistrationProperties, registration);
}

protected void register() {
    if (!this.registration.getNacosDiscoveryProperties().isRegisterEnabled()) {
        log.debug("Registration disabled.");
    } else {
        if (this.registration.getPort() < 0) {
            this.registration.setPort(this.getPort().get());
        }
  //调用父类的register
        super.register();
    }
}

public abstract class AbstractAutoServiceRegistration<R extends Registration> implements AutoServiceRegistration, ApplicationContextAware, ApplicationListener<WebServerInitializedEvent> {
    //...略

    //实现监听类的方法
    public void onApplicationEvent(WebServerInitializedEvent event) {
        this.bind(event);
    }

 //具体实现
    public void bind(WebServerInitializedEvent event) {
        ApplicationContext context = event.getApplicationContext();
        if (!(context instanceof ConfigurableWebServerApplicationContext) || !"management".equals(((ConfigurableWebServerApplicationContext)context).getServerNamespace())) {
            this.port.compareAndSet(0, event.getWebServer().getPort());
            //启动
            this.start();
        }
    }

    public void start() {
        if (!this.isEnabled()) {
            if (logger.isDebugEnabled()) {
                logger.debug("Discovery Lifecycle disabled. Not starting");
            }

        } else {
            if (!this.running.get()) {
                this.context.publishEvent(new InstancePreRegisteredEvent(this, this.getRegistration()));
                //调用注册的方法
                this.register();
                if (this.shouldRegisterManagement()) {
                    this.registerManagement();
                }

                this.context.publishEvent(new InstanceRegisteredEvent(this, this.getConfiguration()));
                this.running.compareAndSet(false, true);
            }

        }
    }
    //...略
}

protected void register() {
    //调用NacosServiceRegistry的register方法
    this.serviceRegistry.register(this.getRegistration());
}

public void register(Registration registration) {
    if (StringUtils.isEmpty(registration.getServiceId())) {
        log.warn("No service to register for nacos client...");
    } else {
        //实例化NamingService
        NamingService namingService = this.namingService();
        //服务id、组信息
        String serviceId = registration.getServiceId();
        String group = this.nacosDiscoveryProperties.getGroup();
        //实例信息封装
        Instance instance = this.getNacosInstanceFromRegistration(registration);
        try {
            //注册实例
            namingService.registerInstance(serviceId, group, instance);
            log.info("nacos registry, {} {} {}:{} register finished", new Object[]{group, serviceId, instance.getIp(), instance.getPort()});
        } catch (Exception var7) {
            if (this.nacosDiscoveryProperties.isFailFast()) {
                log.error("nacos registry, {} register failed...{},", new Object[]{serviceId, registration.toString(), var7});
                ReflectionUtils.rethrowRuntimeException(var7);
            } else {
                log.warn("Failfast is false. {} register failed...{},", new Object[]{serviceId, registration.toString(), var7});
            }
        }

    }
}

public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
    //检查服务实例设置的心跳时间是否合法
    NamingUtils.checkInstanceIsLegal(instance);
    String groupedServiceName = NamingUtils.getGroupedName(serviceName, groupName);
    if (instance.isEphemeral()) {
        BeatInfo beatInfo = this.beatReactor.buildBeatInfo(groupedServiceName, instance);
        this.beatReactor.addBeatInfo(groupedServiceName, beatInfo);
    }
 //服务注册
    this.serverProxy.registerService(groupedServiceName, groupName, instance);
}