消息队列如何保证幂等—AOP【代码篇】

于 2024-07-03 19:40:23 发布
阅读量635 收藏 18
点赞数 12
文章标签： java spring java-rocketmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44591233/article/details/140157932
版权

准备知识：AOP、注解

1. 定义幂等相关的注解

/**
 * 幂等注解
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Idempotent {

    /**
     * 幂等Key，只有在 {@link Idempotent#type()} 为 {@link IdempotentTypeEnum#SPEL} 时生效
     */
    String key() default "";

    /**
     * 触发幂等失败逻辑时，返回的错误提示信息
     */
    String message() default "您操作太快，请稍后再试";

    /**
     * 验证幂等场景，支持多种 {@link IdempotentSceneEnum}
     */
    IdempotentSceneEnum scene() default IdempotentSceneEnum.RESTAPI;

    /**
     * 验证幂等类型，支持多种幂等方式
     * RestAPI 建议使用 {@link IdempotentTypeEnum#TOKEN} 或 {@link IdempotentTypeEnum#PARAM}
     * 其它类型幂等验证，使用 {@link IdempotentTypeEnum#SPEL}
     */
    IdempotentTypeEnum type() default IdempotentTypeEnum.PARAM;

    /**
     * 设置防重令牌 Key 前缀，MQ 幂等去重可选设置
     * {@link IdempotentSceneEnum#MQ} and {@link IdempotentTypeEnum#SPEL} 时生效
     */
    String uniqueKeyPrefix() default "";

    /**
     * 设置防重令牌 Key 过期时间，单位秒，默认 1 小时，MQ 幂等去重可选设置
     * {@link IdempotentSceneEnum#MQ} and {@link IdempotentTypeEnum#SPEL} 时生效
     */
    long keyTimeout() default 3600L;
}

《消息队列如何保证幂等【方案篇】》中说到了三种幂等解决方案，最终全部浓缩到@Idempotent一个注解上，注解里面各个字段的含义如下图所示：
在这里插入图片描述

重要的字段有两个，scene 和 type

Scene字段

代表是接口的防重复提交还是消息队列的防重复消费，通过一个枚举标识。

package org.opengoofy.index12306.framework.starter.idempotent.enums;

/**
 * 幂等验证场景枚举
 */
public enum IdempotentSceneEnum {
    
    /**
     * 基于 RestAPI 场景验证（接口防重复提交）
     */
    RESTAPI,
    
    /**
     * 基于 MQ 场景验证（消息队列防重复消费）
     */
    MQ
}

Type字段

代表使用什么方式实现幂等，其中 TOKEN 和 PARAM 以及 SPEL 可以应用于接口防重复提交，SPEL 应用于消息队列防重复消费。

  • 分布式锁：PARAM 和 SPEL。
  • Token 令牌：TOKEN。
  • 去重表：SPEL。
package org.opengoofy.index12306.framework.starter.idempotent.enums;

/**
 * 幂等验证类型枚举
 */
public enum IdempotentTypeEnum {
    
    /**
     * 基于 Token 方式验证
     */
    TOKEN,
    
    /**
     * 基于方法参数方式验证
     */
    PARAM,
    
    /**
     * 基于 SpEL 表达式方式验证
     */
    SPEL
}

2. 幂等 AOP 解析注解

使用Spring的AOP机制来提供幂等性保障。只需要在需要保证幂等性的方法上添加 @Idempotent 注解，并通过@annotation注解定义增强原始方法的前置逻辑、后置逻辑。

简单来说，就是先获取到原始方法上的幂等注解（@Idempotent），然后获取到对应的幂等处理实现类（@annotation(Idempotent)）。通过实现类进行幂等前置逻辑，执行完成后操作被@Idempotent注解修饰的原始业务方法，最终执行释放资源的后置逻辑。

/**
 * 幂等注解 AOP 拦截器
 */
@Aspect
public final class IdempotentAspect {

