Java反射技術詳解

Posted on 2021-11-08 by WalkonNet

前言

相信很多人都知道反射可以說是Java中最強大的技術瞭，它可以做的事情太多太多，很多優秀的開源框架都是通過反射完成的，比如最初的很多註解框架，後來因為java反射影響性能，所以被運行時註解APT替代瞭，java反射有個開源框架jOOR相信很多人都用過，不過我們還是要學習反射的基礎語法，這樣才能自己寫出優秀的框架，當然這裡所講的反射技術，是學習Android插件化技術、Hook技術等必不可少的！

一、基本反射技術

1.1 根據一個字符串得到一個類

getClass方法

 String name = "Huanglinqing";
 Class c1 = name.getClass();
 System.out.println(c1.getName());

打印結果如下：

Class.forName

比如我們獲取java.lang.String的類名

   String name = "java.lang.String";
   Class c1 = null;
   try {
          c1 = Class.forName(name);
          System.out.println(c1.getName());
      } catch (ClassNotFoundException e) {
  }

這裡也通過捕獲異常，因為我們傳的這個字符串可能不合法，字符串合法命名是類的命名空間和類的名稱組成

打印結果如下：

我們還可以通過c1.getSuperclass()獲取到他的父類

Type屬性

基本類型都有type屬性，可以得到這個基本類型的類型，比如：

Class c1 = Boolean.TYPE;
Class c2 = Byte.TYPE;
Class c3 = Float.TYPE;
Class c4 = Double.TYPE;

二、獲取類的成員

當類中方法定義為私有的時候我們能調用？不能！當變量是私有的時候我們能獲取嗎？不能！但是反射可以，比如源碼中有你需要用到的方法，但是那個方法是私有的，這個時候你就可以通過反射去執行這個私有方法，並且獲取私有變量。

獲取類的構造函數

為瞭便於測試，我們定義一個Test類，Test類如下：（省略get和set方法）

Test類中我們定義是三個私有變量，生成兩個公有的含參構造方法和一個私有的含參構造方法以及一個公有的無參構造方法。

public class Test {
    private int age;
    private String name;
    private int testint;
    public Test(int age) {
        this.age = age;
    }
    public Test(int age, String name) {
        this.age = age;
        this.name = name;
    }
    private Test(String name) {
        this.name = name;
    }
    public Test() {
    }

下面我們通過反射獲取這些構造方法

獲取類的所有構造方法

 Test test = new Test();
 Class c4 = test.getClass();
 Constructor[] constructors ;
 constructors = c4.getDeclaredConstructors();

通過getDeclaredConstructors可以返回類的所有構造方法，返回的是一個數組因為構造方法可能不止一個，通過getModifiers可以得到構造方法的類型，getParameterTypes可以得到構造方法的所有參數，返回的是一個Class數組，所以我們如果想獲取所有構造方法以及每個構造方法的參數類型，可以有如下代碼：

  for (int i = 0; i < constructors.length; i++) {
        System.out.print(Modifier.toString(constructors[i].getModifiers()) + "參數：");
        Class[] parametertypes = constructors[i].getParameterTypes();
        for (int j = 0; j < parametertypes.length; j++) {
             System.out.print(parametertypes[j].getName() + " ");
       }
      System.out.println("");
  }

運行結果如下所示：

這樣我們就得到瞭類中所有構造方法和構造方法中的參數，那麼我們如何獲取特定的構造方法呢？

獲取類中特定的構造方法

我們可以通過getConstructors方法獲取類中所有的public類型的構造方法，代碼和上面一樣就不演示瞭。

我們可以通過getDeclaredConstructor()方法傳參獲取特定參數類型的構造方法，這裡註意是getDeclaredConstructor()不是 getDeclaredConstructors() ，所以返回的是一個Class對象而不是一個Class數組。

獲取無參構造方法直接不傳參數，如下所示:

   try {
          constructors = c4.getDeclaredConstructor();
          System.out.print(Modifier.toString(constructors.getModifiers()) + );
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
      }

這裡要進行異常捕獲，因為可能不存在對應的構造方法，打印結果如下：

如果我們想獲取有兩個參數分別為int和String類型的構造方法，代碼如下：

  Class[] p = {int.class,String.class};
  try {
       constructors = c4.getDeclaredConstructor(p);
       System.out.print(Modifier.toString(constructors.getModifiers()) + "參數:");
       Class[] parametertypes = constructors.getParameterTypes();
       for (int j = 0; j < parametertypes.length; j++) {
            System.out.print(parametertypes[j].getName() + " ");
          }
       } catch (NoSuchMethodException e) {
            e.printStackTrace();
     }

這裡我們同樣打印出構造方法的參數：

調用構造方法

從這裡開始慢慢到瞭關鍵的一步，得到類的實例，我們主要借助於newInstance方法，為瞭方便演示我們將測試類的兩個構造方法打印出來.

