sentinel流控效果是如何生效的

一、sentinel简介

Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件，主要以流量为切入点，从流量控制、流量路由、熔断降级、系统自适应保护等多个维度来帮助用户保障微服务的稳定性

随着微服务的流行，服务和服务之间的稳定性变得越来越重要。伴随着公司用户量和流量的日益增加，对于数据库的压力是越来越大，Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护

二、源码入口

使用sentinel有两种方式，一种方式是对需要限流和降级的接口资源方法上面加入@SentinelResource注解，还有一种就是通过拦截器的方式进行资源保护限流和降级，其实两种方法执行的关键方法都是同一段代码，今天我们暂时通过注解这种aop切面的形式，sentinel源码是如何实现限流和降级的呢

底层源码的工作还是基于SpringBoot的自动装配原理，在spring-cloud-starter-alibaba-sentinel.jar，下面的spring.fatories里面的SentinelAutoConfiguration类，我们来看看这个类的源码


在Spring容器启动的时候实例化了一个SentinelResourceAspect类，看这个类的命名就应该可以大概猜到这个类就是一个切面类，我们点击进入

@Aspect
public class SentinelResourceAspect extends AbstractSentinelAspectSupport {

    @Pointcut("@annotation(com.alibaba.csp.sentinel.annotation.SentinelResource)")
    public void sentinelResourceAnnotationPointcut() {
    }

    @Around("sentinelResourceAnnotationPointcut()")
    public Object invokeResourceWithSentinel(ProceedingJoinPoint pjp) throws Throwable {
        Method originMethod = resolveMethod(pjp);

        SentinelResource annotation = originMethod.getAnnotation(SentinelResource.class);
        if (annotation == null) {
            // Should not go through here.
            throw new IllegalStateException("Wrong state for SentinelResource annotation");
        }
        String resourceName = getResourceName(annotation.value(), originMethod);
        EntryType entryType = annotation.entryType();
        int resourceType = annotation.resourceType();
        Entry entry = null;
        try {
            entry = SphU.entry(resourceName, resourceType, entryType, pjp.getArgs());
            return pjp.proceed();
        } catch (BlockException ex) {
            return handleBlockException(pjp, annotation, ex);
        } catch (Throwable ex) {
            Class<? extends Throwable>[] exceptionsToIgnore = annotation.exceptionsToIgnore();
            // The ignore list will be checked first.
            if (exceptionsToIgnore.length > 0 && exceptionBelongsTo(ex, exceptionsToIgnore)) {
                throw ex;
            }
            if (exceptionBelongsTo(ex, annotation.exceptionsToTrace())) {
                traceException(ex);
                return handleFallback(pjp, annotation, ex);
            }

            // No fallback function can handle the exception, so throw it out.
            throw ex;
        } finally {
            if (entry != null) {
                entry.exit(1, pjp.getArgs());
            }
        }
    }
}

一看就知道这个切面类，是利用的aop的技术，切点就是我们上面说的@SentinelResource注解，所以当我们的接口方法上面加了@SentinelResource注解，执行这个接口里面的业务逻辑前会先进入这个切面类的invokeResourceWithSentinel方法，我们看看这个切面是如何执行的，我们重点看SphU.entry(resourceName, resourceType, entryType, pjp.getArgs())这个方法


public static Entry entry(String name, int resourceType, EntryType trafficType, Object[] args)
    throws BlockException {
    return Env.sph.entryWithType(name, resourceType, trafficType, 1, args);
}

在这个Env的类的实例化的时候会执行static代码块的逻辑

public class Env {

    public static final Sph sph = new CtSph();

    static {
        // If init fails, the process will exit.
        InitExecutor.doInit();
    }

}

我们继续看看这个InitExecutor.doInit()方法里面到底做了什么动作

