Sentinel源码分析----Node分析

Sentinel中有很多类型的Node，例如DefaultNode、StatisticNode、ClusterNode、还有个EntranceNode总共四种类型的Node，第一次看的时候非常懵逼，Node是啥？四个Node有什么不同？

上篇文章中，我们看到StatisticSlot中使用了Node去统计了请求信息，那么Node应该就是做请求统计用的，看下Node接口里定义

public interface Node {
    long totalRequest();
    long totalSuccess();
    long blockRequest();
    long totalException();
    long passQps();
    long blockQps();
    long totalQps();
    long successQps();
    long maxSuccessQps();
    long exceptionQps();
    long avgRt();
    long minRt();
    int curThreadNum();
    long previousBlockQps();
    long previousPassQps();
    Map metrics();
    void addPassRequest(int count);
    void addRtAndSuccess(long rt, int success);
    void increaseBlockQps(int count);
    void increaseExceptionQps(int count);
    void increaseThreadNum();
    void decreaseThreadNum();
    void reset();
    void debug();
}

方法比较多，但是方法名字很清晰，那么可以得出结论：

• 内部实现可以不说，但是对外部来说Node是做为一个请求数据统计和获取的载体

另外再看下四个Node的关系：

image.png

那么这四个Node中，哪个去实现了Node接口的方法呢？ 通过代码看到是StatisticNode实现了Node接口的所有方法，也就是说，另外三个Node有两种可能的作用：

1. DefaultNode、ClusterNode、EntranceNode继承于StatisticNode，基于其提供的数据统计和获取方法，实现自身一些特殊逻辑
2. StatisticNode提供了默认的方法，DefaultNode、ClusterNode、DntranceNode有自身的计算逻辑，需要重写这些方法

接下来通过具体代码分析，来看下到底是哪种情况。

EntranceNode

首先在上一篇文章中，我们从入口开始分析了整个调用链路流程，最先遇到和Node相关的代码的时候，是在ContextUtil#trueEnter中

    //#com.alibaba.csp.sentinel.Constants
    public final static DefaultNode ROOT = new EntranceNode(new StringResourceWrapper(ROOT_ID, EntryType.IN),
        Env.nodeBuilder.buildClusterNode());
    //ContextUtil#trueEnter
    protected static Context trueEnter(String name, String origin) {
        Context context = contextHolder.get();
        if (context == null) {
            Map localCacheNameMap = contextNameNodeMap;
            DefaultNode node = localCacheNameMap.get(name);
            if (node == null) {
                if (contextNameNodeMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {
                            //....
                } else {
                    node = new EntranceNode(new StringResourceWrapper(name, EntryType.IN), null);
                    // Add entrance node.
                    Constants.ROOT.addChild(node);

                    Map newMap = new HashMap(
                    contextNameNodeMap.size() + 1);
                    newMap.putAll(contextNameNodeMap);
                    newMap.put(name, node);
                    contextNameNodeMap = newMap;
                }
            }
            //....
        }
        return context;
    }

这里可以看到，一个ContextName会对应一个EntranceNode，EntranceNode从字面意思来看，叫做入口节点，也就是说，一个上下文开始的时候，会创建一个EntranceNode与其对应，代表该上下文的入口。

另外看到EntranceNode会挂在ROOT节点下面，而ROOT又是一个EntranceNode节点，而其是全局唯一的，他代表应用的入口节点，如下

image.png

ROOT是一个EntranceNode类型的节点，他可以挂子节点，子节点为上下文节点，那么上下文节点下面挂的是啥？别急，我们继续分析

接下看下类的定义

public class EntranceNode extends DefaultNode {

    public EntranceNode(ResourceWrapper id, ClusterNode clusterNode) {
        super(id, clusterNode);
    }

    @Override
    public long avgRt() {
        long total = 0;
        long totalQps = 0;
        for (Node node : getChildList()) {
            total += node.avgRt() * node.passQps();
            totalQps += node.passQps();
        }
        return total / (totalQps == 0 ? 1 : totalQps);
    }

    @Override
    public long blockQps() {
        long blockQps = 0;
        for (Node node : getChildList()) {
            blockQps += node.blockQps();
        }
        return blockQps;
    }

    @Override
    public long blockRequest() {
        long r = 0;
        for (Node node : getChildList()) {
            r += node.blockRequest();
        }
        return r;
    }

    @Override
    public int curThreadNum() {
        int r = 0;
        for (Node node : getChildList()) {
            r += node.curThreadNum();
        }
        return r;
    }

    @Override
    public long totalQps() {
        long r = 0;
        for (Node node : getChildList()) {
            r += node.totalQps();
        }
        return r;
    }

    @Override
    public long successQps() {
        long r = 0;
        for (Node node : getChildList()) {
            r += node.successQps();
        }
        return r;
    }

    @Override
    public long passQps() {
        long r = 0;
        for (Node node : getChildList()) {
            r += node.passQps();
        }
        return r;
    }

    @Override
    public long totalRequest() {
        long r = 0;
        for (Node node : getChildList()) {
            r += node.totalRequest();
        }
        return r;
    }

}

可以看到EntranceNode重写了获取数据统计的方法，获取的时候将所有子节点的数据全累加后返回

DefaultNode

第二次遇到与Node相关的应该是调用链中的NodeSelectorSlot，在看代码之前，先看下类上的注释，其中注释里画两个图：

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

EntranceNode1和EntranceNode2表示两个不同的上下文，而上下文节点下分别挂了个DefaultNode

    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 = Env.nodeBuilder.buildTreeNode(resourceWrapper, null);
                    HashMap cacheMap = new HashMap(map.size());
                    cacheMap.putAll(map);
                    cacheMap.put(context.getName(), node);
                    map = cacheMap;
                }
                ((DefaultNode)context.getLastNode()).addChild(node);
            }
        }

        context.setCurNode(node);
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }
    // com.alibaba.csp.sentinel.node.DefaultNodeBuilder#buildTreeNode
    public DefaultNode buildTreeNode(ResourceWrapper id, ClusterNode clusterNode) {
        return new DefaultNode(id, clusterNode);
    }

这里与EntranceNode的创建有点类似，都是以ContextName为key去保存的，也就是说DefaultNode也是和上下文相关的节点。

当创建成功后，会调用DefaultNode的addChild方法将创建的DefaultNode挂在某个节点下，我们看下getLastNode返回的是什么

    /**
     * Current processing entry.
     */
    private Entry curEntry;
    public Node getLastNode() {
        if (curEntry != null && curEntry.getLastNode() != null) {
            return curEntry.getLastNode();
        } else {
            return entranceNode;
        }
    }

curEntry是什么？在上篇文章分析到的entryWithPriority方法中，有如下代码

        Entry e = new CtEntry(resourceWrapper, chain, context);// 1
        try {
            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);
        }

注意看标记1这个位置，这里创建了一个Entry，并将创建好的上下文对象作为参数传进去，看下其构造方法

    CtEntry(ResourceWrapper resourceWrapper, ProcessorSlot