import javax.persistence.*;
import java.time.LocalDateTime;

@Entity
@Table(name = "idempotency_control")
public class IdempotencyControl {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String requestId;

    @Column(nullable = false)
    private String status;

    @Column(nullable = false)
    private LocalDateTime timestamp;

    // Constructors, getters and setters
}

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface IdempotencyControlRepository extends JpaRepository<IdempotencyControl, Long> {
    IdempotencyControl findByRequestId(String requestId);
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class IdempotencyService {

    @Autowired
    private IdempotencyControlRepository repository;

    @Transactional
    public String processRequest(String requestId, String payload) {
        IdempotencyControl control = repository.findByRequestId(requestId);
        if (control != null) {
            return "Request already processed"; // 通過control表結(jié)果確定返回的內(nèi)容
        }

        control = new IdempotencyControl();
        control.setRequestId(requestId);
        control.setStatus("PROCESSING");
        control.setTimestamp(LocalDateTime.now());
        repository.save(control);

        // Process the request here


        // Assume processing is successful
        control.setStatus("COMPLETED");
        repository.save(control);

        return "Request processed successfully";
    }
}

public boolean checkAndInsertIdempotentKey(String requestId) {
    String sql = "INSERT INTO idempotency_keys (request_id, status, created_at) VALUES (?, 'PENDING', NOW()) ON DUPLICATE KEY UPDATE request_id=request_id";
    try {
        int result = jdbcTemplate.update(sql, requestId);
        return result == 1;
    } catch (DuplicateKeyException e) {
        return false;
    }
}

http {
    lua_shared_dict locks 10m;  # 分配10MB內(nèi)存用于存儲鎖信息

    server {
        location /api {
            default_type 'text/plain';
            content_by_lua_block {
                local redis = require "resty.redis"
                local red = redis:new()
                red:set_timeout(1000)  -- 1秒超時
                local ok, err = red:connect("127.0.0.1", 6379)
                if not ok then
                    ngx.say("Failed to connect to Redis: ", err)
                    return
                end

                local key = "unique_key_" .. ngx.var.request_uri
                local res, err = red:setnx(key, ngx.var.remote_addr)
                if res == 0 then
                    ngx.say("Duplicate request")
                    return
                end

                -- 設(shè)置鍵的過期時間，防止永久占用
                red:expire(key, 60)  -- 60秒后自動刪除鍵

                -- 轉(zhuǎn)發(fā)請求到后端應(yīng)用
                ngx.exec("@backend")
            }
        }

        location @backend {
            proxy_pass http://backend_servers;
        }
    }
}

@RestController
@RequestMapping("/api")
public class ApiController {

    @PostMapping("/process")
    public ResponseEntity<String> processRequest(@RequestBody SomeData data) {
        // 處理請求
        return ResponseEntity.ok("Processed successfully");
    }
}

location /api {
    set_by_lua $token 'return ngx.var.arg_token';
    access_by_lua '
        local res = ngx.location.capture("/redis", { args = { key = ngx.var.token, value = "EXISTS" } })
        if res.body == "EXISTS" then
            ngx.exit(ngx.HTTP_FORBIDDEN)
        end
    ';
    proxy_pass http://my_backend;
}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.AfterReturning;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.data.redis.core.StringRedisTemplate;

@Aspect
@Component
public class IdempotenceAspect {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Pointcut("@annotation(Idempotent)") // 假設(shè)Idempotent是一個自定義注解，用于標記需要冪等保護的方法
    public void idempotentOperation() {}

    @AfterReturning("idempotentOperation()")
    public void afterReturning(JoinPoint joinPoint) {
        // 獲取請求標識
        String key = extractKeyFromJoinPoint(joinPoint);
        // 將操作標識存入Redis中，標記為已處理
        redisTemplate.opsForValue().set(key, "processed", 10, TimeUnit.MINUTES); // 示例中設(shè)置10分鐘后過期
    }

    private String extractKeyFromJoinPoint(JoinPoint joinPoint) {
        // 此處實現(xiàn)從方法參數(shù)等獲取key的邏輯
        return "SOME_KEY";
    }
}

@Aspect
@Component
public class IdempotencyAspect {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..)) && @annotation(Idempotent)", returning = "result")
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        String key = getKeyFromJoinPoint(joinPoint);
        redisTemplate.opsForValue().set(key, "COMPLETED", 10, TimeUnit.MINUTES);
    }

    private String getKeyFromJoinPoint(JoinPoint joinPoint) {
        // Logic to extract key based on method arguments or annotations
    }
}

// 假設(shè)有一個訂單提交的接口
@PostMapping("/submitOrder")
public ResponseEntity<String> submitOrder(@RequestBody Order order) {
    boolean isProcessed = idempotencyService.checkAndRecord(order.getId());
    if (!isProcessed) {
        return ResponseEntity.ok("訂單已成功提交");
    } else {
        return ResponseEntity.status(HttpStatus.CONFLICT).body("操作已處理");
    }
}

// AOP切面處理
@Aspect
@Component
public class IdempotencyAspect {

    @Autowired
    private IdempotencyService idempotencyService;

    @Before("@annotation(Idempotent) && args(request,..)")
    public void checkIdempotency(JoinPoint joinPoint, IdempotentRequest request) throws Throwable {
        if (!idempotencyService.isRequestUnique(request.getRequestId())) {
            throw new IdempotencyException("Duplicate request detected.");
        }
    }
}