SpringBoot中接口幂等性的5种实现方法详解_Java

1. 幂等性的概念与重要性

1.1 什么是幂等性

幂等性（idempotence）是指无论对同一操作执行多少次，结果都是相同的。在api设计中，幂等性确保了重复请求不会导致意外的副作用。

1.2 为什么需要幂等性

网络波动：网络不稳定可能导致请求重复发送
客户端重试：客户端在超时后可能会重试请求
用户误操作：用户可能重复点击提交按钮
分布式系统：分布式环境下，消息可能重复投递

1.3 幂等性的应用场景

支付接口
订单创建接口
数据更新接口
资源创建接口

2. 实现方案

方案一：基于数据库唯一索引

实现原理

通过在数据库表中添加唯一索引，确保重复的请求不会导致数据重复插入。

核心源码

数据库表设计：

create table `order` (
  `id` bigint(20) not null auto_increment,
  `order_no` varchar(32) not null comment '订单号',
  `user_id` bigint(20) not null comment '用户id',
  `amount` decimal(10,2) not null comment '金额',
  `status` int(11) not null comment '状态',
  `create_time` datetime not null comment '创建时间',
  primary key (`id`),
  unique key `uk_order_no` (`order_no`) comment '订单号唯一索引'
) engine=innodb default charset=utf8mb4 comment='订单表';

service层实现：

@service
public class orderservice {
    @autowired
    private ordermapper ordermapper;
    
    @transactional
    public order createorder(ordercreaterequest request) {
        // 生成唯一订单号
        string orderno = generateorderno();
        
        order order = new order();
        order.setorderno(orderno);
        order.setuserid(request.getuserid());
        order.setamount(request.getamount());
        order.setstatus(0);
        order.setcreatetime(new date());
        
        try {
            ordermapper.insert(order);
            return order;
        } catch (duplicatekeyexception e) {
            // 唯一索引冲突，说明订单已存在
            return ordermapper.selectbyorderno(orderno);
        }
    }
    
    private string generateorderno() {
        // 生成唯一订单号的逻辑
        return "ord" + system.currenttimemillis() + randomutil.randomstring(6);
    }
}

优劣势分析

优点：

实现简单，依赖数据库自身的约束
可靠性高，数据库保证唯一性

缺点：

仅适用于插入操作
并发性能受数据库限制
错误处理需要捕获异常

适用场景

订单创建
用户注册
资源分配

方案二：基于token令牌

实现原理

客户端请求获取令牌
服务端生成唯一令牌并存储
客户端携带令牌发起请求
服务端验证令牌并执行操作
操作完成后删除令牌

核心源码

token生成与验证：

@component
public class idempotenttokenservice {
    @autowired
    private redistemplate<string, object> redistemplate;
    
    /**
     * 生成幂等性令牌
     */
    public string generatetoken() {
        string token = uuid.randomuuid().tostring();
        // 存储令牌，设置过期时间为5分钟
        redistemplate.opsforvalue().set("idempotent_token:" + token, token, 5, timeunit.minutes);
        return token;
    }
    
    /**
     * 验证令牌
     */
    public boolean validatetoken(string token) {
        if (stringutils.isempty(token)) {
            return false;
        }
        string key = "idempotent_token:" + token;
        // 原子操作，获取并删除令牌
        return redistemplate.delete(key);
    }
}

controller层实现：

@restcontroller
@requestmapping("/api/order")
public class ordercontroller {
    @autowired
    private idempotenttokenservice idempotenttokenservice;
    @autowired
    private orderservice orderservice;
    
    /**
     * 获取幂等性令牌
     */
    @getmapping("/token")
    public responseentity<string> gettoken() {
        string token = idempotenttokenservice.generatetoken();
        return responseentity.ok(token);
    }
    
    /**
     * 创建订单
     */
    @postmapping
    public responseentity<order> createorder(@requestheader("x-idempotent-token") string token, 
                                           @requestbody ordercreaterequest request) {
        // 验证令牌
        if (!idempotenttokenservice.validatetoken(token)) {
            return responseentity.badrequest().build();
        }
        
        order order = orderservice.createorder(request);
        return responseentity.ok(order);
    }
}

优劣势分析

优点：

适用范围广，可用于各种操作
实现灵活，可自定义过期时间
性能较好，基于redis操作

缺点：

需要额外的redis存储
增加了请求次数（获取令牌）
客户端需要额外处理令牌

