Java基礎之反射使用

最近看源碼時發現很多地方使用的反射機制，一直對這個反射機制不太清楚，今天花一點時間看了看，敲了敲反射的使用方法；
兩個類：Main.class，Person.class;
Main.class實現各種方法的測試。
Person三個私有成員變量：name、age、sex；其中sex的set方法為私有方法；其他getter和setter都是public;兩個構造函數，一個無參數，一個參數為name和age;

package reflect;

public class Person {
    private String name;
    private int age;
    private String sex;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private void setSex(String sex) {
        this.sex = sex;
    }

    public String getSex() {
        return sex;
    }

    public void sayPerson(String name, int age) {
        System.out.println(name+ "  " + age);
    }

    @Override
    public String toString() {
        return getName() + " " + getSex() + " " + getAge();
    }
}

構造函數的反射調用

  public static void testConstructor() {
        Class<?> person = null;

        try {
            //獲取到類對象
            person = Class.forName("reflect.Person");
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            //獲取構造函數（String,int）
            Constructor cons = person.getConstructor(String.class,int.class);
            System.out.println(cons.newInstance("AA", 15));

            //獲取無參構造函數()
            Constructor cons2 = person.getConstructor();
            System.out.println(cons2.newInstance());
        } catch (Exception e) {
            e.printStackTrace();
        }

        //獲取構造函數列表
        Constructor<?>[] t = person.getConstructors();
        for (Constructor a : t)
            System.out.println(a);
    }

輸出

AA null 15
null null 0
public reflect.Person(java.lang.String,int)
public reflect.Person()

成員變量的反射set和get

