Java 反射机制详解

来源：互联网发布：自动语音播报软件编辑：程序博客网时间：2024/05/16 11:40

本篇文章已授权微信公众号 guolin_blog （郭霖）独家发布

为什么要写这一系列的博客呢？

因为在 Android 开发的过程中，泛型，反射，注解这些知识进场会用到，几乎所有的框架至少都会用到上面的一两种知识，如 Gson 就用到泛型，反射，注解，Retrofit 也用到泛型，反射，注解。学好这些知识对我们进阶非常重要，尤其是阅读开源框架源码或者自己开发开源框架。

java Type 详解

java 反射机制详解

注解使用入门（一）

Android 自定义编译时注解1 - 简单的例子

Android 编译时注解 —— 语法详解

带你读懂 ButterKnife 的源码

反射机制

什么是反射机制

简单来说，放射可以帮助我们在动态运行的时候，对于任意一个类，可以获得其所有的方法（包括 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 thisdeclaredConstructor.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);

demo 下载地址

好了，今天就写这么多了，明天准备回一下家，接着回一下学校。下一篇准备写关于怎样编写自定义注解（基于编译时期的），敬且期待。

最后的最后，卖一下广告，欢迎大家关注我的微信公众号，扫一扫下方二维码或搜索微信号 stormjun，即可关注。目前专注于 Android 开发，主要分享 Android开发相关知识和一些相关的优秀文章，包括个人总结，职场经验等。

2 1