在项目使用中，经常使用json的反序列化获取某个值，如果某个值的路径比较深，除了编写工作量变大和风险扩大外，还有就是代码不够整洁。抽空写了个根据地址寻址json内容中的某个值的工具类。

说明：

1.工具类使用google Gson,有兴趣的可以使用其他json序列号工具改造。大概流程都一样

     private static final String JSON_ARRAY_FORMAT = "(.)*(\\[(\\d)+])$";

 /**
     * 根据路径获取json对象的值
     * 约定：
     * 路径格式：下层用点代表 数组用[index]代表
     * 举例：
     * a.b[1].c
     * [0].a.c
     * a[1].b
     * a.
     * [0]
     *
     * @param json
     * @param path
     * @return Object 如果获取不到 返回null
     */
    public static <T> T getObjectGson4Path(String json, String path, Class<T> tClass) {
        Gson gson = new Gson();
        JsonElement value4Path = getValue4Path(json, path);
        if (null == value4Path) {
            LOGGER.error("can't find value by path {} ", path);
            return null;
        }
        try {
            return gson.fromJson(value4Path, tClass);
        } catch (JsonSyntaxException e) {
            LOGGER.error("can't find format Type is {} value", tClass.getName());
            return null;
        }
    }

    /**
     * 根据路径获取json对象的值
     * 约定：
     * 路径格式：下层用点代表 数组用[index]代表
     * 举例：
     * a.b[1].c
     * [0].a.c
     * a[1].b
     * a.
     * [0]
     *
     * @param json
     * @param path
     * @return List 如果获取不到 返回null
     */
    public static <T> List<T> getListGson4Path(String json, String path, Class<T> tClass) {
        Gson gson = new Gson();
        JsonElement value4Path = getValue4Path(json, path);
        if (null == value4Path) {
            LOGGER.error("can't find value by path {} ", path);
            return null;
        }
        if (!value4Path.isJsonArray()) {
            throw new IllegalArgumentException("parse format not match");
        }
        JsonArray asJsonArray = value4Path.getAsJsonArray();
        ArrayList<T> objects = new ArrayList<>(asJsonArray.size());
        try {
            for (JsonElement jsonElement : asJsonArray) {
                objects.add(gson.fromJson(value4Path, tClass));
            }
        } catch (JsonSyntaxException e) {
            LOGGER.error("can't find format Type is {} value", tClass.getName());
            return null;
        }
        return objects;
    }


    private static JsonElement getValue4Path(String content, String path) {
        LOGGER.info("content={},path={}", content, path);
        if (StringUtils.isBlank(path)) {
            LOGGER.warn("path is blank");
            return null;
        }
        if (!isJSONStr(content)) {
            LOGGER.warn("content format not json");
            return null;
        }
        JsonParser parser = new JsonParser();
        JsonElement parse = parser.parse(content);
        String[] split = path.split("\\.");
        StringBuilder stringBuilder = new StringBuilder();
        for (String s : split) {
            try {
                parse = parseJson(parse, s, stringBuilder);
            } catch (Exception e) {
                LOGGER.warn("can't find value ,this path is {}", path);
                return null;
            }
        }
        return parse;
    }

    private static JsonElement parseJson(JsonElement jsonElement, String childPath, StringBuilder sb) {
        if (jsonElement.isJsonNull()) {
            return null;
        }
        if (StringUtils.isBlank(childPath)) {
            return jsonElement;
        }
        sb.append(".").append(childPath);
        Matcher matcher = Pattern.compile(JSON_ARRAY_FORMAT).matcher(childPath);
        if (matcher.find()) {
            String group = matcher.group(1);
            if (null == group) {
                group = matcher.group(0);
            }
            String s = group.replaceAll("\\[", "\\\\[");
            String[] split1 = childPath.split(s);
            String key = null;
            if (null == split1 || split1.length == 0) {
                key = "";
            } else {
                key = split1[0];
            }
            String index = group.substring(1, group.length() - 1);
            if (StringUtils.isBlank(key)) {
                if (!jsonElement.isJsonArray()) {
                    LOGGER.warn("can't find value by this childPath,path={}", sb.substring(1));
                    return null;
                }
                JsonArray asJsonArray = jsonElement.getAsJsonArray();
                JsonElement res = asJsonArray.get(Integer.valueOf(index));
                return res;
            } else {
                JsonObject asJsonObject = jsonElement.getAsJsonObject();
                JsonElement res = asJsonObject.get(key);
                return res;
            }
        } else {
            JsonObject asJsonObject = jsonElement.getAsJsonObject();
            JsonElement res = asJsonObject.get(childPath);
            return res;
        }

    }

    public static void main(String[] args) {
        String str12 = "{\"additionJson\":{\"needPush\":true},\"id\":123456,\"date\":\"2013-4-13 12: 36: 54\"}";
        Boolean objectGson4Path12 = getObjectGson4Path(str12, "additionJson.needPush", Boolean.class);
        System.out.println(objectGson4Path12);
    }


 

