反射帮助ReflectionWraper

import android.util.Log;


import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;


public class ClassReflectionWraper {
    private final String TAG = "ClassReflectionWraper";


    public Class<?> mClass;
    private Object mInstance;
    private boolean mShowInfo = true;

    /**
     * 方法集合
     */
    private HashMap<String, Method> mMethodMap = new HashMap<String, Method>();
    /**
     * 内部类集合
     */
    private HashMap<String, Class> mInnerClassMap = new HashMap<String, Class>();
    /**
     * 成员变量集合
     */
    private HashMap<String, Field> mFieldMap = new HashMap<String, Field>();


    public ClassReflectionWraper(String className, boolean logInfo){
        mShowInfo = logInfo;
        try {
            mClass = Class.forName(className);
            getFieldsInfo();
            getConstructors();
            getMethodsInfo();
            getInnerClassesInfo();
        } catch (ClassNotFoundException e) {
            Log.d(TAG, "class not found:" + className);
        }
    }

    /**
     * 获取 类的方法 变量 内部类集合
     * @param clazz
     */
    public ClassReflectionWraper(Class<?> clazz){
        mClass = clazz;
        getFieldsInfo();
        getConstructors();
        getMethodsInfo();
        getInnerClassesInfo();
    }


    public Object instantiate(Object...objects){
        if(objects != null && objects.length > 0){
            Class[] paramClasses = new Class[objects.length];
            for (int i = 0; i < objects.length; i++) {
                paramClasses[i] = objects[i].getClass();
            }
            try {
                Constructor<?> constructor = mClass.getConstructor(paramClasses);
                mInstance = constructor.newInstance(objects);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }


        } else {
            try {
                mInstance = mClass.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }


        return mInstance;
    }

    /**
     * 获取类的所有成员变量
     */
    private void getFieldsInfo() {
        Field[] fields = mClass.getDeclaredFields();
        for(int i = 0;i < fields.length; i ++){
            if (mShowInfo) {
                Log.d(TAG, "field class name:" + fields[i].toString());
                Log.d(TAG, "field name:" + fields[i].getName());
            }
            mFieldMap.put(fields[i].getName(), fields[i]);
        }
    }


    /**
     * 类的所有的构造方法
     */
    private void getConstructors() {
        Constructor[] constructors = mClass.getConstructors();
        for(int i = 0;i < constructors.length; i ++){
            if(mShowInfo) {
                Log.d(TAG, "Constructor:" + constructors[i].toString());
            }
        }
    }

    /**
     *获取类的所有函数
     */
    private void getMethodsInfo() {
        Method[] methods = mClass.getDeclaredMethods();
        for(int i = 0;i < methods.length; i ++){
            if (mShowInfo) {
                Log.d(TAG, "Methods:" + methods[i].toString());
            }
            mMethodMap.put(methods[i].getName(), methods[i]);
        }
    }

    /**
     * 获取类的所有的内部类
     */
    private void getInnerClassesInfo() {
        Class[] classes = mClass.getDeclaredClasses();
        for(int i = 0;i < classes.length; i ++){
            Log.d(TAG, "Class:" + classes[i].toString());
            mInnerClassMap.put(classes[i].getSimpleName(), classes[i]);
        }
    }


    /**
     *
     * @param methodName    方法名
     * @param target    要调用此方法的对象（或静态方法的null)
     * @param params    参数
    方法的参数
     * @return
     */
    public Object invokeMethods(String methodName, Object target, Object ... params){
        Log.d(TAG, "invoke method: "  + methodName);
        try {
            if (mMethodMap.get(methodName) != null) {
                Method method = mMethodMap.get(methodName);
                method.setAccessible(true);
                return method.invoke(target, params);
            } else {
                Log.e(TAG, "no such method: " + methodName);
            }
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        return null;
    }


    @SuppressWarnings("unchecked")
    public <T> T getFieldValue(String fieldname, Object instance, T classs){
        Field field = mFieldMap.get(fieldname);
        try {
            return (T) field.get(instance);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
            return null;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     *
     * @param fieldname     变量名
     * @param instance      要调用此变量的对象
     * @return
     */
    public Object getFieldValue(String fieldname, Object instance) {
        Field field = mFieldMap.get(fieldname);
        try {
            field.setAccessible(true);
            return field.get(instance);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
            return null;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     *
     * @param fieldname     变量名
     * @param instance      要调用此变量的对象
     * @param value     新的值
     * @return
     */
    public boolean setFieldValue(String fieldname, Object instance, Object value){
        Field field = mFieldMap.get(fieldname);
        field.setAccessible(true);
        field.getGenericType();
        try {
            field.set(instance, value);
            return true;
        } catch (IllegalArgumentException e) {
            return false;
        } catch (IllegalAccessException e) {
            return false;
        }
    }

    /**
     * 
     * @param className
     * @return
     */
    public Class<?> getInnerClass(String className){
        return mInnerClassMap.get(className);
    }
}