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