加密 解密 EncryptUtils PwdUtils
String text = "base64 in java8 lib";
//编码
String encode = Base64.getEncoder().encodeToString(text.getBytes(StandardCharsets.UTF_8));
System.out.println(encode);
//解码
String decode = new String(Base64.getDecoder().decode(encode), StandardCharsets.UTF_8);
System.out.println(decode);
package com.want.imdg.utils;
import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
/**
* EncryptUtils.java
* Original Author:
* Company: mdcl
* Copyright @ mdcl Co.,Ltd.
**/
public class EncryptUtils {
private static final String PASSWORD_CRYPT_KEY = "88888888";
private final static String DES = "DES";
/**
* 加密
* @param src 数据源
* @param key 密钥，长度必须是8的倍数
* @return 返回加密后的数据
* @throws Exception
*/
public byte[] encrypt(byte[] src, byte[] key) throws Exception {
// DES算法要求有一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 从原始密匙数据创建DESKeySpec对象
DESKeySpec dks = new DESKeySpec(key);
// 创建一个密匙工厂，然后用它把DESKeySpec转换成
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey securekey = keyFactory.generateSecret(dks);
// Cipher对象实际完成加密操作
Cipher cipher = Cipher.getInstance(DES);
// 用密匙初始化Cipher对象
cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
// 获取数据并加密
return cipher.doFinal(src);
}
/**
* 解密
* @param src 数据源
* @param key 密钥，长度必须是8的倍数
* @return 返回解密后的原始数据
* @throws Exception
*/
public byte[] decrypt(byte[] src, byte[] key) throws Exception {
// DES算法要求有一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 从原始密匙数据创建一个DESKeySpec对象
DESKeySpec dks = new DESKeySpec(key);
// 创建一个密匙工厂，然后用它把DESKeySpec对象转换成
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey securekey = keyFactory.generateSecret(dks);
// Cipher对象实际完成解密操作
Cipher cipher = Cipher.getInstance(DES);
// 用密匙初始化Cipher对象
cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
//获取数据并解密
return cipher.doFinal(src);
}
/**
* 密码解密
* @param data
* @return
* @throws Exception
*/
public final String decrypt(String data) throws Exception {
try {
return new String(decrypt(hex2byte(data.getBytes()),PASSWORD_CRYPT_KEY.getBytes()));
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 密码加密
* @param password
* @return
* @throws Exception
*/
public final String encrypt(String password) {
try {
return byte2hex(encrypt(password.getBytes(), PASSWORD_CRYPT_KEY.getBytes()));
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 二行制转字符串
* @param b
* @return
*/
public String byte2hex(byte[] b) {
String hs = "";
String stmp = "";
for (int n = 0; n < b.length; n++) {
stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
if (stmp.length() == 1)
hs = hs + "0" + stmp;
else
hs = hs + stmp;
}
return hs.toUpperCase();
}
public byte[] hex2byte(byte[] b) {
if ((b.length % 2) != 0)
throw new IllegalArgumentException("长度不是偶数");
byte[] b2 = new byte[b.length / 2];
for (int n = 0; n < b.length; n += 2) {
String item = new String(b, n, 2);
b2[n / 2] = (byte) Integer.parseInt(item, 16);
}
return b2;
}
public static void main(String[] args) throws Exception {
EncryptUtils en = new EncryptUtils();
String str = "password";
String str1 = en.encrypt(str);
System.out.println("加密后的串 : " + str1);
System.out.println("解密后的串 : " + en.decrypt(str1));
}
}
ApplicationContextUtil
package com.want.imdg.utils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class ApplicationContextUtil {
static ApplicationContext ctx;
public static ApplicationContext getContext() {
if (ctx != null) {
return ctx;
}
ctx = new ClassPathXmlApplicationContext("/applicationContent.xml");
return ctx;
}
public static Object getBean(String name) {
if (name == null || "".equals(name)) {
return null;
}
return getContext().getBean(name);
}
}
public static String exception(Throwable t) {
if (t == null)
return null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
t.printStackTrace(new PrintStream(baos));
try {
baos.close();
} catch (IOException e) {
log.error("batch-TaskResponse-exception(),IOException:", e);
}
return baos.toString();
}
public class SystemGCTask implements Runnable, Serializable {
static Logger log = Logger.getLogger(SystemGCTask.class);
/**
*
*/
private static final long serialVersionUID = -2805100782229098414L;
@Override
public void run() {
log.info("Run System.gc();");
System.gc();
}
}
package com.want.imdg.utils;
import java.security.MessageDigest;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 加密明文密码
* @author 00272334
*
*/
public class PwdUtils {
/**
* MD5加密字符串
* @param inStr
* @return 加密后的字符串
* @throws Exception
*/
public static String md5Encode(String inStr) throws Exception {
MessageDigest md5 = null;
try {
md5 = MessageDigest.getInstance("MD5");
} catch (Exception e) {
System.out.println(e.toString());
e.printStackTrace();
return "";
}
byte[] byteArray = inStr.getBytes("UTF-8");
byte[] md5Bytes = md5.digest(byteArray);
StringBuffer hexValue = new StringBuffer();
for (int i = 0; i < md5Bytes.length; i++) {
int val = ((int) md5Bytes[i]) & 0xff;
if (val < 16) {
hexValue.append("0");
}
hexValue.append(Integer.toHexString(val));
}
return hexValue.toString();
}
/**
* 正则表达式验证密码规则
* @param str
* @return
*/
public static boolean regex(String str){
// 至少包含一个大写字母、一个数字、一个特殊字符、一些小写字母 大于八位~@#$%^&*()_+|\\=-`
// String pattern = "(?=^.{8,25}$)(?=(?:.*?\\d){1})(?=.*[a-z])(?=(?:.*?[A-Z]){1})(?=(?:.*?[!@#$%*()_+^&}{:;?.]){1})(?!.*\\s)[0-9a-zA-Z!@#$%?*()_+^&]*$";
// String pattern = "(?=^.{8,25}$)(?=(?:.*?\\d){1})(?=.*[a-z])(?=(?:.*?[A-Z]){1})(?=(?:.*?[~@#$%^&*()_+|\\=-`}{:;?.]){1})(?!.*\\s)[0-9a-zA-Z!~@#$%^&*()_+|\\=-`]*$";
String pattern = "(?=.*[0-9])(?=.*[a-zA-Z])(?=.*[^a-zA-Z0-9]).{8,}";
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(str);
return m.matches();
}
/**
* 测试主函数
* @param args
* @throws Exception
*/
public static void main(String args[]) throws Exception {
// String str = new String("P@ssw0rd3");//43c6b452ddf13e5e74254dbca7b5ca68
// System.out.println("原始：" + str);
// System.out.println("MD5后：" + md5Encode(str));
String str = "wwwwwwwww@";
String pattern = "(?=.*[0-9])(?=.*[a-zA-Z])(?=.*[^a-zA-Z0-9]).{8,}";
// String pattern = "(?=^.{8,25}$)(?=(?:.*?\\d){1})(?=.*[a-z])(?=(?:.*?[A-Z]){1})(?=(?:.*?[!@#$%*()_+^&}{:;?.]){1})(?!.*\\s)[0-9a-zA-Z!@#$%*()_+^&]*$";
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(str);
System.out.println(m.matches());
}
}