幂等简单了解

m0_51771176

已于 2024-09-06 13:55:51 修改

阅读量141

点赞数 1

文章标签： spring boot spring java 数据库分布式

于 2024-09-06 11:31:10 首次发布

本文链接：https://blog.csdn.net/m0_51771176/article/details/141955469

版权

(注:本文内容来源通义灵码,以做简单记录 )

一.什么是幂等?

幂等（Idempotent）是指一个操作可以多次执行，并且多次执行的效果与执行一次的效果相同。这个概念在数学和计算机科学中都有应用，特别是在网络应用和分布式系统的设计中尤为重要。

在计算机科学中的应用
API设计：
对于一些HTTP方法如GET和DELETE，它们被设计为幂等的。例如，多次删除一个资源应该和只删除一次有相同的结果。
数据库操作：
在数据库中，某些操作如删除记录或更新唯一值也是幂等的。例如，尝试更新一个已经具有目标值的字段不会改变其状态。
分布式系统：
在分布式系统中，由于网络不稳定可能导致消息重复发送，幂等操作可以确保即使消息重复处理也不会影响最终结果的一致性。
事务处理：
在事务处理中，幂等操作有助于保证即使事务失败并重试，也能得到一致的结果。

通过确保操作的幂等性，可以简化系统的实现复杂度，提高系统的可靠性和容错能力。

二.java中幂等的实现方法?

在Java中实现接口的幂等性可以通过多种方法来完成，以下是一些常见的实现方式：

1.使用数据库唯一约束

对于插入操作，可以通过设置数据库表的唯一索引来保证幂等性。例如，使用主键唯一性来避免重复记录的插入。

   // 假设有一个实体类User，其中id为主键
   public void createUser(User user) {
       userRepository.save(user);
   }

这里假设userRepository实现了对数据库的操作，并且User表中的id字段是唯一标识。

2.乐观锁

对于更新操作，可以使用乐观锁机制，通常通过在数据库表中增加一个版本字段(version)，并在更新时检查该版本字段是否与预期一致

   @Version
   private int version;

   public void updateUser(User user) {
       User existingUser = userRepository.findById(user.getId());
       if (existingUser.getVersion() == user.getVersion()) {
           userRepository.save(user);
       } else {
           throw new OptimisticLockingFailureException("Update conflict");
       }
   }

这里使用了JPA的@Version注解来自动管理版本字段。

3.防重令牌

对于可能重复提交的请求，可以采用防重令牌机制。每个请求都需要携带一个全局唯一的令牌，这个令牌在服务器端存储一段时间，在这段时间内，相同的令牌只能被接受一次

   public void processRequest(String uniqueToken, Request request) {
       if (!tokenStore.contains(uniqueToken)) {
           tokenStore.add(uniqueToken);
           // 执行业务逻辑
           performBusinessLogic(request);
       } else {
           // 返回提示信息，表示请求已被处理
           return;
       }
   }

tokenStore可以是内存中的结构如HashMap，也可以是数据库中的临时表。

4.使用唯一标识符

可以给每个请求分配一个全局唯一的标识符（如UUID），并在处理请求前检查该标识符是否已经被处理过。

   public void handleRequest(String requestId, Request request) {
       if (!requestIdStore.contains(requestId)) {
           requestIdStore.add(requestId);
           // 执行业务逻辑
           performBusinessLogic(request);
       } else {
           // 返回提示信息，表示请求已被处理
           return;
       }
   }

5.幂等性切面实现

利用AOP（面向切面编程）来实现幂等性，可以在请求进入业务逻辑之前进行幂等性校验。

   @Aspect
   public class IdempotentAspect {

       @Around("@annotation(Idempotent)")
       public Object invoke(ProceedingJoinPoint joinPoint) throws Throwable {
           // 实现幂等性校验逻辑
           String requestId = getRequestIdFromRequest(joinPoint.getArgs());
           if (!requestIdStore.contains(requestId)) {
               requestIdStore.add(requestId);
               return joinPoint.proceed();
           } else {
               // 返回提示信息，表示请求已被处理
               return "Request already processed";
           }
       }
   }

这里@Idempotent是一个自定义的注解，用于标记需要幂等性处理的方法。
这些方法可以根据具体的应用场景选择合适的实现方式。在实际开发中，可能还需要考虑并发控制、事务管理等问题。

三.AOP切面注解实现幂等...

在Java中，利用AOP（面向切面编程）来实现幂等性是一种常见的做法。这种方式可以将幂等性检查逻辑从业务逻辑中分离出来，通过切面的方式统一处理，从而减少重复代码，增强代码的可维护性和可读性。
下面是一个详细的步骤说明，展示如何使用Spring AOP来实现幂等性切面：

步骤 1: 定义幂等性注解

首先，我们需要定义一个自定义注解，用于标记那些需要幂等性处理的方法。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Idempotent {
    // 可以添加额外的参数配置，比如幂等性检查的有效时间等
}

步骤 2: 创建幂等性切面

接下来，我们需要创建一个切面类，该类将包含幂等性检查的逻辑。

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class IdempotentAspect {

    private final IdempotentTokenStore idempotentTokenStore;

    public IdempotentAspect(IdempotentTokenStore idempotentTokenStore) {
        this.idempotentTokenStore = idempotentTokenStore;
    }

    @Around("@annotation(idempotent)")
    public Object handleIdempotent(ProceedingJoinPoint joinPoint, Idempotent idempotent) throws Throwable {
        String requestId = extractRequestId(joinPoint);

        if (idempotentTokenStore.contains(requestId)) {
            // 如果请求ID已经被处理过，则直接返回，不再执行业务逻辑
            return "Request already processed";
        }

        try {
            // 将请求ID加入到存储中
            idempotentTokenStore.add(requestId);
            // 继续执行方法
            return joinPoint.proceed();
        } finally {
            // 清理请求ID，如果有必要的话
            idempotentTokenStore.remove(requestId);
        }
    }

    private String extractRequestId(ProceedingJoinPoint joinPoint) {
        // 从请求参数中提取请求ID，这里假设请求ID作为第一个参数传递
        Object[] args = joinPoint.getArgs();
        if (args.length > 0 && args[0] instanceof String) {
            return (String) args[0];
        }
        throw new IllegalArgumentException("Request ID not found in arguments");
    }
}

步骤 3: 创建幂等性令牌存储

为了存储请求ID，我们可以创建一个简单的令牌存储类。这个类可以使用任何持久化存储解决方案，例如Redis或者内存中的Map。

import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class InMemoryIdempotentTokenStore implements IdempotentTokenStore {

    private final ConcurrentHashMap<String, Boolean> tokens = new ConcurrentHashMap<>();

    @Override
    public boolean contains(String requestId) {
        return tokens.containsKey(requestId);
    }

    @Override
    public void add(String requestId) {
        tokens.put(requestId, Boolean.TRUE);
    }

    @Override
    public void remove(String requestId) {
        tokens.remove(requestId);
    }
}

步骤 4: 应用幂等性注解

最后，我们可以在需要幂等性处理的方法上应用@Idempotent注解，并将请求ID作为方法的第一个参数传递。

@Service
public class SomeService {

    @Idempotent
    public String processRequest(String requestId, Request request) {
        // 业务逻辑
        return "Processed successfully";
    }
}