常用JAVA工具类大全

字符串操作工具类

@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;
    }

}