前言

相信很多人都知道反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的，比如最初的很多注解框架，后来因为java反射影响性能，所以被运行时注解APT替代了，java反射有个开源框架jOOR相信很多人都用过，不过我们还是要学习反射的基础语法，这样才能自己写出优秀的框架，当然这里所讲的反射技术，是学习Android插件化技术、Hook技术等必不可少的！

一、基本反射技术

1.1 根据一个字符串得到一个类

getClass方法

  1.  String name = "Huanglinqing";
  2.  Class c1 = name.getClass();
  3.  System.out.println(c1.getName());
  1.  打印结果如下：<br />    ![](https://cdn.nlark.com/yuque/0/2020/png/2332604/1599993365257-9ddb8dec-da9b-434d-a779-44318878596f.png#align=left&display=inline&height=114&margin=%5Bobject%20Object%5D&originHeight=114&originWidth=498&size=0&status=done&style=none&width=498)

Class.forName

  1. 比如我们获取java.lang.String的类名 
  1.    String name = "java.lang.String";
  2.    Class c1 = null;
  3.    try {
  4.           c1 = Class.forName(name);
  5.           System.out.println(c1.getName());
  6.       } catch (ClassNotFoundException e) {
  7.   }
  1. 这里也通过捕获异常，因为我们传的这个字符串可能不合法，字符串合法命名是类的命名空间和类的名称组成<br />    打印结果如下：<br />    ![](https://cdn.nlark.com/yuque/0/2020/png/2332604/1599993365302-75a7dacb-53ee-4e35-978b-455b52ae1a42.png#align=left&display=inline&height=119&margin=%5Bobject%20Object%5D&originHeight=119&originWidth=664&size=0&status=done&style=none&width=664)<br />   我们还可以通过c1.getSuperclass()获取到他的父类<br />   **Type属性**<br />    基本类型都有type属性，可以得到这个基本类型的类型，比如：
  1. Class c1 = Boolean.TYPE;
  2. Class c2 = Byte.TYPE;
  3. Class c3 = Float.TYPE;
  4. Class c4 = Double.TYPE;
  1. 停停停！这些东西有啥子用，如此鸡肋！ 别急，一切都是为后续做准备。

二、获取类的成员

  1.      当类中方法定义为私有的时候我们能调用？不能！当变量是私有的时候我们能获取吗？不能！但是反射可以，比如源码中有你需要用到的方法，但是那个方法是私有的，这个时候你就可以通过反射去执行这个私有方法，并且获取私有变量。

获取类的构造函数

为了便于测试，我们定义一个Test类，Test类如下：（省略get和set方法）
Test类中我们定义是三个私有变量，生成两个公有的含参构造方法和一个私有的含参构造方法以及一个公有的无参构造方法。

  1. public class Test {
  3.     private int age;
  4.     private String name;
  5.     private int testint;
  7.     public Test(int age) {
  8.         this.age = age;
  9.     }
  11.     public Test(int age, String name) {
  12.         this.age = age;
  13.         this.name = name;
  14.     }
  16.     private Test(String name) {
  17.         this.name = name;
  18.     }
  20.     public Test() {
  21.     }
  1.   下面我们通过反射获取这些构造方法<br />       **获取类的所有构造方法**
  1.  Test test = new Test();
  2.  Class c4 = test.getClass();
  3.  Constructor[] constructors ;
  4.  constructors = c4.getDeclaredConstructors();
  • 通过getDeclaredConstructors可以返回类的所有构造方法，返回的是一个数组因为构造方法可能不止一个，
  • 通过getModifiers可以得到构造方法的类型，
  • getParameterTypes可以得到构造方法的所有参数，返回的是一个Class数组，

所以我们如果想获取所有构造方法以及每个构造方法的参数类型，可以有如下代码：

  1.   for (int i = 0; i < constructors.length; i++) {
  2.         System.out.print(Modifier.toString(constructors[i].getModifiers()) + "参数：");
  3.         Class[] parametertypes = constructors[i].getParameterTypes();
  4.         for (int j = 0; j < parametertypes.length; j++) {
  5.              System.out.print(parametertypes[j].getName() + " ");
  6.        }
  7.       System.out.println("");
  8.   }
  1. 运行结果如下所示：<br />    ![](https://cdn.nlark.com/yuque/0/2020/png/2332604/1599993365304-e1c1cfd4-48ef-43f8-b0e1-19128e6f84f3.png#align=left&display=inline&height=184&margin=%5Bobject%20Object%5D&originHeight=184&originWidth=512&size=0&status=done&style=none&width=512)<br />    这样我们就得到了类中所有构造方法和构造方法中的参数，那么我们如何获取特定的构造方法呢？<br />   ** 获取类中特定的构造方法**<br />    我们可以通过getConstructors方法获取类中 所有的public类型的构造方法，代码和上面一样就不演示了。<br />    我们可以通过getDeclaredConstructor()方法传参获取特定参数类型的构造方法，这里注意是getDeclaredConstructor()不是  getDeclaredConstructors() ，所以返回的是一个Class对象而不是一个Class数组。<br />    获取无参构造方法直接不传参数，如下所示:
  1. try {
  2.     constructors = c4.getDeclaredConstructor();
  3.     System.out.print(Modifier.toString(constructors.getModifiers()) + );
  4. } catch (NoSuchMethodException e) {
  5.     e.printStackTrace();
  6. }
  1. 这里要进行异常捕获，因为可能不存在对应的构造方法，打印结果如下：  <br />    <br />![](https://cdn.nlark.com/yuque/0/2020/png/2332604/1599993365303-79edc7e1-95df-48b0-9e90-e42273fbd167.png#align=left&display=inline&height=137&margin=%5Bobject%20Object%5D&originHeight=137&originWidth=734&size=0&status=done&style=none&width=734)<br />   如果我们想获取有两个参数分别为int和String类型的构造方法，代码如下：
  1.   Class[] p = {int.class,String.class};
  2.   try {
  3.        constructors = c4.getDeclaredConstructor(p);
  4.        System.out.print(Modifier.toString(constructors.getModifiers()) + "参数:");
  5.        Class[] parametertypes = constructors.getParameterTypes();
  6.        for (int j = 0; j < parametertypes.length; j++) {
  7.             System.out.print(parametertypes[j].getName() + " ");
  8.           }
  9.        } catch (NoSuchMethodException e) {
  10.             e.printStackTrace();
  11.      }

这里我们同样打印出构造方法的参数：
反射 - 图1
调用构造方法
从这里开始慢慢到了关键的一步，得到类的实例，我们主要借助于newInstance方法，为了方便演示我们将测试类的两个构造方法打印出来. 

  1.    public Test(int age, String name) {
  2.         this.age = age;
  3.         this.name = name;
  4.         System.out.println("hello" + name + "i am" + age);
  5.     }
  8.     private Test(String name) {
  9.         this.name = name;
  10.         System.out.println("My Name is" +
  11.                 name);
  12.     }

我们先来调用public的方法，如下所示：

  1.  Class[] p = {int.class,String.class};
  2.  constructors = c4.getDeclaredConstructor(p);
  3.  constructors.newInstance(24,"HuangLinqing");

运行打印结果如下：
反射 - 图2
那么调用私有构造方法呢，和上面一样，只是我们要设置constructors.setAccessible(true);代码如下：

  1.   Class[] p = {String.class};
  2.   constructors = c4.getDeclaredConstructor(p);
  3.   constructors.setAccessible(true);
  4.   constructors.newInstance("HuangLinqing");

打印结果如下：
反射 - 图3
调用类的私有方法
如何调用类中的私有方法呢，我们先在测试类中编写一个测试的私有方法 如下：

  1. 1.   private void welcome(String tips){
  2. 2.         System.out.println(tips);
  3. 3.     }

我们知道如果我们要正常的调用类的方法都是通过类.方法调用，所以我们调用私有方法也需要得到类的实例，而我们上面newInstace已经得到了类的实例，这样就好办了。

  1. 1.    Class[] p4 = {String.class};
  2. 2.    Method method = c4.getDeclaredMethod("welcome",p4);
  3. 3.    method.setAccessible(true);

我们首先通过 getDeclaredMethod方法获取到这个私有方法，第一个参数是方法名，第二个参数是参数类型
然后通过invoke方法执行，invoke需要两个参数一个是类的实例，一个是方法参数。

  1. 1.      Class[] p4 = {String.class};
  2. 2.      Method method = c4.getDeclaredMethod("welcome",p4);
  3. 3.      method.setAccessible(true);
  4. 4.      Object arg1s[] = {"欢迎关注代码男人技术公众号"};
  5. 5.      method.invoke(test,arg1s);
  1.  test类的实例当不能new 获取的时候我们也可以通过反射获取，就是上面的newInstance方法。打印结果如下：<br />    ![](https://cdn.nlark.com/yuque/0/2020/png/2332604/1599993365392-ac22c306-1743-4213-8a2e-d7661cf4cc2b.png#align=left&display=inline&height=121&margin=%5Bobject%20Object%5D&originHeight=121&originWidth=419&size=0&status=done&style=none&width=419)<br />** 获取类的私有字段并修改值**<br />**  **看到这里你可能会说，有了set方法，什么私有不私有，test.set不就可以了，但是这里要注意我们是没有办法得到这个类的实例的，要不然都可以得到实例就没有反射一说了。我们在通过反射得到类的实例之后先获取字段：
  1. 1. Field field = c4.getDeclaredField("name");
  2. 2. field.setAccessible(true);
  3. 3. field.set(o,"代码男人");

o是我们上面通过反射构造方法获取的实例， 打印field.get(o).toString()的值如下：

反射 - 图4
不过要注意的是我们修改了name的值只对当前的实例对象有效。

Java的基本反射语法就是这样了，欢迎加入技术群一起探讨！
最后反射封装类如下：

  1. package jnidemo.hlq.com.hookdemo;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  7. /**
  8.  * @author Huanglinqing
  9.  * @date 2019/4/28
  10.  */
  12. public class Reflex {
  14.     /**
  15.      * 获取无参构造函数
  16.      * @param className
  17.      * @return
  18.      */
  19.     public static Object createObject(String className) {
  20.         Class[] pareTyples = new Class[]{};
  21.         Object[] pareVaules = new Object[]{};
  23.         try {
  24.             Class r = Class.forName(className);
  25.             return createObject(r, pareTyples, pareVaules);
  26.         } catch (ClassNotFoundException e) {
  27.             e.printStackTrace();
  28.         }
  30.         return null;
  31.     }
  33.     /**
  34.      * 获取无参构造方法
  35.      * @param clazz
  36.      * @return
  37.      */
  38.     public static Object createObject(Class clazz) {
  39.         Class[] pareTyple = new Class[]{};
  40.         Object[] pareVaules = new Object[]{};
  42.         return createObject(clazz, pareTyple, pareVaules);
  43.     }
  45.     /**
  46.      * 获取一个参数的构造函数  已知className
  47.      *
  48.      * @param className
  49.      * @param pareTyple
  50.      * @param pareVaule
  51.      * @return
  52.      */
  53.     public static Object createObject(String className, Class pareTyple, Object pareVaule) {
  55.         Class[] pareTyples = new Class[]{pareTyple};
  56.         Object[] pareVaules = new Object[]{pareVaule};
  58.         try {
  59.             Class r = Class.forName(className);
  60.             return createObject(r, pareTyples, pareVaules);
  61.         } catch (ClassNotFoundException e) {
  62.             e.printStackTrace();
  63.         }
  65.         return null;
  66.     }
  69.     /**
  70.      * 获取单个参数的构造方法 已知类
  71.      *
  72.      * @param clazz
  73.      * @param pareTyple
  74.      * @param pareVaule
  75.      * @return
  76.      */
  77.     public static Object createObject(Class clazz, Class pareTyple, Object pareVaule) {
  78.         Class[] pareTyples = new Class[]{pareTyple};
  79.         Object[] pareVaules = new Object[]{pareVaule};
  81.         return createObject(clazz, pareTyples, pareVaules);
  82.     }
  84.     /**
  85.      * 获取多个参数的构造方法 已知className
  86.      * @param className
  87.      * @param pareTyples
  88.      * @param pareVaules
  89.      * @return
  90.      */
  91.     public static Object createObject(String className, Class[] pareTyples, Object[] pareVaules) {
  92.         try {
  93.             Class r = Class.forName(className);
  94.             return createObject(r, pareTyples, pareVaules);
  95.         } catch (ClassNotFoundException e) {
  96.             e.printStackTrace();
  97.         }
  99.         return null;
  100.     }
  103.     /**
  104.      * 获取构造方法
  105.      *
  106.      * @param clazz
  107.      * @param pareTyples
  108.      * @param pareVaules
  109.      * @return
  110.      */
  111.     public static Object createObject(Class clazz, Class[] pareTyples, Object[] pareVaules) {
  112.         try {
  113.             Constructor ctor = clazz.getDeclaredConstructor(pareTyples);
  114.             ctor.setAccessible(true);
  115.             return ctor.newInstance(pareVaules);
  116.         } catch (Exception e) {
  117.             e.printStackTrace();
  118.         }
  120.         return null;
  121.     }
  124.     /**
  125.      * 获取多个参数的方法
  126.      * @param obj
  127.      * @param methodName
  128.      * @param pareTyples
  129.      * @param pareVaules
  130.      * @return
  131.      */
  132.     public static Object invokeInstanceMethod(Object obj, String methodName, Class[] pareTyples, Object[] pareVaules) {
  133.         if (obj == null) {
  134.             return null;
  135.         }
  137.         try {
  138.             //调用一个private方法 //在指定类中获取指定的方法
  139.             Method method = obj.getClass().getDeclaredMethod(methodName, pareTyples);
  140.             method.setAccessible(true);
  141.             return method.invoke(obj, pareVaules);
  143.         } catch (Exception e) {
  144.             e.printStackTrace();
  145.         }
  147.         return null;
  148.     }
  150.     /**
  151.      * 获取一个参数的方法
  152.      * @param obj
  153.      * @param methodName
  154.      * @param pareTyple
  155.      * @param pareVaule
  156.      * @return
  157.      */
  158.     public static Object invokeInstanceMethod(Object obj, String methodName, Class pareTyple, Object pareVaule) {
  159.         Class[] pareTyples = {pareTyple};
  160.         Object[] pareVaules = {pareVaule};
  162.         return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
  163.     }
  165.     /**
  166.      * 获取无参方法
  167.      * @param obj
  168.      * @param methodName
  169.      * @return
  170.      */
  171.     public static Object invokeInstanceMethod(Object obj, String methodName) {
  172.         Class[] pareTyples = new Class[]{};
  173.         Object[] pareVaules = new Object[]{};
  175.         return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
  176.     }
  179.     /**
  180.      * 无参静态方法
  181.      * @param className
  182.      * @param method_name
  183.      * @return
  184.      */
  185.     public static Object invokeStaticMethod(String className, String method_name) {
  186.         Class[] pareTyples = new Class[]{};
  187.         Object[] pareVaules = new Object[]{};
  189.         return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
  190.     }
  192.     /**
  193.      * 获取一个参数的静态方法
  194.      * @param className
  195.      * @param method_name
  196.      * @param pareTyple
  197.      * @param pareVaule
  198.      * @return
  199.      */
  200.     public static Object invokeStaticMethod(String className, String method_name, Class pareTyple, Object pareVaule) {
  201.         Class[] pareTyples = new Class[]{pareTyple};
  202.         Object[] pareVaules = new Object[]{pareVaule};
  204.         return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
  205.     }
  207.     /**
  208.      * 获取多个参数的静态方法
  209.      * @param className
  210.      * @param method_name
  211.      * @param pareTyples
  212.      * @param pareVaules
  213.      * @return
  214.      */
  215.     public static Object invokeStaticMethod(String className, String method_name, Class[] pareTyples, Object[] pareVaules) {
  216.         try {
  217.             Class obj_class = Class.forName(className);
  218.             return invokeStaticMethod(obj_class, method_name, pareTyples, pareVaules);
  219.         } catch (Exception e) {
  220.             e.printStackTrace();
  221.         }
  223.         return null;
  224.     }
  226.     /**
  227.      * 无参静态方法
  228.      * @param method_name
  229.      * @return
  230.      */
  231.     public static Object invokeStaticMethod(Class clazz, String method_name) {
  232.         Class[] pareTyples = new Class[]{};
  233.         Object[] pareVaules = new Object[]{};
  235.         return invokeStaticMethod(clazz, method_name, pareTyples, pareVaules);
  236.     }
  238.     /**
  239.      * 一个参数静态方法
  240.      * @param clazz
  241.      * @param method_name
  242.      * @param classType
  243.      * @param pareVaule
  244.      * @return
  245.      */
  246.     public static Object invokeStaticMethod(Class clazz, String method_name, Class classType, Object pareVaule) {
  247.         Class[] classTypes = new Class[]{classType};
  248.         Object[] pareVaules = new Object[]{pareVaule};
  250.         return invokeStaticMethod(clazz, method_name, classTypes, pareVaules);
  251.     }
  253.     /**
  254.      * 多个参数的静态方法
  255.      * @param clazz
  256.      * @param method_name
  257.      * @param pareTyples
  258.      * @param pareVaules
  259.      * @return
  260.      */
  261.     public static Object invokeStaticMethod(Class clazz, String method_name, Class[] pareTyples, Object[] pareVaules) {
  262.         try {
  263.             Method method = clazz.getDeclaredMethod(method_name, pareTyples);
  264.             method.setAccessible(true);
  265.             return method.invoke(null, pareVaules);
  266.         } catch (Exception e) {
  267.             e.printStackTrace();
  268.         }
  270.         return null;
  271.     }
  274.     public static Object getFieldObject(String className, Object obj, String filedName) {
  275.         try {
  276.             Class obj_class = Class.forName(className);
  277.             return getFieldObject(obj_class, obj, filedName);
  278.         } catch (ClassNotFoundException e) {
  279.             e.printStackTrace();
  280.         }
  281.         return null;
  282.     }
  284.     public static Object getFieldObject(Class clazz, Object obj, String filedName) {
  285.         try {
  286.             Field field = clazz.getDeclaredField(filedName);
  287.             field.setAccessible(true);
  288.             return field.get(obj);
  289.         } catch (Exception e) {
  290.             e.printStackTrace();
  291.         }
  293.         return null;
  294.     }
  297.     public static void setFieldObject(Class clazz, Object obj, String filedName, Object filedVaule) {
  298.         try {
  299.             Field field = clazz.getDeclaredField(filedName);
  300.             field.setAccessible(true);
  301.             field.set(obj, filedVaule);
  302.         } catch (Exception e) {
  303.             e.printStackTrace();
  304.         }
  305.     }
  307.     public static void setFieldObject(String className, Object obj, String filedName, Object filedVaule) {
  308.         try {
  309.             Class obj_class = Class.forName(className);
  310.             setFieldObject(obj_class, obj, filedName, filedVaule);
  311.         } catch (ClassNotFoundException e) {
  312.             e.printStackTrace();
  313.         }
  314.     }
  317.     public static Object getStaticFieldObject(String className, String filedName) {
  318.         return getFieldObject(className, null, filedName);
  319.     }
  321.     public static Object getStaticFieldObject(Class clazz, String filedName) {
  322.         return getFieldObject(clazz, null, filedName);
  323.     }
  325.     public static void setStaticFieldObject(String classname, String filedName, Object filedVaule) {
  326.         setFieldObject(classname, null, filedName, filedVaule);
  327.     }
  329.     public static void setStaticFieldObject(Class clazz, String filedName, Object filedVaule) {
  330.         setFieldObject(clazz, null, filedName, filedVaule);
  331.     }
  332. }