手写springcloud|熔断 hystrix

最新推荐文章于 2022-11-12 18:27:50 发布
最新推荐文章于 2022-11-12 18:27:50 发布
阅读量783 收藏
点赞数
分类专栏： 手写Spring Cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiewenfeng520/article/details/102160819
版权

文章目录

手写springcloud|熔断hystrix

github示例代码

github对应代码仓库地址：https://github.com/huajiexiewenfeng/spring-cloud-project-learn

服务调用和熔断的方式

假设：

  • web容器为tomcat
  • MVC为Spring Web MVC

hystrix是在controller调用DB 或者 controller调用其他service 过程中通过编码的方式进行服务调用的熔断或者限流
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PgumwzEd-1570269190766)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1570268847993.png)]

熔断的流程

一般有两种方式

  • 超时时间
    • 当调用的方法执行时间超过设置的超时时间，服务端返回容错对象
  • 信号量
    • 单位时间内，服务端的访问量超过一定数量，线程阻塞
      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zeD8Bgsf-1570269190767)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1570086404109.png)]

Spring Cloud Hystrix 熔断细节

基本步骤

  1. 激活熔断 @EnableCircuitBreaker
  2. 配置Hystrix注解或者实现HystrixCommand抽象类
  3. 配置Hystrix属性和fallback方法
  4. 实现fallback方法

原版使用核心代码

本文将实现类似的效果

    @HystrixCommand(
            fallbackMethod = "errorContent",
            commandProperties = {
                    @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",
                            value = "100")
            }
    )
    @GetMapping("/say")
    public String say(@RequestParam("message") String message) throws InterruptedException {
        int value = random.nextInt(200);
        System.out.println("say() cost " + value + "ms");
        Thread.sleep(value);
        System.out.println("port:" + getPort() + ",接收到消息-say:" + message);
        return "port:" + getPort() + ",Hello," + message;
    }

实现过程

添加依赖

springboot
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
    </parent>
springcloud
<spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
其他依赖

  • 本环境将server服务注册到zookeeper，如果不需要可以注释掉zookeeper相关的依赖

  • hystrix依赖是为了测试原版功能

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zookeeper-all</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.zookeeper</groupId>
                    <artifactId>zookeeper</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.12</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

简易版本

通过简易版本了解基本的熔断实现过程

await()

模拟方法执行，随机等待200ms以内

    private String await(String message) throws InterruptedException, TimeoutException {
        int value = random.nextInt(200);
        System.out.println("say() cost " + value + "ms");
        Thread.sleep(value);
        System.out.println("port:" + getPort() + ",接收到消息-say:" + message);
        return "port:" + getPort() + ",Hello," + message;
    }

sayLevel1()

实现调用和熔断功能

使用线程池ExecutorService+Future

  • future.get(100, TimeUnit.MILLISECONDS)
    • 超过100毫秒，会抛出TimeoutException异常
  • 当await()方法执行超过100毫秒
    • 抛出TimeoutException异常
    • 执行errorContent()方法
  ...
private final ExecutorService executorService = Executors.newSingleThreadExecutor();
 ...
     /**
     * 简易版本
     *
     * @param message
     * @return
     * @throws InterruptedException
     */
    @GetMapping("/sayLevel1")
    public String sayLevel1(@RequestParam("message") String message) throws Exception {
        Future<String> future = executorService.submit(() -> {
            return await(message);
        });
        String res = null;
        //100毫秒超时时间
        try {
            res = future.get(100, TimeUnit.MILLISECONDS);
        } catch (InterruptedException | TimeoutException e) {
            return errorContent(message);
        }
        return res;
    }

errorContent()

容错返回方法

 public String errorContent(String message) {
        return "Fault";
    }

测试

浏览器输入

http://127.0.0.1:8080/sayLevel1?message=xwf

中级版本

使用spring web mvc中的interceptor拦截器实现+自定义注解

  1. 拦截所有request的请求
  2. 判断方法上是否有@Timeout注解
  3. Future+超时控制+反射执行原方法
  4. 捕捉异常
  5. 反射执行fallback方法

@Timeout注解

