SpringCloud Alibaba Nacos註冊中心原始碼淺析

一、前置瞭解

1.1 簡介

Nacos是一款阿里巴巴推出的一款微服務發現、配置管理框架。我們本次對將對它的服務註冊發現功能進行簡單原始碼分析。

1.2 流程

Nacos的分析分為兩部分，一部分是我們的客戶端（將自己註冊到Nacos），另一部分是Nacos Server處理我們的註冊請求等。

1.3 要分析demo示例

細節篇幅不多展示，大致如下

1.3.1 客戶端方面：

引入了pom依賴

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

並在application.yml配置好nacos地址（本地），我們的這個應用啟動後會向Nacos服務端去註冊。

1.3.2 Nacos服務端方面

我們從https://github.com/alibaba/nacos，即Nacos的官網github按tag拉下原始碼到本地。

會有很多模組：address、api、client、cmdb、core、console等等。

從console裡的Nacos.java檔案啟動即可，它是個SpringBoot應用，啟動後就可以處理註冊等請求了。

二、Nacos客戶端原始碼流程

2.1 自動配置觸發邏輯入口

開啟客戶端引入的依賴包的pom，只引入了spring-cloud-alibaba-nacos-discovery：

SpringCloud系列都是通過spring.factories檔案進行自動配置，我們開啟spring-cloud-alibaba-nacos-discovery的spring.factories檔案：

去看看NacosDiscoveryAutoConfiguration這個名字的，名字可以看出它是和自動註冊發現相關的配置類：

@Configuration
@EnableConfigurationProperties
@ConditionalOnNacosDiscoveryEnabled
@ConditionalOnProperty(value = "spring.cloud.service-registry.auto-registration.enabled", matchIfMissing = true)
@AutoConfigureAfter({ AutoServiceRegistrationConfiguration.class,
		AutoServiceRegistrationAutoConfiguration.class })
public class NacosDiscoveryAutoConfiguration {

	@Bean
	public NacosServiceRegistry nacosServiceRegistry(
			NacosDiscoveryProperties nacosDiscoveryProperties) {
		return new NacosServiceRegistry(nacosDiscoveryProperties);
	}

	@Bean
	@ConditionalOnBean(AutoServiceRegistrationProperties.class)
	public NacosRegistration nacosRegistration(
			NacosDiscoveryProperties nacosDiscoveryProperties,
			ApplicationContext context) {
		return new NacosRegistration(nacosDiscoveryProperties, context);
	}

	@Bean
	@ConditionalOnBean(AutoServiceRegistrationProperties.class)
	public NacosAutoServiceRegistration nacosAutoServiceRegistration(
			NacosServiceRegistry registry,
			AutoServiceRegistrationProperties autoServiceRegistrationProperties,
			NacosRegistration registration) {
		return new NacosAutoServiceRegistration(registry,
				autoServiceRegistrationProperties, registration);
	}
}

註冊了三個Bean，各個Bean名字也是見名知義，上面兩個是服務與nacos註冊邏輯本身，最後一個Auto的才是自動配置相關的，應該是入口。

開啟NacosAutoServiceRegistration原始碼，會發現它的父類AbstractAutoServiceRegistration實現了ApplicationListener介面，一般很多框架都是通過監聽spring事件機制然後開始運作各自的原始碼邏輯，開啟ApplicationListener介面的重寫方法看看：

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

	//略***

	@Override
	@SuppressWarnings("deprecation")
	public void onApplicationEvent(WebServerInitializedEvent event) {
		bind(event);
	}

註冊入口應該就是這裡，bind方法開始執行nacos自己的邏輯，bind方法：

	public void bind(WebServerInitializedEvent event) {
		ApplicationContext context = event.getApplicationContext();
		//略
		this.port.compareAndSet(0, event.getWebServer().getPort());
		this.start();
	}

start:

