hcq0514
hcq0514

Sentinel流程源码

主要流程

  • springboot集成包
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-sentinel
            2.2.3.RELEASE
        

该包的spring.factories里导入了这些组件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.alibaba.cloud.sentinel.SentinelWebAutoConfiguration,\
com.alibaba.cloud.sentinel.SentinelWebFluxAutoConfiguration,\
com.alibaba.cloud.sentinel.endpoint.SentinelEndpointAutoConfiguration,\
com.alibaba.cloud.sentinel.custom.SentinelAutoConfiguration,\
com.alibaba.cloud.sentinel.feign.SentinelFeignAutoConfiguration

org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker=\
com.alibaba.cloud.sentinel.custom.SentinelCircuitBreakerConfiguration

主要是通过SentinelWebAutoConfiguration这个类添加一个MVC拦截器

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        if (!sentinelWebInterceptorOptional.isPresent()) {
            return;
        }
        SentinelProperties.Filter filterConfig = properties.getFilter();
        registry.addInterceptor(sentinelWebInterceptorOptional.get())
                .order(filterConfig.getOrder())
//拦截全路径/*
                .addPathPatterns(filterConfig.getUrlPatterns());
    }
  • 入口：在web请求过来的时候拦截，调用AbstractSentinelInterceptor接口
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {
        try {
//获取请求的路径 比如访问的说localhost:8085/area/list，resourceName 为 area/list
            String resourceName = getResourceName(request);

            if (StringUtil.isEmpty(resourceName)) {
                return true;
            }
            
            if (increaseReferece(request, this.baseWebMvcConfig.getRequestRefName(), 1) != 1) {
                return true;
            }
            
            String origin = parseOrigin(request);
            String contextName = getContextName(request);
            ContextUtil.enter(contextName, origin);
//主要是进入到这个方法
            Entry entry = SphU.entry(resourceName, ResourceTypeConstants.COMMON_WEB, EntryType.IN);
            request.setAttribute(baseWebMvcConfig.getRequestAttributeName(), entry);
            return true;
        } catch (BlockException e) {
            try {
//处理流控的exception返回给前端，可以自己定制返回内容
                handleBlockException(request, response, e);
            } finally {
                ContextUtil.exit();
            }
            return false;
        }
    }
  • 主要拦截方法：entry方法一直点进来会进到com.alibaba.csp.sentinel.CtSph#entryWithPriority
    private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args)
        throws BlockException {
        Context context = ContextUtil.getContext();
...省略一堆校验
//获取该资源的拦截链
        ProcessorSlot chain = lookProcessChain(resourceWrapper);
        if (chain == null) {
            return new CtEntry(resourceWrapper, null, context);
        }
//将资源，拦截链环境包装为一个entry
        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;
    }

    ProcessorSlot lookProcessChain(ResourceWrapper resourceWrapper) {
//获取该资源上的拦截链
        ProcessorSlotChain chain = chainMap.get(resourceWrapper);
//当第一次进来的时候回拦截链chain为空
        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;
    }
 
 
     
  
  • chain = SlotChainProvider.newSlotChain();创建拦截链
     这边主要是创建了8个拦截链，分别对应我们sentinel控制台配的8个,主要我们常用的说流控规则跟降级规则
    •  
 
 
 
 
   
   
 
    表头 
    表头 
   
 
   
   
   
 
    链路节点生成 
    NodeSelectorSlot 
   
 
   
 
    集群流控 
    ClusterBuilderSlot 
   
 
   
 
    规则限制日志相关 
    LogSlot 
   
 
   
 
    统计相关(重要) 
    StatisticSlot 
   
 
   
 
    热点规则 
    ParamFlowSlot 
   
 
   
 
    授权规则 
    AuthoritySlot 
   
 
   
 
    系统规则 
    SystemSlot 
   
 
   
 
    流控规则(重要) 
    FlowSlot 
   
 
   
 
    降级规则(重要) 
    DegradeSlot 
   
 
   
 
 
 
    public static ProcessorSlotChain newSlotChain() {
        if (slotChainBuilder != null) {
            return slotChainBuilder.build();
        }
...省略spi等代码
    }

public class HotParamSlotChainBuilder implements SlotChainBuilder {
    @Override
    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 ParamFlowSlot());
        chain.addLast(new SystemSlot());
        chain.addLast(new AuthoritySlot());
        chain.addLast(new FlowSlot());
        chain.addLast(new DegradeSlot());
        return chain;
    }
}

 
 
构建后形成这个链表
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
     
  
  • 真正执行拦截链的方法 chain.entry(...);
     调用chain里面的first.transformEntry方法，也就是他的处理方法，因为第一个是默认的DefaultProcessorSlotChain，他没有做任何处理，直接调用 next.transformEntry给下面的责任链处理
    •  
 
 
 
    @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 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);
        }
    }

 
 
几个责任链的主要代码
 
 
     
  
  • NodeSelectorSlot(负责请求链路资源的归纳)
     负责收集资源的路径，并将这些资源的调用路径，以树状结构存储起来，用于根据凋用路径来限流降级
    •  
 
 
 
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, Object obj, int count, boolean prioritized, Object... args)
        throws Throwable {
//context.getName()的结果是sentinel_spring_web_context形成下面那个节点
        DefaultNode node = map.get(context.getName());
        if (node == null) {
            synchronized (this) {
                node = map.get(context.getName());
                if (node == null) {
                    node = new DefaultNode(resourceWrapper, null);
                    HashMap cacheMap = new HashMap(map.size());
                    cacheMap.putAll(map);
                    cacheMap.put(context.getName(), node);
                    map = cacheMap;
                    // Build invocation tree
                    ((DefaultNode) context.getLastNode()).addChild(node);
                }
            }
        }
        context.setCurNode(node);
//调用下个Slot处理
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }

 
 
 
  
 
   
  
   
 
  
 
  
 
 
 
 
     
  
  • ClusterBuilderSlot(集群相关)
    •  
 
 
 
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args)
        throws Throwable {
        if (clusterNode == null) {
            synchronized (lock) {
                if (clusterNode == null) {
                    // Create the cluster node.
                    clusterNode = new ClusterNode(resourceWrapper.getName(), resourceWrapper.getResourceType());
                    HashMap newMap = new HashMap<>(Math.max(clusterNodeMap.size(), 16));
                    newMap.putAll(clusterNodeMap);
                    newMap.put(node.getId(), clusterNode);

                    clusterNodeMap = newMap;
                }
            }
        }
        node.setClusterNode(clusterNode);
        if (!"".equals(context.getOrigin())) {
            Node originNode = node.getClusterNode().getOrCreateOriginNode(context.getOrigin());
            context.getCurEntry().setOriginNode(originNode);
        }
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }

 
 
     
  
  • LogSlot(日志相关)
    •  
 
 
 
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode obj, int count, boolean prioritized, Object... args)
        throws Throwable {
        try {
            fireEntry(context, resourceWrapper, obj, count, prioritized, args);
        } catch (BlockException e) {
//当发生限制时记录信息。
            EagleEyeLogUtil.log(resourceWrapper.getName(), e.getClass().getSimpleName(), e.getRuleLimitApp(),
                context.getOrigin(), count);
            throw e;
        } catch (Throwable e) {
            RecordLog.warn("Unexpected entry exception", e);
        }
    }

 
 
     
  
  •  
    StatisticSlot(重要，统计类)
     
    •  
 
 
 
