SpringBoot 接口幂等性的实现

1UPDATE my_table SET price=price+50,version=version+1 WHERE id=1 AND version=5

 1<?xml version="1.0" encoding="UTF-8"?>
 2<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 4    <modelVersion>4.0.0</modelVersion>
 5
 6    <parent>
 7        <groupId>org.springframework.boot</groupId>
 8        <artifactId>spring-boot-starter-parent</artifactId>
 9        <version>2.3.4.RELEASE</version>
10    </parent>
11
12    <groupId>mydlq.club</groupId>
13    <artifactId>springboot-idempotent-token</artifactId>
14    <version>0.0.1</version>
15    <name>springboot-idempotent-token</name>
16    <description>Idempotent Demo</description>
17
18    <properties>
19        <java.version>1.8</java.version>
20    </properties>
21
22    <dependencies>
23        <!--springboot web-->
24        <dependency>
25            <groupId>org.springframework.boot</groupId>
26            <artifactId>spring-boot-starter-web</artifactId>
27        </dependency>
28        <!--springboot data redis-->
29        <dependency>
30            <groupId>org.springframework.boot</groupId>
31            <artifactId>spring-boot-starter-data-redis</artifactId>
32        </dependency>
33        <dependency>
34            <groupId>org.apache.commons</groupId>
35            <artifactId>commons-pool2</artifactId>
36        </dependency>
37        <!--lombok-->
38        <dependency>
39            <groupId>org.projectlombok</groupId>
40            <artifactId>lombok</artifactId>
41        </dependency>
42    </dependencies>
43
44    <build>
45        <plugins>
46            <plugin>
47                <groupId>org.springframework.boot</groupId>
48                <artifactId>spring-boot-maven-plugin</artifactId>
49            </plugin>
50        </plugins>
51    </build>
52
53</project>

 1spring:
 2  redis:
 3    ssl: false
 4    host: 127.0.0.1
 5    port: 6379
 6    database: 0
 7    timeout: 1000
 8    password:
 9    lettuce:
10      pool:
11        max-active: 100
12        max-wait: -1
13        min-idle: 0
14        max-idle: 20

 1import java.util.Arrays;
 2import java.util.UUID;
 3import java.util.concurrent.TimeUnit;
 4import lombok.extern.slf4j.Slf4j;
 5import org.springframework.beans.factory.annotation.Autowired;
 6import org.springframework.data.redis.core.StringRedisTemplate;
 7import org.springframework.data.redis.core.script.DefaultRedisScript;
 8import org.springframework.data.redis.core.script.RedisScript;
 9import org.springframework.stereotype.Service;