import java.lang.annotation.*;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Timeout {
    int timeout() default 100;//超时时间
    String fallback() default "";//回退方法
}

WebMvcConfig配置

增加CircuitBreakerHandlerInterceptor拦截器

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    public void addInterceptors(InterceptorRegistry registry) {
       registry.addInterceptor(new CircuitBreakerHandlerInterceptor());
    }

}

拦截器

import com.huajie.spring.cloud.server.annotation.Timeout;
import org.springframework.core.MethodParameter;
import org.springframework.util.StringUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Map;
import java.util.concurrent.*;
import java.util.stream.Stream;

public class CircuitBreakerHandlerInterceptor implements HandlerInterceptor {

    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Timeout timeOut = handlerMethod.getMethodAnnotation(Timeout.class);
            if (null != timeOut) {
                int timeout = timeOut.timeout();

                String fallback = timeOut.fallback();
                Object bean = handlerMethod.getBean();
                Method method = handlerMethod.getMethod();

                Map<String, String[]> parameterMap = request.getParameterMap();
                Class<?>[] parameterTypes = method.getParameterTypes();
                //实参
                Object[] paramValues = new Object[parameterTypes.length];

                int i=0;
                for (Map.Entry<String, String[]> param : parameterMap.entrySet()) {
                    String value = Arrays.toString(param.getValue()).replaceAll("\\[|\\]", "")
                            .replaceAll("\\s", ",");
                    paramValues[i] = caseStringValue(value, parameterTypes[i]);
                    i++;
                }

                Future<Object> future = executorService.submit(new Callable<Object>() {
                    @Override
                    public Object call() throws Exception {
                        return method.invoke(bean,paramValues);
                    }
                });
                Object returnValue = null;
                try {
                    returnValue = future.get(timeout, TimeUnit.MILLISECONDS);
                } catch (TimeoutException e) {
                    if (StringUtils.hasText(fallback)) {
                        returnValue = invokeFallbackMethod(handlerMethod, fallback,paramValues);
                    }else{
                        returnValue="server is busy";
                    }

                }
                response.getWriter().write(String.valueOf(returnValue));
                return false;
            }
        }
        return false;
    }

    private Object invokeFallbackMethod(HandlerMethod handlerMethod, String fallback, Object[] paramValues) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Object bean = handlerMethod.getBean();
        //fallback方法签名要和原方法保持一致（参数类型和个数相同）
        MethodParameter[] methodParameters = handlerMethod.getMethodParameters();
        Class[] parameterTypes = Stream.of(methodParameters).map(MethodParameter::getParameterType)
                .toArray(Class[]::new);
        Method method = bean.getClass().getMethod(fallback, parameterTypes);
        return method.invoke(bean,paramValues);
    }

    private Object caseStringValue(String value, Class<?> parameterType) {
        if (Integer.class == parameterType) {
            return Integer.valueOf(value);
        } else if (Double.class == parameterType) {
            return Double.valueOf(value);
        } else if (String.class == parameterType) {
            return String.valueOf(value);
        } else {
            if (value != null) {
                return value;
            } else {
                return null;
            }
        }
    }
}

sayLevelTimeout()

 /**
     * 高级版本
     *
     * @param message
     * @return
     * @throws Exception
     */
    @Timeout(timeout = 150,fallback = "errorContent")
    @GetMapping("/sayLevelTimeout")
    public String sayLevelTimeout(@RequestParam("message") String message) throws Exception {
        return await(message);
    }

    public String errorContent(String message) {
        return "Fault";
    }

测试

浏览器输入

http://127.0.0.1:8080/sayLevelTimeout?message=xwf

高级版本

此版本测试必须要注释调用中级版本，会互相影响

  1. 将中级版本中的拦截方式修改为AOP拦截即可
  2. 信号量使用JUC中的semaphore实现

spring Aop + 自定义注解 + 超时时间和信号量两种方式

  • 超时时间

    • 切换线程Future

  • 信号量

    • 不切换线程，阻塞线程

@GPHystrixCommand注解

import com.netflix.hystrix.contrib.javanica.annotation.HystrixException;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import com.netflix.hystrix.contrib.javanica.annotation.ObservableExecutionMode;

