Android反射机制实现与原理

ReflectionTest.java
package crazypebble.reflectiontest; import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.Serializable; public class ReflectionTest extends Object implements ActionListener,Serializable{
// 成员变量
private int bInt;
public Integer bInteger = new Integer(4);
public String strB = "crazypebble";
private String strA; // 构造函数
public ReflectionTest() { } protected ReflectionTest(int id, String name) { } // 成员方法
public int abc(int id, String name) {
System.out.println("crazypebble ---> " + id + "-" + name);
return 0;
} protected static void edf() { } @Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub } }

get_Reflection_Constructors()
/**
* 获取反射类中的构造方法
* 输出打印格式："Modifier修饰域 构造方法名(参数类型列表)"
*/
public static void get_Reflection_Constructors(ReflectionTest r) { Class temp = r.getClass();
String className = temp.getName(); // 获取指定类的类名 try {
Constructor[] theConstructors = temp.getDeclaredConstructors(); // 获取指定类的公有构造方法 for (int i = 0; i < theConstructors.length; i++) {
int mod = theConstructors[i].getModifiers(); // 输出修饰域和方法名称
System.out.print(Modifier.toString(mod) + " " + className + "("); Class[] parameterTypes = theConstructors[i].getParameterTypes(); // 获取指定构造方法的参数的集合
for (int j = 0; j < parameterTypes.length; j++) { // 输出打印参数列表
System.out.print(parameterTypes[j].getName());
if (parameterTypes.length > j+1) {
System.out.print(", ");
}
}
System.out.println(")");
}
} catch (Exception e) {
e.printStackTrace();
}
}

get_Reflection_Method()
/**
* 获取反射类的方法
* 打印输出格式："RetType FuncName(paramTypeList)"
*/
public static void get_Reflection_Method(ReflectionTest r) { Class temp = r.getClass();
String className = temp.getName(); /*
* Note: 方法getDeclaredMethods()只能获取到由当前类定义的所有方法，不能获取从父类继承的方法
* 方法getMethods() 不仅能获取到当前类定义的public方法，也能得到从父类继承和已经实现接口的public方法
* 请查阅开发文档对这两个方法的详细描述。
*/
//Method[] methods = temp.getDeclaredMethods();
Method[] methods = temp.getMethods(); for (int i = 0; i < methods.length; i++) { // 打印输出方法的修饰域
int mod = methods[i].getModifiers();
System.out.print(Modifier.toString(mod) + " "); // 输出方法的返回类型
System.out.print(methods[i].getReturnType().getName()); // 获取输出的方法名
System.out.print(" " + methods[i].getName() + "("); // 打印输出方法的参数列表
Class[] parameterTypes = methods[i].getParameterTypes();
for (int j = 0; j < parameterTypes.length; j++) {
System.out.print(parameterTypes[j].getName());
if (parameterTypes.length > j+1) {
System.out.print(", ");
}
}
System.out.println(")");
}
}

