網際網路API介面冪等設計

阿新 • • 發佈：2018-11-08

冪等性概念：保證唯一的意思如何防止介面不能重複提交===保證介面冪等性

介面冪等產生原因：1.rpc呼叫時網路延遲（重試傳送請求） 2.表單重複提交

解決思路：redis+token,使用Tonken令牌，保證臨時且唯一,將token放入redis中，並設定過期時間

如何使用Token 解決冪等性,步驟：
1.在調介面之前生成對應的令牌（Token），存放在Redis
2.呼叫介面的時候，將該令牌放入請求頭中 | 表單隱藏域中
3.介面獲取對應的令牌，如果能夠獲取該令牌（將當前令牌刪除掉）就直接執行該訪問的業務邏輯
4.介面獲取對應的令牌，如果獲取不到該令牌，直接返回請勿重複提交

程式碼部分，使用AOP自定義註解方式對Token進行驗證. 防止表單重複提交中，使用AOP註解方式生成Token
1.rpc呼叫時網路延遲（重試傳送請求）

pom.xml

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.3.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- 引入redis的依賴包 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.28</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.36</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.1</version>
    </dependency>

</dependencies>

application.properties

# REDIS (RedisProperties)
# Redis資料庫索引（預設為0）
spring.redis.database=0
# Redis伺服器地址
spring.redis.host=localhost
# Redis伺服器連線埠
spring.redis.port=6379
# Redis伺服器連線密碼（預設為空）
spring.redis.password=
# 連線池最大連線數（使用負值表示沒有限制）
spring.redis.jedis.pool.max-active=8
# 連線池最大阻塞等待時間（使用負值表示沒有限制）
spring.redis.jedis.pool.max-wait=-1
# 連線池中的最大空閒連線
spring.redis.jedis.pool.max-idle=8
# 連線池中的最小空閒連線
spring.redis.jedis.pool.min-idle=0
# 連線超時時間（毫秒）
spring.redis.timeout=5000

mybatis.configuration.map-underscore-to-camel-case=true
mybatis.mapper-locations=mybatis/**/*Mapper.xml
mybatis.type-aliases-package=com.yz.entity

spring.datasource.url=jdbc:mysql://localhost:3306/test01
spring.datasource.username=root
spring.datasource.password=1234
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.UUID;

/**
 * 生成token,放入redis中
 * Created by yz on 2018/7/29.
 */
@Component
public class RedisToken {

    @Autowired
    private BaseRedisService baseRedisService;

    private static final long TOKENTIME = 60*60;

    public String getToken(){
        String token = "token"+UUID.randomUUID();
        baseRedisService.setString(token,token,TOKENTIME);
        return token;
    }

    public boolean checkToken(String tokenKey){
        String tokenValue = baseRedisService.getString(tokenKey);
        if(StringUtils.isEmpty(tokenValue)){
            return false;
        }
        // 保證每個介面對應的token只能訪問一次，保證介面冪等性問題
        baseRedisService.delKey(tokenKey);
        return true;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * 整合封裝redis
 * Created by yz on 2018/7/29.
 */
@Component
public class BaseRedisService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public void setString(String key,Object data,Long timeout){
        if(data instanceof String){
            String value = (String) data;
            stringRedisTemplate.opsForValue().set(key,value);
        }
        if(timeout != null){
            stringRedisTemplate.expire(key,timeout,TimeUnit.SECONDS);
        }
    }

    public String getString(String key){
        return stringRedisTemplate.opsForValue().get(key);
    }

    public void delKey(String key){
        stringRedisTemplate.delete(key);
    }
}

import com.yz.entity.User;
import com.yz.service.UserService;
import com.yz.utils.RedisToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * 處理rpc呼叫請求
 * Created by yz on 2018/7/29.
 */
@RestController
public class UserController {

    @Autowired
    private RedisToken redisToken;

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/createRedisToken")
    public String createRedisToken(){
        return redisToken.getToken();
    }

    @RequestMapping(value = "/addUser")
    public String addOrder(User user, HttpServletRequest request){
        // 獲取請求頭中的token令牌
        String token = request.getHeader("token");
        if(StringUtils.isEmpty(token)){
            return "引數錯誤";
        }
        // 校驗token
        boolean isToken = redisToken.checkToken(token);
        if(!isToken){
            return "請勿重複提交!";
        }
        // 業務邏輯
        int result = userService.addUser(user);
        return result >0 ? "新增成功" : "新增失敗";
    }

}

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan("com.yz.mapper")
@SpringBootApplication
public class YzApplication {