10
11@Slf4j
12@Service
13public class TokenUtilService {
14
15    @Autowired
16    private StringRedisTemplate redisTemplate;
17
18    /**
19     * 存入 Redis 的 Token 键的前缀
20     */
21    private static final String IDEMPOTENT_TOKEN_PREFIX = "idempotent_token:";
22
23    /**
24     * 创建 Token 存入 Redis，并返回该 Token
25     *
26     * @param value 用于辅助验证的 value 值
27     * @return 生成的 Token 串
28     */
29    public String generateToken(String value) {
30        // 实例化生成 ID 工具对象
31        String token = UUID.randomUUID().toString();
32        // 设置存入 Redis 的 Key
33        String key = IDEMPOTENT_TOKEN_PREFIX + token;
34        // 存储 Token 到 Redis，且设置过期时间为5分钟
35        redisTemplate.opsForValue().set(key, value, 5, TimeUnit.MINUTES);
36        // 返回 Token
37        return token;
38    }
39
40    /**
41     * 验证 Token 正确性
42     *
43     * @param token token 字符串
44     * @param value value 存储在Redis中的辅助验证信息
45     * @return 验证结果
46     */
47    public boolean validToken(String token, String value) {
48        // 设置 Lua 脚本，其中 KEYS[1] 是 key，KEYS[2] 是 value
49        String script = "if redis.call('get', KEYS[1]) == KEYS[2] then return redis.call('del', KEYS[1]) else return 0 end";
50        RedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
51        // 根据 Key 前缀拼接 Key
52        String key = IDEMPOTENT_TOKEN_PREFIX + token;
53        // 执行 Lua 脚本
54        Long result = redisTemplate.execute(redisScript, Arrays.asList(key, value));
55        // 根据返回结果判断是否成功成功匹配并删除 Redis 键值对，若果结果不为空和0，则验证通过
56        if (result != null && result != 0L) {
57            log.info("验证 token={},key={},value={} 成功", token, key, value);
58            return true;
59        }
60        log.info("验证 token={},key={},value={} 失败", token, key, value);
61        return false;
62    }
63
64}

 1import lombok.extern.slf4j.Slf4j;
 2import mydlq.club.example.service.TokenUtilService;
 3import org.springframework.beans.factory.annotation.Autowired;
 4import org.springframework.web.bind.annotation.*;
 5
 6@Slf4j
 7@RestController
 8public class TokenController {
 9
10    @Autowired
11    private TokenUtilService tokenService;
12
13    /**
14     * 获取 Token 接口
15     *
16     * @return Token 串
17     */
18    @GetMapping("/token")
19    public String getToken() {
20        // 获取用户信息（这里使用模拟数据）
21        // 注：这里存储该内容只是举例，其作用为辅助验证，使其验证逻辑更安全，如这里存储用户信息，其目的为:
22        // - 1)、使用"token"验证 Redis 中是否存在对应的 Key
23        // - 2)、使用"用户信息"验证 Redis 的 Value 是否匹配。
24        String userInfo = "mydlq";
25        // 获取 Token 字符串，并返回
26        return tokenService.generateToken(userInfo);
27    }
28
29    /**
30     * 接口幂等性测试接口
31     *
32     * @param token 幂等 Token 串
33     * @return 执行结果
34     */
35    @PostMapping("/test")
36    public String test(@RequestHeader(value = "token") String token) {
37        // 获取用户信息（这里使用模拟数据）
38        String userInfo = "mydlq";
39        // 根据 Token 和与用户相关的信息到 Redis 验证是否存在对应的信息
40        boolean result = tokenService.validToken(token, userInfo);
41        // 根据验证结果响应不同信息
42        return result ? "正常调用" : "重复调用";
43    }
44
45}

 1import org.springframework.boot.SpringApplication;
 2import org.springframework.boot.autoconfigure.SpringBootApplication;
 3
 4@SpringBootApplication
 5public class Application {
 6
 7    public static void main(String[] args) {
 8        SpringApplication.run(Application.class, args);
 9    }
10
11}

 1import org.junit.Assert;
 2import org.junit.Test;
 3import org.junit.runner.RunWith;
 4import lombok.extern.slf4j.Slf4j;
 5import org.springframework.beans.factory.annotation.Autowired;
 6import org.springframework.boot.test.context.SpringBootTest;
 7import org.springframework.http.MediaType;
 8import org.springframework.test.context.junit4.SpringRunner;
 9import org.springframework.test.web.servlet.MockMvc;
10import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
11import org.springframework.test.web.servlet.setup.MockMvcBuilders;
12import org.springframework.web.context.WebApplicationContext;
13
14@Slf4j
15@SpringBootTest
16@RunWith(SpringRunner.class)
17public class IdempotenceTest {
18
19    @Autowired
20    private WebApplicationContext webApplicationContext;
21
22    @Test
23    public void interfaceIdempotenceTest() throws Exception {
24        // 初始化 MockMvc
25        MockMvc mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
26        // 调用获取 Token 接口
27        String token = mockMvc.perform(MockMvcRequestBuilders.get("/token")
28                .accept(MediaType.TEXT_HTML))
29                .andReturn()
30                .getResponse().getContentAsString();
31        log.info("获取的 Token 串：{}", token);
32        // 循环调用 5 次进行测试
33        for (int i = 1; i <= 5; i++) {
34            log.info("第{}次调用测试接口", i);
35            // 调用验证接口并打印结果
36            String result = mockMvc.perform(MockMvcRequestBuilders.post("/test")
37                    .header("token", token)
38                    .accept(MediaType.TEXT_HTML))
39                    .andReturn().getResponse().getContentAsString();
40            log.info(result);
41            // 结果断言
42            if (i == 0) {
43                Assert.assertEquals(result, "正常调用");
44            } else {
45                Assert.assertEquals(result, "重复调用");
46            }
47        }
48    }
49
50}

 1[main] IdempotenceTest:  获取的 Token 串：980ea707-ce2e-456e-a059-0a03332110b4
 2[main] IdempotenceTest:  第1次调用测试接口
 3[main] IdempotenceTest:  正常调用
 4[main] IdempotenceTest:  第2次调用测试接口
 5[main] IdempotenceTest:  重复调用
 6[main] IdempotenceTest:  第3次调用测试接口
 7[main] IdempotenceTest:  重复调用
 8[main] IdempotenceTest:  第4次调用测试接口
 9[main] IdempotenceTest:  重复调用
10[main] IdempotenceTest:  第5次调用测试接口
11[main] IdempotenceTest:  重复调用