在實際的業務中，難免會跟第三方系統進行數據的交互與傳遞，那么如何保證數據在傳輸過程中的安全呢（防竊取）？除了https的協議之外，能不能加上通用的一套算法以及規范來保證傳輸的安全性呢？

下面我們就來討論下常用的一些API設計的安全方法，可能不一定是最好的，有更牛逼的實現方式，但是這篇是我自己的經驗分享.

一、token 簡介

Token：訪問令牌access token, 用于接口中, 用于標識接口調用者的身份、憑證，減少用戶名和密碼的傳輸次數。一般情況下客戶端(接口調用方)需要先向服務器端申請一個接口調用的賬號，服務器會給出一個AppId和一個key, key用于參數簽名使用，注意key保存到客戶端，需要做一些安全處理，防止泄露。

Token的值一般是UUID，服務端生成Token后需要將token做為key，將一些和token關聯的信息作為value保存到緩存服務器中(redis)，當一個請求過來后，服務器就去緩存服務器中查詢這個Token是否存在，存在則調用接口，不存在返回接口錯誤，一般通過攔截器或者過濾器來實現，Token分為兩種：

API Token(接口令牌): 用于訪問不需要用戶登錄的接口，如登錄、注冊、一些基本數據的獲取等。獲取接口令牌需要拿appId、timestamp和sign來換，sign=加密(timestamp+key) USER Token(用戶令牌): 用于訪問需要用戶登錄之后的接口，如：獲取我的基本信息、保存、修改、刪除等操作。獲取用戶令牌需要拿用戶名和密碼來換

關于Token的時效性：token可以是一次性的、也可以在一段時間范圍內是有效的，具體使用哪種看業務需要。

一般情況下接口最好使用https協議，如果使用http協議，Token機制只是一種減少被黑的可能性，其實只能防君子不能防小人。

一般token、timestamp和sign 三個參數會在接口中會同時作為參數傳遞，每個參數都有各自的用途。

二、timestamp 簡介

timestamp: 時間戳，是客戶端調用接口時對應的當前時間戳，時間戳用于防止DoS攻擊。

當黑客劫持了請求的url去DoS攻擊，每次調用接口時接口都會判斷服務器當前系統時間和接口中傳的的timestamp的差值，如果這個差值超過某個設置的時間(假如5分鐘)，那么這個請求將被攔截掉，如果在設置的超時時間范圍內，是不能阻止DoS攻擊的。timestamp機制只能減輕DoS攻擊的時間，縮短攻擊時間。如果黑客修改了時間戳的值可通過sign簽名機制來處理。

DoS

DoS是Denial of Service的簡稱，即拒絕服務，造成DoS的攻擊行為被稱為DoS攻擊，其目的是使計算機或網絡無法提供正常的服務。最常見的DoS攻擊有計算機網絡帶寬攻擊和連通性攻擊。

DoS攻擊是指故意的攻擊網絡協議實現的缺陷或直接通過野蠻手段殘忍地耗盡被攻擊對象的資源，目的是讓目標計算機或網絡無法提供正常的服務或資源訪問，使目標系統服務系統停止響應甚至崩潰，而在此攻擊中并不包括侵入目標服務器或目標網絡設備。這些服務資源包括網絡帶寬，文件系統空間容量，開放的進程或者允許的連接。這種攻擊會導致資源的匱乏，無論計算機的處理速度多快、內存容量多大、網絡帶寬的速度多快都無法避免這種攻擊帶來的后果。

Pingflood: 該攻擊在短時間內向目的主機發送大量ping包，造成網絡堵塞或主機資源耗盡。

Synflood: 該攻擊以多個隨機的源主機地址向目的主機發送SYN包，而在收到目的主機的SYN ACK后并不回應，這樣，目的主機就為這些源主機建立了大量的連接隊列，而且由于沒有收到ACK一直維護著這些隊列，造成了資源的大量消耗而不能向正常請求提供服務。

