前言
http/https协议提交在被抓包时请求内容是明文的, 直接传输账号密码的风险非常大，故这里我们要对数据加密处理，并生成校验码，防止数据篡改
Http/https传输账户密码等数据时需要加密处理的原因主要有以下几点：
- 数据保密性：账户密码等敏感信息是用户的私密数据，如果明文传输，可能会被中间人窃取或篡改，导致用户的账户被盗用或信息泄露。通过加密处理，可以保证数据在传输过程中的保密性，使得只有合法的接收方能够解密和使用这些数据。
- 防止篡改：在传输过程中，数据可能会被恶意篡改，例如中间人攻击、数据包劫持等。通过加密处理，可以在接收方验证数据的完整性，确保数据在传输过程中没有被篡改。
- 身份验证：加密处理可以用于身份验证，确保数据的发送方和接收方的身份是合法的。例如，使用公钥加密算法对数据进行加密，只有拥有私钥的接收方才能解密，从而验证发送方的身份。
具体思路
1.前端对账户信息进行AES加密（与后端使用同一密钥），密码进行MD5加密，再将加密后面的两个字符串拼接在一起，进行MD5加密作为我们的校验码(校验加密数据在请求过程中是否被更改)
2.后端收到加密后的账户和密码以及校验码，同1加密得校验码，比较校验码是否一致，如果一致，进行后续操作
- 注册时，后端对接受到的MD5加密后的密码进行加盐加密操作,并将盐值一并存入库中，方便后续登录校验
- 登录时，取得对应用户的盐值，对接收到的密码进行加盐加密，再与原先库中的密码相比较
以下是注册操作的大体流程
代码实现
前端信息加密处理（Vue）
安装crypto-js库，用来AES加密
npm install crypto-js --save-dev编写AES加密工具类
import CryptoJS from 'crypto-js';
//加密
export const aesEncrypt = (word : string, keyStr : string) => {
keyStr = keyStr ? keyStr : 'abcdsxyzhkj12345'; //判断是否存在ksy，不存在就用定义好的key
const key = CryptoJS.enc.Utf8.parse(keyStr);
const srcs = CryptoJS.enc.Utf8.parse(word);
const encrypted = CryptoJS.AES.encrypt(srcs, key, { mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.Pkcs7 });
return encrypted.toString();
}
//解密
export const aesDecrypt = (word : string, keyStr : string) => {
keyStr = keyStr ? keyStr : 'abcdsxyzhkj12345';
const key = CryptoJS.enc.Utf8.parse(keyStr);
const decrypt = CryptoJS.AES.decrypt(word, key, { mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.Pkcs7 });
return CryptoJS.enc.Utf8.stringify(decrypt).toString();
}
//密钥（长度必须为16位，或者16位的倍数）
export const encodeSecret = "1148+=--jkl;P,fj"编写MD5加密类
// md5加密
export function md5(string : string,bit : Number) {
function md5_RotateLeft(lValue, iShiftBits) {
return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
}
function md5_AddUnsigned(lX, lY) {
var lX4, lY4, lX8, lY8, lResult;
lX8 = (lX & 0x80000000);
lY8 = (lY & 0x80000000);
lX4 = (lX & 0x40000000);
lY4 = (lY & 0x40000000);
lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
if (lX4 & lY4) {
return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
}
if (lX4 | lY4) {
if (lResult & 0x40000000) {
return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
} else {
return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
}
} else {
return (lResult ^ lX8 ^ lY8);
}
}
function md5_F(x, y, z) {
return (x & y) | ((~x) & z);
}
function md5_G(x, y, z) {
return (x & z) | (y & (~z));
}
function md5_H(x, y, z) {
return (x ^ y ^ z);
}
function md5_I(x, y, z) {
return (y ^ (x | (~z)));
}
function md5_FF(a, b, c, d, x, s, ac) {
a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_F(b, c, d), x), ac));
return md5_AddUnsigned(md5_RotateLeft(a, s), b);
};
function md5_GG(a, b, c, d, x, s, ac) {
a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_G(b, c, d), x), ac));
return md5_AddUnsigned(md5_RotateLeft(a, s), b);
};
function md5_HH(a, b, c, d, x, s, ac) {
a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_H(b, c, d), x), ac));
return md5_AddUnsigned(md5_RotateLeft(a, s), b);
};
function md5_II(a, b, c, d, x, s, ac) {
a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_I(b, c, d), x), ac));
return md5_AddUnsigned(md5_RotateLeft(a, s), b);
};
function md5_ConvertToWordArray(string) {
var lWordCount;
var lMessageLength = string.length;
var lNumberOfWords_temp1 = lMessageLength + 8;
var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
var lWordArray = Array(lNumberOfWords - 1);
var lBytePosition = 0;
var lByteCount = 0;
while (lByteCount < lMessageLength) {
lWordCount = (lByteCount - (lByteCount % 4)) / 4;
lBytePosition = (lByteCount % 4) * 8;
lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount) << lBytePosition));
lByteCount++;
}
lWordCount = (lByteCount - (lByteCount % 4)) / 4;
lBytePosition = (lByteCount % 4) * 8;
lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
return lWordArray;
};
function md5_WordToHex(lValue) {
var WordToHexValue = "", WordToHexValue_temp = "", lByte, lCount;
for (lCount = 0; lCount <= 3; lCount++) {
lByte = (lValue >>> (lCount * 8)) & 255;
WordToHexValue_temp = "0" + lByte.toString(16);
WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);
}
return WordToHexValue;
};
function md5_Utf8Encode(string) {
string = string.replace(/\r\n/g, "\n");
var utftext = "";
for (var n = 0; n < string.length; n++) {
var c = string.charCodeAt(n);
if (c < 128) {
utftext += String.fromCharCode(c);
} else if ((c > 127) && (c < 2048)) {
utftext += String.fromCharCode((c >> 6) | 192);
utftext += String.fromCharCode((c & 63) | 128);
} else {
utftext += String.fromCharCode((c >> 12) | 224);
utftext += String.fromCharCode(((c >> 6) & 63) | 128);
utftext += String.fromCharCode((c & 63) | 128);
}
}
return utftext;
};
var x = Array();
var k, AA, BB, CC, DD, a, b, c, d;
var S11 = 7, S12 = 12, S13 = 17, S14 = 22;
var S21 = 5, S22 = 9, S23 = 14, S24 = 20;
var S31 = 4, S32 = 11, S33 = 16, S34 = 23;
var S41 = 6, S42 = 10, S43 = 15, S44 = 21;
string = md5_Utf8Encode(string);
x = md5_ConvertToWordArray(string);
a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;
for (k = 0; k < x.length; k += 16) {
AA = a; BB = b; CC = c; DD = d;
a = md5_FF(a, b, c, d, x[k + 0], S11, 0xD76AA478);
d = md5_FF(d, a, b, c, x[k + 1], S12, 0xE8C7B756);
c = md5_FF(c, d, a, b, x[k + 2], S13, 0x242070DB);
b = md5_FF(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
a = md5_FF(a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
d = md5_FF(d, a, b, c, x[k + 5], S12, 0x4787C62A);
c = md5_FF(c, d, a, b, x[k + 6], S13, 0xA8304613);
b = md5_FF(b, c, d, a, x[k + 7], S14, 0xFD469501);
a = md5_FF(a, b, c, d, x[k + 8], S11, 0x698098D8);
d = md5_FF(d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
c = md5_FF(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
b = md5_FF(b, c, d, a, x[k + 11], S14, 0x895CD7BE);
a = md5_FF(a, b, c, d, x[k + 12], S11, 0x6B901122);
d = md5_FF(d, a, b, c, x[k + 13], S12, 0xFD987193);
c = md5_FF(c, d, a, b, x[k + 14], S13, 0xA679438E);
b = md5_FF(b, c, d, a, x[k + 15], S14, 0x49B40821);
a = md5_GG(a, b, c, d, x[k + 1], S21, 0xF61E2562);
d = md5_GG(d, a, b, c, x[k + 6], S22, 0xC040B340);
c = md5_GG(c, d, a, b, x[k + 11], S23, 0x265E5A51);
b = md5_GG(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
a = md5_GG(a, b, c, d, x[k + 5], S21, 0xD62F105D);
d = md5_GG(d, a, b, c, x[k + 10], S22, 0x2441453);
c = md5_GG(c, d, a, b, x[k + 15], S23, 0xD8A1E681);
b = md5_GG(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
a = md5_GG(a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
d = md5_GG(d, a, b, c, x[k + 14], S22, 0xC33707D6);
c = md5_GG(c, d, a, b, x[k + 3], S23, 0xF4D50D87);
b = md5_GG(b, c, d, a, x[k + 8], S24, 0x455A14ED);
a = md5_GG(a, b, c, d, x[k + 13], S21, 0xA9E3E905);
d = md5_GG(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
c = md5_GG(c, d, a, b, x[k + 7], S23, 0x676F02D9);
b = md5_GG(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
a = md5_HH(a, b, c, d, x[k + 5], S31, 0xFFFA3942);
d = md5_HH(d, a, b, c, x[k + 8], S32, 0x8771F681);
c = md5_HH(c, d, a, b, x[k + 11], S33, 0x6D9D6122);
b = md5_HH(b, c, d, a, x[k + 14], S34, 0xFDE5380C);
a = md5_HH(a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
d = md5_HH(d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
c = md5_HH(c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
b = md5_HH(b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
a = md5_HH(a, b, c, d, x[k + 13], S31, 0x289B7EC6);
d = md5_HH(d, a, b, c, x[k + 0], S32, 0xEAA127FA);
c = md5_HH(c, d, a, b, x[k + 3], S33, 0xD4EF3085);
b = md5_HH(b, c, d, a, x[k + 6], S34, 0x4881D05);
a = md5_HH(a, b, c, d, x[k + 9], S31, 0xD9D4D039);
d = md5_HH(d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
c = md5_HH(c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
b = md5_HH(b, c, d, a, x[k + 2], S34, 0xC4AC5665);
a = md5_II(a, b, c, d, x[k + 0], S41, 0xF4292244);
d = md5_II(d, a, b, c, x[k + 7], S42, 0x432AFF97);
c = md5_II(c, d, a, b, x[k + 14], S43, 0xAB9423A7);
b = md5_II(b, c, d, a, x[k + 5], S44, 0xFC93A039);
a = md5_II(a, b, c, d, x[k + 12], S41, 0x655B59C3);
d = md5_II(d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
c = md5_II(c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
b = md5_II(b, c, d, a, x[k + 1], S44, 0x85845DD1);
a = md5_II(a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
d = md5_II(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
c = md5_II(c, d, a, b, x[k + 6], S43, 0xA3014314);
b = md5_II(b, c, d, a, x[k + 13], S44, 0x4E0811A1);
a = md5_II(a, b, c, d, x[k + 4], S41, 0xF7537E82);
d = md5_II(d, a, b, c, x[k + 11], S42, 0xBD3AF235);
c = md5_II(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
b = md5_II(b, c, d, a, x[k + 9], S44, 0xEB86D391);
a = md5_AddUnsigned(a, AA);
b = md5_AddUnsigned(b, BB);
c = md5_AddUnsigned(c, CC);
d = md5_AddUnsigned(d, DD);
}
if(bit==32){
return (md5_WordToHex(a) + md5_WordToHex(b) + md5_WordToHex(c) + md5_WordToHex(d)).toLowerCase();
}
return (md5_WordToHex(b) + md5_WordToHex(c)).toLowerCase();
}后端处理（springboot）
自定义AES加密密钥以及盐值长度等配置
encoding:
# key需要为16位的倍数
aes-secret-key: "9948+=--jkl;P,fj"
salt-length: 6定义AES工具类
/**
* java使用AES加密解密 AES-128-ECB加密
* 与mysql数据库aes加密算法通用
* 数据库aes加密解密
* -- 加密
* SELECT to_base64(AES_ENCRYPT('www.gowhere.so','jkl;POIU1234++=='));
* -- 解密
* SELECT AES_DECRYPT(from_base64('Oa1NPBSarXrPH8wqSRhh3g=='),'jkl;POIU1234++==');
* @author 836508
*
*/
public class AESUtil {
// 加密
public static String Encrypt(String sSrc, String sKey) throws Exception {
if (sKey == null) {
System.out.print("Key为空null");
return null;
}
// 判断Key是否为16位
if (sKey.length() != 16) {
System.out.print("Key长度不是16位");
return null;
}
byte[] raw = sKey.getBytes("utf-8");
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");//"算法/模式/补码方式"
cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
byte[] encrypted = cipher.doFinal(sSrc.getBytes("utf-8"));
return new BASE64Encoder().encode(encrypted);//此处使用BASE64做转码功能，同时能起到2次加密的作用。
}
// 解密
public static String Decrypt(String sSrc, String sKey) throws Exception {
try {
// 判断Key是否正确
if (sKey == null) {
System.out.print("Key为空null");
return null;
}
// 判断Key是否为16位
if (sKey.length() != 16) {
System.out.print("Key长度不是16位");
return null;
}
byte[] raw = sKey.getBytes("utf-8");
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, skeySpec);
byte[] encrypted1 = new BASE64Decoder().decodeBuffer(sSrc);//先用base64解密
try {
byte[] original = cipher.doFinal(encrypted1);
String originalString = new String(original,"utf-8");
return originalString;
} catch (Exception e) {
System.out.println(e.toString());
return null;
}
} catch (Exception ex) {
System.out.println(ex.toString());
return null;
}
}
public static void main(String[] args) throws Exception {
/*
* 此处使用AES-128-ECB加密模式，key需要为16位。
*/
String cKey = "9948+=--jkl;P,fj";
// 需要加密的字串
String cSrc = "W2hXf6pAeuCP0u2Domsnfg==";
System.out.println(cSrc);
// // 加密
// String enString = AESUtil.Encrypt(cSrc, cKey);
// System.out.println("加密后的字串是：" + enString);
// 解密
String DeString = AESUtil.Decrypt(cSrc, cKey);
System.out.println("解密后的字串是：" + DeString);
}
}定义MD5工具类
/**
* @description MD5加密工具类，支持位数，加盐，无盐，大小写
*/
public class MD5Util {
/**
* @Title: md5Lower
* @Description:不加盐值32位小写
*/
public static String md5Lower(String plainText) {
String md5 = null;
if (null != plainText && !"".equals(plainText)) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(plainText.getBytes("UTF-8"));
md5 = new BigInteger(1, md.digest()).toString(16);
} catch (Exception e) {
e.printStackTrace();
}
}
return md5;
}
/**
* @Title: md5Lower
* @Description:加盐值32位小写
*/
public static String md5Lower(String plainText, String saltValue) {
String md5 = null;
if (null != plainText && !"".equals(plainText) && null != saltValue && !"".equals(saltValue)) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(plainText.getBytes("UTF-8"));
md.update(saltValue.getBytes("UTF-8"));
md5 = new BigInteger(1, md.digest()).toString(16);
} catch (Exception e) {
e.printStackTrace();
}
}
return md5;
}
/**
* @Title: md5_16Lower
* @Description:不加盐值16位小写
*/
public static String md5_16Lower(String plainText) {
String md5 = md5Lower(plainText);
return null==md5?md5:md5.substring(8, 24);
}
/**
* @Title: md5_16Lower
* @Description:加盐值16位小写
*/
public static String md5_16Lower(String plainText, String saltValue) {
String md5 = md5Lower(plainText, saltValue);
return null==md5?md5:md5.substring(8, 24);
}
/**
* @Title: md5_16Upper
* @Description:不加盐值16位大写
*/
public static String md5_16Upper(String plainText) {
String md5 = md5_16Lower(plainText);
return null==md5?md5:md5.toUpperCase();
}
/**
* @Title: md5_16Upper
* @Description:加盐值16位大写
*/
public static String md5_16Upper(String plainText, String saltValue) {
String md5 = md5_16Lower(plainText, saltValue);
return null==md5?md5:md5.toUpperCase();
}
/**
* @Title: md5Upper
* @Description:不加盐值32位大写
*/
public static String md5Upper(String plainText) {
String md5 = md5Lower(plainText);
return null==md5?md5:md5.toUpperCase();
}
/**
* @Title: md5Upper
* @Description:加盐值32位大写
*/
public static String md5Upper(String plainText, String saltValue) {
String md5 = md5Lower(plainText, saltValue);
return null==md5?md5:md5.toUpperCase();
}
}随机盐值生成工具类(能生成随机字符串即可)
public class RandUtils {
/**
* 生成count长度的验证码
* @param count
* @return
*/
public static String getRandomCode(Integer count){
Random r = new Random();
String includes = "qwertyuiopasdfghjklzxcvbnm1234567890";
String code = "";
for (int i = 0; i < count; i++) {
Integer index = r.nextInt(36);
code += includes.charAt(index);
}
return code;
}
}用户注册Controller层
@PostMapping("/register")
public R register(@Valid @RequestBody UserRegisterDto registerQo) throws Exception {
// 1.数据hash校验
String username = registerQo.getUsername();
String password = registerQo.getPassword();
String hashCode = MD5Util.md5Lower(username + password); //重新生成校验码
if(!hashCode.equals(registerQo.getHashCode())){
return R.error("数据异常,请重试");
}
// 2.用户名AES解密还原
registerQo.setUsername(AESUtil.Decrypt(username, AES_SECRET));
// 3.校验通过，开始注册流程
userService.userRegister(registerQo);
return R.success("用户注册成功");
}用户注册Service层
@Override
public void userRegister(UserRegisterDto registerQo) {
// 1.验证码校验
String code = redisService.getString(registerQo.getUserEmail());
if (!registerQo.getVericode().equals(code)) {
throw new CustomException("验证码错误");
}
// 2.查询信息是否存在
LambdaQueryWrapper<SystemUser> queryWrapper1 = new LambdaQueryWrapper<>();
queryWrapper1.eq(SystemUser::getUserEmail, registerQo.getUserEmail());
SystemUser systemUserOld = getOne(queryWrapper1);
if (systemUserOld != null) {
throw new CustomException("该邮箱已经被注册");
}
LambdaQueryWrapper<SystemUser> queryWrapper2 = new LambdaQueryWrapper<>();
queryWrapper2.eq(SystemUser::getUsername, registerQo.getUsername());
systemUserOld = getOne(queryWrapper2);
if (systemUserOld != null) {
throw new CustomException("该用户名已经被注册");
}
// 3.加盐加密操作
String salt = RandUtils.getRandomCode(SALT_LENGTH); //生成盐值
String passwordMd5WithSalt = MD5Util.md5Lower(registerQo.getPassword(), salt);//加盐MD5加密
// 4.添加用户
SystemUser systemUser = new SystemUser();
systemUser.setUsername(registerQo.getUsername());
systemUser.setPassword(passwordMd5WithSalt);
systemUser.setUserEmail(registerQo.getUserEmail());
systemUser.setHash(salt); //一并保存盐值
save(systemUser);
// 5.删除验证码缓存
redisService.delete(registerQo.getUserEmail());
}用户登录Controller层
@PostMapping("/login")
public R login(@Valid @RequestBody UserLoginDto userLoginDto) throws Exception {
// 1.数据hash校验
String username = userLoginDto.getUsername();
String password = userLoginDto.getPassword();
String hashCode = MD5Util.md5Lower(username + password); //重新生成校验码
if(!hashCode.equals(userLoginDto.getHashCode())){
return R.error("数据异常,请重试");
}
// 2.用户名AES解密还原
userLoginDto.setUsername(AESUtil.Decrypt(username, AES_SECRET));
// 3.校验通过，开始登录验证
LoginSuccessVo loginVo = userService.userLogin(userLoginDto);
return R.success(loginVo);
}用户登录service层
@Override
public LoginSuccessVo userLogin(UserLoginDto userLoginDto) {
// 1.验证码校验
String code = redisService.getString(Constant.ImageCodePreKey + userLoginDto.getCodeUuid());
if (code == null) {
throw new CustomException("验证码已过期");
}
if (!code.toUpperCase().equals(userLoginDto.getVericode().toUpperCase())) {
throw new CustomException("验证码错误");
}
// 2.查找用户
SystemUser systemUser = seekUser(userLoginDto.getUsername());
if (systemUser == null) {
throw new CustomException("用户不存在");
}
// 3.密码校验
// 密码盐值处理
String password = MD5Util.md5Lower(userLoginDto.getPassword() + systemUser.getHash());
if (!systemUser.getPassword().equals(password)) {
throw new CustomException("用户密码错误");
}
// 4.封装token信息
UUID token = UUID.randomUUID();
/*将token存入缓存中,有效期为三天，这里我们把token当成key,用户id当成value*/
redisService.setStringTime(token.toString(), systemUser.getId().toString(), new Long(3), TimeUnit.DAYS);
/*删除本次登录验证码的缓存*/
redisService.delete(Constant.ImageCodePreKey + userLoginDto.getCodeUuid());
/*返回登录成功的信息*/
LoginSuccessVo loginVo = new LoginSuccessVo();
systemUser.setPassword("");
loginVo.setSystemUser(systemUser);
loginVo.setToken(token.toString());
return loginVo;
}相关文章
【JS】【Vue3】【React】获取鼠标位置的方法：JavaScript、Vue 3和React示例
随着Web应用程序的复杂性不断增加，获取用户交互信息变得越来越重要。其中，获取鼠标位置是一项常见的任务，可以用于实现各种交互效果，如拖拽、悬停提示等。本文将探讨在JavaScript、Vue 3和React中获取鼠标位置的不同方法，并提供相应的示例。
编程日记 2024/02/28 09:12:05
Springboot中如何记录好日志
springboot项目如何配置日志，日志门面和日志实现的区别是什么，如何通过日志切面将日志和代码解耦，这里都有分享。
编程日记 2024/02/27 21:34:27
Java实战：定制Spring MVC拦截器链
本文将详细介绍如何定制Spring MVC拦截器链。我们将探讨Spring MVC拦截器的基本概念，以及如何使用Spring Boot和Spring MVC来实现自定义拦截器
编程日记 2024/02/24 08:34:15
【Vue3】使用ref与reactive创建响应式对象
先来简单介绍一下ref，它可以定义响应式的变量let xxx = ref(初始值)。**返回值：**一个RefImpl的实例对象，简称ref对象或refref对象的value属性是响应式的。JSxxx.value，但模板中不需要.value，直接使用即可。对于let name = ref('张三')来说，name不是响应式的，name.value是响应式的。下面我们看一看上图红框中代表的意思是，我们哪里需要响应就在哪个里面导入上述代码即可。
编程日记 2024/02/21 09:49:43
如何设置页面恢复运行事件触发回调
由于 Android 原生的 resume 和 pause 事件不能区分是压后台导致还是页面切换导致，所以 pageResume 和 pagePause 事件是通过 JSAPI 调用记录回调的，仅适用于同一个 session 内 Window 之间的互相切换。当一个 WebView 界面重新回到栈顶时，例如从后台被唤起、锁屏界面恢复、从下个页面回退，会触发页面恢复运行（resume）事件。如果这个界面是通过 popWindow 或 popTo 到达，且传递了 data 参数，则此页可以获取到这些参数。
编程日记 2024/02/21 09:47:28
日常遇到Maven出现依赖版本/缓存问题通用思路。
如果怀疑是本地仓库中缓存的依赖有问题，可以手动删除本地仓库（默认位置在用户的.m2/repository目录下），但这是一个较为极端的做法，因为这会删除所有项目的所有本地依赖，之后Maven将不得不重新下载这些依赖。针对于这样的问题 首先我们的第一思路 就是怀疑到是缓存的问题，那么我在这里去描述一下 我们遇到这类通用类的问题如何解决。检查项目的pom.xml文件，确认依赖声明正确无误，没有冲突的版本号或不正确的依赖范围。版本问题导致的，但是我确认过了一下的一些操作 依然没有解决我的问题。
编程日记 2024/02/21 09:45:27
vue打包优化，webpack的8大配置方案
vue-cli 生成的项目通常集成Webpack ，在打包的时候，需要webpack来做一些事情。这里我们希望它可以压缩代码体积，提高运行效率。
编程日记 2024/02/19 20:53:02
什么是tomcat？tomcat是干什么用的？
Tomcat是一个开源的、轻量级的应用服务器，是Apache软件基金会的一个项目。它实现了Java Servlet、JavaServer Pages（JSP）和Java Expression Language（EL）等Java技术，用于支持在Java平台上运行的动态Web应用程序。AJP是用于Apache服务器与Tomcat之间进行通信的协议，通常用于将动态生成的内容传递给Apache服务器进行处理。它能够运行Servlet和JSP，提供了一个环境，使得开发者能够构建和运行基于Java的Web应用。
编程日记 2024/02/19 20:51:12
IP定位技术助力网络安全保护
当网络遭受DDoS攻击时，通过IP定位技术，可以迅速确定攻击源头的地理位置，进而采取相应的防御措施，如屏蔽攻击源IP地址等。随着技术的不断进步和应用场景的不断拓展，IP定位技术将在网络安全保护领域发挥更加重要的作用，为网络空间的安全稳定提供有力保障。例如，网络管理员可以根据IP定位结果，将恶意IP地址列入黑名单，阻止其访问网络，从而避免潜在的安全威胁。IP定位技术是一种基于IP地址的地理位置定位技术，通过分析IP地址的归属地信息，可以精确地确定网络用户的地理位置，从而实现对网络流量的有效监控和管理。
编程日记 2024/02/19 20:50:32
C# winfrom中excel文件导入导出
在C#交流群里，看到很多小伙伴在excel数据导入导出到C#界面上存在疑惑，所以今天专门做了这个主题，希望大家有所收获！环境：win10+vs2017界面：主要以演示为主，所以没有做优化，然后主界面上添加两个按钮，分别命名为ExportExcel和ImportExcel，添加两个dataGridView，分别是dataGridView1和dataGridView2然后在窗体加载程序中给dataGr...
编程日记 2024/02/17 14:00:34
maven实战：Centos7.9原生安装maven
通过官网https://maven.apache.org下载 后缀名为.tar.gz的压缩包。将压缩包上传到服务器/usr/local/bin 目录下，使用以下命令解压。
编程日记 2024/02/16 20:31:50
Java 与 JavaScript 的区别与联系
Java 和 JavaScript 两种编程语言在软件开发中扮演着重要的角色。尽管它们都以“Java”命名，但实际上它们是完全不同的语言，各有其独特的特点和用途。本文将深入探讨 Java 和 JavaScript 的区别与联系，帮助大家更好地理解它们在编程世界中的作用。
编程日记 2024/02/13 20:01:28
C语言中的作用域与生命周期
但是全局变量被 static 修饰之后，外部链接属性就变成了内部链接属性，只能在自己所在的源文件内部使用了，其他源文件，即使声明了，也是无法正常使用的。结论：static修饰局部变量改变了变量的生命周期，生命周期改变的本质是改变了变量的存储类型，本来一个局部变量是存储在内存的栈区的，但是被 static 修饰后存储到了静态区。extern 是用来声明外部符号的，如果一个全局的符号在A文件中定义的，在B文件中想使用，就可以使用extern进行声明，然后使用。全局变量的生命周期是：整个程序的生命周期。
编程日记 2024/02/13 20:00:24
树莓派4B（Raspberry Pi 4B）使用docker搭建springBoot/springCloud服务
树莓派4B（Raspberry Pi 4B）使用docker搭建springBoot/springCloud服务
编程日记 2024/02/13 19:58:42
Python和Java的区别（不断更新）
运行效率：一般来说，Java的运行效率要高于Python，这主要是因为Java是编译型语言，其代码在执行前会进行预编译，而Python是解释型语言，边解释边执行。而Python没有类似的强大虚拟机，但它的核心是可以很方便地使用C语言函数或C++库，这使得Python可以轻松地与底层硬件进行交互。**类型系统：**Java是一种静态类型语言，所有变量需要先声明（类型）才能使用，且类型在编译时就已经确定。总的来说，Python和Java各有其优势和特点，选择哪种语言取决于具体的项目需求、开发环境以及个人偏好。
编程日记 2024/02/11 20:37:25
.[hudsonL@cock.li].mkp勒索病毒数据怎么处理|数据解密恢复
这些勒索病毒往往攻击入侵的目标基本是Windows系统的服务器，包括一些市面上常见的业务应用软件，例如：金蝶软件数据库，用友软件数据库，管家婆软件数据库，速达软件数据库，科脉软件数据库，海典软件数据库，思迅软件数据库，OA软件数据库，ERP软件数据库，自建网站的数据库等，均是其攻击加密的常见目标文件，所以有以上这些业务应用软件的服务器更应该注意做好服务器安全加固及数据备份工作。通过采取这些预防措施，您可以最大程度地降低成为[hudsonL@cock.li].mkp勒索病毒等威胁的风险，并保护您的数据安全。
编程日记 2024/02/10 19:57:10
服务器与电脑的区别?
服务器是指一种专门提供计算和存储资源、运行特定软件服务的物理或虚拟计算机。服务器主要用于接受和处理来自客户端（如个人电脑、手机等）的请求，并向客户端提供所需的服务或数据。服务器在网络环境中扮演着中心节点的角色，负责存储和管理数据、提供网络服务、处理计算任务等。
编程日记 2024/02/10 19:41:26
windows下ngnix自启动（借助工具winSw）
在windows下安装nginx后，不想每次都手动启动。本文记录下windows下ngnix自启动（借助工具winSw）的操作流程提示：以下是本篇文章正文内容，下面案例可供参考本文记录下windows下ngnix自启动（借助工具winSw）的操作流程。
编程日记 2024/02/08 18:11:23
synchronized 和 Lock 有什么区别？synchronized 和 ReentrantLock 区别是什么？说一下 atomic 的原理？
例如，AtomicInteger 的 incrementAndGet() 方法就是通过 CAS 操作实现的，它首先尝试原子地将共享变量加 1，如果操作成功，则返回新的值，否则重试直到操作成功为止。CAS 操作的原理是，当 V 的值等于 A 时，将 V 的值更新为 B，否则什么也不做。synchronized 和 Lock 都是 Java 中用于实现线程同步的关键字/类库，它们都能够提供对共享资源的安全访问和防止数据竞争的功能，但是在实现方式、特性、适用场景等方面存在一些差异。
编程日记 2024/02/07 09:09:26
Java开发四则运算-使用递归和解释器模式
四则运算Expression implement。ExpressionParser 核心实现类。Context 编写测试代码。
编程日记 2024/02/03 10:54:40
Kafka常见生产问题详解
比如，在原有Topic下，可以调整Producer的分区策略，让Producer将后续的消息更多的发送到新增的Partition里，这样可以让各个Partition上的消息能够趋于平衡。思路是可行的，但是重试的次数，发送消息的数量等都是需要考虑的问题。PageCache缓存中的消息是断电即丢失的。因为如果业务逻辑异步进行，而消费者已经同步提交了Offset，那么如果业务逻辑执行过程中出现了异常，失败了，那么Broker端已经接收到了消费者的应答，后续就不会再重新推送消息，这样就造成了业务层面的消息丢失。
编程日记 2024/02/02 14:04:11
深入理解 Java 变量类型、声明及应用
Java 变量 变量是用于存储数据值的容器。在 Java 中，有不同类型的变量，例如： String - 存储文本，例如 &quot;你好&quot;。字符串值用双引号引起来。 int - 存储整数（全数字），没有小数，例如 123 或 -123。 float - 存储浮点数，带有小数，例如 19.
编程日记 2024/02/01 21:45:51
Zookeeper分布式队列实战
ZooKeeper实现队列步骤1.创建队列根节点：在Zookeeper中创建一个持久节点，用作队列的根节点。所有队列元素的节点将放在这个根节点下。2.实现入队操作：当需要将一个元素添加到队列时，可以在队列的根节点下创建一个临时有序节点。节点的数据可以包含队列元素的信息。3.实现出队操作：当需要从队列中取出一个元素时，先获取根节点下的所有子节点。再找到具有最小序号的子节点，获取该节点的数据，删除该节点，然后返回节点的数据。
编程日记 2024/02/01 14:42:13
SpringMVC校验注解不生效
用来实现参数校验功能。Spring使用hibernate-validator作为它的默认实现，我们只需要进行一些简单的注解声明，就可以达到参数校验的功能。但是在实际使用场景中，经常会出现校验没生效的问题。
编程日记 2024/01/31 20:39:50
Web 安全之点击劫持（Clickjacking）攻击详解
点击劫持（Clickjacking）攻击，又称为界面伪装攻击，是一种利用视觉欺骗手段进行攻击的方式。攻击者通过技术手段欺骗用户点击本没有打算点击的位置，当用户在被攻击者攻击的页面上进行操作时，实际点击结果被劫持，从而被攻击者利用。这种攻击方式利用了用户对网站的信任，通过覆盖层（通常是透明的iframe）覆盖在另一个网页之上，使受害者无法察觉。
编程日记 2024/01/28 17:47:23
为什么Java中的String类被设计为final类？
String类作为Java中不可或缺的类之一，被设计成final类带来了不可变性、安全性、可靠性和性能优势。不可变的特性使得String对象在多线程环境下安全共享，提高了应用程序的并发性和性能。此外，String类的设计还符合Java类库的一致性和规范，确保了整个语言的稳定性和可靠性。因此，String类被设计成final类是出于多方面的考虑，以提供最佳的使用体验和编程效率。
编程日记 2024/01/27 08:53:11
bat脚本打开多个黑窗口并执行不同的命令
在使用java -jar运行jar包之前，需要先启动redis，而redis的安装目录与jar包不在同一目录下，所以每次启动项目的时候都需要来回的切换目录。现写了一个bat脚本，用来一键启动redis和jar包。start cmd /k "cd /d redis安装目录 && redis-server redis.windows.conf"其中，cmd /k命令是不关闭黑窗口的命令，timeout /T 3表示等待3秒，/NOBREAK表示键盘输入不会中断等待。
编程日记 2024/01/26 16:42:44
鸿蒙（ArkUI）开发：实现二级联动
列表的二级联动（Cascading List）是指根据一个列表（一级列表）的选择结果，来更新另一个列表（二级列表）的选项。这种联动可以使用户根据实际需求，快速定位到想要的选项，提高交互体验。例如，短视频中拍摄风格的选择、照片编辑时的场景的选择，本文即为大家介绍如何开发二级联动。
编程日记 2024/01/25 21:53:21
Vue和React的区别 | | React函数式写法和类写法的区别
React 更多的是一个库而不是框架，它更专注于视图层的管理，通过社区和第三方库来进行补充和扩展。类式组件: 类式组件是 ES6 中引入的 class 类的一种用法，它继承自 React.Component，拥有完整的生命周期和内部状态管理能力。它是无状态的，没有生命周期和内部状态。而在 React 中，我们使用 JSX 语法，它是一种 JavaScript 的扩展语法，可以在 JavaScript 中直接编写类似 HTML 的结构。在 React 中，我们可以定义组件的两种方式，即函数式组件和类式组件。
编程日记 2024/01/24 20:03:08