1. 前言

上一篇介绍了Sentinel的Context、Entry、Node相关的信息。在创建Node时，涉及到了NodeSelectorSlot和ClusterBuilderSlot，创建Entry的时候，会创建一个chain。本文会通过源码分析这些对象的作用。

2. 功能插槽

2.1. 功能插槽的作用

当使用SphU.entry()获取资源创建Entry对象的时候，会创建一系列的功能插槽，这些插槽以责任链的方式组合在一起，每个插槽分别处理不同的功能。

在CtSph#entryWithPriority()方法中会尝试去获取chain，如果没有，则创建：

 ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);

具体的获取流程：

源码位置：CtSph.java

private static volatile Map<ResourceWrapper, ProcessorSlotChain> chainMap
        = new HashMap<ResourceWrapper, ProcessorSlotChain>();
        
ProcessorSlot<Object> lookProcessChain(ResourceWrapper resourceWrapper) {
    //先从缓存中获取，如果没有再创建
    ProcessorSlotChain chain = chainMap.get(resourceWrapper);
    if (chain == null) {
        synchronized (LOCK) {
            chain = chainMap.get(resourceWrapper);
            if (chain == null) {
                // Entry size limit. 处理链的数量不能超过6000,
                if (chainMap.size() >= Constants.MAX_SLOT_CHAIN_SIZE) {
                    return null;
                }
                //创建处理链
                chain = SlotChainProvider.newSlotChain();
                Map<ResourceWrapper, ProcessorSlotChain> newMap = new HashMap<ResourceWrapper, ProcessorSlotChain>(
                    chainMap.size() + 1);
                newMap.putAll(chainMap);
                newMap.put(resourceWrapper, chain);
                chainMap = newMap;
            }
        }
    }
    return chain;
}

可以看到，chain会先保存到一个静态的全局map中，以资源名称为key，chain为value，所以同一个resource只有一个chain。

实际创建chain的地方是SlotChainProvider.newSlotChain():

#源码位置：SlotChainProvider.java

 private static volatile SlotChainBuilder slotChainBuilder = null;

 public static ProcessorSlotChain newSlotChain() {

    //如果builder不为空，创建chain，否则先创建builder，再创建chain
    if (slotChainBuilder != null) {
        return slotChainBuilder.build();
    }

    resolveSlotChainBuilder();

    if (slotChainBuilder == null) {
        RecordLog.warn("[SlotChainProvider] Wrong state when resolving slot chain builder, using default");
        slotChainBuilder = new DefaultSlotChainBuilder();
    }
    return slotChainBuilder.build();
}

2.2. SlotChainBuilder

SlotChainBuilder负责创建功能插槽链，SlotChainBuilder是一个接口，里面只有一个build方法，定义功能插槽如何创建。

可以看到首先看一下SlotChainBuilder有三个实现，不同的实现增加不同的处理能力。

DefaultSlotChainBuilder：默认的功能插槽构造器
GatewaySlotChainBuilder：网关插槽构造器，里面新增了网关限流功能
HotParamSlotChainBuilder：热点参数插槽构造器，里面新增了热点参数功能

这里看一下默认的功能插槽构造器，其他的两个只是在适当的位置新增一个处理插槽。

public class DefaultSlotChainBuilder implements SlotChainBuilder {

    @Override
    public ProcessorSlotChain build() {
        ProcessorSlotChain chain = new DefaultProcessorSlotChain();
        chain.addLast(new NodeSelectorSlot());
        chain.addLast(new ClusterBuilderSlot());
        chain.addLast(new LogSlot());
        chain.addLast(new StatisticSlot());
        chain.addLast(new SystemSlot());
        chain.addLast(new AuthoritySlot());
        chain.addLast(new FlowSlot());
        chain.addLast(new DegradeSlot());

        return chain;
    }
}

可以看到build方法主要是创建一个DefaultProcessorSlotChain,然后将不同功能的插槽添加进去。

需要注意的是，Sentinel是通过SPI的形式选择使用哪个SlotChainBuilder来创建功能插槽的。