用于存储资源的统计信息以及调用者信息，例如该资源的 RT QPS, thread count等等这些信息将用作为多维度限流，降级的依据
 统计用的是滑动时间算法，篇幅有点长，放到滑动时间算法与sentinel实践
 
 
 
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable {
        try {
            //执行后面的检查
            fireEntry(context, resourceWrapper, node, count, prioritized, args);
            // 如果其他的校验都成功没有问题
            //增加单位时间成功线程数量
            node.increaseThreadNum();
            //增加单位时间成功请求,(滑动时间窗口计数实现)
            node.addPassRequest(count);

            if (context.getCurEntry().getOriginNode() != null) {
                // Add count for origin node.
                context.getCurEntry().getOriginNode().increaseThreadNum();
                context.getCurEntry().getOriginNode().addPassRequest(count);
            }

            if (resourceWrapper.getEntryType() == EntryType.IN) {
                // Add count for global inbound entry node for global statistics.
                Constants.ENTRY_NODE.increaseThreadNum();
                Constants.ENTRY_NODE.addPassRequest(count);
            }

            // Handle pass event with registered entry callback handlers.
            for (ProcessorSlotEntryCallback handler : StatisticSlotCallbackRegistry.getEntryCallbacks()) {
                handler.onPass(context, resourceWrapper, node, count, args);
            }
        } catch (PriorityWaitException ex) {
            node.increaseThreadNum();
            if (context.getCurEntry().getOriginNode() != null) {
                // Add count for origin node.
                context.getCurEntry().getOriginNode().increaseThreadNum();
            }

            if (resourceWrapper.getEntryType() == EntryType.IN) {
                // Add count for global inbound entry node for global statistics.
                Constants.ENTRY_NODE.increaseThreadNum();
            }
            // Handle pass event with registered entry callback handlers.
            for (ProcessorSlotEntryCallback handler : StatisticSlotCallbackRegistry.getEntryCallbacks()) {
                handler.onPass(context, resourceWrapper, node, count, args);
            }
        } catch (BlockException e) {
            // Blocked, set block exception to current entry.
            context.getCurEntry().setError(e);

            // Add block count.
            node.increaseBlockQps(count);
            if (context.getCurEntry().getOriginNode() != null) {
                context.getCurEntry().getOriginNode().increaseBlockQps(count);
            }

            if (resourceWrapper.getEntryType() == EntryType.IN) {
                // Add count for global inbound entry node for global statistics.
                Constants.ENTRY_NODE.increaseBlockQps(count);
            }

            // Handle block event with registered entry callback handlers.
            for (ProcessorSlotEntryCallback handler : StatisticSlotCallbackRegistry.getEntryCallbacks()) {
                handler.onBlocked(e, context, resourceWrapper, node, count, args);
            }

            throw e;
        } catch (Throwable e) {
            // Unexpected error, set error to current entry.
            context.getCurEntry().setError(e);

            // This should not happen.
            node.increaseExceptionQps(count);
            if (context.getCurEntry().getOriginNode() != null) {
                context.getCurEntry().getOriginNode().increaseExceptionQps(count);
            }

            if (resourceWrapper.getEntryType() == EntryType.IN) {
                Constants.ENTRY_NODE.increaseExceptionQps(count);
            }
            throw e;
        }
    }

 
 
     
  
  • ParamFlowSlot(热点流控)
    •  
 
 
 
//对有添加热点流控规则的资源进行限制
    void checkFlow(ResourceWrapper resourceWrapper, int count, Object... args) throws BlockException {
        if (args == null) {
            return;
        }
        if (!ParamFlowRuleManager.hasRules(resourceWrapper.getName())) {
            return;
        }
        List rules = ParamFlowRuleManager.getRulesOfResource(resourceWrapper.getName());

        for (ParamFlowRule rule : rules) {
            applyRealParamIdx(rule, args.length);

            // Initialize the parameter metrics.
            ParameterMetricStorage.initParamMetricsFor(resourceWrapper, rule);

            if (!ParamFlowChecker.passCheck(resourceWrapper, rule, count, args)) {
                String triggeredParam = "";
                if (args.length > rule.getParamIdx()) {
                    Object value = args[rule.getParamIdx()];
                    triggeredParam = String.valueOf(value);
                }
                throw new ParamFlowException(resourceWrapper.getName(), triggeredParam, rule);
            }
        }
    }

 
 
     
  
  • SystemSlot
     当配置了系统规则后，会根据配置的系统规则进行校验
    •  
 
 
 
    public static void checkSystem(ResourceWrapper resourceWrapper) throws BlockException {
 ...
        // qps限制数
        double currentQps = Constants.ENTRY_NODE == null ? 0.0 : Constants.ENTRY_NODE.successQps();
        if (currentQps > qps) {
            throw new SystemBlockException(resourceWrapper.getName(), "qps");
        }
        // thread限制
        int currentThread = Constants.ENTRY_NODE == null ? 0 : Constants.ENTRY_NODE.curThreadNum();
        if (currentThread > maxThread) {
            throw new SystemBlockException(resourceWrapper.getName(), "thread");
        }
        //rt限制
        double rt = Constants.ENTRY_NODE == null ? 0 : Constants.ENTRY_NODE.avgRt();
        if (rt > maxRt) {
            throw new SystemBlockException(resourceWrapper.getName(), "rt");
        }
        if (highestSystemLoadIsSet && getCurrentSystemAvgLoad() > highestSystemLoad) {
            if (!checkBbr(currentThread)) {
                throw new SystemBlockException(resourceWrapper.getName(), "load");
            }
        }
        // CPU使用率
        if (highestCpuUsageIsSet && getCurrentCpuUsage() > highestCpuUsage) {
            throw new SystemBlockException(resourceWrapper.getName(), "cpu");
        }
    }

 
 
     
  
  • AuthoritySlot(根据配置的授权规则来限制)
    •  
 
 
 
    void checkBlackWhiteAuthority(ResourceWrapper resource, Context context) throws AuthorityException {
        Map> authorityRules = AuthorityRuleManager.getAuthorityRules();

        if (authorityRules == null) {
            return;
        }

        Set rules = authorityRules.get(resource.getName());
        if (rules == null) {
            return;
        }

        for (AuthorityRule rule : rules) {
            if (!AuthorityRuleChecker.passCheck(rule, context)) {
                throw new AuthorityException(context.getOrigin(), rule);
            }
        }
    }

 
 
     
  
  •  
    FlowSlot(重要，限流相关,sentinel拉取配置应用nacos的动态加载配置com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager.FlowPropertyListener主要调用该方法)
     
    •  
 
 
 
    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);
                }
            }
        }
    }
  //----------------------------------✂------------------------------------------
获取flowRules流控规则,规则naco
        public Collection apply(String resource) {
            //getFlowRuleMap里面代码是 return flowRules; 返回本地的规则map文件
            Map> flowRules = FlowRuleManager.getFlowRuleMap();
            return flowRules.get(resource);
        }