public static void doInit() {
    if (!initialized.compareAndSet(false, true)) {
        return;
    }
    try {
        List initFuncs = SpiLoader.of(InitFunc.class).loadInstanceListSorted();
        List initList = new ArrayList();
        for (InitFunc initFunc : initFuncs) {
            RecordLog.info("[InitExecutor] Found init func: {}", initFunc.getClass().getCanonicalName());
            insertSorted(initList, initFunc);
        }
        for (OrderWrapper w : initList) {
            w.func.init();
            RecordLog.info("[InitExecutor] Executing {} with order {}",
                w.func.getClass().getCanonicalName(), w.order);
        }
    } catch (Exception ex) {
        RecordLog.warn("[InitExecutor] WARN: Initialization failed", ex);
        ex.printStackTrace();
    } catch (Error error) {
        RecordLog.warn("[InitExecutor] ERROR: Initialization failed with fatal error", error);
        error.printStackTrace();
    }
}

首先用cas做了并发安全处理，保证多线程情况下面只有一个线程执行成功，然后这里主要的逻辑是 SpiLoader.of(InitFunc.class).loadInstanceListSorted()，然后会调用到里面的load方法

/**
 * Load all Provider instances of the specified Service, sorted by order value in class's {@link Spi} annotation
 *
 * @return Sorted Provider instances list
 */
public List loadInstanceListSorted() {
    load();

    return createInstanceList(sortedClassList);
}

    /**
     * Load the Provider class from Provider configuration file
     */
    public void load() {
        if (!loaded.compareAndSet(false, true)) {
            return;
        }

        String fullFileName = SPI_FILE_PREFIX + service.getName();
        ClassLoader classLoader;
        if (SentinelConfig.shouldUseContextClassloader()) {
            classLoader = Thread.currentThread().getContextClassLoader();
        } else {
            classLoader = service.getClassLoader();
        }
        if (classLoader == null) {
            classLoader = ClassLoader.getSystemClassLoader();
        }
        Enumeration urls = null;
        try {
            urls = classLoader.getResources(fullFileName);
        } catch (IOException e) {
            fail("Error locating SPI configuration file, filename=" + fullFileName + ", classloader=" + classLoader, e);
        }

        if (urls == null || !urls.hasMoreElements()) {
            RecordLog.warn("No SPI configuration file, filename=" + fullFileName + ", classloader=" + classLoader);
            return;
        }

        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();

            InputStream in = null;
            BufferedReader br = null;
            try {
                in = url.openStream();
                br = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8));
                String line;
                while ((line = br.readLine()) != null) {
                    if (StringUtil.isBlank(line)) {
                        // Skip blank line
                        continue;
                    }

                    line = line.trim();
                    int commentIndex = line.indexOf("#");
                    if (commentIndex == 0) {
                        // Skip comment line
                        continue;
                    }

                    if (commentIndex > 0) {
                        line = line.substring(0, commentIndex);
                    }
                    line = line.trim();

                    Class clazz = null;
                    try {
                        clazz = (Class) Class.forName(line, false, classLoader);
                    } catch (ClassNotFoundException e) {
                        fail("class " + line + " not found", e);
                    }

                    if (!service.isAssignableFrom(clazz)) {
                        fail("class " + clazz.getName() + "is not subtype of " + service.getName() + ",SPI configuration file=" + fullFileName);
                    }

                    classList.add(clazz);
                    Spi spi = clazz.getAnnotation(Spi.class);
                    String aliasName = spi == null || "".equals(spi.value()) ? clazz.getName() : spi.value();
                    if (classMap.containsKey(aliasName)) {
                        Class<? extends S> existClass = classMap.get(aliasName);
                        fail("Found repeat alias name for " + clazz.getName() + " and "
                                + existClass.getName() + ",SPI configuration file=" + fullFileName);
                    }
                    classMap.put(aliasName, clazz);

                    if (spi != null && spi.isDefault()) {
                        if (defaultClass != null) {
                            fail("Found more than one default Provider, SPI configuration file=" + fullFileName);
                        }
                        defaultClass = clazz;
                    }

                    RecordLog.info("[SpiLoader] Found SPI implementation for SPI {}, provider={}, aliasName={}"
                            + ", isSingleton={}, isDefault={}, order={}",
                        service.getName(), line, aliasName
                            , spi == null ? true : spi.isSingleton()
                            , spi == null ? false : spi.isDefault()
                            , spi == null ? 0 : spi.order());
                }
            } catch (IOException e) {
                fail("error reading SPI configuration file", e);
            } finally {
                closeResources(in, br);
            }
        }

        sortedClassList.addAll(classList);
        Collections.sort(sortedClassList, new Comparator>() {
            @Override
            public int compare(Class<? extends S> o1, Class<? extends S> o2) {
                Spi spi1 = o1.getAnnotation(Spi.class);
                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);
            }
        });
    }