get_Reflection_Field_Value()
/**
* 获取反射类中的属性和属性值
* 输出打印格式："Modifier Type : Name = Value"
* Note: 对于未初始化的指针类型的属性，将不输出结果
*/
public static void get_Reflection_Field_Value(ReflectionTest r) { Class temp = r.getClass(); // 获取Class类的对象的方法之一 try {
System.out.println("public 属性");
Field[] fb = temp.getFields();
for (int i = 0; i < fb.length; i++) { Class cl = fb[i].getType(); // 属性的类型 int md = fb[i].getModifiers(); // 属性的修饰域 Field f = temp.getField(fb[i].getName()); // 属性的值
f.setAccessible(true);
Object value = (Object)f.get(r); // 判断属性是否被初始化
if (value == null) {
System.out.println(Modifier.toString(md) + " " + cl + " : " + fb[i].getName());
}
else {
System.out.println(Modifier.toString(md) + " " + cl + " : " + fb[i].getName() + " = " + value.toString());
}
} System.out.println("public & 非public 属性");
Field[] fa = temp.getDeclaredFields();
for (int i = 0; i < fa.length; i++) { Class cl = fa[i].getType(); // 属性的类型 int md = fa[i].getModifiers(); // 属性的修饰域 Field f = temp.getDeclaredField(fa[i].getName()); // 属性的值
f.setAccessible(true); // Very Important
Object value = (Object) f.get(r); if (value == null) {
System.out.println(Modifier.toString(md) + " " + cl + " : " + fa[i].getName());
}
else {
System.out.println(Modifier.toString(md) + " " + cl + " : " + fa[i].getName() + " = " + value.toString());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}

LoadMethod.java
package crazypebble.reflectiontest; import java.lang.reflect.Constructor;
import java.lang.reflect.Method; public class LoadMethod { /**
* 在运行时加载指定的类，并调用指定的方法
* @param cName Java的类名
* @param MethodName 方法名
* @param types 方法的参数类型
* @param params 方法的参数值
* @return
*/
public Object Load(String cName, String MethodName, String[] types, String[] params) { Object retObject = null; try {
// 加载指定的类
Class cls = Class.forName(cName); // 获取Class类的对象的方法之二 // 利用newInstance()方法，获取构造方法的实例
// Class的newInstance方法只提供默认无参构造实例
// Constructor的newInstance方法提供带参的构造实例
Constructor ct = cls.getConstructor(null);
Object obj = ct.newInstance(null);
//Object obj = cls.newInstance(); // 构建 方法的参数类型
Class paramTypes[] = this.getMethodTypesClass(types); // 在指定类中获取指定的方法
Method meth = cls.getMethod(MethodName, paramTypes); // 构建 方法的参数值
Object argList[] = this.getMethodParamObject(types, params); // 调用指定的方法并获取返回值为Object类型
retObject = meth.invoke(obj, argList); } catch (Exception e) {
System.err.println(e);
} return retObject;
} /**
* 获取参数类型，返回值保存在Class[]中
*/
public Class[] getMethodTypesClass(String[] types) {
Class[] cs = new Class[types.length]; for (int i = 0; i < cs.length; i++) {
if (types[i] != null || !types[i].trim().equals("")) {
if (types[i].equals("int") || types[i].equals("Integer")) {
cs[i] = Integer.TYPE;
}
else if (types[i].equals("float") || types[i].equals("Float")) {
cs[i] = Float.TYPE;
}
else if (types[i].equals("double") || types[i].equals("Double")) {
cs[i] = Double.TYPE;
}
else if (types[i].equals("boolean") || types[i].equals("Boolean")) {
cs[i] = Boolean.TYPE;
}
else {
cs[i] = String.class;
}
}
}
return cs;
} /**
* 获取参数Object[]
*/
public Object[] getMethodParamObject(String[] types, String[] params) { Object[] retObjects = new Object[params.length]; for (int i = 0; i < retObjects.length; i++) {
if(!params[i].trim().equals("")||params[i]!=null){
if(types[i].equals("int")||types[i].equals("Integer")){
retObjects[i]= new Integer(params[i]);
}
else if(types[i].equals("float")||types[i].equals("Float")){
retObjects[i]= new Float(params[i]);
}
else if(types[i].equals("double")||types[i].equals("Double")){
retObjects[i]= new Double(params[i]);
}
else if(types[i].equals("boolean")||types[i].equals("Boolean")){
retObjects[i]=new Boolean(params[i]);
}
else{
retObjects[i] = params[i];
}
}
} return retObjects;
}
}

// 利用newInstance()方法，获取构造方法的实例 // Class的newInstance方法，仅提供默认无参的实例化方法，类似于无参的构造方法 // Constructor的newInstance方法，提供了带参数的实例化方法，类似于含参的构造方法 Constructor ct = cls.getConstructor(null); Object obj = ct.newInstance(null); Object obj = cls.newInstance();

LoadMethodEx.java
package crazypebble.reflectiontest; import java.lang.reflect.Constructor;
import java.lang.reflect.Method; public class LoadMethodEx { /**
* 在运行时加载指定的类，并调用指定的方法
* @param cName Java的类名
* @param MethodName 方法名
* @param params 方法的参数值
* @return
*/
public Object Load(String cName, String MethodName, Object[] params) { Object retObject = null; try {
// 加载指定的类
Class cls = Class.forName(cName); // 获取Class类的对象的方法之二 // 利用newInstance()方法，获取构造方法的实例
// Class的newInstance方法只提供默认无参构造实例
// Constructor的newInstance方法提供带参的构造实例
Constructor ct = cls.getConstructor(null);
Object obj = ct.newInstance(null);
//Object obj = cls.newInstance(); // 根据方法名获取指定方法的参数类型列表
Class paramTypes[] = this.getParamTypes(cls, MethodName); // 获取指定方法
Method meth = cls.getMethod(MethodName, paramTypes);
meth.setAccessible(true); // 调用指定的方法并获取返回值为Object类型
retObject = meth.invoke(obj, params); } catch (Exception e) {
System.err.println(e);
} return retObject;
} /**
* 获取参数类型，返回值保存在Class[]中
*/
public Class[] getParamTypes(Class cls, String mName) {
Class[] cs = null; /*
* Note: 由于我们一般通过反射机制调用的方法，是非public方法
* 所以在此处使用了getDeclaredMethods()方法
*/
Method[] mtd = cls.getDeclaredMethods();
for (int i = 0; i < mtd.length; i++) {
if (!mtd[i].getName().equals(mName)) { // 不是我们需要的参数，则进入下一次循环
continue;
} cs = mtd[i].getParameterTypes();
}
return cs;
}
}

执行结果
属性：
public 属性
public class java.lang.Integer : bInteger = 4
public class java.lang.String : strB = crazypebble
public & 非public 属性
private int : bInt = 0
public class java.lang.Integer : bInteger = 4
public class java.lang.String : strB = crazypebble
private class java.lang.String : strA 构造方法：
public crazypebble.reflectiontest.ReflectionTest()
protected crazypebble.reflectiontest.ReflectionTest(int, java.lang.String) 父类/接口：
父类: java.lang.Object
接口0: java.awt.event.ActionListener
接口1: java.io.Serializable 成员方法：
public int abc(int, java.lang.String)
public void actionPerformed(java.awt.event.ActionEvent)
public final native void wait(long)
public final void wait()
public final void wait(long, int)
public boolean equals(java.lang.Object)
public java.lang.String toString()
public native int hashCode()
public final native java.lang.Class getClass()
public final native void notify()
public final native void notifyAll() 反射机制调用方法:LoadMethod
crazypebble ---> 1-hello, android-1! 反射机制调用方法:LoadMethodEx
crazypebble ---> 2-hello, android-2?
返回结果：0

AndroidReflection
package crazypebble.androidreflection; import java.lang.reflect.Field; import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button; public class MainActivity extends Activity {
/** Called when the activity is first created. */
private static Button btnHandler = null;
private static Button btnShowing = null;
AlertDialog alertDialog = null; @Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main); btnHandler = (Button)findViewById(R.id.btn_mHandler);
btnHandler.setOnClickListener(new ButtonListener()); btnShowing = (Button)findViewById(R.id.btn_mShowing);
btnShowing.setOnClickListener(new ButtonListener()); alertDialog = new AlertDialog.Builder(this)
.setTitle("abc")
.setMessage("Content")
.setIcon(R.drawable.icon)
.setPositiveButton("确定", new PositiveClickListener())
.setNegativeButton("取消", new NegativeClickListener())
.create();
} private class ButtonListener implements OnClickListener { @Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_mHandler:
modify_mHandler();
alertDialog.show();
break;
case R.id.btn_mShowing:
alertDialog.show();
break;
default:
break;
}
}
} private class PositiveClickListener implements android.content.DialogInterface.OnClickListener { @Override
public void onClick(DialogInterface dialog, int which) {
// 方法二时启用
modify_dismissDialog(false);
}
} private class NegativeClickListener implements android.content.DialogInterface.OnClickListener { @Override
public void onClick(DialogInterface dialog, int which) {
// 方法一时启用
//dialog.dismiss(); // 方法二时启用
modify_dismissDialog(true);
}
} /*
* 第一种方法：修改AlertController类的private成员变量mHandler的值
*/
public void modify_mHandler() {
try {
Field field = alertDialog.getClass().getDeclaredField("mAlert");
field.setAccessible(true);
// 获取mAlert变量的值
Object obj = field.get(alertDialog);
field = obj.getClass().getDeclaredField("mHandler");
field.setAccessible(true);
// 修改mHandler变量的值，使用新的ButtonHandler类
field.set(obj, new MyButtonHandler(alertDialog)); } catch (Exception e) {
e.printStackTrace();
}
} /*
* 第二种方法：修改dismissDialog()方法
*/
public void modify_dismissDialog(boolean flag) {
try {
Field field = alertDialog.getClass().getSuperclass().getDeclaredField("mShowing");
field.setAccessible(true);
// 将mShowing变量设为false，表示对话框已经关闭
field.set(alertDialog, flag);
alertDialog.dismiss();
} catch (Exception e) {
e.printStackTrace();
}
}
}

MyButtonHandler.java
package crazypebble.androidreflection; import java.lang.ref.WeakReference; import android.content.DialogInterface;
import android.os.Handler;
import android.os.Message; public class MyButtonHandler extends Handler{ // Button clicks have Message.what as the BUTTON{1,2,3} constant
private static final int MSG_DISMISS_DIALOG = 1; private WeakReference<DialogInterface> mDialog; public MyButtonHandler(DialogInterface dialog) {
mDialog = new WeakReference<DialogInterface>(dialog);
} @Override
public void handleMessage(Message msg) {
switch (msg.what) { case DialogInterface.BUTTON_POSITIVE:
case DialogInterface.BUTTON_NEGATIVE:
case DialogInterface.BUTTON_NEUTRAL:
((DialogInterface.OnClickListener) msg.obj).onClick(mDialog.get(), msg.what);
break;
}
}
}