Java 反射机制详解
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://cloud.tencent.com/developer/article/1341961
本篇文章已授权微信公众号 guolin_blog （郭霖）独家发布
为什么要写这一系列的博客呢？
因为在 Android 开发的过程中， 泛型，反射，注解这些知识进场会用到，几乎所有的框架至少都会用到上面的一两种知识，如 Gson 就用到泛型，反射，注解，Retrofit 也用到泛型，反射，注解 。学好这些知识对我们进阶非常重要，尤其是阅读开源框架源码或者自己开发开源框架。
反射机制
什么是反射机制
简单来说，放射可以帮助我们在动态运行的时候，对于任意一个类，可以获得其所有的方法（包括 public protected private 默认状态的），所有的变量 （包括 public protected private 默认状态的）。是不是很强大呢。
反射机制有什么作用呢？
- 获取某些类的一些变量，调用某些类的私有方法。（例如在Android开发中我们可以用来开启 WiFi 热点，调用 WifiManager 中的 setWifiApEnabled() 方法 ）
- 增加代码的灵活性。很多主流框架都使用了反射技术.像ssh框架都采用两种技术 xml做配置文件+反射技术.
假如有这样一个类 Person，它拥有多个成员变量，country,city,name,province,height,age 等，同时它拥有多个 构造方法，多个方法，这些变量，方法的访问权限既有 public 也有 private 的。下面我们以这个为例子，一起看怎样使用反射获得相应的 Filed，Constructor，Method。
/**
* 博客地址：http://blog.csdn.net/gdutxiaoxu
* @author xujun
* @time 2017/3/29 22:19.
*/
public class Person {
public String country;
public String city;
private String name;
private String province;
private Integer height;
private Integer age;
public Person() {
System.out.println("调用Person的无参构造方法");
}
private Person(String country, String city, String name) {
this.country = country;
this.city = city;
this.name = name;
}
public Person(String country, Integer age) {
this.country = country;
this.age = age;
}
private String getMobile(String number) {
String mobile = "010-110" + "-" + number;
return mobile;
}
private void setCountry(String country) {
this.country=country;
}
public void getGenericHelper(HashMap<String, Integer> hashMap) {
}
public Class getGenericType() {
try {
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
Method method = getClass().getDeclaredMethod("getGenericHelper",HashMap.class);
Type[] genericParameterTypes = method.getGenericParameterTypes();
if (null == genericParameterTypes || genericParameterTypes.length < 1) {
return null;
}
ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
Type rawType = parameterizedType.getRawType();
System.out.println("----> rawType=" + rawType);
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
return null;
}
for (int i = 0; i < actualTypeArguments.length; i++) {
Type type = actualTypeArguments[i];
System.out.println("----> type=" + type);
}
} catch (Exception e) {
}
return null;
}
@Override
public String toString() {
return "Person{" +
"country='" + country + '\'' +
", city='" + city + '\'' +
", name='" + name + '\'' +
", province='" + province + '\'' +
", height=" + height +
'}';
}
}使用反射获得所有构造方法（包括私有的，非私有的）
默认权限的指的是没有修饰符修饰的
几个重要的方法讲解
方法 | 描述 |
|---|---|
public Constructor getConstructor(Class… parameterTypes) | 获得指定的构造方法，注意只能获得 public 权限的构造方法，其他访问权限的获取不到 |
public Constructor getDeclaredConstructor(Class… parameterTypes) | 获得指定的构造方法，注意可以获取到任何访问权限的构造方法。 |
public Constructor[] getConstructors() throws SecurityException | 获得所有 public 访问权限的构造方法 |
public Constructor[] getDeclaredConstructors() throws SecurityException | 获得所有的构造方法，包括（public, private,protected,默认权限的） |
看了上面的几个方法，其实很好区分
- 后缀带 s 的返回对象时数组类型，是可以获得相应权限的所有方法的，如 Constructor getConstructor() 方法 和 Constructor
获得所有的构造方法
public static void printConstructor(String className) {
try {
Class<?> aClass = Class.forName(className);
Constructor<?>[] constructors = aClass.getConstructors();
print(constructors);
Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
print(declaredConstructors);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}print: private com.example.reflectdemo.Person(java.lang.String,java.lang.String,java.lang.String) print: public com.example.reflectdemo.Person() print:public com.example.reflectdemo.Person(java.lang.String,java.lang.Integer) print:public com.example.reflectdemo.Person(java.lang.String,java.lang.Integer)
对比 Person 里面所有的构造方法，可以知道我们代码的逻辑是正确的
获得指定的构造方法
public static Constructor getConstructor(String className, Class<?>... clzs) {
try {
Class<?> aClass = Class.forName(className);
Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(clzs);
print(declaredConstructor);
// if Constructor is not public,you should call this
declaredConstructor.setAccessible(true);
return declaredConstructor;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
return null;
}
public class TestHelper {
public static final String TAG="xujun";
public static final String CLASS_NAME = "com.example.reflectdemo.Person";
public static final String CHINA = "China";
public static void testConstructor(){
ReflectHelper.printConstructor(CLASS_NAME);
Constructor constructor = ReflectHelper.getConstructor(CLASS_NAME, String.class, Integer.class);
try {
Object meinv = constructor.newInstance(CHINA, 12);
Person person = (Person) meinv;
Log.i(TAG, "testConstructor: =" + person.toString());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}我们将可以看到以下的输出结果
testConstructor: =Person country=China, city=null, name=null, province=null, height=null, age=12
可以看到 country=China，age=12 这说明我们成功通过反射调用 Person 带两个参数的沟改造方法。
注意事项
如果该方法，或者该变量不是 public 访问权限的，我们应该调用相应的 setAccessible(true) 方法，才能访问得到
//if Constructor is not public,you should call this
declaredConstructor.setAccessible(true);使用反射获得所有的 Filed 变量
获得所有的 Filed 变量
public static void printFiled(String className) {
try {
Class<?> aClass = Class.forName(className);
Field[] fields = aClass.getFields();
PrintUtils.print(fields);
Field[] declaredFields = aClass.getDeclaredFields();
PrintUtils.print(declaredFields);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}获得指定的成员变量
现在假如我们要获得 Person 中的私有变量 age ，我们可以通过以下的代码获得，同时并打印出所有的成员变量。
public static Field getFiled(String className, String filedName) {
Object o = null;
try {
Class<?> aClass = Class.forName(className);
Field declaredField = aClass.getDeclaredField(filedName);
// if not public,you should call this
declaredField.setAccessible(true);
return declaredField;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
return null;
}
public static void testFiled(){
ReflectHelper.printFileds(CLASS_NAME);
Person person = new Person(CHINA, 12);
Field field = ReflectHelper.getFiled(CLASS_NAME, "age");
try {
Integer integer = (Integer) field.get(person);
PrintUtils.print("integer="+integer);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}我们可以看到以下的输出结果
print: public java.lang.String com.example.reflectdemo.Person.country print: public java.lang.String com.example.reflectdemo.Person.city print: public java.lang.String com.example.reflectdemo.Person.country print: public java.lang.String com.example.reflectdemo.Person.city print: private java.lang.String com.example.reflectdemo.Person.name print: private java.lang.String com.example.reflectdemo.Person.province print: private java.lang.Integer com.example.reflectdemo.Person.height print: private java.lang.Integer com.example.reflectdemo.Person.age print:integer=12
使用反射执行相应的 Method
主要有以下几个方法，
- public Method[] getDeclaredMethods()
- public Method[] getMethods() throws SecurityException
- public Method getDeclaredMethod()
- public Method getMethod(String name, Class
获取所有的 Method
public static void printMethods(String className) {
try {
Class<?> aClass = Class.forName(className);
Method[] declaredMethods = aClass.getDeclaredMethods();
PrintUtils.print(declaredMethods);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}print: public java.lang.String com.example.reflectdemo.Person.toString() print: public java.lang.Class com.example.reflectdemo.Person.getGenericType() print: private void com.example.reflectdemo.Person.setCountry(java.lang.String) print: public void com.example.reflectdemo.Person.getGenericHelper(java.util.HashMap) print: private java.lang.String com.example.reflectdemo.Person.getMobile(java.lang.String)
对比 Person 里面的所有方法，毫无疑问我们的代码逻辑是正确的。
获取指定的 Method
我们可以使用 getDeclaredMethod(String name, Class
public static void testMethod(){
ReflectHelper.printMethods(CLASS_NAME);
Person person=new Person();
Method method = ReflectHelper.getMethod(CLASS_NAME,
"setCountry", String.class);
try {
// 执行方法，结果保存在 person 中
Object o = method.invoke(person, CHINA);
// 拿到我们传递进取的参数 country 的值 China
String country=person.country;
PrintUtils.print(country);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
public class ReflectHelper {
private static final String TAG = "ReflectHelper";
public static Method getMethod(String className, String methodName, Class<?>... clzs) {
try {
Class<?> aClass = Class.forName(className);
Method declaredMethod = aClass.getDeclaredMethod(methodName, clzs);
declaredMethod.setAccessible(true);
return declaredMethod;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
return null;
}
}执行上面的函数，将可以看到下面的结果
print:China
即我们成功利用反射调用 Person 的 setCountry 方法，并将值成功改变。
使用反射操作数组
/**
* 利用反射操作数组
* 1 利用反射修改数组中的元素
* 2 利用反射获取数组中的每个元素
*/
public static void testArrayClass() {
String[] strArray = new String[]{"5","7","暑期","美女","女生","女神"};
Array.set(strArray,0,"帅哥");
Class clazz = strArray.getClass();
if (clazz.isArray()) {
int length = Array.getLength(strArray);
for (int i = 0; i < length; i++) {
Object object = Array.get(strArray, i);
String className=object.getClass().getName();
System.out.println("----> object=" + object+",className="+className);
}
}
}—-> object=帅哥,className=java.lang.String —-> object=7,className=java.lang.String —-> object=暑期,className=java.lang.String —-> object=美女,className=java.lang.String —-> object=女生,className=java.lang.String —-> object=女神,className=java.lang.String
从结果可以说明，我们成功通过 Array.set(strArray,0,”帅哥”) 改变数组的值。
使用反射获得泛型类型
public static void getGenericHelper(HashMap<String, Person> map) {
}现在假设我们有这样一个方法，那我们要怎样获得 HashMap 里面的 String，Person 的类型呢？
对于 Java Type还不熟悉的可以先读这一篇博客 java Type 详解
public static void getGenericType() {
try {
Method method =TestHelper.class.getDeclaredMethod("getGenericHelper",HashMap.class);
Type[] genericParameterTypes = method.getGenericParameterTypes();
// 检验是否为空
if (null == genericParameterTypes || genericParameterTypes.length < 1) {
return ;
}
// 取 getGenericHelper 方法的第一个参数
ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
Type rawType = parameterizedType.getRawType();
System.out.println("----> rawType=" + rawType);
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
return ;
}
// 打印出每一个类型
for (int i = 0; i < actualTypeArguments.length; i++) {
Type type = actualTypeArguments[i];
System.out.println("----> type=" + type);
}
} catch (Exception e) {
}
}执行上面的代码，输出结果
—-> rawType=class java.util.HashMap —-> type=class java.lang.String —-> type=class com.example.reflectdemo.Person
怎样获得 Metho,Field,Constructor 的访问权限 （ public,private,ptotected 等）
其实很简单，我们阅读文档可以发现他们都有 getModifiers() 方法，该方法放回 int 数字， 我们在利用 Modifier.toString() 就可以得到他们的访问权限
int modifiers = method.getModifiers();
Modifier.toString(modifiers);