java ClassUtil 反射工具类

Bertha 。 2023-02-18 01:54 20阅读 0赞

常用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();
            }
        }
    }