    /**
     * 增强方法标记 {@link Idempotent} 注解逻辑
     */
    @Around("@annotation(org.opengoofy.index12306.framework.starter.idempotent.annotation.Idempotent)")
    public Object idempotentHandler(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取到方法上的幂等注解实际数据
        Idempotent idempotent = getIdempotent(joinPoint);
        // 通过幂等场景以及幂等类型，获取幂等执行处理器
        IdempotentExecuteHandler instance = IdempotentExecuteHandlerFactory.getInstance(idempotent.scene(), idempotent.type());
        Object resultObj;
        try {
            // 执行幂等处理前置逻辑（保障原始业务方法幂等）
            instance.execute(joinPoint, idempotent);
            // 如果幂等处理逻辑没有抛异常，处理中间业务
            resultObj = joinPoint.proceed();
            // 处理幂等后置逻辑，比如释放资源或者锁之类的
            instance.postProcessing();
        } catch (RepeatConsumptionException ex) {
            /**
             * 该异常为消息队列防重复提交独有，触发幂等逻辑时可能有两种情况：
             *    * 1. 消息还在处理，但是不确定是否执行成功，那么需要返回错误，方便 RocketMQ 再次通过重试队列投递
             *    * 2. 消息处理成功了，该消息直接返回成功即可
             */
            if (!ex.getError()) {
                return null;  // 消息处理成功
            }
            throw ex;
        } catch (Throwable ex) {
            // 客户端消费存在异常，需要删除幂等标识方便下次 RocketMQ 再次通过重试队列投递
            instance.exceptionProcessing();
            throw ex;
        } finally {
            // 清理幂等容器上下文
            IdempotentContext.clean();
        }
        return resultObj;
    }

    public static Idempotent getIdempotent(ProceedingJoinPoint joinPoint) throws NoSuchMethodException {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method targetMethod = joinPoint.getTarget().getClass().getDeclaredMethod(methodSignature.getName(), methodSignature.getMethod().getParameterTypes());
        return targetMethod.getAnnotation(Idempotent.class);
    }
}
  • Around(“@annotation(org.opengoofy.index12306.framework.starter.idempotent.annotation.Idempotent)”)：@annotation(Idempotent)注解表示 idempotentHandler 方法为@Idempotent修饰的原始方法的增强方法。
  • @Around为环绕通知，在idempotentHandler方法中通过ProceedingJoinPoint手动调用原始业务方法。
  • 先获取原始业务方法上的幂等注解实际数据，根据幂等注解中的实际数据（Scene字段、Type字段）获取幂等执行处理器
    // 获取到方法上的幂等注解实际数据
Idempotent idempotent = getIdempotent(joinPoint);
// 通过幂等场景以及幂等类型，获取幂等执行处理器
IdempotentExecuteHandler instance = IdempotentExecuteHandlerFactory.getInstance(idempotent.scene(), idempotent.type());
  • 通过幂等执行处理器instance执行原始业务的前置逻辑、后置逻辑
    // 执行幂等处理前置逻辑（保障原始业务方法幂等）
instance.execute(joinPoint, idempotent);
// 如果幂等处理逻辑没有抛异常，处理中间业务
resultObj = joinPoint.proceed();
// 处理幂等后置逻辑，比如释放资源或者锁之类的
instance.postProcessing();

2.1. 获取幂等处理器

针对不同幂等验证场景（Scene字段）以及幂等处理类型（Type字段）拆分了不同的策略模式处理器，帮助我们实现高内聚低耦合。

/**
 * 幂等执行处理器工厂
 * <p>
 * Q：可能会有同学有疑问：这里为什么要采用简单工厂模式？策略模式不行么？
 * A：策略模式同样可以达到获取真正幂等处理器功能。但是简单工厂的语意更适合这个场景，所以选择了简单工厂
 */
public final class IdempotentExecuteHandlerFactory {

    /**
     * 获取幂等执行处理器
     *
     * @param scene 指定幂等验证场景类型
     * @param type  指定幂等处理类型
     * @return 幂等执行处理器
     */
    public static IdempotentExecuteHandler getInstance(IdempotentSceneEnum scene, IdempotentTypeEnum type) {
        IdempotentExecuteHandler result = null;
        switch (scene) {
            case RESTAPI -> {
                switch (type) {
                    case PARAM -> result = ApplicationContextHolder.getBean(IdempotentParamService.class);
                    case TOKEN -> result = ApplicationContextHolder.getBean(IdempotentTokenService.class);
                    case SPEL -> result = ApplicationContextHolder.getBean(IdempotentSpELByRestAPIExecuteHandler.class);
                    default -> {
                    }
                }
            }
            case MQ -> result = ApplicationContextHolder.getBean(IdempotentSpELByMQExecuteHandler.class);
            default -> {
            }
        }
        return result;
    }
}
  • RESTAPI 防止接口重复提交场景下：Type可以为PARAM、TOKEN、SPEL
  • MQ 防止消息队列重复消费场景下：Type可以为SPEL