在这个load方法里面这里会加载到sentinel-core.jar下面META-INF目录下面的services里面的所有的实现类，通过反射实例化



这里我们先返回进入到这个entryWithType方法里面去

@Override
public Entry entryWithType(String name, int resourceType, EntryType entryType, int count, Object[] args)
    throws BlockException {
    return entryWithType(name, resourceType, entryType, count, false, args);
}

  @Override
    public Entry entryWithType(String name, int resourceType, EntryType entryType, int count, boolean prioritized,
                               Object[] args) throws BlockException {
        StringResourceWrapper resource = new StringResourceWrapper(name, entryType, resourceType);
        return entryWithPriority(resource, count, prioritized, args);
    }

  private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args)
        throws BlockException {
        Context context = ContextUtil.getContext();
        if (context instanceof NullContext) {
            // The {@link NullContext} indicates that the amount of context has exceeded the threshold,
            // so here init the entry only. No rule checking will be done.
            return new CtEntry(resourceWrapper, null, context);
        }

        if (context == null) {
            // Using default 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);
        }

        ProcessorSlot chain = lookProcessChain(resourceWrapper);

        /*
         * Means amount of resources (slot chain) exceeds {@link Constants.MAX_SLOT_CHAIN_SIZE},
         * so no rule checking will be done.
         */
        if (chain == null) {
            return new CtEntry(resourceWrapper, null, context);
        }

        Entry e = new CtEntry(resourceWrapper, chain, context);
        try {
            chain.entry(context, resourceWrapper, null, count, prioritized, args);
        } catch (BlockException e1) {
            e.exit(count, args);
            throw e1;
        } catch (Throwable e1) {
            // This should not happen, unless there are errors existing in Sentinel internal.
            RecordLog.info("Sentinel unexpected exception", e1);
        }
        return e;
    }

这里最后会调用到entryWithPriority这个方法里面，这里面用到了责任链的设计模式，首先会构造一个处理的链路，我们关注一下这个lookProcessChain(resourceWrapper)方法

ProcessorSlot 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 = SlotChainProvider.newSlotChain();
                Map newMap = new HashMap(
                    chainMap.size() + 1);
                newMap.putAll(chainMap);
                newMap.put(resourceWrapper, chain);
                chainMap = newMap;
            }
        }
    }
    return chain;
}
首先会从一个缓存map里面去取，如果为空的话， 调用SlotChainProvider.newSlotChain()构造一个链路，并且放到map里面缓存
public static ProcessorSlotChain newSlotChain() {
    if (slotChainBuilder != null) {
        return slotChainBuilder.build();
    }

    // Resolve the slot chain builder SPI.
    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();
}
这里也是用到jdk的spi机制，会加载sentinel-core.jar里面META-INF下面的services下面配置的ProcessSlot的实现类
# 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
最终通过DefaultSlotChainBuilder的build方法构造了一个处理器责任链，如下图

然后依次调用 chain.entry(context, resourceWrapper, null, count, prioritized, args)方法，依次调用图中的各个slot类，这里我们重点看看FlowSlot类和DegradeSlot这两个类的entry方法
@Override
public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                  boolean prioritized, Object... args) throws Throwable {
    checkFlow(resourceWrapper, context, node, count, prioritized);

    fireEntry(context, resourceWrapper, node, count, prioritized, args);
}
在这个FlowSlot的entry方法，首先会校验我们控制台配置的限流流控规则，最终会调用到checkFlow方法
void checkFlow(ResourceWrapper resource, Context context, DefaultNode node, int count, boolean prioritized)
    throws BlockException {
    checker.checkFlow(ruleProvider, resource, context, node, count, prioritized);
}

