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

一、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

代码语言：txt复制

public interface ProcessorSlot<T> {

    void entry(....); //开始入口

    void fireEntry(....);//finish意味着结束

    void exit(....);//退出插槽

    void fireExit(....);//退出插槽结束

}

代码语言：txt复制

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

ProcessorSlot 的抽象实现 AbstractLinkedProcessorSlot

代码语言：txt复制

  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）

代码语言：txt复制

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 ：

代码语言：txt复制

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.初始化first和end的slot，
2.开始执行entry
3.开始执行fireEntry并查询是否下一个slot，如果有则执行第2步
4.开始执行exit
5.开始执行fireExit并查询是否有下一个slot，如果有则执行第4步
6.结束

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

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

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

SLOT的加载

1.定义顺序

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

代码语言：txt复制

@SpiOrder(-10000)
public class NodeSelectorSlot extends AbstractLinkedProcessorSlot<Object> {

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

2.SPI加载

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

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

代码语言：txt复制

@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.加载完后排序

代码语言：txt复制

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

微服务 iOA应用安全访问服务

0 人点赞