2.2 执行幂等前置逻辑

获取到对应的幂等处理器后，我们就开始执行幂等的真实处理逻辑（原始业务方法的前置逻辑）。

/**
 * 抽象幂等执行处理器
 */
public abstract class AbstractIdempotentExecuteHandler implements IdempotentExecuteHandler {

    /**
     * 构建幂等验证过程中所需要的参数包装器
     *
     * @param joinPoint AOP 方法处理
     * @return 幂等参数包装器
     */
    protected abstract IdempotentParamWrapper buildWrapper(ProceedingJoinPoint joinPoint);

    /**
     * 执行幂等处理逻辑
     *
     * @param joinPoint  AOP 方法处理
     * @param idempotent 幂等注解
     */
    public void execute(ProceedingJoinPoint joinPoint, Idempotent idempotent) {
        // 模板方法模式：构建幂等参数包装器  通过各策略实现类获取 IdempotentParamWrapper 参数
        IdempotentParamWrapper idempotentParamWrapper = buildWrapper(joinPoint).setIdempotent(idempotent);
        handler(idempotentParamWrapper);
    }
}

不同的策略实现类（PARAM、TOKEN、SPEL）都会自定义实现幂等处理逻辑，比如 buildWrapper方法和handler方法，这里使用了模版方法模式进行了一个封装，让具体的实现细节下沉到实现类中。
在这里插入图片描述

获取到 IdempotentParamWrapper 参数后调用 handler 执行具体的幂等逻辑方法。
在这里插入图片描述

2.3 执行幂等后置逻辑：释放幂等相关资源

idempotentHandler方法的最后，通过 instance.postProcessing(); 调用幂等释放资源方法，进行分布式锁的解锁等行为，同样是各个幂等策略实现类（各个幂等处理器）自定义，有的需要释放资源，有的不需要。不需要释放的，空实现即可。

以分布式解锁为参考：

@Override
public void postProcessing() {
    RLock lock = null;
    try {
        lock = (RLock) IdempotentContext.getKey(LOCK);
    } finally {
        if (lock != null) {
            lock.unlock();
        }
    }
}

Example：消息队列防止重新消费

在这里插入图片描述

3.1 Idempotent注解字段值

Scene = MQ， Type = SPEL；

3.2 订单消费者业务逻辑

用户支付成功后，回调订单消费者

/**
 * 支付结果回调订单消费者
 */
@Slf4j
@Component
@RequiredArgsConstructor
@RocketMQMessageListener(
        topic = OrderRocketMQConstant.PAY_GLOBAL_TOPIC_KEY,
        selectorExpression = OrderRocketMQConstant.PAY_RESULT_CALLBACK_TAG_KEY,
        consumerGroup = OrderRocketMQConstant.PAY_RESULT_CALLBACK_ORDER_CG_KEY
)
public class PayResultCallbackOrderConsumer implements RocketMQListener<MessageWrapper<PayResultCallbackOrderEvent>> {

    private final OrderService orderService;

    @Idempotent(
            uniqueKeyPrefix = "index12306-order:pay_result_callback:",
            key = "#message.getKeys()+'_'+#message.hashCode()",
            type = IdempotentTypeEnum.SPEL,
            scene = IdempotentSceneEnum.MQ,
            keyTimeout = 7200L
    )
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void onMessage(MessageWrapper<PayResultCallbackOrderEvent> message) {
        // ......
    }
}
  • onMessage方法被@Idempotent注解修饰，通过AOP机制对onMessage方法进行增强，完成幂等判断；
  • key：消息的唯一标识；
  • Scene = MQ， Type = SPEL；

3.3 SpEL 表达式

key里面的参数就是 SpEL 表达式，是 Spring 提供的自然语言表达式。

SpEL（Spring Expression Language）是 Spring 框架提供的一种表达式语言，用于在运行时评估表达式。它支持在 Spring 应用程序中进行动态求值和访问对象的属性、方法调用、运算符操作等。

SpEL表达式的语法类似于其他编程语言的表达式语言，具有以下特点：

  1. 属性访问：可以使用点号（.）来访问对象的属性，例如 person.name。
  2. 方法调用：可以通过在表达式中使用方法名和参数来调用对象的方法，例如 person.getName()。
  3. 运算符操作：支持常见的算术运算符（如加减乘除）、逻辑运算符（如与、或、非）和比较运算符（如等于、大于、小于等）。
  4. 条件表达式：支持条件表达式，例如三元运算符 condition ? value1 : value2。
  5. …

