BUG指挥官
BUG指挥官

聊聊服务熔断降级Sentinel

分布式系统的流量防卫兵，Sentinel是面向分布式服务框架的流量控制组件，主要以流量为切入点，从限流、流量整形、熔断降级、系统负载保护、热点防护等多个维度来帮助开发者保障微服务的稳定性。Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景，例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。Sentinel 可以简单的分为 Sentinel 核心库和 Dashboard。核心库不依赖 Dashboard，但是结合 Dashboard 可以取得最好的效果。

官网参考地址：github.com/alibaba/Sen…

工程引入依赖

需要开启服务熔断降级的工程引入jar依赖。

    com.alibaba.cloud    spring-cloud-starter-alibaba-sentinel     com.alibaba.csp    sentinel-datasource-nacos

Dashboard控制台

控制台用于展示配置的规则，以及请求的实时监控，下载与sentinel对应版本的sentinel-dashboard.jar启动文件。

相关配置

下载地址：github.com/alibaba/Sen…

启动命令例（设置端口、用户名、密码、jar的位置）：java -Dserver.port=8090 -Dsentinel.dashboard.auth.username=qingyun -Dsentinel.dashboard.auth.password=123456 -jar sentinel-dashboard-1.8.1.jar 工程配置文件中配置sentinel控制台连接信息：

spring: cloud:   sentinel:     transport:         dashboard: 127.0.0.1:8090       port: 8719 #默认8719，假如被占用了会自动从8719开始依次+1扫描。直至找到未被占用的端口

聊聊服务熔断降级Sentinel_第1张图片

Nacos实例化规则

在Dashboard控制台上添加的规则只能存在内存中，重启控制台后规则会丢失，所以实例化规则可以选择nacos。目前项目中在nacos配置规则，在Dashboard中回显规则，监控访问情况。

nacos中配置规则

聊聊服务熔断降级Sentinel_第2张图片

项目引入规则

聊聊服务熔断降级Sentinel_第3张图片

Dashboard回显规则

聊聊服务熔断降级Sentinel_第4张图片

Sentinel实现

注解方式定义资源

Sentinel 支持通过 @SentinelResource 注解定义资源并配置 blockHandler 和 fallback 函数来进行限流之后的处理。例如：

@GetMapping("/getTestListSentinelFlow")@SentinelResource(value = "todolist/getTestListSentinelFlow", fallback = "fallbackGetTestListSentinel",fallbackClass = FallbackAppcenter.class, blockHandler = "blockHandlerGetTestListSentinel",blockHandlerClass = BlockHandlerAppcenter.class)public Result> getTestListSentinelFlow() {    Result> result = umappTestService.getTestList();    return result;} /*** 处理blockHandler对应的方法*/public static Result> blockHandlerGetTestListSentinel(BlockException ex) {    return Result.error("被流控了"+ex.getMessage());} /*** 处理fallback对应的方法*/public static Result> fallbackGetTestListSentinel(Throwable e) {    e.printStackTrace();    return Result.error("抛出异常了"+e.getMessage());}

参数说明

value:对应资源名 blockHandler：设置流控降级后的方法（默认改方法必须写在同一个类中），如果处理方法不想在一个类中，可以配置blockHandlerClass=xxx.class，但是方法必须是static。 fallback：当接口出现异常，可以交个fallback指定的方法处理（默认改方法必须写在同一个类中），如果处理方法不想在同一个类中，可以配置fallbackClass=xxx.class，但是方法必须是static， blockHandler和fallback同时指定了，当触发了限流和异常时，blockHandler优先级更高 exceptionsToIgnore:数组的方式指定排除哪些异常不处理

统一异常处理

定义一个统一处理BlockException异常的类，接口名中不需要写@SentinelResource指定异常调用的方法，但是需要具体异常处理的方法，还是需要使用@SentinelResource指定。

