《一起学sentinel》二、初探sentinel的Slot

微信扫一扫,分享到朋友圈

《一起学sentinel》二、初探sentinel的Slot

slot概述

Sentinel 里面,所有的 资源 都对应一个资源名称( resourceName ), 每次 资源 调用 都会创建一个 Entry 对象。Entry 可以通过对主流框架的适配自动创建,也可以通过注解的方式或调用 SphU API 显式创建。Entry 创建 候,同时也会 创建一系列功能插槽 (slot chain),这些插槽有不同的职责,例如:

  • NodeSelectorSlot 负责 收集资源的路径 ,并将这些资源的调用路径,以树状结构 存储 起来,用于根据调用路径来 限流降级
  • ClusterBuilderSlot 则用于 存储 资源的 统计信息 以及 调用者信息 ,例如该资源的 RT, QPS, thread count 等等,这些信息将用 作为多维度限流,降级的依据
  • StatisticSlot 则用于 记录 、统计不同纬度的 runtime 指标监控信息
  • FlowSlot 则用于根据预设的限流规则以及前面 slot 统计的状态,来进行 流量控制
  • AuthoritySlot 则根据配置的黑白名单和调用来源信息,来做 黑白名单控制
  • DegradeSlot 则通过统计信息以及预设的规则,来做 熔断降级
  • SystemSlot 则通过系统的状态,例如 load1 等,来 控制总的入口流量

下面是关系结构图

solt的基本逻辑及代码演示

每个Slot执行完业务逻辑处理后,会调用 fireEntry() 方法,该方法将会触发下一个节点的 entry 方法,下一个节点又会调用他的 fireEntry ,以此类推直到最后一个 Slot ,由此就形成了 sentinel 的责任链。

  • 工作流概述:

    下面我会根据slot 的基本实现 processorSlot 讲一下slot 的基本结构及用法

  • 先看看顶层接口ProcessorSlot

    public interface ProcessorSlot<T> {
    void entry(....); //开始入口
    void fireEntry(....);//finish意味着结束
    void exit(....);//退出插槽
    void fireExit(....);//退出插槽结束
    }
    复制代码

​ 这个接口有4个方法,entry,fireEntry,exit,fireExit

  • ProcessorSlot 的抽象实现 AbstractLinkedProcessorSlot

    public abstract class AbstractLinkedProcessorSlot<T> implements ProcessorSlot<T> {
    private AbstractLinkedProcessorSlot<?> next = null;
    @Override
    public void fireEntry(... ) throws Throwable {
    //当业务执行完毕后,如果还有下一个slot
    if (next != null) {
    next.transformEntry(context, resourceWrapper, obj, count, prioritized, args);
    }
    }
    @SuppressWarnings("unchecked")
    //指向下一个slot的entry,每一个slot根据自己的职责不同,有自己的实现
    void transformEntry(... ) throws Throwable {
    T t = (T)o;
    entry(context, resourceWrapper, t, count, prioritized, args);
    }
    @Override
    public void fireExit(... ) {
    //当一个slot的exit执行完毕后,如果还有下一个未关闭slot
    if (next != null) {
    //指向下一个slot的exit
    next.exit(context, resourceWrapper, count, args);
    }
    }
    public AbstractLinkedProcessorSlot<?> getNext() {
    return next;
    }
    public void setNext(AbstractLinkedProcessorSlot<?> next) {
    this.next = next;
    }
    }
    复制代码
    • DefaultProcessorSlotChain实现了上述的chain(setNext和getNext)

      public class DefaultProcessorSlotChain extends ProcessorSlotChain {
      //直接实现了AbstractLinkedProcessorSlot的实例并作为first,可以理解为当前slot
      AbstractLinkedProcessorSlot<?> first = new AbstractLinkedProcessorSlot<Object>() {
      @Override
      public void entry(... )
      throws Throwable {
      super.fireEntry(context, resourceWrapper, t, count, prioritized, args);
      }
      @Override
      public void exit(... ) {
      super.fireExit(context, resourceWrapper, count, args);
      }
      };
      //默认的end(可以理解为当前的后一个slot)
      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) {
      //将后一个slot放进当前slot的next
      end.setNext(protocolProcessor);
      //将end指向后一个slot
      end = protocolProcessor;
      }
      }
      复制代码
  • AbstractLinkedProcessorSlot 的实例 DemoSlot :

    public class DemoSlot extends AbstractLinkedProcessorSlot<DefaultNode> {
    //开始入口
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count, boolean prioritized, Object... args)
    throws Throwable {
    //finish意味着结束
    fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }
    //退出插槽
    @Override
    public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {
    //退出插槽结束
    fireExit(context, resourceWrapper, count, args);
    }
    }
    复制代码

