Nacos整合之服务注册编码实践

<artifactId>spring-cloud-alibaba-nacos-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-cloud-alibaba-nacos-demo</name>
<packaging>pom</packaging>
<description>Spring Cloud Alibaba Nacos Demo</description>

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>ltd.newbee.cloud</groupId>
    <artifactId>nacos-provider-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>nacos-provider-demo</name>
    <description>Spring Cloud Alibaba Provider Demo</description>

    <parent>
        <groupId>ltd.newbee.cloud</groupId>
        <artifactId>spring-cloud-alibaba-nacos-demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
    </dependencies>
</project>

package ltd.newbee.cloud.api;

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

@RestController
public class NewBeeCloudGoodsAPI {

    @Value("${server.port}")
    private String applicationServerPort; // 读取当前应用的启动端口

    @GetMapping("/goodsServiceTest")
    public String goodsServiceTest() {
        // 返回信息给调用端
        return "this is goodsService from port:" + applicationServerPort;
    }
}

package ltd.newbee.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProviderApplication {

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

# 项目启动端口
server.port=8091
# 应用名称
spring.application.name=newbee-cloud-goods-service
# 注册中心 Nacos 的访问地址
spring.cloud.nacos.discovery.server-addr=localhost:8848
# 登录名(默认 username，可自行修改)
spring.cloud.nacos.username=nacos
# 密码(默认 password，可自行修改)
spring.cloud.nacos.password=nacos

http://localhost:8848/nacos/v1/ns/catalog/instances?serviceName=newbee-cloud-goods-service&clusterName=DEFAULT&pageSize=10&pageNo=1&namespaceId=

{"list": [{"instanceId": "192.168.1.105#8091#DEFAULT#DEFAULT_GROUP@@newbee-cloud-goods-service", "ip": "192.168.1.105", "port": 8091, "weight": 1.0, "healthy": true, "enabled": true, "ephemeral": true, "clusterName": "DEFAULT", "serviceName": "DEFAULT_GROUP@@newbee-cloud-goods-service", "metadata": {"preserved.register.source": "SPRING_CLOUD"}, "lastBeat": 1648392838653, "marked": false, "app": "unknown", "instanceHeartBeatInterval": 5000, "instanceHeartBeatTimeout": 15000, "ipDeleteTimeout": 30000}], "count": 1}

xxx is not found!;

2023-06-22 22:37:11.457 INFO 6332 --- [ main ]
c.a.c.n.registry.NacosServiceRegistry : nacos registry, DEFAULT_GROUP
newbee-cloud-goods-service 192.168.1.105:8091 register finished

package com.alibaba.cloud.nacos.registry;

// 配置类
@Configuration(proxyBeanMethods = false)
// 属性值配置
@EnableConfigurationProperties
// 自动配置生效条件 1
@ConditionalOnNacosDiscoveryEnabled
// 自动配置生效条件 2
@ConditionalOnProperty(value =
        "spring.cloud.service-registry.auto-registration.enabled",
        matchIfMissing = true)
// 自动配置时机在 AutoServiceRegistrationConfiguration、
// AutoServiceRegistrationAutoConfiguration、NacosDiscoveryAutoConfiguration 之后
@AutoConfigureAfter({AutoServiceRegistrationConfiguration.class,
        AutoServiceRegistrationAutoConfiguration.class,
        NacosDiscoveryAutoConfiguration.class})
public class NacosServiceRegistryAutoConfiguration {
    @Bean // 注册 NacosRegistration 到 IoC 容器中
    @ConditionalOnBean(AutoServiceRegistrationProperties.class)
    // 当前 IoC 容器中存在 AutoServiceRegistrationProperties 类型的 Bean 时该 Bean 时注册
    public NacosRegistration nacosRegistration(
            ObjectProvider<List<NacosRegistrationCustomizer>> registrationCustomizers,
            NacosDiscoveryProperties nacosDiscoveryProperties,
            ApplicationContext context) {
        return new NacosRegistration(registrationCustomizers.getIfAvailable(),
                nacosDiscoveryProperties, context);
    }

    @Bean // 注册 NacosAutoServiceRegistration 到 IoC 容器中
    @ConditionalOnBean(AutoServiceRegistrationProperties.class)
    // 当前 IoC容器中存在 AutoServiceRegistrationProperties 类型的 Bean 时该 Bean 时注册
    public NacosAutoServiceRegistration nacosAutoServiceRegistration(
            NacosServiceRegistry registry,
            AutoServiceRegistrationProperties autoServiceRegistrationProperties,
            NacosRegistration registration) {
        return new NacosAutoServiceRegistration(registry,
                autoServiceRegistrationProperties, registration);
    }
}

public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
    NamingUtils.checkInstanceIsLegal(instance);
    String groupedServiceName = NamingUtils.getGroupedName(serviceName, groupName);
    //是否为临时服务。默认为临时服务，即默认发送“心跳”信息至 Nacos Server
    if (instance.isEphemeral()) {
        BeatInfo beatInfo = beatReactor.buildBeatInfo(groupedServiceName, instance);
        //创建“心跳”线程，向 Nacos Server 发送“心跳”信息
        beatReactor.addBeatInfo(groupedServiceName, beatInfo);
    }
    //向 Nacos Server 注册服务
    serverProxy.registerService(groupedServiceName, groupName, instance);
}