/** * 统一异常处理类 */@Componentpublic class MyBlockExceptionHandler implements BlockExceptionHandler {    Logger log = LoggerFactory.getLogger(this.getClass());     @Override    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException e) throws Exception {        Message message = null;        log.info("BlockException======="+e.getRule());        if(e instanceof FlowException){            message = message.error(300,"接口被限流了");        } else if(e instanceof DegradeException){            message = message.error(301,"接口被降级了");        } else if(e instanceof ParamFlowException){            message =  message.error(302,"接口热点参数限流了");        } else if(e instanceof SystemBlockException){            message =  message.error(303,"接口触发系统保护规则了");        } else if(e instanceof AuthorityException){            message =  message.error(304,"授权接口不通过");        }        //返回json格式        httpServletResponse.setStatus(500);        httpServletResponse.setCharacterEncoding("utf-8");        httpServletResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);        new ObjectMapper().writeValue(httpServletResponse.getWriter(),message);    }}

Sentinel 功能

流量控制

每秒请求的并发数大于服务器能提供的最大QPS，对大于的部分进行限流，返回“稍后重试”或者直接拒绝处理。

聊聊服务熔断降级Sentinel_第5张图片

rule-type为流控方式，例选择了flow（流控），则data-id中配置的规则都是流控，其他的规则配置无效。

规则配置参考：github.com/alibaba/Sen…

流控模式--直接

nacos中配置规则：

[       {        "resource": "/todolist/getTestList",        "controlBehavior":0,        "count":2,        "grade":1,        "limitApp": "default",        "strategy":0    },     {        "resource": "todolist/getTestListSentinelFlow",        "controlBehavior":0,        "count":2,        "grade":1,        "limitApp": "default",        "strategy":0    }]

Dashboard回显规则：

聊聊服务熔断降级Sentinel_第6张图片

流控模式--关联

关联的资源访问达到配置的阈值，则此资源的访问会被流控，关联的资源自己不需要做配置。

业务场景举例：在获取订单的接口/order/get中配置了管理资源为/order/add，并且设置了QPS为2，则当/order/add接口每秒访问大于2次，/order/get接口直接限流；此处接口资源/order/add没有做任何配置。

聊聊服务熔断降级Sentinel_第7张图片

流控模式--链路

资源通过调用关系，形成调用链路，构成一棵调用树。

业务场景举例：资源/order/test1和/order/test2都调用了资源getUser,Sentinel只允许根据某个入口的统计信息做限流。同时调用getUser方法，对/order/test1进行限流，/order/test2不限流。

聊聊服务熔断降级Sentinel_第8张图片

聊聊服务熔断降级Sentinel_第9张图片

流控效果

快速失败：默认的流量控制方式，当QPS超过任意规则的阈值后，新的请求就会被立即拒绝，拒绝方式为抛出FlowException。这种方式适用于处理能力已知的情况下，比如通过压测确定了系统的准确水位后。

Warm up（激增流量）：预热/冷启动方式，当系统长期处于低水位的情况下，当流量突然增加时，直接把系统拉升到可能瞬间把系统拉垮。通过“冷启动”，让通过的流量缓慢增加，在一定时间内逐渐增加到阈值上限，给冷系统一个预热的时间，避免冷系统被压垮。

冷加载因子：codeFactor默认是3，即QPS从threshold/3开始，经过预热时长逐渐升至指定的QPS阈值。

聊聊服务熔断降级Sentinel_第10张图片

排队等待（脉冲流量）：严格控制请求通过的间隔时间，也即是让请求以均匀的速度通过。该方式的作用如下图所示：

聊聊服务熔断降级Sentinel_第11张图片

这种方式主要用于处理间隔性突发的流量，例如消息队列。在某一秒有大量的请求进来，而接下来的几秒则处于空闲状态，我们希望系统能在接下来的空闲时间逐渐处理这些请求，而不是在第一秒直接拒绝多余的请求。

注意：暂不支持QPS>1000的排队等待处理

熔断降级

远程服务不稳定或者网络抖动时暂时关闭，就叫服务熔断。当某个服务熔断之后，服务将不再调用，此时客户端可以自己准备一个本地的fallback（回退）回调，返回一个缺省值。虽然服务水平下降，但好歹可用，总比直接宕机要强，这也要看适合的场景。

聊聊服务熔断降级Sentinel_第12张图片

熔断降级方式，则引入的rule-type为degrade。

nacos中配置规则：

[  {  "resource": "todolist/getTestListSentinelDegrade",  "grade":0,  "count":1000,  "timeWindow":3,  "minRequestAmount": 2,  "statIntervalMs":3000,  "slowRatioThreshold":0.1  }]

Dashboard回显规则：

聊聊服务熔断降级Sentinel_第13张图片

熔断策略

慢调用比例：慢调用比例作为阈值，需要设置运行慢调用的RT(即最大的响应时间ms），请求的响应时间大于该值则统计为慢调用。当单位统计时长内请求数目大于设置的最小请求数，并且慢调用的比例大于阈值，则接下来的熔断时长内请求会被熔断，经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN）,若接下来的一个请求响应时间小于设置的慢调用RT则结束熔断，若大于设置的慢调用RT则会再次被熔断。

例子：每次请求处理的最大时长为1秒，大于1秒则为慢调用；3秒内，请求数大于2，且有1次是慢调用，则熔断服务3秒

聊聊服务熔断降级Sentinel_第14张图片

异常比例：单位统计时长内请求数目大于设置的最小请求数，并且异常的比例大于阈值，则接下来的熔断时长内请求自动熔断

异常数：当单位统计时长内的异常数目超过阈值之后会自动进行熔断。

系统自适应保护

Sentinel 同时提供系统维度的自适应保护能力。防止雪崩，是系统防护中重要的一环。当系统负载较高的时候，如果还持续让请求进入，可能会导致系统崩溃，无法响应。

系统自适应保护，则引入的rule-type为system。

例子：cpu使用率阈值为5%，大于5%则触发系统保护规则。

nacos中配置规则：

[  {    "resource": "todolist/system",    "highestSystemLoad":3.0,    "highestCpuUsage":0.05,    "avgRt":10,    "qps": 20,    "maxThread":10  }]

聊聊服务熔断降级Sentinel_第15张图片

聊聊服务熔断降级Sentinel_第16张图片

load自适应（仅对Linux/unix-like机器生效）：系统的load1作为启发指标，进行自适应系统保护。当系统load1超过设定的启发值，且系统当前的并发线程数超过估算的系统容量时，才会触发系统保护（BBR阶段）。

RT:当单台机器上所有入口流量的评价RT达到阈值时触发系统保护，单位是毫秒。

线程数：当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。

入口QPS：当单台机器上所有入口流量的QPS到阈值即触发系统保护。

CPU使用率：当系统CPU使用率超过阈值即触发系统保护（取值范围0.0-1.0），比较灵活。

热点参数限流

热点参数限流会统计传入参数中的热点参数，并根据配置的限流阈值与模式，对包含热点参数的资源调用进行限流。热点参数限流可以看做是一种特殊的流量控制，仅对包含热点参数的资源调用生效。

聊聊服务熔断降级Sentinel_第17张图片

热点参数，则引入的rule-type为param-flow。

例：给接口getById的第一个参数（index为0）添加热点限流，普通参数qps最大2，参数为1时，最大qps可以达到5。

nacos中配置规则：

[  {    "burstCount": 0,    "clusterMode": false,    "controlBehavior": 0,    "count": 2,    "durationInSec": 1,    "grade": 1,    "limitApp": "default",    "maxQueueingTimeMs": 0,    "paramFlowItemList": [      {      "classType": "int",      "count": 5,      "object": "1"      }    ],    "paramIdx": 0,    "resource": "todolist/getById"  }]

Dashboard回显规则：

聊聊服务熔断降级Sentinel_第18张图片

黑白名单控制

很多时候，我们需要根据调用来源来判断该次请求是否允许放行，这时候可以使用 Sentinel 的来源访问控制（黑白名单控制）的功能。来源访问控制根据资源的请求来源（origin）限制资源是否通过，若配置白名单则只有请求来源位于白名单内时才可通过；若配置黑名单则请求来源位于黑名单时不通过，其余的请求通过。

系统自适应保护，则引入的rule-type为authority。

例：给ip为10.18.xx.xx的请求来源添加对资源/todolist/getTestList1访问的黑名单。

nacos中配置规则：

[    {        "resource": "/todolist/getTestList1",        "limitApp": "10.18.xx.xx",        "strategy": 1    }]

项目工程中添加解析来源ip的配置类：

@Componentpublic class IpLimitConifg implements RequestOriginParser {    //解析调用的ip    @Override    public String parseOrigin(HttpServletRequest request) {        return request.getRemoteAddr();    }}

Dashboard回显规则：

聊聊服务熔断降级Sentinel_第19张图片

Sentinel实现原理

在 Sentinel 里面，所有的资源都对应一个资源名称（resourceName），每次资源调用都会创建一个 Entry 对象。Entry 可以通过对主流框架的适配自动创建，也可以通过注解的方式或调用 SphU API 显式创建。Entry 创建的时候，同时也会创建一系列功能插槽（slot chain），这些插槽有不同的职责，根据定义的资源名创建的功能插槽chain如下：

聊聊服务熔断降级Sentinel_第20张图片

聊聊服务熔断降级Sentinel_第21张图片

  • first 链表的头结点；
  • NodeSelectorSlot 负责收集资源的路径，并将这些资源的调用路径，以树状结构存储起来，用于根据调用路径来限流降级；
  • ClusterBuilderSlot 则用于存储资源的统计信息以及调用者信息，例如该资源的 RT, QPS, thread count 等等，这些信息将用作为多维度限流，降级的依据；
  • LogSlot 日志打印；
  • StatisticSlot 则用于记录、统计不同纬度的 runtime 指标监控信息；
  • AuthoritySlot 则根据配置的黑白名单和调用来源信息，来做黑白名单控制；
  • SystemSlot 则通过系统的状态，例如 load1 等，来控制总的入口流量；
  • FlowSlot 则用于根据预设的限流规则以及前面 slot 统计的状态，来进行流量控制；
  • DegradeSlot 则通过统计信息以及预设的规则，来做熔断降级；
  • end 链表的尾结点。

现在以SphU.entry方法为切入点来开始分析。这个方法会去申请一个entry，如果能够申请成功，则说明没有被限流，否则会抛出BlockException，表明已经被限流了。

sentinel的责任链的传递方式：每个Slot节点执行完自己的业务后，会调用fireEntry来触发下一个节点的entry方法，就通过SlotChain完成了对每个节点的entry()方法的调用，每个节点会根据创建的规则，进行自己的逻辑处理，当统计的结果达到设置的阈值时，就会触发限流、降级等事件，具体就是抛出BlockException异常。

源码分析

以SphU.entry(RESOURCE_NAME)进入流控的源码规则创建。

调用的是SphU.java类的entry方法:

    public static Entry entry(String name) throws BlockException {        return Env.sph.entry(name, EntryType.OUT, 1, OBJECTS0);    }

接下来调用的是Env类中创建的CtSph类，CtSph类实现了Sph接口，CtSph类的entry方法：

    public Entry entry(String name, EntryType type, int count, Object... args) throws BlockException {        StringResourceWrapper resource = new StringResourceWrapper(name, type);        return entry(resource, count, args);    }

根据传递的资源名和EntryType类型创建StringResourceWrapper，再调用CtSph类中的entry方法：

public Entry entry(ResourceWrapper resourceWrapper, int count, Object... args) throws BlockException {        return entryWithPriority(resourceWrapper, count, false, args);    }

再调用CtSph类的entryWithPriority方法：

private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args)        throws BlockException {        Context context = ContextUtil.getContext();        if (context instanceof NullContext) {            // The {@link NullContext} indicates that the amount of context has exceeded the threshold,            // so here init the entry only. No rule checking will be done.            return new CtEntry(resourceWrapper, null, context);        }        if (context == null) {            // Using default context.            context = InternalContextUtil.internalEnter(Constants.CONTEXT_DEFAULT_NAME);        }        // Global switch is close, no rule checking will do.        if (!Constants.ON) {            return new CtEntry(resourceWrapper, null, context);        }        ProcessorSlot chain = lookProcessChain(resourceWrapper);        /*         * Means amount of resources (slot chain) exceeds {@link Constants.MAX_SLOT_CHAIN_SIZE},         * so no rule checking will be done.         */        if (chain == null) {            return new CtEntry(resourceWrapper, null, context);        }        Entry e = new CtEntry(resourceWrapper, chain, context);        try {            chain.entry(context, resourceWrapper, null, count, prioritized, args);        } catch (BlockException e1) {            e.exit(count, args);            throw e1;        } catch (Throwable e1) {            // This should not happen, unless there are errors existing in Sentinel internal.            RecordLog.info("Sentinel unexpected exception", e1);        }        return e;    } 
  
 
  
 
  
主要关注CtSph类创建责任链的方法lookProcessChain(resourceWrapper)：
 
  
 
  
 
  
 ProcessorSlot lookProcessChain(ResourceWrapper resourceWrapper) {        ProcessorSlotChain chain = chainMap.get(resourceWrapper);        if (chain == null) {            synchronized (LOCK) {                chain = chainMap.get(resourceWrapper);                if (chain == null) {                    // Entry size limit.                    if (chainMap.size() >= Constants.MAX_SLOT_CHAIN_SIZE) {                        return null;                    }                    chain = SlotChainProvider.newSlotChain();                    Map newMap = new HashMap(                        chainMap.size() + 1);                    newMap.putAll(chainMap);                    newMap.put(resourceWrapper, chain);                    chainMap = newMap;                }            }        }        return chain;    } 
  
 
  
 
  
当我们第一次访问资源名为“hello”的时候，从chainMap（全局资源责任链集合）中获取不到此资源的任何定义，然后使用synchronized加锁双校验是否为空的检查方式校验是否为空（防止并发线程不安全），为空则开始创建责任链chain；Constants.MAX_SLOT_CHAIN_SIZE最大值为6000，目前责任链最大值定义是6000。chainMap是一个map集合：
 
  
 
  
 
  
    private static volatile Map chainMap        = new HashMap();
 
  
 
  
 
  
使用volatile关键字进行修饰，为了线程安全使用缓存一致性协议（MESI），当map中数据变动后其他线程能通过总线嗅探机制感知，然后及时失效自己工作内存中的数据并从主内存中重新获取数据写入自己的工作内存。
 
  
 
  
 
  
从chainMap中获取不到资源的定义（第一次访问），使用SlotChainProvider类创建责任链SlotChainProvider.newSlotChain()：
 
  
 
  
 
  
   public static ProcessorSlotChain newSlotChain() {        if (slotChainBuilder != null) {            return slotChainBuilder.build();        }        // Resolve the slot chain builder SPI.        slotChainBuilder = SpiLoader.of(SlotChainBuilder.class).loadFirstInstanceOrDefault();        if (slotChainBuilder == null) {            // Should not go through here.            RecordLog.warn("[SlotChainProvider] Wrong state when resolving slot chain builder, using default");            slotChainBuilder = new DefaultSlotChainBuilder();        } else {            RecordLog.info("[SlotChainProvider] Global slot chain builder resolved: {}",                slotChainBuilder.getClass().getCanonicalName());        }        return slotChainBuilder.build();    }
 
  
 
  
 
  
第一次的时候，责任链的构造接口类SlotChainBuilder为空，通过类SpiLoader构造一个责任链的构造类：
 
  
 
  
 
  
 slotChainBuilder = SpiLoader.of(SlotChainBuilder.class).loadFirstInstanceOrDefault()
 
  
 
  
 
  
使用责任链的构造类创建插槽，调用slotChainBuilder.build()。
 
  
 
  
 
  
DefaultSlotChainBuilder类实现了SlotChainBuilder接口，所以执行slotChainBuilder.build()的方法在DefaultSlotChainBuilder类中：
 
  
 
  
 
  
  public ProcessorSlotChain build() {        ProcessorSlotChain chain = new DefaultProcessorSlotChain();        List sortedSlotList = SpiLoader.of(ProcessorSlot.class).loadInstanceListSorted();        for (ProcessorSlot slot : sortedSlotList) {            if (!(slot instanceof AbstractLinkedProcessorSlot)) {                RecordLog.warn("The ProcessorSlot(" + slot.getClass().getCanonicalName() + ") is not an instance of AbstractLinkedProcessorSlot, can't be added into ProcessorSlotChain");                continue;            }            chain.addLast((AbstractLinkedProcessorSlot) slot);        }        return chain;    }
 
  
 
  
 
  
DefaultProcessorSlotChain类继承了ProcessorSlotChain类，所以使用DefaultProcessorSlotChain创建类：
 
  
 
  
 
  
public class DefaultProcessorSlotChain extends ProcessorSlotChain {    AbstractLinkedProcessorSlot first = new AbstractLinkedProcessorSlot() {        @Override        public void entry(Context context, ResourceWrapper resourceWrapper, Object t, int count, boolean prioritized, Object... args)            throws Throwable {            super.fireEntry(context, resourceWrapper, t, count, prioritized, args);        }        @Override        public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {            super.fireExit(context, resourceWrapper, count, args);        }    };    AbstractLinkedProcessorSlot end = first;    @Override    public void addFirst(AbstractLinkedProcessorSlot protocolProcessor) {        protocolProcessor.setNext(first.getNext());        first.setNext(protocolProcessor);        if (end == first) {            end = protocolProcessor;        }    }    @Override    public void addLast(AbstractLinkedProcessorSlot protocolProcessor) {        end.setNext(protocolProcessor);        end = protocolProcessor;    }    /**     * Same as {@link #addLast(AbstractLinkedProcessorSlot)}.     *     * @param next processor to be added.     */    @Override    public void setNext(AbstractLinkedProcessorSlot next) {        addLast(next);    }    @Override    public AbstractLinkedProcessorSlot getNext() {        return first.getNext();    }    @Override    public void entry(Context context, ResourceWrapper resourceWrapper, Object t, int count, boolean prioritized, Object... args)        throws Throwable {        first.transformEntry(context, resourceWrapper, t, count, prioritized, args);    }    @Override    public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {        first.exit(context, resourceWrapper, count, args);    }} 
  
 
  
 
  
先创建出chain的DefaultProcessorSlotChain类，使用属性first存放DefaultProcessorSlotChain类，并把first赋值给end：
 
  
 
  
 
  
AbstractLinkedProcessorSlot  end = first;
 
  
 
  
 
  
类SpiLoader加载需要的9个插槽slot：
 
  
 
  
聊聊服务熔断降级Sentinel_第22张图片
 
  
 
  
循环把这9个slot添加到Chain责任链中：
 
  
 
  
 
  
     for (ProcessorSlot slot : sortedSlotList) {            if (!(slot instanceof AbstractLinkedProcessorSlot)) {                RecordLog.warn("The ProcessorSlot(" + slot.getClass().getCanonicalName() + ") is not an instance of AbstractLinkedProcessorSlot, can't be added into ProcessorSlotChain");                continue;            }            chain.addLast((AbstractLinkedProcessorSlot) slot);        }
 
  
 
  
 
  
DefaultProcesserSlotChain类添加到责任链最后位置方法：
 
  
 
  
 
  
    public void addLast(AbstractLinkedProcessorSlot protocolProcessor) {        end.setNext(protocolProcessor);        end = protocolProcessor;    }
 
  
 
  
 
  
初始的时候把first赋值给了end，addLast方法操作的是end属性，每次都添加到end属性的下一个节点，并且把当前节点赋值给end属性，循环把这九个插槽赋值到责任链上。
 
  
 
  
 
  
构建出来的责任链添加到全局chainMap资源中：
 
  
 
  
 
  
                    Map newMap = new HashMap(                        chainMap.size() + 1);                    newMap.putAll(chainMap);                    newMap.put(resourceWrapper, chain);                    chainMap = newMap;
 
  
 
  
 
  
添加的方式为：创建一个临时的map对象，大小为全局chainMap大小加1，先把chainMap添加到临时的map中，再把刚才创建的责任链添加到临时map中，key为根据资源名构建的wrapper对象，value为责任链；再把整个临时map赋值给全局chainMap。
 
  
 
  
 
  
创建完责任链后，根据资源名构建的wrapper和chain和访问的context构建Entry对象。
 
  
 
  
 
  
Entry e = new CtEntry(resourceWrapper, chain, context)
 
  
 
  
 
  
resourceWrapper构建的资源截图：
 
  
 
  
聊聊服务熔断降级Sentinel_第23张图片
 
  
 
  
责任链chain截图：
 
  
 
  
聊聊服务熔断降级Sentinel_第24张图片
 
  
 
  
context内容截图：
 
  
 
  
聊聊服务熔断降级Sentinel_第25张图片
 
  
 
  
通过调用责任链的entry方法，若是调用异常，则抛出BlockException：
 
  
 
  
 
  
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);}
 
  
 
  
 
  
执行DefaultProcessorSlotChain类的entry方法：
 
  
 
  
 
  
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);}
 
  
 
  
 
  
接着执行first.transformEntry()，先执行责任链的第一个节点first，first的类型是AbstractLinkedProcessorSlot类，所以执行AbstractLinkedProcessorSlot的transformEntry方法：
 
  
 
  
 
  
void transformEntry(Context context, ResourceWrapper resourceWrapper, Object o, int count, boolean prioritized, Object... args)    throws Throwable {    T t = (T)o;    entry(context, resourceWrapper, t, count, prioritized, args);}
 
  
 
  
 
  
当前的t强转后为null，再调用entry后，调用到AbstractLinkedProcessorSlot的entry方法：
 
  
 
  
 
  
public void entry(Context context, ResourceWrapper resourceWrapper, Object t, int count, boolean prioritized, Object... args)    throws Throwable {    super.fireEntry(context, resourceWrapper, t, count, prioritized, args);}
 
  
 
  
 
  
再调用AbstractLinkedProcessorSlot的fireEntry方法：
 
  
 
  
 
  
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);    }}
 
  
 
  
 
  
调用到AbstractLinkedProcessorSlot的transformEntry方法：
 
  
 
  
 
  
void transformEntry(Context context, ResourceWrapper resourceWrapper, Object o, int count, boolean prioritized, Object... args)    throws Throwable {    T t = (T)o;    entry(context, resourceWrapper, t, count, prioritized, args);}
 
  
 
  
 
  
此entry方法的实现类是NodeSelectSlot：
 
  
 
  
 
  
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);fireEntry(context, resourceWrapper, node, count, prioritized, args);
 
  
 
  
 
  
同样的每个插槽都有一个全局map，用于记录资源的访问情况，map也是使用volatile修饰（保证每个线程拿到的数据一致），同样使用synchronized加锁双非空校验赋值。
 
  
 
  
 
  
执行完后调用fireEntry方法，开始同样的方式创建责任链的next节点，此时调用到AbstractLinkedProcessorSlot类的fireEntry方法，再调用transformEntry方法，接着调用entry进入到具体的T转成的插槽中执行方法。
 
  
 
  
 
  
权限AuthoritySlot插槽会根据设置的黑白名单进行校验，entry方法：
 
  
 
  
 
  
public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count, boolean prioritized, Object... args)    throws Throwable {    checkBlackWhiteAuthority(resourceWrapper, context);    fireEntry(context, resourceWrapper, node, count, prioritized, args);}
 
  
 
  
 
  
checkBlackWhiteAuthority先拿到配置的权限规则，若是没有配置直接通过，有配置再进行校验，校验不通过直接抛出AuthorityException异常，方法：
 
  
 
  
 
  
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);        }    }}
 
  
 
  
 
  
系统SystemSlot插槽会根据设置的规则校验，entry方法：
 
  
 
  
 
  
public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,                  boolean prioritized, Object... args) throws Throwable {    SystemRuleManager.checkSystem(resourceWrapper);    fireEntry(context, resourceWrapper, node, count, prioritized, args);}
 
  
 
  
 
  
SystemRuleManager.checkSystem校验系统规则，若是有违背规则的直接抛出SystemBlockException异常：
 
  
 
  
 
  
public static void checkSystem(ResourceWrapper resourceWrapper) throws BlockException {    if (resourceWrapper == null) {        return;    }    // Ensure the checking switch is on.    if (!checkSystemStatus.get()) {        return;    }    // for inbound traffic only    if (resourceWrapper.getEntryType() != EntryType.IN) {        return;    }    // total qps    double currentQps = Constants.ENTRY_NODE == null ? 0.0 : Constants.ENTRY_NODE.successQps();    if (currentQps > qps) {        throw new SystemBlockException(resourceWrapper.getName(), "qps");    }    // total thread    int currentThread = Constants.ENTRY_NODE == null ? 0 : Constants.ENTRY_NODE.curThreadNum();    if (currentThread > maxThread) {        throw new SystemBlockException(resourceWrapper.getName(), "thread");    }    double rt = Constants.ENTRY_NODE == null ? 0 : Constants.ENTRY_NODE.avgRt();    if (rt > maxRt) {        throw new SystemBlockException(resourceWrapper.getName(), "rt");    }    // load. BBR algorithm.    if (highestSystemLoadIsSet && getCurrentSystemAvgLoad() > highestSystemLoad) {        if (!checkBbr(currentThread)) {            throw new SystemBlockException(resourceWrapper.getName(), "load");        }    }    // cpu usage    if (highestCpuUsageIsSet && getCurrentCpuUsage() > highestCpuUsage) {        throw new SystemBlockException(resourceWrapper.getName(), "cpu");    }}
 
  
 
  
 
  
热点参数ParamFlowSlot插槽entry方法，没有配置热点参数直接调用fireEntry执行下一个：
 
  
 
  
 
  
public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,                  boolean prioritized, Object... args) throws Throwable {    if (!ParamFlowRuleManager.hasRules(resourceWrapper.getName())) {        fireEntry(context, resourceWrapper, node, count, prioritized, args);        return;    }    checkFlow(resourceWrapper, count, args);    fireEntry(context, resourceWrapper, node, count, prioritized, args);}
 
  
 
  
 
  
校验热点参数，有异常抛出ParamFlowException异常：
 
  
 
  
 
  
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);        }    }}
 
  
 
  
 
  
流控FlowSlot插槽entry方法：
 
  
 
  
 
  
public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,                  boolean prioritized, Object... args) throws Throwable {    checkFlow(resourceWrapper, context, node, count, prioritized);    fireEntry(context, resourceWrapper, node, count, prioritized, args);}
 
  
 
  
 
  
校验流控规则，有异常抛出FlowException异常：
 
  
 
  
 
  
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);            }        }    }}
 
  
 
  
 
  
获取到流控规则的配置项信息：
 
  
 
  
聊聊服务熔断降级Sentinel_第26张图片
 
  
 
  
降级DegradeSlot插槽entry方法：
 
  
 
  
 
  
public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,                  boolean prioritized, Object... args) throws Throwable {    performChecking(context, resourceWrapper);    fireEntry(context, resourceWrapper, node, count, prioritized, args);}
 
  
 
  
 
  
降级规则校验，有异常抛出DegradeException：
 
  
 
  
 
  
void performChecking(Context context, ResourceWrapper r) throws BlockException {    List circuitBreakers = DegradeRuleManager.getCircuitBreakers(r.getName());    if (circuitBreakers == null || circuitBreakers.isEmpty()) {        return;    }    for (CircuitBreaker cb : circuitBreakers) {        if (!cb.tryPass(context)) {            throw new DegradeException(cb.getRule().getLimitApp(), cb.getRule());        }    }}
 
  
 
  
 
  
校验流程图：
 
  
 
  
聊聊服务熔断降级Sentinel_第27张图片
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(sentinel,java,spring)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                                
  • windows下源码安装golang
                                    616050468