public void checkFlow(Function> ruleProvider, ResourceWrapper resource,
                          Context context, DefaultNode node, int count, boolean prioritized) throws BlockException {
        if (ruleProvider == null || resource == null) {
            return;
        }
        Collection rules = ruleProvider.apply(resource.getName());
        if (rules != null) {
            for (FlowRule rule : rules) {
                if (!canPassCheck(rule, context, node, count, prioritized)) {
                    throw new FlowException(rule.getLimitApp(), rule);
                }
            }
        }
    }
通过Collection rules = ruleProvider.apply(resource.getName())拿到我们在sentinel控制台配置的各种限流规则，然后遍历进行校验，不通过就抛出FlowException异常,这个时候整个这个责任链的执行流程就结束了，但是在之前执行的StatisticSlot的entry方法里面用try catch包裹住了，在这个SentinelResource Aspect里面会捕获BlocakExption异常,进行处理
@Around("sentinelResourceAnnotationPointcut()")
public Object invokeResourceWithSentinel(ProceedingJoinPoint pjp) throws Throwable {
    Method originMethod = resolveMethod(pjp);

    SentinelResource annotation = originMethod.getAnnotation(SentinelResource.class);
    if (annotation == null) {
        // Should not go through here.
        throw new IllegalStateException("Wrong state for SentinelResource annotation");
    }
    String resourceName = getResourceName(annotation.value(), originMethod);
    EntryType entryType = annotation.entryType();
    int resourceType = annotation.resourceType();
    Entry entry = null;
    try {
        entry = SphU.entry(resourceName, resourceType, entryType, pjp.getArgs());
        return pjp.proceed();
    } catch (BlockException ex) {
        return handleBlockException(pjp, annotation, ex);
    } catch (Throwable ex) {
        Class<? extends Throwable>[] exceptionsToIgnore = annotation.exceptionsToIgnore();
        // The ignore list will be checked first.
        if (exceptionsToIgnore.length > 0 && exceptionBelongsTo(ex, exceptionsToIgnore)) {
            throw ex;
        }
        if (exceptionBelongsTo(ex, annotation.exceptionsToTrace())) {
            traceException(ex);
            return handleFallback(pjp, annotation, ex);
        }

        // No fallback function can handle the exception, so throw it out.
        throw ex;
    } finally {
        if (entry != null) {
            entry.exit(1, pjp.getArgs());
        }
    }
}
protected Object handleBlockException(ProceedingJoinPoint pjp, SentinelResource annotation, BlockException ex)
    throws Throwable {

    // Execute block handler if configured.
    Method blockHandlerMethod = extractBlockHandlerMethod(pjp, annotation.blockHandler(),
        annotation.blockHandlerClass());
    if (blockHandlerMethod != null) {
        Object[] originArgs = pjp.getArgs();
        // Construct args.
        Object[] args = Arrays.copyOf(originArgs, originArgs.length + 1);
        args[args.length - 1] = ex;
        return invoke(pjp, blockHandlerMethod, args);
    }

    // If no block handler is present, then go to fallback.
    return handleFallback(pjp, annotation, ex);
}
最终会拿到这个SentinelResource注解里面配置的异常处理方法完成调用，至此整个sentinel流控保护流程就结束了，至于在这个责任链里面是如何统计各项指标，如何判断qps是否超过配置的最大值，以及sentinel里面的熔断，断路器何时进行打开，何时进行半开，何时关闭，里面的算法很复杂，以后专门写一篇文章来分析






展开阅读全文



页面更新：2024-03-07



标签：切面   切入点   注解   源码   实例   流量   逻辑   异常   效果   方法   责任





