spring 实现重试日志，重发同步请求

最新推荐文章于 2023-11-24 16:32:35 发布
最新推荐文章于 2023-11-24 16:32:35 发布
阅读量697 收藏 2
点赞数
分类专栏： spring学习 文章标签： spring boot 设计模式 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33071429/article/details/121377848
版权

1. 设计目的

         公司系统与第三方同步接口调用频繁出错，因此业务提出需求，需要在本系统中第三方调用失败的接口，能够看到重试日志，错误原因，当错误原因解决后，能够发起重试请求，对第三方接口调用失败的请求进行重发。

2. 技术实现方案

 

 

       首先， 通过spring 切面拦截到第三方请求，获取到请求头部、请求参数、请求体等相关请求信息，生成一张同步请求日志表，将这些请求数据放入到数据库表中，然后运行定时任务，定时扫描

同步请求日志表，获取到同步失败的数据，将失败的数据放入到同步重试日志表中，前端获取到这些同步失败的数据，将数据中包含的请求方式、请求头、请求参数、请求体进行封装，点击重试按钮，将封装的请求进行重新调用，后端再将重新调用的返回结果更新重试日志表中。

      注意： 前端重发的请求将会重新携带以下两个参数，retry 标识是重试请求， businessId  标识重试的是那条数据，这样做的目的是重试请求返回结果会更改重试日志表的返回结果，同时重试请求不会再进入同步日志表，将两张表的功能区分开来。

     扩展： 目前数据量不大，先使用数据库做存储，如果以后数据量大了，可以把数据库替换为mongdb 或者 es，对代码侵入性也不强，比较方便扩展。

3. 代码实现细节

3.1 请求拦截切面类 SyncLogAspect

/**
 * @author tuwenbin@newhope.cn
 * @Title: SyncLogAspect
 * @Description: 拦截同步请求, 记录同步日志
 * @date 2021/11/8 17:50
 */
@Aspect
@Component
@Slf4j
@Order(1)
public class SyncLogAspect {

    @Autowired
    private PluginSyncLogService syncLogService;
    @Autowired
    private PluginRetryLogService retryLogService;
    @Autowired
    private PluginApiService pluginApiService;

    @Pointcut("@annotation(GenerateSyncLog)|| @within(GenerateSyncLog)")
    public void syncLogPointcut() {
    }

    @Around("syncLogPointcut()")
    public Object doGenerateSyncLog(ProceedingJoinPoint joinPoint) throws Throwable {

        // 获取HttpServletRequest
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        String requestURL= request.getRequestURI();
        //获取url格式 /plugin-api/api-boh-v1/pushMaterialInfo
        String[] urlArrays = requestURL.split(PluginConstant.SPLIT_INCLINED_ROD);
        if(urlArrays.length >= PluginConstant.URL_LENGTH){
            String pluginName = urlArrays[2];
            String method = urlArrays[3];

            if(LogConfigEnum.containMethod(pluginName, method)){
                //判断是否是重试请求, 如果是重试请求, 直接将请求放在重试日志表中
                String retry = request.getParameter(PluginConstant.REQUEST_RETRY);
                String businessId = request.getParameter(PluginConstant.REQUEST_BUSINESSID);

                PluginSyncLog syncLog = new PluginSyncLog();
                if(!PluginConstant.RETRY_FLAG.equals(retry)){
                    syncLog = buildSyncLog(request, pluginName, method);
                }

                Object proceed = joinPoint.proceed();

                if(PluginConstant.RETRY_FLAG.equals(retry)){
                    updateRetryLog(pluginName, method, proceed, businessId);
                }else {
                    String syncStatus = getSyncStatus(proceed, pluginName, method);
                    syncLog.setStatus(syncStatus);
                    syncLog.setResponseData(JSONObject.toJSONString(proceed));
                    syncLogService.save(syncLog);
                }
                return proceed;
            }
        }

        return joinPoint.proceed();
    }

    /**
     * 更新重试日志
     * @param pluginName
     * @param method
     * @param proceed
     * @param businessId
     */
    private void updateRetryLog(String pluginName, String method, Object proceed, String businessId) {
        PluginRetryLog retryLog = retryLogService.getById(Long.valueOf(businessId));
        if(Objects.nonNull(retryLog)){
            LogHandler logHandler = RetryLogStrategyFactory.getLogHandler(pluginName, method);
            RetryResult retryResult = logHandler.methodExecute(proceed);
            retryLog.setRetryStatus(retryResult.getRetryStatus());
            retryLog.setFailureReason(retryResult.getFailureReason());
            retryLogService.saveOrUpdate(retryLog);
        }
    }