我们分步骤解析这个 SpEL 表达式最终运行结果是什么？

1. #message.getKeys() 
2. +'_'+ 
3. #message.hashCode()

共分为三部分，第一部分，通过请求入参 message 对象，获取属性 keys 值，然后再获取 message 对象的 hashCode 值，通过 _ 的方式拼接在一起，就得到了本次请求的唯一幂等 Key。

3.4 幂等处理逻辑（原始onMessage方法的前置逻辑）

/**
 * 基于 SpEL 方法验证请求幂等性，适用于 MQ 场景
 */
@RequiredArgsConstructor
public final class **IdempotentSpELByMQExecuteHandler** extends AbstractIdempotentExecuteHandler implements IdempotentSpELService {

    private final DistributedCache distributedCache;

    private final static int TIMEOUT = 600;
    private final static String WRAPPER = "wrapper:spEL:MQ";

    @SneakyThrows
    @Override
    protected IdempotentParamWrapper buildWrapper(ProceedingJoinPoint joinPoint) {
        Idempotent idempotent = IdempotentAspect.getIdempotent(joinPoint);
        // 通过执行 SpEL 表达式获取值
        String key = (String) SpELUtil.parseKey(idempotent.key(), ((MethodSignature) joinPoint.getSignature()).getMethod(), joinPoint.getArgs());
        return IdempotentParamWrapper.builder()
														         .lockKey(key)
														         .joinPoint(joinPoint)
														         .build();
    }

    @Override
    public void handler(IdempotentParamWrapper wrapper) {
        // 拼接前缀和 SpEL 表达式对应的 Key 生成最终放到 Redis 中的唯一标识
        String uniqueKey = wrapper.getIdempotent().uniqueKeyPrefix() + wrapper.getLockKey();
        // 向 Redis 触发命令，如果值不存在则存储返回 True，值存在返回 False
        Boolean setIfAbsent = ((StringRedisTemplate) distributedCache.getInstance())
                .opsForValue()
                .setIfAbsent(uniqueKey, IdempotentMQConsumeStatusEnum.CONSUMING.getCode(), TIMEOUT, TimeUnit.SECONDS);
        // **如果值为 False，那么就代表要么消息已经执行完成了或者执行中，两个不同的状态需要执行不同的逻辑**
        // 为此，需要再进行判断
        if (setIfAbsent != null && !setIfAbsent) {
            // 获取幂等标识对应的值，判断是否为已执行成功
            String consumeStatus = distributedCache.get(uniqueKey, String.class);
            // 如果已经执行成功了，那么 error 为 false；执行中 error 为 true
            boolean error = IdempotentMQConsumeStatusEnum.isError(consumeStatus);
            LogUtil.getLog(wrapper.getJoinPoint()).warn("[{}] MQ repeated consumption, {}.", uniqueKey, error ? "Wait for the client to delay consumption" : "Status is completed");
            // 将异常抛出到上层
            throw new RepeatConsumptionException(error);
        }
        IdempotentContext.put(WRAPPER, wrapper);
    }

    // ......
}
  • 幂等处理器实现类IdempotentSpELByMQExecuteHandler中自定义实现了buildWrapper方法和handler方法
  • 获取SpEL表达式的值，也就是获取消息的唯一标识 key。接着通过构造者设计模式的方式将IdempotentParamWrapper对象的lockKey字段设置为key值。
    // 通过执行 SpEL 表达式获取值
String key = (String) SpELUtil.parseKey(idempotent.key(), ((MethodSignature) joinPoint.getSignature()).getMethod(), joinPoint.getArgs());
return IdempotentParamWrapper.builder()
					         .lockKey(key)
					         .joinPoint(joinPoint)
			         		 .build();
  • handler方法中通过去重表的逻辑判断消息有没有被重复消费。如果消息已经被消费成功了，那么抛出RepeatConsumptionException(false)；如果消息还在被其他的消费者线程消费中，那么抛出RepeatConsumptionException(false)。
    // 拼接前缀和 SpEL 表达式对应的 Key 生成最终放到 Redis 中的唯一标识