    public static void main(String[] args) {
        SpringApplication.run(YzApplication.class, args);
    }
}

測試效果：

獲取token

請求介面

再次請求：

將程式碼改造成AOP註解方式實現

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

/**
 * 解決介面冪等性問題,支援網路延遲和表單提交
 * Created by yz on 2018/7/29.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckToken {
    // 區分請求來源
    String type();
}

import com.yz.annotation.CheckToken;
import com.yz.utils.ConstantUtils;
import com.yz.utils.RedisToken;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * 介面冪等切面
 * Created by yz on 2018/7/29.
 */
@Aspect
@Component
public class ExtApiAopIdempotent {

    @Autowired
    private RedisToken redisToken;

    // 切入點，攔截所有請求
    @Pointcut("execution(public * com.yz.controller.*.*(..))")
    public void rlAop(){}

    // 環繞通知攔截所有訪問
    @Around("rlAop()")
    public Object doBefore(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        // 判斷方法上是否有加ExtApiAopIdempotent註解
        MethodSignature methodSignature = (MethodSignature) proceedingJoinPoint.getSignature();
        CheckToken declaredAnnotation = methodSignature.getMethod().getDeclaredAnnotation(CheckToken.class);
        if(declaredAnnotation != null){
            String type = declaredAnnotation.type();
            String token = null;
            HttpServletRequest request = getRequest();
            if(type.equals(ConstantUtils.EXTAPIHEAD)){
                // 獲取請求頭中的token令牌
                token = request.getHeader("token");
            }else{
                // 從表單中獲取token
                token = request.getParameter("token");
            }
            if(StringUtils.isEmpty(token)){
                return "引數錯誤";
            }
            // 校驗token
            boolean isToken = redisToken.checkToken(token);
            if(!isToken){
                return "請勿重複提交!";
            }
        }
        // 放行
        Object proceed = proceedingJoinPoint.proceed();
        return proceed;
    }

    public HttpServletRequest getRequest(){
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        return request;
    }

    public void response(String msg)throws IOException{
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletResponse response = attributes.getResponse();
        response.setHeader("Content-type","text/html;charset=UTF-8");
        PrintWriter writer = response.getWriter();
        try {
            writer.print(msg);
        } finally {
            writer.close();
        }
    }

}

controller使用@CheckToken註解：

import com.yz.annotation.CheckToken;
import com.yz.entity.User;
import com.yz.service.UserService;
import com.yz.utils.ConstantUtils;
import com.yz.utils.RedisToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * 處理rpc呼叫請求
 * Created by yz on 2018/7/29.
 */
@RestController
public class UserController {

    @Autowired
    private RedisToken redisToken;

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/createRedisToken")
    public String createRedisToken(){
        return redisToken.getToken();
    }

    // 使用CheckToken註解方式保證請求冪等性
    @RequestMapping(value = "/addUser")
    @CheckToken(type = ConstantUtils.EXTAPIHEAD)
    public String addOrder(User user, HttpServletRequest request){
        // 業務邏輯
        int result = userService.addUser(user);
        return result >0 ? "新增成功" : "新增失敗";
    }

}

執行效果：

2.表單重複提交

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp
spring.http.encoding.force=true
spring.http.encoding.charset=UTF-8
spring.http.encoding.enabled=true
server.tomcat.uri-encoding=UTF-8

index.jsp

<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/addUserForPage" method="post">
    <input type="hidden" id="token" name="token" value="${token}">
        name: <input id="name" name="name" />
    <p>
        age:  <input id="age" name="age" />
    <p>
        <input type="submit" value="submit" />
</form>
</body>
</html>

import com.yz.annotation.CheckToken;
import com.yz.entity.User;
import com.yz.service.UserService;
import com.yz.utils.ConstantUtils;
import com.yz.utils.RedisToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;

/**
 * 處理表單提交請求
 * Created by yz on 2018/7/29.
 */
@Controller
public class UserPageController {

    @Autowired
    private RedisToken redisToken;

    @Autowired
    private UserService userService;

    /**
     * 頁面跳轉
     * @param req
     * @return
     */
    @RequestMapping("/indexPage")
    public String indexPage(HttpServletRequest req){
        req.setAttribute("token",redisToken.getToken());
        return "index";
    }

    // 使用CheckToken註解方式保證請求冪等性
    @RequestMapping(value = "/addUserForPage")
    @CheckToken(type = ConstantUtils.EXTAPIFROM)
    @ResponseBody
    public String addOrder(User user, HttpServletRequest request){
        // 業務邏輯
        int result = userService.addUser(user);
        return result >0 ? "新增成功" : "新增失敗";
    }
}

自定義註解生成Token,將 req.setAttribute("token",redisToken.getToken()); 放在AOP中，減少程式碼冗餘：

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

/**
 * 自定義註解生成Token
 * Created by yz on 2018/7/29.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CreatToken {
}

// 切入點，攔截所有請求
@Pointcut("execution(public * com.yz.controller.*.*(..))")
public void rlAop(){}

// 前置通知，生成Token
@Before("rlAop()")
public void before(JoinPoint point){
    MethodSignature signature = (MethodSignature) point.getSignature();
    CreatToken declaredAnnotation = signature.getMethod().getDeclaredAnnotation(CreatToken.class);
    if(declaredAnnotation != null){
        getRequest().setAttribute("token",redisToken.getToken());
    }
}

import com.yz.annotation.CheckToken;
import com.yz.annotation.CreatToken;
import com.yz.entity.User;
import com.yz.service.UserService;
import com.yz.utils.ConstantUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;

/**
 * 處理表單提交請求
 * Created by yz on 2018/7/29.
 */
@Controller
public class UserPageController {