   public Test(int age, String name) {
        this.age = age;
        this.name = name;
        System.out.println("hello" + name + "i am" + age);
    }
    private Test(String name) {
        this.name = name;
        System.out.println("My Name is" +
                name);
    }

我們先來調用public的方法，如下所示：

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

運行打印結果如下：

那麼調用私有構造方法呢，和上面一樣，隻是我們要設置constructors.setAccessible(true);代碼如下：

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

打印結果如下：

調用類的私有方法

如何調用類中的私有方法呢，我們先在測試類中編寫一個測試的私有方法如下：

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

我們知道如果我們要正常的調用類的方法都是通過類.方法調用，所以我們調用私有方法也需要得到類的實例，而我們上面newInstace已經得到瞭類的實例，這樣就好辦瞭。

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

我們首先通過 getDeclaredMethod方法獲取到這個私有方法，第一個參數是方法名，第二個參數是參數類型

然後通過invoke方法執行，invoke需要兩個參數一個是類的實例，一個是方法參數。

     Class[] p4 = {String.class};
     Method method = c4.getDeclaredMethod("welcome",p4);
     method.setAccessible(true);
     Object arg1s[] = {"歡迎關註代碼男人技術公眾號"};
     method.invoke(test,arg1s);

test類的實例當不能new 獲取的時候我們也可以通過反射獲取，就是上面的newInstance方法。

打印結果如下：

獲取類的私有字段並修改值

看到這裡你可能會說，有瞭set方法，什麼私有不私有，test.set不就可以瞭，但是這裡要註意我們是沒有辦法得到這個類的實例的，要不然都可以得到實例就沒有反射一說瞭。我們在通過反射得到類的實例之後先獲取字段：

Field field = c4.getDeclaredField("name");
field.setAccessible(true);
field.set(o,"代碼男人");

是我們上面通過反射構造方法獲取的實例，打印field.get(o).toString()的值如下：

不過要註意的是我們修改瞭name的值隻對當前的實例對象有效。

Java的基本反射語法就是這樣瞭，歡迎加入技術群一起探討！

最後反射封裝類如下：

package jnidemo.hlq.com.hookdemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * @author Huanglinqing
 * @date 2019/4/28
 */
public class Reflex {
    /**
     * 獲取無參構造函數
     * @param className
     * @return
     */
    public static Object createObject(String className) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};
        try {
            Class r = Class.forName(className);
            return createObject(r, pareTyples, pareVaules);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 獲取無參構造方法
     * @param clazz
     * @return
     */
    public static Object createObject(Class clazz) {
        Class[] pareTyple = new Class[]{};
        Object[] pareVaules = new Object[]{};
        return createObject(clazz, pareTyple, pareVaules);
    }
    /**
     * 獲取一個參數的構造函數  已知className
     *
     * @param className
     * @param pareTyple
     * @param pareVaule
     * @return
     */
    public static Object createObject(String className, Class pareTyple, Object pareVaule) {
        Class[] pareTyples = new Class[]{pareTyple};
        Object[] pareVaules = new Object[]{pareVaule};
        try {
            Class r = Class.forName(className);
            return createObject(r, pareTyples, pareVaules);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 獲取單個參數的構造方法 已知類
     *
     * @param clazz
     * @param pareTyple
     * @param pareVaule
     * @return
     */
    public static Object createObject(Class clazz, Class pareTyple, Object pareVaule) {
        Class[] pareTyples = new Class[]{pareTyple};
        Object[] pareVaules = new Object[]{pareVaule};
        return createObject(clazz, pareTyples, pareVaules);
    }
    /**
     * 獲取多個參數的構造方法 已知className
     * @param className
     * @param pareTyples
     * @param pareVaules
     * @return
     */
    public static Object createObject(String className, Class[] pareTyples, Object[] pareVaules) {
        try {
            Class r = Class.forName(className);
            return createObject(r, pareTyples, pareVaules);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 獲取構造方法
     *
     * @param clazz
     * @param pareTyples
     * @param pareVaules
     * @return
     */
    public static Object createObject(Class clazz, Class[] pareTyples, Object[] pareVaules) {
        try {
            Constructor ctor = clazz.getDeclaredConstructor(pareTyples);
            ctor.setAccessible(true);
            return ctor.newInstance(pareVaules);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 獲取多個參數的方法
     * @param obj
     * @param methodName
     * @param pareTyples
     * @param pareVaules
     * @return
     */
    public static Object invokeInstanceMethod(Object obj, String methodName, Class[] pareTyples, Object[] pareVaules) {
        if (obj == null) {
            return null;
        }
        try {
            //調用一個private方法 //在指定類中獲取指定的方法
            Method method = obj.getClass().getDeclaredMethod(methodName, pareTyples);
            method.setAccessible(true);
            return method.invoke(obj, pareVaules);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 獲取一個參數的方法
     * @param obj
     * @param methodName
     * @param pareTyple
     * @param pareVaule
     * @return
     */
    public static Object invokeInstanceMethod(Object obj, String methodName, Class pareTyple, Object pareVaule) {
        Class[] pareTyples = {pareTyple};
        Object[] pareVaules = {pareVaule};
        return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
    }
    /**
     * 獲取無參方法
     * @param obj
     * @param methodName
     * @return
     */
    public static Object invokeInstanceMethod(Object obj, String methodName) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};
        return invokeInstanceMethod(obj, methodName, pareTyples, pareVaules);
    }
    /**
     * 無參靜態方法
     * @param className
     * @param method_name
     * @return
     */
    public static Object invokeStaticMethod(String className, String method_name) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};
        return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
    }
    /**
     * 獲取一個參數的靜態方法
     * @param className
     * @param method_name
     * @param pareTyple
     * @param pareVaule
     * @return
     */
    public static Object invokeStaticMethod(String className, String method_name, Class pareTyple, Object pareVaule) {
        Class[] pareTyples = new Class[]{pareTyple};
        Object[] pareVaules = new Object[]{pareVaule};
        return invokeStaticMethod(className, method_name, pareTyples, pareVaules);
    }
    /**
     * 獲取多個參數的靜態方法
     * @param className
     * @param method_name
     * @param pareTyples
     * @param pareVaules
     * @return
     */
    public static Object invokeStaticMethod(String className, String method_name, Class[] pareTyples, Object[] pareVaules) {
        try {
            Class obj_class = Class.forName(className);
            return invokeStaticMethod(obj_class, method_name, pareTyples, pareVaules);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 無參靜態方法
     * @param method_name
     * @return
     */
    public static Object invokeStaticMethod(Class clazz, String method_name) {
        Class[] pareTyples = new Class[]{};
        Object[] pareVaules = new Object[]{};
        return invokeStaticMethod(clazz, method_name, pareTyples, pareVaules);
    }
    /**
     * 一個參數靜態方法
     * @param clazz
     * @param method_name
     * @param classType
     * @param pareVaule
     * @return
     */
    public static Object invokeStaticMethod(Class clazz, String method_name, Class classType, Object pareVaule) {
        Class[] classTypes = new Class[]{classType};
        Object[] pareVaules = new Object[]{pareVaule};
        return invokeStaticMethod(clazz, method_name, classTypes, pareVaules);
    }
    /**
     * 多個參數的靜態方法
     * @param clazz
     * @param method_name
     * @param pareTyples
     * @param pareVaules
     * @return
     */
    public static Object invokeStaticMethod(Class clazz, String method_name, Class[] pareTyples, Object[] pareVaules) {
        try {
            Method method = clazz.getDeclaredMethod(method_name, pareTyples);
            method.setAccessible(true);
            return method.invoke(null, pareVaules);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static Object getFieldObject(String className, Object obj, String filedName) {
        try {
            Class obj_class = Class.forName(className);
            return getFieldObject(obj_class, obj, filedName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static Object getFieldObject(Class clazz, Object obj, String filedName) {
        try {
            Field field = clazz.getDeclaredField(filedName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static void setFieldObject(Class clazz, Object obj, String filedName, Object filedVaule) {
        try {
            Field field = clazz.getDeclaredField(filedName);
            field.setAccessible(true);
            field.set(obj, filedVaule);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void setFieldObject(String className, Object obj, String filedName, Object filedVaule) {
        try {
            Class obj_class = Class.forName(className);
            setFieldObject(obj_class, obj, filedName, filedVaule);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static Object getStaticFieldObject(String className, String filedName) {
        return getFieldObject(className, null, filedName);
    }
    public static Object getStaticFieldObject(Class clazz, String filedName) {
        return getFieldObject(clazz, null, filedName);
    }
    public static void setStaticFieldObject(String classname, String filedName, Object filedVaule) {
        setFieldObject(classname, null, filedName, filedVaule);
    }
    public static void setStaticFieldObject(Class clazz, String filedName, Object filedVaule) {
        setFieldObject(clazz, null, filedName, filedVaule);
    }
}

總結

本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！

Java反射技術詳解

目錄

前言

一、基本反射技術

1.1 根據一個字符串得到一個類

getClass方法

Class.forName

Type屬性

二、獲取類的成員

獲取類中特定的構造方法

調用構造方法

調用類的私有方法

獲取類的私有字段並修改值

總結

推薦閱讀：

發佈留言取消回覆

近期文章

目錄

前言

一、基本反射技術

1.1 根據一個字符串得到一個類

getClass方法

Class.forName

Type屬性

二、獲取類的成員

獲取類中特定的構造方法

調用構造方法

調用類的私有方法

獲取類的私有字段並修改值

總結

推薦閱讀：

發佈留言 取消回覆

近期文章

標籤

發佈留言取消回覆