String uniqueKey = wrapper.getIdempotent().uniqueKeyPrefix() + wrapper.getLockKey();
// 去重表：向 Redis 触发命令，如果值不存在则存储返回 True，值存在返回 False
Boolean setIfAbsent = ((StringRedisTemplate) distributedCache.getInstance())
        .opsForValue()
        .setIfAbsent(uniqueKey, IdempotentMQConsumeStatusEnum.CONSUMING.getCode(), TIMEOUT, TimeUnit.SECONDS);
// 如果值为 False，那么就代表要么消息已经执行完成了或者执行中，两个不同的状态需要执行不同的逻辑
// 为此，需要再进行判断
if (setIfAbsent != null && !setIfAbsent) {
    // 获取幂等标识对应的值，判断消息是否为已执行成功
    String consumeStatus = distributedCache.get(uniqueKey, String.class);
    // 如果已经执行成功了，那么 error 为 false
    // 如果消息还在执行中，那么 error 为 true
    boolean error = IdempotentMQConsumeStatusEnum.isError(consumeStatus);
    LogUtil.getLog(wrapper.getJoinPoint()).warn("[{}] MQ repeated consumption, {}.", uniqueKey, error ? "Wait for the client to delay consumption" : "Status is completed");
    // 将异常抛出到上层（携带error一起抛出）
    throw new RepeatConsumptionException(error);
}
  • RepeatConsumptionException中true和false很重要，如果为false，那么消息就不会再进行重新投递；如果为true，那么消息会触发延迟消费，等待之后RocketMQ重新投递。
    /**
 * 幂等注解 AOP 拦截器
 */
@Aspect
public final class IdempotentAspect {

    /**
     * 增强方法标记 {@link Idempotent} 注解逻辑
     */
    @Around("@annotation(org.opengoofy.index12306.framework.starter.idempotent.annotation.Idempotent)")
    public Object idempotentHandler(ProceedingJoinPoint joinPoint) throws Throwable {
        Idempotent idempotent = getIdempotent(joinPoint);
        IdempotentExecuteHandler instance = IdempotentExecuteHandlerFactory.getInstance(idempotent.scene(), idempotent.type());
        Object resultObj;
        try {
            instance.execute(joinPoint, idempotent);
            resultObj = joinPoint.proceed();  // 执行消费者onMessege方法
            instance.postProcessing();
        } catch (RepeatConsumptionException ex) {
            /**
             * 触发幂等逻辑时可能有两种情况，分别对应 error 为 true 还是 false
             *    * 1. 消息还在处理，但是不确定是否执行成功，那么需要返回错误，方便 RocketMQ 再次通过重试队列投递
             *    * 2. 消息处理成功了，该消息直接返回成功即可
             */
            if (!ex.getError()) {
                return null; // 返回null代表成功
            }
            throw ex;
        } catch (Throwable ex) {
            // 客户端消费存在异常，需要删除幂等标识方便下次 RocketMQ 再次通过重试队列投递
            instance.exceptionProcessing();
            throw ex;
        } finally {
            IdempotentContext.clean();
        }
        return resultObj;
    }

    public static Idempotent getIdempotent(ProceedingJoinPoint joinPoint) throws NoSuchMethodException {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method targetMethod = joinPoint.getTarget().getClass().getDeclaredMethod(methodSignature.getName(), methodSignature.getMethod().getParameterTypes());
        return targetMethod.getAnnotation(Idempotent.class);
    }
}
    1. 如果前置逻辑execute没有出现异常，说明消息可以正常消费，调用消息消费者的 onMessage 方法（joinPoint.proceed()）。
    2. 如果前置逻辑execute出现异常，不会调用消息消费者的 onMessage 方法，并且通过捕获 RepeatConsumptionException 异常，获取里面 error 变量为 true 或者 false：
      • 如果 error 为 true，代表需要抛异常让 RocketMQ 重试。
      • 如果 error 为 false，代表消息已经消费过了，不执行业务逻辑，将异常吞掉返回 RocketMQ 消费成功即可。

3.5 设置消费状态为已完成

如果获取到了幂等标识，然后正常业务逻辑也执行成功了，会调用 instance.postProcessing(); 将幂等标识的完成状态设置为已完成。

获取唯一标识幂等 Key，并设置幂等 Key 的状态为已完成，流程结束。