Smurf：該攻擊向一個子網的廣播地址發一個帶有特定請求（如ICMP回應請求）的包，并且將源地址偽裝成想要攻擊的主機地址。子網上所有主機都回應廣播包請求而向被攻擊主機發包，使該主機受到攻擊。

Land-based：攻擊者將一個包的源地址和目的地址都設置為目標主機的地址，然后將該包通過IP欺騙的方式發送給被攻擊主機，這種包可以造成被攻擊主機因試圖與自己建立連接而陷入死循環，從而很大程度地降低了系統性能。

Ping of Death：根據TCP/IP的規范，一個包的長度最大為65536字節。盡管一個包的長度不能超過65536字節，但是一個包分成的多個片段的疊加卻能做到。當一個主機收到了長度大于65536字節的包時，就是受到了Ping of Death攻擊，該攻擊會造成主機的宕機。

Teardrop：IP數據包在網絡傳遞時，數據包可以分成更小的片段。攻擊者可以通過發送兩段（或者更多）數據包來實現TearDrop攻擊。第一個包的偏移量為0，長度為N，第二個包的偏移量小于N。為了合并這些數據段，TCP/IP堆棧會分配超乎尋常的巨大資源，從而造成系統資源的缺乏甚至機器的重新啟動。

PingSweep：使用ICMP Echo輪詢多個主機。

三、sign 簡介

nonce：隨機值，是客戶端隨機生成的值，作為參數傳遞過來，隨機值的目的是增加sign簽名的多變性。隨機值一般是數字和字母的組合，6位長度，隨機值的組成和長度沒有固定規則。

sign: 一般用于參數簽名，防止參數被非法篡改，最常見的是修改金額等重要敏感參數， sign的值一般是將所有非空參數按照升續排序然后+token+key+timestamp+nonce(隨機數)拼接在一起，然后使用某種加密算法進行加密，作為接口中的一個參數sign來傳遞，也可以將sign放到請求頭中。

接口在網絡傳輸過程中如果被黑客挾持，并修改其中的參數值，然后再繼續調用接口，雖然參數的值被修改了，但是因為黑客不知道sign是如何計算出來的，不知道sign都有哪些值構成，不知道以怎樣的順序拼接在一起的，最重要的是不知道簽名字符串中的key是什么，所以黑客可以篡改參數的值，但沒法修改sign的值，當服務器調用接口前會按照sign的規則重新計算出sign的值然后和接口傳遞的sign參數的值做比較，如果相等表示參數值沒有被篡改，如果不等，表示參數被非法篡改了，就不執行接口了。

四、防止重復提交

對于一些重要的操作需要防止客戶端重復提交的(如非冪等性重要操作)，具體辦法是當請求第一次提交時將sign作為key保存到redis，并設置超時時間，超時時間和Timestamp中設置的差值相同。

當同一個請求第二次訪問時會先檢測redis是否存在該sign，如果存在則證明重復提交了，接口就不再繼續調用了。如果sign在緩存服務器中因過期時間到了，而被刪除了，此時當這個url再次請求服務器時，因token的過期時間和sign的過期時間一直，sign過期也意味著token過期，那樣同樣的url再訪問服務器會因token錯誤會被攔截掉，這就是為什么sign和token的過期時間要保持一致的原因。拒絕重復調用機制確保URL被別人截獲了也無法使用（如抓取數據）。

對于哪些接口需要防止重復提交可以自定義個注解來標記。

注意：所有的安全措施都用上的話有時候難免太過復雜，在實際項目中需要根據自身情況作出裁剪，比如可以只使用簽名機制就可以保證信息不會被篡改，或者定向提供服務的時候只用Token機制就可以了。如何裁剪，全看項目實際情況和對接口安全性的要求。

五、使用流程

1.接口調用方(客戶端)向接口提供方(服務器)申請接口調用賬號，申請成功后，接口提供方會給接口調用方一個appId和一個key參數

