对象反射填充默认值，不支持循环应用设置

在YAPI接口编写测试参数，入参设置默认值，当对象过大时，不想一个一个写，可以自动生成

 

package com.thinkgem.jeesite.test;

import com.alibaba.fastjson.JSON;
import com.suyun.common.result.Result;
import com.suyun.modules.vehicle.dto.InstructionParamDto;
import com.suyun.modules.vehicle.vo.VehDriDataAnalysisVo;
import com.suyun.utils.json.SimpleJsonFormat;
import com.thinkgem.jeesite.conf.TestConfiguration;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {TestConfiguration.class})
public class JSONTest {

    public static void main(String[] args) {
        InstructionParamDto instructionParamDto = new InstructionParamDto();
        initPropertyDefaultValue(instructionParamDto);
        System.out.println(JSON.toJSONString(instructionParamDto));
    }

    private static Object initPropertyDefaultValue(Object obj) {
        Field[] fields = obj.getClass().getDeclaredFields();
        Method[] methods = obj.getClass().getDeclaredMethods();
        Map methodNameMethodMap = new HashMap(methods.length);
        for (Method method : methods) {
            methodNameMethodMap.put(method.getName().toLowerCase(), method);
        }
        for (Field field : fields) {
            Class clazz = field.getType();
            String propertyName = field.getName();
            Method method = methodNameMethodMap.get("set" + propertyName.toLowerCase());
            if (method == null) {
                continue;
            }
            try {
                if (isWrapClass(clazz) || isCommonDataType(clazz)) {
                    if (clazz == Boolean.class || clazz.getName().contains("boolean")) {
                        method.invoke(obj, Boolean.TRUE);
                    } else if (clazz == Byte.class || clazz.getName().contains("byte")) {
                        method.invoke(obj, new Byte("1"));
                    } else if (clazz == Short.class || clazz.getName().contains("short")) {
                        method.invoke(obj, new Short("1"));
                    } else if (clazz == Integer.class || clazz.getName().contains("int")) {
                        method.invoke(obj, 1);
                    } else if (clazz == Long.class || clazz.getName().contains("long")) {
                        method.invoke(obj, 1L);
                    } else if (clazz == Float.class || clazz.getName().contains("float")) {
                        method.invoke(obj, 1F);
                    } else if (clazz == Double.class || clazz.getName().contains("double")) {
                        method.invoke(obj, 1D);
                    } else if (clazz == Character.class || clazz.getName().contains("char")) {
                        method.invoke(obj, '1');
                    }
                } else if (Date.class.isAssignableFrom(clazz)) {
                    method.invoke(obj, new Date());
                } else if (String.class.isAssignableFrom(clazz)) {
                    method.invoke(obj, "测试");
                } else {
                    method.invoke(obj, initPropertyDefaultValue(clazz.newInstance()));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return obj;
    }

    /**
     * 判断是否是基础数据类型，即 int,double,long等类似格式
     */
    public static boolean isCommonDataType(Class clazz) {
        return clazz.isPrimitive();
    }

    /**
     * 判断是否是基础数据类型的包装类型
     *
     * @param clz
     * @return
     */
    public static boolean isWrapClass(Class clz) {
        try {
            return ((Class) clz.getField("TYPE").get(null)).isPrimitive();
        } catch (Exception e) {
            return false;
        }
    }
}