Java工具：自定義註解實體與json相互轉換

package com.zycfc.mpc.process.util;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.assertj.core.util.Lists;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Maps;
import lombok.Data;
import lombok.Data;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor //無參構造
@AllArgsConstructor //全參構造
public class Student{
	@ChanFld(name = "stu_name")
	public String name;
	@ChanFld(name = "stu_boolean")
	public boolean b;
	@ChanFld(name = "stu_age")
	public String age;
	@ChanFld(name = "stu_list")
	public List<Master> masList;
	@ChanFld(name = "stu_tea")
	public Teacher tea = new Teacher();
	@ChanFld(name = "stu_map")
	public Map<String, Head> mapH;
	public static void main(String[] args) throws Exception {
		//根據對象中註解轉化不同的json字符串	
		Student stu = Student.builder().name("xiaoming").age("18").build();
		String jsonStr=JSON.toJSONString(returnJsonString(stu));

	}
	// 根據註解對象轉json
	public static Map returnJsonString(Object obj) throws IllegalArgumentException, IllegalAccessException {
		HashMap<Object, Object> map = Maps.newHashMap();
		Field[] fields = obj.getClass().getFields();
		for (Field field : fields) {
			ChanFld chanFld = field.getDeclaredAnnotation(ChanFld.class);
			if (chanFld != null) {
				Class<?> type = field.getType();
				// 如果是基礎數據類型
				if (type == String.class || type == Boolean.class || type == BigDecimal.class
						|| type == boolean.class) {
					map.put(chanFld.name(), field.get(obj));
					continue;
				}
				// 如果是list
				if (type == List.class) {
					List<Object> list = (List<Object>) field.get(obj);
					List<Map> listMap = Lists.newArrayList();
					for (Object object : list) {
						listMap.add(returnJsonString(object));
					}
					map.put(chanFld.name(), listMap);
					continue;
				}
				// 如果是map
				if (type == Map.class) {
					Map mapKey = Maps.newHashMap();
					Map mapTemp = (Map) field.get(obj);
					Set keySet = mapTemp.keySet();
					for (Object key : keySet) {
						Object object = mapTemp.get(key);
						Map returnJsonString = returnJsonString(object);
						mapKey.put(key, returnJsonString);
					}
					map.put(chanFld.name(), mapKey);
					continue;
				}
				// 如果是對象類型
				map.put(chanFld.name(), returnJsonString(field.get(obj)));
			}
		}
		return map;
	}
	// 根據對應註解json轉回對象
	public static Object returnObject(String jsonString, Object obj) throws Exception {
		// Map parseObject = JSON.parseObject(jsonString,Map.class);
		JSONObject parseObject = JSON.parseObject(jsonString);
		Field[] fields = getAllFields(obj.getClass());
		for (Field field : fields) {
			ChanFld chanFld = field.getDeclaredAnnotation(ChanFld.class);
			if (chanFld != null) {
				Class<?> type = field.getType();
				// 如果是基礎數據類型
				if (type == String.class || type == Boolean.class || type == BigDecimal.class
						|| type == boolean.class) {
					field.set(obj, parseObject.get(chanFld.name()));
					continue;
				}
				// 如果是list
				if (type == List.class) {
					JSONArray jsonArray = parseObject.getJSONArray(chanFld.name());
					Type genericType = field.getGenericType();
					if (genericType == null)
						continue;
					// 如果是泛型參數的類型
					if (genericType instanceof ParameterizedType) {
						ParameterizedType pt = (ParameterizedType) genericType;
						// 得到泛型裏的class類型對象
						Class<?> accountPrincipalApproveClazz = (Class<?>) pt.getActualTypeArguments()[0];
						Object accountPrincipalApprove = accountPrincipalApproveClazz.newInstance();
						List<Object> objList = Lists.newArrayList();
						for (Object object : jsonArray) {
							Object returnObject = returnObject(object.toString(), accountPrincipalApprove);
							objList.add(returnObject);
						}
						field.set(obj, objList);
						continue;
					}
				}
				// 如果是map
				if (type == Map.class) {
					Type genericType = field.getGenericType();
					if (genericType == null)
						continue;
					// 如果是泛型參數的類型
					if (genericType instanceof ParameterizedType) {
						ParameterizedType pt = (ParameterizedType) genericType;
						// 得到泛型裏的class類型對象
						Class<?> accountPrincipalApproveClazz = (Class<?>) pt.getActualTypeArguments()[1];
						Object accountPrincipalApprove = accountPrincipalApproveClazz.newInstance();
						Map mapFinal = new HashMap();
						Map map = (Map) parseObject.get(chanFld.name());
						Set keySet = map.keySet();
						for (Object key : keySet) {
							mapFinal.put(key,
									returnObject(map.get(key).toString(), accountPrincipalApprove));
						}
						field.set(obj, mapFinal);
					}
					continue;
				}
				// 如果是對象類型
				Object object = parseObject.get(chanFld.name());
				Class<?> b = (Class<?>) field.getGenericType();
				Object returnObject = returnObject(parseObject.get(chanFld.name()).toString(), b.newInstance());
				field.set(obj, returnObject);
			}
		}
		return obj;
	}
	 public static Field[] getAllFields(Class clazz) {
	        List<Field> fieldList = Lists.newArrayList();
	        while (clazz != null) {
	            fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
	            clazz = clazz.getSuperclass();
	        }
	        Field[] fields = new Field[fieldList.size()];
	        fieldList.toArray(fields);
	        return fields;
	    }
}