2.客戶端攜帶參數appId、timestamp、sign去調用服務器端的API token，其中sign=加密(appId + timestamp + key)

3.客戶端拿著api_token 去訪問不需要登錄就能訪問的接口

4.當訪問用戶需要登錄的接口時，客戶端跳轉到登錄頁面，通過用戶名和密碼調用登錄接口，登錄接口會返回一個usertoken, 客戶端拿著usertoken 去訪問需要登錄才能訪問的接口

sign的作用是防止參數被篡改，客戶端調用服務端時需要傳遞sign參數，服務器響應客戶端時也可以返回一個sign用于客戶度校驗返回的值是否被非法篡改了。客戶端傳的sign和服務器端響應的sign算法可能會不同。

六、示例代碼

1. dependency

org.springframework.boot spring-boot-starter-data-redis redis.clients jedis 2.9.0 org.springframework.boot spring-boot-starter-web

2. RedisConfiguration

@Configuration public class RedisConfiguration { @Bean public JedisConnectionFactory jedisConnectionFactory(){ return new JedisConnectionFactory(); }

/**
 * 支持存儲對象
 * @return
 */
@Bean
public RedisTemplate<String, String> redisTemplate(){
    RedisTemplate<String, String> redisTemplate = new StringRedisTemplate();
    redisTemplate.setConnectionFactory(jedisConnectionFactory());
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);


    jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
    redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
    redisTemplate.afterPropertiesSet();


    return redisTemplate;
}
復制代碼

}

3. TokenController

@Slf4j @RestController @RequestMapping("/api/token") public class TokenController {

@Autowired
private RedisTemplate redisTemplate;


/**
 * API Token
 *
 * @param sign
 * @return
 */
@PostMapping("/api_token")
public ApiResponse<AccessToken> apiToken(String appId, @RequestHeader("timestamp") String timestamp, @RequestHeader("sign") String sign) {
    Assert.isTrue(!StringUtils.isEmpty(appId) && !StringUtils.isEmpty(timestamp) && !StringUtils.isEmpty(sign), "參數錯誤");


    long reqeustInterval = System.currentTimeMillis() - Long.valueOf(timestamp);
    Assert.isTrue(reqeustInterval < 5 * 60 * 1000, "請求過期，請重新請求");


    // 1. 根據appId查詢數據庫獲取appSecret
    AppInfo appInfo = new AppInfo("1", "12345678954556");


    // 2. 校驗簽名
    String signString = timestamp + appId + appInfo.getKey();
    String signature = MD5Util.encode(signString);
    log.info(signature);
    Assert.isTrue(signature.equals(sign), "簽名錯誤");


    // 3. 如果正確生成一個token保存到redis中，如果錯誤返回錯誤信息
    AccessToken accessToken = this.saveToken(0, appInfo, null);


    return ApiResponse.success(accessToken);
}




@NotRepeatSubmit(5000)
@PostMapping("user_token")
public ApiResponse<UserInfo> userToken(String username, String password) {
    // 根據用戶名查詢密碼, 并比較密碼(密碼可以RSA加密一下)
    UserInfo userInfo = new UserInfo(username, "81255cb0dca1a5f304328a70ac85dcbd", "111111");
    String pwd = password + userInfo.getSalt();
    String passwordMD5 = MD5Util.encode(pwd);
    Assert.isTrue(passwordMD5.equals(userInfo.getPassword()), "密碼錯誤");


    // 2. 保存Token
    AppInfo appInfo = new AppInfo("1", "12345678954556");
    AccessToken accessToken = this.saveToken(1, appInfo, userInfo);
    userInfo.setAccessToken(accessToken);
    return ApiResponse.success(userInfo);
}


private AccessToken saveToken(int tokenType, AppInfo appInfo,  UserInfo userInfo) {
    String token = UUID.randomUUID().toString();


    // token有效期為2小時
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(new Date());
    calendar.add(Calendar.SECOND, 7200);
    Date expireTime = calendar.getTime();


    // 4. 保存token
    ValueOperations<String, TokenInfo> operations = redisTemplate.opsForValue();
    TokenInfo tokenInfo = new TokenInfo();
    tokenInfo.setTokenType(tokenType);
    tokenInfo.setAppInfo(appInfo);


    if (tokenType == 1) {
        tokenInfo.setUserInfo(userInfo);
    }


    operations.set(token, tokenInfo, 7200, TimeUnit.SECONDS);


    AccessToken accessToken = new AccessToken(token, expireTime);


    return accessToken;
}


public static void main(String[] args) {
    long timestamp = System.currentTimeMillis();
    System.out.println(timestamp);
    String signString = timestamp + "1" + "12345678954556";
    String sign = MD5Util.encode(signString);
    System.out.println(sign);


    System.out.println("-------------------");
    signString = "password=123456&username=1&12345678954556" + "ff03e64b-427b-45a7-b78b-47d9e8597d3b1529815393153sdfsdfsfs" + timestamp + "A1scr6";
    sign = MD5Util.encode(signString);
    System.out.println(sign);
}
復制代碼

}

