java ClassUtil 反射工具类

常用java反射工具类

ppackage com.gentlesoft.ecm.sys;


import cn.hutool.core.util.ObjectUtil;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.Map;

public class ClassUtils {

    /**
     * 取对象全部属性名
     *
     * @param o 对象
     * @return
     */
    public static String[] getFiledName(Object o) {
        Field[] fields = o.getClass().getDeclaredFields();
        String[] fieldNames = new String[fields.length];
        for (int i = 0; i < fields.length; i++) {
            fieldNames[i] = fields[i].getName();
        }
        return fieldNames;
    }

    /**
     * 根据属性名获取值
     *
     * @param fieldName
     * @param o
     * @return
     */
    public static Object getFieldValueByName(String fieldName, Object o) {
        try {
            String firstLetter = fieldName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetter + fieldName.substring(1);
            Method method = o.getClass().getMethod(getter, new Class[]{});
            Object value = method.invoke(o, new Object[]{});
            return value;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 根据属性名称和对象转化成对应的值
     *
     * @param bean     对象
     * @param property 属性名称
     * @param var      原始值
     * @return
     */
    public static Object convertValueByPropertyAndObjcet(Object bean, String property, Object var) {
        try {
            String value = var.toString();
            Class<?> cls = bean.getClass();
            Field field = cls.getDeclaredField(property);
            String type = field.getType().getSimpleName();
            if (null != type && !"".equals(type) && null != value && !"".equals(value)) {
                if ("String".equals(type)) {
                    return value;
                } else if ("Date".equals(type)) {
                    return parseDate(value);
                } else if ("Integer".equals(type) || "int".equals(type)) {
                    return Integer.parseInt(value);
                } else if ("Long".equalsIgnoreCase(type)) {
                    return Long.parseLong(value);
                } else if ("Double".equalsIgnoreCase(type)) {
                    return Double.parseDouble(value);
                } else if ("Boolean".equalsIgnoreCase(type)) {
                    return Boolean.parseBoolean(value);
                } else {
                    return new NullPointerException("not supper type" + type);
                }
            } else {
                return new NullPointerException("Object does not have this property：" + property);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return e;
        }
    }

    /**
     * 为对象属性赋值
     *
     * @param bean   对象
     * @param valMap map：键—属性名，值-属性值
     */
    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 fieldSetName = parSetName(field.getName());
                if (!valMap.containsKey(field.getName())) {
                    continue;
                }
                if (!checkSetMet(methods, fieldSetName)) {
                    continue;
                }
                Method fieldSetMet = cls.getMethod(fieldSetName, field.getType());
                String value = valMap.get(field.getName());
                if (null != value && !"".equals(value)) {
                    String fieldType = field.getType().getSimpleName();
                    setValue(fieldType, fieldSetMet, bean, value);
                }
            } catch (Exception e) {
                continue;
            }
        }

    }

    /**
     * 根据属性给对象赋值
     *
     * @param bean      对象
     * @param fieldName 属性名
     * @param var       值
     */
    public static void setFieldValueByFieldName(Object bean, String fieldName, Object var) {
        try {
            boolean falg = null != var && !var.equals(null);
            if (falg) {
                Class<?> cls = bean.getClass();
                Field field = cls.getDeclaredField(fieldName);
                Method fieldSetMet = cls.getMethod(parSetName(fieldName), field.getType());
                String fieldType = field.getType().getSimpleName();
                if (null != fieldType && !"".equals(fieldType)) {
                    setValue(fieldType, fieldSetMet, bean, var);
                } else {
                    new NullPointerException("Object does not have this property：" + fieldName);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 格式化string为Date
     *
     * @param datestr
     * @return date
     */
    public static Date parseDate(String datestr) {
        if (null == datestr || "".equals(datestr)) {
            return null;
        }
        try {
            String fmtstr = null;
            if (datestr.indexOf(':') > 0) {
                fmtstr = "yyyy-MM-dd HH:mm:ss";
            } else {
                fmtstr = "yyyy-MM-dd";
            }
            SimpleDateFormat sdf = new SimpleDateFormat(fmtstr, Locale.UK);
            return sdf.parse(datestr);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 日期转化为String
     *
     * @param date
     * @return date string
     */
    public static String fmtDate(Date date) {
        if (null == date) {
            return null;
        }
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US);
            return sdf.format(date);
        } catch (Exception e) {
            return null;
        }
    }

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

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

    /**
     * 拼接某属性的 get方法
     *
     * @param fieldName
     * @return String
     */
    public static String parGetName(String fieldName) {
        if (null == fieldName || "".equals(fieldName)) {
            return null;
        }
        return "get" + fieldName.substring(0, 1).toUpperCase()
                + fieldName.substring(1);
    }

    /**
     * 拼接在某属性的 set方法
     *
     * @param fieldName
     * @return String
     */
    public static String parSetName(String fieldName) {
        if (null == fieldName || "".equals(fieldName)) {
            return null;
        }
        return "set" + fieldName.substring(0, 1).toUpperCase()
                + fieldName.substring(1);
    }

    /**
     * 根据属性字段类型设置属性值
     *
     * @param fieldType
     * @param fieldSetMet
     * @param bean
     * @param var
     */
    public static void setValue(String fieldType, Method fieldSetMet, Object bean, Object var) {
        try {
            switch (fieldType) {
                case "String":
                    fieldSetMet.invoke(bean, var.toString());
                    break;
                case "Date":
                    Date date = parseDate(var.toString());
                    fieldSetMet.invoke(bean, date);
                    break;
                case "Integer":
                    Integer integerval = Integer.parseInt(var.toString());
                    fieldSetMet.invoke(bean, integerval);
                    break;
                case "int":
                    Integer intval = Integer.parseInt(var.toString());
                    fieldSetMet.invoke(bean, intval);
                    break;
                case "Long":
                    Long longval = Long.parseLong(var.toString());
                    fieldSetMet.invoke(bean, longval);
                    break;
                case "Double":
                    Double doubleval = Double.parseDouble(var.toString());
                    fieldSetMet.invoke(bean, doubleval);
                    break;
                case "Boolean":
                    Boolean booleanval = Boolean.parseBoolean(var.toString());
                    fieldSetMet.invoke(bean, booleanval);
                    break;
                case "BigDecimal":
                    BigDecimal decimal = new BigDecimal(var.toString());
                    fieldSetMet.invoke(bean, decimal);
                    break;
                case "Float":
                    Float flolt = Float.parseFloat(var.toString());
                    fieldSetMet.invoke(bean, flolt);
                    break;
                default:
                    new NullPointerException("not supper type" + fieldType);
                    break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}