import java.lang.annotation.*;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface GPHystrixCommand {
    int timeout() default 0;

    int semaphore() default 0;//信号量

    String fallback() default "";
}

AOP切面类

package com.huajie.spring.cloud.server.aspect;

import com.huajie.spring.cloud.server.annotation.GPHystrixCommand;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;
import java.lang.reflect.Method;
import java.util.concurrent.*;

@Component
@Aspect
public class HystrixAnnotationAuthorizingAspect {

    private ExecutorService executorService = Executors.newFixedThreadPool(20);
    private Semaphore semaphore = null;

    @Pointcut("@annotation(com.huajie.spring.cloud.server.annotation.GPHystrixCommand)")
    void anyRPCAnnotatedMethodCall() {
    }

    @Around("anyRPCAnnotatedMethodCall()")
    public Object executeAnnotatedMethod(ProceedingJoinPoint aJoinPoint) throws Throwable {
        BeforeAdviceMethodInvocationAdapter mi = BeforeAdviceMethodInvocationAdapter.createFrom(aJoinPoint);
        Method method = mi.getMethod();
        Object[] args = mi.getArguments();
        Object res = null;
        if (method.isAnnotationPresent(GPHystrixCommand.class)) {
            GPHystrixCommand annotation = method.getAnnotation(GPHystrixCommand.class);
            int timeout = annotation.timeout();
            int semaphoreValue = annotation.semaphore();
            String fallback = annotation.fallback();
            if (0 == timeout && 0 == semaphoreValue || 0 != timeout) {
                Future<Object> future = executorService.submit(() -> {
                    Object returnValue = null;
                    try {
                        returnValue = aJoinPoint.proceed(args);
                    } catch (Throwable throwable) {
                        throw new Exception(throwable);
                    }
                    return returnValue;
                });
                //100毫秒超时时间
                try {
                    res = future.get(timeout, TimeUnit.MILLISECONDS);
                } catch (InterruptedException | TimeoutException e) {
                    future.cancel(true);
                    res = invokeFallbackMethod(method, aJoinPoint.getTarget(), fallback, args);
                }
            }
            if (0 != semaphoreValue) {
                if (semaphore == null) {
                    semaphore = new Semaphore(semaphoreValue);
                }
                try {
                    semaphore.acquire();
                    res = aJoinPoint.proceed(args);
                } finally {
                    semaphore.release();
                }
            }
            return res;
        }
        return null;
    }

    private Object invokeFallbackMethod(Method method, Object bean, String fallback, Object[] arguments) throws Exception {
        // 查找 fallback 方法
        Method fallbackMethod = findFallbackMethod(method, bean, fallback);
        return fallbackMethod.invoke(bean, arguments);
    }

    private Method findFallbackMethod(Method method, Object bean, String fallbackMethodName) throws
            NoSuchMethodException {
        // 通过被拦截方法的参数类型列表结合方法名，从同一类中找到 fallback 方法
        Class beanClass = bean.getClass();
        Method fallbackMethod = beanClass.getMethod(fallbackMethodName, method.getParameterTypes());
        return fallbackMethod;
    }

    @PreDestroy
    private void destroy() {
        executorService.shutdown();
    }
}

调用方法

 /**
     * 高级版本超时时间
     *
     * @param message
     * @return
     * @throws Exception
     */
    @GPHystrixCommand(timeout = 150,fallback = "errorContent")
    @GetMapping("/sayLevel3")
    public String sayLevel3(@RequestParam("message") String message) throws Exception {
        return await(message);
    }

    /**
     * 高级版本信号量
     *
     * @param message
     * @return
     * @throws Exception
     */
    @GPHystrixCommand(semaphore = 5)
    @GetMapping("/sayLevel4")
    public String sayLevel4(@RequestParam("message") String message) throws Exception {
        return await(message);
    }

    public String errorContent(String message) {
        return "Fault";
    }

完整版本

其他类

BeforeAdviceMethodInvocationAdapter

Aop封装工具类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.AdviceSignature;
import org.aspectj.lang.reflect.MethodSignature;

import java.lang.reflect.Method;

public class BeforeAdviceMethodInvocationAdapter implements MethodInvocation {