适用场景

支付接口
表单提交
数据更新

方案三：基于分布式锁

实现原理

通过分布式锁确保同一时间只有一个请求执行操作，避免并发问题。

核心源码

分布式锁实现：

@component
public class distributedlockservice {
    @autowired
    private redistemplate<string, object> redistemplate;
    
    /**
     * 获取分布式锁
     */
    public boolean trylock(string key, long expiretime) {
        boolean result = redistemplate.opsforvalue().setifabsent(key, "locked", expiretime, timeunit.milliseconds);
        return boolean.true.equals(result);
    }
    
    /**
     * 释放分布式锁
     */
    public void releaselock(string key) {
        redistemplate.delete(key);
    }
}

service层实现：

@service
public class paymentservice {
    @autowired
    private distributedlockservice distributedlockservice;
    @autowired
    private paymentmapper paymentmapper;
    
    public payment processpayment(paymentrequest request) {
        // 生成锁键
        string lockkey = "payment_lock:" + request.getorderno();
        
        try {
            // 尝试获取锁，设置过期时间为30秒
            if (!distributedlockservice.trylock(lockkey, 30000)) {
                throw new businessexception("支付处理中，请稍后再试");
            }
            
            // 检查是否已支付
            payment existingpayment = paymentmapper.selectbyorderno(request.getorderno());
            if (existingpayment != null && existingpayment.getstatus() == 1) {
                return existingpayment;
            }
            
            // 处理支付逻辑
            payment payment = new payment();
            payment.setorderno(request.getorderno());
            payment.setamount(request.getamount());
            payment.setstatus(1);
            payment.setcreatetime(new date());
            
            paymentmapper.insert(payment);
            return payment;
        } finally {
            // 释放锁
            distributedlockservice.releaselock(lockkey);
        }
    }
}

优劣势分析

优点：

适用范围广，可用于各种操作
支持并发场景
实现灵活，可自定义锁的粒度

缺点：

依赖分布式锁实现
可能存在锁竞争问题
实现复杂度较高

适用场景

支付处理
库存扣减
数据同步

方案四：基于redis实现

实现原理

通过redis的原子操作（如setnx）实现幂等性控制。

核心源码

redis幂等性实现：

@component
public class redisidempotentservice {
    @autowired
    private redistemplate<string, object> redistemplate;
    
    /**
     * 检查并设置幂等性键
     */
    public boolean checkandset(string key, long expiretime) {
        boolean result = redistemplate.opsforvalue().setifabsent(key, "processed", expiretime, timeunit.milliseconds);
        return boolean.true.equals(result);
    }
    
    /**
     * 生成幂等性键
     */
    public string generatekey(string prefix, string... params) {
        stringbuilder sb = new stringbuilder(prefix);
        for (string param : params) {
            sb.append(":").append(param);
        }
        return sb.tostring();
    }
}

service层实现：

@service
public class orderservice {
    @autowired
    private redisidempotentservice redisidempotentservice;
    @autowired
    private ordermapper ordermapper;
    
    public order createorder(ordercreaterequest request) {
        // 生成幂等性键
        string key = redisidempotentservice.generatekey("order_create", 
                                                     request.getuserid(), 
                                                     request.getproductid());
        
        // 检查是否已处理
        if (!redisidempotentservice.checkandset(key, 30000)) {
            throw new businessexception("订单已处理，请不要重复提交");
        }
        
        // 创建订单逻辑
        order order = new order();
        order.setuserid(request.getuserid());
        order.setproductid(request.getproductid());
        order.setamount(request.getamount());
        order.setstatus(0);
        order.setcreatetime(new date());
        
        ordermapper.insert(order);
        return order;
    }
}

优劣势分析

优点：

实现简单，基于redis原子操作
性能优异，redis操作速度快
适用范围广

缺点：

依赖redis服务
需要合理设置过期时间
键的设计需要考虑唯一性

适用场景

高频接口
表单提交
数据更新

方案五：基于乐观锁

实现原理

通过版本号或时间戳实现乐观锁，确保数据更新的一致性。

核心源码

数据库表设计：

create table `product` (
  `id` bigint(20) not null auto_increment,
  `name` varchar(100) not null comment '产品名称',
  `stock` int(11) not null comment '库存',
  `version` int(11) not null default '0' comment '版本号',
  `update_time` datetime not null comment '更新时间',
  primary key (`id`)
) engine=innodb default charset=utf8mb4 comment='产品表';