@Override
public void postProcessing() {
    IdempotentParamWrapper wrapper = (IdempotentParamWrapper) IdempotentContext.getKey(WRAPPER);
    if (wrapper != null) {
        Idempotent idempotent = wrapper.getIdempotent();
        String uniqueKey = idempotent.uniqueKeyPrefix() + wrapper.getLockKey();
        try {
            distributedCache.put(**uniqueKey, IdempotentMQConsumeStatusEnum.CONSUMED.getCode()**, idempotent.keyTimeout(), TimeUnit.SECONDS);
        } catch (Throwable ex) {
            LogUtil.getLog(wrapper.getJoinPoint()).error("[{}] Failed to set MQ anti-heavy token.", uniqueKey);
        }
    }
}

3.6 能保障永久幂等么？

根据postProcessing方法可以看出，消息的唯一标识uniqueKey存在过期时间。

distributedCache.put(**uniqueKey, IdempotentMQConsumeStatusEnum.CONSUMED.getCode()**, idempotent.keyTimeout(), TimeUnit.SECONDS);

所以不能保障永久幂等，因为 Redis 内存资源比较珍贵，如果长时间保存幂等 Key，会造成 Redis 内存占用增加。

小鱼干不写作业
关注
  • 12
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
消息队列之如何保证消息的幂等性
qq_36284689的博客
05-03 281
目录1.1 前言2.1 解决方案1.1 前言 不管是RQ还是Kafka等消息队列，在被消费者消费的时候需要防止的一个问题就是：如何防止消息被重复消费，也是就消息的幂等性。这问题通常不是 MQ 自己保证的，是由我们开发来保证的。挑一个 Kafka 来举个例子，说说怎么重复消费吧。 Kafka 实际上有个 offset 的概念，就是每个消息写进去，都有一个 offset，代表消息的序号，然后 con...
消息队列如何保证幂等【方案篇】
最新发布
weixin_44591233的博客
06-14 549
这里的可靠性指的是，只要消息被成功投递到了消息中间件，它就不会丢失，至少能够被消费者成功消费一次。在客户端进行第二次业务请求时，必须携带这个 Token，服务端会验证这个 Token，如果验证成功，则执行业务逻辑并从 Redis 中删除该 Token。Example：用户在付款的时候，同时点击了多次付款按钮，后端处理了多次相同的扣款请求，结果导致账户被扣了多次钱。如果验证失败，说明 Redis 中已经没有对应的 Token，表示重复操作，服务端会直接返回指定的结果给客户端。，将消息发送到重试队列。
消息队列的消费幂等性如何保证
梦~'
08-16 1908
参考大佬文章：消息队列的消费幂等性如何保证 这里先介绍下幂等性： 幂等性： 一个幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同 比如：一条数据或者一个请求，重复发起多次，我们要确保对应的数据不会受影响。 为什么要保证消费的幂等性？ 基于"业务场景"进行分析，比如某些正常情况下，我们是不允许同一个订单重复支付，这种场景就需要保证操作的幂等性。 常用的幂等性保证方法： 1.利用数据库的唯一约束实现幂等 比如将订单表中的订单编号设置为唯一索引，创建订单时，根据订单编号就可以保证幂等 2.
如何保证消息队列消息消费的幂等性
勇心在馨
09-17 789
消息被重新消费场景 用kafka举例： 生产者向kafka打入3条数据，分别是(数据1，offset=100)，(数据2，offset=110)，(数据3，offset=120) 消费者每消费一条数据即将刚消费的消息offset提交给kafka。 考虑一种场景：消费者消费到数据2的消息，再准备提交offset=110时，消费者出了故障，本来要提交的offset未能提交。等消费者修复故障重启...
aop实现幂等性校验
cy0327的博客
05-28 491
自定义注解、aop、redis，对接口方法进行幂等校验 //自定义注解： @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface AutoCheckMethod { } //redis工具类 public class RedisTemplateUtil extends RedisTemplate<Serializable, Object> { /** * 如果已经
java高并发买秒杀完整代码
06-12
在实际开发过程中，还需要考虑其他优化策略，如限流（如使用Hystrix熔断器）、分布式锁（如Redis锁或Zookeeper分布式锁）以及采用消息队列（如RabbitMQ或Kafka）异步处理订单生成和发货等后续流程，以保证系统的稳定...
基于TCC机制的分布式事务管理器源代码
12-15
此外，ByteTCC还支持服务间的异步通信，这通常通过消息队列实现。这种方式可以进一步提高系统的并发处理能力，同时减轻了单个服务的压力。通过在Try阶段发送消息，然后在Confirm或Cancel阶段接收并处理这些消息，...
21-面试宝典(进一般互联网公司必看).docx
08-22
这篇面试宝典涵盖了基础篇、核心篇、框架篇、微服务篇、安全&性能、工程篇等多个方面的知识点，总结了大多数互联网公司的面试题目，涉及到Java基础知识、数据存储、缓存、消息队列、框架、微服务、安全、性能优化、...
seckill
03-13
4. **消息队列**：在高并发下，将秒杀请求放入Redis的消息队列，再异步处理，可以缓解瞬时压力，保证服务稳定。 5. **过期时间**：设置Redis中的键过期时间，避免数据积累占用过多内存，同时也能清理无效的请求。 ...
aop 幂等验证（二）
weixin_30383279的博客
04-25 139
1 创建IIdempotent @Target({ElementType.PARAMETER, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface IIdempotent { } 2 创建aop @Component @Aspect publ...
Aop注解+Redis解决SpringBoot接口幂等性(源码自取)
暗武逢天的博客
03-08 1345
幂等是一个数学与计算机学概念，在数学中某一元运算为幂等时，其作用在任一元素两次后会和其作用一次的结果相同。在计算机中编程中，一个幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同。幂等函数或幂等方法是指可以使用相同参数重复执行，并能获得相同结果的函数。这些函数不会影响系统状态，也不用担心重复执行会对系统造成改变。
Spring Aop实现接口幂等性处理
qq_41296669的博客
12-25 485
用户快速的双击了某个按钮，前端没有禁用该按钮，导致发送了两次重复的请求。
【智能排班系统】基于AOP和自定义注解实现接口幂等性
记录一名在读研究生的学习笔记、感悟、开发产物
04-06 932
使用多种方式实现接口幂等性，通过定义注解方便对方法进行幂等性控制
使用AOP实现防止表单重复提交问题,解决后端幂等性问题
Persistence___的博客
02-19 614
在最近的工作开发中，需要设计到防止表单重复提交的问题。在前端的js中做了点击置灰的效果，但是无法防止使用postmain等刷新页面进行恶意攻击 ，就想用后端的技术来完成防止表单提交于是在网上找了一下。特此记录一下自己写的过程与碰到的问题。 借鉴了某位大神的博客后写的忘记保存地址了。。。。。 首先定义一个注解类。 /** * 可以防止表单提交的注解 */ @Retention(RetentionPolicy.RUNTIME)//指定该注解在运行时可以获取 @Target(ElementType.METHO
【架构设计】Java如何利用AOP实现幂等操作，防止客户端重复操作
Java程序员专栏
06-02 1169
首先，定义一个自定义注解，用于标记需要进行幂等控制的方法。
消息队列-------消息幂等
无名小辈
09-29 670
消息幂等性 1.什么是幂等性：对一个接口，执行相同的操作，一个跟多次的结果都相同，就叫幂等性，简单来讲，接口应该对重复操作，进行预防性的处理，比如不再执行等 2.、消息队列可能存在的问题： 消息积压 高可用性 消息的延时， 消息失效 3.为什么使用消息队列 解耦，异步，削峰 解耦：避免硬编码，Java ，pyton,c++不同系统之间相互通信 异步：a可以同时调用b接口，c接口...
消息队列如何保证消息幂等性消费
一瓶绿茶三元钱
01-05 1291
只是不同的消息队列发送的确认信息形式不同,例如RabbitMQ是发送一个ACK确认消息，RocketMQ是返回一个CONSUME_SUCCESS成功标志，kafka实际上有个offset的概念，每一个消息都有一个offset，kafka消费过消息后，需要提交offset，让消息队列知道自己已经消费过了。正常情况下，消费者在消费消息时候，消费完毕后，会发送一个确认信息给消息队列，消息队列就知道该消息被消费了，就会将该消息从消息队列中删除。可以看出，消息发送和消息消费两个步骤是有可能产生消息不幂等的问题。
aop如何实现接口幂等性
03-14
AOP可以通过拦截器来实现接口幂等性，具体实现方式是在接口方法执行前，先检查该请求是否已经被处理过，如果已经处理过，则直接返回结果，否则继续执行接口方法，并在执行完毕后将请求标记为已处理。这样可以避免重复提交请求，保证接口的幂等性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值