//----------------------------------✂------------------------------------------
判断是否能通过该规则
    private static boolean passLocalCheck(FlowRule rule, Context context, DefaultNode node, int acquireCount,
                                          boolean prioritized) {
        Node selectedNode = selectNodeByRequesterAndStrategy(rule, context, node);
        if (selectedNode == null) {
            return true;
        }
//这边的getRater()方法会根据你配置时的 1、快速失败  2、Warm Up 3、 排队等待 三个类型分别调用不同的方法
        return rule.getRater().canPass(selectedNode, acquireCount, prioritized);
    }

 
 
     
  
  1. 快速失败
     主要是调用com.alibaba.csp.sentinel.slots.block.flow.controller.DefaultController#canPass()
    2.  
 
 
 
    @Override
    public boolean canPass(Node node, int acquireCount, boolean prioritized) {
        //获取当前平均访问次数,avgUsedTokens是获取node.passQps()，调用StatisticNode#passQps
        int curCount = avgUsedTokens(node);
        //如果超过限制则直接返回false
        if (curCount + acquireCount > count) {
        //DefaultController这边的 prioritized 为false里面的方法不提示
            if (prioritized && grade == RuleConstant.FLOW_GRADE_QPS) {
      ...
                }
            }
            return false;
        }
        return true;
    }

 
 
     
  
  1. Warm Up 调用了WarmUpController#canPass(...) 这边主要使用的是令牌桶算法
    2.  
 
 
 
    //构建函数
    private void construct(double count, int warmUpPeriodInSec, int coldFactor) {
        //冷因子不能小于1,默认为3
        if (coldFactor <= 1) {
            throw new IllegalArgumentException("Cold factor should be larger than 1");
        }
        //设置阈值
        this.count = count;
        //设置冷因子
        this.coldFactor = coldFactor;
        // thresholdPermits = 0.5 * warmupPeriod / stableInterval.
        // warningToken = 100;
        //预警token=(预热时长*阈值)/(冷因子-1)
        warningToken = (int)(warmUpPeriodInSec * count) / (coldFactor - 1);
        // / maxPermits = thresholdPermits + 2 * warmupPeriod /
        // (stableInterval + coldInterval)
        // maxToken = 200
        //最大token=(预热预警token*阈值)/(冷因子-1)
        maxToken = warningToken + (int)(2 * warmUpPeriodInSec * count / (1.0 + coldFactor));
        // slope
        // slope = (coldIntervalMicros - stableIntervalMicros) / (maxPermits
        // - thresholdPermits);
        slope = (coldFactor - 1.0) / count / (maxToken - warningToken);
    }

    @Override
    public boolean canPass(Node node, int acquireCount, boolean prioritized) {
        long passQps = (long) node.passQps();

        long previousQps = (long) node.previousPassQps();
        syncToken(previousQps);

        // 开始计算它的斜率
        // 如果进入了警戒线，开始调整他的qps
        long restToken = storedTokens.get();
        if (restToken >= warningToken) {
            long aboveToken = restToken - warningToken;
            // 消耗的速度要比warning快，但是要比慢
            // current interval = restToken*slope+1/count
            double warningQps = Math.nextUp(1.0 / (aboveToken * slope + 1.0 / count));
            if (passQps + acquireCount <= warningQps) {
                return true;
            }
        } else {
            if (passQps + acquireCount <= count) {
                return true;
            }
        }

        return false;
    }

 
 
     
  
  1. 排队等待
     主要是用到RateLimiterController#canPass(com.alibaba.csp.sentinel.node.Node, int, boolean)
    2.  
 
 
 
   @Override
    public boolean canPass(Node node, int acquireCount, boolean prioritized) {
        //当请求通过量小于等于0时，直接返回通过
        if (acquireCount <= 0) {
            return true;
        }
        // Reject when count is less or equal than 0.
        // Otherwise,the costTime will be max of long and waitTime will overflow in some cases.
        // 这个count是你控制台设置的阈值
        if (count <= 0) {
            return false;
        }
        //获取当前时间
        long currentTime = TimeUtil.currentTimeMillis();
        // Calculate the interval between every two requests.
        // 计算两个请求之间需要花费的时间
        // 假设acquireCount=1,count =10, 则((1*1)/10*1000)取整=1000
        long costTime = Math.round(1.0 * (acquireCount) / count * 1000);

        // Expected pass time of this request.
        // 预期通过这个请求的时间
        long expectedTime = costTime + latestPassedTime.get();
        // 判断预期通过时间是否小于当前时间
        if (expectedTime <= currentTime) {
            // Contention may exist here, but it's okay.
            latestPassedTime.set(currentTime);
            return true;
        } else {
            // Calculate the time to wait.
            // 计算预计需要等待的时间(当前预期需要花费的时间+最后一次成功的时间-当前时间)
            long waitTime = costTime + latestPassedTime.get() - TimeUtil.currentTimeMillis();
            // 如果预计需要等待的时间大于后台配置的等待时间，则直接拒绝
            if (waitTime > maxQueueingTimeMs(后台配置为毫秒)) {
                return false;
            } else {
            // 设置latestPassedTime,用atomic变量防止并发
                long oldTime = latestPassedTime.addAndGet(costTime);
                try {
            // 再做一次超时判断
                    waitTime = oldTime - TimeUtil.currentTimeMillis();
                    if (waitTime > maxQueueingTimeMs) {
                        latestPassedTime.addAndGet(-costTime);
                        return false;
                    }
                    // in race condition waitTime may <= 0
            // 休眠等待时间
                    if (waitTime > 0) {
                        Thread.sleep(waitTime);
                    }
                    return true;
                } catch (InterruptedException e) {
                }
            }
        }
        return false;
    }

 
 
     
  
  •  
    DegradeSlot(重要，降级相关)
     
    •  
 
 
 
    @Override
    public boolean passCheck(Context context, DefaultNode node, int acquireCount, Object... args) {
        if (cut.get()) {
            return false;
        }

        ClusterNode clusterNode = ClusterBuilderSlot.getClusterNode(this.getResource());
        if (clusterNode == null) {
            return true;
        }
        //熔断策略为RT（响应时间）慢调用比例 这边三个规则对应后台的配置
        if (grade == RuleConstant.DEGRADE_GRADE_RT) {
           //平均响应时间
            double rt = clusterNode.avgRt();
            if (rt < this.count) {
                passCount.set(0);
                return true;
            }
            // Sentinel will degrade the service only if count exceeds.
            // 只有在通过数超过设置的最小值的时候才会降级
            if (passCount.incrementAndGet() < rtSlowRequestAmount) {
                return true;
            }
        }
            // 熔断策略为异常比例时
         else if (grade == RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO) {
            // 单位时间内的异常数
            double exception = clusterNode.exceptionQps();
            // 单位时间内的成功数
            double success = clusterNode.successQps();
            // 单位时间内的总共请求数
            double total = clusterNode.totalQps();
            // If total amount is less than minRequestAmount, the request will pass.
            // 当总共请求数达不到最小请求数(后台配置)时直接放行
            if (total < minRequestAmount) {
                return true;
            }

            // In the same aligned statistic time window,
            // "success" (aka. completed count) = exception count + non-exception count (realSuccess)
            // success数包含了有异常跟无异常的，所以要求realSuc要减去异常数
            double realSuccess = success - exception;
            if (realSuccess <= 0 && exception < minRequestAmount) {
                return true;
            }
            if (exception / success < count) {
                return true;
            }
        }
            // 熔断策略为异常数
          else if (grade == RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT) {
            //一分钟内的异常数  totalException() {    return rollingCounterInMinute.exception();   }
            double exception = clusterNode.totalException();
            if (exception < count) {
                return true;
            }
        }

        if (cut.compareAndSet(false, true)) {
            ResetTask resetTask = new ResetTask(this);
            pool.schedule(resetTask, timeWindow, TimeUnit.SECONDS);
        }

        return false;
    }

 
 