4. WebMvcConfiguration

@Configuration public class WebMvcConfiguration extends WebMvcConfigurationSupport {

private static final String[] excludePathPatterns  = {"/api/token/api_token"};


@Autowired
private TokenInterceptor tokenInterceptor;


@Override
public void addInterceptors(InterceptorRegistry registry) {
    super.addInterceptors(registry);
    registry.addInterceptor(tokenInterceptor)
            .addPathPatterns("/api/**")
            .excludePathPatterns(excludePathPatterns);
}
復制代碼

} 5. TokenInterceptor @Component public class TokenInterceptor extends HandlerInterceptorAdapter {

@Autowired
private RedisTemplate redisTemplate;


/**
 *
 * @param request
 * @param response
 * @param handler 訪問的目標方法
 * @return
 * @throws Exception
 */
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    String token = request.getHeader("token");
    String timestamp = request.getHeader("timestamp");
    // 隨機字符串
    String nonce = request.getHeader("nonce");
    String sign = request.getHeader("sign");
    Assert.isTrue(!StringUtils.isEmpty(token) && !StringUtils.isEmpty(timestamp) && !StringUtils.isEmpty(sign), "參數錯誤");


    // 獲取超時時間
    NotRepeatSubmit notRepeatSubmit = ApiUtil.getNotRepeatSubmit(handler);
    long expireTime = notRepeatSubmit == null ? 5 * 60 * 1000 : notRepeatSubmit.value();


    // 2. 請求時間間隔
    long reqeustInterval = System.currentTimeMillis() - Long.valueOf(timestamp);
    Assert.isTrue(reqeustInterval < expireTime, "請求超時，請重新請求");


    // 3. 校驗Token是否存在
    ValueOperations<String, TokenInfo> tokenRedis = redisTemplate.opsForValue();
    TokenInfo tokenInfo = tokenRedis.get(token);
    Assert.notNull(tokenInfo, "token錯誤");


    // 4. 校驗簽名(將所有的參數加進來，防止別人篡改參數) 所有參數看參數名升續排序拼接成url
    // 請求參數 + token + timestamp + nonce
    String signString = ApiUtil.concatSignString(request) + tokenInfo.getAppInfo().getKey() + token + timestamp + nonce;
    String signature = MD5Util.encode(signString);
    boolean flag = signature.equals(sign);
    Assert.isTrue(flag, "簽名錯誤");


    // 5. 拒絕重復調用(第一次訪問時存儲，過期時間和請求超時時間保持一致), 只有標注不允許重復提交注解的才會校驗
    if (notRepeatSubmit != null) {
        ValueOperations<String, Integer> signRedis = redisTemplate.opsForValue();
        boolean exists = redisTemplate.hasKey(sign);
        Assert.isTrue(!exists, "請勿重復提交");
        signRedis.set(sign, 0, expireTime, TimeUnit.MILLISECONDS);
    }


    return super.preHandle(request, response, handler);
}
復制代碼

}

