Sentinel源码之SlotChain入口解析

2022-05-21 10:32:22 阅读：174 来源： 互联网

标签：slot chain SlotChain resourceWrapper 源码 context Sentinel com csp

SlotChain入口解析

默认Chain解析

我们从这里继续分析，这个位置的chain.entry方法，但是此时这个chain是谁？

//CtSph中
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);
}

那么这个位置开始，我们就要分析一下如下代码

官方定义：Sentinel 将 ProcessorSlot作为 SPI 接口进行扩展（1.7.2 版本以前 SlotChainBuilder作为 SPI），使得 Slot Chain 具备了扩展的能力。您可以自行加入自定义的 slot 并编排 slot 间的顺序，从而可以给 Sentinel 添加自定义的功能。

lookProcessChain()用于构建一个责任链。Sentinel的处理核心都在这个责任链中，链中每一个节点是一个Slot实例，这个链通过BlockException异常来告知调用入口最终的执行情况

// 获取chain链
ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);
//-------------------具体看lookProcessChain方法---------------------
ProcessorSlot<Object> lookProcessChain(ResourceWrapper resourceWrapper) {
 // 先从chainMap获取，若是存在，则直接返回
 ProcessorSlotChain chain = chainMap.get(resourceWrapper);
 if (chain == null) {
     synchronized (LOCK) {
         chain = chainMap.get(resourceWrapper);
         if (chain == null) {
             // Entry size limit.
             if (chainMap.size() >= Constants.MAX_SLOT_CHAIN_SIZE) {
                 return null;
             }
				// 通过SlotChainProvider创建一个slot链
             chain = SlotChainProvider.newSlotChain();
             Map<ResourceWrapper, ProcessorSlotChain> newMap = new HashMap<ResourceWrapper, ProcessorSlotChain>(
                 chainMap.size() + 1);
             newMap.putAll(chainMap);
             // 添加到Map缓存中
             newMap.put(resourceWrapper, chain);
             chainMap = newMap;
         }
     }
 }
 return chain;
}

这个位置我们要具体分析SlotChainProvider这个类型，它的主要作用就是通过已解析的槽链构建器，创建槽链的提供者

从这里我们可以看出SlotChainBuilder及ProcessorSlot 使用Java SPI技术实现可配置化，即在/META-INF/services/接口全限命名的文件中配置实现类，然后由ServiceLoader实现加载，这种技术在SpringBoot中都有使用。

package com.alibaba.csp.sentinel.slotchain;

import com.alibaba.csp.sentinel.log.RecordLog;
import com.alibaba.csp.sentinel.slots.DefaultSlotChainBuilder;
import com.alibaba.csp.sentinel.spi.SpiLoader;

/**
 * A provider for creating slot chains via resolved slot chain builder SPI.
 *
 * @author Eric Zhao
 * @since 0.2.0
 */
public final class SlotChainProvider {

    private static volatile SlotChainBuilder slotChainBuilder = null;

    /**
     * The load and pick process is not thread-safe, but it's okay since the method should be only invoked
     * via {@code lookProcessChain} in {@link com.alibaba.csp.sentinel.CtSph} under lock.
     *
     * @return new created slot chain
     */
    public static ProcessorSlotChain newSlotChain() {
        if (slotChainBuilder != null) {
            return slotChainBuilder.build();
        }

        // 读取配置文件在/META-INF/services/接口全限定命名的文件中配置实现类.
        slotChainBuilder = SpiLoader.of(SlotChainBuilder.class).loadFirstInstanceOrDefault();

        if (slotChainBuilder == null) {
            // Should not go through here.
            RecordLog.warn("[SlotChainProvider] Wrong state when resolving slot chain builder, using default");
            //使用默认的DefaultSlotChainBuilder来构建ProcessorSlotChain
            slotChainBuilder = new DefaultSlotChainBuilder();
        } else {
            RecordLog.info("[SlotChainProvider] Global slot chain builder resolved: {}",
                slotChainBuilder.getClass().getCanonicalName());
        }
        //使用DefaultSlotChainBuilder构建
        return slotChainBuilder.build();
    }

    private SlotChainProvider() {}
}