    @Autowired
    private UserService userService;

    /**
     * 頁面跳轉,使用自定義註解生成token,傳遞到跳轉頁面中
     * @param req
     * @return
     */
    @RequestMapping("/indexPage")
    @CreatToken
    public String indexPage(HttpServletRequest req){
        //req.setAttribute("token",redisToken.getToken());
        return "index";
    }

    // 使用CheckToken註解方式保證請求冪等性
    @RequestMapping(value = "/addUserForPage")
    @CheckToken(type = ConstantUtils.EXTAPIFROM)
    @ResponseBody
    public String addOrder(User user, HttpServletRequest request){
        // 業務邏輯
        int result = userService.addUser(user);
        return result >0 ? "新增成功" : "新增失敗";
    }
}

請求頁面的時候，AOP註解會將建立好的token傳入到頁面中：

程式碼下載地址：https://github.com/yangzeng1211/api_idempotent.git

網際網路API介面冪等設計

冪等性概念：保證唯一的意思如何防止介面不能重複提交===保證介面冪等性介面冪等產生原因：1.rpc呼叫時網路延遲（重試傳送請求） 2.表單重複提交解決思路：redis+token,使用Tonken令牌，保證臨時且唯一,將token放入redis中，並設定過期時間如何使

網際網路 API 介面冪等性設計

WEB 資源或 API 方法的冪等性是指一次和多次請求某一個資源應該具有同樣的副作用。冪等性是系統的介面對外一種承諾(而不是實現), 承諾只要呼叫介面成功, 外部多次呼叫對系統的影響是一致的。冪等性是分散式系統設計中的一個重要概念，對超時處理、系統恢復等具有重要意義。宣告為冪

基於redis的API介面冪等設計

在網際網路API介面中，由於網路超時、手動重新整理等經常導致客戶端重複提交資料到服務端，這就要求在設計API介面時做好冪等控制。尤其是在面向微服務架構的系統中，系統間的呼叫非常頻繁，如果不做好冪等性設定，輕則會導致髒資料入庫，重則導致資損。本例基於Redi

服務介面的冪等設計

介面冪等什麼是介面冪等？就是一個介面，被重複呼叫多次，卻能夠保證對系統內部產生的影響是一致的，也就是呼叫多次和呼叫一次，資料的變化是一樣的，是相同的，不會因為呼叫多次而出現任何資料問題。分散式系統中，介面冪等性是系統可行性論證的第一個步驟。很多地方需要把介面設計成冪等。思路基本上是3種： 1 當第N

架構設計 | 介面冪等性原則，防重複提交Token管理

本文原始碼：[GitHub·點這裡](https://github.com/cicadasmile/data-manage-parent) || [GitEE·點這裡](https://gitee.com/cicadasmile/data-manage-parent) # 一、冪等性概念 ## 1、冪等

程式設計冪等設計：資料最終一致性的保證

冪等定義冪等（idempotent、idempotence）是一個數學與計算機學概念，常見於抽象代數中。在程式設計中.一個冪等操作的特點是其任意多次執行所產生的影響均與一次執行的影響相同。冪等函式，或冪等方法，是指可以使用相同引數重複執行，並能獲得相同結果的函式。這些函式不會影響系統狀態，也

介面冪等的重要性

介面冪等是說，用相同的引數，呼叫一次和呼叫多次，其返回的結果應該是一樣的。比如一個介面時用來儲存資料的，那如果使用者在頁面上，連續兩次點選提交(點選提交後，頁面加遮罩層除外)，那勢必會發送2次請求，如果介面沒有做冪等，資料庫肯定被插入了2條相同資料如何把

分散式處理冪等設計

最近做的專案的效能調優中關於冪等設計的一些總結場景：假設有這樣一個方法，包含了一些DB操作，check if existing then update else save. 如果兩個執行緒同時去執行這個方法，並且他們處理的是同一條資料，期望應該是其中一個執行緒是save，

如何處理介面冪等性問題

在微服務架構下，我們在完成一個訂單流程時經常遇到下面的場景：一個訂單建立介面，第一次呼叫超時了，然後呼叫方重試了一次在訂單建立時，我們需要去扣減庫存，這時介面發生了超時，呼叫方重試了一次當這筆訂單開始支付，在支付請求發出之後，在服務端發生了扣錢操作，介面響應超時了，呼

分散式系統中的冪等設計

前言現如今我們的系統大多拆分為分散式SOA，或者微服務，一套系統中包含了多個子系統服務，而一個子系統服務往往會去呼叫另一個服務，而服務呼叫服務無非就是使用RPC通訊或者restful，既然是通訊，那麼就有可能再伺服器處理完畢後返回結果的時候掛掉，這個時候使用者端發現很久沒

系統冪等設計

開發十年，就只剩下這套架構體系了！ >>>

穩定性三十六計-冪等設計

引子群裡發了一個總共1千元的拼手氣紅包，共10個。靜兒點進去，額，搶到了0.05元。這個不甘心啊。退出來重新打開了這個紅包，你猜怎樣？顯示我搶到了0.05元！這就是冪等(idempotence)，不管多少次請求某一個資源，對資源都具有相同的影響。冪等性是系統的介面對外一種承諾，承諾只要呼叫介

介面冪等性的解決方案

在程式設計中，冪等操作的特點是其任意多次執行所產生的影響均與一次執行的影響相同。冪等函式指的是那些使用相同引數重複執行也能獲得相同結果的函式。這些函式不會影響系統狀態，也不用擔心重複執行會對系統造成改變。比如說getIdCard()函式和setTrue()函式就是冪等函式。冪等在我的理解裡就是，一個操作不

深入理解冪等性及Restful風格API的冪等性問題詳解

什麼是冪等性 HTTP/1.1中對冪等性的定義是：一次和多次請求某一個資源對於資源本身應該具有同樣的結果（網路超時等問題除外）。也就是說，其任意多次執行對資源本身所產生的影響均與一次執行的影響相同。這裡需要關注幾個重點：冪等不僅僅只是一次（或多次）請求對資源沒有副作用（比如查詢資料庫操作，沒有增刪改，因此

介面冪等性如何實現？

導讀轉載自冪等性如何實現？深入瞭解一波！！！現在這個時代大家可能最關心的就是錢了，那麼有沒有想過你銀行轉賬給你沒有一次是轉多的，要麼失敗，要麼成功，為什麼不能失誤一下多轉一筆呢？醒醒吧年輕人，別做夢了，做銀行的能那麼傻x嗎？今天我們就來談一談為什麼銀行轉賬不能多給我轉一筆？關乎到錢的問題，小夥伴們打起

實現介面冪等性的幾種方案

搶微信紅包的時候我們都知道：一個紅包一旦你搶過之後，以後無論你點多少次都是一樣的結果。紅包會提示你已經搶過此紅包，而不會讓你再搶一次。搶紅包介面就是一個非常典型的冪等介面，搶一次和搶多次具有一樣的效果。類似的介面在我們的開發過程中會有很多，比如在電商的下單過程中： > 訂單建立介面,第一次呼叫返回超時了

API介面的安全設計驗證—ticket，簽名，時間戳

概述與前端對接的API介面，如果被第三方抓包並進行惡意篡改引數，可能會導致資料洩露，甚至會被篡改資料，我主要圍繞時間戳，token，簽名三個部分來保證API介面的安全性 1.使用者成功登陸站點後，伺服器會返回一個token，使用者的任何操作都必須帶了這個引數，可以將這個引數直接放到header裡。 2.客

Java學習資料支付介面的冪等性設計

1. 什麼是冪等性？在數學中的冪等性定義：在某二元運算下，冪等元素是指被自己重複運算(或對於函式是為複合)的結果等於它自己的元素。例如，乘法下唯一兩個冪等實數為0和1。即 s * s = s 某一元運算為冪等時，其作用在任一元素兩次後會和其作用一次的結果相同。例如，高斯符號便是冪等的，即f(f(x

動力節點Java學習資料支付介面的冪等性設計

1. 什麼是冪等性？在數學中的冪等性定義：在某二元運算下，冪等元素是指被自己重複運算(或對於函式是為複合)的結果等於它自己的元素。例如，乘法下唯一兩個冪等實數為0和1。即 s * s = s 某一元運算為冪等時，其作用在任一元素兩次後會和其作用一次的結果相同。例如，高斯符號便是

34、分散式服務介面的冪等性如何設計（比如不能重複扣款）？

1、面試題分散式服務介面的冪等性如何設計（比如不能重複扣款）？ 2、面試官心裡分析從這個問題開始，面試官就已經進入了實際的生產問題的面試了。一個分散式系統中的某個介面，要保證冪等性，該如何保證？這個事兒其實是你做分散式系統的時候必須要考慮的一個生產環境的技術問題。啥意思呢？

網際網路API介面冪等設計

相關推薦