6. MD5Util ----MD5工具類，加密生成數字簽名

public class MD5Util {

private static final String hexDigits[] = { "0", "1", "2", "3", "4", "5",
        "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };


private static String byteArrayToHexString(byte b[]) {
    StringBuffer resultSb = new StringBuffer();
    for (int i = 0; i < b.length; i++)
        resultSb.append(byteToHexString(b[i]));


    return resultSb.toString();
}


private static String byteToHexString(byte b) {
    int n = b;
    if (n < 0)
        n += 256;
    int d1 = n / 16;
    int d2 = n % 16;
    return hexDigits[d1] + hexDigits[d2];
}


public static String encode(String origin) {
    return encode(origin, "UTF-8");
}
public static String encode(String origin, String charsetname) {
    String resultString = null;
    try {
        resultString = new String(origin);
        MessageDigest md = MessageDigest.getInstance("MD5");
        if (charsetname == null || "".equals(charsetname))
            resultString = byteArrayToHexString(md.digest(resultString
                    .getBytes()));
        else
            resultString = byteArrayToHexString(md.digest(resultString
                    .getBytes(charsetname)));
    } catch (Exception exception) {
    }
    return resultString;
}
復制代碼

}

7. @NotRepeatSubmit -----自定義注解，防止重復提交。

/**

• 禁止重復提交

/ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface NotRepeatSubmit { /* 過期時間，單位毫秒 **/ long value() default 5000; }

8. AccessToken

@Data @AllArgsConstructor public class AccessToken { /** token */ private String token;

/** 失效時間 */
private Date expireTime;
復制代碼

}

9. AppInfo

@Data @NoArgsConstructor @AllArgsConstructor public class AppInfo { /** App id / private String appId; /* API 秘鑰 */ private String key; }

10. TokenInfo

@Data public class TokenInfo { /** token類型: api:0 、user:1 */ private Integer tokenType;

/** App 信息 */
private AppInfo appInfo;


/** 用戶其他數據 */
private UserInfo userInfo;
復制代碼

}

11. UserInfo

@Data public class UserInfo { /** 用戶名 / private String username; /* 手機號 / private String mobile; /* 郵箱 / private String email; /* 密碼 / private String password; /* 鹽 */ private String salt;

private AccessToken accessToken;


public UserInfo(String username, String password, String salt) {
    this.username = username;
    this.password = password;
    this.salt = salt;
}
復制代碼

}

12. ApiCodeEnum

/**

• 錯誤碼code可以使用純數字,使用不同區間標識一類錯誤，也可以使用純字符，也可以使用前綴+編號
•  
• 錯誤碼：ERR + 編號
•  
• 可以使用日志級別的前綴作為錯誤類型區分 Info(I) Error(E) Warning(W)
•  
• 或者以業務模塊 + 錯誤號
•  
• TODO 錯誤碼設計
•  
• Alipay 用了兩個code，兩個msg(docs.open.alipay.com/api_1/alipa…)

*/ public enum ApiCodeEnum { SUCCESS("10000", "success"), UNKNOW_ERROR("ERR0001","未知錯誤"), PARAMETER_ERROR("ERR0002","參數錯誤"), TOKEN_EXPIRE("ERR0003","認證過期"), REQUEST_TIMEOUT("ERR0004","請求超時"), SIGN_ERROR("ERR0005","簽名錯誤"), REPEAT_SUBMIT("ERR0006","請不要頻繁操作"), ;

/** 代碼 */
private String code;


/** 結果 */
private String msg;


ApiCodeEnum(String code, String msg) {
    this.code = code;
    this.msg = msg;
}


public String getCode() {
    return code;
}


public String getMsg() {
    return msg;
}
復制代碼

}

13. ApiResult

