Sentinel源码解析之NodeSelectorSlot

绝地灬酷狼 2023-01-22 12:51 19阅读 0赞

> 原创不易，转载请注明出处

### 文章目录 ###

*   *   *  前言
         *  1. 源码剖析
         *   *  1.1 entry方法
             *  1.2 exit
         *  总结

--------------------

### 前言 ###

我们在《[Sentinel源码解析之slotchain构建过程][Sentinel_slotchain]》一文中介绍了slot链的构建过程（创建），并分析了其源码，需要注意的是，在sentinel中，一个资源对应着一个slot链，毫不夸张的说sentinel的核心其实就是这个slot链，一看到这个链，我们更应该想到的是责任链设计模式（不知道的同学需要百度研究下），sentinel其实就是个拦截器链，比如一个请求过来，经过层层slot拦截，全部满足要求就继续执行，不通过就抛出异常，从本篇开始我们就按照调用顺序深入剖析下它的各个slot，看看每个slot都是干什么的，就从第一个slot NodeSelectorSlot开始，这个NodeSelectorSlot从命名上就能猜出来，做node选择的slot。

### 1. 源码剖析 ###

看slot的源码，我们要时刻记着，一个资源对应一个slot链  
这里我们先看下NodeSelectorSlot它的成员变量

/** * {@link DefaultNode}s of the same resource in different context. */
        private volatile Map<String, DefaultNode> map = new HashMap<String, DefaultNode>(10);

就是个map，存储着资源与node的对应关系

#### 1.1 entry方法 ####

@Override
    public void entry(Context context, ResourceWrapper resourceWrapper, Object obj, int count, boolean prioritized, Object... args)
            throws Throwable { 
    	// 一个context name 对应着一个defaultNode对象
    	// 根据context name 获取 node
    	DefaultNode node = map.get(context.getName());
    	if (node == null) { 
    	    synchronized (this) { 
    	        node = map.get(context.getName());
    	        if (node == null) { // 没有就创建
    	            node = new DefaultNode(resourceWrapper, null);
    	            HashMap<String, DefaultNode> cacheMap = new HashMap<String, DefaultNode>(map.size());
    	            cacheMap.putAll(map);
    	            cacheMap.put(context.getName(), node);
    	            map = cacheMap;
    	        }
    	        // Build invocation tree
    	        // 构建调用树
    	        ((DefaultNode)context.getLastNode()).addChild(node);
    	    }
    	}
    	// 设置当前node
    	context.setCurNode(node);
    	//这里传了一个node过去
    	fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }

其实不关心业务含义的话，看这段代码很简单，无非就是从map中获取DefaultNode对象，如果不存在的话就创建。  
但是我们不知道这个context是什么东西，它的name属性又是什么东西，有经验的程序员同学，一看到这个context就知道是个上下文，而且一般配合着ThreadLocal来使用，代码中倒数第二句把node设置到了这个context中，这个node就会跟着这个context一直往下传，但是我们知道这些是远远不够的，这时候我们就要结合之前的一些代码来看了，我们在《[Sentinel源码解析之一次请求走进Sentinel][Sentinel_Sentinel]》一文中，剖析了sentinel适配SpringMVC的过滤器，在这里我们再来回顾一下，其实你要想拦截一些web请求做一些处理，就得使用filter，sentinel适配web其实就是使用的filter来做的。在sentinel-web-servlet项目中，有  
CommonFilter这么一个类，就是实现了servlet的Filter接口，重写doFilter方法，我们来看下核心的代码

ContextUtil.enter(target, origin);
    entry = SphU.entry(target, EntryType.IN);

这里解释下target跟origin，target的话就是当前资源，这里也就是你请求路径，origin，这个是上游的请求路径，在微服务中，上游服务调用下游服务，sentinel会通过一些手段将上游的资源信息带到下游服务中，这个不用太关心。  
先看下这个ContextUtil.enter(target, origin);这段代码

protected static Context trueEnter(String name, String origin) { 
           // 获取context
           Context context = contextHolder.get();
           if (context == null) { 
               Map<String, DefaultNode> localCacheNameMap = contextNameNodeMap;
               // 根据名字获取DefaultNode
               DefaultNode node = localCacheNameMap.get(name);
               if (node == null) { 
    
                   // context name 大于2000 ，就说明满了，然后 返回NULL_CONTEXT
                   if (localCacheNameMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) { 
                       setNullContext();
                       return NULL_CONTEXT;
                   } else { 
                       try { 
                           LOCK.lock();
                           node = contextNameNodeMap.get(name);
                           if (node == null) { 
                               if (contextNameNodeMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) { 
                                   setNullContext();
                                   return NULL_CONTEXT;
                               } else { 
    
                                   // 创建一个EntranceNode
                                   node = new EntranceNode(new StringResourceWrapper(name, EntryType.IN), null);
                                   // Add entrance node. 根结点添加 子node
                                   Constants.ROOT.addChild(node);
    
                                   Map<String, DefaultNode> newMap = new HashMap<>(contextNameNodeMap.size() + 1);
                                   newMap.putAll(contextNameNodeMap);
                                   newMap.put(name, node);
                                   contextNameNodeMap = newMap;
                               }
                           }
                       } finally { 
                           LOCK.unlock();
                       }
                   }
               }
               context = new Context(node, name);
               context.setOrigin(origin);
               contextHolder.set(context);
           }
    
           return context;
       }

