【sentinel】深入浅出之原理篇NodeSelectorSl

这篇文章开始分析SlotChain中的各个Slot，第一个Slot为NodeSelectorSlot 。
NodeSelectorSlot 负责收集资源的路径，并将这些资源的调用路径，以树状结构存储起来，用于根据调用路径来限流降级；

public class NodeSelectorSlot extends AbstractLinkedProcessorSlot<Object> {
   private volatile Map<String, DefaultNode> map = new HashMap<String, DefaultNode>(10);

   @Override
   public void entry(Context context, ResourceWrapper resourceWrapper, Object obj, int count, boolean prioritized, Object... args)
       throws Throwable {
       //从上下文获取Context命名的Node节点
       DefaultNode node = map.get(context.getName());
       if (node == null) {
           synchronized (this) {
               node = map.get(context.getName());
               if (node == null) {
                   //创建resource对应的Node 类型为DeaultNode
                   node = Env.nodeBuilder.buildTreeNode(resourceWrapper, null);
                   //保存Node  一个resource对应一个Node
                   HashMap<String, DefaultNode> cacheMap = new HashMap<String, DefaultNode>(map.size());
                   cacheMap.putAll(map);
                   cacheMap.put(context.getName(), node);
                   map = cacheMap;
               }
               // 添加到Context的Node节点，这里构造了一棵节点🌲
               ((DefaultNode)context.getLastNode()).addChild(node);
           }
       }
       //设置当前Context的当前节点为node
       context.setCurNode(node);
       //调用下一个Slot
       fireEntry(context, resourceWrapper, node, count, prioritized, args);
   }

   @Override
   public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {
       fireExit(context, resourceWrapper, count, args);
   }
}

可以看到，在NodeSelectorSlot节点中，首先根据ContextName获取默认节点，若默认节点不存在，则创建一个默认节点，并将改节点保存在缓存map中，然后设置当前节点为默认节点

调用顺序资源的调用路径树形结构哪里存储？

重点就在于下面这行代码

 ((DefaultNode)context.getLastNode()).addChild(node);

通过上下文首先获取最后一个节点，如果当前节点不为null，则当前节点就为最后一个节点，如果当前节点为null，则为entranceNode。
获取到最后一个节点，然后将当前节点挂在最后一个节点后面。

public class Context {
    private final String name;
    private DefaultNode entranceNode;
    private Entry curEntry;
    private String origin = "";
    private final boolean async;

    public Node getLastNode() {
        //从当前节点获取
        if (curEntry != null && curEntry.getLastNode() != null) {
            return curEntry.getLastNode();
        } else {
            //直接返回entranceNode
            return entranceNode;
        }
    }
}

public class DefaultNode extends StatisticNode {

    private ResourceWrapper id;
    private volatile Set<Node> childList = new HashSet<>();
    private ClusterNode clusterNode;

    public void addChild(Node node) {
        if (node == null) {
            RecordLog.warn("Trying to add null child to node <{0}>, ignored", id.getName());
            return;
        }
        //如果子节点包含了该节点，则跳过
        if (!childList.contains(node)) {
            synchronized (this) {
                //不包含该节点，则将当前节点挂在子节点里面
                if (!childList.contains(node)) {
                    Set<Node> newSet = new HashSet<>(childList.size() + 1);
                    newSet.addAll(childList);
                    newSet.add(node);
                    childList = newSet;
                }
            }
            RecordLog.info("Add child <{0}> to node <{1}>", ((DefaultNode)node).id.getName(), id.getName());
        }
    }
}

这种结构有点类似大学学的数据结构:栈
先来的位于栈首，后来的位于栈尾，后进先出。栈首位置永远是EntranceNode节点
举个例子：创建一个Context和5个resourceEntry，看一下整个树的结构会是什么样子。

 public static void main(String[] args) {
    try {
        Context context=ContextUtil.enter("context1");
        Entry entry=SphU.entry("A");
        Entry entry2=SphU.entry("B");
        Entry entry3=SphU.entry("C");
        Entry entry4=SphU.entry("D");
        Entry entry5=SphU.entry(""E);
        entry.exit();
        entry2.exit();
        entry3.exit();
        entry4.exit();
        entry5.exit();
        ContextUtil.exit();
    } catch (BlockException ex) {
        // 处理被流控的逻辑
        System.out.println("blocked!");
    }catch (Exception e){
        e.printStackTrace();
    }
}

运行结果如下:

运行结果.png

可以看到，EntranceNode的子节点为A，A的子节点为B，B的子节点为C，一直到E。

既然子Node都是一个，那么为什么还需要HashSet来保存，而不是定义一个DefaultNode？

public static void main(String[] args) {

    try {
        Context context=ContextUtil.enter("context1");
        Entry entry=SphU.entry("A");
        Entry entry2=SphU.entry("B");
        entry2.exit();
        Entry entry3=SphU.entry("C");
        entry3.exit();
        Entry entry4=SphU.entry("D");
        Entry entry5=SphU.entry("E");
        entry.exit();
/*                entry2.exit();
        entry3.exit();*/
        entry4.exit();
        entry5.exit();
        ContextUtil.exit();
    } catch (BlockException ex) {
        // 处理被流控的逻辑
        System.out.println("blocked!");
    }catch (Exception e){
        e.printStackTrace();
    }
}

运行上述代码，你就会发现，节点A的子Node有三个，B，C，D，节点D的子节点有一个E，如图：

运行结果

为什么会是这样？

上面提到，所有树的结构类似于栈，后入先出，当最后一个节点exit之后，最后一个节点的前一个节点为最后一个节点，就会存在多个子节点的问题。

再通过代码可以看到，一个 ContextName对应同一个 Resource使用同一个DefaultNode,一个 ContextName对应不同Resource使用同一个EntranceNode。