@Data @NoArgsConstructor @AllArgsConstructor public class ApiResult {

/** 代碼 */
private String code;


/** 結果 */
private String msg;
復制代碼

}

14. ApiUtil -------這個參考支付寶加密的算法寫的.我直接Copy過來了。

public class ApiUtil {

/**
 * 按參數名升續拼接參數
 * @param request
 * @return
 */
public static String concatSignString(HttpServletRequest request) {
    Map<String, String> paramterMap = new HashMap<>();
    request.getParameterMap().forEach((key, value) -> paramterMap.put(key, value[0]));
    // 按照key升續排序，然后拼接參數
    Set<String> keySet = paramterMap.keySet();
    String[] keyArray = keySet.toArray(new String[keySet.size()]);
    Arrays.sort(keyArray);
    StringBuilder sb = new StringBuilder();
    for (String k : keyArray) {
        // 或略掉的字段
        if (k.equals("sign")) {
            continue;
        }
        if (paramterMap.get(k).trim().length() > 0) {
            // 參數值為空，則不參與簽名
            sb.append(k).append("=").append(paramterMap.get(k).trim()).append("&");
        }
    }


    return sb.toString();
}


public static String concatSignString(Map<String, String> map) {
    Map<String, String> paramterMap = new HashMap<>();
    map.forEach((key, value) -> paramterMap.put(key, value));
    // 按照key升續排序，然后拼接參數
    Set<String> keySet = paramterMap.keySet();
    String[] keyArray = keySet.toArray(new String[keySet.size()]);
    Arrays.sort(keyArray);
    StringBuilder sb = new StringBuilder();
    for (String k : keyArray) {
        if (paramterMap.get(k).trim().length() > 0) {
            // 參數值為空，則不參與簽名
            sb.append(k).append("=").append(paramterMap.get(k).trim()).append("&");
        }
    }
    return sb.toString();
}


/**
 * 獲取方法上的@NotRepeatSubmit注解
 * @param handler
 * @return
 */
public static NotRepeatSubmit getNotRepeatSubmit(Object handler) {
    if (handler instanceof HandlerMethod) {
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        NotRepeatSubmit annotation = method.getAnnotation(NotRepeatSubmit.class);


        return annotation;
    }


    return null;
}
復制代碼

}

15. ApiResponse

@Data @Slf4j public class ApiResponse { /** 結果 */ private ApiResult result;

/** 數據 */
private T data;


/** 簽名 */
private String sign;




public static <T> ApiResponse success(T data) {
    return response(ApiCodeEnum.SUCCESS.getCode(), ApiCodeEnum.SUCCESS.getMsg(), data);
}


public static ApiResponse error(String code, String msg) {
    return response(code, msg, null);
}


public static <T> ApiResponse response(String code, String msg, T data) {
    ApiResult result = new ApiResult(code, msg);
    ApiResponse response = new ApiResponse();
    response.setResult(result);
    response.setData(data);


    String sign = signData(data);
    response.setSign(sign);


    return response;
}


private static <T> String signData(T data) {
    // TODO 查詢key
    String key = "12345678954556";
    Map<String, String> responseMap = null;
    try {
        responseMap = getFields(data);
    } catch (IllegalAccessException e) {
        return null;
    }
    String urlComponent = ApiUtil.concatSignString(responseMap);
    String signature = urlComponent + "key=" + key;
    String sign = MD5Util.encode(signature);


    return sign;
}


/**
 * @param data 反射的對象,獲取對象的字段名和值
 * @throws IllegalArgumentException
 * @throws IllegalAccessException
 */
public static Map<String, String> getFields(Object data) throws IllegalAccessException, IllegalArgumentException {
    if (data == null) return null;
    Map<String, String> map = new HashMap<>();
    Field[] fields = data.getClass().getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
        Field field = fields[i];
        field.setAccessible(true);


        String name = field.getName();
        Object value = field.get(data);
        if (field.get(data) != null) {
            map.put(name, value.toString());
        }
    }