public void start() {
   //略
   if (!this.running.get()) {
      this.context.publishEvent(
            new InstancePreRegisteredEvent(this, getRegistration()));
      register();
      if (shouldRegisterManagement()) {
         registerManagement();
      }
      this.context.publishEvent(
            new InstanceRegisteredEvent<>(this, getConfiguration()));
      this.running.compareAndSet(false, true);
   }

}

這裡就可以發現自動配置觸發的註冊方法了，register();，後續就是如何註冊了！

2.2 客戶端註冊邏輯 register()

不斷跟進剛剛的多個register()重名方法，會來到真正的register方法，如下：

	public void register(Registration registration) {
		//略
		String serviceId = registration.getServiceId();
		Instance instance = getNacosInstanceFromRegistration(registration);

		try {
			namingService.registerInstance(serviceId, instance);
			//略
		}
		catch (Exception e) {
			//略
		}
	}

邏輯比較直接，主要是獲取服務id（比如服務名啥的）+這個例項的具體資訊（封裝成Instance），最後通過namingService去註冊，跟進註冊：

    public void registerInstance(String serviceName, String groupName, Instance instance) throws NacosException {
		//判斷是否是臨時節點
        if (instance.isEphemeral()) {
            BeatInfo beatInfo = new BeatInfo();
            beatInfo.setServiceName(NamingUtils.getGroupedName(serviceName, groupName));
            beatInfo.setIp(instance.getIp());
            beatInfo.setPort(instance.getPort());
            beatInfo.setCluster(instance.getClusterName());
            beatInfo.setWeight(instance.getWeight());
            beatInfo.setMetadata(instance.getMetadata());
            beatInfo.setScheduled(false);
            //略
            beatReactor.addBeatInfo(NamingUtils.getGroupedName(serviceName, groupName), beatInfo);
        }

        serverProxy.registerService(NamingUtils.getGroupedName(serviceName, groupName), groupName, instance);
    }

心跳機制

其實這裡可以看出如果不是臨時節點是不需要傳送心跳訊息的，這裡心跳機制是通過beatReactor.addBeatInfo裡內部的一個定時任務去實現的，核心就是內部的：

            long result = serverProxy.sendBeat(beatInfo);
            long nextTime = result > 0 ? result : beatInfo.getPeriod();
            executorService.schedule(new BeatTask(beatInfo), nextTime, TimeUnit.MILLISECONDS);

通過執行緒池跑任務，定時訪問Nacos服務端的/instance/beat介面，傳送HTTP請求 表示自己活著

繼續看註冊

剛剛registerInstance裡的

serverProxy.registerService(NamingUtils.getGroupedName(serviceName, groupName), groupName, instance);

繼續跟進：

    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>(9);
        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", JSON.toJSONString(instance.getMetadata()));

        reqAPI(UtilAndComs.NACOS_URL_INSTANCE, params, HttpMethod.POST);

    }

其實就是準備引數準備發http請求了哈，註冊的介面地址是NACOS_URL_INSTANCE，也就是：/instance的post請求

客戶端註冊總結：

1.通過SpringCloud一貫使用的spring.factories檔案進行自動配置

2.自動配置類將自己注入IOC容器，並實現了ApplicationListener介面，在web容器初始化事件釋出之後載入自己的邏輯

3.載入註冊邏輯，通過傳送http請求到/instance介面將本身的資訊發給Nacos服務端，以及心跳任務定時傳送，告訴自己活著

三、Nacos服務端處理註冊

上面有說到nacos客戶端註冊是通過傳送http請求到/instance介面。我們看看/instance介面做了什麼。Nacos服務端的controller原始碼如下：

@RestController
@RequestMapping(UtilsAndCommons.NACOS_NAMING_CONTEXT + "/instance")
public class InstanceController {
    //...略

    @CanDistro
    @PostMapping
    public String register(HttpServletRequest request) throws Exception {

        String serviceName = WebUtils.required(request, CommonParams.SERVICE_NAME);
        String namespaceId = WebUtils.optional(request, CommonParams.NAMESPACE_ID, Constants.DEFAULT_NAMESPACE_ID);

        serviceManager.registerInstance(namespaceId, serviceName, parseInstance(request));
        return "ok";
    }
}