    /**
     * 获取同步状态, 返回结果list中有未成功的，记录同步标识为失败
     * @param result
     * @param pluginName
     * @param method
     */
    private String getSyncStatus(Object result, String pluginName, String method) {
        LogHandler logHandler = RetryLogStrategyFactory.getLogHandler(pluginName, method);
        if(Objects.isNull(logHandler)){
            throw new BizException("未配置对应的日志处理器");
        }
        String syncStatus = logHandler.getSyncStatus(result);
        return syncStatus;
    }

    private PluginSyncLog buildSyncLog(HttpServletRequest request, String pluginName, String method) {
        PluginSyncLog syncLog = new PluginSyncLog();

        syncLog.setRequestUrl(request.getRequestURI());
        syncLog.setRequestHeader(JSONArray.toJSONString(getHeadersInfo(request)));
        syncLog.setRequestMethod(request.getMethod());
        syncLog.setRequestParams(request.getQueryString());

        LogConfigEnum configEnum = LogConfigEnum.valueOf(pluginName, method);
        syncLog.setDataSource(configEnum.getDataSource().getSource());
        syncLog.setDataTarget(configEnum.getDataTarget());
        syncLog.setDataType(configEnum.getDataType().getType());
        String body = ((RequestWrapper) request).getBody();

        syncLog.setSyncTime(LocalDateTime.now());
        syncLog.setRequestBody(body);
        //设置推送目的地
        PushTargetVo pushTargetVo = pluginApiService.getTenantIdAndOrgId(request, pluginName, syncLog.getDataSource());
        syncLog.setTenantId(pushTargetVo.getTenantId());
        syncLog.setOrgId(pushTargetVo.getOrgId());
        return syncLog;
    }

    private Map<String, String> getHeadersInfo(HttpServletRequest request) {
        Map<String, String> map = new HashMap<>();
        Enumeration headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String key = (String) headerNames.nextElement();
            String value = request.getHeader(key);
            map.put(key, value);
        }
        return map;
    }

}

3.2 定时任务扫描 GenerateRetryLogJob

@Component
@Slf4j
public class GenerateRetryLogJob {

    @Autowired
    private PluginSyncLogService syncLogService;
    @Autowired
    private PluginRetryLogService retryLogService;


    /**
     * 生成重试错误日志, 每5分钟执行一次
     */
    @Scheduled(cron = "0 */1 * * * ?")
    public void generateRetryLog() {
        String date = DateUtils.getDate();
        LocalDateTime now = LocalDateTime.now();
        String lastWeek = DateUtils.formatDate(now.minusDays(7), null);

        List<PluginRetryLog> retryLogList = new ArrayList<>();

        List<PluginSyncLogVo> failSyncLogList = syncLogService.findFailSyncLogList(lastWeek, date);
        if(!CollectionUtils.isEmpty(failSyncLogList)){
            failSyncLogList.forEach(logVo -> {
                String dataSource = logVo.getDataSource();
                String dataType = logVo.getDataType();
                String responseData = logVo.getResponseData();

                LogConfigEnum logConfigEnum = LogConfigEnum.configEnumOf(dataSource, dataType);
                LogHandler logHandler = RetryLogStrategyFactory.getLogHandler(logConfigEnum.getPluginName(), logConfigEnum.getMethod());

                //获取到失败的业务code集合
                Map<String, ResultData> failMap = logHandler.getFailMap(responseData);
                List<PluginRetryLog> retryLogs = logHandler.parseRequestBody(logVo, failMap, responseData);

                retryLogList.addAll(retryLogs);
            });
        }

        if(!CollectionUtils.isEmpty(retryLogList)){
            retryLogService.saveBatch(retryLogList);
        }

        if(!CollectionUtils.isEmpty(failSyncLogList)){
            List<PluginSyncLog> syncLogs = new ArrayList<>();
            failSyncLogList.forEach(failSyncLog ->{
                PluginSyncLog syncLog = syncLogService.getById(failSyncLog.getId());
                syncLog.setRetryFlag(PluginConstant.RETRY_FLAG_TRUE);
                syncLogs.add(syncLog);
            });

            syncLogService.saveOrUpdateBatch(syncLogs);
        }
    }


}