    return map;
}
復制代碼

}

七、ThreadLocal

ThreadLocal是線程內的全局上下文。就是在單個線程中，方法之間共享的內存，每個方法都可以從該上下文中獲取值和修改值。

實際案例：

在調用api時都會傳一個token參數，通常會寫一個攔截器來校驗token是否合法，我們可以通過token找到對應的用戶信息(User)，如果token合法，然后將用戶信息存儲到ThreadLocal中，這樣無論是在controller、service、dao的哪一層都能訪問到該用戶的信息。作用類似于Web中的request作用域。

傳統方式我們要在方法中訪問某個變量，可以通過傳參的形式往方法中傳參，如果多個方法都要使用那么每個方法都要傳參；如果使用ThreadLocal所有方法就不需要傳該參數了，每個方法都可以通過ThreadLocal來訪問該值。

ThreadLocalUtil.set("key", value); 保存值 T value = ThreadLocalUtil.get("key"); 獲取值

ThreadLocalUtil

public class ThreadLocalUtil { private static final ThreadLocal<Map<String, Object>> threadLocal = new ThreadLocal() { @Override protected Map<String, Object> initialValue() { return new HashMap<>(4); } };

public static Map<String, Object> getThreadLocal(){
    return threadLocal.get();
}


public static <T> T get(String key) {
    Map map = (Map)threadLocal.get();
    return (T)map.get(key);
}


public static <T> T get(String key,T defaultValue) {
    Map map = (Map)threadLocal.get();
    return (T)map.get(key) == null ? defaultValue : (T)map.get(key);
}


public static void set(String key, Object value) {
    Map map = (Map)threadLocal.get();
    map.put(key, value);
}


public static void set(Map<String, Object> keyValueMap) {
    Map map = (Map)threadLocal.get();
    map.putAll(keyValueMap);
}


public static void remove() {
    threadLocal.remove();
}


public static <T> Map<String,T> fetchVarsByPrefix(String prefix) {
    Map<String,T> vars = new HashMap<>();
    if( prefix == null ){
        return vars;
    }
    Map map = (Map)threadLocal.get();
    Set<Map.Entry> set = map.entrySet();


    for( Map.Entry entry : set){
        Object key = entry.getKey();
        if( key instanceof String ){
            if( ((String) key).startsWith(prefix) ){
                vars.put((String)key,(T)entry.getValue());
            }
        }
    }
    return vars;
}


public static <T> T remove(String key) {
    Map map = (Map)threadLocal.get();
    return (T)map.remove(key);
}


public static void clear(String prefix) {
    if( prefix == null ){
        return;
    }
    Map map = (Map)threadLocal.get();
    Set<Map.Entry> set = map.entrySet();
    List<String> removeKeys = new ArrayList<>();


    for( Map.Entry entry : set ){
        Object key = entry.getKey();
        if( key instanceof String ){
            if( ((String) key).startsWith(prefix) ){
                removeKeys.add((String)key);
            }
        }
    }
    for( String key : removeKeys ){
        map.remove(key);
    }
}
復制代碼

}

總結:這個是目前第三方數據接口交互過程中常用的一些參數與使用示例，希望對大家有點幫助。

當然如果為了保證更加的安全，可以加上RSA,RSA2，AES等等加密方式，保證了數據的更加的安全，但是唯一的缺點是加密與解密比較耗費CPU的資源。

一般是RSA+AES結合！原理：AES加密參數，rsa加密AES的密鑰，后端通過RSA解密得到AES密鑰，然后通過AES解密，得到前端傳的參數

沒有絕對安全，只有相對安全

此文轉載：cnblogs.com/jurendage/p/12653865.html

作者：不求上進的程序員
鏈接：https://juejin.cn/post/6970195224807096351
來源：掘金
著作權歸作者所有。商業轉載請聯系作者獲得授權，非商業轉載請注明出處。