java反射的一些工具方法

java反射的一些工具方法

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Field;
import java.util.Set;

/**
 * 反射的工具类
 * @author xx
 * @date 2022/10/9 9:56
 */
public class ReflectUtil {

    private static final Logger log = LoggerFactory.getLogger(ReflectUtil.class);

    /**
     * 根据参数创建一个新的对象，其余的默认值
     * @param t1
     * @param keys
     * @param <T>
     * @return
     */
    public static <T> T createNewByKeys(T t1, Set<String> keys){
        try {
            T t = (T) createByType(t1.getClass());
            Object val;
            for (String key : keys) {
                //先从原始对象里面获取值
                val = getByName(t1, key);
                //再塞到新的对象里面
                setByName(t, key, val);
            }
            return t;
        } catch (Exception e) {
            log.error("创建新对象异常", e);
        }
        return null;
    }

    /**
     * 通过属性名称获取值
     * @param t
     * @param name
     * @param <T>
     * @return
     */
    public static <T> Object getByName(T t, String name) {
        if (StringUtils.isEmpty(name)) {
            return null;
        }
        //处理..形式的属性名称
        String[] arr = name.split("\\.");
        Object obj = t;
        for (String s : arr) {
            obj =  getByAttr(obj, s);
            if (obj == null) {
                break;
            }
        }
        return obj;
    }

    /**
     * 通过属性名称设置新的值
     * @param t
     * @param name
     * @param val
     * @param <T>
     */
    public static <T> void setByName(T t, String name, Object val){
        if (StringUtils.isEmpty(name)) {
            return;
        }
        //处理..形式的属性名称
        String[] arr = name.split("\\.");
        Object obj = t;
        Object newObj;
        Class tClass;
        if (arr.length > 1) {
            for (int i = 0; i < arr.length - 1; i++) {
                newObj = getByAttr(obj, arr[i]);
                if (newObj == null) {
                    tClass = getTypeByName(obj, arr[i]);
                    if (tClass == null) {
                        break;
                    }
                    newObj = createByType(tClass);
                    if (newObj == null) {
                        break;
                    }
                    setByAttr(obj, arr[i], newObj);
                }
                obj = newObj;
            }
        }
        //最后把最底层的值塞进去
        setByAttr(obj, arr[arr.length - 1], val);
    }

    /**
     * 根据类型创建对象
     * @param tClass
     * @return
     */
    public static <T> T createByType(Class<T> tClass){
        try {
            //调用无参构造器创建对象
            return tClass.newInstance();
        } catch (Exception e) {
            log.error("根据类型创建对象异常", e);
        }
        return null;
    }

    /**
     * 最底层的根据属性名称设置值的方法，最纯粹的属性
     * @param t
     * @param name
     * @param value
     * @param <T>
     */
    private static <T> void setByAttr(T t, String name, Object value) {
        if (t == null || StringUtils.isEmpty(name)) {
            return;
        }
        Field field = null;
        try {
            //只获取本类的属性
            field = t.getClass().getDeclaredField(name);
            field.setAccessible(true);
            field.set(t, value);
        } catch (Exception e) {
            log.error("反射设置值异常", e);
        } finally {
            if (field != null) {
                field.setAccessible(false);
            }
        }
    }

    /**
     * 获取属性类型
     * @param t
     * @param name
     * @param <T>
     * @return
     */
    private static <T> Class getTypeByName(T t, String name){
        try {
            Field field = t.getClass().getDeclaredField(name);
            return field.getType();
        } catch (Exception e) {
            log.error("获取属性类型异常", e);
        }
        return null;
    }

    /**
     * 最底层的根据属性名称获取数据，最纯粹的属性
     * @param t
     * @param name
     * @param <T>
     * @return
     */
    private static <T> Object getByAttr(T t, String name) {
        if (t == null || StringUtils.isEmpty(name)) {
            return null;
        }
        Field field = null;
        try {
            //只获取本类的属性
            field = t.getClass().getDeclaredField(name);
            field.setAccessible(true);
            return field.get(t);
        } catch (Exception e) {
            log.error("反射获取值异常", e);
        } finally {
            if (field != null) {
                field.setAccessible(false);
            }
        }
        return null;
    }

}