Talk about sentinel WebAutoConfiguration of Sentinel



This article mainly studies sentinel’s SentinelWebAutoConfiguration


spring-cloud-alibaba-sentinel-autoconfigure-0.2.0.BUILD-SNAPSHOT-sources.jar! /org/springframework/cloud/alibaba/sentinel/

@ConditionalOnProperty(name = "", matchIfMissing = true)
public class SentinelWebAutoConfiguration {
    private static final Logger logger = LoggerFactory

    private String projectName;

    private SentinelProperties properties;

    public static final String APP_NAME = "";

    private void init() {
        if (StringUtils.isEmpty(System.getProperty(APP_NAME))) {
            System.setProperty(APP_NAME, projectName);
        if (StringUtils.isEmpty(System.getProperty(TransportConfig.SERVER_PORT))) {
            System.setProperty(TransportConfig.SERVER_PORT, properties.getPort());
        if (StringUtils.isEmpty(System.getProperty(TransportConfig.CONSOLE_SERVER))) {
            System.setProperty(TransportConfig.CONSOLE_SERVER, properties.getDashboard());


    public FilterRegistrationBean<Filter> servletRequestListener() {
        FilterRegistrationBean<Filter> registration = new FilterRegistrationBean<>();

        SentinelProperties.Filter filterConfig = properties.getFilter();

        if (null == filterConfig) {
            filterConfig = new SentinelProperties.Filter();

        if (filterConfig.getUrlPatterns() == null
                || filterConfig.getUrlPatterns().isEmpty()) {
            List<String> defaultPatterns = new ArrayList<>();

        registration.addUrlPatterns(filterConfig.getUrlPatterns().toArray(new String[0]));
        Filter filter = new CommonFilter();
        registration.setOrder(filterConfig.getOrder());"[Sentinel Starter] register Sentinel with urlPatterns: {}.",
        return registration;

  • During initialization, set the project name. if is not specified, use to specify it.
  • If csp.sentinel.dashboard.server and csp.sentinel.api.port are not specified, and are used to specify
  • CommonFilter is registered in FilterRegistrationBean.


sentinel-web-servlet-0.1.1-sources.jar! /com/alibaba/csp/sentinel/adapter/servlet/

public class CommonFilter implements Filter {

    public void init(FilterConfig filterConfig) {


    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {
        HttpServletRequest sRequest = (HttpServletRequest)request;
        Entry entry = null;

        try {
            String target = FilterUtil.filterTarget(sRequest);
            target = WebCallbackManager.getUrlCleaner().clean(target);

            entry = SphU.entry(target, EntryType.IN);

            chain.doFilter(request, response);
        } catch (BlockException e) {
            HttpServletResponse sResponse = (HttpServletResponse)response;
            WebCallbackManager.getUrlBlockHandler().blocked(sRequest, sResponse);
        } catch (IOException e2) {
            throw e2;
        } catch (ServletException e3) {
            throw e3;
        } catch (RuntimeException e4) {
            throw e4;
        } finally {
            if (entry != null) {

    public void destroy() {

  • This filter formats the url first, then calls ContextUtil.enter(target) to initialize the context, and finally calls SphU.entry(target, EntryType.IN) to judge the current limit.
  • Throwing BlockException returns the current-limiting page, other exceptions trace, and finally exit the entry


sentinel-core-0.1.1-sources.jar! /com/alibaba/csp/sentinel/

     * Checking all {@link Rule}s about the resource.
     * @param name the unique name for the protected resource
     * @param type the resource is an inbound or an outbound method. This is used
     *             to mark whether it can be blocked when the system is unstable,
     *             only inbound traffic could be blocked by {@link SystemRule}
     * @throws BlockException if the block criteria is met, eg. when any rule's threshold is exceeded.
    public static Entry entry(String name, EntryType type) throws BlockException {
        return Env.sph.entry(name, type, 1, OBJECTS0);
  • Env.sph is used here.


sentinel-core-0.1.1-sources.jar! /com/alibaba/csp/sentinel/

public class Env {

    public static final SlotsChainBuilder slotsChainbuilder = new DefaultSlotsChainBuilder();
    public static final NodeBuilder nodeBuilder = new DefaultNodeBuilder();
    public static final Sph sph = new CtSph();

    static {
        // If init fails, the process will exit.

  • CtSph is created here, and then the static method initializes InitExecutor.


sentinel-core-0.1.1-sources.jar! /com/alibaba/csp/sentinel/init/

 * Load registered init functions and execute in order.
 * @author Eric Zhao
public final class InitExecutor {

    private static AtomicBoolean initialized = new AtomicBoolean(false);

     * If one {@link InitFunc} throws an exception, the init process
     * will immediately be interrupted and the application will exit.
     * The initialization will be executed only once.
    public static void doInit() {
        if (!initialized.compareAndSet(false, true)) {
        try {
            ServiceLoader<InitFunc> loader = ServiceLoader.load(InitFunc.class);
            List<OrderWrapper> initList = new ArrayList<OrderWrapper>();
            for (InitFunc initFunc : loader) {
      "[Sentinel InitExecutor] Found init func: " + initFunc.getClass().getCanonicalName());
                insertSorted(initList, initFunc);
            for (OrderWrapper w : initList) {
      "[Sentinel InitExecutor] Initialized: %s with order %d",
                    w.func.getClass().getCanonicalName(), w.order));
        } catch (Exception ex) {
  "[Sentinel InitExecutor] Init failed", ex);

    private static void insertSorted(List<OrderWrapper> list, InitFunc func) {
        int order = resolveOrder(func);
        int idx = 0;
        for (; idx < list.size(); idx++) {
            if (list.get(idx).getOrder() > order) {
        list.add(idx, new OrderWrapper(order, func));

    private static int resolveOrder(InitFunc func) {
        if (!func.getClass().isAnnotationPresent(InitOrder.class)) {
            return InitOrder.LOWEST_PRECEDENCE;
        } else {
            return func.getClass().getAnnotation(InitOrder.class).value();

    private InitExecutor() {}

    private static class OrderWrapper {
        private final int order;
        private final InitFunc func;

        OrderWrapper(int order, InitFunc func) {
            this.order = order;
            this.func = func;

        int getOrder() {
            return order;

        InitFunc getFunc() {
            return func;
  • SPI is used here to load InitFunc, which mainly has two implementation classes, one is CommandCenterInitFunc, and the other is HeartbeatSenderInitFunc


sentinel-core-0.1.1-sources.jar! /com/alibaba/csp/sentinel/

     * Do all {@link Rule}s checking about the resource.
     * <p>Each distinct resource will use a {@link ProcessorSlot} to do rules checking. Same resource will use
     * same {@link ProcessorSlot} globally. </p>
     * <p>Note that total {@link ProcessorSlot} count must not exceed {@link Constants#MAX_SLOT_CHAIN_SIZE},
     * otherwise no rules checking will do. In this condition, all requests will pass directly, with no checking
     * or exception.</p>
     * @param resourceWrapper resource name
     * @param count           tokens needed
     * @param args            arguments of user method call
     * @return {@link Entry} represents this call
     * @throws BlockException if any rule's threshold is exceeded
    public Entry entry(ResourceWrapper resourceWrapper, int count, Object... args) throws BlockException {
        Context context = ContextUtil.getContext();
        if (context instanceof NullContext) {
            // Init the entry only. No rule checking will occur.
            return new CtEntry(resourceWrapper, null, context);

        if (context == null) {
            context = MyContextUtil.myEnter(Constants.CONTEXT_DEFAULT_NAME, "", resourceWrapper.getType());

        // Global switch is close, no rule checking will do.
        if (!Constants.ON) {
            return new CtEntry(resourceWrapper, null, context);

        ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);

         * Means processor size exceeds {@link Constants.MAX_ENTRY_SIZE}, no
         * rule checking will do.
        if (chain == null) {
            return new CtEntry(resourceWrapper, null, context);

        Entry e = new CtEntry(resourceWrapper, chain, context);
        try {
            chain.entry(context, resourceWrapper, null, count, args);
        } catch (BlockException e1) {
            e.exit(count, args);
            throw e1;
        } catch (Throwable e1) {
  "sentinel unexpected exception", e1);
        return e;

     * Get {@link ProcessorSlotChain} of the resource. new {@link ProcessorSlotChain} will
     * be created if the resource doesn't relate one.
     * <p>Same resource({@link ResourceWrapper#equals(Object)}) will share the same
     * {@link ProcessorSlotChain} globally, no matter in witch {@link Context}.<p/>
     * <p>
     * Note that total {@link ProcessorSlot} count must not exceed {@link Constants#MAX_SLOT_CHAIN_SIZE},
     * otherwise null will return.
     * </p>
     * @param resourceWrapper target resource
     * @return {@link ProcessorSlotChain} of the resource
    private ProcessorSlot<Object> lookProcessChain(ResourceWrapper resourceWrapper) {
        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;

                    chain =;
                    HashMap<ResourceWrapper, ProcessorSlotChain> newMap
                        = new HashMap<ResourceWrapper, ProcessorSlotChain>(
                        chainMap.size() + 1);
                    newMap.put(resourceWrapper, chain);
                    chainMap = newMap;
        return chain;
  • This is mainly verified by ProcessorSlot, the chain. if the chain is null, it is created by ()


sentinel-core-0.1.1-sources.jar! /com/alibaba/csp/sentinel/slots/

 * Helper class to create {@link ProcessorSlotChain}.
 * @author qinan.qn
 * @author leyou
public class DefaultSlotsChainBuilder implements SlotsChainBuilder {

    public ProcessorSlotChain build() {
        ProcessorSlotChain chain = new DefaultProcessorSlotChain();
        chain.addLast(new NodeSelectorSlot());
        chain.addLast(new ClusterBuilderSlot());
        chain.addLast(new LogSlot());
        chain.addLast(new StatisticSlot());
        chain.addLast(new SystemSlot());
        chain.addLast(new AuthoritySlot());
        chain.addLast(new FlowSlot());
        chain.addLast(new DegradeSlot());

        return chain;

  • By default, eight slot are created here, followed by NodeSelectorSlot, ClusterBuilderSlot, LogSlot, StatisticSlot, SystemSlot, AuthoritySlot, FlowSlot, DegradeSlot.

The overall structure of slot here is as follows:

  • NodeSelectorSlot is mainly used for tree call path current limit degradation.
  • ClusterBuilderSlot Statistics Resource Response Time, qps, etc
  • LogSlot is used to record block exceptions.
  • StatisticSlot from clusterNode and defaultNode
  • SystemSlot performs current limiting control through the load of the system.
  • AuthoritySlot controls current limit according to black and white list.
  • FlowSlot is controlled by a specified current limit rule.
  • DegradeSlot performs fusing degradation according to the degradation rule


  • Sentinel’s SentinelWebAutoConfiguration adapts the configuration of springboot and springcloud, and then injects CommonFilter
  • The CommonFilter intercepts the method, performs entry before execution to determine whether the current is limited, throws a BlockException if the current is limited, performs return results if not, and finally exit the entry of the current limit
  • The whole current-limiting logic adopts the mode of responsibility chain, and sets current-limiting in different dimensions through ProcessorSlotChain to judge current-limiting in turn