作者：巨人大哥
連結：https://www.cnblogs.com/jurendage/p/12653865.html
說明：在實際的業務中，難免會跟第三方系統進行數據的互動與傳遞，那麽如何保證數據在傳輸過程中的安全呢（防竊取）？除了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機制就可以了。如何裁剪，全看計畫實際情況和對介面安全性的要求。
使用流程
介面呼叫方(客戶端)向介面提供方(伺服器)申請介面呼叫帳號，申請成功後，介面提供方會給介面呼叫方一個appId和一個key參數
客戶端攜帶參數appId、timestamp、sign去呼叫伺服器端的API token，其中sign=加密(appId + timestamp + key)
客戶端拿著api_token 去存取不需要登入就能存取的介面
當存取使用者需要登入的介面時，客戶端跳轉到登入頁面，透過使用者名稱和密碼呼叫登入介面，登入介面會返回一個usertoken, 客戶端拿著usertoken 去存取需要登入才能存取的介面
sign的作用是防止參數被篡改，客戶端呼叫伺服端時需要傳遞sign參數，伺服器響應客戶端時也可以返回一個sign用於客戶度校驗返回的值是否被非法篡改了。客戶端傳的sign和伺服器端響應的sign演算法可能會不同。
範例程式碼
dependency
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
RedisConfiguration
@Configuration
public classRedisConfiguration{
@Bean
public JedisConnectionFactory jedisConnectionFactory(){
returnnew 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;
}
}
TokenController
@Slf4j
@RestController
@RequestMapping("/api/token")
public classTokenController{
@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);
}
}
WebMvcConfiguration
@Configuration
public classWebMvcConfigurationextendsWebMvcConfigurationSupport{
privatestaticfinal String[] excludePathPatterns = {"/api/token/api_token"};
@Autowired
private TokenInterceptor tokenInterceptor;
@Override
publicvoidaddInterceptors(InterceptorRegistry registry){
super.addInterceptors(registry);
registry.addInterceptor(tokenInterceptor)
.addPathPatterns("/api/**")
.excludePathPatterns(excludePathPatterns);
}
}
5. TokenInterceptor
@Component
public classTokenInterceptorextendsHandlerInterceptorAdapter{
@Autowired
private RedisTemplate redisTemplate;
/**
*
* @param request
* @param response
* @param handler 存取的目標方法
* @return
* @throws Exception
*/
@Override
publicbooleanpreHandle(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);
}
returnsuper.preHandle(request, response, handler);
}
}
MD5Util ----MD5工具類，加密生成數位簽名
public classMD5Util {
privatestatic final String hexDigits[] = { "0", "1", "2", "3", "4", "5",
"6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
privatestatic String byteArrayToHexString(byte b[]) {
StringBuffer resultSb = new StringBuffer();
for (int i = 0; i < b.length; i++)
resultSb.append(byteToHexString(b[i]));
return resultSb.toString();
}
privatestatic 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];
}
publicstatic String encode(String origin) {
return encode(origin, "UTF-8");
}
publicstatic 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;
}
}
@NotRepeatSubmit -----自訂註解，防止重復送出。
/**
* 禁止重復送出
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interfaceNotRepeatSubmit {
/** 過期時間，單位毫秒 **/
longvalue() default 5000;
}
AccessToken
@Data
@AllArgsConstructor
public classAccessToken {
/** token */
private String token;
/** 失效時間 */
private Date expireTime;
}
AppInfo
@Data
@NoArgsConstructor
@AllArgsConstructor
public classAppInfo{
/** App id */
private String appId;
/** API 秘鑰 */
private String key;
}
TokenInfo
@Data
public classTokenInfo {
/** token型別: api:0 、user:1 */
private Integer tokenType;
/** App 資訊 */
private AppInfo appInfo;
/** 使用者其他數據 */
private UserInfo userInfo;
}
UserInfo
@Data
public classUserInfo {
/** 使用者名稱 */
private String username;
/** 手機號 */
private String mobile;
/** 信箱 */
private String email;
/** 密碼 */
private String password;
/** 鹽 */
private String salt;
private AccessToken accessToken;
publicUserInfo(String username, String password, String salt){
this.username = username;
this.password = password;
this.salt = salt;
}
}
ApiCodeEnum
/**
* 錯誤碼code可以使用純數位,使用不同區間標識一類錯誤，也可以使用純字元，也可以使用字首+編號
*
* 錯誤碼：ERR + 編號
*
* 可以使用日誌級別的字首作為錯誤型別區分 Info(I) Error(E) Warning(W)
*
* 或者以業務模組 + 錯誤號
*
* TODO 錯誤碼設計
*
* Alipay 用了兩個code，兩個msg(https://docs.open.alipay.com/api_1/alipay.trade.pay)
*/
publicenum 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;
}
}
ApiResult
@Data
@NoArgsConstructor
@AllArgsConstructor
public classApiResult{
/** 程式碼 */
private String code;
/** 結果 */
private String msg;
}
ApiUtil -------這個參考支付寶加密的演算法寫的.我直接Copy過來了。
public classApiUtil{
/**
* 按參數名升續拼接參數
* @param request
* @return
*/
public staticString 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(newString[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 staticString 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(newString[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;
}
returnnull;
}
}
ApiResponse
@Data
@Slf4j
public classApiResponse<T> {
/** 結果 */
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) {
returnnull;
}
String urlComponent = ApiUtil.concatSignString(responseMap);
String signature = urlComponent + "key=" + key;
String sign = MD5Util.encode(signature);
return sign;
}
/**
* @param data 反射的物件,獲取物件的欄位名和值
* @throws IllegalArgumentException
* @throws IllegalAccessException
*/
public staticMap<String, String> getFields(Object data) throws IllegalAccessException, IllegalArgumentException {
if (data == null) returnnull;
Map<String, String> map = new HashMap<>();
Field[] fields = data.get class().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 classThreadLocalUtil<T> {
private staticfinal ThreadLocal<Map<String, Object>> threadLocal = new ThreadLocal() {
@Override
protected Map<String, Object> initialValue() {
returnnew HashMap<>(4);
}
};
public staticMap<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 staticvoidset(String key, Object value) {
Map map = (Map)threadLocal.get();
map.put(key, value);
}
public staticvoidset(Map<String, Object> keyValueMap) {
Map map = (Map)threadLocal.get();
map.putAll(keyValueMap);
}
public staticvoid 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 staticvoid 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的資源.
