《一起学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 等,来控制总的入口流量

下面是关系结构图

ProcessorSlot子类及实现类.png

solt的基本逻辑及代码演示

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

  • 工作流概述:

    slot工作流.png


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


  • 先看看顶层接口ProcessorSlot

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

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

  • ProcessorSlot 的抽象实现 AbstractLinkedProcessorSlot

    public abstract class AbstractLinkedProcessorSlot implements ProcessorSlot {
    
        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() {
      
              @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 {
        
            //开始入口
            @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 {
       
       

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

      2.SPI加载

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

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

      slot-spi-class.png
      @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  List loadPrototypeInstanceListSorted(Class clazz) {
          //这里就是第二步的加载
          ServiceLoader serviceLoader = ServiceLoaderUtil.getServiceLoader(clazz);
      
          List> orderWrappers = new ArrayList<>();
          //循环遍历加载
          for (T spi : serviceLoader) {
              //查询对应类的顺序(第一步)
              int order = SpiOrderResolver.resolveOrder(spi);
              //将顺序和类插入List(手动有序数组)
              SpiOrderResolver.insertSorted(orderWrappers, spi, order);
          }
      }
      
      
      
      //排序方法很简答
      private static  void insertSorted(List> 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)