跟進裡面的serviceManager.registerInstance註冊方法：

    public void registerInstance(String namespaceId, String serviceName, Instance instance) throws NacosException {

        createEmptyService(namespaceId, serviceName, instance.isEphemeral());

        Service service = getService(namespaceId, serviceName);

        if (service == null) {
            throw new NacosException(NacosException.INVALID_PARAM,
                "service not found, namespace: " + namespaceId + ", service: " + serviceName);
        }

        addInstance(namespaceId, serviceName, instance.isEphemeral(), instance);
    }

createEmptyService是要在放入instance例項（即註冊的那個節點資訊）之前確保service存在，不存在則建立一個，之後就可以通過getService取出來了。最後再通過addInstance繼續註冊

看看createEmptyService是怎麼建立的，什麼結構？

3.1 createEmptyService建立保證Service

通過斷點不斷跟進createEmptyService方法原始碼，會來到ServiceManager.java的putService方法：

    public void putService(Service service) {
        if (!serviceMap.containsKey(service.getNamespaceId())) {
            synchronized (putServiceLock) {
                if (!serviceMap.containsKey(service.getNamespaceId())) {
                    serviceMap.put(service.getNamespaceId(), new ConcurrentHashMap<>(16));
                }
            }
        }
        serviceMap.get(service.getNamespaceId()).put(service.getName(), service);
    }

最後是放到到一個serviceMap的Map結構去了，如下：

private Map<String, Map<String, Service>> serviceMap = new ConcurrentHashMap<>();

雙層Map，內部含義其實是：

Map<namespace,Map<group:serviceNmae,Service>>//第一層key是namespace，第二層裡才是name和service

實際上放入map之後，還會把service初始化，呼叫init方法，內部會執行健康檢查：

1.某個例項超過15秒沒收到心跳則把它的healthy屬性設定為false

2.繼續超過30秒沒收到心跳就會直接剔除這個例項

3.2 addInstance註冊

回到前面的註冊地方，最後保證了有Service之後繼續走主邏輯,addInstance:

addInstance(namespaceId, serviceName, instance.isEphemeral(), instance);

跟進

    public void addInstance(String namespaceId, String serviceName, boolean ephemeral, Instance... ips) throws NacosException {

        String key = KeyBuilder.buildInstanceListKey(namespaceId, serviceName, ephemeral);

        Service service = getService(namespaceId, serviceName);

        synchronized (service) {
            List<Instance> instanceList = addIpAddresses(service, ephemeral, ips);

            Instances instances = new Instances();
            instances.setInstanceList(instanceList);

            consistencyService.put(key, instances);
        }
    }

最後是執行consistencyService.put(key, instances);註冊，這裡會有兩個實現DistroConsistencyServiceImpl和RaftConsistencyServiceImpl，分別對應著註冊中心的AP實現和CP實現，一個基於記憶體優先可用性（A），一個基於磁碟優先一致性（C），是CAP理論裡的取捨。CAP具體可看：https://baike.baidu.com/item/CAP原則/5712863?fr=aladdin

四、Nacos服務端AP模式實現：DistroConsistencyServiceImpl

Nacos的AP模式採用distro協議，Distro是阿里的自創協議，Distro 協議被定位為 臨時資料的一致性協議

繼續看之前的原始碼，註冊最後是來到：

consistencyService.put(key, instances);

跟進：

    @Override
    public void put(String key, Record value) throws NacosException {
        //1.將註冊例項更新到記憶體登錄檔
        onPut(key, value);
        //2.同步例項資訊到Nacos Server叢集其它節點
        taskDispatcher.addTask(key);
    }

如加的註釋這樣，分了兩步實現

4.1 onPut將註冊例項更新到記憶體登錄檔