别看很长，难度不大这段代码，首先是从contextHolder获取这个context，这个contextHolder就是个ThreadLocal `ThreadLocal<Context> contextHolder = new ThreadLocal<>();` 这里想想，如果是项目刚启动，还没有请求过来，肯定是没有的，这个时候就会继续往下走，从一个缓存map中获取DefaultNode ，这个也是没有的，接着就是判断map的大小，不能超过2000，超过了就返回一个null context，不超过的话就会创建EntranceNode 对象，将这个资源传入构造，同时将新创建的EntranceNode 对象挂在ROOT 节点上，缓存到这个map中。这个ROOT节点其实也是个EntranceNode，不过它的资源名字是`machine-root`。  
接着往下看就是创建context了，然后将创建的context放到ThreadLocal中。  
好了，到这里`ContextUtil.enter(target, origin);`这句代码就分析完成了。

接着分析下`entry = SphU.entry(target, EntryType.IN);`

private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args)
            throws BlockException { 
            // 获取某个线程对应的context
            Context context = ContextUtil.getContext();
            if (context instanceof NullContext) { 
                // The {@link NullContext} indicates that the amount of context has exceeded the threshold,
                // so here init the entry only. No rule checking will be done.
                return new CtEntry(resourceWrapper, null, context);
            }
            // 如果是null的话
            if (context == null) { 
    
                // Using default context.
                context = MyContextUtil.myEnter(Constants.CONTEXT_DEFAULT_NAME, "", resourceWrapper.getType());
            }
    
            // Global switch is close, no rule checking will do.
            if (!Constants.ON) { 
                return new CtEntry(resourceWrapper, null, context);
            }
            ///创建 processor Slot
            ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);
    
            /* * Means amount of resources (slot chain) exceeds {@link Constants.MAX_SLOT_CHAIN_SIZE}, * so no rule checking will be done. */
            if (chain == null) { 
                return new CtEntry(resourceWrapper, null, context);
            }
            // 创建ctEntry对象
            Entry e = new CtEntry(resourceWrapper, chain, context);
            try { 
    
                //chain entry
                chain.entry(context, resourceWrapper, null, count, prioritized, args);
            } catch (BlockException e1) { 
                e.exit(count, args);
                throw e1;
            } catch (Throwable e1) { 
                // This should not happen, unless there are errors existing in Sentinel internal.
                RecordLog.info("Sentinel unexpected exception", e1);
            }
            return e;
        }

它其实会到这段代码中，先获取context，上面我们创建了context，这里直接获取就OK了。  
接着构建slot链，这里我们就不看了，之前都介绍过。  
接着创建CtEntry对象，这里没啥好看的  
最后就是进入slot链执行了。  
到这里我们的context来龙去脉都能解释清楚了，但是node之间还是很乱，我们来画下关系

*                  machine-root
     *                  /         \
     *                 /           \
     *         EntranceNode1   EntranceNode2
     *               /               \
     *              /                 \
     *      DefaultNode(nodeA)   DefaultNode(nodeA)
     *             |                    |
     *             +- - - - - - - - - - +- - - - - - -> ClusterNode(nodeA);

这个正好就是NodeSelectorSlot 类上面注释画的那个关系。  
machine-root 是顶级的节点，也就是根节点  
EntranceNode1是一个线程节点，属于context  
而NodeSelectorSlot 里面维护的那个map，是相同资源不同context DefaultNode  
反正这里挺绕的。

#### 1.2 exit ####

@Override
    public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) { 
        // 没干啥操作，接着往后调用
        fireExit(context, resourceWrapper, count, args);
    }

啥也没干，接着往下执行了。

### 总结 ###

本文是第一个slot NodeSelectorSlot的源码解析，也是稍微简单的，代码不难，但是这里面Node的关系还是需要慢慢的体会

[Sentinel_slotchain]: https://inetyoung.blog.csdn.net/article/details/111147217
[Sentinel_Sentinel]: https://inetyoung.blog.csdn.net/article/details/109860612