3.3 日志处理器 LogHandler

       在系统与第三方请求对接中，第三方有多个，且由不同的人员对接开发完成，没有设计统一的请求与响应对象，为了对这种情况进行兼容，设计了日志处理器 LogHandler，运用工厂模式与策略模式，实现了对不同的第三方，不同的请求url，可以实现自己的日志处理器，进行灵活的数据处理。

       同时当调用某个接口批量传输数据，数据可能有的成功，有的失败，且数据的失败原因不一样，为了兼容这种情况，运用处理器可以对数据进行拆分，拆分为单条，放入到重试日志表中，进行重试。

/**
 * @author tuwenbin@newhope.cn
 * @Title: Loghandler
 * @Description: 日志处理器
 * <R>  R 返回类型
 * @date 2021/11/11 11:03
 */
public interface LogHandler<R> {


    /**
     * 获取数据同步状态
     * @param result
     * @return
     */
    String getSyncStatus(R result);

    /**
     * 判断是否全局错误
     * @param responseData
     * @return
     */
    boolean isGlobalError(String responseData);

    /**
     * 解析生成重试方法执行结果
     * @param result
     * @return
     */
    RetryResult methodExecute(R result);

    /**
     * 获取到失败集合
     * @param responseData 相应内容
     * @return
     */
    Map<String, ResultData> getFailMap(String responseData);

    /**
     * 解析请求数据, 构建重试日志集合
     * @param logVo 失败数据
     * @param failMap 失败集合
     * @param responseData 相应数据
     * @return
     */
    List<PluginRetryLog> parseRequestBody(PluginSyncLogVo logVo, Map<String, ResultData> failMap, String responseData);

处理器工厂类

public class RetryLogStrategyFactory {

    private static Map<LogConfigEnum, LogHandler> logHandlerMap = new HashMap<>();

    static {
        logHandlerMap.put(LogConfigEnum.YX_PUSH_ORDER, new YxOrderLogHandler());
        logHandlerMap.put(LogConfigEnum.YX_PUSH_MATERIAL, new YxMaterialLogHandler());
        logHandlerMap.put(LogConfigEnum.YX_PUSH_STORE, new YxStoreLogHandler());
        logHandlerMap.put(LogConfigEnum.WG_PUSH_ORDER, new WgLogHandler());
        logHandlerMap.put(LogConfigEnum.WG_PUSH_MATERIAL, new WgLogHandler());
    }


    /**
     * 获取日志处理器
     * @param pluginName 插件名称
     * @param method 调用方法
     * @return
     */
    public static LogHandler getLogHandler(String pluginName, String method){
        LogConfigEnum configEnum = LogConfigEnum.valueOf(pluginName, method);
        LogHandler logHandler = logHandlerMap.get(configEnum);
        return logHandler;
    }
}

4. 扩展示例

4.1 新增配置项

       当我们新增一个第三方接口调用来源时， 在枚举类  DataSourceEnum 类中新增一个来源

     当我们新增一个请求时，在 LogConfigEnum 中新增一个请求类型、请求配置项，设置好对应的请求 uri。

 

 4.2 新增日志处理器

        可以对这个请求来源先实现一个公共的请求处理，实现一些公共的方法。

/**
 * @author tuwenbin@newhope.cn
 * @Title: YxLogHandler
 * @Description: yx 调用处理
 * @date 2021/11/12 10:01
 */
public class YxLogHandler implements LogHandler<YunXianRespResult>{


    @Override
    public String getSyncStatus(YunXianRespResult result) {
        String status = PluginConstant.SUCCESS_CODE;

        if(!PluginConstant.SUCCESS_CODE.equals(result.getCode())){
            status = PluginConstant.FAIL_CODE;
        }

        List<ResultData> dataList = result.getData();
        if(!CollectionUtils.isEmpty(dataList)){
            for(ResultData data : dataList){
                String code = data.getCode();
                if(!PluginConstant.SUCCESS_CODE.equals(code)){
                    status = PluginConstant.FAIL_CODE;
                }
            }
        }

        return status;
    }

    @Override
    public boolean isGlobalError(String responseData) {
        YunXianRespResult result = JSONObject.parseObject(responseData, YunXianRespResult.class);
        return !PluginConstant.SUCCESS_CODE.equals(result.getCode());
    }