    private Object _object;
    private Method _method;
    private Object[] _arguments;

    public static BeforeAdviceMethodInvocationAdapter createFrom(JoinPoint aJoinPoint) {
        if (aJoinPoint.getSignature() instanceof MethodSignature) {
            return new BeforeAdviceMethodInvocationAdapter(aJoinPoint.getThis(),
                    ((MethodSignature) aJoinPoint.getSignature()).getMethod(),
                    aJoinPoint.getArgs());

        } else if (aJoinPoint.getSignature() instanceof AdviceSignature) {
            return new BeforeAdviceMethodInvocationAdapter(aJoinPoint.getThis(),
                    ((AdviceSignature) aJoinPoint.getSignature()).getAdvice(),
                    aJoinPoint.getArgs());

        } else {
            throw new IllegalArgumentException("The joint point signature is invalid: expected a MethodSignature or an AdviceSignature but was " + aJoinPoint.getSignature());
        }
    }

    public BeforeAdviceMethodInvocationAdapter(Object anObject, Method aMethod, Object[] someArguments) {
        _object = anObject;
        _method = aMethod;
        _arguments = someArguments;
    }

    public Object[] getArguments() {
        return _arguments;
    }

    public Method getMethod() {
        return _method;
    }

    public Object proceed() throws Throwable {
        return null;
    }

    public Object getThis() {
        return _object;
    }
}
MethodInvocation

Aop工具接口类

import java.lang.reflect.Method;

public interface MethodInvocation {

    Object proceed() throws Throwable;

    Method getMethod();

    Object[] getArguments();

    Object getThis();

}
ServerController

controller层测试类

package com.huajie.spring.cloud.server.controller;

import com.huajie.spring.cloud.server.annotation.GPHystrixCommand;
import com.huajie.spring.cloud.server.annotation.Timeout;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;
import java.util.concurrent.*;

@RestController
public class ServerController {

    private final Environment environment;

    private final static Random random = new Random();

    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    public ServerController(Environment environment) {
        this.environment = environment;
    }

    public String getPort() {
        return environment.getProperty("local.server.port");
    }

    @HystrixCommand(
            fallbackMethod = "errorContent",
            commandProperties = {
                    @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",
                            value = "100")
            }
    )
    @GetMapping("/say")
    public String say(@RequestParam("message") String message) throws InterruptedException {
        int value = random.nextInt(200);
        System.out.println("say() cost " + value + "ms");
        Thread.sleep(value);
        System.out.println("port:" + getPort() + ",接收到消息-say:" + message);
        return "port:" + getPort() + ",Hello," + message;
    }

    /**
     * 简易版本
     *
     * @param message
     * @return
     * @throws InterruptedException
     */
    @GetMapping("/sayLevel1")
    public String sayLevel1(@RequestParam("message") String message) throws Exception {
        Future<String> future = executorService.submit(() -> {
            return await(message);
        });
        String res = null;
        //100毫秒超时时间
        try {
            res = future.get(100, TimeUnit.MILLISECONDS);
        } catch (InterruptedException | TimeoutException e) {
            return errorContent(message);
        }
        return res;
    }

    private String await(String message) throws InterruptedException {
        int value = random.nextInt(200);
        System.out.println("say() cost " + value + "ms");
        Thread.sleep(value);
        System.out.println("port:" + getPort() + ",接收到消息-say:" + message);
        return "port:" + getPort() + ",Hello," + message;
    }

    /**
     * 中级版本
     *
     * @param message
     * @return
     * @throws Exception
     */
    @GetMapping("/sayLevel2")
    public String sayLevel2(@RequestParam("message") String message) throws Exception {
        Future<String> future = executorService.submit(() -> {
            return await(message);
        });
        String res = null;
        try {
            res = future.get(100, TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            future.cancel(true);
            throw e;
        }
        return res;
    }

    /**
     * 高级版本
     *
     * @param message
     * @return
     * @throws Exception
     */
    @Timeout(timeout = 150,fallback = "errorContent")
    @GetMapping("/sayLevelTimeout")
    public String sayLevelTimeout(@RequestParam("message") String message) throws Exception {
        return await(message);
    }

    /**
     * 高级版本
     *
     * @param message
     * @return
     * @throws Exception
     */
    @GPHystrixCommand(timeout = 150,fallback = "errorContent")
    @GetMapping("/sayLevel3")
    public String sayLevel3(@RequestParam("message") String message) throws Exception {
        return await(message);
    }

    /**
     * 高级版本
     *
     * @param message
     * @return
     * @throws Exception
     */
    @GPHystrixCommand(semaphore = 5)
    @GetMapping("/sayLevel4")
    public String sayLevel4(@RequestParam("message") String message) throws Exception {
        return await(message);
    }

    public String errorContent(String message) {
        return "Fault";
    }

}

