确保接口幂等性：Redisson 的分布式锁与布隆过滤器的应用

小媛要早睡吖

于 2024-12-17 11:38:26 发布

阅读量1.4k

点赞数 38

文章标签： redis 分布式数据库

本文链接：https://blog.csdn.net/qq_50134188/article/details/144530000

版权

前言

在微服务架构下，上游系统与下游系统之间进行交易时，如何保证交易操作的幂等性是一个至关重要的问题。作为中间系统，我们的责任是确保交易请求的唯一性，防止同一交易请求被多次执行，从而导致数据的不一致或重复交易。在这个场景下，我们通常会借助 Redis 的分布式锁和布隆过滤器来实现接口的幂等性。

什么是接口幂等性？

幂等性是指接口在多次调用的情况下，得到的结果是一致的，即无论接口调用多少次，返回的结果应该是相同的。对于交易系统而言，接口幂等性至关重要，因为交易一旦被执行多次，可能导致用户重复扣款、重复发送消息等问题。

需求背景

在我们这个中间系统中，负责处理来自上游系统的交易请求，并将请求转发到下游系统进行处理。交易操作需要遵循以下流程：

接收交易请求：接收到上游系统的交易请求，包含 uid 和交易信息。
判断交易请求是否已处理：通过 uid 判断该交易是否已经处理过。如果已处理，则不重复处理；如果未处理，则进行后续操作。
执行交易：调用下游系统接口进行交易处理。
返回结果：返回交易处理的结果。

在这个流程中，确保交易请求的幂等性是至关重要的。为了防止同一请求被多次执行，我们可以使用 Redis 分布式锁和布隆过滤器来实现幂等性控制。

1. Redisson 分布式锁

什么是 Redisson？

Redisson 是一个 Redis 客户端，提供了丰富的分布式数据结构，其中包括分布式锁、分布式集合、分布式队列等。它在性能和易用性上都表现得非常出色，适用于分布式应用的场景。

为什么使用 Redisson 分布式锁？

在分布式系统中，多个节点并发处理相同的请求时，可能会导致重复处理同一个交易。为了确保同一时间内只有一个节点能处理某个请求，我们需要一个锁来串行化请求。Redisson 提供了分布式锁机制，可以保证在多个 Redis 客户端间获取锁的唯一性。

Redisson 提供了 getLock 方法，可以轻松地实现分布式锁。

Redisson 分布式锁的实现

通过 uid 作为锁的唯一标识，我们可以确保同一 uid 的请求只会被处理一次。以下是使用 Redisson 实现分布式锁的代码示例：

import org.redisson.api.RedissonClient;
import org.redisson.api.RLock;
import org.redisson.Redisson;
import org.redisson.config.Config;

public class TransactionService {

    private RedissonClient redissonClient;
    private BloomFilter bloomFilter;

    public TransactionService(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
        this.bloomFilter = new BloomFilter(1000000, 0.01);  // 初始化布隆过滤器
    }

    public void processTransaction(String uid, String transactionData) {
        // 检查布隆过滤器，判断交易是否已经处理过
        if (bloomFilter.test(uid)) {
            System.out.println("Transaction already processed");
            return;
        }

        // 获取分布式锁
        RLock lock = redissonClient.getLock("lock:transaction:" + uid);

        try {
            // 尝试获取锁
            if (lock.tryLock()) {
                try {
                    // 执行交易处理
                    performTransaction(transactionData);
                    System.out.println("Transaction processed successfully");

                    // 将 uid 添加到布隆过滤器中，防止重复处理
                    bloomFilter.add(uid);

                } finally {
                    // 释放锁
                    lock.unlock();
                }
            } else {
                System.out.println("Transaction already being processed");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("Transaction processing interrupted");
        }
    }

    private void performTransaction(String transactionData) {
        // 执行交易的具体逻辑，例如调用下游系统接口等
        System.out.println("Performing transaction with data: " + transactionData);
    }
}

关键点：

使用 getLock("lock:transaction:" + uid) 创建一个唯一的锁，防止多个节点同时处理相同的交易。
lock.tryLock() 尝试获取锁，成功获取后继续执行交易处理逻辑，失败则表示该请求正在被其他节点处理。
在处理完交易后，释放锁 lock.unlock()。

2. 布隆过滤器

什么是布隆过滤器？

布隆过滤器（Bloom Filter）是一种高效的概率型数据结构，用于检测元素是否在集合中。它具有如下特点：

高效：查找操作非常快速，且内存占用小。
有误判：可能会误判某个元素存在，但绝不会漏判。

在交易场景中，布隆过滤器可以用来判断某个 uid 是否已经处理过。如果已经处理过，表示该交易请求已经执行过，可以跳过；如果没有处理过，则继续执行交易，并将 uid 添加到布隆过滤器中。

布隆过滤器的实现

import org.redisson.api.RedissonClient;

public class BloomFilter {

    private Set<String> filter;

    public BloomFilter(int capacity, double errorRate) {
        // 这里是一个简化版的布隆过滤器实现，实际应用中可以使用 Redis 自带的布隆过滤器等工具
        filter = new HashSet<>();
    }

    public boolean test(String uid) {
        // 判断元素是否存在
        return filter.contains(uid);
    }

    public void add(String uid) {
        // 向布隆过滤器中添加元素
        filter.add(uid);
    }
}