到这里我们看完了 Slot 的基本执行过程, 总结一下

  • 1.初始化 firstendslot
  • 2.开始执行 entry
  • 3.开始执行 fireEntry 并查询是否下一个 slot ,如果有则执行第2步
  • 4.开始执行 exit
  • 5.开始执行 fireExit 并查询是否有下一个 slot ,如果有则执行第4步
  • 6.结束

我们使用 Slot 方式进行处理时,需要实现一个 类似tomcat 的 lifeCycle ,但是差异是 tomcatlifeCycle 是一个使用异步事件的方式执行容器内逻辑,而 sentinel 使用的是一种 子父依赖关系 的链式调用,强调了顺序性执行。

默认的各个插槽之间的顺序是固定的,因为有的插槽需要依赖其他的插槽计算出来的结果才能进行工作。

下面我们看看是如何保证顺序的

SLOT的加载

1.定义顺序

sentinel 在每个实例化的 slot 上面备注了顺序的参数,如

@SpiOrder(-10000)
public class NodeSelectorSlot extends AbstractLinkedProcessorSlot<Object> {
复制代码

这是一个自定义的注解,保存的内容主要就是上面的(-10000)作为顺序权重

2.SPI加载

默认的 chain 会调用 sentinel 的类加载工具 SpiLoaderloadPrototypeInstanceListSorted(ProcessorSlot.class) ;

这个方法会将所有实现了 ProcessorSlot 的类,用 SPI 的方式加载

@SpiOrder(-10000)
public class NodeSelectorSlot
@SpiOrder(-9000)
public class ClusterBuilderSlot
@SpiOrder(-8000)
public class LogSlot
@SpiOrder(-7000)
public class StatisticSlot
@SpiOrder(-5000)
public class SystemSlot
@SpiOrder(-6000)
public class AuthoritySlot
@SpiOrder(-2000)
public class FlowSlot
@SpiOrder(-1000)
public class DegradeSlot
复制代码

3.加载完后排序

public static <T> List<T> loadPrototypeInstanceListSorted(Class<T> clazz) {
//这里就是第二步的加载
ServiceLoader<T> serviceLoader = ServiceLoaderUtil.getServiceLoader(clazz);
List<SpiOrderWrapper<T>> orderWrappers = new ArrayList<>();
//循环遍历加载
for (T spi : serviceLoader) {
//查询对应类的顺序(第一步)
int order = SpiOrderResolver.resolveOrder(spi);
//将顺序和类插入List(手动有序数组)
SpiOrderResolver.insertSorted(orderWrappers, spi, order);
}
}
//排序方法很简答
private static <T> void insertSorted(List<SpiOrderWrapper<T>> list, T spi, int order) {
int idx = 0;
for (; idx < list.size(); idx++) {
//循环遍历定长的list,一次比对大小
if (list.get(idx).getOrder() > order) {
break;如果发现当前索引大于
}
}
list.add(idx, new SpiOrderWrapper<>(order, spi));
}
复制代码

微信扫一扫,分享到朋友圈

《一起学sentinel》二、初探sentinel的Slot

你见过的最有意境的教师节祝福是什么?

上一篇

沟通型女生如何塑造前端成长路线

下一篇

你也可能喜欢

《一起学sentinel》二、初探sentinel的Slot

长按储存图像,分享给朋友