在项目使用中，经常使用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〕的小学生 热爱编程，喜欢挑战新事物！

基于 Spring Boot 框架

Maven
<!-- hutool -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.5.1</version>
</dependency>

package com.bood.common.utils;

import cn.hutool.core.convert.Convert;
import com.bood.shimmer.common.utils.StringUtils;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

/**
 * <p>
 * 客户端工具类
 * </p>
 *
 * @author：bood
 * @date：2020/9/23
 */
public class ServletUtils {

    public ServletUtils() {
    }

    /**
     * <p>
     * 获取当前线程 request 对象
     * </p>
     *
     * @return：javax.servlet.http.HttpServletRequest
     * @author：bood
     * @date：2020/9/23
     */
    public static HttpServletRequest getRequest() {
        return new ServletUtils().getCurrentThreadRequest();
    }

    /**
     * <p>
     * 获取当前线程 response 对象
     * </p>
     *
     * @return：javax.servlet.http.HttpServletResponse
     * @author：bood
     * @date：2020/9/23
     */
    public static HttpServletResponse getResponse() {
        return new ServletUtils().getCurrentThreadResponse();
    }

    /**
     * <p>
     * 获取当前线程 session 对象
     * </p>
     *
     * @return：javax.servlet.http.HttpSession
     * @author：bood
     * @date：2020/9/23
     */
    public static HttpSession getSession() {
        return new ServletUtils().getCurrentThreadSession();
    }

    /**
     * 获取String参数
     */
    public static String getParameter(String name) {
        return getRequest().getParameter(name);
    }

    /**
     * 获取String参数
     */
    public static String getParameter(String name, String defaultValue) {
        return Convert.toStr(getRequest().getParameter(name), defaultValue);
    }

    /**
     * 获取Integer参数
     */
    public static Integer getParameterToInt(String name) {
        return Convert.toInt(getRequest().getParameter(name));
    }

    /**
     * 获取Integer参数
     */
    public static Integer getParameterToInt(String name, Integer defaultValue) {
        return Convert.toInt(getRequest().getParameter(name), defaultValue);
    }

    /**
     * <p>
     * 将字符串渲染到客户端
     * </p>
     *
     * @param response: 渲染对象
     * @param string: 待渲染的字符串
     * @return：java.lang.String
     * @author：bood
     * @date：2020/12/2
     */
    public static String renderString(HttpServletResponse response, String string) {
        try {
            response.setStatus(200);
            response.setContentType("application/json");
            response.setCharacterEncoding("utf-8");
            response.getWriter().print(string);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * <p>
     * 是否是 Ajax 异步请求
     * </p>
     *
     * @param request:
     * @return：boolean
     * @author：bood
     * @date：2020/12/2
     */
    public static boolean isAjaxRequest(HttpServletRequest request) {
        String accept = request.getHeader("accept");
        if (accept != null && accept.indexOf("application/json") != -1) {
            return true;
        }

        String xRequestedWith = request.getHeader("X-Requested-With");
        if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1) {
            return true;
        }

        String uri = request.getRequestURI();
        if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml")) {
            return true;
        }

        String ajax = request.getParameter("__ajax");
        if (StringUtils.inStringIgnoreCase(ajax, "json", "xml")) {
            return true;
        }
        return false;
    }

    private HttpServletRequest getCurrentThreadRequest() {
        return getRequestAttributes().getRequest();
    }

    private HttpServletResponse getCurrentThreadResponse() {
        return getRequestAttributes().getResponse();
    }

    private HttpSession getCurrentThreadSession() {
        return getRequestAttributes().getRequest().getSession();
    }

    private static ServletRequestAttributes getRequestAttributes() {
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        return (ServletRequestAttributes) attributes;
    }

}

混〔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〕的小学生 热爱编程，喜欢挑战新事物！  撩撩博主 😃