大纲
1.Sentinel底层的核心概念
2.Sentinel中Context的设计思想与源码实现
3.Java SPI机制的引入
4.Java SPI机制在Sentinel处理链中的应用
5.Sentinel默认处理链ProcessorSlot的构建
1.Sentinel底层的核心概念
(1)资源和规则
(2)Context
(3)ProcessorSlot
(4)Node
(1)资源和规则
一.什么是资源、规则和Entry
二.使用责任链模式 + 过滤器来收集资源的调用数据
三.如何设计Entry资源访问类
四.如何设计Entry资源访问类的子类
一.什么是资源、规则和Entry
**资源：**可以是一个方法、一个接口或一段代码。资源是被Sentinel保护和管理的对象。
**规则：**用来定义资源应遵循的约束条件。Sentinel支持多种规则类型，如流控规则、熔断降级规则等。
**Entry：**可以理解为是对资源的一次访问。
在Sentinel中，资源和规则是紧密相互关联的。Sentinel会根据配置的规则，对资源的调用进行控制，从而保证系统稳定。
二.使用责任链模式 + 过滤器来收集资源的调用数据
Sentinel要实现流控、熔断降级等功能，首先需要收集资源的调用数据。比如：QPS、请求失败次数、请求成功次数、线程数、响应时间等。
为了收集资源的这些调用数据，可以使用过滤器。将需要限制的资源配置在配置文件中，然后创建一个过滤器来拦截请求。当发现当前请求的接口已在配置文件中配置时，便需要进行数据收集。比如每次收到请求都将totalQps字段值 + 1，请求成功则再将successQps字段值 + 1。但使用一个过滤器是不够的，因为不仅有限制QPS的规则，也可能有限制异常比例的规则等。因此还需要使用责任链模式，让每一种规则都对应一个过滤器节点。这样拦截请求进行过滤时，便会形成一个过滤器处理链：开始 -> 流控过滤器 -> 黑白名单过滤器 -> 熔断降级过滤器 -> 业务 -> 结束。
三.如何设计Entry资源访问类
Entry可以理解为是对资源的一次访问。在使用责任链模式之前，需要先设计Entry资源访问类。
已知资源可以是一个方法、一个接口甚至一段代码，那么资源就肯定要有资源名称，比如方法名、接口名、其他自定义名称。因此，可以设计如下Entry资源访问类：
//资源访问类
public class Entry {
//资源名称
private final String name;
}一个资源作为API提供给第三方调用时，此时它属于入口流量。一个资源也会主动请求第三方API，此时它属于出口流量。第三方调用自己时，需要限制QPS。自己调用第三方时，第三方也有QPS限制。所以需要一个EntryType类：
public enum EntryType {
//入口流量，资源被调用
IN,
//出口流量，资源调用其他接口
OUT;
}然后，还需要一个ResourceTypeConstants类来记录资源的类型，表明资源是HTTP接口、RPC接口、还是Gateway网关服务等。
//资源类
public final class ResourceTypeConstants {
//默认类型
public static final int COMMON = 0;
//Web类型，也就是最常见的HTTP类型
public static final int COMMON_WEB = 1;
//RPC类型，如Dubbo RPC，Grpc，Thrift等
public static final int COMMON_RPC = 2;
//API网关
public static final int COMMON_API_GATEWAY = 3;
//数据库SQL操作
public static final int COMMON_DB_SQL = 4;
}因此，一个资源起码有三个字段：名称(name)、资源类型(resourceType)以及请求类型(entryType)。将这三个字段包装成一个ResourceWrapper类，如下所示：
//资源类(资源包装类)
public class ResourceWrapper {
//资源名称
protected final String name;
//资源类型：入口流量还是出口流量
protected final EntryType entryType;
//请求类型：HTTP类型、RPC类型、API网关
protected final int resourceType;
public ResourceWrapper(String name, EntryType entryType, int resourceType) {
this.name = name;
this.entryType = entryType;
this.resourceType = resourceType;
}
}接着，将这个ResourceWrapper资源类放入到Entry资源访问类中：
public class Entry {
//封装了：名称(name)、请求类型(entryType)以及资源类型(resourceType)三个字段
protected final ResourceWrapper resourceWrapper;
public Entry(ResourceWrapper resourceWrapper) {
this.resourceWrapper = resourceWrapper;
}
}类图如下：
同时，还需记录资源访问的开始时间和完成时间：
public class Entry {
//资源访问的开始时间
private final long createTimestamp;
//资源访问的完成时间
private long completeTimestamp;
//封装了：名称(name)、请求类型(entryType)以及资源类型(resourceType)三个字段
protected final ResourceWrapper resourceWrapper;
public Entry(ResourceWrapper resourceWrapper) {
this.resourceWrapper = resourceWrapper;
//给开始时间赋值为当前系统时间
this.createTimestamp = TimeUtil.currentTimeMillis();
}
}然后，还需记录这个资源总的请求数、请求成功、请求失败等指标。可以将获取这些指标的方法放到一个interface里，然后通过interface提供的方法获取这些指标，可称这个interface为Node。
//用于统计资源的各项指标数据
public interface Node {
//总的请求数
long totalRequest();
//请求成功数
long totalSuccess();
...
}于是，Entry资源访问类变成如下：
public class Entry {
//资源访问的开始时间
private final long createTimestamp;
//资源访问的完成时间
private long completeTimestamp;
//统计资源的各项数据指标
private Node curNode;
//封装了：名称(name)、请求类型(entryType)以及资源类型(resourceType)三个字段
protected final ResourceWrapper resourceWrapper;
public Entry(ResourceWrapper resourceWrapper) {
this.resourceWrapper = resourceWrapper;
//给开始时间赋值为当前系统时间
this.createTimestamp = TimeUtil.currentTimeMillis();
}
}此外，当触发预设规则的阈值时，系统将抛出警告提示。因此还要自定义一个异常类BlockException。所以，Entry资源访问类最终如下：
//Each SphU.entry() will return an Entry.
//This class holds information of current invocation:
//createTime, the create time of this entry, using for rt statistics.
//current Node, that is statistics of the resource in current context.
//origin Node, that is statistics for the specific origin.
//Usually the origin could be the Service Consumer's app name, see ContextUtil.enter(String name, String origin).
//ResourceWrapper, that is resource name.
//A invocation tree will be created if we invoke SphU.entry() multi times in the same Context,
//so parent or child entry may be held by this to form the tree.
//Since Context always holds the current entry in the invocation tree,
//every Entry.exit() call should modify Context.setCurEntry(Entry) as parent entry of this.
public abstract class Entry {
//资源访问的开始时间
private final long createTimestamp;
//资源访问的完成时间
private long completeTimestamp;
//统计资源的各项数据指标
private Node curNode;
//异常
private BlockException blockError;
//封装了：名称(name)、请求类型(entryType)以及资源类型(resourceType)三个字段
protected final ResourceWrapper resourceWrapper;
public Entry(ResourceWrapper resourceWrapper) {
this.resourceWrapper = resourceWrapper;
//给开始时间赋值为当前系统时间
this.createTimestamp = TimeUtil.currentTimeMillis();
}
}Entry资源访问类的设计总结：
每次资源被访问时都会创建一个Entry资源访问对象。Entry资源访问对象会包含：资源名称、资源类型、请求类型、操作资源的开始和结束时间、统计各项指标的接口以及自定义流控异常。
根据这些字段可以完成以下需求：统计一个资源的出口流量、成功次数、失败次数等指标。根据规则配置判断是否超出阈值，若是则抛出自定义异常BlockException。这样的Entry资源访问类，能灵活方便管理和监控资源，满足不同的需求。
为了方便子类继承，可以将Entry资源访问类设计为抽象类。
四.如何设计Entry资源访问类的子类
假设需要提供一个外部接口(sms/send)用于发送短信服务，具体的短信发送操作是通过第三方云服务提供商提供的API或SDK完成的，第三方云服务提供商需要使用方对其提供的API或SKD进行QPS限流。
当用户请求接口sms/send到达系统时，会生成一个名为sms/send的Entry。由于当接口sms/send请求第三方API时，也需要进行限流操作，因此还会生成一个名为yun/sms/api的Entry。
可以发现这两个Entry都属于同一次请求，即这两个Entry是有关联的。
Entry(name=sms/send)的子节点是Entry(name=yun/sms/api)
Entry(name=yun/sms/api)的父节点是Entry(name=sms/send)这显然是父子关系，可以使用双向链表表示，因此需要两个指针。
此外，由于这两个Entry属于同一个请求，即它们位于同一个作用范围内。因此，需要一个字段来表示作用范围。
最后，由于需要通过设置一系列的过滤器来采集Entry的各规则下的指标。所以，还需增加一个存放处理链(处理器插槽链条)类型的字段。
综上，可以设计Entry的子类CtEntry如下：
//Entry的子类
class CtEntry extends Entry {
//指向上一个节点，父节点，类型为Entry
protected Entry parent = null;
//指向下一个节点，子节点，类型为Entry
protected Entry child = null;
//作用域，上下文
protected Context context;
//处理链(处理器插槽链条)
protected ProcessorSlot<Object> chain;
}(2)Context
Context对象的用途是存储请求调用链中关联的Entry信息。在Sentinel中，每个请求都有一个与之关联的Context实例。当系统接收到一个请求时，就会创建出一个Context。请求的处理过程中可能会涉及多个资源，Context便会在多个资源中传递。
Context类的设计如下：
public class Context {
//名称
private final String name;
//处理到哪个Entry了
private Entry curEntry;
//来源，比如请求 IP
private String origin = "";
}可以发现Context比较简单，它就像一个容器一样。Context会关联此次请求的所有资源，即包含一个Entry双向链表。一个Context的生命周期内可能有多个资源操作，并非是一个接口对应一个Context，可以是多个接口对应一个Context。比如A调用B，B调用C，那么A、B、C三个资源就属于同一个Context。Context生命周期内的最后一个资源退出时就会清理并结束该Context。
Context类的设计总结：
在处理一个请求对应的一个资源时或者多个资源时，这些资源的操作必须要建立在一个Context环境下，而且每一个资源的操作必须要通过Entry对象来完成。也就是一个请求对应一个Context，一个请求可能操作多个资源。而多个资源又对应多个Entry，但这些Entry却都属于同一个Context。
(3)ProcessorSlot
ProcessorSlot就是一个用于负责数据采集的处理链(处理器插槽链条)的节点。每当一个资源被调用时都会创建一个Entry资源访问对象。Entry资源访问对象中就有一条节点为ProcessorSlot的处理链，对应于Entry对象的chain属性。这意味着在创建Entry对象时，也会生成一系列ProcessorSlot处理槽，这些ProcessorSlot处理槽各自承担不同的职责。
一.NodeSelectorSlot
NodeSelectorSlot负责构建资源的调用路径，然后将这些资源的调用路径以树状结构存储起来，方便后续根据资源的调用路径进行数据统计和限流降级。
二.ClusterBuilderSlot
ClusterBuilderSlot负责实现集群限流功能，ClusterBuilderSlot会将请求的流量信息汇报到集群的统计节点，然后根据集群限流规则决定是否应该限制请求。
三.StatisticSlot
StatisticSlot负责记录资源的访问统计信息，比如通过的请求数、阻塞的请求数、响应时间等。StatisticSlot会将每次资源访问的信息记录在资源的统计节点中，这些统计信息是Sentinel执行流量控制(如限流、熔断降级等)的重要指标。
四.SystemSlot
SystemSlot用于实现系统保护功能，它会提供基于系统负载、系统平均响应时间和系统入口QPS的保护策略。
五.AuthoritySlot
AuthoritySlot用于实现授权规则功能，比如基于黑白名单的访问权限。
六.FlowSlot
FlowSlot用于实现流量控制功能，比如对不同来源的流量进行限制、基于调用关系对流量进行控制。
七.DegradeSlot
DegradeSlot用于实现熔断降级功能，可以支持基于异常比例、异常数和响应时间的降级策略，处理链(处理器插槽链条)之间的关系图如下：
ProcessorSlot的用途总结：负责构建调用路径树、进行数据采集、实施流量控制和熔断降级等规则。
(4)Node
Node的用途很简单，就是基于处理槽采集的数据进行统计。比如统计总的请求量、请求成功量、请求失败量等指标。因此可以定义如下接口：
public interface Node {
//获取总请求量
long totalRequest();
//获取请求成功量
long successRequest();
//获取请求失败量
long failedRequest();
...
}即然Node是一个接口，那么需要提供一个具体的实现类。由于Node接口主要关注统计相关功能，因此可将实现类命名为StatisticNode，如下所示：
public class StatisticNode implements Node {
...
}通过StatisticNode类可完成Node接口定义的各种性能指标的收集和计算。但为了更多维度的计算，比如：上下文Context维度、资源维度等，还需要额外设计如下三个子类：
一.DefaultNode(单机里的资源维度)
默认节点，用于统计名字相同的Context下的某个资源的调用数据，意味着DefaultNode是以Context和ResourceWrapper为维度进行统计。
二.EntranceNode(接口维度)
继承自DefaultNode，是名字相同的Context的入口节点。用于统计名字相同的Context下的所有资源的调用数据，维度为Context。注意：默认创建的Context都是名字相同的，一个线程对应一个Context。所以EntranceNode可以理解为统计某接口被所有线程访问的调用数据。
三.ClusterNode(集群中的资源维度)
ClusterNode保存的是同一个资源的相关的统计信息，ClusterNode是以资源为维度的，不区分Context。
//Holds real-time statistics for resources.
public interface Node extends OccupySupport, DebugSupport {
...
}
public class StatisticNode implements Node {
...
}
//A Node used to hold statistics for specific resource name in the specific context.
//Each distinct resource in each distinct Context will corresponding to a DefaultNode.
//This class may have a list of sub DefaultNodes.
//Child nodes will be created when calling SphU.entry() multiple times in the same Context.
public class DefaultNode extends StatisticNode {
...
}
//A Node represents the entrance of the invocation tree.
//One Context will related to a EntranceNode, which represents the entrance of the invocation tree.
//New EntranceNode will be created if current context does't have one.
//Note that same context name will share same EntranceNode globally.
public class EntranceNode extends DefaultNode {
...
}
//This class stores summary runtime statistics of the resource, including rt, thread count, qps and so on.
//Same resource shares the same ClusterNode globally, no matter in which Context.
public class ClusterNode extends StatisticNode {
...
}
//The ClusterNode is uniquely identified by the ResourceId.
//The DefaultNode is identified by both the resource id and Context.
//In other words, one resource id will generate multiple DefaultNode for each distinct context,
//but only one ClusterNode.**三者的区别：**DefaultNode统计的是名字相同的Context下的某个资源的调用数据，EntranceNode统计的是名字相同的Context下的全部资源的调用数据，ClusterNode统计的是某个资源在所有Context下的调用数据。
注意：资源可以是一个方法、一个接口或一段代码。一个请求会对应一个Context，一个请求可能包含多个方法，所以一个请求可能操作多个资源，一个Context可能包含多个资源。
**Node的用途总结：**统计各种维度的各种数据指标。
(5)总结
一.资源访问对象Entry
每次访问资源都会创建一个Entry资源访问对象。每个Entry对象都会包含资源的基本信息(如名称、请求类型、资源类型等)、数据采集链和获取指标信息的方法(如QPS、成功请求数、失败请求数等)。由于一次请求可能涉及多个资源，因此Entry资源访问对象采用双向链表结构。
二.管理资源对象的上下文Context
资源的操作要在一个Context环境下进行，一个Context可包含多个资源。
三.请求、Entry、Context、ProcessorSlot、Node之间的关系
每次访问资源都要创建一个Entry对象，资源操作要建立在一个Context环境下。一个请求对应一个Context，一个Context可以包含多个资源，也就是一个Context会包含一条完整请求链路中涉及的所有资源。每个资源都通过ProcessorSlot进行数据采集和规则验证，而采集完的数据交由Node去做聚合统计分析。
**总之：**每个请求都需要与Context绑定，一个Context可以关联多个资源。每个资源都通过处理链ProcessorSlot进行数据采集和规则验证。ProcessorSlot数据采集完成后，会通过Node进行统计和分析。
2.Sentinel中Context的设计思想与源码实现
(1)初始化Entry和Context的设计思想
(2)初始化Entry的源码---将处理链、Context与Entry对象绑定
(3)初始化Context的源码---如何创建Context和EntranceNode
(4)总结
(1)初始化Entry和Context的设计思想
一.Context对象的name属性一般取默认值
Context对象是有一个name属性的，所以如果没有指定Context对象的name属性，则Context对象的name默认为sentinel_default_context。
Context context = InternalContextUtil.internalEnter("sentinel_default_context");二.使用ThreadLocal绑定线程和Context对象
由于一个请求要与一个Context对象进行绑定，一个请求由一个线程处理。所以可以定义一个ThreadLocal变量，让一个线程与一个Context对象绑定。
//存放线程与Context的绑定关系
private static ThreadLocal<Context> contextHolder = new ThreadLocal<>();三.如何初始化Entry对象
由于一个请求涉及多个资源，即一个Context对象会包含多个Entry对象，所以每个Entry对象必然属于某个Context对象。因此初始化Entry对象时需要将Context对象绑定到Entry对象中，这可以在Entry的构造方法中传入一个Context对象。当然Entry的构造方法也会传入一个ResourceWrapper对象，因为Entry的基本属性(名称、请求类型、资源类型)会封装在ResourceWrapper对象中。当然，Entry对象还需要的关键属性有：ProcessorSlot和Node。
//初始化Entry的基本属性
ResourceWrapper resource = new ResourceWrapper("/hello/world", EntryType.OUT, ResourceTypeConstants.COMMON);
//初始化Context
Context context = InternalContextUtil.internalEnter("sentinel_default_context");
//放到Entry当中
CtEntry entry = new CtEntry(resourceWrapper, context);(2)初始化Entry的源码---将处理链、Context与Entry对象绑定
Sentinel创建资源访问对象的入口是：SphU.entry("/hello/world")，在执行SphU.entry()方法时会初始化一个Context对象，其中便会调用CtSph.entry()方法创建一个Entry资源访问对象。
在CtSph的entry()方法中，首先会创建一个StringResourceWrapper对象，然后调用CtSph的entryWithPriority()方法执行如下的处理逻辑：初始化Context -> 将Context与线程绑定 -> 初始化Entry -> 将Context和ResourceWrapper放入Entry中。
在CtSph的entryWithPriority()方法中，由于创建一个Entry资源访问对象时，需要传入当前线程对应的Context，所以首先会调用ContextUtil的getContext()方法从当前线程中获取Context。如果获取到的Context为空，也就是当前线程没有绑定Context，那么就调用InternalContextUtil的internalEnter()方法创建一个Context对象，也就是调用ContextUtil的trueEnter()方法创建一个Context对象，并把这个Context对象放入ThreadLocal线程变量contextHolder中。然后调用CtSph的lookProcessChain()方法初始化处理链，接着创建一个Entry资源访问对象并将处理链、Context与该Entry资源访问对象绑定，最后调用ProcessorSlot的entry()方法执行处理链节点的数据采集 + 规则验证。
//The fundamental Sentinel API for recording statistics and performing rule checking for resources.
public class SphU {
private static final Object[] OBJECTS0 = new Object[0];
...
//Record statistics and perform rule checking for the given resource.
//@param name the unique name of the protected resource
public static Entry entry(String name) throws BlockException {
//调用CtSph.entry()方法创建一个Entry资源访问对象，默认的请求类型为OUT
return Env.sph.entry(name, EntryType.OUT, 1, OBJECTS0);
}
...
}
//Sentinel Env. This class will trigger all initialization for Sentinel.
public class Env {
//创建一个CtSph对象
public static final Sph sph = new CtSph();
static {
//If init fails, the process will exit.
InitExecutor.doInit();
}
}
public class CtSph implements Sph {
...
//Record statistics and perform rule checking for the given resource.
//@param name the unique name for the protected resource
//@param type the traffic type (inbound, outbound or internal).
//This is used to mark whether it can be blocked when the system is unstable, only inbound traffic could be blocked by SystemRule
//@param count the amount of calls within the invocation (e.g. batchCount=2 means request for 2 tokens)
//@param args args for parameter flow control or customized slots
@Override
public Entry entry(String name, EntryType type, int count, Object... args) throws BlockException {
//StringResourceWrapper是ResourceWrapper的子类，且StringResourceWrapper的构造方法默认了资源类型为COMMON
StringResourceWrapper resource = new StringResourceWrapper(name, type);
return entry(resource, count, args);
}
//Do all {@link Rule}s checking about the resource.
public Entry entry(ResourceWrapper resourceWrapper, int count, Object... args) throws BlockException {
//调用CtSph.entryWithPriority()方法，执行如下处理：
//初始化Context -> 将Context与线程绑定 -> 初始化Entry -> 将Context和ResourceWrapper放入Entry中
return entryWithPriority(resourceWrapper, count, false, args);
}
private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args) throws BlockException {
//从当前线程中获取Context
Context context = ContextUtil.getContext();
if (context instanceof NullContext) {
return new CtEntry(resourceWrapper, null, context);
}
//如果没获取到Context
if (context == null) {
//Using default context.
//创建一个名为sentinel_default_context的Context，并且与当前线程绑定
context = InternalContextUtil.internalEnter(Constants.CONTEXT_DEFAULT_NAME);
}
//Global switch is close, no rule checking will do.
if (!Constants.ON) {
return new CtEntry(resourceWrapper, null, context);
}
//调用CtSph.lookProcessChain()方法初始化处理链(处理器插槽链条)
ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);
if (chain == null) {
return new CtEntry(resourceWrapper, null, context);
}
//创建出一个Entry资源访问对象，将处理链(处理器插槽链条)、Context与Entry资源访问对象绑定
//其中会将Entry的三个基础属性(封装在resourceWrapper里)以及当前Entry所属的Context作为参数传入CtEntry的构造方法
Entry e = new CtEntry(resourceWrapper, chain, context);
try {
//处理链(处理器插槽链条)入口，负责采集数据，规则验证
//调用DefaultProcessorSlotChain.entry()方法执行处理链每个节点的逻辑(数据采集+规则验证)
chain.entry(context, resourceWrapper, null, count, prioritized, args);
} catch (BlockException e1) {
//规则验证失败，比如：被流控、被熔断降级、触发黑白名单等
e.exit(count, args);
throw e1;
} catch (Throwable e1) {
RecordLog.info("Sentinel unexpected exception", e1);
}
return e;
}
...
private final static class InternalContextUtil extends ContextUtil {
static Context internalEnter(String name) {
//调用ContextUtil.trueEnter()方法创建一个Context对象
return trueEnter(name, "");
}
static Context internalEnter(String name, String origin) {
return trueEnter(name, origin);
}
}
}
public class StringResourceWrapper extends ResourceWrapper {
public StringResourceWrapper(String name, EntryType e) {
//调用父类构造方法，且默认资源类型为COMMON
super(name, e, ResourceTypeConstants.COMMON);
}
...
}初始化Context的核心源码总结：
1.从当前ThreadLocal里获取Context
2.获取不到Context，则创建Context并将Context放到ThreadLocal里，与当前请求线程绑定
3.初始化处理链(处理器插槽链条)
4.将处理链(处理器插槽链条)、Context与Entry资源访问对象绑定
5.执行每一个链条的逻辑(数据采集 + 规则验证)
6.验证失败抛出BlockException(3)初始化Context的源码---如何创建Context和EntranceNode
ContextUtil的trueEnter()方法会尝试从ThreadLocal获取一个Context对象。如果获取不到，那么再创建一个Context对象然后放入到ThreadLocal中。
由于当前线程可能会涉及创建多个Entry，所以该方法需要注意并发问题。但是并非在创建Context时需要注意并发，因为一个线程本就需要一个Context。而是在创建Context对象所需的EntranceNode对象时才需注意并发，因为相同名字的Context对象会共用同一个EntranceNode对象。默认情况下，创建的Context对象都是有相同名字的，这样一个EntranceNode对象就可以对当前机器的所有请求进行统计。
其中在创建EntranceNode对象时，会使用Double Check + 锁的机制，先从缓存EntranceNode对象的Map中尝试获取已存在的EntranceNode。如果获取不到EntranceNode，那么再去创建EntranceNode对象，然后使用写时复制 + 锁去更新缓存EntranceNode对象的Map。
//Utility class to get or create Context in current thread.
//Each SphU.entry() should be in a Context.
//If we don't invoke ContextUtil.enter() explicitly, DEFAULT context will be used.
public class ContextUtil {
//Store the context in ThreadLocal for easy access.
//存放线程与Context的绑定关系
//每个请求对应一个线程，每个线程绑定一个Context，所以每个请求对应一个Context
private static ThreadLocal<Context> contextHolder = new ThreadLocal<>();
//Holds all EntranceNode. Each EntranceNode is associated with a distinct context name.
//以Context的name作为key，EntranceNode作为value缓存到HashMap中
private static volatile Map<String, DefaultNode> contextNameNodeMap = new HashMap<>();
private static final ReentrantLock LOCK = new ReentrantLock();
private static final Context NULL_CONTEXT = new NullContext();
...
//ContextUtil.trueEnter()方法会尝试从ThreadLocal获取一个Context对象
//如果获取不到，再创建一个Context对象然后放入ThreadLocal中
//入参name其实一般就是默认的Constants.CONTEXT_DEFAULT_NAME=sentinel_default_context
//由于当前线程可能会涉及创建多个Entry资源访问对象，所以trueEnter()方法需要注意并发问题
protected static Context trueEnter(String name, String origin) {
//从ThreadLocal中获取当前线程绑定的Context对象
Context context = contextHolder.get();
//如果当前线程还没绑定Context对象，则初始化Context对象并且与当前线程进行绑定
if (context == null) {
//首先要获取或创建Context对象所需要的EntranceNode对象，EntranceNode会负责统计名字相同的Context下的指标数据
//将全局缓存contextNameNodeMap赋值给一个临时变量localCacheNameMap
//因为后续会对contextNameNodeMap的内容进行修改，所以这里需要将原来的contextNameNodeMap复制一份出来
//从而避免后续对contextNameNodeMap的内容进行修改时，可能造成对接下来读取contextNameNodeMap内容的影响
Map<String, DefaultNode> localCacheNameMap = contextNameNodeMap;
//从缓存副本localCacheNameMap中获取EntranceNode
//这个name其实一般就是默认的sentinel_default_context
DefaultNode node = localCacheNameMap.get(name);
//如果获取的EntranceNode为空
if (node == null) {
//为了防止缓存无限制地增长，导致内存占用过高，需要设置一个上限，只要超过上限，就直接返回NULL_CONTEXT
if (localCacheNameMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {
setNullContext();
return NULL_CONTEXT;
} else {
//如果Context还没创建，缓存里也没有当前Context名称对应的EntranceNode，并且缓存数量尚未达到2000
//那么就创建一个EntranceNode，创建EntranceNode时需要加锁，否则会有线程不安全问题
//毕竟需要修改HashMap类型的contextNameNodeMap
//通过加锁 + 缓存 + 写时复制更新缓存，避免并发情况下创建出多个EntranceNode对象
//一个线程对应一个Context对象，多个线程对应多个Context对象
//这些Context对象会使用ThreadLocal进行隔离，但它们的name默认都是sentinel_default_context
//根据下面的代码逻辑：
//多个线程(对应多个Context的name默认都是sentinel_default_context)会共用同一个EntranceNode
//于是可知，多个Context对象会共用一个EntranceNode对象
LOCK.lock();
try {
//从缓存中获取EntranceNode
node = contextNameNodeMap.get(name);
//对node进行Double Check
//如果没获取到EntranceNode
if (node == null) {
if (contextNameNodeMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {
setNullContext();
return NULL_CONTEXT;
} else {
//创建EntranceNode，缓存到contextNameNodeMap当中
node = new EntranceNode(new StringResourceWrapper(name, EntryType.IN), null);
//Add entrance node.
//将新创建的EntranceNode添加到ROOT中，ROOT就是每个Node的根结点
Constants.ROOT.addChild(node);
//写时复制，将新创建的EntranceNode添加到缓存中
Map<String, DefaultNode> newMap = new HashMap<>(contextNameNodeMap.size() + 1);
newMap.putAll(contextNameNodeMap);
newMap.put(name, node);
contextNameNodeMap = newMap;
}
}
} finally {
//解锁
LOCK.unlock();
}
}
}
//此处可能会有多个线程同时执行到此处，并发创建多个Context对象
//但这是允许的，因为一个请求对应一个Context，一个请求对应一个线程，所以一个线程本来就需要创建一个Context对象
//初始化Context，将刚获取到或刚创建的EntranceNode放到Context的entranceNode属性中
context = new Context(node, name);
context.setOrigin(origin);
//将创建出来的Context对象放入ThreadLocal变量contextHolder中，实现Context对象与当前线程的绑定
contextHolder.set(context);
}
return context;
}
...
}(4)总结
初始化Entry和Context的整体流程：
3.Java SPI机制的引入
(1)Java SPI机制的简介
(2)基于Java SPI机制开发日志框架的示例
(3)ServiceLoader的原理简介
(1)Java SPI机制的简介
SPI(Service Provider Interface)是Java提供的一种轻量级的服务发现机制，可以让开发者通过约定的方式，在程序运行时动态加载和替换接口的实现，从而提高程序的扩展性和灵活性。
比如在写框架时可以先写一个接口，然后内置几种实现类(实现不同算法)。但是业务系统接入这个框架时应该选择哪种算法、采取哪个实现类呢？这时就可以通过配置来完成。
首先将接口实现类的全限定名配置在配置文件中，然后当业务系统启动时，框架会读取配置文件并解析出配置类的全限定名，接着通过反射机制在运行时动态替换接口的默认实现类。
(2)基于Java SPI机制开发日志框架的示例
假设要开发一个日志框架，其中需要实现一个Logger接口，用于记录日志。我们希望在框架中预置两个Logger实现类：ConsoleLogger和FileLogger，同时也希望用户可以根据自己的需要扩展Logger实现类。
步骤一：定义Logger接口
public interface Logger {
void log(String message);
}步骤二：在框架中内置ConsoleLogger和FileLogger实现类
public class ConsoleLogger implements Logger {
@Override
public void log(String message) {
//直接打印到控制台
System.out.println("[ConsoleLogger] " + message);
}
}
public class FileLogger implements Logger {
@Override
public void log(String message) {
//将日志写入文件
}
}步骤三：实现SPI机制 + 扩展Logger实现类
首先，在META-INF/services目录下创建文件"com.example.Logger"，文件内容为Logger实现类的全限定名。例如，如下的MyLogger就是用户自定义的Logger实现类。
com.example.MyLogger然后，在框架中读取Logger实现类的全限定名，并实例化Logger实现类，这可以通过以下代码实现。这段代码会从META-INF/services目录下读取Logger实现类的全限定名，然后通过Java反射机制实例化对应的Logger实现类，并调用其log()方法。
public static void main(String[] args){
ServiceLoader<Logger> loggerServiceLoader = ServiceLoader.load(Logger.class);
for (Logger logger : loggerServiceLoader) {
logger.log("Hello, Java SPI!");
}
}(3)ServiceLoader的原理简介
ServiceLoader是Java提供的一种基于SPI机制的服务加载器，它可以在程序运行时动态加载和实例化实现了某个接口的类。所以通过ServiceLoader机制，可以方便地扩展和替换程序中的实现类。
ServiceLoader的使用非常简单，只要首先按照规范创建接口和实现类，然后在META-INF/services目录下创建以接口全限定名命名的文件，接着在文件中写入实现类的全限定名，最后调用ServiceLoader的load()方法便可以加载并实例化实现类。
ServiceLoader的load()方法会根据传入的接口获取接口的全类名，然后将前缀/META-INF/services与接口的全类名拼接来定位到配置文件，接着读取配置文件的内容获取文件中的字符串，最后解析字符串得到实现类的全类名并添加到一个数组。
ServiceLoader实现了迭代器Iterable接口，当遍历ServiceLoader时，ServiceLoader会调用Class的forName()方法加载类并通过反射创建实例。如果没有指定类加载器，则会使用当前线程的上下文类加载器来加载类。通过这种方式，就可以方便地扩展和替换程序中的实现类。
(4)总结
Java SPI是一种轻量级的服务发现机制，可以动态加载和替换接口实现类。通过约定的方式，开发者可在程序运行时动态地加载和替换接口的实现，从而提高程序的扩展性和灵活性。
Java SPI机制通常与ServiceLoader一起使用，ServiceLoader会从META-INF/services目录下的配置文件中，读取接口实现类的全限定名，并通过Java反射机制实例化对应的类，从而实现对接口实现类的动态加载和替换。
SPI机制在开源项目中被广泛使用，例如SpringBoot、RocketMQ、Dubbo、Sentinel等。
Java SPI的使用流程图如下：
4.Java SPI机制在Sentinel处理链中的应用
(1)初始化Entry会初始化处理链
(2)初始化处理链的设计分析
(3)Sentinel初始化处理链的完整流程
(4)Sentinel初始化处理任链之加载SPI文件
(5)Sentinel初始化处理链之实例化Class
(1)初始化Entry会初始化处理链
初始化Entry时会调用两个与处理链相关的核心方法：一是调用CtSph的lookProcessChain()方法初始化处理链，二是调用ProcessorSlot的entry()方法执行处理链节点的逻辑。
public class CtSph implements Sph {
...
//Record statistics and perform rule checking for the given resource.
//@param name the unique name for the protected resource
//@param type the traffic type (inbound, outbound or internal).
//This is used to mark whether it can be blocked when the system is unstable, only inbound traffic could be blocked by SystemRule
//@param count the amount of calls within the invocation (e.g. batchCount=2 means request for 2 tokens)
//@param args args for parameter flow control or customized slots
@Override
public Entry entry(String name, EntryType type, int count, Object... args) throws BlockException {
//StringResourceWrapper是ResourceWrapper的子类，且StringResourceWrapper的构造方法默认了资源类型为COMMON
StringResourceWrapper resource = new StringResourceWrapper(name, type);
return entry(resource, count, args);
}
//Do all {@link Rule}s checking about the resource.
public Entry entry(ResourceWrapper resourceWrapper, int count, Object... args) throws BlockException {
//调用CtSph.entryWithPriority()方法，执行如下处理：
//初始化Context -> 将Context与线程绑定 -> 初始化Entry -> 将Context和ResourceWrapper放入Entry中
return entryWithPriority(resourceWrapper, count, false, args);
}
private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args) throws BlockException {
//从当前线程中获取Context
Context context = ContextUtil.getContext();
if (context instanceof NullContext) {
return new CtEntry(resourceWrapper, null, context);
}
//如果没获取到Context
if (context == null) {
//Using default context.
//创建一个名为sentinel_default_context的Context，并且与当前线程绑定
context = InternalContextUtil.internalEnter(Constants.CONTEXT_DEFAULT_NAME);
}
//Global switch is close, no rule checking will do.
if (!Constants.ON) {
return new CtEntry(resourceWrapper, null, context);
}
//调用CtSph.lookProcessChain()方法初始化处理链(处理器插槽链条)
ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);
if (chain == null) {
return new CtEntry(resourceWrapper, null, context);
}
//创建出一个Entry对象，将处理链(处理器插槽链条)、Context与Entry绑定
//其中会将Entry的三个基础属性(封装在resourceWrapper里)以及当前Entry所属的Context作为参数传入CtEntry的构造方法
Entry e = new CtEntry(resourceWrapper, chain, context);
try {
//处理链(处理器插槽链条)入口，负责采集数据，规则验证
//调用DefaultProcessorSlotChain.entry()方法执行处理链每个节点的逻辑(数据采集+规则验证)
chain.entry(context, resourceWrapper, null, count, prioritized, args);
} catch (BlockException e1) {
//规则验证失败，比如：被流控、被熔断降级、触发黑白名单等
e.exit(count, args);
throw e1;
} catch (Throwable e1) {
RecordLog.info("Sentinel unexpected exception", e1);
}
return e;
}
...
private final static class InternalContextUtil extends ContextUtil {
static Context internalEnter(String name) {
//调用ContextUtil.trueEnter()方法创建一个Context对象
return trueEnter(name, "");
}
static Context internalEnter(String name, String origin) {
return trueEnter(name, origin);
}
}
}(2)初始化处理链的设计分析
一.初始化处理链需要加锁确保线程安全
由于每个线程在执行CtSph的entry()方法创建一个Entry对象时，都需要首先调用CtSph的lookProcessChain()方法获取一个处理链，然后再根据这个处理链去初始化一个Entry对象，所以多个同样的Entry对象会共用一个处理链对象。
需要注意：即便是多个线程访问同样的资源(ResourceWrapper对象的属性一样)，多个线程也会对应多个Entry对象(Entry对象之间的基本属性一样)，多个线程也会对应多个Context对象(使用ThreadLocal存放Context对象)，从而多个Entry对象会对应各自的Context对象。多个Entry对象会共用一个处理链对象(使用HashMap来缓存处理链对象)，多个Context对象会共用一个Node对象(使用HashMap来缓存Node对象)，多个Entry对象会共用一个Node对象(使用HashMap来缓存Node对象)。
因此当出现多线程并发创建多个Entry对象时，CtSph的lookProcessChain()方法自然就会被多线程并发调用。所以在初始化处理链时，需要考虑线程安全和性能问题。
为了确保线程安全，可以采用加锁的方式来初始化处理链，然后将处理链缓存到HashMap中来提高性能，如下伪代码所示：
//缓存处理链，key为资源，value为处理链
//多个线程创建多个Entry对象时，也会创建多个ResourceWrapper对象
//但这些ResourceWrapper对象，在同一个资源下，其属性是一样的
private static volatile Map<ResourceWrapper, ProcessorSlotChain> chainMap = new HashMap<ResourceWrapper, ProcessorSlotChain>();
//加锁synchronized
synchronized ProcessorSlot<Object> lookProcessChain(ResourceWrapper resourceWrapper) {
ProcessorSlotChain chain = chainMap.get(resourceWrapper);
if (chain == null) {
//构建(初始化)处理链(处理器插槽链条)
chain = SlotChainProvider.newSlotChain();
//将处理链(处理器插槽链条)放到缓存中
chainMap.put(resourceWrapper, chain);
}
return chain;
}二.初始化处理链通过SPI机制动态管理节点
初始化处理链时可使用List硬编码添加每个节点。
public class DefaultSlotChainBuilder implements SlotChainBuilder {
@Override
public ProcessorSlotChain build() {
//硬编码
ProcessorSlotChain chain = new DefaultProcessorSlotChain();
chain.addLast(new NodeSelectorSlot());
chain.addLast(new ClusterBuilderSlot());
chain.addLast(new StatisticSlot());
chain.addLast(new AuthoritySlot());
chain.addLast(new SystemSlot());
chain.addLast(new FlowSlot());
chain.addLast(new DegradeSlot());
return chain;
}
}但硬编码的缺点是无法动态增减ProcessorSlot。比如不需要授权AuthoritySlot，硬编码时就不好删除了。比如内置的几个ProcessorSlot不符合业务需求，硬编码难以实现自定义。因此，需要使用SPI机制来解决硬编码带来的问题。也就是在配置文件中注册多个实现类，然后通过迭代器的方式逐个加载。
具体就是在META-INF/services目录下创建一个接口文件，然后将需要注册的实现类的全类名每行一个写入该文件中。框架启动时依次读取该文件中的实现类，并按照文件中注册的顺序加载。如果业务系统也创建了META-INF/services目录以及一个接口文件，那么业务系统的实现类并不会覆盖框架内置的实现类，而是叠加起来使用。
利用SPI机制，可以实现责任链模式的可插拔式扩展，处理链(处理器插槽链条)的每个节点都可以动态添加、删除、替换。
三.使用SPI机制的两大步骤
**步骤一：**创建META-INF/services目录，然后在该目录下创建一个文件名为如下的文件，文件内容为定义了处理链由哪些节点组成的类的类名全路径。
com.alibaba.csp.sentinel.slotchain.SlotChainBuilder**步骤二：**通过ServiceLoader初始化处理链节点。
public static void main(String[] args){
ServiceLoader<SlotChainBuilder> serviceLoader = ServiceLoader.load(SlotChainBuilder.class);
...
}四.初始化处理链的设计要点总结
要点一：初始化处理链时加锁
要点二：使用HashMap缓存处理链
要点三：使用SPI机制初始化处理链
(3)Sentinel初始化处理链的完整流程
一.将处理链存储在全局缓存 + 使用锁初始化处理链
如果对CtSph的lookProcessChain()方法加锁，则锁的粒度过大。所以可以在操作缓存处理链的HashMap时才加synchronized锁，而且在操作缓存处理链的HashMap时，使用了Double Check + 写时复制。
二.利用SPI机制完成处理链的初始化
为了增加扩展性，Sentinel初始化处理链时使用了SPI机制两次。第一次使用SPI机制，是为了可以自定义处理链的节点编排。第二次使用SPI机制，是为了可以自定义处理链各节点的具体逻辑。
public class CtSph implements Sph {
//Same resource will share the same ProcessorSlotChain}, no matter in which Context.
//Same resource is that ResourceWrapper#equals(Object).
private static volatile Map<ResourceWrapper, ProcessorSlotChain> chainMap = new HashMap<ResourceWrapper, ProcessorSlotChain>();
private static final Object LOCK = new Object();
...
//Get ProcessorSlotChain of the resource.
//new ProcessorSlotChain will be created if the resource doesn't relate one.
//Same resource will share the same ProcessorSlotChain globally, no matter in which Context.
//Same resource is that ResourceWrapper#equals(Object).
//Note that total ProcessorSlot count must not exceed Constants.MAX_SLOT_CHAIN_SIZE, otherwise null will return.
ProcessorSlot<Object> lookProcessChain(ResourceWrapper resourceWrapper) {
ProcessorSlotChain chain = chainMap.get(resourceWrapper);
if (chain == null) {
//操作chainMap时才加锁
synchronized (LOCK) {
chain = chainMap.get(resourceWrapper);
if (chain == null) {//Double Check
//Entry size limit.
if (chainMap.size() >= Constants.MAX_SLOT_CHAIN_SIZE) {
return null;
}
//初始化处理链(处理器插槽链条)
chain = SlotChainProvider.newSlotChain();
//写时复制
Map<ResourceWrapper, ProcessorSlotChain> newMap = new HashMap<ResourceWrapper, ProcessorSlotChain>(chainMap.size() + 1);
newMap.putAll(chainMap);
newMap.put(resourceWrapper, chain);
chainMap = newMap;
}
}
}
return chain;
}
...
}
//A provider for creating slot chains via resolved slot chain builder SPI.
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 CtSph.lookProcessChain() under lock.
public static ProcessorSlotChain newSlotChain() {
//如果存在，则直接返回
if (slotChainBuilder != null) {
return slotChainBuilder.build();
}
//Resolve the slot chain builder SPI.
//第一次使用SPI: 通过SPI机制初始化SlotChainBuilder
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");
slotChainBuilder = new DefaultSlotChainBuilder();
} else {
RecordLog.info("[SlotChainProvider] Global slot chain builder resolved: {}", slotChainBuilder.getClass().getCanonicalName());
}
return slotChainBuilder.build();
}
private SlotChainProvider() {}
}
public final class SpiLoader<S> {
//Cache the SpiLoader instances, key: classname of Service, value: SpiLoader instance
private static final ConcurrentHashMap<String, SpiLoader> SPI_LOADER_MAP = new ConcurrentHashMap<>();
//Cache the classes of Provider
private final List<Class<? extends S>> classList = Collections.synchronizedList(new ArrayList<Class<? extends S>>());
//Cache the sorted classes of Provider
private final List<Class<? extends S>> sortedClassList = Collections.synchronizedList(new ArrayList<Class<? extends S>>());
...
//Create SpiLoader instance via Service class Cached by className, and load from cache first
public static <T> SpiLoader<T> of(Class<T> service) {
AssertUtil.notNull(service, "SPI class cannot be null");
AssertUtil.isTrue(service.isInterface() || Modifier.isAbstract(service.getModifiers()), "SPI class[" + service.getName() + "] must be interface or abstract class");
String className = service.getName();
SpiLoader<T> spiLoader = SPI_LOADER_MAP.get(className);
if (spiLoader == null) {
synchronized (SpiLoader.class) {
spiLoader = SPI_LOADER_MAP.get(className);
if (spiLoader == null) {//Double Check
SPI_LOADER_MAP.putIfAbsent(className, new SpiLoader<>(service));
spiLoader = SPI_LOADER_MAP.get(className);
}
}
}
return spiLoader;
}
//Load the first-found Provider instance,if not found, return default Provider instance
public S loadFirstInstanceOrDefault() {
//SPI机制加载Class，然后将加载的Class放到classList数组里
load();
//循环遍历，根据classList里的Class来初始化对应的实例
for (Class<? extends S> clazz : classList) {
if (defaultClass == null || clazz != defaultClass) {
return createInstance(clazz);
}
}
//初始化默认的DefaultSlotChainBuilder
return loadDefaultInstance();
}
//Load all Provider instances of the specified Service, sorted by order value in class's {@link Spi} annotation
public List<S> loadInstanceListSorted() {
//比如读取com.alibaba.csp.sentinel.slotchain.ProcessorSlot文件里的Class名字
//然后根据这些Class名字加载Class
//接着将Class放到sortedClassList集合中
load();
//实例化sortedClassList集合里的每个Class
return createInstanceList(sortedClassList);
}
...
}
//Builder for a default {@link ProcessorSlotChain}.
@Spi(isDefault = true)
public class DefaultSlotChainBuilder implements SlotChainBuilder {
@Override
public ProcessorSlotChain build() {
ProcessorSlotChain chain = new DefaultProcessorSlotChain();
//通过SPI机制加载责任链的节点ProcessorSlot实现类
//然后按照@Spi注解的order属性进行排序并进行实例化
//最后将ProcessorSlot实例放到sortedSlotList中
List<ProcessorSlot> sortedSlotList = SpiLoader.of(ProcessorSlot.class).loadInstanceListSorted();
//遍历已排好序的ProcessorSlot集合
for (ProcessorSlot slot : sortedSlotList) {
//安全检查，防止业务系统也写了一个SPI文件，但没按规定继承AbstractLinkedProcessorSlot
if (!(slot instanceof AbstractLinkedProcessorSlot)) {
RecordLog.warn("The ProcessorSlot(" + slot.getClass().getCanonicalName() + ") is not an instance of AbstractLinkedProcessorSlot, can't be added into ProcessorSlotChain");
continue;
}
//调用DefaultProcessorSlotChain.addLast()方法构建单向链表
//将责任链的节点ProcessorSlot实例放入DefaultProcessorSlotChain中
chain.addLast((AbstractLinkedProcessorSlot<?>) slot);
}
//返回单向链表
return chain;
}
}第一次使用SPI机制是初始化SlotChainBuilder，在com.alibaba.csp.sentinel.slotchain.SlotChainBuilder文件中，框架默认的是com.alibaba.csp.sentinel.slots.DefaultSlotChainBuilder。
在SpiLoader的loadFirstInstanceOrDefault()方法中，根据"if (defaultClass == null || clazz != defaultClass)"可知，系统接入Sentinel时可以自定义SPI接口文件来替换DefaultSlotChainBuilder。
比如想删除AuthoritySlot，那么可以在META-INF/services目录下，创建文件名如下，文件值为自定义接口的实现类全路径，如下：
文件名：com.alibaba.csp.sentinel.slotchain.SlotChainBuilder
文件值：com.example.MyCustomSlotChainBuilder然后在MyCustomSlotChainBuilder中就可以自定义一套处理链的规则。
public class MyCustomSlotChainBuilder implements SlotChainBuilder {
@Override
public ProcessorSlotChain build() {
ProcessorSlotChain chain = new DefaultProcessorSlotChain();
chain.addLast(new NodeSelectorSlot());
chain.addLast(new ClusterBuilderSlot());
chain.addLast(new StatisticSlot());
chain.addLast(new FlowSlot());
return chain;
}
}第二次使用SPI机制是执行DefaultSlotChainBuilder的build()方法初始化处理链，其中的核心代码是SpiLoader.of(ProcessorSlot.class).loadInstanceListSorted()。所调用的方法会读取com.alibaba.csp.sentinel.slotchain.ProcessorSlot文件内容，然后根据文件内容加载Class，接着将Class放到sortedClassList集合中，最后实例化sortedClassList集合中的Class并返回ProcessorSlot实例列表。
注意：ProcessorSlot实现类是有序的，即处理链的节点是有序的。比如ClusterBuilderSlot的前一个节点必须是NodeSelectorSlot，StatisticSlot的前一个节点必须是ClusterBuilderSlot等。
(4)Sentinel初始化处理链之加载SPI文件
Sentinel初始化处理链时会先后调用如下两个方法，这两个方法都会调用SpiLoader的load()方法来加载SPI文件。
SpiLoader.of(SlotChainBuilder.class).loadFirstInstanceOrDefault()
SpiLoader.of(ProcessorSlot.class).loadInstanceListSorted()SpiLoader的load()方法的执行过程就是加载SPI文件的过程。但是由于SPI文件可能会有很多个，比如负责管控整个处理链的Builder对应的SPI文件：
com.alibaba.csp.sentinel.slotchain.SlotChainBuilder以及处理链节点的ProcessorSlot对应的SPI文件：
com.alibaba.csp.sentinel.slotchain.ProcessorSlot虽然它们都隶属于META-INF/services下，但其文件名是不一样的。所以按理应在load()方法添加一个参数如：load(String fileName)。但是Sentinel却没这么做，因为Sentinel使用配置去替代参数。
具体做法就是：先在SpiLoader内定义常量SPI_FILE_PREFIX = "META-INF/services/"。有了SPI文件夹后，还需接口全路径名为名称的文件，就可读取文件了。
于是SpiLoader提供了一个静态的of()方法，来指定要加载那一类接口。也就是SpiLoader的of()方法会返回一个指定加载某种接口的SpiLoader实例。
然后在执行指定加载某一类接口的SpiLoader实例的load()方法时，就能将指定要加载的接口的名称拼接上SPI_FILE_PREFIX文件夹前缀，得到一份完整的文件路径，接着就可通过IO流读取文件里的内容。
从文件中获取到指定加载的某一类接口的实现类类名之后，就可以通过Class.forName() + 线程上下文类加载器去加载对应的实现类，加载到的实现类会放入到classList和sortedClassList两个列表中。
注意：Sentinel的SPI机制没有使用JDK内置的ServiceLoader，而是自己实现。因为Sentinel的SPI有一些定制化逻辑，比如@Spi注解的order属性可以指定实例化类时的顺序。但本质上和JDK内置的ServiceLoader一致，只是多了个性化的逻辑。
public final class SpiLoader<S> {
//Default path for the folder of Provider configuration file
//SPI文件夹路径
private static final String SPI_FILE_PREFIX = "META-INF/services/";
//Cache the SpiLoader instances, key: classname of Service, value: SpiLoader instance
//每个接口Class对应的SpiLoader，只需new一次即可，new完就可以将其缓存起来
private static final ConcurrentHashMap<String, SpiLoader> SPI_LOADER_MAP = new ConcurrentHashMap<>();
//Cache the classes of Provider
private final List<Class<? extends S>> classList = Collections.synchronizedList(new ArrayList<Class<? extends S>>());
//Cache the sorted classes of Provider
private final List<Class<? extends S>> sortedClassList = Collections.synchronizedList(new ArrayList<Class<? extends S>>());
//The Service class, must be interface or abstract class
//指定要使用SPI进行加载的实现类的接口的Class，比如SlotChainBuilder.class、ProcessorSlot.class
private Class<S> service;
...
private SpiLoader(Class<S> service) {
this.service = service;
}
//Create SpiLoader instance via Service class
//Cached by className, and load from cache first
//@param service Service class 指定要使用SPI加载的实现类的接口的Class
public static <T> SpiLoader<T> of(Class<T> service) {
//判断是不是null
AssertUtil.notNull(service, "SPI class cannot be null");
//判断是不是interface类型
AssertUtil.isTrue(service.isInterface() || Modifier.isAbstract(service.getModifiers()), "SPI class[" + service.getName() + "] must be interface or abstract class");
//获取接口的全路径名，判断缓存里是否已经存在
String className = service.getName();
SpiLoader<T> spiLoader = SPI_LOADER_MAP.get(className);
//缓存里没有，则使用Double Check + 锁机制去初始化SpiLoader，然后将初始化好的SpiLoader实例放到缓存
if (spiLoader == null) {
synchronized (SpiLoader.class) {
spiLoader = SPI_LOADER_MAP.get(className);
if (spiLoader == null) {
//new SpiLoader<>(service)初始化SpiLoader实例
SPI_LOADER_MAP.putIfAbsent(className, new SpiLoader<>(service));
spiLoader = SPI_LOADER_MAP.get(className);
}
}
}
//返回SpiLoader实例
return spiLoader;
}
//Load the first-found Provider instance,if not found, return default Provider instance
public S loadFirstInstanceOrDefault() {
//SPI机制加载Class，然后将加载的Class放到classList数组里
load();
//循环遍历，根据classList里的Class来初始化对应的实例
for (Class<? extends S> clazz : classList) {
if (defaultClass == null || clazz != defaultClass) {
return createInstance(clazz);
}
}
//初始化默认的DefaultSlotChainBuilder
return loadDefaultInstance();
}
//Load all Provider instances of the specified Service, sorted by order value in class's {@link Spi} annotation
public List<S> loadInstanceListSorted() {
//比如读取com.alibaba.csp.sentinel.slotchain.ProcessorSlot文件里的Class名字
//然后根据这些Class名字加载Class
//接着将Class放到sortedClassList集合中
load();
//实例化sortedClassList集合里的每个Class
return createInstanceList(sortedClassList);
}
//Load the Provider class from Provider configuration file
public void load() {
...
//IO流读取文件内容
while (urls.hasMoreElements()) {
...
clazz = (Class<S>) Class.forName(line, false, classLoader);
//加入到集合中
classList.add(clazz);
...
}
...
//生成新的按照order排序的集合
sortedClassList.addAll(classList);
//进行排序
Collections.sort(sortedClassList, new Comparator<Class<? extends S>>() {
@Override
public int compare(Class<? extends S> o1, Class<? extends S> o2) {
//获取Spi注解
Spi spi1 = o1.getAnnotation(Spi.class);
//获取Spi注解的order属性
int order1 = spi1 == null ? 0 : spi1.order();
Spi spi2 = o2.getAnnotation(Spi.class);
int order2 = spi2 == null ? 0 : spi2.order();
return Integer.compare(order1, order2);
}
});
}
...
}(5)Sentinel初始化处理链之实例化Class
执行完SpiLoader的load()方法加载好指定的实现类的Class后，就会调用SpiLoader的createInstance()方法或createInstanceList()方法实例化Class。
SpiLoader放入createInstance(clazz)方法内部会判断是否是单例，如果是单例则放到缓存当中，如果不是单例则每次都通过clazz.newInstance()方法创建一个新的对象。
public final class SpiLoader<S> {
//Cache the singleton instance of Provider, key: classname of Provider, value: Provider instance
private final ConcurrentHashMap<String, S> singletonMap = new ConcurrentHashMap<>();
...
//Create Provider instance list
private List<S> createInstanceList(List<Class<? extends S>> clazzList) {
if (clazzList == null || clazzList.size() == 0) {
return Collections.emptyList();
}
List<S> instances = new ArrayList<>(clazzList.size());
for (Class<? extends S> clazz : clazzList) {
S instance = createInstance(clazz);
instances.add(instance);
}
return instances;
}
//Create Provider instance
private S createInstance(Class<? extends S> clazz) {
Spi spi = clazz.getAnnotation(Spi.class);
boolean singleton = true;
if (spi != null) {
singleton = spi.isSingleton();
}
return createInstance(clazz, singleton);
}
//Create Provider instance
private S createInstance(Class<? extends S> clazz, boolean singleton) {
S instance = null;
try {
if (singleton) {
instance = singletonMap.get(clazz.getName());
if (instance == null) {
synchronized (this) {
instance = singletonMap.get(clazz.getName());
if (instance == null) {
instance = service.cast(clazz.newInstance());
singletonMap.put(clazz.getName(), instance);
}
}
}
} else {
instance = service.cast(clazz.newInstance());
}
} catch (Throwable e) {
fail(clazz.getName() + " could not be instantiated");
}
return instance;
}
...
}(6)总结
一.初始化处理链时需要加锁和使用缓存
初始化一个Entry对象时需要根据一个处理链对象进行初始化，并发请求同一接口时的多个同样的Entry对象会共用一个处理链对象，所以初始化处理链的过程中需要加锁来保证线程安全性，初始化完处理链后需要将其放到全局缓存里来提高性能。
二.初始化处理链时分两步使用SPI
首先初始化Builder，负责管控处理链整体即编排处理链节点。Sentinel要求Builder只能存在一个，而且是外部系统优先原则。可以在com.alibaba.csp.sentinel.slotchain.SlotChainBuilder文件中，指定替代默认的DefaultSlotChainBuilder的自定义接口实现类。
然后通过Builder初始化完整的处理链，这里也是通过SPI机制进行初始化。因此可以进行扩展，比如外部系统自定义ProcessorSlot添加到处理链。注意ProcessorSlot是有顺序的，如果顺序没指定正确，则可能造成异常。ProcessorSlot的顺序可以通过@Spi注解的order属性设置。为了防止出现bug，建议直接将自定义的ProcessorSlot放到最后。
三.Sentinel通过配置的方式来替代传入参数
SpiLoader的of()方法会返回一个指定加载某种实现类的SpiLoader实例，这样就可以使用类似SpiLoader.of().load()的方式通过SPI进行加载。
四.Sentinel没有采用JDK内置的ServiceLoader来实现SPI机制
Sentinel单独写一套SPI的实现逻辑，核心原因是需要支持个性化的配置。比如@Spi注解支持order排序属性以及isSingleton是否单例属性。如果是单例，则每个类全局只能实例化一次(通过Map缓存实现)。如果不是单例，则每次都new一个新的对象。
五.Sentinel的这套SPI机制可以当作工具类拷贝到业务系统中
因为没有其他外部依赖，它被单独放到一个包里。
5.Sentinel默认处理链ProcessorSlot的构建
(1)Sentinel默认处理链的节点
(2)Sentinel默认处理链的构建
(1)Sentinel默认处理链的节点
Sentinel中的ProcessorSlot是流量控制处理过程中的处理器，每个ProcessorSlot处理器子类负责处理特定的任务。Sentinel默认的处理链会基于SPI配置在sentinel-core模块的如下文件中：
# Sentinel-1.8.6/sentinel-core/src/main/resources/META-INF/services/com.alibaba.csp.sentinel.slotchain.ProcessorSlot
# 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一共8个Slot，每个Slot都是一个过滤器，各自承担不同的职责。这些Slot整体可以划分为两类：指标数据采集的Slot和规则验证的Slot。其中规则验证的Slot包括：授权验证、流控验证、熔断降级验证。
每个Slot都有自己在整个处理链(处理器插槽链条)中的顺序，具体的顺序(也就是实例化顺序)并不是根据SPI文件的编写顺序来确定的，而是基于修饰每个Slot的@Spi注解来确定的。
@Spi注解有一个order属性用于设置顺序。SpiLoader的load()方法在读取SPI文件时，会按order属性对Slot进行排序，并将排好序的ProcessorSlot实现类放入sortedClassList中。这样后续就可以遍历sortedClassList，按照顺序实例化这些Slot的实现类。
一.NodeSelectorSlot
负责创建和维护资源调用树(资源调用关系)，同时为资源访问对象Entry关联对应的统计节点DefaultNode。这样不仅可实现对资源调用链路的监控，还能统计每个资源的调用信息。
二.ClusterBuilderSlot
负责根据资源的统计信息，计算集群维度的统计数据。集群维度统计数据是从资源维度的统计数据中整合得到的，这些统计数据用于实现资源在集群中的流量控制、熔断降级等功能。
三.LogSlot
负责记录请求异常时的日志，可用于故障排查。
四.StatisticsSlot
负责统计资源的调用数据，如成功调用次数、异常次数、响应时间等。这些数据可用于分析资源的性能，或驱动其他Slot(如限流降级Slot)运行。
五.AuthoritySlot
负责进行授权控制，根据资源的授权规则来判断是否允许请求进行访问。如果请求不被允许访问，AuthoritySlot将抛出AuthorityException异常。
六.SystemSlot
负责进行系统保护，根据系统保护规则(如CPU使用率、负载等)判断请求是否需要被限制。如果需要被限制，SystemSlot将抛出SystemException异常。
七.FlowSlot
负责进行流量控制，根据资源的流量控制规则(如QPS限制等)来判断请求是否需要被限流。如果需要被限流，FlowSlot将抛出一个FlowException异常。
八.DegradeSlot
负责进行熔断降级，根据资源的熔断降级规则(如异常比例等)来判断请求是否需要被降级。如果需要被降级，DegradeSlot将抛出一个DegradeException异常。
(2)Sentinel默认处理链的构建
处理链(处理器插槽链条)ProcessorSlotChain其实就是一条责任链，由于责任链是典型的单向链表结构，所以每个Slot必须要有一个next属性，用于指向下一个节点。
为了实现单向链表结构：可以利用已排好序的Slot列表以及每个Slot都有的next引用的特性。只需遍历已排序的Slot列表，让每个Slot的next引用指向下一个Slot即可。这是一个非常简单的单向链表操作，可将这个过程封装到DefaultProcessorSlotChain类中的addLast()方法中。
//Builder for a default {@link ProcessorSlotChain}.
@Spi(isDefault = true)
public class DefaultSlotChainBuilder implements SlotChainBuilder {
@Override
public ProcessorSlotChain build() {
//创建一个DefaultProcessorSlotChain对象实例
ProcessorSlotChain chain = new DefaultProcessorSlotChain();
//通过SPI机制加载责任链的节点ProcessorSlot实现类
//然后按照@Spi注解的order属性进行排序并进行实例化
//最后将ProcessorSlot实例放到sortedSlotList中
List<ProcessorSlot> sortedSlotList = SpiLoader.of(ProcessorSlot.class).loadInstanceListSorted();
//遍历已排好序的ProcessorSlot列表
for (ProcessorSlot slot : sortedSlotList) {
//安全检查，防止业务系统也写了一个SPI文件，但没按规定继承AbstractLinkedProcessorSlot
if (!(slot instanceof AbstractLinkedProcessorSlot)) {
RecordLog.warn("The ProcessorSlot(" + slot.getClass().getCanonicalName() + ") is not an instance of AbstractLinkedProcessorSlot, can't be added into ProcessorSlotChain");
continue;
}
//调用DefaultProcessorSlotChain.addLast()方法构建单向链表
//将责任链的节点ProcessorSlot实例放入DefaultProcessorSlotChain中
chain.addLast((AbstractLinkedProcessorSlot<?>) slot);
}
//返回单向链表
return chain;
}
}
public class DefaultProcessorSlotChain extends ProcessorSlotChain {
AbstractLinkedProcessorSlot<?> first = new AbstractLinkedProcessorSlot<Object>() {
@Override
public void entry(Context context, ResourceWrapper resourceWrapper, Object t, int count, boolean prioritized, Object... args) throws Throwable {
super.fireEntry(context, resourceWrapper, t, count, prioritized, args);
}
@Override
public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {
super.fireExit(context, resourceWrapper, count, args);
}
};
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) {
end.setNext(protocolProcessor);
end = protocolProcessor;
}
@Override
public void setNext(AbstractLinkedProcessorSlot<?> next) {
addLast(next);
}
@Override
public AbstractLinkedProcessorSlot<?> getNext() {
return first.getNext();
}
@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);
}
@Override
public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {
first.exit(context, resourceWrapper, count, args);
}
}
public abstract class AbstractLinkedProcessorSlot<T> implements ProcessorSlot<T> {
private AbstractLinkedProcessorSlot<?> next = null;
@Override
public void fireEntry(Context context, ResourceWrapper resourceWrapper, Object obj, int count, boolean prioritized, Object... args) throws Throwable {
if (next != null) {
next.transformEntry(context, resourceWrapper, obj, count, prioritized, args);
}
}
@SuppressWarnings("unchecked")
void transformEntry(Context context, ResourceWrapper resourceWrapper, Object o, int count, boolean prioritized, Object... args) throws Throwable {
T t = (T)o;
entry(context, resourceWrapper, t, count, prioritized, args);
}
@Override
public void fireExit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {
if (next != null) {
next.exit(context, resourceWrapper, count, args);
}
}
public AbstractLinkedProcessorSlot<?> getNext() {
return next;
}
public void setNext(AbstractLinkedProcessorSlot<?> next) {
this.next = next;
}
}