作为后起之秀，Nacos基本要取代Eureka的位置，我没有在项目中使用过，只在本地跑了一下，处于好奇我想浅显的分析Nacos的实现，看看是否比Eureka更优秀
官网图
从图中可以看到，nacos似乎比eureka多了一致性协议，eureka是p2p，也就是非强一致性，貌似nacos解决了这个问题，nacos还有控制台，嗯这个确实更方便了
一、服务注册
1.1 客户端
eureka是利用SmartLifeCycle接口的生命周期方法來完成调用的。
nacos是利用的事件监听机制来触发的。都是固定的套路，首先就是分析NacosDiscoveryAutoConfiguration ，然后里面有个@Bean NacosAutoServiceRegistration.
spring的时间监听某个时间是通过泛型来判断的ApplicationListener<WebServerInitializedEvent>，也就是说是是web容器初始化完成就开始调用的。然后就是常规的封装注册信息，然后调用http接口
//临时节点特殊处理
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);
long instanceInterval = instance.getInstanceHeartBeatInterval();
beatInfo.setPeriod(instanceInterval == 0 ? DEFAULT_HEART_BEAT_INTERVAL : instanceInterval);
beatReactor.addBeatInfo(NamingUtils.getGroupedName(serviceName, groupName), beatInfo);
}
//调用http接口
serverProxy.registerService(NamingUtils.getGroupedName(serviceName, groupName), groupName, instance);
在调用http接口的时候，如果有多个服务端，他是随机选取的，如果随机选取的服务端调用失败，那么开始顺序的调用其他服务端接口
还有稍微有点特殊的地方就是，注册的时候它分临时节点还是持久化节点，如果是临时时节点他有额外的动作：立马加上心跳
心跳代码：
//搞了一个一次性的心跳
executorService.schedule(new BeatTask(beatInfo), 0, TimeUnit.MILLISECONDS);
//然后在BeatTask方法后有立马开启一个新的调度
run(){
long result = serverProxy.sendBeat(beatInfo);//发送http请求
long nextTime = result > 0 ? result : beatInfo.getPeriod();
//立马又开启一个
executorService.schedule(new BeatTask(beatInfo), nextTime, TimeUnit.MILLISECONDS);
}
我目前有2个疑问
- 为什么只有临时节点会立马开启一个心跳？
- 他的心跳这种定时任务，一旦上次发生异常，那么下次不会有心跳发生了（因为不会立马开启一个新的调度）
1.2 服务端
读了服务端代码感觉他的方法名字起的有一点乱，而且逻辑有点复杂，而且还不写注释。
在InstanceController的register()是入口
1.1.2 创建空服务
服务的创建中存在很多逻辑，这也是我读源码的时候头疼的地方，功能耦合性太高，你创建服务就创建服务，可以再其他地方进行类似健康检查之类的工作，他基本都柔和到一起了，它主要包含下面三个大功能(一个创建服务动作，做了好多事情)
- 创建Service，然后存在注册表中
- 开启健康检查任务，主要是为了服务剔除
- 加入listener
private Map<String, CopyOnWriteArrayList<RecordListener>> listeners = new ConcurrentHashMap<>();，listener的子类就是service，他有2个重要方法onChnage和onDelete，主要就是处理节点增删改之后的处理逻辑。这里加入listener，其实也是等待这处理的意思。nacos注册节点大思想就是异步的思想，比如现在他要写一个instance到内存，他是直接提交一个notification然后开启一个while死循环，然后这些listener逐个处理。
补充知识：关于注册，必须了解它的注册表，他的结构也非常复杂，必须通过官网的图解结合才能理解
翻译成代码就是Map<String, Map<String, Service>> serviceMap，其中第一个key是namespace，第二个key是service名字，最终存的是Service
该类中有一个重要字段private Map<String, Cluster> clusterMap = new HashMap<>();，这里就牵扯出了Cluster的概念。Cluster中有三个字段
//一个cluster有多个实例
@JSONField(serialize = false)
private Set<Instance> persistentInstances = new HashSet<>();
@JSONField(serialize = false)
private Set<Instance> ephemeralInstances = new HashSet<>();
//持有属于service的引用
@JSONField(serialize = false)
private Service service;
- namespace：是起到环境隔离的效果，比如dev stage prod
- service name：指的就是一个具体的服务，该服务可能有N个实例
- cluster：这个概念是最难理解的，下面是官网的图，可以理解成是的集合一组实例的集合，通过集群进行数据同步，而且可以看出serive和cluster是相互持有引用的
//创建空服务的入口
createEmptyService(namespaceId, serviceName, instance.isEphemeral());
//创建空服务最终调用的方法
public void createServiceIfAbsent(String namespaceId, String serviceName, boolean local, Cluster cluster) throws NacosException {
Service service = getService(namespaceId, serviceName);
//判断是否有服务
if (service == null) {
Loggers.SRV_LOG.info("creating empty service {}:{}", namespaceId, serviceName);
service = new Service();
if (cluster != null) {
//如果cluster不为空，那么service和cluster相互更新引用
cluster.setService(service);
service.getClusterMap().put(cluster.getName(), cluster);
}
service.validate();
if (local) {
//临时节点
putServiceAndInit(service);
} else {
//持久化节点
addOrReplaceService(service);
}
}
}
下面针对创建空服务三个功能进行具体分析
1. 存在注册表中
serviceMap.get(service.getNamespaceId()).put(service.getName(), service);
2. 健康检查
nacos的定时任务粒度是service，也就是每个service就开启一个定时任务，这种控制带来的就是更灵敏。但是占用内存更高。
心跳是每5秒执行一次。
如果超过15秒没有心跳那么就会发布心跳超时任务
如果超过30秒没有心跳那么就删除该节点
3. 添加到listener中
//临时
consistencyService.listen(KeyBuilder.buildInstanceListKey(service.getNamespaceId(), service.getName(), true), service);
//持久化
consistencyService.listen(KeyBuilder.buildInstanceListKey(service.getNamespaceId(), service.getName(), false), service);
什么是listener你？，看下面的源码，他就是一个map，key主要由namespace和service组成， service本身就是集成RecordListener，所以CopyOnWriteArrayList中存放的就是service，可以理解成他就是一个service的集合，
Map<String, CopyOnWriteArrayList<RecordListener>> listeners
单独分析listener没有意义，必须要结合notifier来分析
1.1.3 存储instance
上面已经创建了service，相当于给instance创建了个容器，下面就是朝容器里面放instance,这里又分为临时节点和持久化节点。
主要做了2部分内容，一个是向阻塞队列中插入值，然后有个while循环一直以阻塞的方式取改队列，然后和上面的listener结合起来进行节点状态变更的处理，主要就是判断是增加了节点，删除了节点等。另外一部分好像是服务同步的。
入口
consistencyService.put(key, instances);//这个就是存储instance和服务同步的入口
onPut(key, value);//加入一个新的notifier，然后异步的处理加入新的instance
taskDispatcher.addTask(key);//处理服务同步
这次只针对临时节点分析
这里主要是取阻塞队列之后的处理比较重要。主要切入方法是updateIPs,针对这个源码有几个局部变量我分析一下
- clusterMap：key是cluster name，value是cluster对象
- ipMap：key是cluster名字，value是instance列表，这个方法看上去很长，其实都是在组织ipMap
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) {
...................
}
//上面代码都是在组织ipMap
//下面的代码就是循环调用cluster的updateIPs方法
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);
}
}
搞了这么一大圈就是就是调用cluster的updateIPs方法，因为cluster是instance的集合，nacos中添加一个instance做的逻辑太复杂了，按照道理添加实例无非就是向注册表中插入一个instance，但是他搞这么麻烦主要是他的那段代码也是为了适应更新操作。
- 找出更新的节点，然后进行处理
- 找出新增的节点，然后进行处理
- 找出要剔除的节点，然后进行处理
- 整个过程处处体现了copyOnWrite的思想
public void updateIPs(List<Instance> ips, boolean ephemeral) {
Set<Instance> toUpdateInstances = ephemeral ? ephemeralInstances : persistentInstances;
HashMap<String, Instance> oldIPMap = new HashMap<>(toUpdateInstances.size());
for (Instance ip : toUpdateInstances) {
oldIPMap.put(ip.getDatumKey(), ip);
}
List<Instance> updatedIPs = updatedIPs(ips, oldIPMap.values());
if (updatedIPs.size() > 0) {
......
}
List<Instance> newIPs = subtract(ips, oldIPMap.values());
if (newIPs.size() > 0) {
....
}
List<Instance> deadIPs = subtract(oldIPMap.values(), ips);
if (deadIPs.size() > 0) {
....
}
toUpdateInstances = new HashSet<>(ips);
if (ephemeral) {
ephemeralInstances = toUpdateInstances;
} else {
persistentInstances = toUpdateInstances;
}
}
1.1.4 服务同步
核心代码在下面，关于syncData的源码，在后面在分析
long timestamp = System.currentTimeMillis();
boolean success = NamingProxy.syncData(data, task.getTargetServer());
if (!success) {
SyncTask syncTask = new SyncTask();
syncTask.setKeys(task.getKeys());
syncTask.setRetryCount(task.getRetryCount() + 1);
syncTask.setLastExecuteTime(timestamp);
syncTask.setTargetServer(task.getTargetServer());
retrySync(syncTask);
} else {
// clear all flags of this task:
for (String key : task.getKeys()) {
taskMap.remove(buildKey(key, task.getTargetServer()));
}
}
至此整个临时节点的服务注册就算分析完了，我大致在总结一遍
- 创建空service对象，在空service对象中开启定时剔除任务，向listener中添加对象为了后面异步存储instance服务（注册表结构复杂，然后一个方法里面 功能太多）
- 存储instance对象，这里采用异步的方式从阻塞队列中取数据，然后还处理（异步是特色，copyOnWrite对整体性能进一步提高，但是我总是感觉一个方法里面的功能还是太多，导致功能不清晰）
- 增加同步任务（这个整体功能清晰，有spring的感觉）
二、服务续约
在分析服务端代码的时候发现，如果在心跳的时候发现没有instance，会调用注册接口，这个是为了啥？
if (instance == null) {
instance = new Instance();
instance.setPort(clientBeat.getPort());
instance.setIp(clientBeat.getIp());
instance.setWeight(clientBeat.getWeight());
instance.setMetadata(clientBeat.getMetadata());
instance.setClusterName(clusterName);
instance.setServiceName(serviceName);
instance.setInstanceId(instance.generateInstanceId());
instance.setEphemeral(clientBeat.isEphemeral());
serviceManager.registerInstance(namespaceId, serviceName, instance);
}
Service service = serviceManager.getService(namespaceId, serviceName);
if (service == null) {
throw new NacosException(NacosException.SERVER_ERROR, "service not found: " + serviceName + "@" + namespaceId);
}
service.processClientBeat(clientBeat);
在processClientBeant的方法中，和eureka稍微不同的是，它也是采用异步处理的
HealthCheckReactor.scheduleNow(clientBeatProcessor);//异步的去处理
instance.setLastBeat(System.currentTimeMillis());//心跳核心代码
三、服务同步
public String onSyncDatum(HttpServletRequest request, HttpServletResponse response) throws Exception {
Map<String, Datum<Instances>> dataMap =
serializer.deserializeMap(entity.getBytes(), Instances.class);
for (Map.Entry<String, Datum<Instances>> entry : dataMap.entrySet()) {
if (KeyBuilder.matchEphemeralInstanceListKey(entry.getKey())) {
String namespaceId = KeyBuilder.getNamespace(entry.getKey());
String serviceName = KeyBuilder.getServiceName(entry.getKey());
if (!serviceManager.containService(namespaceId, serviceName)
&& switchDomain.isDefaultInstanceEphemeral()) {
//如果没有服务就创建一个控服务，在注册的时候已经分析过
serviceManager.createEmptyService(namespaceId, serviceName, true);
}
//前面注册的时候也分析过这个方法，这个方法就是加入一个notifier
consistencyService.onPut(entry.getKey(), entry.getValue().value);
}
}
return "ok";
}
服务同步的代码和注册的代码基本是一致的。没有服务就创建空服务，然后加入一个notifier异步的处理新的instance。
四、服务下线
其实在服务注册的时候已经分析过了，他的服务剔除是以service为单位的。
2027
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