1
2
3
4
5







	

		

		
		

		

			

			
解读广汽埃安AION S：售13.98万，纯电续航460km，值不值得购买？

			

			

			其实在10-25万元的纯电动家轿的市场中，不乏聚集了众多的竞争对手，尤其是咱们的自主品牌最近几年新车更是如雨后春笋一般涌出。那么我们消费者面对众多纯电动轿车该如何选择呢？然而今天我们就为大家介绍一款在市场中关注
			

		

	

	

		

		
		

		

			

			
2023年换荣耀手机，这3款目前好评率最高，旗舰芯入手不亏

			

			

			#头条创作挑战赛#智能手机高速发展十年有余了，日益增强的性能，并不能和体验的提升同步起来，电池也也越来越不够用了，因此，在当下手机都越来越趋同的情况下，优化系统体验，建立高效的生态环境才是最重要的。在这方面，各家其实一
			

		

	

	

		

		
		

		

			

			
张勇为何“发飙”？

			

			

			文 | 杨万里大佬“发飙”是啥样？哪吒汽车联合创始人兼CEO张勇来了一场真人秀。4月8日，张勇在社交平台上情绪激动地发文称，“我们出了一台GT....各种冷言讽语，如果是外国品牌出的或者那几家出的就都是好的.....我就喜欢看
			

		

	

	

		

		
		

		

			

			
游戏领域AI开挂可期 属于开发者的创作新大陆浮现

			

			

			游戏从来不仅仅只是游戏，而是最具创造力、想象力、沉浸感的创作载体，因此，游戏业成为了众多新科技的试验场。这也不难理解，为何云技术的拓展和AI的爆发，都率先在游戏作品中找到了切实落地的应用场景。起家于游戏领域的实时
			

		

	

	

		

		
		

		

			

			
通信设施：数字中国关键底座，三大环节龙头梳理

			

			

			通信设施构筑数字中国的设施基础，包括光通信器件、光纤光缆以及交换机等。光通信器件：光电子器件及配套半导体集成电路光芯片是现在光通信器件的核心元件，按功能可以分为激光器芯片和探测器 芯片。C&C 初步调查显示全球
			

		

	

	

		

		
		

		

			

			
翻版“灵动岛”？realme Narzo N55发布，采用“mini 胶囊”

			

			

			近日，realme正式发布新机realmeNarzoN55，支持类似苹果灵动岛的“mini”胶囊功能。外观上看，realmeNarzoN55配备了居中打孔显示屏，采用类似于苹果灵动岛的“mini胶囊”功能，侧面指纹识别。采用蓝色和黑色两种配色，6.72英寸Fu
			

		

	

	

		

		
		

		

			

			
叫板AI！为站立的“裸女”补充完整，插画家先出手了

			

			

			从去年开始，与人工智能绘画的消息就层出不穷，一时间真的让人感觉，人工智能要取代艺术家了，冲在第一线的插画家也感到人人自危，其实完全不用这样紧张，现阶段的人工智能依旧比较初级，只能起到一个辅助作用，大多数人工智能绘制的
			

		

	

	

		

		
		

		

			

			
外星生物骨架？好奇号发现极其古怪的尖刺，专家震惊官方无解释

			

			

			是生物遗迹，还是自然现象？好奇号在第3786个火星日拍到的古怪尖刺。NASA / JPL-Caltech / MSSS好奇号在第3786个火星日拍到的古怪尖刺。可以看到附近其他岩石中也有类似的尖刺，只是稍不明显。NASA / JPL-Caltech / MSSS人
			

		

	

	

		

		
		

		

			

			
现在，小米系列比红米还便宜

			

			

			虽然小米 13 Ultra 的即将登场，没有让小米 12S Ultra、小米 13 以及小米 13 Pro 迎来降价。 但，小米 12S 和 12S Pro，还是有滴。 喏，机哥发现，目前在某东百亿补贴里边。 小米 12S 8+256GB 的价格，已经来到了 2979 元。  考
			

		

	

	

		

		
		

		

			

			