感谢

不懂的浪漫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java熔断器_一种熔断器的实现方法与流程
weixin_36435325的博客
02-25 2099
本发明涉及java开发技术领域，特别涉及一种熔断器的实现方法。背景技术：目前，在微服务架构中，为了方便系统的前期的开发以及后期升级、维护，提交工作效率，一般会将系统划分为多个服务单元。各个服务单元通过服务注册以及订阅的方式互相依赖。同时，在各个服务单元中，会出现服务间互相调用的情况。这就有可能因为网络问题或所依赖的服务单元自身故障造成调用失败。如果此时系统出现大量调用已出现故障的服务单元，最后会因...
手写Hystrix断路器 (个人理解)
小趴菜的小蛋泡
07-18 59
首先理解断路器的三种状态，分为关闭，开放，半开 正常情况下，在远程调用时，如果出现调用失败的情况下，会打开断路器
手写一个简易版断路器(hystrix)
念念不忘，必有回响
06-27 576
理论基础 根据熔断器模式(Circuit Breaker Pattern) 共有上面几种状态 Closed:默认状态，Circuit Breaker 内部维护着最近的失败次数(failure count)。每操作失败一次，失败次数就会加一。当失败次数达到设定的阈值，就会进入Open状态 Open: 操作不会执行，会立即失败。Circuit Breaker 内部维护一个计时器。当时间达到设定的阈值，就会从Open状态进入到Half-Open状态 Half-Open: 只要操作失败一次，立即进入Open状
用 100 行代码手写一个 Hystrix
小眼睛的博客
07-01 510
熔断与降级 离小眼睛家不远的地方，开了一个熟食店。店内有两个窗口总能排起长龙，一个窗口是选好的凉菜让师傅调味，一个窗口是买到的扒鸡让胖师傅现场脱骨。顾客的正常的流程，大致是这个样子滴： 炎炎夏日，邀三五好友，喝杯啤酒吹吹牛皮，岂不美哉。可能大家跟小眼睛想法一致，小店的生意日渐火爆。这天，小眼睛选好了菜，付了钱，正准备排队让师傅调口味、脱骨。目测两个窗口排队时间不会少于 20 分钟，加之几个朋友轮番催促，果断放弃，拎着菜直接回家。于是我到流程就变成了： 当下游的服务（调料...
简单的熔断 java实现 CircuitBreaker
qq_39093570的博客
12-10 2553
简单的熔断 java实现 CircuitBreaker 接口 熔断 严格来说应该间隔一定时间后在开放请求 参考第三个熔断 public interface CircuitBreaker { T execute(); } 基于qps的熔断 即单位时间请求数不能超过阈值 否则熔断 返回默认的failback方法 package com.multiplyzero.mz.core.rpc; impor...
SpringCloud之熔断监控Hystrix Dashboard的实现
08-25
主要介绍了SpringCloud之熔断监控Hystrix Dashboard的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spring cloud gateway配置Hystrix 熔断、限流、后台调用注意点.pdf
11-18
spring cloud
springcloud 熔断监控Hystrix Dashboard和Turbine
08-25
主要介绍了springcloud 熔断监控Hystrix Dashboard和Turbine，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
SpringCloud Hystrix服务熔断.docx
最新发布
11-10
SpringCloud Hystrix服务熔断
SpringCloud微服务之Hystrix组件实现服务熔断的方法
08-25
微服务架构特点就是多服务，多数据源，支撑系统应用。这样导致微服务之间存在依赖关系。这篇文章主要介绍了SpringCloud微服务之Hystrix组件实现服务熔断的方法,需要的朋友可以参考下
Java RPC框架熔断降级机制原理解析
08-24
主要介绍了Java RPC框架熔断降级机制原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
手写SpringBoot框架
02-16
阅读SpringBoot底层源码，手写类SpringBoot框架，并附控制层，视图层路径的测试。
熔断器Hystrix实战
08-31
熔断器Hystrix实战的一些demo代码，想要入门的话，就下载下来看看
高级JAVA - 手写简单的重试组件学习Spring Retry
BlueKitty的博客
07-18 689
目录 一 . 定义注解 二 . 利用cglib代理扩展重试业务 三 . 编写代理类 , 使用自定义的XRetryInterceptor作为拦截器 四 . 编写相关业务方法 , 测试代码 五 . 测试结果 之前讲了Spring Retry的用法及配置 , 这次通过手写一个简单的组件来学习Spring Retry的实现 . 源代码 :https://download.csdn.ne...
业务学习 -- 高并发系统保护之限流和降级熔断
井底之蛙
06-16 4067
限流是我们在业务开发中经常遇到的问题 1、请求入口限流（Nginx 限流，Tomcat 线程池及等待队列设置，限流算法（漏桶算法，令牌桶算法，计数器算法）） 2、接口调用限流（Spring Cloud Hystrix（线程池/信号量） 和 Sentinel（信号量）） 3、基于削峰填谷流量整理（kafka、RocketMQ和RabbitMQ） https://juejin.im/post/5b3a...
熔断机制hystrix
热门推荐
smillest的专栏
06-12 1万+
熔断机制hystrix一、问题产生雪崩效应：是一种因服务提供者的不可用导致服务调用者的不可用,并将不可用逐渐放大的过程  正常情况下的服务：某一服务出现异常，拖垮整个服务链路，消耗整个线程队列，造成服务不可用，资源耗尽：         形成过程：           1）服务提供者不可用                                 a）硬件故障：硬件损坏造成的服务器主机宕机,...
手动实现服务熔断功能
希望我的博客，能解决你工作中的问题
07-13 1274
在我们分布式系统中， 经常会用用到 Hystrix 、Resilience4j 等主流服务熔断器，平时使用得非常熟悉，但是否有想过，自己手动实现一个，熔断器呢 ？今天我们就以前来基于Spring AOP实现一个服务熔断器。 一、熔断器概念 在断路器对象中封装受保护的⽅法调⽤； 该对象监控调⽤和断路情况； 调⽤失败触发阈值后，后续调⽤直接由断路器返回错误，不再执⾏实际调⽤； 下图为熔断器的工作原...
SpringCloud——Hystrix（手写断路器思路、测试与优化）
YiRenGengShangBuQi的博客
08-08 343
启动类中给RestTemplate加入Bean容器。在Controller中添加切点注解@MyAnno。在切面中将方法以注解的形式添加到切点注解中。左边出现一个圈说明已经添加。对断路器模型代码进行优化。
17.hystrix手写断路器：线程池，切面，面向对象（springcloud）
weixin_59334478的博客
11-12 231
关：服务正常调用 A---》B 开：在一段时间内，调用失败当20s后，将拦截器设置成半开半关状态，此时有一部分数据尝试访问该服务，如果还是不能访问，则再次设置为拦截器开启状态。第一次判断发现该服务无法使用，直接把拦截器设置成打开状态，这个时间窗口（20s）内访问该服务，都直接不会访问。半开半关状态下，当为随机取值为1时会尝试访问服务查看其是否恢复正常，为其他数时不访问服务。1.创建项目，导入依赖。2.创建拦截器状态类。3.创建拦截器模型类。4.创建拦截器注解类。5.创建拦截器切面类。6.创建拦截器控制类。
springcloud hystrix 熔断 降级 区别
09-07
Spring Cloud Hystrix是一个开源的熔断器框架，它能够帮助开发者有效地处理服务依赖中的延迟和故障。熔断器的主要目的是在出现故障时提供一种优雅的降级机制，以避免整个系统的崩溃。 熔断和降级是Hystrix中两个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值