字符串操作工具类
@Slf4j
public class StringUtils {
/**
* 判断字符串是否为null或者空格
*
* @param str
* @return false不为空 ture为空
*/
public static boolean checkIsStrNull(String str) {
if (null != str && str.trim().length() > 0) {
return false;
} else {
return true;
}
}
/**
* 判断字符串是否为null或者空格
* @param str
* @return true不为空 false为空
*/
public static boolean checkIsStrNotNull(String str){
if (null != str && str.trim().length() > 0) {
return true;
} else {
return false;
}
}
/**
* 逗号拼接的字符串转list
* @param str:逗号拼接的字符串
* @return resultList 返回字符串list
*/
public static List<String> strToList(String str){
String[] strArr =str.split("\\,");
List<String> resultList = new ArrayList<String>(Arrays.asList(strArr));
return resultList;
}
/**
* list转换成逗号拼接的字符串
*/
public static String listToStr(List<String> list, char separator){
StringBuilder sb = new StringBuilder();
for (int i = 0; i < list.size(); i++) {
sb.append(list.get(i)).append(separator);
}
return list.isEmpty() ? "" : sb.toString().substring(0, sb.toString().length() - 1);
}
/**
* 字符串中文改为unicode格式
*
* @param str
* @return
*/
public static String chineseToUnicode(String str) {
StringBuffer result = new StringBuffer();
for (int i = 0; i < str.length(); i++) {
int chr1 = (char) str.charAt(i);
if (chr1 >= 19968 && chr1 <= 171941) {
result.append("\\u" + Integer.toHexString(chr1));
} else {
result.append(str.charAt(i));
}
}
String resultString = result.toString();
try {
resultString = new String(resultString.getBytes(), "utf-8");
} catch (UnsupportedEncodingException e) {
log.error("不支持的编码格式",e);
}
return resultString;
}
/**
* object转String
* @param obj
*/
public static String obj2str(Object obj){
return null == obj ? null : obj.toString();
}
/**
* object 转long
*
*/
public static Long obj2Long(Object obj){
return null == obj ? null : Long.valueOf(obj.toString());
}
public static void main(String[] args) {
String a="1,2,3";
String[] b = a.split("\\,");
List<String> resultList = strToList(a);
System.out.println(resultList);
String c = listToStr(resultList,',');
System.out.println(c);
}
/**
* 防止通配符
*/
public static String checkString(String str) {
if (com.uniview.base.util.StringUtils.checkIsStrNotNull(str)) {
StringBuilder b = new StringBuilder();
b.append(str.trim());
StringBuilder tempBuilder = new StringBuilder();
tempBuilder.append(str.trim());
for (int i = 0, j = 0; i < b.length(); i++) {
char x = b.charAt(i);
if (x == '%' || x == '_') {
tempBuilder.insert(i + j, '\\');
j++;
}
}
str = tempBuilder.toString();
}
return str;
}
}
Jackson常用工具类
public class JacksonUtils {
private static ObjectMapper mapper = new ObjectMapper();
/**
* bean转json
*/
public static String beanToJson(Object obj) throws IOException {
StringWriter sw = new StringWriter();
JsonGenerator gen = new JsonFactory().createJsonGenerator(sw);
mapper.writeValue(gen, obj);
gen.close();
return sw.toString();
}
/**
* json转bean
*/
public static <T> T jsonToBean(String jsonStr, Class<T> objClass)
throws JsonParseException, JsonMappingException, IOException {
return mapper.readValue(jsonStr, objClass);
}
/**
* map转json
*/
public static String mapToJson(Map<String,Object> map) {
ObjectMapper mapper = new ObjectMapper();
String string = null;
try {
string = mapper.writeValueAsString(map);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return string;
}
/**
* json转map
*/
public static Map<String,Object> jsonToMap(String str){
ObjectMapper mapper = new ObjectMapper();
Map readValue = null;
try {
readValue = mapper.readValue(str, Map.class);
} catch (IOException e) {
e.printStackTrace();
}
return readValue;
}
/**
* object 转 json
* @param object
* @return
*/
public static String objectToJson(Object object){
String str = null;
ObjectMapper mapper = new ObjectMapper();
try {
str= mapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return str;
}
}
Id生成器
public class IdGenerator {
private long workerId;
private long datacenterId;
private long sequence = 0L;
private long twepoch = 1288834974657L; // Thu, 04 Nov 2010 01:42:54 GMT
private long workerIdBits = 5L; // 节点ID长度
private long datacenterIdBits = 5L; // 数据中心ID长度
private long maxWorkerId = -1L ^ (-1L << workerIdBits); // 最大支持机器节点数0~31,一共32个
private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits); // 最大支持数据中心节点数0~31,一共32个
private long sequenceBits = 12L; // 序列号12位
private long workerIdShift = sequenceBits; // 机器节点左移12位
private long datacenterIdShift = sequenceBits + workerIdBits; // 数据中心节点左移17位
private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits; // 时间毫秒数左移22位
private long sequenceMask = -1L ^ (-1L << sequenceBits); // 4095
private long lastTimestamp = -1L;
private static class IdGenHolder {
private static final IdGenerator instance = new IdGenerator();
}
public static IdGenerator get(){
return IdGenHolder.instance;
}
public IdGenerator() {
this(0L, 0L);
}
public IdGenerator(long workerId, long datacenterId) {
if (workerId > maxWorkerId || workerId < 0) {
throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
}
if (datacenterId > maxDatacenterId || datacenterId < 0) {
throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
}
this.workerId = workerId;
this.datacenterId = datacenterId;
}
public synchronized String nextId() {
//获取当前毫秒数
long timestamp = timeGen();
//如果服务器时间有问题(时钟后退) 报错。
if (timestamp < lastTimestamp) {
throw new RuntimeException(String.format(
"Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
}
//如果上次生成时间和当前时间相同,在同一毫秒内
if (lastTimestamp == timestamp) {
//sequence自增,因为sequence只有12bit,所以和sequenceMask相与一下,去掉高位
sequence = (sequence + 1) & sequenceMask;
//判断是否溢出,也就是每毫秒内超过4095,当为4096时,与sequenceMask相与,sequence就等于0
if (sequence == 0) {
//自旋等待到下一毫秒
timestamp = tilNextMillis(lastTimestamp);
}
} else {
//如果和上次生成时间不同,重置sequence,就是下一毫秒开始,sequence计数重新从0开始累加
sequence = 0L;
}
lastTimestamp = timestamp;
// 最后按照规则拼出ID。
// 000000000000000000000000000000000000000000 00000 00000 000000000000
// time datacenterId workerId sequence
long idnext= ((timestamp - twepoch) << timestampLeftShift) | (datacenterId << datacenterIdShift)
| (workerId << workerIdShift) | sequence;
return String.valueOf(idnext);
}
protected long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
protected long timeGen() {
return System.currentTimeMillis();
}
}
public class TransSeqGenerator {
private static IdGenerator idGenerator = IdGenerator.get();
public static String getDictTypeId(){
return idGenerator.nextId();
}
}
日期工具类
public class CalendarUtils {
/**
* 获取当前日期字符串
*/
public static String getDate() {
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, 0);
String date = new SimpleDateFormat("yyyyMMdd").format(cal.getTime());
return date;
}
/**
* 获取当前日期字符串
*/
public static String getNDate() {
Calendar cal = Calendar.getInstance();
String date = new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime());
return date;
}
/**
* 获取当前时间字符串
*/
public static String getTime() {
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, 0);
String time = new SimpleDateFormat("HHmmss").format(cal.getTime());
return time;
}
/**
* 获取当前日期+时间
*/
public static String getDateTime() {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, 0);
String dateTime = new SimpleDateFormat("yyyyMMddHHmmss").format(calendar.getTime());
return dateTime;
}
/**
* 获取当前日期时间
*
* @return Date 默认类型 yyyy-MM-dd HH:mm:ss
*/
public static Date getNowDateTime() {
return getNowDateTime("yyyy-MM-dd HH:mm:ss");
}
/**
* 获取当前日期时间
*
* @param format:格式化模板
* @return Date 返回时间类型 yyyy-MM-dd HH:mm:ss
*/
public static Date getNowDateTime(String format) {
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat(format);
String dateString = formatter.format(currentTime);
ParsePosition pos = new ParsePosition(0);
Date currentTimeFormat = formatter.parse(dateString, pos);
return currentTimeFormat;
}
/**
* 将当前时间转换成ISO8601格式
*/
public static String formatNowToISO8601(){
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
Date date = new Date();
return formatter.format(date);
}
/**
* 获取当前时间前5分钟
* @param offset:单位分钟,向前为-,向后为正
* @return
*/
public static String getOffsetBeforeNow(int offset){
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
Calendar beforeTime = Calendar.getInstance();
beforeTime.add(Calendar.MINUTE, offset);// offset分钟之前的时间
Date beforeD = beforeTime.getTime();
String time = sdf.format(beforeD);
return time;
}
/**
* 获取前30天时间系列
*/
public static List getThirtyDate() {
List thirtyMap=new ArrayList() ;
Calendar calc = Calendar.getInstance();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
Date kDate1 = calc.getTime();
String thirtyDateStr1 = formatter.format(kDate1);
thirtyMap.add(thirtyDateStr1);
for (int k = 0; k < 29; k++) {
calc.add(calc.DATE, -1);
Date kDate = calc.getTime();
String thirtyDateStr = formatter.format(kDate);
thirtyMap.add(thirtyDateStr);
}
return thirtyMap;
}
/**
* 获取当前短时间
*
* @return Date:返回当前日期
*/
public static Date getNowDate() {
return getNowDate("yyyy-MM-dd");
}
/**
* 获取当前短时间
*
* @param format:日期格式
* @return Date:返回当前日期
*/
public static Date getNowDate(String format) {
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
String dateString = formatter.format(currentTime);
ParsePosition pos = new ParsePosition(0);
Date currentTimeFormat = formatter.parse(dateString, pos);
return currentTimeFormat;
}
/**
* 日期转字符串
*/
public static String dateToStr(Date date) {
return dateToStr(date, "yyyy-MM-dd");
}
/**
* 日期转字符串
*/
public static String dateToStr(Date date, String format) {
if ((null == date) || StringUtils.isBlank(format)) {
return null;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
return simpleDateFormat.format(date);
}
/**
* 字符串转日期
*
* @param dateStr :传入的日期字符串
*/
public static Date strToDate(String dateStr) throws Exception {
return strToDate(dateStr, "yyyyMMddHHmmss");
}
/**
* 字符串转日期
*
* @param dateStr :传入的日期字符串
* @param format :传入的日期字符串的格式
*/
public static Date strToDate(String dateStr, String format) throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date date = sdf.parse(dateStr);
return date;
}
/**
* 获取上月第一天和最后一天的日期
*
* @param: para=0:返回第一天日期
* @param: para=-1:返回最后一天日期
* @return: 第一天和最后一天的日期
*/
public static Date getLastMonth(int para) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Calendar lastDate = Calendar.getInstance();
lastDate.add(Calendar.MONTH, -1);
lastDate.set(Calendar.DATE, 1);
lastDate.roll(Calendar.DATE, para);
String str = sdf.format(lastDate.getTime());
ParsePosition pos = new ParsePosition(0);
Date currentTimeFormat = sdf.parse(str, pos);
return currentTimeFormat;
}
/**
* 获取上周一和周天的日期
*
* @param: para=1:代表周一
* @param: para=7:代表周天
* @return: 周一和周天的日期
*/
public static Date getLastWeek(int para) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Calendar calendar = Calendar.getInstance();
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
int offset = para - dayOfWeek;
calendar.add(Calendar.DATE, offset - 7);
String lastEndDate = sdf.format(calendar.getTime());
ParsePosition pos = new ParsePosition(0);
Date currentTimeFormat = sdf.parse(lastEndDate, pos);
return currentTimeFormat;
}
/**
* 获取当前时间的上一年的最后一天和第一天日期
* @param
* @return Date
*/
public static Date getLastYear(int para){
Calendar calendar = Calendar.getInstance();
calendar.clear();
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, 0);
String date = new SimpleDateFormat("yyyy").format(cal.getTime());
calendar.set(Calendar.YEAR, Integer.valueOf(date)-1);
calendar.roll(Calendar.DAY_OF_YEAR, para);
Date lastYear = calendar.getTime();
return lastYear;
}
public static List lastWeekEveryday() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar instance = Calendar.getInstance();
// 调整到上周
instance.add(Calendar.WEDNESDAY, -1);
// 调整到上周1
instance.set(Calendar.DAY_OF_WEEK, 2);
List weekDayNum = new ArrayList<>();
for (int i = 1; i <= 7; i++) {
weekDayNum.add(sdf.format(instance.getTime()));
instance.add(Calendar.DAY_OF_WEEK, 1);
}
return weekDayNum;
}
/**
* 根据给定的开始和结束日期,输出中间日期
* @param:
* @param:
* @return:
*/
public static List<String> createDate(String beginTime,String endTime) throws Exception{
DateFormat FORMATTER = new SimpleDateFormat("yyyy-MM-dd");
// String beginTime="2019-04-27";
// String endTime="2019-05-5";
Calendar startDay = Calendar.getInstance();
Calendar endDay = Calendar.getInstance();
startDay.setTime(FORMATTER.parse(beginTime));
endDay.setTime(FORMATTER.parse(endTime));
Calendar currentPrintDay = startDay;
List list = new ArrayList();
while (true) {
list.add(FORMATTER.format(currentPrintDay.getTime()));
// 日期加一
currentPrintDay.add(Calendar.DATE, 1);
// 日期加一后判断是否达到终了日,达到则终止打印
if (currentPrintDay.compareTo(endDay) == 0) {
break;
}
}
list.add(FORMATTER.format(endDay.getTime()));
return list;
}
public static List<String> getTwelveMonth() {
DateFormat FORMATTER = new SimpleDateFormat("yyyy-MM");
List<String> last12Months = new ArrayList<>();
Calendar cal = Calendar.getInstance();
//如果当前日期大于二月份的天数28天或者29天会导致计算月份错误,会多出一个三月份,故设置一个靠前日期解决此问题
cal.set(Calendar.DAY_OF_MONTH, 1);
for (int i = 0; i < 12; i++) {
last12Months.add(FORMATTER.format(cal.getTime()));
//last12Months.add(cal.get(Calendar.YEAR) + "-" + cal.get(Calendar.MONTH) + 1);
cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - 1); //逐次往前推1个月
}
for(String month:last12Months) {
System.out.println(month);
}
return last12Months;
}
/**
* description 校验8位字符串是否为正确的日期格式
* @param str 8位日期字符串
* @return boolean
*/
public static boolean isValidDate(String str) {
boolean result = true;
//判断字符串长度是否为8位
if(str.length() == 8){
SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
try {
// 设置lenient为false.
// 否则SimpleDateFormat会比较宽松地验证日期,比如2007/02/29会被接受,并转换成2007/03/01
format.setLenient(false);
format.parse(str);
} catch (ParseException e) {
// 如果throw java.text.ParseException或者NullPointerException,就说明格式不对
result = false;
} catch (NullPointerException ex){
result = false;
}
}else{
result = false;
}
return result;
}
public static boolean isValidTime(String str){
boolean result = true;
//判断字符串长度是否为6位
if(str.length() == 6){
SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
try {
// 设置lenient为false.
// 否则SimpleDateFormat会比较宽松地验证日期,比如2007/02/29会被接受,并转换成2007/03/01
format.setLenient(false);
format.parse("20190808" + str);
} catch (ParseException e) {
// 如果throw java.text.ParseException或者NullPointerException,就说明格式不对
result = false;
} catch (NullPointerException ex){
result = false;
}
}else{
result = false;
}
return result;
}
public static void main(String[] args) {
/*try {
String date = CalendarUtils.getDate();
System.out.println("======" + date + "==========");
String time = getTime();
System.out.println("=====" + time + "===========");
String dateTime = CalendarUtils.getDateTime();
System.out.println("=====" + dateTime + "===========");
System.out.println(strToDate(dateTime));
System.out.println("===结束==");
Date date1 = new Date();
System.out.println(dateToStr(date1));
Date date2 = getNowDateTime();
System.out.println(date2);
getTwelveMonth();
} catch (Exception e) {
e.printStackTrace();
}*/
String time = CalendarUtils.getOffsetBeforeNow(-5);
System.out.println(time);
}
Bse64工具类
@Slf4j
public class Base64Util {
/**
* base64字符串转换为字节数组
*
* @param base64 base64字符串
* @return 结果
*/
public static byte[] toBytes(String base64) {
return Base64.getDecoder().decode(base64);
}
/**
* 将base64字符串转换为字节数组后写入指定的文件
*
* @param base64 base64字符串
* @param fileName 文件名
* @return 结果
*/
public static File toFile(String base64, String fileName) {
byte[] bytes = toBytes(base64);
File file = new File(fileName);
bytesToFile(bytes, file);
return file;
}
/**
* 将字节数组写入指定的文件中
*
* @param bytes 字节数组
* @param file 文件
*/
private static void bytesToFile(byte[] bytes, File file) {
FileOutputStream out = null;
try {
out = new FileOutputStream(file);
out.write(bytes);
out.flush();
} catch (Exception e) {
log.error("IO异常", e);
} finally {
if (null != out) {
try {
out.close();
} catch (IOException e) {
log.error("关闭流异常", e);
}
}
}
}
/**
* 通过图片的url获取图片的字节数组
*
* @param imgUrl 图片url
* @return 结果
*/
public static byte[] getBytesByImgUrl(String imgUrl) {
byte[] data = new byte[0];
InputStream inputStream = null;
ByteArrayOutputStream outputStream = null;
HttpURLConnection connection = null;
try {
URL url = new URL(imgUrl);
connection = (HttpURLConnection) url.openConnection();
connection.connect();
inputStream = connection.getInputStream();
outputStream = new ByteArrayOutputStream();
//创建一个Buffer字符串
byte[] bytes = new byte[1024];
//每次读取的字符串长度,如果为-1,代表全部读取完毕
int len;
//使用一个输入流从buffer里把数据读取出来
while ((len = (inputStream.read(bytes))) != -1) {
outputStream.write(bytes, 0, len);
}
data = outputStream.toByteArray();
} catch (IOException e) {
log.error("IO异常", e);
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
log.error("关闭流异常", e);
}
}
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
log.error("关闭流异常", e);
}
}
if (connection != null) {
connection.disconnect();
}
}
return data;
}
/**
* 通过图片的url获取图片的base64字符串
*
* @param imgUrl 图片url
* @return 结果
*/
public static String getBase64ByImgUrl(String imgUrl) {
byte[] data = getBytesByImgUrl(imgUrl);
return toBase64(data);
}
/**
* 字节数组转换为base64字符串
*
* @param bytes 字节数组
* @return 结果
*/
public static String toBase64(byte[] bytes) {
return new String(Base64.getEncoder().encode(bytes));
}
/**
* 解密JDK1.8
*/
public static String decodeThrowsException(String str) throws UnsupportedEncodingException {
byte[] decodeBytes = Base64.getDecoder().decode(str.getBytes("utf-8"));
return new String(decodeBytes);
}
/**
* 字符串转md5字符串
*
* @Param string 字符串
* @return 结果
*/
public static String toMd5(String str) throws NoSuchAlgorithmException {
MessageDigest md5 = MessageDigest.getInstance("md5");
byte[] result = md5.digest(str.getBytes());
char[] chars = new char[] { '0', '1', '2', '3', '4', '5', '6', '7' , '8', '9', 'a', 'b', 'c', 'd', 'e','f' };
StringBuffer sb = new StringBuffer();
for (int i = 0; i < result.length; i++) {
// 一个字节对应两个字符
byte x = result[i];
// 取得高位
int h = 0x0f & (x >>> 4);
// 取得低位
int l = 0x0f & x;
sb.append(chars[h]).append(chars[l]);
}
return sb.toString();
}
}
防止通配符
public static String checkString(String str) {
StringBuilder b = new StringBuilder();
b.append(str.trim());
StringBuilder tempBuilder = new StringBuilder();
tempBuilder.append(str.trim());
for (int i = 0, j = 0; i < b.length(); i++) {
char x = b.charAt(i);
if (x == '%' || x == '_') {
tempBuilder.insert(i + j, '\\');
j++;
}
}
str = tempBuilder.toString();
return str;
}
加解密工具类
public class AESEncodeUtil {
private static Logger LOGGER = LoggerFactory.getLogger(AESEncodeUtil.class);
public static final String DefaultKey = "hjzgg1qa2ws3ed!@#$%^";
/**
* @desc 产生随机密钥(这里产生密钥必须是16位)
* @return 返回16位的密钥
*/
public static String generateKey() {
String key = UUID.randomUUID().toString();
key = key.replace("-", "").substring(0, 16);// 替换掉-号
return key;
}
/**
* @desc 将base 64 code AES解密
* @param contentString 待解密的base 64 code
* @param keyString 解密密钥
* @return 解密后的string
* @throws Exception
*/
public static String aesDecrypt(String contentString, String keyString) {
String decryptString = "404";
try {
if (!"".equals(contentString)) {
decryptString = aesDecryptByBytes(base64Decode(contentString), keyString);
}
} catch (Exception e) {
LOGGER.error("解密发生异常:" + e);
if (e instanceof BadPaddingException) {
return "404";
}
}
return decryptString;
}
/**
* @desc AES解密
* @param encryptBytes 待解密的byte[]
* @param decryptKey 解密密钥
* @return 解密后的String
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidKeyException
* @throws BadPaddingException
* @throws IllegalBlockSizeException
* @throws Exception
*/
public static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
random.setSeed(decryptKey.getBytes());
kgen.init(128, random);
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
byte[] decryptBytes = cipher.doFinal(encryptBytes);
return new String(decryptBytes);
}
/**
* @desc base 64 decode
* @param base64Code 待解码的base 64 code
* @return 解码后的byte[]
* @throws IOException
* @throws Exception
*/
@SuppressWarnings("restriction")
public static byte[] base64Decode(String base64Code) throws IOException {
return "".equals(base64Code) ? null : new BASE64Decoder().decodeBuffer(base64Code);
}
/**
* @desc AES加密为base 64 code
* @param contentString 待加密的内容
* @param keyString 加密密钥
* @return 加密后的base 64 code
* @throws UnsupportedEncodingException
* @throws BadPaddingException
* @throws IllegalBlockSizeException
* @throws NoSuchPaddingException
* @throws NoSuchAlgorithmException
* @throws InvalidKeyException
* @throws Exception
*/
public static String aesEncrypt(String contentString, String keyString) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
return base64Encode(aesEncryptToBytes(contentString, keyString));
}
/**
* @desc base 64 encode
* @param bytes 待编码的byte[]
* @return 编码后的base 64 code
*/
@SuppressWarnings("restriction")
public static String base64Encode(Object bytes) {
return new BASE64Encoder().encode((byte[]) bytes);
}
/**
* @desc AES加密
* @param content 待加密的内容
* @param encryptKey 加密密钥
* @return 加密后的byte[]
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidKeyException
* @throws UnsupportedEncodingException
* @throws BadPaddingException
* @throws IllegalBlockSizeException
* @throws Exception
* @throws Exception
*/
public static Object aesEncryptToBytes(String content, String encryptKey) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
random.setSeed(encryptKey.getBytes());
kgen.init(128, random);
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
return cipher.doFinal(content.getBytes("utf-8"));
}
/**
* @desc 结合base64实现md5加密
* @param msg 待加密字符串
* @return 获取md5后转为base64
* @throws NoSuchAlgorithmException
* @throws Exception
*/
public static String md5Encrypt(String msg) throws NoSuchAlgorithmException {
return "".equals(msg) ? null : base64Encode(md5(msg.getBytes()));
}
/**
* @desc 获取byte[]的md5值
* @param bytes byte[]
* @return md5
* @throws NoSuchAlgorithmException
* @throws Exception
*/
public static byte[] md5(byte[] bytes) throws NoSuchAlgorithmException {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(bytes);
return md.digest();
}
public static void main(String[] args) throws Exception {
String content = "wechat2016";// 需要加密的明文
System.out.println("加密前:" + content);
System.out.println("默认的加密密钥和解密密钥:" + DefaultKey);
String encrypt = aesEncrypt(content, DefaultKey);
System.out.println("加密后密文:" + encrypt);
String decrypt = aesDecrypt("5geddJ7Qizcd+o6UKIuMkqGJRfGJpkwOPG2d/c50TXg=", DefaultKey);
System.out.println("解密后明文:" + decrypt);
}
}
自定义异常和Controller层返回
RespDTO
public class RespDTO<T> implements Serializable{
public int code = 0;
public String error = "";
public T data;
public static RespDTO onSuc(Object data) {
RespDTO resp = new RespDTO();
resp.data = data;
return resp;
}
public static RespDTO onSuc() {
RespDTO resp = new RespDTO();
return resp;
}
@Override
public String toString() {
return "RespDTO{" +
"code=" + code +
", error='" + error + '\'' +
", data=" + data +
'}';
}
public void setCode(int code) {
this.code = code;
}
public void setError(String error) {
this.error = error;
}
}
CommonException
public class CommonException extends RuntimeException {
private ErrorCode errorCode;
public CommonException(ErrorCode errorCode) {
super(errorCode.getMsg());
this.errorCode = errorCode;
}
public CommonException(ErrorCode errorCode, String msg) {
super(msg);
this.errorCode = errorCode;
}
public ErrorCode getErrorCode() {
return errorCode;
}
public int getCode() {
return errorCode.getCode();
}
public String getMsg() {
return errorCode.getMsg();
}
}
CommonExceptionHandler
@ControllerAdvice
@ResponseBody
@Slf4j
public class CommonExceptionHandler {
@ExceptionHandler(Exception.class)
public ResponseEntity<RespDTO> handleException(Exception e) {
RespDTO resp = new RespDTO();
if(e instanceof CommonException){
log.error("commonException:====>>>>>"+e.getMessage(),e);
CommonException commonException = (CommonException) e;
resp.code = commonException.getCode();
resp.error = e.getMessage();
return new ResponseEntity(resp, HttpStatus.OK);
}else{
log.error("Exception:=====>>>>>"+e.getMessage(),e);
resp.setCode(-1);
resp.setError("操作失败");
return new ResponseEntity(resp, HttpStatus.OK);
}
}
}
ErrorCode
public enum ErrorCode {
OK(0, "成功"),
FAIL(-1, "操作失败");
private int code;
private String msg;
ErrorCode(int code, String msg) {
this.code = code;
this.msg = msg;
}
public int getCode() {
return code;
}
public String getMsg() {
return msg;
}
public static ErrorCode codeOf(int code) {
for (ErrorCode state : values()) {
if (state.getCode() == code) {
return state;
}
}
return null;
}
}