chatgpt5 最新发布时间确定？不要信，OpenAI官方没有任何消息

			

			

			近期，在各个网站都看到了GPT5的信息，我这边也很在意ChatGPT5何时发布，gpt4已经如此强悍，gpt5不敢想象。以下是百度的新闻信息我尝试寻找这些文章的来源，因为chatgpt的母公司openai是国外的嘛，他们说来源于openai的blog，但是
			

		

	

	

		

		
		

		

			

			
索尼也被指垄断市场：美议员要求其提供独家游戏协议

			

			

			受FTC新的游戏机市场定义和最近一次FTC听证会对微软指控的推动，北达科他州共和党参议员Kevin Cramer指责索尼的PlayStation部门存在反竞争行为，并要求该公司提供敏感的商业文件。“索尼的行为导致了更高的价格和更少的
			

		

	

	

		

		
		

		

			

			
将数据主权归还给用户的加密社交软件：GetChat

			

			

			2021年1 月 6 日，美国国会发生暴乱，Twitter、Facebook 和 YouTube 等 13 家社交平台均采取行动，封禁或限制特朗普账户和与其相关的内容。此等现象表明，中心化社交平台具有严格的内容审查性及垄断性，用户对于自己的账户和信
			

		

	

	

		

		
		

		

			

			
耳目一新！这场智慧盛宴，解锁了5G智慧电台新“神器”

			

			

			来源：【红网-时刻新闻】红网时刻新闻4月15日讯（记者 胡弋）4月12日—4月14日，第十期马栏山智慧融媒创造营在长沙举办，本期活动以“科文融合 智创新声”为主题，各路嘉宾齐聚，共探媒体融合高质量发展。活动现场，5G智慧电台全新产
			

		

	

	

		

		
		

		

			

			
阿里+百度 VS GPT，能打平手吗？

			

			

			帮大家测试一下通义千问和同行相比的智能程度、实用性能。全文共 3368 字，阅读大约需要 8 分钟作者 | 罗立璇 贾阳编辑 | 王晓玲 最近一周，中国大厂们的ChatGPT对标产品真是应接不暇，纷纷上桌。阿里的大模型“通义千问”
			

		

	

	

		

		
		

		

			

			
什么是区块链？

			

			

			前言区块链是近年来非常火热的一个话题，它是一种去中心化的、基于密码学的、具有不可篡改性和可追溯性的分布式账本技术。它的出现引起了人们的广泛关注和研究，被认为是第四次工业革命的重要驱动力。本文将从区块链的定
			

		

	


上滑加载更多 ↓






	

	
推荐阅读：


	

		

			

			
英伟达RTX 4070最新测评来了！光追效果更棒，但仅限于2k游

			

		

	


	

		

			

			
龙胆泻肝丸巧搭配，效果翻倍，失眠，痰多，湿热 气虚都可用

			

		

	


	

		

			

			
dark and darker 汉化方法 一招教你实现dark and dark

			

		

	


	

		

			

			
黑色丝袜搭配细跟长靴，不到10厘米的高度，衬托身材效果确

			

		

	


	

		

			

			
别被带节奏！汪峰洛阳演唱会被嘲效果太差？听听在现场的人

			

		

	


	

		

			

			
一杯竹筒奶茶的流量账本

			

		

	


	

		

			

			
上班族该如何养胃？ 日常养胃方法送给你

			

		

	


	

		

			

			
dark and darker怎么参与测试/抢先体验 参加越来越黑

			

		

	


	

		

			

			
Python求绝对值的五种方法，你掌握了吗？

			

		

	


	

		

			

			
基于Dubbo3.1.8分析Dubbo3源码

			

		

	


	

	
	

	
友情链接：

	

		
	

	


	

	
更多：

	

		
本站资料均由网友自行发布提供，仅用于学习交流。如有版权问题，请与我联系，QQ：4156828  

		
© CopyRight 2008-2024 All Rights Reserved. Powered By bs178.com  闽ICP备11008920号-3
闽公网安备35020302034844号

	

	

	




Top