一个很好用的反射工具类

在网上搜索很久，终于找到一个很好用的反射工具类，略微修改后，终于可以正常使用了。

注意：混淆后的代码不能用反射调用。

package com.android.systemui.recents.misc;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
public class ReflectUtil {
/**
 * 使用反射调用方法
 *
 * @param o 被调用对象
 * @param methodName 被调用对象的方法名称
 * @param args 被调用方法所需传入的参数列表
 */
public static Object callMethod(Object o,String methodName,Object... args) {
    Object result = null;
    try {
        int argslen = args.length;
        Class c = o.getClass();
        Method m = null;

        Class<?> argsTypes[] = new Class<?>[argslen];
        //基本类型在参数传递过程中会自动封住成对象类型，这里还原成基本类型的Class
        for (int i=0;i<argslen;i++) {
            argsTypes[i] = args[i].getClass();
            if (argsTypes[i] == Integer.class) {
                argsTypes[i] = int.class;
            }
            if (argsTypes[i] == Float.class) {
                argsTypes[i] = float.class;
            }
            if (argsTypes[i] == Long.class) {
                argsTypes[i] = long.class;
            }
            if (argsTypes[i] == Byte.class) {
                argsTypes[i] = byte.class;
            }
            if (argsTypes[i] == Double.class) {
                argsTypes[i] = double.class;
            }
            if (argsTypes[i] == Boolean.class) {
                argsTypes[i] = boolean.class;
            }
        }

        if (argslen == 0) {
            m = c.getDeclaredMethod(methodName);
        } else {
            Method[] methodes = c.getDeclaredMethods();
            for (Method method: methodes) {
                Class<?>[] parameterTypes = method.getParameterTypes();
                if (method.getName().equals(methodName) && parameterTypes.length == argslen) {
                    int i;
                    for (i=0;i<argslen;i++) {
                        if (argsTypes[i] != parameterTypes[i]) {
                            break;
                        }
                    }
                    if (i == argslen) {
                        m = method;
                        break;
                    }
                }
            }
        }
        if (m == null) {
            String argsName = Arrays.toString(argsTypes).replace("[", "(").replace("]", ")");
            throw new NoSuchMethodException(methodName + argsName);
        }
        m.setAccessible(true);
        result = m.invoke(o,args);
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return result;
}

/**
 * 使用反射设置变量值
 *
 * @param target 被调用对象
 * @param fieldName 被调用对象的字段，一般是成员变量或静态变量，不可是常量！
 * @param value 值
 * @param <T> value类型，泛型
 */
public static <T> void setValue(Object target,String fieldName,T value) {
    try {
        Class c = target.getClass();
        Field f = c.getDeclaredField(fieldName);
        f.setAccessible(true);
        f.set(target, value);
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}

/**
 * 使用反射获取变量值
 *
 * @param target 被调用对象
 * @param fieldName 被调用对象的字段，一般是成员变量或静态变量，不可以是常量
 * @param <T> 返回类型，泛型
 * @return 值
 */
public static <T> T getValue(Object target,String fieldName) {
    T value = null;
    try {
        Class c = target.getClass();
        Field f = c.getDeclaredField(fieldName);
        f.setAccessible(true);
        value = (T) f.get(target);
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return value;
}

}