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);
}
}