package com.bood.common.utils;

/**
 * <p>
 * 驼峰与下划线之间互转工具类
 * </p>
 * 
 * @author：bood
 * @date：2020/10/16
 */
public class CamelCaseUtil {

    private static final char SEPARATOR = '_';

    private CamelCaseUtil() {
    }

    /**
     * <p>
     * 转下划线
     * </p>
     *
     * @param s: 
     * @return：java.lang.String
     * @author：bood
     * @date：2020/10/16
     */
    public static String toUnderlineName(String s) {
        if (s == null) {
            return null;
        }

        StringBuilder sb = new StringBuilder();
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            boolean nextUpperCase = true;

            if (i < (s.length() - 1)) {
                nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
            }

            if ((i >= 0) && Character.isUpperCase(c)) {
                if (!upperCase || !nextUpperCase) {
                    if (i > 0) sb.append(SEPARATOR);
                }
                upperCase = true;
            } else {
                upperCase = false;
            }

            sb.append(Character.toLowerCase(c));
        }
        return sb.toString();
    }

    /**
     * <p>
     * 转驼峰
     * </p>
     *
     * @param s: 
     * @return：java.lang.String
     * @author：bood
     * @date：2020/10/16
     */
    public static String toCamelCase(String s) {
        if (s == null) {
            return null;
        }
        s = s.toLowerCase();
        StringBuilder sb = new StringBuilder(s.length());
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == SEPARATOR) {
                upperCase = true;
            } else if (upperCase) {
                sb.append(Character.toUpperCase(c));
                upperCase = false;
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * <p>
     * 转大写驼峰
     * </p>
     *
     * @param s: 
     * @return：java.lang.String
     * @author：bood
     * @date：2020/10/16
     */
    public static String toCapitalizeCamelCase(String s) {
        if (s == null) {
            return null;
        }
        s = toCamelCase(s);
        return s.substring(0, 1).toUpperCase() + s.substring(1);
    }

}



混〔IT〕的小学生 热爱编程，喜欢挑战新事物！

package com.bood.common.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * <p>
 * Date 时间工具类
 * </p>
 *
 * @author：bood
 * @date：2020/10/16
 */
public class DateUtils {

    private final static SimpleDateFormat sdfYear = new SimpleDateFormat("yyyy");

    private final static SimpleDateFormat sdfDay = new SimpleDateFormat("yyyy-MM-dd");

    private final static SimpleDateFormat sdfDays = new SimpleDateFormat("yyyyMMdd");

    private final static SimpleDateFormat sdfTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    private final static SimpleDateFormat sdfTimeString = new SimpleDateFormat("yyyyMMddHHmmss");

    public DateUtils() {
    }
    
    /**
     * 获取 YYYY 格式
     *
     * @return yyyy
     */
    public static String getYear() {
        return sdfYear.format(new Date());
    }

    /**
     * 获取 YYYY-MM-DD 格式
     *
     * @return YYYY-MM-DD
     */
    public static String getDay() {
        return sdfDay.format(new Date());
    }

    /**
     * 获取 YYYYMMDD 格式
     *
     * @return YYYYMMDD
     */
    public static String getDays() {
        return sdfDays.format(new Date());
    }

    /**
     * 获取 YYYY-MM-DD HH:mm:ss 格式
     *
     * @return YYYY-MM-DD HH:mm:ss
     */
    public static String getTime() {
        return sdfTime.format(new Date());
    }

    /**
     * 获取 YYYYMMDDHHmmss 格式
     *
     * @return YYYYMMDDHHmmss
     */
    public static String getTimeString() {
        return sdfTimeString.format(new Date());
    }

    /**
     * <p>
     * 日期比较，如果s > = e 返回 true 否则返回 false
     * </p>
     *
     * @param s:
     * @param e:
     * @return：boolean
     * @author：bood
     * @date：2020/10/16
     */
    public static boolean compareDate(String s, String e) {
        if (fomatDate(s) == null || fomatDate(e) == null) {
            return false;
        }
        return fomatDate(s).getTime() >= fomatDate(e).getTime();
    }

