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流程源码)






    

  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
说私域
人工智能小程序

    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    

    • 

  • linux中sdl的使用教程,sdl使用入门
Melissa Corvinus
linux中sdl的使用教程

    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    

    • 

  • 四章-32-点要素的聚合
彩云飘过

    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    

    • 

  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业

    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    

    • 

  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
二挡起步
web前端期末大作业javascripthtmlcss旅游风景

    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    

    • 

  • libyuv之linux编译
jaronho
Linuxlinux运维服务器

    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    

    • 

  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
算法大师
华为od面试python

    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
    

    • 

  • 闲鱼鱼小铺怎么开通？鱼小铺开通需要哪些流程？
高省APP大九

    闲鱼鱼小铺是平台推出的一个专业程度的店铺，与普通店铺相比会有更多的权益，比如说发布的商品数量从50增加到500；拥有专业的店铺数据看板与分析的功能，这对于专门在闲鱼做生意的用户来说是非常有帮助的，那么鱼小铺每个人都能开通吗？大家好，我是高省APP联合创始人蓓蓓导师，高省APP是2021年推出的电商导购平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个可省钱佣金高，能
    

    • 

  • ARM驱动学习之基础小知识
JT灬新一
ARM嵌入式arm开发学习

    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    

    • 

  • Low Power概念介绍-Voltage Area
飞奔的大虎

    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
    

    • 

  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）
算法大师
华为od面试python

    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
    

    • 

  • nosql数据库技术与应用知识点
皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库

    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    

    • 

  • 下一站深圳
默琊

    昨天已经买好3/15到深圳的机票了，原本上周还有点拖延症发作，不太积极，所以昨天就直接逼迫自己买机票，然后在订房，下周就是确认行业和把具体的面谈日程定下来。行业的选择上目前没有太大的偏好，上一份工作主要是风控和客服，客服部分也算是个小组长，有负责培训和一些案件SOP流程的制定等工作。总感觉客服这个职位的职涯发展只能是垂直的往更高的管理层走，对于横向发展似乎不容易，而鉴于做客服1年的感受，我不太喜欢
    

    • 

  • 简单了解 JVM
记得开心一点啊
jvm

    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    

    • 

  • ArrayList 源码解析
程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea

    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    

    • 

  • 网络通信流程
记得开心一点啊
服务器网络运维

    目录♫IP地址♫子网掩码♫MAC地址♫相关设备♫ARP寻址♫网络通信流程♫IP地址我们已经知道IP地址由网络号+主机号组成，根据IP地址的不同可以有5钟划分网络号和主机号的方案：其中，各类地址的表示范围是：分类范围适用网络网络数量主机最大连接数A类0.0.0.0~127.255.255.255大型网络12616777214【(2^24)-2】B类128.0.0.0~191.255.255.255中
    

    • 

  • Python神器！WEB自动化测试集成工具 DrissionPage
亚丁号
python开发语言

    一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
    

    • 

  • Java爬虫框架（一）--架构设计
狼图腾-狼之传说
java框架java任务html解析器存储电子商务

    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    

    • 

  • android 更改窗口的层次,浮窗开发之窗口层级
Ms.Bu
android更改窗口的层次

    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
    

    • 

  • SpringCloudAlibaba—Sentinel(限流)
菜鸟爪哇

    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    

    • 

  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程
极客小张
stm32qt机器人物联网人机交互毕业设计c语言

    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
    

    • 

  • 基于STM32的汽车仪表显示系统：集成CAN、UART与I2C总线设计流程
极客小张
stm32汽车嵌入式硬件物联网单片机c语言

    一、项目概述项目目标与用途本项目旨在设计和实现一个基于STM32微控制器的汽车仪表显示系统。该系统能够实时显示汽车的速度、转速、油量等关键信息，并通过CAN总线与其他汽车控制单元进行通信。这种仪表显示系统不仅提高了驾驶的安全性和便捷性，还能为汽车提供更智能的用户体验。技术栈关键词微控制器：STM32显示技术：TFTLCD/OLED传感器：速度传感器、温度传感器、油量传感器通信协议：CAN总线、UA
    

    • 

  • JAVA·一个简单的登录窗口
MortalTom
java开发语言学习

    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    

    • 

  • 笋丁网页自动回复机器人V3.0.0免授权版源码
希希分享
软希网58soho_cn源码资源笋丁网页自动回复机器人

    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
    

    • 

  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能
小康师兄
ESP32-C3入门教程https服务器esp32OTAMQTT

    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
    

    • 

  • 项目：事半功倍的法宝
小小效能

    行动的三大流程：记录、排程和执行，也讲了易效能的4D原则以及T-step标签法。这些流程和方法能够解决我们眼前的一地鸡毛，让我们有更多时间和精力去关注更为长远的事情，完成工作、生活和人生中重要的项目。项目管理能够让我们围绕结果去做事情，达成事半功倍的效果，也就是做更少的事情，但达成更好的效果。如果我们能够不断地达成一个又一个的项目，那么我们的人生无疑会像滚雪球一样，在长坡道上面不断积累。一、项目的
    

    • 

  • 【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码）
疯狂的机器人
Python搞定车载自动化pythonDoIPUDSISO142291SO13400Bootloadertcp/ip

    系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
    

    • 

  • Table列表复现框实现【勾选-搜索-再勾选】
～四时春～
java开发语言elementuivue

    Table列表复现框实现【勾选-搜索-再勾选】概要整体架构流程代码实现技术细节注意参考文献概要最近在开发时遇到一个问题，在进行表单渲染时，正常选中没有问题，单如果需要搜索选中时，一个是已选中的不会回填，二是在搜索的结果中进行选中，没有实现，经过排查，查找资料后实现。例如：整体架构流程具体的实现效果如下：代码实现{{scope.row.userName}}已选区{{userItem.userName
    

    • 

  • 进销存小程序源码 PHP网络版ERP进销存管理系统 全开源可二开
摸鱼小号
php

    可直接源码搭建部署发布后使用：一、功能模块介绍该系统模板主要有进，销，存三个主要模板功能组成，下面将介绍各模块所对应的功能；进：需要将产品采购入库，自动生成采购明细台账同时关联财务生成付款账单；销：是指对客户的销售订单记录，汇总生成产品销售明细及回款计划；存：库存的日常盘点与统计，库存下限预警、出入库台账、库存位置等。1.进购管理采购订单：采购下单审批→由上级审批通过采购入库；采购入库：货品到货>
    

    • 

  • 《转介绍方法论》学习笔记
小可乐的妈妈

    一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
    

    • 

  • 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节点最多
    

    •