/**
 * register a instance to service with specified instance properties.
 *
 * @param serviceName name of service
 * @param groupName group of service
 * @param instance instance to register
 * @throws NacosException nacos exception
 */
public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
    NAMING_LOGGER.info("[REGISTER-SERVICE] {} registering service {} with instance: {}", namespaceId, serviceName, instance);

    final Map<String, String> params = new HashMap<String, String>(16);

    /** 封装请求参数 Start **/
    params.put(CommonParams.NAMESPACE_ID, namespaceId);
    params.put(CommonParams.SERVICE_NAME, serviceName);
    params.put(CommonParams.GROUP_NAME, groupName);
    params.put(CommonParams.CLUSTER_NAME, instance.getClusterName());
    params.put("ip", instance.getIp());
    params.put("port", String.valueOf(instance.getPort()));
    params.put("weight", String.valueOf(instance.getWeight()));
    params.put("enable", String.valueOf(instance.isEnabled()));
    params.put("healthy", String.valueOf(instance.isHealthy()));
    params.put("ephemeral", String.valueOf(instance.isEphemeral()));
    params.put("metadata", JacksonUtils.toJson(instance.getMetadata()));
    /** 封装请求参数 End **/

    //向 Nacos Server 发送 HTTP 请求，完成服务的注册
    reqApi(UtilAndComs.nacosUrlInstance, params, HttpMethod.POST);
}

/**
 * Add beat information.
 *
 * @param serviceName service name
 * @param beatInfo    beat information
 */
public void addBeatInfo(String serviceName, BeatInfo beatInfo) {
    NAMING_LOGGER.info("[BEAT] adding beat: {} to beat map.", beatInfo);
    String key = buildKey(serviceName, beatInfo.getIp(), beatInfo.getPort());
    BeatInfo existBeat = null;
    if ((existBeat = dom2Beat.remove(key)) != null) {
        existBeat.setStopped(true);
    }
    dom2Beat.put(key, beatInfo);
    //启动“心跳”线程
    executorService.schedule(new BeatTask(beatInfo), beatInfo.getPeriod(),
            TimeUnit.MILLISECONDS);
    MetricsMonitor.getDom2BeatSizeMonitor().set(dom2Beat.size());
}

class BeatTask implements Runnable {

    BeatInfo beatInfo;

    public BeatTask(BeatInfo beatInfo) {
        this.beatInfo = beatInfo;
    }

    @Override
    public void run() {
        if (beatInfo.isStopped()) {
            return;
        }
        long nextTime = beatInfo.getPeriod();
        try {
            //向 Nacos Server 发送“心跳”请求
            JsonNode result = serverProxy.sendBeat(beatInfo, beatReactor);
            this.lightBeatEnabled = lightBeatEnabled;

            long interval = result.get("clientBeatInterval").asLong();
            boolean lightBeatEnabled = false;
            if (result.has(CommonParams.LIGHT_BEAT_ENABLED)) {
                lightBeatEnabled = result.get(CommonParams.LIGHT_BEAT_
                        ENABLED).asBoolean();
            }
            beatReactor.this.lightBeatEnabled = lightBeatEnabled;
            if (interval > 0) {
                nextTime = interval;
            }
            int code = NamingResponseCode.OK;
            if (result.has(CommonParams.CODE)) {
                code = result.get(CommonParams.CODE).asInt();
            }
            //Nacos Server 返回该服务不存在，需要重新注册
            if (code == NamingResponseCode.RESOURCE_NOT_FOUND) {
                Instance instance = new Instance();
                instance.setPort(beatInfo.getPort());
                instance.setIp(beatInfo.getIp());
                instance.setWeight(beatInfo.getWeight());
                instance.setMetadata(beatInfo.getMetadata());
                instance.setClusterName(beatInfo.getCluster());
                instance.setServiceName(beatInfo.getServiceName());
                instance.setInstanceId(beatInfo.getInstanceId());
                instance.setEphemeral(true);
                try {
                    serverProxy.registerService(beatInfo.getServiceName(),
                            NamingUtils.getGroupName(beatInfo.
                                    getServiceName()), instance);
                } catch (Exception ignore) {
                } catch (NacosException ex) {
                    NAMING_LOGGER.error("[CLIENT-BEAT] failed to send beat: {}, msg: {}",
                            JacksonUtils.toJson(beatInfo), ex.getErrCode(),
                            ex.getErrMsg());
                } catch (Exception unknownEx) {
                    NAMING_LOGGER.error("[CLIENT-BEAT] failed to send beat: {}, unknown exception msg: {}",
                            JacksonUtils.toJson(beatInfo), unknownEx.getMessage(),
                            unknownEx);
                } finally {
                    //启动下一次"心跳"线程，循环执行 BeatTask 线程的 run() 方法，定时发送"心跳"信息
                    executorService.schedule(new BeatTask(beatInfo), nextTime,
                            TimeUnit.MILLISECONDS);
                }
            }
        }
    }
}