    @Override
    public RetryResult methodExecute(YunXianRespResult result) {
        RetryResult retryResult = new RetryResult();

        Integer retryStatus = RetryStatusEnum.FAIL.getStatus();
        List<ResultData> dataList = result.getData();
        if(!CollectionUtils.isEmpty(dataList)){
            //数据会被拆分，只有一条数据
            ResultData resultData = dataList.get(0);
            if(PluginConstant.SUCCESS_CODE.equals(resultData.getCode())){
                retryStatus = RetryStatusEnum.SUCCESS.getStatus();
            }else {
                retryResult.setFailureReason(resultData.getErrorMsg());
            }
            retryResult.setBusinessCode(resultData.getBusinessCode());
        }else {
            String code = result.getCode();
            if(PluginConstant.SUCCESS_CODE.equals(code)){
                retryStatus = RetryStatusEnum.SUCCESS.getStatus();
            }
            retryResult.setFailureReason(result.getErrorMsg());
        }

        retryResult.setRetryStatus(retryStatus);
        return retryResult;
    }

    @Override
    public Map<String, ResultData> getFailMap(String responseData) {
        Map<String, ResultData> failMap = new HashMap<>(16);

        YunXianRespResult respResult = JSONObject.parseObject(responseData, YunXianRespResult.class);

        List<ResultData> dataList = JSONArray.parseArray(JSONArray.toJSONString(respResult.getData()), ResultData.class);
        if(!CollectionUtils.isEmpty(dataList)){
            dataList.forEach(data -> {
                String code = data.getCode();
                if(!PluginConstant.SUCCESS_CODE.equals(code)){
                    failMap.put(data.getBusinessCode(), data);
                }
            });
        }

        return failMap;
    }

    @Override
    public List<PluginRetryLog> parseRequestBody(PluginSyncLogVo logVo, Map<String, ResultData> failMap, String responseData) {
        return null;
    }


}

     然后对每个请求需求额外处理，不一样的，再实现单独的请求处理器。

 

public class YxMaterialLogHandler extends YxLogHandler {

    @Override
    public List<PluginRetryLog> parseRequestBody(PluginSyncLogVo logVo, Map<String, ResultData> failMap, String responseData) {
        List<PluginRetryLog> retryLogList = new ArrayList<>();

        List<PushMaterialInfoReq> reqList = JSONArray.parseArray(logVo.getRequestBody(), PushMaterialInfoReq.class);
        if(this.isGlobalError(responseData)){
            YunXianRespResult result = JSONObject.parseObject(responseData, YunXianRespResult.class);
            PluginRetryLog retryLog = PluginUtil.buildGlobalRetryLog(logVo, result.getErrorMsg());
            retryLogList.add(retryLog);

        }else {
            if(!CollectionUtils.isEmpty(reqList)){
                reqList.forEach(req -> {
                    String goodCode = req.getMerchandiseCode();
                    if(failMap.containsKey(goodCode)){
                        List<PushMaterialInfoReq> requestList = new ArrayList<>();
                        requestList.add(req);
                        ResultData failData = failMap.get(goodCode);

                        PluginRetryLog retryLog = PluginUtil.buildRetryLog(logVo, failData);
                        retryLog.setRequestBody(JSONArray.toJSONString(requestList));
                        retryLogList.add(retryLog);
                    }
                });
            }

        }
        return retryLogList;
    }

}
public class YxOrderLogHandler extends YxLogHandler{

