springboot返回JSON结果下划线

返回json对象需要是下划线来区分前后端

一共两个类

过滤或者包含类

package com.xxx.utils.json;

import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.BeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.FilterProvider;
import com.fasterxml.jackson.databind.ser.PropertyFilter;
import com.fasterxml.jackson.databind.ser.PropertyWriter;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;

import java.util.*;

import com.fasterxml.jackson.databind.ser.BeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.FilterProvider;
import com.fasterxml.jackson.databind.ser.PropertyWriter;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.std.BeanSerializerBase;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.io.IOException;
import java.util.*;

@JsonFilter("JacksonFilter")
public class JacksonJsonFilter extends FilterProvider {

    private final Map<Class<?>, Set<String>> includeMap = new HashMap<>();
    private final Map<Class<?>, Set<String>> filterMap = new HashMap<>();

    public void include(Class<?> type, String[] fields) {
        addToMap(includeMap, type, fields);
    }

    public void filter(Class<?> type, String[] fields) {
        addToMap(filterMap, type, fields);
    }

    private void addToMap(Map<Class<?>, Set<String>> map, Class<?> type, String[] fields) {
        if (fields != null && fields.length > 0) {
            Set<String> fieldSet = map.computeIfAbsent(type, k -> new HashSet<>());
            fieldSet.addAll(Arrays.asList(fields));
        }
    }

    @Override
    public BeanPropertyFilter findFilter(Object filterId) {
        throw new UnsupportedOperationException("Access to deprecated filters not supported");
    }

    @Override
    public PropertyFilter findPropertyFilter(Object filterId, Object valueToFilter) {
        return new SimpleBeanPropertyFilter() {
            @Override
            public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider prov, PropertyWriter writer)
                    throws Exception {
                if (apply(pojo.getClass(), writer.getName())) {
                    writer.serializeAsField(pojo, jgen, prov);
                } else if (!jgen.canOmitFields()) {
                    writer.serializeAsOmittedField(pojo, jgen, prov);
                }
            }
        };
    }

    public boolean apply(Class<?> type, String name) {
        Set<String> includeFields = includeMap.get(type);
        Set<String> filterFields = filterMap.get(type);

        return (includeFields == null || includeFields.contains(name)) &&
                (filterFields == null || !filterFields.contains(name));
    }
}

实际使用工具类

package com.xxx.utils.json;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import java.io.*;
import java.util.Set;

/**
* JSON的驼峰和下划线互转帮助类
 * @author yql
 */

public class JsonUtils {

	private static final char UNDERLINE = '_';

	/**
	 *
	 * @param clazz  需求处理字段的源class对象
	 * @param object 最后返回的结果
	 * @param array 需要过滤/包含的字段名称
	 * @param useInclude true是包含,false是过滤
	 * @param <T>
	 * @return
	 * @throws JsonProcessingException
	 */
	public static <T> Object toUnderlineJsonString(Class<T> clazz, Object object, String[] array, boolean useInclude)  {
		ObjectMapper mapper = new ObjectMapper();
		mapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
			@Override
			public void serialize(Object arg0, JsonGenerator arg1, SerializerProvider arg2) throws IOException, JsonProcessingException {
				arg1.writeString("");
			}
		});
		JacksonJsonFilter jacksonFilter = new JacksonJsonFilter();
		if (useInclude) {
			jacksonFilter.include(clazz, array);
		} else {
			jacksonFilter.filter(clazz, array);
		}
		mapper.setFilterProvider(jacksonFilter);
		mapper.addMixIn(clazz, jacksonFilter.getClass());
		String json = null;
		try {
			json = mapper.writeValueAsString(object);
		} catch (JsonProcessingException e) {
			e.printStackTrace();
			throw new RuntimeException("返回结果转换异常");
		}
		return convert(json);
	}

	private static void convert(Object json) {
		if (json instanceof JSONArray) {
			JSONArray arr = (JSONArray) json;
			for (Object obj : arr) {
				convert(obj);
			}
		} else if (json instanceof JSONObject) {
			JSONObject jo = (JSONObject) json;
			Set<String> keys = jo.keySet();
			String[] array = keys.toArray(new String[keys.size()]);
			for (String key : array) {
				Object value = jo.get(key);
				jo.remove(key);
				jo.put(camelToUnderline(key), value);
				convert(value);
			}
		}
	}

	private static Object convert(String json) {
		Object obj = JSON.parse(json);
		convert(obj);
		return obj;
	}

	private static String camelToUnderline(String param) {
		if (param == null || param.trim().isEmpty()) {
			return "";
		}
		int len = param.length();
		StringBuilder sb = new StringBuilder(len);
		for (int i = 0; i < len; i++) {
			char c = param.charAt(i);
			if (Character.isUpperCase(c)) {
				sb.append(UNDERLINE);
				sb.append(Character.toLowerCase(c));
			} else {
				sb.append(c);
			}
		}
		return sb.toString();
	}

	public static boolean isJson(String content) {
		try {
			JSONObject.parse(content);
			return true;
		} catch (Exception e) {
			return false;
		}
	}

	public static String readFile(String path) {
		String lastStr = "";
		BufferedReader reader = null;
		try {
			Resource resource = new ClassPathResource(path);
			File file = resource.getFile();
			FileInputStream in = new FileInputStream(file);
			reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
			String tempString = null;
			while ((tempString = reader.readLine()) != null) {
				lastStr = lastStr + tempString;
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e1) {
				}
			}
		}
		return lastStr;
	}

	public static JSONArray getJsonArray(String path) {
		JSONArray jsonArray = new JSONArray();
		try {
			ClassPathResource classPathResource = new ClassPathResource(path);
			BufferedReader reader = new BufferedReader(new InputStreamReader(classPathResource.getInputStream(), "utf-8"));
			String line = null;
			String message = new String();
			while ((line = reader.readLine()) != null) {
				message += line;
			}
			jsonArray = (JSONArray) JSONArray.parse(message);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return jsonArray;
	}

	public static JSONObject getJsonObject(String path) {
		JSONObject jsonObject = new JSONObject();
		try {
			ClassPathResource classPathResource = new ClassPathResource(path);
			BufferedReader reader = new BufferedReader(new InputStreamReader(classPathResource.getInputStream(), "utf-8"));
			String line = null;
			String message = new String();
			while ((line = reader.readLine()) != null) {
				message += line;
			}
			jsonObject = (JSONObject) JSONObject.parse(message);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return jsonObject;
	}
}

具体使用案例

        List<User > list=new ArrayList<>();
        User d1=new User ();
        d1.setUserId("1");
        list.add(d1);
		// 只返回userId       
		Object s1 = JsonUtils.toUnderlineJsonString(User.class, list, new String[]{"userId"}, true);
		// 返回除了userId以外的所有字段
        Object s2 = JsonUtils.toUnderlineJsonString(User.class, list, new String[]{"userId"}, false);
        System.out.println(s1);
        System.out.println(s2);