golang安装golang环境windows
                                    
             系统： 64位win7， 开发环境：sublime text 2，  go版本： 1.4.1 
  
 1.  安装前准备(gcc, gdb, git) 
       golang在64位系
    
                                
    • 
                                
  • redis批量删除带空格的key
                                    bylijinnan
redis
                                    
    redis批量删除的通常做法： 
 
 
redis-cli keys "blacklist*" | xargs redis-cli del 
 
上面的命令在key的前后没有空格时是可以的，但有空格就不行了： 
 

$redis-cli keys "blacklist*"
1) "blacklist:12: [email protected]
    
                                
    • 
                                
  • oracle正则表达式的用法
                                    0624chenhong
oracle正则表达式
                                    
      方括号表达示 
方括号表达式 
描述 
[[:alnum:]] 
字母和数字混合的字符 
[[:alpha:]] 
字母字符 
[[:cntrl:]] 
控制字符 
[[:digit:]] 
数字字符 
[[:graph:]] 
图像字符 
[[:lower:]] 
小写字母字符 
[[:print:]] 
打印字符 
[[:punct：]] 
标点符号字符 
[[:space:]]
    
                                
    • 
                                
  • 2048源码(核心算法有，缺少几个anctionbar，以后补上)
                                    不懂事的小屁孩
