java 反射工具类

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

@Slf4j
public final class ReflectUtils {

    /**
     * 复制相同的属性
     * @param src
     * @param result
     * @return
     */
    public static Object copePropreties(Object src, Object result) {
        if (null == src || null == result) {
            return null;
        }
        Map<String, Object> map = beanToMap(src);
        if (null != map && map.size() > 0) {
            for (String key : map.keySet()) {
                ReflectUtils.setFieldValue(result, key, map.get(key));
            }
        }
        return src;
    }

    /**
     * 将实体类转换成HashMap<属性名，属性值>
     *
     * @param obj
     * @return
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     */
    public static Map<String, Object> beanToMap(Object obj) {
        if (null == obj) {
            return null;
        }
        Map<String, Object> map = null;
        Field[] list = null;
        Class<?> clazz = obj.getClass();
        map = new HashMap<>();
        try {
            for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
                list = clazz.getDeclaredFields();
                if (null != list && list.length > 0) {
                    for (Field field : list) {
                        if (null == field) {
                            continue;
                        }
                        field.setAccessible(true);
                        map.put(field.getName(), field.get(obj));
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        list = null;
        map.remove("serialVersionUID");
        return map;
    }

    /**
     * 获取类为Object，属性名为fieldName的属性值
     *
     * @param obj
     * @param fieldName
     * @return
     */
    public static Field getField(Object obj, String fieldName) {
        if (null == obj && StringUtils.isBlank(fieldName)) {
            return null;
        }
        Class<?> clazz = obj.getClass();
        Field field = null;
        for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
            try {
                field = clazz.getDeclaredField(fieldName);
                if (null != field) {
                    return field;
                }
            } catch (Exception e) {
            }
        }
        return field;

    }

    /**
     * 调用类为Object，属性名为fieldName的get方法获取属性值
     *
     * @param obj
     * @param fieldName
     * @return
     */
    public static Object getValue(Object obj, String fieldName) {
        Field field = getField(obj, fieldName);
        field.setAccessible(true);
        try {
            PropertyDescriptor pd = new PropertyDescriptor(field.getName(),
                    obj.getClass());
            Method getMethod = pd.getReadMethod();
            return getMethod.invoke(obj);
        } catch (Exception e) {
        }
        return null;

    }
    /**
     *调用object类的属性名为fieldName的set方法，给属性fieldName赋值
    **/
    public static void setFieldValue(Object object, String fieldName, Object value) {
        Field field = getField(object, fieldName);
        if (null == field) {
            log.info(fieldName);
            return;
        }
        field.setAccessible(true);// 设置可操作性
        try {
            // 将 object 中 field 所代表的值 设置为 value
            field.set(object, value);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}