跟進onPut原始碼：

    public void onPut(String key, Record value) {

        if (KeyBuilder.matchEphemeralInstanceListKey(key)) {
            //封裝資料節點儲存
            Datum<Instances> datum = new Datum<>();
            datum.value = (Instances) value;
            datum.key = key;
            datum.timestamp.incrementAndGet();
            dataStore.put(key, datum);
        }

        if (!listeners.containsKey(key)) {
            return;
        }
		//只要傳key就拿到上面的節點去更新了
        notifier.addTask(key, ApplyAction.CHANGE);
    }

這裡也看到了最後notifier.addTask運用了生產者消費者的思想，裡面是新增一個任務到阻塞佇列中去，等著處理，因為這些操作本身不需要立即返回成功，對提升效能有很大幫助。

傳了ApplyAction.CHANGE型別，我們跟進notifier.addTask，會發現是在Notifier內部類裡，它是多執行緒Runnable的實現類，邏輯都在run方法裡，等著對應的執行緒調起執行。

public class Notifier implements Runnable {
		//略部分程式碼
        @Override
        public void run() {

            while (true) {
                try {
                    //略部分程式碼
                    for (RecordListener listener : listeners.get(datumKey)) {
                        count++;
                        try {
                            if (action == ApplyAction.CHANGE) {
                                listener.onChange(datumKey, dataStore.get(datumKey).value);
                                continue;
                            }
                            if (action == ApplyAction.DELETE) {
                                listener.onDelete(datumKey);
                                continue;
                            }
                        } catch (Throwable e) {
                            //略
                        }
                    }

                    //略
                } catch (Throwable e) {
                    //略
                }
            }
        }
    }

判斷是剛才我們傳的ApplyAction.CHANGE會去執行listener.onChange，這裡有多個實現，我們可以通過打斷點進入的是com.alibaba.nacos.naming.core.Service類中

    public void onChange(String key, Instances value) throws Exception {
        //略
        updateIPs(value.getInstanceList(), KeyBuilder.matchEphemeralInstanceListKey(key));
        recalculateChecksum();
    }

核心就是updateIPs：

    public void updateIPs(Collection<Instance> instances, boolean ephemeral) {
        Map<String, List<Instance>> ipMap = new HashMap<>(clusterMap.size());
        for (String clusterName : clusterMap.keySet()) {
            ipMap.put(clusterName, new ArrayList<>());
        }

        for (Instance instance : instances) {
            try {
                if (instance == null) {
                    Loggers.SRV_LOG.error("[NACOS-DOM] received malformed ip: null");
                    continue;
                }

                if (StringUtils.isEmpty(instance.getClusterName())) {
                    instance.setClusterName(UtilsAndCommons.DEFAULT_CLUSTER_NAME);
                }

                if (!clusterMap.containsKey(instance.getClusterName())) {
                    Loggers.SRV_LOG.warn("cluster: {} not found, ip: {}, will create new cluster with default configuration.",
                        instance.getClusterName(), instance.toJSON());
                    Cluster cluster = new Cluster(instance.getClusterName(), this);
                    cluster.init();
                    getClusterMap().put(instance.getClusterName(), cluster);
                }

                List<Instance> clusterIPs = ipMap.get(instance.getClusterName());
                if (clusterIPs == null) {
                    clusterIPs = new LinkedList<>();
                    ipMap.put(instance.getClusterName(), clusterIPs);
                }

                clusterIPs.add(instance);
            } catch (Exception e) {
                Loggers.SRV_LOG.error("[NACOS-DOM] failed to process ip: " + instance, e);
            }
        }

        for (Map.Entry<String, List<Instance>> entry : ipMap.entrySet()) {
            //make every ip mine
            List<Instance> entryIPs = entry.getValue();
            clusterMap.get(entry.getKey()).updateIPs(entryIPs, ephemeral);
        }

        setLastModifiedMillis(System.currentTimeMillis());
        getPushService().serviceChanged(this);
        StringBuilder stringBuilder = new StringBuilder();

        for (Instance instance : allIPs()) {
            stringBuilder.append(instance.toIPAddr()).append("_").append(instance.isHealthy()).append(",");
        }

    }