private static void testFeild() {
        //設置只有名字和年齡的對象
        Person person = new Person("AA", 12);
        try {
            person.getClass().getFields();
            //注意getDeclaredFields和 getFields的區別
            Field[] fields = person.getClass().getDeclaredFields();

            for (int i = 0; i < fields.length; i++) {
                //打印所有的成員變量
                System.out.println(fields[i]);
                //設置字段可訪問
                fields[i].setAccessible(true);
                //設置對象的成員變量值
                if (i == 0)
                    fields[i].set(person, "BB");
                else if (i == 1) {
                    fields[i].set(person, 17);
                } else if (i == 2) {
                    fields[i].set(person, "女");
                }
                //打印對象的成員變量值
                System.out.println(fields[i].get(person));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(person);
    }

輸出

public java.lang.String reflect.Person.name
BB
private int reflect.Person.age
int
17
private java.lang.String reflect.Person.sex
女
BB 女 17

成員方法的調用

    private static void testMethod() {
        Person person = new Person("AA", 12);
        try {
            Method method = person.getClass().getDeclaredMethod("setSex", String.class);
            //私有成員變量必須要設置可訪問才能調用
            method.setAccessible(true);
            method.invoke(person, "男");
            System.out.println(person);

            Method method1 = person.getClass().getDeclaredMethod("sayPerson", String.class, int.class);
            method1.invoke(person, "張三", 22);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

輸出

AA 男 12
張三 22

getDeclaredFields和 getFields的區別

    private static void testAiffGetFeildsAndGetDeclaredFields() {
        //設置只有名字和年齡的對象
        Person person = new Person("AA", 12);
        try {
            person.getClass().getFields();
            //注意getDeclaredFields和 getFields的區別
            Field[] fields = person.getClass().getDeclaredFields();
            Field[] fields2 = person.getClass().getFields();

            for (int i = 0; i < fields.length; i++) {
                System.out.println(fields[i]);
            }
            for (int i = 0; i < fields.length; i++) {
                System.out.println(fields2[i]);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
  }

輸出

private java.lang.String reflect.Person.name
private int reflect.Person.age
private java.lang.String reflect.Person.sex

可以看到輸出的只有三個，也就是說fields2 為空；我們將Person的name字段更改為public，再進行測試輸出如下：

public java.lang.String reflect.Person.name
private int reflect.Person.age
private java.lang.String reflect.Person.sex
public java.lang.String reflect.Person.name

輸出4個數據，其中為name的數據顯示的兩條，此兩條數據都是public類型；
因此getFields獲取的數據為public字段，getDeclaredFields則獲取了所有的字段；

getEnclosingClass()、getEnclosingConstructor()、getEnclosingMethod()的區別；

都是與內部類所在代碼位置相關的函數；
getEnclosingClass()：獲取該類在那個類中定義；
getEnclosingConstructor():該類在哪個構造函數中定義；
getEnclosingMethod():該類在哪個方法中定義的；

invoke方法分析

@CallerSensitive
    public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        MethodAccessor ma = methodAccessor;             // read volatile
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }

override是什么呢，查看源碼是 method.setAccessible(true)設置該值,當設置為true，就可以忽略權限進行訪問，這也就是為什么private要訪問必須設置此標志的原因；
Reflection.quickCheckMemberAccess(clazz, modifiers)代碼查看，確實是判斷是不是public成員的:

public static boolean quickCheckMemberAccess(Class<?> var0, int var1) {
     return Modifier.isPublic(getClassAccessFlags(var0) & var1);
}

checkAccess(caller, clazz, obj, modifiers);是判斷不是public情況下，是否為該類（有可以子類的情況），再去判斷是不是protected,同時對該類進行緩存，下一次調用此類就可以直接使用;
MethodAccessor是方法訪問對象接口，在為null的情況下通過acquireMethodAccessor()函數實例化實現類；最后調用實現類的invoke;acquireMethodAccessor()代碼如下：

 private MethodAccessor acquireMethodAccessor() {
        // First check to see if one has been created yet, and take it
        // if so
        MethodAccessor tmp = null;
        if (root != null) tmp = root.getMethodAccessor();/*此處的root就是該方法對象*/
        if (tmp != null) {
            methodAccessor = tmp;
        } else {
            // Otherwise fabricate one and propagate it up to the root
            tmp = reflectionFactory.newMethodAccessor(this);
            setMethodAccessor(tmp);
        }
        return tmp;
    }

該方法以工廠模式ReflectionFactory來獲得MethodAccessor 對象，
tmp = reflectionFactory.newMethodAccessor(this);

   public MethodAccessor newMethodAccessor(Method var1) {
        checkInitted();
        if (noInflation && !ReflectUtil.isVMAnonymousClass(var1.getDeclaringClass())) {
            return (new MethodAccessorGenerator()).generateMethod(var1.getDeclaringClass(), var1.getName(), var1.getParameterTypes(), var1.getReturnType(), var1.getExceptionTypes(), var1.getModifiers());
        } else {
            NativeMethodAccessorImpl var2 = new NativeMethodAccessorImpl(var1);
            DelegatingMethodAccessorImpl var3 = new DelegatingMethodAccessorImpl(var2);
            var2.setParent(var3);
            return var3;
        }
    }

如果noInflation的屬性為true,則直接返回MethodAccessorGenerator創建的一個MethodAccessor。
否則返回DelegatingMethodAccessorImpl，并將他與一個NativeMethodAccessorImpl互相引用。但DelegatingMethodAccessorImpl執行invoke方法的時候又委托給NativeMethodAccessorImpl，因此最終是NativeMethodAccessorImpl調用了的invoke()。NativeMethodAccessorImpl的invoke代碼如下：

    public Object invoke(Object var1, Object[] var2) throws IllegalArgumentException, InvocationTargetException {
        if (++this.numInvocations > ReflectionFactory.inflationThreshold() && !ReflectUtil.isVMAnonymousClass(this.method.getDeclaringClass())) {
            MethodAccessorImpl var3 = (MethodAccessorImpl)(new MethodAccessorGenerator()).generateMethod(this.method.getDeclaringClass(), this.method.getName(), this.method.getParameterTypes(), this.method.getReturnType(), this.method.getExceptionTypes(), this.method.getModifiers());
            this.parent.setDelegate(var3);
        }

        return invoke0(this.method, var1, var2);
    }

其中numInvocations 是對該方法的調用次數的累積，若是numInvocations 計數調用次數超過ReflectionFactory.inflationThreshold()==15，則更改DelegatingMethodAccessorImpl的委托對象，由new MethodAccessorGenerator()生成的MethodAccessor對象代理，調用其invoke();

為什么要有這個15次的計數呢？這就是MethodAccessorGenerator()生成的MethodAccessor與NativeMethodAccessorImpl生成的MethodAccessor有區別；什么區別呢？
可以看到MethodAccessorGenerator()是通過java直接生成的，NativeMethodAccessorImpl則是用native生成的；
Java實現的版本在初始化時需要較多時間，但長久來說性能較好；native版本正好相反，啟動時相對較快，但運行時間長了之后速度就比不過Java版了。這是HotSpot的優化方式帶來的性能特性，同時也是許多虛擬機的共同點：跨越native邊界會對優化有阻礙作用，它就像個黑箱一樣讓虛擬機難以分析也將其內聯，于是運行時間長了之后反而是托管版本的代碼更快些。
為保持最好特性，前15次使用native，之后使用java版本；

該方法學習根據源碼結合寂靜沙灘的JAVA深入研究——Method的Invoke方法]

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • /Library/Java/JavaVirtualMachines/jdk-9.jdk/Contents/Home...
    光劍書架上的書閱讀 3,923評論 2贊 8
  • 1. Java基礎部分 基礎部分的順序：基本語法，類相關的語法，內部類的語法，繼承相關的語法，異常的語法，線程的語...
    子非魚_t_閱讀 31,754評論 18贊 399
  • Spring Cloud為開發人員提供了快速構建分布式系統中一些常見模式的工具（例如配置管理，服務發現，斷路器，智...
    卡卡羅2017閱讀 134,869評論 18贊 139
  • 一：java概述：1，JDK：Java Development Kit，java的開發和運行環境，java的開發工...
    ZaneInTheSun閱讀 2,687評論 0贊 11
  • 清晨，我路過 高高掛在樹間的鐵籠， 聽到那清脆的啼鳴。 ——清脆！ 讓我禁不住為之動容。 可我不敢想象， 在那狹小...
    沂河生閱讀 175評論 0贊 1