到这里我们就清楚的知道了其实现在使用的是使用DefaultSlotChainBuilder.build()来创建的，以下是源码在这个其中，做了几件事：

创建DefaultProcessorSlotChain

读取/META-INF/services/中的配置文件

强制转型为AbstractLinkedProcessorSlot（所有插槽的抽象父类）

@Spi(isDefault = true)
public class DefaultSlotChainBuilder implements SlotChainBuilder {

    @Override
    public ProcessorSlotChain build() {
        // 创建DefaultProcessorSlotChain
        ProcessorSlotChain chain = new DefaultProcessorSlotChain();
		// 读取配置文件在/META-INF/services/接口全限定命名的文件
        List<ProcessorSlot> sortedSlotList = SpiLoader.of(ProcessorSlot.class).loadInstanceListSorted();
        for (ProcessorSlot slot : sortedSlotList) {
            if (!(slot instanceof AbstractLinkedProcessorSlot)) {
                RecordLog.warn("The ProcessorSlot(" + slot.getClass().getCanonicalName() + ") is not an instance of AbstractLinkedProcessorSlot, can't be added into ProcessorSlotChain");
                continue;
            }

            chain.addLast((AbstractLinkedProcessorSlot<?>) slot);
        }

        return chain;
    }
}

具体读取的内容如下：

# Sentinel default ProcessorSlots 
com.alibaba.csp.sentinel.slots.nodeselector.NodeSelectorSlot
com.alibaba.csp.sentinel.slots.clusterbuilder.ClusterBuilderSlot
com.alibaba.csp.sentinel.slots.logger.LogSlot
com.alibaba.csp.sentinel.slots.statistic.StatisticSlot
com.alibaba.csp.sentinel.slots.block.authority.AuthoritySlot
com.alibaba.csp.sentinel.slots.system.SystemSlot
com.alibaba.csp.sentinel.slots.block.flow.FlowSlot
com.alibaba.csp.sentinel.slots.block.degrade.DegradeSlot

这些就是Sentinel提供的默认功能插槽

NodeSelectorSlot解析

分析到这里我们就可以回到CtSph中，查看entry方法这个时候我们就知道了实际上调用entry方法的是DefaultProcessorSlotChain

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);
}

@Override
public void entry(Context context, ResourceWrapper resourceWrapper, Object t, int count, boolean prioritized, Object... args)
 throws Throwable {
 // 转到下一个节点
 first.transformEntry(context, resourceWrapper, t, count, prioritized, args);
}

这个位置是转入到下一个节点，那么下一个节点明显就是NodeSelectorSlot，那我们来看具体操作

void transformEntry(Context context, ResourceWrapper resourceWrapper, Object o, int count, boolean prioritized, Object... args)
 throws Throwable {
 T t = (T)o;
 //NodeSelectorSlot
 entry(context, resourceWrapper, t, count, prioritized, args);
}

NodeSelectorSlot具体内容官网有给出解释：

这个 slot 主要负责收集资源的路径，并将这些资源的调用路径，以树状结构存储起来，用于根据调用路径来限流降级。

DefaultNode用于统计一个resource在当前Context中的流量数据，所以再结合NodeSelectorSlot，最终得出结论：处理不同的Context name，同一个Resource name的情况

@Override
public void entry(Context context, ResourceWrapper resourceWrapper, Object obj, int count, boolean prioritized, Object... args)
 throws Throwable {

 // 从缓存中获取，创建DefaultNode
 DefaultNode node = map.get(context.getName());
 // 双重判断，如果判断为空
 if (node == null) {
     synchronized (this) {
         node = map.get(context.getName());
         if (node == null) {
             // 创建一个DefaultNode并且放入到缓存中
             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
             // 将新建的Node添加到调用树中
             ((DefaultNode) context.getLastNode()).addChild(node);
         }

     }
 }

 context.setCurNode(node);
 // 触发下一个节点
 fireEntry(context, resourceWrapper, node, count, prioritized, args);
}

标签：slot,chain,SlotChain,resourceWrapper,源码,context,Sentinel,com,csp
来源： https://www.cnblogs.com/ZT-666/p/16294549.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Sentinel源码之SlotChain入口解析

SlotChain入口解析