集成nacos后配置更新相关源码
 
 
主要利用nacos配置读取更新等,可参考nacos配置中心源码Nacos配置中心源码
 
 
 
     
  
  • 参考nacos配置更新，他主要是注册一个listener监听nacos config(当有数据发生改变的时候调用listener)
     主要是通过CacheData#safeNotifyListener这个方法来修改的，我们重点看这个方法，具体nacos配置更新流程可查看
    •  
 
 
 
    private void safeNotifyListener(final String dataId, final String group, final String content, final String type,
            final String md5, final ManagerListenerWrap listenerWrap) {
        final Listener listener = listenerWrap.listener;
        
        Runnable job = new Runnable() {
            @Override
            public void run() {
                ClassLoader myClassLoader = Thread.currentThread().getContextClassLoader();
                ClassLoader appClassLoader = listener.getClass().getClassLoader();
                try {
                    if (listener instanceof AbstractSharedListener) {
                        AbstractSharedListener adapter = (AbstractSharedListener) listener;
                        adapter.fillContext(dataId, group);
                        LOGGER.info("[{}] [notify-context] dataId={}, group={}, md5={}", name, dataId, group, md5);
                    }
                    // 执行回调之前先将线程classloader设置为具体webapp的classloader，以免回调方法中调用spi接口是出现异常或错用（多应用部署才会有该问题）。
                    Thread.currentThread().setContextClassLoader(appClassLoader);
                    
                    ConfigResponse cr = new ConfigResponse();
                    cr.setDataId(dataId);
                    cr.setGroup(group);
                    cr.setContent(content);
                    configFilterChainManager.doFilter(null, cr);
                    String contentTmp = cr.getContent();
                    //主要是调用这个方法，下面其他代码省略
                    listener.receiveConfigInfo(contentTmp);
                    ...
}
//----------------------------------✂------------------------------------------
这个是nacos sentinel实现的监听器

    public NacosDataSource(final Properties properties, final String groupId, final String dataId,
                           Converter parser) {
        super(parser);
        if (StringUtil.isBlank(groupId) || StringUtil.isBlank(dataId)) {
            throw new IllegalArgumentException(String.format("Bad argument: groupId=[%s], dataId=[%s]",
                groupId, dataId));
        }
        AssertUtil.notNull(properties, "Nacos properties must not be null, you could put some keys from PropertyKeyConst");
        this.groupId = groupId;
        this.dataId = dataId;
        this.properties = properties;
        this.configListener = new Listener() {
            @Override
            public Executor getExecutor() {
                return pool;
            }
            @Override
            public void receiveConfigInfo(final String configInfo) {
                RecordLog.info(String.format("[NacosDataSource] New property value received for (properties: %s) (dataId: %s, groupId: %s): %s",
                    properties, dataId, groupId, configInfo));
                T newValue = NacosDataSource.this.parser.convert(configInfo);
                //主要是调用这个方法 Update the new value to the property.
                getProperty().updateValue(newValue);
            }
        };
        initNacosListener();
        loadInitialConfig();
    }
//----------------------------------✂------------------------------------------

    public boolean updateValue(T newValue) {
        if (isEqual(value, newValue)) {
            return false;
        }
        RecordLog.info("[DynamicSentinelProperty] Config will be updated to: " + newValue);

        value = newValue;
        for (PropertyListener listener : listeners) {
            //找到对当前规则感兴趣的listener,并修改值
            listener.configUpdate(newValue);
        }
        return true;
    }           
//----------------------------------✂------------------------------------------

    private static final class FlowPropertyListener implements PropertyListener> {

        @Override
        public void configUpdate(List value) {
            //组建新的规则map
            Map> rules = FlowRuleUtil.buildFlowRuleMap(value);
            if (rules != null) {
                //替换map
                flowRules.clear();
                flowRules.putAll(rules);
            }
            RecordLog.info("[FlowRuleManager] Flow rules received: " + flowRules);
        }

        @Override
        public void configLoad(List conf) {
            Map> rules = FlowRuleUtil.buildFlowRuleMap(conf);
            if (rules != null) {
                flowRules.clear();
                flowRules.putAll(rules);
            }
            RecordLog.info("[FlowRuleManager] Flow rules loaded: " + flowRules);
        }
    }


 
 
sentinel集成nacos总结
 
 
客户端启动时，会根据配置地址去取nacos上取sentinel配置，然后保存在本地的rules，每次校次检验直接用本地rules去检验。
 启动sentinel控制台，当在控制台修改的时候会同步到nacos配置。当修改为nacos获取的时候也是一样的，也会从nacos去取配置，
 客户端方面，当nacos配置发生变化，sentinel会有监听器去执行，修改掉本地的配置。
 
 
问题：
 如果修改nacos的配置，dashboard会同步吗
 实测，直接在nacos的控制台修改配置，dashboard也会同步，原理也是用的nacos的配置动态更新
 引入的包为sentinel-datasource-nacos在这里面
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Sentinel流程源码)

        

            

                
    
                    
  • 解决前后端分离跨域产生的session丢失问题
                        luckilyil
BUGjavaservlet
                        
    目录前言存储用户信息的方式Cookies：Token（令牌）：LocalStorage/SessionStorage：Session：Redis：OAuth/OIDC：本篇文章主要讲使用session会话来存储信息会话机制1.何为一次会话，会话从什么时候开始，从什么时候结束？2.cookies如何保持会话，它的工作流程？3.什么是Session？Session的工作原理：问题出现解决方法总结前言现
    
                    
    • 
                    
  • 什么是Spring Boot？它在Java后端开发中的作用是什么？
                        破碎的天堂鸟
学习教程javaspringboot数据库
                        
    什么是SpringBoot？SpringBoot是由Pivotal团队开发的一个基于Spring框架的快速开发框架，旨在简化Spring应用的初始搭建和开发流程。其核心理念是“约定优于配置”（ConventionoverConfiguration），通过默认配置和自动化机制，使开发者能够快速构建独立的、生产级别的应用程序。以下是其核心定义与特点：基于Spring的扩展与优化SpringBoot并非
    
                    
    • 
                    
  • Node.js 如何发布一个 NPM 包——详细教程
                        还是鼠鼠
node.jsnpm前端node.jsvscode
                        
    在本文中，我将带大家一步步学习如何创建并发布一个NPM包，帮助开发者理解整个流程，并能顺利将自己的JavaScript库发布到NPM上供他人使用。1.安装Node.js和npm在开始之前，请确保你的电脑上已经安装了Node.js和npm（Node.js自带npm）。你可以在终端（Windows用户请使用cmd或PowerShell）输入以下命令检查是否已安装：node-vnpm-v如果出现版本号，
    
                    
    • 
                    
  • 做代理仓建议使用海外仓系统吗？
                        易境通
海外仓系统大数据
                        
    日益繁荣的跨境电商市场吸引了许多货代企业想要参与其中，却苦于没有经验、缺乏充裕资金和人力资源。而代理仓模式为企业提供了低成本、高灵活性的解决方案，能够有效降低门槛，快速响应市场需求。无需大量的资金、资源、人力投入，即可快速入局海外仓市场。此时，使用一个拥有代理功能的海外仓系统，可以有效简化代理账号和价格设置、客户信息管理，以及财务对账等多个环节流程，大大降低企业的操作难度，帮助企业全面提升管理效率
    
                    
    • 
                    
  • 双缓冲机制（Double Buffering）快速接收处理串口接收到的大量数据帧
                        wys99999
单片机stm32
                        
    这种方式通常称为双缓冲机制（DoubleBuffering），也被称为Ping-Pong缓冲。在嵌入式系统中，双缓冲机制常用于高效处理连续数据流，例如串口接收、DMA数据传输等。原理双缓冲机制的核心思想是使用两个缓冲区（数组）轮流接收和处理数据。具体流程如下：数据接收阶段：当一个缓冲区正在接收数据时，另一个缓冲区可以被处理。切换缓冲区：当接收缓冲区填满后，立即切换到另一个空闲缓冲区进行数据接收，同
    
                    
    • 
                    
  • 每日面试题-假设有一个 1G 大的 HashMap，此时用户请求过来刚好触发它的扩容，会怎样？让你改造下 HashMap 的实现该怎样优化？
                        晚夜微雨问海棠呀
java开发语言
                        
    一、原理解析：HashMap扩容机制的核心问题当HashMap的size>capacity*loadFactor时触发扩容（默认负载因子0.75）。扩容流程如下：创建新数组：容量翻倍（newCap=oldCap{privateNode[]oldTable;privateNode[]newTable;privatevolatileintmigrationIndex=0;//迁移进度指针publicv
    
                    
    • 
                    
  • 2024年第五届MathorCup数学应用挑战赛--大数据竞赛思路、代码更新中.....
                        宇哥预测优化代码学习
1024程序员节
                        
    欢迎来到本博客❤️❤️博主优势：博客内容尽量做到思维缜密，逻辑清晰，为了方便读者。⛳️座右铭：行百里者，半于九十。本文目录如下：目录⛳️研赛及概况一、竞赛背景与目的二、组织机构与参赛对象三、竞赛时间与流程四、竞赛要求与规则五、奖项设置与奖励六、研究文档撰写建议七、参考资料与资源1找程序网站推荐2公式编辑器、流程图、论文排版324年研赛资源下载4思路、Python、Matlab代码分享......⛳
    
                    
    • 
                    
  • Linux服务器设置jar包开机自启
                        一个简单的名称
Linux服务器linuxjar
                        
    一、准备工作将jar包上传到服务器（本文将jar包上传到/home/project/jar/）新建脚本文件（本文将脚本文件放在/home/project/sh/文件下）注：sentinel-dashboard是我的程序名，可根据实际情况替换二、新建、编辑jar包的启动和停止脚本#启动脚本文件vim/home/project/sh/sentinel-dashboard-start.sh#停止脚本文件
    
                    
    • 
                    
  • RabbitMQ基本原理
                        码农小伙
消息队列rabbitmq分布式
                        
    一、基本结构所有中间件技术都是基于TCP/IP协议基础之上进行构建新的协议规范，RabbitMQ遵循的是AMQP协议（AdvancedMessageQueuingProtocol-高级消息队列协议）。生产者发送消息流程：1、生产者和Broker建立TCP连接；2、生产者和Broker建立通道；3、生产者通过通道消息发送给Broker，由Exchange将消息进行转发；4、Exchange将消息转发
    
                    
    • 
                    
  • Spring Boot 整合 RabbitMQ：注解声明队列与交换机详解
                        Cloud_.
java-rabbitmqspringbootrabbitmqMQ消息队列
                        
    RabbitMQ作为一款高性能的消息中间件，在分布式系统中广泛应用。SpringBoot通过spring-boot-starter-amqp提供了对RabbitMQ的无缝集成，开发者可以借助注解快速声明队列、交换机及绑定规则，极大简化了配置流程。本文将通过代码示例和原理分析，详细介绍如何用注解实现RabbitMQ的集成，并深入解析交换机的作用与类型。一、环境准备1.添加依赖在pom.xml中引入S
    
                    
    • 
                    
  • java:实现设置窗体背景颜色为淡蓝色（附带源码）
                        Katie。
Java实战项目java信息可视化开发语言
                        
    一、项目简介在桌面应用开发中，窗体背景颜色作为界面设计的重要组成部分，不仅影响整体美观，还能传递特定的情感和品牌信息。本项目旨在使用JavaSwing简单实现将窗体背景颜色设置为淡蓝色效果。该示例展示了如何创建一个基本的JFrame，并通过调用其内容面板的setBackground()方法，设置背景颜色为淡蓝色（RGB值173,216,230）。通过本项目，初学者可以了解Swing基本组件的使用方
    
                    
    • 
                    
  • 若依框架二次开发——启动 RuoYi-Cloud 微服务项目
                        bjzhang75
项目开发实践微服务若依
                        
    文章目录前期准备第一步：拉取RuoYi-Cloud项目源码第二步：初始化数据库1.创建数据库2.导入数据第三步：配置Nacos并启用持久化1.下载并解压Nacos2.启动Nacos3.访问Nacos控制台第四步：安装并运行Redis1.安装Redis2.启动Redis第五步：修改后端配置第六步：启动后端服务第七步：启动前端项目1.进入前端项目目录2.安装前端依赖3.启动前端第八步：访问系统总结Ru
    
                    
    • 
                    
  • 前端实例：轮播图效果
                        2301_81535770
前端
                        
    利用HTML、CSS和JavaScript实现轮播图效果。一、轮播图原理：通过给窗口设置position属性和overflow属性，使得超出窗口范围的部分被隐藏，表面可见范围只包含窗口，但实际上其内部空间很大；调整胶卷相对于窗口的位置，使得整个胶卷向左移动；调用JS中的定时器，实现轮播效果。流程图如下：二、实现自动切换效果1、HTML搭建基础框架分为图片展示窗口和上下页切换按键两部分>2、CSS设
    
                    
    • 
                    
  • Axios源码深度剖析 - XHR篇
                        IT博客技术分享
ajaxnode.jsjavascript
                        
    Axios源码深度剖析-XHR篇#Axios源码深度剖析-XHR篇[axios](https://github.com/axios/axios)是一个基于Promise的http请求库，可以用在浏览器和node.js中，目前在github上有42K的star数##分析axios-目录-[axios项目目录结构](#axios项目目录结构)-[名词解释](#名词解释)-[axios内部的运作流程图]
    
                    
    • 
                    
  • 远程视像搬运小车控制系统设计(源码+万字报告+实物)
                        炳烛之明科技
stm32嵌入式硬件单片机
                        
    目录第1章绪论11.1研究目的及意义11.2国内外研究现状21.3主要研究内容3第2章系统的总体结构42.1总体方案设计42.2功能需求分析42.2.1技术路线42.3单片机型号选择5第3章系统的硬件部分设计63.1系统总体设计63.2系统的主要功能模块设计63.2.1蜂鸣器电路模块设计63.2.2YX4055AM驱动电路模块设计73.2.3按键电路模块设计73.2.4颜色识别传感器模块设计83.
    
                    
    • 
                    
  • 百度地图开放平台Key值申请
                        前端熊猫
百度地图开发平台AK
                        
    百度地图开放平台key值获取流程首先，登录需选择个人或者企业实名认证进入百度地图开放平台，点击右上角的控制台，进入开发者管理界面：选择应用管理->我的应用，点击创建应用，填写服务端：需设置IP白名单（安全性更高）或者浏览器端：需配置Referer白名单（防止恶意调用），获取测试key！！！在“我的应用”列表中，可查看并复制AK
    
                    
    • 
                    
  • SAP-ABAP：SAP生产业务（PP模块）全流程深度解析
                        爱喝水的鱼丶
VIP详情查看专栏SAPABAP开发运维运维系统架构
                        
    SAP生产业务（PP模块）全流程深度解析一、生产主数据架构体系1.主数据矩阵物料主数据工艺路线工作中心生产版本MRP运行2.核心主数据表数据对象表结构关键字段事务码物料主数据MARAMATNR,MTART,DISMMMM01工艺路线PLKO/PLPOPLNNR(路由号),VORNR(工序)CA01工作中心CRHD/CRTXARBPL(工作中心),KAPAR(能力)CR01BOMMAST/STPOS
    
                    
    • 
                    
  • 使用定时器中断进行延时，取代delay，不影响主流程的运行
                        litvm
bug解决经验分享单片机嵌入式硬件
                        
    在单片机开发中，我们经常会用到延时函数-delay();比如LED的闪烁、ADC采集、向其他设备发送指令后等待回复数据等等，应用非常广泛，也很好用。但它也有一个致命的缺点——死等，举个例子，一个工程中有A、B、C三个任务，如果是裸机开发，不考虑中断的话，它会按while(1)中固定的顺序去执行。由于任务需要，B中会经常delay_ms(500);，那么在delay过程中，整个程序都会在B中等待50
    
                    
    • 
                    
  • SAP库龄计算报表（源码）
                        SAP 的寒
SAP精品资源ABAP
                        
    一个简单的库龄计算报表，根据移动类型来判断最后移动日期，包含批次和非批次库存。*&---------------------------------------------------------------------**&ReportZMMR_016*&---------------------------------------------------------------------**
    
                    
    • 
                    
  • WebRTC建立Description的通信的实际的原理
                        堕落年代
vue杂论webrtc网络
                        
    一、正确流程的核心逻辑//发送端正确代码示例constsenderPC=newRTCPeerConnection();//生成Offer时立即开始收集候选✅senderPC.createOffer().then(offer=>{awaitsenderPC.setLocalDescription(offer);//触发icecandidate事件sendToReceiver(offer);});//
    
                    
    • 
                    
  • 华为云计算产品系列 | 云上迁移工具RainBow实战详解
                        降世神童
云计算技术专栏华为华为云云计算
                        
    华为云计算产品系列|云上迁移工具RainBow实战详解1.迁移方案2.迁移流程3.迁移实验3.1.Windows系统迁移3.2.Linux系统迁移3.3.存储层迁移1.迁移方案  RainBow可以将物理机或者虚拟机上的业务迁移到华为的虚拟化平台和私有云平台（6.5.1以上支持），还可以实现低版本私有云迁移到高版本私有云。  Rainbow是华为自研迁移工具，支持X86架构下主流的Linux、Wi
    
                    
    • 
                    
  • Linux内核网络源码分析——发送数据
                        hellolwl
Android/Linuxlinux内核网络structoutputsocketconstructor
                        
    原文地址:http://www.penna.cn/blog/?p=218UDP发送：|sys_writefs/read_write.c|sock_writevnet/socket.c|sock_sendmsgnet/socket.c|inet_sendmsgnet/ipv4/af_inet.c|udp_sendmsgnet/ipv4/udp.c|ip_build_xmitnet/ipv4/ip_o
    
                    
    • 
                    
  • 无再暴露源站！群联AI云防护IP隐匿方案+防绕过实战
                        群联云防护小杜
安全问题汇总人工智能tcp/ip网络协议网络安全http服务器
                        
    一、IP隐藏的核心原理群联AI云防护通过三层架构实现源站IP深度隐藏：流量入口层：用户访问域名解析至高防CNAME节点（如ai-protect.example.com）智能调度层：基于AI模型动态分配清洗节点，实时更新节点IP池回源层：防护节点通过加密隧道与源站通信，源站仅接受来自群联节点的流量二、IP隐藏配置全流程1.DNS配置（域名指向群联CNAME）#域名DNS记录示例@CNAMEai-pr
    
                    
    • 
                    
  • brew 安装pip_pip brew wget 安装
                        weixin_32612253
brew安装pip
                        
    终端播放器安装教程从简书上看到一篇,终端实现网易云音乐的文章,并给出了一个github链接.心里有些痒痒,想看看是什么样子,于是尝试安装.安装过程中有些坎坷,记录以便以后查阅.程序实现是用Python写的.安装使用方式仅仅给了三行命令.安装$pipinstallnetease-musicbox$brewinstallmpg123使用$musicbox下载了源码后,不知道该如何安装.三行命令也是莫名
    
                    
    • 
                    
  • MotionLayout（二）：MotionLayout是什么？MotionLayout调试技巧、KeyFrame关键帧等等
                        前期后期
androidkotlin学习
                        
    一、MotionLayout是什么？●定位：AndroidJetpack中的高级布局容器，继承自ConstraintLayout。●核心功能：通过状态（State）和过渡（Transition）定义复杂的界面动画，支持手势交互、路径动画等。●优势：简化动画开发流程，替代传统Animator或TransitionManager，适合处理多视图联动、复杂转场效果。1.1应用场景使用MotionLayo
    
                    
    • 
                    
  • Android 使用设计模式：装饰者设计模式，对功能进行封装升级，学会可以让我们的代码更加的简洁。
                        前期后期
设计模式android设计模式
                        
    一、前言我遇到什么问题要使用装饰者设计模式？看源码的时候：我们发现明明ui有一个功能，但是在这个ui类找不到，后来发现，这个ui被当做一个参数传递到了一个类里面，后来才在这个类里找到了这个功能。突然醍醐灌顶，这不就是装饰者设计模式吗？写代码的时候：如果我们想给一个功能增加新的东西，可以借助装饰者设计模式来装饰，如果不需要则可以把这个方法去掉，非常的简洁和优雅，并且新增的功能放到了另外一个类里面，也
    
                    
    • 
                    
  • 一文读懂 Linux 下 Docker 搭建及简单应用
                        Waitccy
linuxdocker运维服务器
                        
    一、引言在Linux系统的运维与开发场景中，Docker凭借其高效的容器化技术，极大地简化了应用部署与管理流程。它打破了传统环境配置的复杂性，实现应用及其依赖的封装，确保在不同环境中稳定运行。本文将详细介绍在Linux系统下搭建Docker的步骤，并通过几个简单应用示例，带你快速上手Docker。二、Linux下Docker搭建（一）准备工作系统要求：建议使用主流的Linux发行版，如Ubuntu
    
                    
    • 
                    
  • 2025计算机毕设全流程实战指南：Java/Python+协同过滤+小程序开发避坑手册
                        启点毕设
课程设计javapython大四论文指南查重降重技巧毕业设计spring
                        
    技术框架的选择是项目开发的关键起点，直接影响开发效率和最终成果质量。然而，许多开发者在选择技术框架时面临困难：现有知识储备不足以支撑复杂项目需求，团队经验有限，框架选择缺乏前瞻性常导致后期问题。尽管技术框架的选择过程充满挑战，但合适的框架能为项目开发和维护奠定基础，而不当的选择则可能带来持续的技术债务和开发困扰。所以，建议对项目技术框架把握不好的同学，最好是找自己的研究生学长或者老师详细的把关机技
    
                    
    • 
                    
  • CentOS7 python安装Ta-lib 0.6.x【talib不能直接安装，必须先安装ta_lib之c++库才可以】
                        weixin_43343144
服务器运维
                        
    正常流程：CentOS7python安装Ta-lib【talib不能直接安装，必须先安装ta_lib之c++库才可以】_centos7安装ta-lib-CSDN博客不同的版本参考如下！参考官方文档：ta-lib·PyPI务必下载匹配版本的【ta-lib-0.6.4-src.tar.gz】才可以正常安装$wgethttps://github.com/ta-lib/ta-lib/releases/do
    
                    
    • 
                    
  • 基于Qt开发：实现对海康威视网络摄像头视频画面实时预览
                        鱼弦
Qt学习与实践音视频开发系列实践Linux系统编程与驱动开发arm开发
                        
    鱼弦：公众号【红尘灯塔】，CSDN博客专家、内容合伙人、新星导师、全栈领域优质创作者、51CTO(Top红人+专家博主)、github开源爱好者（go-zero源码二次开发、游戏后端架构https://github.com/Peakchen）介绍:本文将介绍如何基于Qt开发框架,实现对海康威视网络摄像头的二次开发应用程序。该应用程序可以实时预览摄像头视频画面,并支持控制云台的水平和垂直移动。这种二
    
                    
    • 
                                
  • C/C++Win32编程基础详解视频下载
                                    择善Zach
编程C++Win32
                                    
    课题视频：C/C++Win32编程基础详解 
视频知识：win32窗口的创建 
                  windows事件机制 
主讲：择善Uncle老师 
学习交流群：386620625 
验证码：625 
 
--
    
                                
    • 
                                
  • Guava Cache使用笔记
                                    bylijinnan
javaguavacache
                                    
    1.Guava Cache的get/getIfPresent方法当参数为null时会抛空指针异常 
 
我刚开始使用时还以为Guava Cache跟HashMap一样，get(null)返回null。 
实际上Guava整体设计思想就是拒绝null的，很多地方都会执行com.google.common.base.Preconditions.checkNotNull的检查。 
 
 
2.Guava
    
                                
    • 
                                
  • 解决ora-01652无法通过128（在temp表空间中）
                                    0624chenhong
oracle
                                    
    解决ora-01652无法通过128（在temp表空间中）扩展temp段的过程 
 
一个sql语句后，大约花了10分钟，好不容易有一个结果，但是报了一个ora-01652错误，查阅了oracle的错误代码说明：意思是指temp表空间无法自动扩展temp段。这种问题一般有两种原因：一是临时表空间空间太小，二是不能自动扩展。 
分析过程： 
   既然是temp表空间有问题，那当
    
                                
    • 
                                
  • Struct在jsp标签
                                    不懂事的小屁孩
struct
                                    
    非UI标签介绍： 
控制类标签： 
1：程序流程控制标签   if   elseif    else 
<s:if test="isUsed"> 
 <span class="label label-success">True</span> 
</
    
                                
    • 
                                
  • 按对象属性排序
                                    换个号韩国红果果
JavaScript对象排序
                                    
    利用JavaScript进行对象排序，根据用户的年龄排序展示 
 
<script>
var bob={
name;bob,
age:30
}
var peter={
name;peter,
age:30
}
var amy={
name;amy,
age:24
}
var mike={
name;mike,
age:29
}
var john={

    
                                
    • 
                                
  • 大数据分析让个性化的客户体验不再遥远
                                    蓝儿唯美
数据分析
                                    
    顾客通过多种渠道制造大量数据，企业则热衷于利用这些信息来实现更为个性化的体验。 
分析公司Gartner表示，高级分析会成为客户服务的关键，但是大数据分析的采用目前仅局限于不到一成的企业。 挑战在于企业还在努力适应结构化数据，疲于根据自身的客户关系管理（CRM）系统部署有效的分析框架，以及集成不同的内外部信息源。 
然而，面对顾客通过数字技术参与而产生的快速变化的信息，企业需要及时作出反应。要想实
    
                                
    • 
                                
  • java笔记4
                                    a-john
java
                                    
    操作符 
1，使用java操作符 
      操作符接受一个或多个参数，并生成一个新值。参数的形式与普通的方法调用不用，但是效果是相同的。加号和一元的正号（+）、减号和一元的负号（-）、乘号（*）、除号（/）以及赋值号（=）的用法与其他编程语言类似。 
      操作符作用于操作数，生成一个新值。另外，有些操作符可能会改变操作数自身的
    
                                
    • 
                                
  • 从裸机编程到嵌入式Linux编程思想的转变------分而治之：驱动和应用程序
                                    aijuans
嵌入式学习
                                    
        笔者学习嵌入式Linux也有一段时间了，很奇怪的是很多书讲驱动编程方面的知识，也有很多书将ARM9方面的知识，但是从以前51形式的（对寄存器直接操作，初始化芯片的功能模块）编程方法，和思维模式，变换为基于Linux操作系统编程，讲这个思想转变的书几乎没有，让初学者走了很多弯路，撞了很多难墙。 
    笔者因此写上自己的学习心得，希望能给和我一样转变
    
                                
    • 
                                
  • 在springmvc中解决FastJson循环引用的问题
                                    asialee
循环引用fastjson
                                    
              我们先来看一个例子： 
          
package com.elong.bms;

import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;

import co
    
                                
    • 
                                
  • ArrayAdapter和SimpleAdapter技术总结
                                    百合不是茶
androidSimpleAdapterArrayAdapter高级组件基础
                                    
    ArrayAdapter比较简单，但它只能用于显示文字。而SimpleAdapter则有很强的扩展性，可以自定义出各种效果 
  
ArrayAdapter;的数据可以是数组或者是队列 
  
     // 获得下拉框对象 
AutoCompleteTextView textview = (AutoCompleteTextView) this

    
                                
    • 
                                
  • 九封信
                                    bijian1013
人生励志
                                    
            有时候，莫名的心情不好，不想和任何人说话，只想一个人静静的发呆。有时候，想一个人躲起来脆弱，不愿别人看到自己的伤口。有时候，走过熟悉的街角，看到熟悉的背影，突然想起一个人的脸。有时候，发现自己一夜之间就长大了。         2014，写给人
    
                                
    • 
                                
  • Linux下安装MySQL Web 管理工具phpMyAdmin
                                    sunjing
PHPInstallphpMyAdmin
                                    
    PHP http://php.net/ 
phpMyAdmin http://www.phpmyadmin.net 
Error compiling PHP on CentOS x64 
  
一、安装Apache 
请参阅http://billben.iteye.com/admin/blogs/1985244 
  
二、安装依赖包 
sudo yum install gd 
    
                                
    • 
                                
  • 分布式系统理论
                                    bit1129
分布式
                                    
    FLP 
One famous theory in distributed computing, known as FLP after the authors Fischer, Lynch, and Patterson, proved that in a distributed system with asynchronous communication and process crashes, 
    
                                
    • 
                                
  • ssh2整合(spring+struts2+hibernate)-附源码
                                    白糖_
eclipsespringHibernatemysql项目管理
                                    
    最近抽空又整理了一套ssh2框架，主要使用的技术如下： 
spring做容器，管理了三层(dao,service,actioin)的对象 
struts2实现与页面交互(MVC)，自己做了一个异常拦截器，能拦截Action层抛出的异常 
hibernate与数据库交互 
BoneCp数据库连接池，据说比其它数据库连接池快20倍，仅仅是据说 
MySql数据库 
  
项目用eclipse
    
                                
    • 
                                
  • treetable bug记录
                                    braveCS
table
                                    
    // 插入子节点删除再插入时不能正常显示。修改：
//不知改后有没有错，先做个备忘
 Tree.prototype.removeNode = function(node) {
      // Recursively remove all descendants of +node+
      this.unloadBranch(node);

      // Remove
    
                                
    • 
                                
  • 编程之美-电话号码对应英语单词
                                    bylijinnan
java算法编程之美
                                    
    

import java.util.Arrays;

public class NumberToWord {

	/**
	 * 编程之美 电话号码对应英语单词
	 * 题目：
     *  手机上的拨号盘，每个数字都对应一些字母，比如2对应ABC，3对应DEF.........，8对应TUV，9对应WXYZ，
     *  要求对一段数字，输出其代表的所有可能的字母组合
    
                                
    • 
                                
  • jquery ajax读书笔记
                                    chengxuyuancsdn
jQuery ajax
                                    
    1、jsp页面 
 
<%@ page language="java" import="java.util.*" pageEncoding="GBK"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()
    
                                
    • 
                                
  • JWFD工作流拓扑结构解析伪码描述算法
                                    comsci
数据结构算法工作活动J#
                                    
      对工作流拓扑结构解析感兴趣的朋友可以下载附件，或者下载JWFD的全部代码进行分析 
 
 
  /*  流程图拓扑结构解析伪码描述算法 
 
        public java.util.ArrayList DFS(String graphid, String stepid, int j) 
    
                                
    • 
                                
  • oracle I/O 从属进程
                                    daizj
oracle
                                    
    I/O 从属进程 
 
　　I/O从属进程用于为不支持异步I/O的系统或设备模拟异步I/O.例如，磁带设备(相当慢)就不支持异步I/O.通过使用I/O 从属进程，可以让磁带机模仿通常只为磁盘驱动器提供的功能。就好像支持真正的异步I/O 一样，写设备的进程(调用者)会收集大量数据，并交由写入器写出。数据成功地写出时，写入器(此时写入器是I/O 从属进程，而不是操作系统)会通知原来的调用者，调用者则会
    
                                
    • 
                                
  • 高级排序:希尔排序
                                    dieslrae
希尔排序
                                    
    
    public void shellSort(int[] array){
        int limit = 1;
        int temp;
        int index;
        
        while(limit <= array.length/3){
            limit = limit * 3 + 1;
    
    
                                
    • 
                                
  • 初二下学期难记忆单词
                                    dcj3sjt126com
englishword
                                    
    kitchen 厨房 
cupboard 厨柜 
salt 盐 
sugar 糖 
oil 油 
fork 叉；餐叉 
spoon 匙；调羹 
chopsticks 筷子 
cabbage 卷心菜；洋白菜 
soup 汤 
Italian 意大利的 
  
Indian 印度的 
workplace  工作场所 
even 甚至；更 
Italy 意大利 
laugh 笑 
m
    
                                
    • 
                                
  • Go语言使用MySQL数据库进行增删改查
                                    dcj3sjt126com
mysql
                                    
    目前Internet上流行的网站构架方式是LAMP，其中的M即MySQL, 作为数据库，MySQL以免费、开源、使用方便为优势成为了很多Web开发的后端数据库存储引擎。MySQL驱动Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持database/sql标准，而有些是采用了自己的实现接口,常用的有如下几种: 
 
  http://code.google.c...o-mysql-dri
    
                                
    • 
                                
  • git命令
                                    shuizhaosi888
git
                                    
    ---------------设置全局用户名：
git config --global user.name "HanShuliang" //设置用户名 
git config --global user.email "[email protected]" //设置邮箱

---------------查看环境配置
git config --li
    
                                
    • 
                                
  • qemu-kvm 网络 nat模式 (四)
                                    haoningabc
kvmqemu
                                    
    qemu-ifup-NAT 
 

#!/bin/bash
BRIDGE=virbr0
NETWORK=192.168.122.0
GATEWAY=192.168.122.1
NETMASK=255.255.255.0
DHCPRANGE=192.168.122.2,192.168.122.254
TFTPROOT=
BOOTP=
function check_bridge()

    
                                
    • 
                                
  • 不要让未来的你，讨厌现在的自己
                                    jingjing0907
生活 奋斗 工作 梦想
                                    
     故事one 
　23岁，他大学毕业，放弃了父母安排的稳定工作，独闯京城，在家小公司混个小职位，工作还算顺手，月薪三千，混了混，混走了一年的光阴。　　　　24岁，有了女朋友，从二环12人的集体宿舍搬到香山民居，一间平房，二人世界，爱爱爱。偶然约三朋四友，打扑克搓麻将，日子快乐似神仙；　　　　25岁，出了几次差，调了两次岗，薪水涨了不过百，生猛狂飙的物价让现实血淋淋，无力为心爱银儿购件大牌
    
                                
    • 
                                
  • 枚举类型详解
                                    一路欢笑一路走
enum枚举详解enumsetenumMap
                                    
    枚举类型详解 
一.Enum详解 
     1.1枚举类型的介绍 
  
JDK1.5加入了一个全新的类型的”类”—枚举类型，为此JDK1.5引入了一个新的关键字enum,我们可以这样定义一个枚举类型。 
  
   Demo:一个最简单的枚举类 
  
public enum ColorType {
   RED
    
                                
    • 
                                
  • 第11章 动画效果（上）
                                    onestopweb
动画
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • Eclipse中jsp、js文件编辑时，卡死现象解决汇总
                                    ljf_home
eclipsejsp卡死js卡死
                                    
    使用Eclipse编辑jsp、js文件时，经常出现卡死现象，在网上百度了N次，经过N次优化调整后，卡死现象逐步好转，具体那个方法起到作用，不太好讲。将所有用过的方法罗列如下： 
  
1、取消验证 
windows–>perferences–>validation 
把 除了manual 下面的全部点掉，build下只留 classpath dependency Valida
    
                                
    • 
                                
  • MySQL编程中的6个重要的实用技巧
                                    tomcat_oracle
mysql
                                    
    每一行命令都是用分号(;)作为结束 
对于MySQL，第一件你必须牢记的是它的每一行命令都是用分号(;)作为结束的，但当一行MySQL被插入在PHP代码中时，最好把后面的分号省略掉，例如： 
mysql_query("INSERT INTO tablename(first_name,last_name)VALUES('$first_name',$last_name')"); 

    
                                
    • 
                                
  • zoj 3820 Building Fire Stations(二分+bfs)
                                    阿尔萨斯
Build
                                    
     题目链接：zoj 3820 Building Fire Stations 
 题目大意：给定一棵树，选取两个建立加油站，问说所有点距离加油站距离的最大值的最小值是多少，并且任意输出一种建立加油站的方式。 
 解题思路：二分距离判断，判断函数的复杂度是o(n)，这样的复杂度应该是o(nlogn)，即使常数系数偏大，但是居然跑了4.5s，也是醉了。 判断函数里面做了3次bfs，但是每次bfs节点最多
    
                                
    •