    @Override
    public List<PluginRetryLog> parseRequestBody(PluginSyncLogVo logVo, Map<String, ResultData> failMap, String responseData) {
        List<PluginRetryLog> retryLogList = new ArrayList<>();

        List<PushOrderInfoReq> reqList = JSONArray.parseArray(logVo.getRequestBody(), PushOrderInfoReq.class);
        if(this.isGlobalError(responseData)){
            YunXianRespResult result = JSONObject.parseObject(responseData, YunXianRespResult.class);
            PluginRetryLog retryLog = PluginUtil.buildGlobalRetryLog(logVo, result.getErrorMsg());
            retryLogList.add(retryLog);

        }else {
            if(!CollectionUtils.isEmpty(reqList)){
                reqList.forEach(req -> {
                    String orderCode = req.getOrderCode();
                    if(failMap.containsKey(orderCode)){
                        List<PushOrderInfoReq> requestList = new ArrayList<>();
                        requestList.add(req);
                        ResultData failData = failMap.get(orderCode);

                        PluginRetryLog retryLog = PluginUtil.buildRetryLog(logVo, failData);
                        retryLog.setRequestBody(JSONArray.toJSONString(requestList));
                        retryLogList.add(retryLog);
                    }
                });
            }

        }

        return retryLogList;
    }
}

4.3 重试请求关闭签名校验

 

qq_33071429
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
异常日志的自动重试，根据数据库记录的异常信息模拟用户当时操作对接口重新调用
yaoyipeng的博客
04-26 476
RequestUtil类代码如下，之所以在请求头中加上EXCEPTION_LOG_TOKEN变量，是为了区分请求的是否是异常日志执行调用的接口，方便后期扩展，请求头中key为EXCEPTION_LOG_TOKEN变量的值你可以记录其他信息，比如用户当时操作的ip和用户当时的操作时间，如果根据异常信息执行调用接口的话，记录的ip是本地ip，而非用户ip，记录的时间也是你执行异常信息时的时间，而非用户当时的操作时间。此方法就是将那些异常信息模仿用户操作重新执行，然后返回执行成功的id。
从定时任务-到任务调度系统xxl-job
weixin_44248755的博客
07-23 1431
定时任务的今生前世以及xxl-job调度系统
Spring Retry重试失败日志打印-@Recover以及邮件通知
fz13768884254的博客
10-19 4528
重试机制配置介绍： 当重达到设定阀值时，还没有成功，那么就需要对日志进行统一打印，发出报警邮件，以便手动补偿或者感知异常。   @Recover  当重试到达指定次数时，被注解的方法将被回调，可以在该方法中进行日志处理。需要注意的是发生的异常和入参类型一致时才会回调。   在Retry标识的方法类中，加入以下方法： @Recover public void recover(...
Spring-retry优雅重试
weixin_45623983的博客
05-05 1023
你好呀，我是歪歪。 前几天我 Review 代码的时候发现项目里面有一坨逻辑写的非常的不好，一眼望去简直就是丑陋之极。 我都不知道为什么会有这样的代码存在项目里面，于是我看了一眼提交记录准备叫对应的同事问问，为什么会写出这样的代码。 然后... 那一坨代码是我 2019 年的时候提交的。 我细细的思考了一下，当时好像由于对项目不熟悉，然后其他的项目里面又有一个类似的功能，我就直接 CV 大法搞过来了，里面的逻辑也没细看。 嗯，原来是历史原因，可以理解，可以理解。 代码里面主要就是一大坨重试
数据同步异常重试机制（Java）
最新发布
Odinpeng的博客
11-24 1800
数据同步重试机制：数据同步异常处理。MySQL数据同步到ElasticSearch，出现异常时，使用数据同步重试方法
springboot基于spring-retry实现重试机制
03-15
本文将详细探讨如何在 Spring Boot 应用中基于 Spring Retry 实现重试机制，以及如何将其应用于支付回调和自定义重试场景。 首先，让我们了解 Spring Retry 的核心概念。Spring Retry 提供了一个 `@Retryable` 注解...
Spring Cloud Gateway重试机制的实现
08-26
Spring Cloud Gateway重试机制的实现 Spring Cloud Gateway重试机制是指在调用Http接口时，遇到失败的情况下，通过重试的方式重新请求接口，以提高系统的可靠性和稳定性。重试机制在生活中也有很多类似的事例，例如...
Spring Cloud 请求重试机制核心代码分析
08-27
首先，Spring Cloud 请求重试机制是基于 Ribbon 和 Hystrix 两个组件实现的。Ribbon 是一个负载均衡器，它可以将请求分配到多个服务器上，而 Hystrix 则是一个断路器，它可以在服务调用失败时提供 fallback 处理。 ...
SpringCloud重试机制配置详解
08-27
SpringCloud重试机制配置详解 在微服务架构中，重试机制是非常重要的组件之一，它可以帮助我们处理远程调用过程中的异常和超时问题。在SpringCloud中，我们可以通过不同的方式来配置重试机制，今天我们就来详细地...
Spring Cloud Gateway重试机制原理解析
08-18
RetryGatewayFilter Factory是Spring Cloud Gateway对请求重试提供的一个GatewayFilter Factory。其配置方式为： spring: cloud: gateway: routes: - id: fsh-house uri: lb://fsh-house predicates: - Path...
SpringBoot 同步和异步网络请求
m0_46911343的博客
11-30 2259
SpringBoot 同步和异步网络请求
Spring ActiveMQ 整合（二）: 重发机制（消息发送失败后的重新发送）
热门推荐
dly1580854879的博客
03-30 2万+
假如现在我手里有一个很重要的消息的，想要发给一个人，但是很不幸，消息发送失败了。这时候怎么办呢怎么解决这种尴尬的情况，这时候我们可以利用activeMQ的 消息重发机制（RedeliveryPolicy） 来解决这个烦人的问题。
spring activeMQ 整合（二）: 重发机制（消息发送失败后的重新发送）
romantic_PK的专栏
08-02 2907
之前已经写了一个spring   activemq整合的demo   ，今天继续完善一下这个demo，让功能更强大。 Spring ActiveMQ 整合（一）: 一个简单的demo，测试消息的发送与接收            假如现在我手里有一个很重要的消息的，想要发给一个人，但是很不幸，消息发送失败了。这时候怎么办呢怎么解决这种尴尬的情况，这时候我们可以利用activeMQ的 
Spring ActiveMQ 整合（二.1）: 重发机制概念解释
dly1580854879的博客
09-27 1350
前言： 好多人问我，根据我的教程，他怎么不能实现消息重复。不是说他们不能实现消息重发，只是对MQ的这个消息重发概念有误解。 一、消息重发的解释： 下面我解释一下，我对这个概念的解读：      ActiveMQ实现了这一功能，叫做ReDelivery(重新投递)。     当消费者在处理消息时有异常发生，会将消息重新放回Queue里，进行下一次处       理。当超过重试次数时，消息会
优雅实现接口重试
基地的博客
04-09 3130
微服务之间互相调用，一般情况下都会设置一些兜底手段，避免服务出现问题，最常见方案就是接口重试机制。 对于接口重试常见的方案有： 1、 硬核捕获； 2、Spring AOP 实现； 3、Spring 自带重试工具； 4、Gavua 提供重试工具。 一、准备工作 1、提供一个接口，该接口用来模拟出现网络波动时，服务调用失败的情况： @Component public class RetryServcie { private LongAdder num = new LongAdder(); /*
PHP使用进程监听模拟消费者，失败重试，连续失败写日志，并存入失败表
程序猿的世界
10-02 256
<?php class Daemon{ protected $pid; protected $paused = false; protected $shouldQuit = false; protected $count = 1; protected $sigalrm = 3; protected $now_job = ''; ...
利用 AOP 记录接口日志
码农UP2U
09-06 1387
那这样的话，我们可以在每个调用接口地址的前后使用输出日志的方式来记录，就可以得到调用接口的入参和接口的返回值，从而有利于我们以后的调试了。我们可以使用 SLF4J 或者 LogBack 等日志框架，在调用接口时来输出一下入参和返回值，大致方法是在调用接口前调用 logger.info 输出入参，然后调用接口后再次调用 logger.info 输出返回值。在我们的后端项目中有很多要调用第三方接口的地方，而调用接口就免不了会因为传递给接口的参数有问题报错，或者对接口的返回值处理不全导致报错或后续的流程有问题。
SpringBoot使用AOP记录接口操作日志
何哥的博客
01-07 2万+
前言：我们项目中可能有这种需求，每个人请求了哪些接口？做了什么事情？参数是什么？重要的接口我们需要记日志以便查找。我们不可能在每个接口中去一一处理，可以借助Spring提供的AOP能力+自定义注解轻松应对。 ...
SpringCloud SpringBoot 同步调用、异步调用、响应式调用
zhaoyang10的专栏
01-25 6400
https://blog.csdn.net/youlangta/article/details/79153439
Spring Gateway如何实现请求重试？
06-08
Spring Gateway提供了`RetryGatewayFilterFactory`工厂类来实现请求重试的功能。该工厂类是基于Spring Retry组件实现的，能够在请求失败时自动重试指定次数。 配置请求重试的步骤如下： 1. 在`application.yml`或`application.properties`中配置重试策略： ``` spring: cloud: gateway: httpclient: retries: 3 # 最大重试次数 retry: enabled: true # 开启重试功能 statuses: BAD_GATEWAY,GATEWAY_TIMEOUT # 需要重试的状态码 methods: GET,POST # 需要重试的请求方法 series: SERVER_ERROR # 需要重试的状态系列 exceptions: # 需要重试的异常类型 - java.io.IOException ``` 2. 在Gateway路由配置中添加`RetryGatewayFilterFactory`过滤器： ``` spring: cloud: gateway: routes: - id: example uri: http://example.org predicates: - Path=/example/** filters: - Retry=3 # 指定重试次数 ``` 上述配置会对`/example/**`路径下的请求进行重试，最大重试次数为3次。 需要注意的是，`RetryGatewayFilterFactory`只会对标记为需要重试的状态码、状态系列、请求方法或异常类型进行重试，如果请求返回的状态码、状态系列、请求方法或异常类型不在重试列表中，则不会进行重试。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值