private static final ServiceLoader<SlotChainBuilder> LOADER = ServiceLoader.load(SlotChainBuilder.class);

2.3. ProcessorSlot

ProcessorSlot代表功能插槽对象，定义了进入功能插槽和退出功能插槽的接口，具体的功能插槽都实现了该接口。

ProcessorSlot继承结构如下：

通过继承可以发现，ProcessorSlot主要是两类，一类是具有特定功能的功能插槽，比如限流、统计、降级等，还有一类是主要是形成插槽链，主要就是DefaultProcessorSlotChain。

2.3.1. DefaultProcessorSlotChain

DefaultProcessorSlotChain代表功能处理链的开始，里面定义了两个节点，第一个节点和最后一个节点，并提供新增节点的方法。


public class DefaultProcessorSlotChain extends ProcessorSlotChain {

    //默认先创建一个头结点插槽
    AbstractLinkedProcessorSlot<?> first = new AbstractLinkedProcessorSlot<Object>() {

        @Override
        public void entry(Context context, ResourceWrapper resourceWrapper, Object t, int count, boolean prioritized, Object... args)
            throws Throwable {
            super.fireEntry(context, resourceWrapper, t, count, prioritized, args);
        }

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

    };
    AbstractLinkedProcessorSlot<?> end = first;

    @Override
    public void addFirst(AbstractLinkedProcessorSlot<?> protocolProcessor) {
        protocolProcessor.setNext(first.getNext());
        first.setNext(protocolProcessor);
        if (end == first) {
            end = protocolProcessor;
        }
    }

    @Override
    public void addLast(AbstractLinkedProcessorSlot<?> protocolProcessor) {
        end.setNext(protocolProcessor);
        end = protocolProcessor;
    }
}

2.3.2. AbstractLinkedProcessorSlot

AbstractLinkedProcessorSlot非常的重要，不仅实现了ProcessorSlot，还实现功能插槽链之间的如何连接的。

    private AbstractLinkedProcessorSlot<?> next = null;

AbstractLinkedProcessorSlot里面通过新增一个next指针标记下一个功能处理槽是哪一个，这样，在一个功能槽处理完流程后，通过next可以找到下一个功能槽，退出的时候也是一样的逻辑。

2.4. 功能插槽小结

上面讲了功能插槽创建的流程，Sentinel是如何将所有的插槽组织工作的。但具体每个功能插槽是怎么工作的，在这个地方先不讲。最后，通过一个图看一下DefaultSlotChainBuilder创建的功能插槽链结构：

3. NodeSelectorSlot

官方文档是这样描述NodeSelectorSlot的：这个 slot 主要负责收集资源的路径，并将这些资源的调用路径以树状结构存储起来，用于根据调用路径进行流量控制。

先看源码：

public class NodeSelectorSlot extends AbstractLinkedProcessorSlot<Object> {

    /**
     * {@link DefaultNode}s of the same resource in different context.
     */
    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 {
        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);
                }

            }
        }

        context.setCurNode(node);
        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会创建一个DefaultNode，然后将该节点设置到Context下的最新一个节点子节点列表中，然后将上下文的当前节点设置为本次创建的节点。

public Node getLastNode() {
    if (curEntry != null && curEntry.getLastNode() != null) {
        return curEntry.getLastNode();
    } else {
        return entranceNode;
    }
}

上面是获取最新节点的逻辑。

NodeSelectorSlot主要作用就是收集资源的路径。在这个Slot中，创建了一个DefaultNode，在上一篇中讲到DefaultNode是以Context和Resource为维度保存统计指标的，但是这个地方的map是根据Context来保存的，这个是为什么呢？需要注意的是功能插槽处理链的创建是根据Resource来的，一个Resource只会创建一个chain，不同的Resource创建不同的chain，所以这地方虽然是使用Context作为key，但其实是Context和Resource为维度的。

4. ClusterBuilderSlot

上面的NodeSelector是创建DefaultNode节点，CLusterBuilderSlot主要是负责创建ClusterNode和来源节点。至于这两个节点的作用，在上一篇已经讲过。

