Java将Map字段名由下划线转驼峰（多层嵌套，递归实现）

前言

最近公司重构项目，由于老项目里面的接口方式是有下划线也有驼峰，但是新接口我们的方式是想统一下划线模式。新接口网关不支持下划线转驼峰，所以需要自己编程将请求参数字段下划线转驼峰。

最终实现的目的是：

{
    
    
	"name": "语音识别",
	"photo_url": "https://www.xxx.cn/edu_ai/3d473f22-53ad-4d2a-beee-30fabab2baca.png",
	"list": [{
    
    
		"id": 111,
		"list_name": "dsadas"
	}],
	"bean": {
    
    
		"id": 111,
		"bean_name": "dsadas"
	},
	"school_ids": [1110000001000000660, 1111111111111111]
}

讲这个json穿转为:

{
    
    
	"photoUrl": "https://bjdownload.cycore.cn/edu_ai/3d473f22-53ad-4d2a-beee-30fabab2baca.png",
	"schoolIds": ["1110000001000000660", "1111111111111111"],
	"name": "语音唤醒",
	"list": [{
    
    
		"id": 111,
		"listName": "dsadas"
	}],
	"bean": {
    
    
		"beanName": "dsadas",
		"id": 111
	}
}

解决方案

废话不多说，直接上代码:

public static Map<String, Object> getUnderToHump(Map<String, Object> map) {
    
    
        if (Objects.isNull(map)) {
    
    
            return map;
        }
        List<Map.Entry<String, Object>> list = map.entrySet().stream().collect(Collectors.toList());
        Map<String, Object> paramMap = new HashMap<>();
        for (Map.Entry<String, Object> entry : list) {
    
    
            if (entry.getKey().indexOf("_") == -1) {
    
    
                Object value = getValue(entry);
                paramMap.put(entry.getKey(), value);
                continue;
            }
            String[] split = entry.getKey().split("_");
            StringBuilder result = new StringBuilder();
            result.append(split[0]);
            for (int i=1;i<split.length;i++) {
    
    
                result.append(split[i].substring(0,1).toUpperCase()).append(split[i].substring(1));
            }
            paramMap.put(result.toString(), getValue(entry));
        }
        return paramMap;
    }

    private static Object getValue(Map.Entry<String, Object> entry) {
    
    
        Object value = entry.getValue();
        if (entry.getValue() instanceof List) {
    
    
            List listValue =(List) entry.getValue();
            List result = new ArrayList();
            for (Object o: listValue) {
    
    
                Object convert = null;
                if (o instanceof Map) {
    
    
                    Map mapList =(Map) o;
                    convert = getUnderToHump(mapList);
                }
                if (o instanceof Long) {
    
    
                    convert = String.valueOf(o);
                }
                result.add(convert);
            }
            value = result;
        }
        if (entry.getValue() instanceof Map) {
    
    
            Map linkedHashMap =(Map) entry.getValue();
            value = getUnderToHump(linkedHashMap);
        }
        if (entry.getValue() instanceof JsonArray) {
    
    
            JsonArray value1 = (JsonArray) entry.getValue();
            JsonArray transValue  = new JsonArray();
            for (JsonElement o:value1) {
    
    
                if (o instanceof JsonObject) {
    
    
                    JsonObject jsonObject =  o.getAsJsonObject();
                    Map underToHump = getUnderToHump(new Gson().fromJson(jsonObject.toString(), Map.class));
                    transValue.add(JsonParser.parseString(new Gson().toJson(underToHump)));
                } else {
    
    
                    transValue.add(o.toString());
                }
            }
            value = transValue;
        }
        if (entry.getValue() instanceof JsonObject) {
    
    
            JsonObject jsonObject  = (JsonObject) entry.getValue();
            value = getUnderToHump( new Gson().fromJson(jsonObject.toString(),Map.class));
        }
        return value;
    }

简单说下吧，其实思路很简单，就是一层一层的看，如果有多层接口，就递归调用getUnderToHump方法讲嵌套的字段给重新修改，最后再组合成新的map的key和value值。