為了防止讀寫併發衝突，方法第一句直接建立了一個新的HashMap，然後去操作新的HashMap，操作完了之後再去替換老的Map資料，CopyOnWrite的思想。

Eureka防止讀寫衝突用的是多級快取結構，多級快取定時同步，客戶端感知及時性不如Nacos。

最後還發布了服務變化事件

4.2 同步例項資訊到Nacos Server叢集其它節點

回到之前的程式碼，put方法中是taskDispatcher.addTask(key);進行同步資訊到叢集其它節點，跟進程式碼：

        public void addTask(String key) {
            queue.offer(key);
        }

就是把節點的key加入到阻塞佇列中了，等待之後執行，這是內部類TaskScheduler裡的方法，看看整體：

public class TaskScheduler implements Runnable {

        //略

        public void addTask(String key) {
            queue.offer(key);
        }

        @Override
        public void run() {

            List<String> keys = new ArrayList<>();
            while (true) {

                try {

                    String key = queue.poll(partitionConfig.getTaskDispatchPeriod(),
                        TimeUnit.MILLISECONDS);

                    if (Loggers.DISTRO.isDebugEnabled() && StringUtils.isNotBlank(key)) {
                        Loggers.DISTRO.debug("got key: {}", key);
                    }

                    if (dataSyncer.getServers() == null || dataSyncer.getServers().isEmpty()) {
                        continue;
                    }

                    if (StringUtils.isBlank(key)) {
                        continue;
                    }

                    if (dataSize == 0) {
                        keys = new ArrayList<>();
                    }

                    keys.add(key);
                    dataSize++;

                    if (dataSize == partitionConfig.getBatchSyncKeyCount() ||
                        (System.currentTimeMillis() - lastDispatchTime) > partitionConfig.getTaskDispatchPeriod()) {

                        for (Server member : dataSyncer.getServers()) {
                            if (NetUtils.localServer().equals(member.getKey())) {
                                continue;
                            }
                            SyncTask syncTask = new SyncTask();
                            syncTask.setKeys(keys);
                            syncTask.setTargetServer(member.getKey());

                            if (Loggers.DISTRO.isDebugEnabled() && StringUtils.isNotBlank(key)) {
                                Loggers.DISTRO.debug("add sync task: {}", JSON.toJSONString(syncTask));
                            }

                            dataSyncer.submit(syncTask, 0);
                        }
                        lastDispatchTime = System.currentTimeMillis();
                        dataSize = 0;
                    }

                } catch (Exception e) {
                    Loggers.DISTRO.error("dispatch sync task failed.", e);
                }
            }
        }
    }

可以看到if (dataSize == partitionConfig.getBatchSyncKeyCount() ||
(System.currentTimeMillis() - lastDispatchTime) > partitionConfig.getTaskDispatchPeriod())

達到一定是數量或時間差，就開始提交批量傳送同步任務。邏輯在同步類DataSyncer的run方法裡，裡面就是往/distro/datum介面傳送資料同步。

五、Nacos服務端CP模式實現：RaftConsistencyServiceImpl

Nacos主要是AP模式，CP模式的RaftConsistencyServiceImpl具體就不展開了，這裡只簡單介紹一下大概實現方式：

1.是阿里自己實現的CP模式的簡單raft協議

2.判斷自己是Leader節點的話才執行邏輯，否則轉發給Leader

3.同步更新例項資料到磁碟，非同步更新記憶體登錄檔

4.用CountDownLatch實現，必須叢集半數以上節點寫入成功才返回客戶端成功

5.成功後呼叫/raft/datum/commit介面提交

六、服務發現

客戶端通過呼叫/instance/list介面獲取服務端map相關資料，並且會有個延時執行的定時任務去不斷更新最新服務資料