springmvc 數據加密解密(1)------服務端加解密
第一次寫文章，不知道怎麼寫，寫的很差或者不對的地方請你們指出，本人確定會虛心接納。前端
對於數據加密和爲何須要數據加密，網上的文章一搜就一大片，以博主那三腳貓的知識就不和你們解釋啦(😂🤣)。
進入正題，博主所在公司開發的項目，不管是app端仍是h5網頁，和後端都以json數據交互，也就是常說的一套接口給全部前端使用，因此完全解放了博主寫接口的壓力，哈哈😆😆。 java
既然涉及數據交互，確定不能避免數據安全的問題，天然而然咱們就會想到對數據進行加密和解密。如今博主接觸到的數加密和解密算法是對稱算法(AES)和非對稱算法(RSA)，固然還有其餘算法，但咱們也不須要研究太多，夠用就行，開發不就是這樣嘛😂😂。咱們傳遞的數據被非法用戶竊取，若是使用AES算法，這個算法的優點就是加解密速度快，因爲祕鑰也保存在前端（若是是保存app，還須要費勁的破解app；但若是是保存在網頁，這個博主不說你們也知道）基本沒有安全保障，若是使用RSA算法，那基本安全無憂，但RSA算法對數據加密和解密很是的耗時，固然這個也受限於服務器哈，若是服務器性能很強，直接使用RSA對數據加密解密就行，若是服務器性能有限，能夠繼續看博主接下來的方式。web
若是咱們的AES祕鑰不能或者很難被獲取到，是否是就解決安全性的問題啦。那咱們如何來保證AES祕鑰很難被獲取呢？沒錯，用RSA來保證，首先AES祕鑰都是隨機的，而後咱們使用RSA算法，對AES的祕鑰進行加密解密，這個其實就是數字信封技術，博主小小的賣弄一波哈😋😋。redis
畫個圖來解釋咱們這個加密解密過程，幫助你們理解。
算法
1：首先客戶端存儲着RSA公鑰，就算非法用戶拿到RSA公鑰，他也很難根據公鑰和加密數據進行解密，這個算法已經保證了，支付寶
也是使用RSA來對數據加密，因此你們能夠放心使用RSA算法。
2：客戶端隨機生成AES的祕鑰，這個祕鑰長度必須是16的倍數，這個是通過項目檢驗獲得驗證，而後使用RSA公鑰對AES產生的祕鑰
進行加密發送給服務端。
3：服務端使用RSA祕鑰對已通過RSA公鑰加密的AES祕鑰進行解密，獲得AES的祕鑰，保存起來；接下來比較重要的就是產生臨時會
話號，爲何須要這個會話號呢？由於咱們的場景下多是不須要用戶登陸的，爲了標識這個用戶，咱們得產生一個會話號，這個
必須是保證惟一性，由於咱們得根據這個會話號去標識當前的請求用戶，還有一個做用就是根據這個會話號來對應不一樣
的AES祕鑰。博主是將會話號保存在redis中，固然也有不少方案，這個看項目需求。
4：接下來就開始進行客戶端和服務端數據交互，固然若是咱們在未登陸狀況下，注意客戶端得傳遞臨時會話號，不然服務端找不到
AES祕鑰就沒辦法對數據解密和加密
說了那麼多理論的東西，是否是有些急不可待看看怎麼取實現了吶。廢話很少說，上代碼。
RSAHelper.javaspring
import java.io.IOException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.junit.Test;
import org.springframework.util.Base64Utils;
public class RSAHelper {
public static final String PUBLIC_KEY_VALUES = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCgl0qiFQP8P/Wv5ZXRe78wxU3h7f/5xkh0ChiJ0f4Md0KZv0cSOzBGptNC41tL6cg1qKNPcEuJH296jet/T0Q+cD2tuofHtnB4ghhhCVHT8gkxhV+DJ61BquUIRrhJwj8jU3pw/klY+gIiiOfJFz2Hpar6Lyp+KCTZTyljg0vKPQIDAQAB";
public static final String PRIVATE_KEY_VALUES = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAKCXSqIVA/w/9a/lldF7vzDFTeHt//nGSHQKGInR/gx3Qpm/RxI7MEam00LjW0vpyDWoo09wS4kfb3qN639PRD5wPa26h8e2cHiCGGEJUdPyCTGFX4MnrUGq5QhGuEnCPyNTenD+SVj6AiKI58kXPYelqvovKn4oJNlPKWODS8o9AgMBAAECgYEAgmW2vVtxK/9HYPd8Kmhf+5sKPX0Cz+8YX9jeyfIQZlDkbHErpXsYHRZTDsoMFN0Uq7VuPg/B1esHmyzn3y0fDIU1MYcrxBGtKWm1AxwpTcCafsQ3VakkMRkTD8QNZXqcyctB4aRIVWq3p3556zHEIwyxUMCr4UDUKjilJBi/q2ECQQDf1N4Gi1eWnkFuVjD6mJ6bfGJ04l8DajIdt/N/a/J4O1TlPMnaBons5cg/evatsiZvRHYsXeoWygaJhCcoap8JAkEAt6uzQXxfM/oNSZj5voIgZc2xhMWej7bAYYS6Q9/n5KNkybtWSHYe8lbJc4Q4/eYzinDwMYRxVNFR0WuUwafqlQJAPjlkG7ei+tk14WGOriu9dAYpLMs9lKpyEjbwN00gE/KSkEPM7ZKBx1y9xX/+kZ0D+Ey0+XKGQB2boaEebaruWQJAXHeivVtCCsbenajYQuL8MISH1JIxK6UT4YSSyc0Vz/O6sB0SaVSea97peLCeiKS2WgJVynglHlBrYoVI1N4WqQJBAJt92JHPMlvsKcmeVgQS5LmobsYc5EYUQ0sHUpvQJ26/hh2pDBKxYmyhl1TNuEVfsjuvDbdfPzn9MMqDt5RPbcc=";
/**
* RSA密鑰長度必須是64的倍數，在512~65536之間。默認是1024
*/
public static final int KEY_SIZE = 1024;
/**
* 生成公鑰、私鑰對(keysize=1024)
*/
public static RSAHelper.KeyPairInfo getKeyPair() {
return getKeyPair(KEY_SIZE);
}
/**
* 生成公鑰、私鑰對
*
* @param keySize
* @return
*/
public static RSAHelper.KeyPairInfo getKeyPair(int keySize) {
try {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
keyPairGen.initialize(keySize);
// 生成一個密鑰對，保存在keyPair中
KeyPair keyPair = keyPairGen.generateKeyPair();
// 獲得私鑰
RSAPrivateKey oraprivateKey = (RSAPrivateKey) keyPair.getPrivate();
// 獲得公鑰
RSAPublicKey orapublicKey = (RSAPublicKey) keyPair.getPublic();
RSAHelper.KeyPairInfo pairInfo = new RSAHelper.KeyPairInfo(keySize);
//公鑰
byte[] publicKeybyte = orapublicKey.getEncoded();
String publicKeyString = Base64.encodeBase64String(publicKeybyte);//Base64.encode(publicKeybyte);
pairInfo.setPublicKey(publicKeyString);
//私鑰
byte[] privateKeybyte = oraprivateKey.getEncoded();
String privateKeyString = Base64.encodeBase64String(privateKeybyte);//Base64.encode(privateKeybyte);
pairInfo.setPrivateKey(privateKeyString);
return pairInfo;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 獲取公鑰對象
*
* @param publicKeyBase64
* @return
* @throws InvalidKeySpecException
* @throws NoSuchAlgorithmException
*/
public static PublicKey getPublicKey(String publicKeyBase64)
throws InvalidKeySpecException, NoSuchAlgorithmException {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
X509EncodedKeySpec publicpkcs8KeySpec =
new X509EncodedKeySpec(Base64.decodeBase64(publicKeyBase64));//Base64.decode(publicKeyBase64)
PublicKey publicKey = keyFactory.generatePublic(publicpkcs8KeySpec);
return publicKey;
}
/**
* 獲取私鑰對象
*
* @param privateKeyBase64
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
*/
public static PrivateKey getPrivateKey(String privateKeyBase64)
throws NoSuchAlgorithmException, InvalidKeySpecException {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PKCS8EncodedKeySpec privatekcs8KeySpec =
new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyBase64));//Base64.decode(privateKeyBase64)
PrivateKey privateKey = keyFactory.generatePrivate(privatekcs8KeySpec);
return privateKey;
}
/**
* 使用公鑰加密
*
* @param content 待加密內容
* @param publicKeyBase64 公鑰 base64 編碼
* @return 通過 base64 編碼後的字符串
*/
public static String encipher(String content, String publicKeyBase64) {
return encipher(content, publicKeyBase64, KEY_SIZE / 8 - 11);
}
/**
* 使用公司鑰加密（分段加密）
*
* @param content 待加密內容
* @param publicKeyBase64 公鑰 base64 編碼
* @param segmentSize 分段大小,通常小於 keySize/8（段小於等於0時，將不使用分段加密）
* @return 通過 base64 編碼後的字符串
*/
public static String encipher(String content, String publicKeyBase64, int segmentSize) {
try {
PublicKey publicKey = getPublicKey(publicKeyBase64);
return encipher(content, publicKey, segmentSize);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 分段加密
*
* @param ciphertext 密文
* @param key 加密祕鑰
* @param segmentSize 分段大小，<=0 不分段
* @return
*/
public static String encipher(String ciphertext, java.security.Key key, int segmentSize) {
try {
// 用公鑰加密
byte[] srcBytes = ciphertext.getBytes();
// Cipher負責完成加密或解密工做，基於RSA
Cipher cipher = Cipher.getInstance("RSA");
// 根據公鑰，對Cipher對象進行初始化
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] resultBytes = null;
if (segmentSize > 0)
resultBytes = cipherDoFinal(cipher, srcBytes, segmentSize); //分段加密
else
resultBytes = cipher.doFinal(srcBytes);
String base64Str = Base64Utils.encodeToString(resultBytes);
return base64Str;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 分段大小
*
* @param cipher
* @param srcBytes
* @param segmentSize
* @return
* @throws IllegalBlockSizeException
* @throws BadPaddingException
* @throws IOException
*/
public static byte[] cipherDoFinal(Cipher cipher, byte[] srcBytes, int segmentSize)
throws IllegalBlockSizeException, BadPaddingException, IOException {
if (segmentSize <= 0)
throw new RuntimeException("分段大小必須大於0");
ByteArrayOutputStream out = new ByteArrayOutputStream();
int inputLen = srcBytes.length;
int offSet = 0;
byte[] cache;
int i = 0;
// 對數據分段解密
while (inputLen - offSet > 0) {
if (inputLen - offSet > segmentSize) {
cache = cipher.doFinal(srcBytes, offSet, segmentSize);
} else {
cache = cipher.doFinal(srcBytes, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * segmentSize;
}
byte[] data = out.toByteArray();
out.close();
return data;
}
/**
* 使用私鑰解密
*
* @param contentBase64 待加密內容,base64 編碼
* @param privateKeyBase64 私鑰 base64 編碼
* @return
* @segmentSize 分段大小
*/
public static String decipher(String contentBase64, String privateKeyBase64) {
return decipher(contentBase64, privateKeyBase64, KEY_SIZE / 8);
}
/**
* 使用私鑰解密（分段解密）
*
* @param contentBase64 待加密內容,base64 編碼
* @param privateKeyBase64 私鑰 base64 編碼
* @return
* @segmentSize 分段大小
*/
public static String decipher(String contentBase64, String privateKeyBase64, int segmentSize) {
try {
PrivateKey privateKey = getPrivateKey(privateKeyBase64);
return decipher(contentBase64, privateKey, segmentSize);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 分段解密
*
* @param contentBase64 密文
* @param key 解密祕鑰
* @param segmentSize 分段大小（小於等於0不分段）
* @return
*/
public static String decipher(String contentBase64, java.security.Key key, int segmentSize) {
try {
// 用私鑰解密
byte[] srcBytes = Base64Utils.decodeFromString(contentBase64);
// Cipher負責完成加密或解密工做，基於RSA
Cipher deCipher = Cipher.getInstance("RSA");
// 根據公鑰，對Cipher對象進行初始化
deCipher.init(Cipher.DECRYPT_MODE, key);
byte[] decBytes = null;//deCipher.doFinal(srcBytes);
if (segmentSize > 0)
decBytes = cipherDoFinal(deCipher, srcBytes, segmentSize); //分段加密
else
decBytes = deCipher.doFinal(srcBytes);
String decrytStr = new String(decBytes);
return decrytStr;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 祕鑰對
*/
public static class KeyPairInfo {
String privateKey;
String publicKey;
int keySize = 0;
public KeyPairInfo(int keySize) {
setKeySize(keySize);
}
public KeyPairInfo(String publicKey, String privateKey) {
setPrivateKey(privateKey);
setPublicKey(publicKey);
}
public String getPrivateKey() {
return privateKey;
}
public void setPrivateKey(String privateKey) {
this.privateKey = privateKey;
}
public String getPublicKey() {
return publicKey;
}
public void setPublicKey(String publicKey) {
this.publicKey = publicKey;
}
public int getKeySize() {
return keySize;
}
public void setKeySize(int keySize) {
this.keySize = keySize;
}
}
public static void main(String[] args) {
System.out.println("第一步：客戶端和服務端進行密碼握手通訊，確保密碼的安全性");
System.out.println(" 1.客戶端請求RSA公鑰");
System.out.println(" 2.服務端開始頒發公鑰給客戶端");
KeyPairInfo keyPairInfo = RSAHelper.getKeyPair();
System.out.println(" 3.服務端返回給客戶端RSA公鑰："+keyPairInfo.getPublicKey());
System.out.println(" 4.服務端本身保存RSA公鑰和RSA私鑰：公鑰："+keyPairInfo.getPublicKey()+";私鑰"+keyPairInfo.getPrivateKey());
String AESPassword = "1234567890123456";
System.out.println(" 5.客戶端產生RES的密碼："+AESPassword);
String AESPasswordEncipher = RSAHelper.encipher(AESPassword, keyPairInfo.getPublicKey());
System.out.println(" 6.客戶端使用RSA的公鑰加密第5步中的產生的RES密碼："+AESPasswordEncipher);
System.out.println(" 7.客戶端發送使用RSA公鑰加密的AES密碼，服務端接收到密碼："+AESPasswordEncipher);
String AESPasswordDecipher = RSAHelper.decipher(AESPasswordEncipher, keyPairInfo.getPrivateKey());
System.out.println(" 8.服務端使用RSA私鑰解密密碼（已經通過RSA加密的AES的密碼）："+AESPasswordDecipher);
System.out.println("第二步：開始數據交互");
String inputStr = "{\"token\":\"ippay_bf0eb479e1b6cfe7cfe609ebf52c5328\",\"info\":[{\"an\":\"2017114256712\",\"sqr\":[\"橫琴國際知識產權交易中心有限公司\"],\"ti\":\"一種視頻編碼方法及裝置\",\"jiaofei\":[{\"name\":\"印花稅\",\"amount\":\"5\"}]}],\"linkMan\":{\"userName\":\"毛雨田\",\"userTel\":\"13718881828\",\"userEmail\":\"layn@live.com\"},\"reimburseInfo\":{\"isReimburse\":\"2\",\"type\":\"1\",\"title\":\"北京航空航天大學\",\"taxNumber\":\"\",\"mailType\":\"1\",\"mailUserName\":\"毛雨田\",\"mailUserTel\":\"13718881828\",\"mailAddr\":\"北京\",\"deliveryType\":\"1\"},\"device\":\"1\"}";
System.out.println(" 1.未使用AES加密前的數據:"+inputStr);
try {
String inputStrEncrypt = AESUtil.aesEncrypt(inputStr, AESPassword);
System.out.println(" 1.客戶端使用第一步中產生的AES密碼對數據加密併發送給服務端:"+inputStrEncrypt);
System.out.println(" 2.服務端接收到客戶端發送過來的加密數據："+inputStrEncrypt);
String inputStrDecrypt = AESUtil.aesDecrypt(inputStrEncrypt, AESPassword);
System.out.println(" 3.服務端使用第一步中解密後的密碼解密數據："+inputStrDecrypt);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
AESUtil.javaapache
import java.math.BigInteger;
import java.util.Map;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.util.Base64Utils;
import com.fasterxml.jackson.databind.ObjectMapper;
public class AESUtil {
public static String AES_KEY = "MTIzNDU2Nzg5MDk4NzY1NA==";
// 算法
private static final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";
private static ObjectMapper objectMapper = new ObjectMapper();
public static Logger logger = Logger.getLogger(AESUtil.class);
/**
* aes解密
*
* @param encrypt
* 內容
* @return
* @throws Exception
*/
public static String aesDecrypt(String encrypt) {
try {
return aesDecrypt(encrypt, AES_KEY);
} catch (Exception e) {
e.printStackTrace();
return "";
}
}
/**
* aes加密
*
* @param content
* @return
* @throws Exception
*/
public static String aesEncrypt(String content) {
try {
return aesEncrypt(content, AES_KEY);
} catch (Exception e) {
e.printStackTrace();
return "";
}
}
/**
* 將byte[]轉爲各類進制的字符串
*
* @param bytes
* byte[]
* @param radix
* 能夠轉換進制的範圍，從Character.MIN_RADIX到Character.MAX_RADIX，超出範圍後變爲10進制
* @return 轉換後的字符串
*/
public static String binary(byte[] bytes, int radix) {
return new BigInteger(1, bytes).toString(radix);// 這裏的1表明正數
}
/**
* base 64 encode
*
* @param bytes
* 待編碼的byte[]
* @return 編碼後的base 64 code
*/
public static String base64Encode(byte[] bytes) {
return Base64.encodeBase64String(bytes);
}
/**
* base 64 decode
*
* @param base64Code
* 待解碼的base 64 code
* @return 解碼後的byte[]
* @throws Exception
*/
public static byte[] base64Decode(String base64Code) throws Exception {
return StringUtils.isEmpty(base64Code) ? null : Base64Utils.decodeFromString(base64Code);
}
/**
* AES加密
*
* @param content
* 待加密的內容
* @param encryptKey
* 加密密鑰
* @return 加密後的byte[]
* @throws Exception
*/
public static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128);
Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(encryptKey.getBytes(), "AES"));
return cipher.doFinal(content.getBytes("utf-8"));
}
/**
* AES加密爲base 64 code
*
* @param content
* 待加密的內容
* @param encryptKey
* 加密密鑰
* @return 加密後的base 64 code
* @throws Exception
*/
public static String aesEncrypt(String content, String encryptKey) throws Exception {
return base64Encode(aesEncryptToBytes(content, encryptKey));
}
/**
* AES解密
*
* @param encryptBytes
* 待解密的byte[]
* @param decryptKey
* 解密密鑰
* @return 解密後的String
* @throws Exception
*/
public static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128);
Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(decryptKey.getBytes(), "AES"));
byte[] decryptBytes = cipher.doFinal(encryptBytes);
return new String(decryptBytes);
}
/**
* 將base 64 code AES解密
*
* @param encryptStr
* 待解密的base 64 code
* @param decryptKey
* 解密密鑰
* @return 解密後的string
* @throws Exception
*/
public static String aesDecrypt(String encryptStr, String decryptKey) throws Exception {
return StringUtils.isEmpty(encryptStr) ? null : aesDecryptByBytes(base64Decode(encryptStr), decryptKey);
}
@SuppressWarnings("unchecked")
public static Map<String, Object> aesDecrypt2Map(String encryptStr, String decryptKey){
if(StringUtils.isBlank(decryptKey) || decryptKey.length() != 16){
return null;
}
try {
String json = aesDecrypt(encryptStr, decryptKey);
return objectMapper.readValue(json, Map.class);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
public static void main(String[] args) throws Exception {
String content = "kkkkkkk";
System.out.println("加密前：" + content);
System.out.println("加密密鑰和解密密鑰：" + AES_KEY);
String encrypt = aesEncrypt(content, AES_KEY);
System.out.println("加密後：" + encrypt);
String decrypt = aesDecrypt(encrypt, AES_KEY);
System.out.println("解密後：" + decrypt);
// js加密後的字符串: lkqsgKHH7OkhIa0tISMtuQ==
//String jsData = aesDecrypt("lkqsgKHH7OkhIa0tISMtuQ==", AES_KEY);
//System.out.println("前端數據解密後的值:" + jsData);
}
}
EncryptController.javajson
import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.smartsport.common.cache.CacheService;
import com.smartsport.common.cache.constant.CacheConstant;
import com.smartsport.common.model.ReturnFormatModel;
import com.smartsport.common.utils.RSAHelper;
import com.smartsport.common.utils.RandomStringUtil;
@Controller
@RequestMapping({ "/encrypt" })
public class EncryptController {
@Autowired
@Qualifier("RedisCacheServiceImpl")
private CacheService cacheService;
@RequestMapping("/disposable")
@ResponseBody
public Map<String, Object> disposable(@RequestBody Map<String, String> jsonMap){
String aesPasswordEncrypt = jsonMap.get("disposable");
System.out.println(aesPasswordEncrypt);
String aesPasswordDecipher = RSAHelper.decipher(aesPasswordEncrypt, RSAHelper.PRIVATE_KEY_VALUES);
String signal = RandomStringUtil.generateString(16) + cacheService.generate(CacheConstant.prefix+"aes_disposable");
System.out.println("signal:"+signal);
cacheService.put(CacheConstant.prefix+"aes_" + signal, aesPasswordDecipher, CacheConstant.AES_DISPOSABLE_TIMEOUT, CacheConstant.AES_DISPOSABLE_UNIT);
Map<String, Object> resultMap= new HashMap<String, Object>();
resultMap.put("signal", signal);
return ReturnFormatModel.retParam("1", resultMap);
}
}
相關文章
- 1. springmvc 數據加密解密(1)------服務端加解密
- 2. springmvc 數據加密解密(2)------前端加解密
- 3. Javascript端加密java服務端解密
- 4. springMVC數據庫加密解密
- 5. 加密解密
- 6. 數據加密解密類
- 7. js數據加密解密
- 8. 數據加密與解密
- 9. unity3d-解密加密數據
- 10. Android數據加密解密
- 更多相關文章...
- • Kotlin 數據類與密封類 - Kotlin 教程
- • 服務端腳本 指南 - 網站建設指南
- • Flink 數據傳輸及反壓詳解
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. springmvc 數據加密解密(1)------服務端加解密
- 2. springmvc 數據加密解密(2)------前端加解密
- 3. Javascript端加密java服務端解密
- 4. springMVC數據庫加密解密
- 5. 加密解密
- 6. 數據加密解密類
- 7. js數據加密解密
- 8. 數據加密與解密
- 9. unity3d-解密加密數據
- 10. Android數據加密解密