相对强大的反射工具类

1.针对场景，反射执行方法或者获取属性中，有时候需要去查找到父类的方法或者属性，该工具类可以查找父类的方法和属性
依赖工具类

reflections-0.10.2.jar

package com.mes.util.common;

import org.reflections.Reflections;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 反射工具类
 *
 * @author xuweijun
 * @date 2022/5/16
 */
public class ReflectUtilsEx {
    /**
     * 执行方法
     * @author xuweijun
     * @date 2022/5/16 14:00
     * @param object
     * @param clazz
     * @param methodName
     * @param parameterTypes
     * @param args
     * @return java.lang.Object
     */
    public static Object invokMethod(final Object object,final Class<?> clazz, final String methodName, final Class<?>[] parameterTypes, final Object[] args) {
        try {
            Method declaredMethod = clazz.getDeclaredMethod(methodName, parameterTypes);
            declaredMethod.setAccessible(true);
            return declaredMethod.invoke(object, args);
        } catch (Exception e) {
            if (e instanceof NoSuchMethodException) {
                Class<?> superclass = clazz.getSuperclass();
                if (null == superclass) {
                    return null;
                }
                return invokMethod(object,superclass,methodName,parameterTypes,args);
            } else {
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * 获取属性
     * @author xuweijun
     * @date 2022/5/16 14:00
     * @param object
     * @param clazz
     * @param fname
     * @return java.lang.Object
     */
    public static Object getObjByField(Object object, Class<?> clazz, final String fname) {
        try {
            final Field field = clazz.getDeclaredField(fname);
            field.setAccessible(true);
            return field.get(object);
        } catch (Exception e) {
            if (e instanceof NoSuchFieldException) {
                Class<?> superclass = clazz.getSuperclass();
                if (null == superclass) {
                    return null;
                }
                return getObjByField(object,superclass,fname);
            } else {
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * 设置属性值
     * @author xuweijun
     * @date 2022/6/11 09:23
     * @param object
     * @param clazz
     * @param fName
     * @param fValue
     * @return void
     */
    public static void setObjFieldValue(Object object, Class<?> clazz, final String fName,final Object fValue) {
        try {
            final Field field = clazz.getDeclaredField(fName);
            field.setAccessible(true);
            field.set(object,fValue);
        } catch (Exception e) {
            if (e instanceof NoSuchFieldException) {
                Class<?> superclass = clazz.getSuperclass();
                if (null == superclass) {
                    return ;
                }
                setObjFieldValue(object,superclass,fName,fValue);
            } else {
                e.printStackTrace();
            }
        }
        return;
    }
    /**
     * Object对象转换成目标对象
     * @author xuweijun
     * @date 2022/7/7 09:07
     * @param fromValue
     * @param toValueType
     * @return T
     */
    public static <T> T convertValue(Object fromValue, Class<T> toValueType) throws IllegalArgumentException {
        return (T) fromValue;
    }
    /**
     * 获得接口的实现类实例,从结果上类似与Spring的接口实例化
     * @author xuweijun
     * @date 2022/7/7 09:07
     * @param clazz
     * @return java.util.Map<java.lang.String,T>
     */
    public static <T> Map<String, T> getSubTypeMap(Class<T> clazz) {
        Reflections reflections = new Reflections(clazz.getPackage().getName());
        Set<Class<? extends T>> subTypesOf = reflections.getSubTypesOf(clazz);
        Map<String, T> collect = subTypesOf.stream().collect(Collectors.toMap(k -> k.getName(), v -> {
            try {
                return v.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return null;
        }));
        return collect;
    }
}