public class ClusterBuilderSlot extends AbstractLinkedProcessorSlot<DefaultNode> {

    private static volatile Map<ResourceWrapper, ClusterNode> clusterNodeMap = new HashMap<>();

    private static final Object lock = new Object();

    private volatile ClusterNode clusterNode = null;

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args)
        throws Throwable {
        if (clusterNode == null) {
            synchronized (lock) {
                if (clusterNode == null) {
                    // Create the cluster node.
                    clusterNode = new ClusterNode();
                    HashMap<ResourceWrapper, ClusterNode> newMap = new HashMap<>(Math.max(clusterNodeMap.size(), 16));
                    newMap.putAll(clusterNodeMap);
                    newMap.put(node.getId(), clusterNode);

                    clusterNodeMap = newMap;
                }
            }
        }
        node.setClusterNode(clusterNode);

        /*
         * if context origin is set, we should get or create a new {@link Node} of
         * the specific origin.
         */
        //如果context定义了来源名称，需要给当前的entry创建一个originNode
        if (!"".equals(context.getOrigin())) {
            Node originNode = node.getClusterNode().getOrCreateOriginNode(context.getOrigin());
            context.getCurEntry().setOriginNode(originNode);
        }

        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }
}

可以看到，ClusterBuilderSlot中有一个ClusterNode类型的变量，因为之前说过，同一个Resource只有一个Chain，所以这个地方创建的ClusterNode是统计某个Resource的数据，所以ClusterNode的统计维度为Resource。

如果定义了入口的来源，这里还会创建一个来源节点，作为统计来源节点相关数据的node，这个地方的统计维度是同一个Resource和orgin为维度。

5. 创建Node、Context、Entry整体流程

上面讲NodeSelectorSlot和ClusterBuilderSlot的时候，只是把大致的流程说一下，至于创建了Node后整个结构是什么样的，这个需要再说一下，如果在看上一篇和这篇中的内容时比较乱，可以看了这一小节后，再去看一下之前的内容。因为到此，整个Sentinel保存统计数据的流程才讲完。

5.1. 再次回忆Context、Entry、Node的创建时机

Context：在使用ContextUtil.entry()或者SphU.entry()的时候会创建Context。
EntranceNode：在创建Context的时候创建EntranceNode，并赋值给Context。
ProcessorSlot：：在使用SphU.entry()创建，同一个Resource共享一个。
Entry：在使用SphU.entry()创建，并通过parent和child将Entry链连接，同时将该Entry对象赋值给Context的curEntry.
DefaultNode：在NodeSelectorSlot中创建，以Resource和Context为维度
ClusterNode：在ClusterBuilderSlot中创建，以Resource为维度。
来源源节点：在ClusterBuilderSlot中创建，以Resource和orgin为维度。

5.2. 流程图

首先先看一下代码：

 ContextUtil.enter("context1","origin1");
 Entry entry = SphU.entry("resource1");

当创建一个Entry的时候，整个关系图如下：

这个时候在获取同一个资源一次：

 Entry entry2 = SphU.entry("resource1");

关系图如下：

接下来在创建不同资源的：

Entry entry3 = SphU.entry("resource2");
Entry entry4 = SphU.entry("resource3");

关系图如下：

上面是在同一个Context下，如果是在不同的Context下，由于chain是以Resource为维度的，所以ClusterNode对同一个Resource只会存在一个，所以多个Context下，关系图就是把上图复制一份，只是ClusterNode指向同一个。

根据关系图，可以很清晰的看到ClusterNode、DefaultNode、OrginNode是按什么样的维度来进行统计的。

6. 小结

本篇主要讲Sentinel通过责任链的方式将各种插槽组合起来实现限流降级等功能，并分析了前两个Slot：NodeSelectorSlot和ClusterNodeSlot的作用。最后结合第一篇的内容画出不同场景下Context、Entry、Node的关系，更加体现ClusterNode、DefaultNode、源节点是按照什么维度进行统计的。在下一篇中，将继续分析Sentinel中的统计功能StatisticSlot，以及各种Node节点是怎么保存数据的。

7. 参考资料

Sentinel工作主流程