    /**
     * <p>
     * 格式化日期
     * </p>
     *
     * @param date:
     * @return：java.util.Date
     * @author：bood
     * @date：2020/10/16
     */
    public static Date fomatDate(String date) {
        DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
        try {
            return fmt.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * <p>
     * 校验日期是否合法
     * </p>
     *
     * @param s:
     * @return：boolean
     * @author：bood
     * @date：2020/10/16
     */
    public static boolean isValidDate(String s) {
        DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
        try {
            fmt.parse(s);
            return true;
        } catch (Exception e) {
            // 如果 throw java.text.ParseException 或者 NullPointerException，就说明格式不对
            return false;
        }
    }

    /**
     * <p>
     * 时间相减得到年数
     * </p>
     *
     * @param startTime:
     * @param endTime:
     * @return：int
     * @author：bood
     * @date：2020/10/16
     */
    public static int getDiffYear(String startTime, String endTime) {
        DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
        try {
            int years = (int) (((fmt.parse(endTime).getTime() - fmt.parse(startTime).getTime()) / (1000 * 60 * 60 * 24)) / 365);
            return years;
        } catch (Exception e) {
            // 如果 throw java.text.ParseException 或者 NullPointerException，就说明格式不对
            return 0;
        }
    }

    /**
     * <p>
     * 时间相减得到天数
     * </p>
     *
     * @param beginDateStr:
     * @param endDateStr:
     * @return：long
     * @author：bood
     * @date：2020/10/16
     */
    public static long getDaySub(String beginDateStr, String endDateStr) {
        long day = 0;
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date beginDate = null;
        Date endDate = null;

        try {
            beginDate = format.parse(beginDateStr);
            endDate = format.parse(endDateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        day = (endDate.getTime() - beginDate.getTime()) / (24 * 60 * 60 * 1000);
        // System.out.println("相隔的天数="+day);
        return day;
    }

    /**
     * <p>
     * 得到 n 天之后的日期
     * </p>
     *
     * @param days:
     * @return：java.lang.String
     * @author：bood
     * @date：2020/10/16
     */
    public static String getAfterDayDate(String days) {
        int daysInt = Integer.parseInt(days);
        // java.util包
        Calendar canlendar = Calendar.getInstance();
        // 日期减 如果不够减会将月变动
        canlendar.add(Calendar.DATE, daysInt);
        Date date = canlendar.getTime();

        SimpleDateFormat sdfd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = sdfd.format(date);

        return dateStr;
    }

    /**
     * 得到n天之后是周几
     *
     * @param days
     * @return
     */
    public static String getAfterDayWeek(String days) {
        int daysInt = Integer.parseInt(days);
        // java.util包
        Calendar canlendar = Calendar.getInstance();
        // 日期相减，如果不够减会将月变动
        canlendar.add(Calendar.DATE, daysInt);
        Date date = canlendar.getTime();

        SimpleDateFormat sdf = new SimpleDateFormat("E");
        String dateStr = sdf.format(date);

        return dateStr;
    }

    /**
     * <p>
     * 获得当前时间之前或之后几个月的日期
     * </p>
     *
     * @param amount: 值可正可负，负<==>before 正<==>after
     * @return：java.lang.String yyyy-MM-dd HH:mm:ss
     * @author：bood
     * @date：2020/10/16
     */
    public static String getAfterMonthDate(Integer amount) {
        //获取当前时间
        Date nowDate = new Date();
        //获取日历类实例
        Calendar cl = Calendar.getInstance();
        //设置当前时间
        cl.setTime(nowDate);
        cl.add(Calendar.MONTH, amount);
        return sdfTime.format(cl.getTime());
    }

    /**
     * <p>
     * 获得当前时间之前或之后几年的日期
     * </p>
     *
     * @param amount: 值可正可负，负<==>before 正<==>after
     * @return：java.lang.String yyyy-MM-dd HH:mm:ss
     * @author：bood
     * @date：2020/10/16
     */
    public static String getAfterYearDate(Integer amount) {
        //获取当前时间
        Date nowDate = new Date();
        //获取日历类实例
        Calendar cl = Calendar.getInstance();
        //设置当前时间
        cl.setTime(nowDate);
        cl.add(Calendar.YEAR, amount);
        return sdfTime.format(cl.getTime());
    }

}

混〔IT〕的小学生 热爱编程，喜欢挑战新事物！  撩撩博主 😃 

package com.bood.common.utils;

import javax.imageio.ImageIO;
import javax.imageio.stream.ImageOutputStream;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.*;
import java.text.DecimalFormat;

/**
 * <p>
 * 图像处理工具类（本类完全可以使用，但是更加推荐ImageMagick +Jmagick </br>
 * 采用C++实现的一个类库，提供了Java的Api，非常强大和高效）</br>
 * 而且要为JVM分配较大的堆内存，否则内存溢出 </br>
 * </p>
 *
 * @author：bood
 * @date：2020/10/16
 */
public class ImageUtils {

    public ImageUtils() {
    }

    /**
     * 缩放图片
     *
     * @param src   源文件
     * @param dest  目标文件
     * @param ratio 缩放比例，如 0.1,0.8,1.2,2.4
     * @throws IOException
     */
    public static void zoom(String src, String dest, double ratio) throws IOException {
        // 获取文件扩展名
        String suffix = src.substring(src.lastIndexOf(".") + 1);
        // 读入文件
        BufferedImage bi = ImageIO.read(new File(src));
        // 计算目标文件宽度
        int targetWidth = Integer.parseInt(new DecimalFormat("0").format(bi.getWidth() * ratio));
        // 计算目标文件高度
        int targetHeight = Integer.parseInt(new DecimalFormat("0").format(bi.getHeight() * ratio));
        // 获取BufferedImage读入的图片的一个缩放的版本
        Image image = bi.getScaledInstance(targetWidth, targetHeight, Image.SCALE_DEFAULT);
        // 创建一张空白的缓存图片
        BufferedImage target = new BufferedImage(targetWidth, targetHeight, BufferedImage.TYPE_INT_RGB);
        // 返回一张2D图像
        Graphics g = target.createGraphics();
        // 将BufferedImage读入的图片画到上一步创建的对象上
        g.drawImage(image, 0, 0, null);
        // 释放
        g.dispose();
        // 图像写入文件
        ImageIO.write(target, suffix, new File(dest));
    }

    /**
     * 切图
     *
     * @param src    源文件
     * @param dest   目标文件
     * @param startX 起点x坐标
     * @param startY 起点y坐标
     * @param endX   结束点x坐标
     * @param endY   结束点y坐标
     * @throws IOException
     */
    public static void cut(String src, String dest, int startX, int startY, int endX, int endY) throws IOException {
        // 获取文件扩展名
        String suffix = src.substring(src.lastIndexOf(".") + 1);
        // 读入文件
        BufferedImage bi = ImageIO.read(new File(src));
        // 计算宽度
        int width = Math.abs(startX - endX);
        // 计算高度
        int height = Math.abs(startY - endY);
        BufferedImage target = bi.getSubimage(startX, startY, width, height);
        ImageIO.write(target, suffix, new File(dest));
    }

    /**
     * 旋转图片
     *
     * @param src     源文件
     * @param dest    目标文件
     * @param degree  旋转角度
     * @param bgcolor 背景色，无背景色为null
     * @throws IOException
     */
    public static void rotate(String src, String dest, int degree, Color bgcolor) throws IOException {
        BufferedImage image = ImageIO.read(new File(src));
        // 原始图象的宽度
        int iw = image.getWidth();
        // 原始图象的高度
        int ih = image.getHeight();
        int w = 0;
        int h = 0;
        int x = 0;
        int y = 0;
        degree = degree % 360;
        if (degree < 0) {
            // 将角度转换到0-360度之间
            degree = 360 + degree;
        }
        // 将角度转为弧度
        double ang = Math.toRadians(degree);

        /**
         * 确定旋转后的图象的高度和宽度
         */
        if (degree == 180 || degree == 0 || degree == 360) {
            w = iw;
            h = ih;
        } else if (degree == 90 || degree == 270) {
            w = ih;
            h = iw;
        } else {
            double cosVal = Math.abs(Math.cos(ang));
            double sinVal = Math.abs(Math.sin(ang));
            w = (int) (sinVal * ih) + (int) (cosVal * iw);
            h = (int) (sinVal * iw) + (int) (cosVal * ih);
        }
        // 确定原点坐标
        x = (w / 2) - (iw / 2);
        y = (h / 2) - (ih / 2);
        BufferedImage rotatedImage = new BufferedImage(w, h, image.getType());
        Graphics2D gs = (Graphics2D) rotatedImage.getGraphics();
        if (bgcolor == null) {
            rotatedImage = gs.getDeviceConfiguration().createCompatibleImage(w, h, Transparency.TRANSLUCENT);
        } else {
            gs.setColor(bgcolor);
            // 以给定颜色绘制旋转后图片的背景
            gs.fillRect(0, 0, w, h);
        }

        AffineTransform at = new AffineTransform();
        // 旋转图象
        at.rotate(ang, w / 2, h / 2);
        at.translate(x, y);
        AffineTransformOp op = new AffineTransformOp(at,
                AffineTransformOp.TYPE_BICUBIC);
        op.filter(image, rotatedImage);
        image = rotatedImage;

        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ImageOutputStream iamgeOut = ImageIO.createImageOutputStream(byteOut);

        ImageIO.write(image, "png", iamgeOut);
        InputStream is = new ByteArrayInputStream(byteOut.toByteArray());

        OutputStream os = new FileOutputStream(new File(dest));

        byte[] buffer = new byte[1024];
        int length = 0;
        while ((length = is.read(buffer)) > 0) {
            os.write(buffer, 0, length);
        }
        os.close();
        is.close();
        byteOut.close();
    }

}

混〔IT〕的小学生 热爱编程，喜欢挑战新事物！  撩撩博主 😃