Java基于内省的反射工具类

PropertyDescriptor 要求必须拥有对应属性的getter setter 方法,所以不适用于枚举, 下面上代码

import cn.hutool.core.date.DateUtil;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import lombok.extern.slf4j.Slf4j;

/**
 * @author ZJ.Fang
 */
@Slf4j
public class ReflectUtil {

    /**
     * 获取field的泛型类型.返回泛型对应的运行时类Class
     *
     */
    public static Class<?> getActualTypeArgument(Field field) {
        Class<?> cls = null;

        if (field != null) {
            ParameterizedType type = (ParameterizedType) field.getGenericType();
            Type actualTypeArgument = type.getActualTypeArguments()[0];
            cls = (Class<?>) actualTypeArgument;
        }
        return cls;
    }

    /**
     * 获取运行时类的简单类名
     *
     */
    public static String getSimpleClassName(Class<?> clazz) {
        String className = "";
        if (clazz != null) {
            className = clazz.getSimpleName();
        }
        return className;

    }

    /**
     * 取Bean的属性和值对应关系的MAP
     *
     */
    public static Map<String, String> getFieldValueMap(Object bean) {
        Class<?> cls = bean.getClass();
        Map<String, String> valueMap = new HashMap<>();
        Method[] methods = cls.getDeclaredMethods();
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            try {
                String fieldType = field.getType().getSimpleName();
                Object fieldVal = parGetMethodToObj(bean, field.getName());
                String result = null;
                if ("Date".equals(fieldType)) {
                    result = DateUtil.format((Date) fieldVal, "yyyy-MM-dd HH:mm:ss");
                } else {
                    if (null != fieldVal) {
                        result = String.valueOf(fieldVal);
                    }
                }
                valueMap.put(field.getName(), result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return valueMap;
    }

    /**
     * set属性的值到Bean
     *
     */
    public static void setFieldValue(Object bean, Map<String, String> valMap) {
        Class<?> cls = bean.getClass();
        // 取出bean里的所有方法
        Method[] methods = cls.getDeclaredMethods();
        Field[] fields = cls.getDeclaredFields();

        for (Field field : fields) {
            try {
                String fieldKeyName = field.getName();
                String value = valMap.get(fieldKeyName);

                if (StringUtils.isNotBlank(value)) {
                    String fieldType = field.getType().getSimpleName();

                    Object fieldValue = null;
                    if ("Date".equals(fieldType)) {
                        fieldValue = DateUtil.parse(value);
                    } else if ("Integer".equals(fieldType) || "int".equals(fieldType)) {
                        fieldValue = Integer.parseInt(value);
                    } else if ("Long".equalsIgnoreCase(fieldType)) {
                        fieldValue = Long.parseLong(value);
                    } else if ("Double".equalsIgnoreCase(fieldType)) {
                        fieldValue = Double.parseDouble(value);
                    } else if ("Boolean".equalsIgnoreCase(fieldType)) {
                        fieldValue = Boolean.parseBoolean(value);
                    } else {
                        System.out.println("not supper type" + fieldType);
                    }

                    parSetMethod(bean, fieldKeyName, fieldValue);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 判断是否存在某属性的 set方法
     *
     */
    public static boolean checkSetMet(Method[] methods, String fieldSetMet) {
        for (Method met : methods) {
            if (fieldSetMet.equals(met.getName())) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断是否存在某属性的 get方法
     *
     */
    public static boolean checkGetMet(Method[] methods, String fieldGetMet) {
        for (Method met : methods) {
            if (fieldGetMet.equals(met.getName())) {
                return true;
            }
        }
        return false;
    }

    /**
     * 拼接某属性的 get方法
     *
     */
    public static String parGetName(String fieldName) {
        if (StringUtils.isNotBlank(fieldName)) {

            int startIndex = 0;
            if (fieldName.charAt(0) == '_') {
                startIndex = 1;
            }
            return "get" + fieldName.substring(startIndex, startIndex + 1).toUpperCase() + fieldName.substring(startIndex + 1);
        }
        return null;
    }

    /**
     * 获取对应属性的get方法
     *
     */
    public static Method achieveGetter(String fieldName, Object obj) {
        PropertyDescriptor descriptor;
        Method method = null;
        try {
            descriptor = new PropertyDescriptor(fieldName, obj.getClass());
            method = descriptor.getReadMethod();
        } catch (IntrospectionException e) {
            e.printStackTrace();
        }
        return method;

    }

    /**
     * 拼接在某属性的 set方法
     *
     */
    public static String parSetName(String fieldName) {
        if (StringUtils.isNotBlank(fieldName)) {

            int startIndex = 0;
            if (fieldName.charAt(0) == '_') {
                startIndex = 1;
            }
            return "set" + fieldName.substring(startIndex, startIndex + 1).toUpperCase() + fieldName.substring(startIndex + 1);
        }
        return null;
    }

    /**
     * 获取存储的键名称（调用parGetName）
     *
     * @return 去掉开头的get或set
     */
    public static String parKeyName(String fieldName) {
        String fieldGetName = parGetName(fieldName);
        if (StringUtils.isNotBlank(fieldGetName) && fieldGetName.length() > 3) {
            return fieldGetName.substring(3);
        }
        return fieldGetName;
    }

    /**
     * 调用对象属性的get方法,返回String
     *
     */
    public static String parGetMethodToStr(Object obj, String fieldName) {
        String value = "";
        try {
            Method getMethod = achieveGetter(fieldName, obj);
            Object objVal = getMethod.invoke(obj);
            if (objVal != null) {
                value = objVal.toString();
            }
        } catch (IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }

        return value;
    }

    /**
     * 调用对象属性的get方法,返回Object
     *
     */
    public static Object parGetMethodToObj(Object obj, String fieldName) {
        PropertyDescriptor descriptor;
        Object resultObj = null;
        try {
            descriptor = new PropertyDescriptor(fieldName, obj.getClass());
            Method method = descriptor.getReadMethod();
            resultObj = method.invoke(obj);
        } catch (IllegalAccessException | IntrospectionException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return resultObj;
    }

    /**
     * 调用对象属性的set方法
     *
     */
    public static void parSetMethod(Object obj, String fieldName, Object param) {
        try {
            PropertyDescriptor propertyDescriptor = new PropertyDescriptor(fieldName, obj.getClass());
            Method method = propertyDescriptor.getWriteMethod();
            log.info("调用方法>>>>>>>{}", method.getName());
            method.invoke(obj, param);
        } catch (IntrospectionException e) {
            log.error("对象可能不存在该方法,请检查...");
            e.printStackTrace();
        } catch (IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}