2048
                                    
    2048游戏基本上有四部分组成， 
1：主activity，包含游戏块的16个方格，上面统计分数的模块 
2：底下的gridview，监听上下左右的滑动，进行事件处理， 
3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字 
4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现) 
 
写代码的流程 
1：设计游戏的布局，基本是两块，上面是分
    
                                
    • 
                                
  • jquery内部链式调用机理
                                    换个号韩国红果果
JavaScriptjquery
                                    
    只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this  因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象） 

function  create(type){
var element=document.createElement(type);
    //this=element;

    
                                
    • 
                                
  • 你订酒店时的每一次点击 背后都是NoSQL和云计算
                                    蓝儿唯美
NoSQL
                                    
    全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。 
云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。 
Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
    
                                
    • 
                                
  • java笔记1
                                    a-john
java
                                    
    1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。 
2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。 
3，面向对象程序设计方式的特性： 
    3.1 万物皆为对象。 
   
    
                                
    • 
                                
  • C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题 必备考点（一）
                                    aijuans
C/C++求职面试必备考点
                                    
            找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。 
       后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
    
                                
    • 
                                
  • 程序员写代码时就不要管需求了吗？
                                    asia007
程序员不能一味跟需求走
                                    
          编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。 
      我的技术不是很好，但是就不代
    
                                
    • 
                                
  • Activity的四种启动模式
                                    百合不是茶
android栈模式启动Activity的标准模式启动栈顶模式启动单例模式启动
                                    
    android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ; 
  
启动模式xml中配置 
    <activity android:name=".MainActivity" android:launchMode="standard&quo
    
                                
    • 
                                
  • Spring中@Autowired标签与@Resource标签的区别
                                    bijian1013
javaspring@Resource@Autowired@Qualifier
                                    
    Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。 
  
1. @Autowired    @Autowired是Spring 提供的，需导入    Package:org.springframewo
    
                                
    • 
                                
  • Changes Between SOAP 1.1 and SOAP 1.2
                                    sunjing
ChangesEnableSOAP 1.1SOAP 1.2
                                    
    JAX-WS 
SOAP Version 1.2 Part 0: Primer (Second Edition) 
SOAP Version 1.2 Part 1: Messaging Framework (Second Edition) 
SOAP Version 1.2 Part 2: Adjuncts (Second Edition) 
  
Which style of WSDL
    
                                
    • 
                                
  • 【Hadoop二】Hadoop常用命令
                                    bit1129
hadoop
                                    
    以Hadoop运行Hadoop自带的wordcount为例， 
  
hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行 
  Hadoop HDFS相关命令 
 
  hadoop fs -ls 
 
 列出HDFS文件系统的第一级文件和第一级
    
                                
    • 
                                
  • java异常处理（初级）
                                    白糖_
javaDAOspring虚拟机Ajax
                                    
    从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。 
最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
    
                                
    • 
                                
  • 记录整理-工作问题
                                    braveCS
工作
                                    
    1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。 
2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
    
                                
    • 
                                
  • org.apache.tools.zip实现文件的压缩和解压，支持中文
                                    bylijinnan
apache
                                    
    刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦） 
后改用org.apache.tools.zip 
org.apache.tools.zip的使用网上有更简单的例子 
下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法 
 



import java.io.BufferedReader;
import java.io.BufferedWrit
    
                                
    • 
                                
  • 读书笔记-4
                                    chengxuyuancsdn
读书笔记
                                    
    1、JSTL 核心标签库标签 
2、避免SQL注入 
3、字符串逆转方法 
4、字符串比较compareTo 
5、字符串替换replace 
6、分拆字符串 
 
 
1、JSTL 核心标签库标签共有13个，
学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html
功能上分为4类：
(1)表达式控制标签：out
    
                                
    • 
                                
  • [物理与电子]半导体教材的一个小问题
                                    comsci
问题
                                    
     
 
      各种模拟电子和数字电子教材中都有这个词汇-空穴 
 
      书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴 
 
      我现在回过头翻大学时候的教材,觉得这个
    
                                
    • 
                                
  • Flashback Database --闪回数据库
                                    daizj
oracle闪回数据库
                                    
    Flashback 技术是以Undo segment中的内容为基础的， 因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。 
在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
    
                                
    • 
                                
  • 简单排序:插入排序
                                    dieslrae
插入排序
                                    
    
    public void insertSort(int[] array){
        int temp;
        
        for(int i=1;i<array.length;i++){
            temp = array[i];
            
            for(int k=i-1;k>=0;k--)
    
                                
    • 
                                
  • C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int * p; //等价于 int *p 也等价于 int* p;
	int i = 5;
	char ch = 'A';

	//p = 5;	//error
	//p = &ch;	//error
	//p = ch;	//error

	p = &i;		// 
    
                                
    • 
                                
  • centos下php redis扩展的安装配置3种方法
                                    dcj3sjt126com
redis
                                    
    方法一 
1.下载php redis扩展包     代码如下 复制代码    
#wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz     
2 tar -zxvf 解压压缩包，cd /扩展包 （进入扩展包然后 运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
    
                                
    • 
                                
  • 线程池(Executors)
                                    shuizhaosi888
线程池
                                    
    在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦 
	public interface Executor {

	    void execute(Runnable command);
	}
 
  
public class RunMain implements Executor{

	@Override
	pub
    
                                
    • 
                                
  • openstack 快速安装笔记
                                    haoningabc
openstack
                                    
    前提是要配置好yum源 
版本icehouse，操作系统redhat6.5 
最简化安装，不要cinder和swift 
三个节点 
172 control节点keystone glance horizon 
173 compute节点nova 
173 network节点neutron 
 

control
/etc/sysctl.conf

net.ipv4.ip_forward =
    
                                
    • 
                                
  • 从c面向对象的实现理解c++的对象（二）
                                    jimmee
C++面向对象虚函数
                                    
    1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。 
2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数 
3. c++中类的析构函数，就时回收内存(free) 
4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。 
专门在
    
                                
    • 
                                
  • 如何让那个一个div可以拖动
                                    lingfeng520240
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/1999/xhtml
    
                                
    • 
                                
  • 第10章 高级事件（中）
                                    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/
    
                                
    • 
                                
  • 计算两个经纬度之间的距离
                                    roadrunners
计算纬度LBS经度距离
                                    
    要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。 
	/**
	 * 
	 * @param longitudeA
	 *            经度A点
	 * @param latitudeA
	 *            纬度A点
	 * @param longitudeB
	 *    
    
                                
    • 
                                
  • 最具争议的10个Java话题
                                    tomcat_oracle
java
                                    
    1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！   　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。   　 
　2、Java 9 即将到来   　　 
Oracle早在8月份就发布
    
                                
    • 
                                
  • zoj 3826 Hierarchical Notation(模拟)
                                    阿尔萨斯
rar
                                    
     题目链接：zoj 3826 Hierarchical Notation 
 题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。 
 解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。 这题是最后10分钟出的，因为没有考虑value为{}的情
    
                                
    •