service层实现：

@service
public class productservice {
    @autowired
    private productmapper productmapper;
    
    @transactional
    public boolean deductstock(long productid, int quantity) {
        // 获取产品信息
        product product = productmapper.selectbyid(productid);
        if (product == null) {
            throw new businessexception("产品不存在");
        }
        
        // 检查库存
        if (product.getstock() < quantity) {
            throw new businessexception("库存不足");
        }
        
        // 更新库存，使用乐观锁
        int result = productmapper.updatestock(productid, quantity, product.getversion());
        if (result == 0) {
            // 更新失败，说明版本号已变化
            throw new businessexception("库存更新失败，请重试");
        }
        
        return true;
    }
}

mapper层实现：

public interface productmapper {
    @update("update product set stock = stock - #{quantity}, version = version + 1, update_time = now() where id = #{productid} and version = #{version}")
    int updatestock(@param("productid") long productid, @param("quantity") int quantity, @param("version") int version);
}

优劣势分析

优点：

实现简单，基于数据库版本号
无锁设计，并发性能好
适用于更新操作

缺点：

仅适用于更新操作
可能需要重试机制
实现复杂度较高

适用场景

库存扣减
数据更新
状态变更

3. 方案比较

方案	实现复杂度	性能	可靠性	适用场景	依赖
基于数据库唯一索引	低	中	高	插入操作	数据库
基于token令牌	中	高	高	各种操作	redis
基于分布式锁	高	中	高	并发操作	redis/zookeeper
基于redis实现	中	高	高	各种操作	redis
基于乐观锁	中	高	中	更新操作	数据库

4. 最佳实践

4.1 选择合适的方案

插入操作：优先使用基于数据库唯一索引的方案
更新操作：优先使用基于乐观锁的方案
高频接口：优先使用基于redis的方案
并发操作：优先使用基于分布式锁的方案
通用场景：优先使用基于token令牌的方案

4.2 性能优化

合理设置过期时间：根据业务场景设置适当的过期时间
批量处理：对于批量操作，考虑批量验证幂等性
异步处理：对于耗时操作，考虑异步处理幂等性验证
缓存优化：使用redis集群提高性能和可靠性

4.3 安全性考虑

防止token泄露：使用https传输token
防止暴力破解：限制token验证失败次数
防止重放攻击：使用时间戳或随机数
数据加密：对敏感数据进行加密存储

4.4 代码示例：综合方案

@restcontroller
@requestmapping("/api/payment")
public class paymentcontroller {
    @autowired
    private idempotenttokenservice idempotenttokenservice;
    @autowired
    private paymentservice paymentservice;
    
    @getmapping("/token")
    public responseentity<string> gettoken() {
        string token = idempotenttokenservice.generatetoken();
        return responseentity.ok(token);
    }
    
    @postmapping
    public responseentity<payment> processpayment(@requestheader("x-idempotent-token") string token, 
                                               @requestbody paymentrequest request) {
        // 1. 验证token
        if (!idempotenttokenservice.validatetoken(token)) {
            return responseentity.badrequest().body(null);
        }
        
        // 2. 处理支付
        payment payment = paymentservice.processpayment(request);
        return responseentity.ok(payment);
    }
}

@service
public class paymentservice {
    @autowired
    private distributedlockservice distributedlockservice;
    @autowired
    private paymentmapper paymentmapper;
    
    public payment processpayment(paymentrequest request) {
        string lockkey = "payment_lock:" + request.getorderno();
        
        try {
            // 3. 获取分布式锁
            if (!distributedlockservice.trylock(lockkey, 30000)) {
                throw new businessexception("支付处理中，请稍后再试");
            }
            
            // 4. 检查是否已支付
            payment existingpayment = paymentmapper.selectbyorderno(request.getorderno());
            if (existingpayment != null && existingpayment.getstatus() == 1) {
                return existingpayment;
            }
            
            // 5. 处理支付逻辑
            payment payment = new payment();
            payment.setorderno(request.getorderno());
            payment.setamount(request.getamount());
            payment.setstatus(1);
            payment.setcreatetime(new date());
            
            paymentmapper.insert(payment);
            return payment;
        } finally {
            // 6. 释放锁
            distributedlockservice.releaselock(lockkey);
        }
    }
}