反射基本方法封装

在这儿为大家分享反射操作的基本方法，可以当作基本工具使用

如果想转载请注明出处，谢谢。

好了，废话不多说，代码如下：

package com.tobiasy.toolkit.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

/**
 * @author tobiasy
 */
public class ReflectUtils {
    /**
     * <p>获取clazz及其父类中的所有属性</p>
     *
     * @param clazz
     * @return
     */
    public static List<Field> getExtendsFields(Class<? extends Object> clazz) {
        Field[] superField = clazz.getSuperclass().getDeclaredFields();
        Field[] targetField = clazz.getDeclaredFields();
        List<Field> fieldList = new ArrayList<>();
        for (Field field : superField) {
            fieldList.add(field);
        }
        for (Field field : targetField) {
            Boolean f = true;
            for (Field field1 : superField) {
                if (field1.getName().equals(field.getName())) {
                    f = false;
                }
            }
            if (f) {
                fieldList.add(field);
            }
        }
        return fieldList;
    }

    /**
     * 根据属性名fieldName查找指定类clazz中的属性域Field
     * @param clazz
     * @param fieldName
     * @return
     */
    public static Field findField(Class clazz, String fieldName) {
        Field field = findPublicField(clazz, fieldName);
        if (field != null) {
            return field;
        }
        return findExtendsField(clazz, fieldName);
    }

    /**
     * 检索子类或者父类中的public修饰的fieldName属性域
     * @param clazz
     * @param fieldName
     * @return
     */
    public static Field findPublicField(Class clazz, String fieldName) {
        try {
            return clazz.getField(fieldName);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据属性名fieldName查找指定类clazz或者父类中的属性域Field
     * @param clazz
     * @param fieldName
     * @return
     */
    public static Field findExtendsField(Class<?> clazz, String fieldName) {
        try {
            return clazz.getDeclaredField(fieldName);
        } catch (NoSuchFieldException var4) {
            return clazz.getSuperclass() != null ? findExtendsField(clazz.getSuperclass(), fieldName) : null;
        }
    }

    public static Method[] getMethods(Class clazz){
        Method[] methods = clazz.getMethods();
        return methods;
    }

    /**
     * 根据参数类型获取继承类中的 Method
     *
     * @param clazz      指定类
     * @param methodName 方法名称
     * @param paramTypes 参数类别，可多个
     * @return
     */
    public static Method findMethod(Class clazz, String methodName, Class... paramTypes) {
        Method method = findPublicMethod(clazz, methodName, paramTypes);
        if (method != null) {
            return method;
        }
        return findExtendsMethod(clazz, methodName, paramTypes);
    }

    /**
     * 检索public修饰的指定方法域
     * @param clazz
     * @param methodName     * @param paramTypes     * @return
     */
    public static Method findPublicMethod(Class clazz, String methodName, Class... paramTypes) {
        try {
            return clazz.getMethod(methodName, paramTypes);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 先从本类对象中找该方法，若没找到就循环从父类对象中去找
     * 
     * @param clazz      指定类
     * @param methodName 方法名称
     * @param paramTypes 参数类别，可多个
     * @return
     */
    public static Method findExtendsMethod(Class<?> clazz, String methodName, Class... paramTypes) {
        try {
            return clazz.getDeclaredMethod(methodName, paramTypes);
        } catch (NoSuchMethodException var4) {
            return clazz.getSuperclass() != null ? findExtendsMethod(clazz.getSuperclass(), methodName, paramTypes) : null;
        }
    }
    /**
     * 执行一个无参方法
     *
     * @param obj
     * @param methodName
     * @return
     * @throws NoSuchMethodException
     */
    public static Object invoke(Object obj, String methodName) throws NoSuchMethodException {
        Object value = null;
        try {
            Method getMethod = obj.getClass().getMethod(methodName, new Class[]{});
            if (getMethod == null) {
                return null;
            }
            value = getMethod.invoke(obj);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return value;
    }
    /**
     * 一个参数
     *
     * @param object
     * @param methodName
     * @param paramType
     * @param parameter
     * @return
     */
    public static Object invoke(Object object, String methodName, Class paramType, Object parameter) {
        Class[] paramTypes = {paramType};
        Object[] parameters = {parameter};
        return invoke(object, methodName, paramTypes, parameters);
    }
    /**
     * 利用反射执行类中指定方法，多个参数
     *
     * @param object     类对象
     * @param methodName 方法名称 
     * @param paramTypes 参数类型
     * @param parameters 参数
     * @return
     */
    public static Object invoke(Object object, String methodName, Class[] paramTypes, Object[] parameters) {
        Class<?> clazz = object.getClass();
        Method method = findMethod(clazz, methodName, paramTypes);
        if (method == null) {
            return null;
        }
        try {
            return method.invoke(object, parameters);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }
}