2. 程式人生 > >JavaReflect（Java反射機制）

JavaReflect（Java反射機制）

阿新 • • 發佈：2019-01-22

在我們做專案時有時為了優化開發效率通常會使用一些第三方框架，這些框架有網路請求、圖片處理、json解析、註解框架等等，尤其在我們想簡化程式碼提高開發效率時就會想到使用第三方的註解框架，比較流行的有butterknife、annotations、xutils等，在我們使用這些框架為我們帶來便利的同時，總是想了解一下它們的執行原理和機制，拿butterknife來說，想要寫出這樣一套框架出來必定要用到一些Java知識，其中就包括註解原理、Java的反射機制。

這篇文章先初步瞭解一下Java的反射機制：

1. 反射機制是什麼

反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意一個方法和屬性；這種動態獲取的資訊以及動態呼叫物件的方法的功能稱為java語言的反射機制。

2. 反射機制能做什麼

反射機制主要提供了以下功能：

  • 在執行時判斷任意一個物件所屬的類；
  • 在執行時構造任意一個類的物件；
  • 在執行時判斷任意一個類所具有的成員變數和方法；
  • 在執行時呼叫任意一個物件的方法；
  • 生成動態代理。

3.反射機制的相關API

java.lang.Class;
java.lang.reflect.Constructor; java.lang.reflect.Field;
java.lang.reflect.Method;
java.lang.reflect.Modifier;

以下將通過具體程式碼實現來說明反射機制可以做哪些事情

  • 通過一個物件（類）獲得完整的包名和類名

ReflectClass 程式碼

package com.yd.test.javareflect;

import java.io.Serializable;

public class ReflectClass extends BaseReflectClass implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private int intValue = 0;
    private String stringValue = null
 
;


    public void method01(){
        System.out.println("ReflectClass_01");
    }

    public void method02(){
        System.out.println("ReflectClass_02");
    }

    public void method03(int intValue, String stringValue){
        System.out.println("ReflectClass_Method03"+" intValue: "+intValue+" stringValue: "+ stringValue);
    }

    public void method04(){
        System.out.println("intValue: "+intValue+"stringValue: "+stringValue);
    }

}

BaseReflectClass 程式碼

package com.yd.test.javareflect;

public class BaseReflectClass {

    int BaseClassMod = 3;

    public void baseMethod(){

    }
}
  • 獲取類的完整包名
public static void main(String[] args) {
/** 獲取類的完整包名 */
ReflectClass reflectClass = new ReflectClass();     
        System.out.println(reflectClass.getClass().getName());
}

輸出：
com.yd.test.javareflect.ReflectClass
Class..getClass().getName()方法可獲取類的完整包名

  • 例項化物件
/** 三種例項化Class的方法 */
        Class class1 = null;
        Class class2 = null;
        Class class3 = null;
        try {
            class1 = Class.forName("com.yd.test.javareflect.ReflectClass");
            // java語言中任何一個java物件都有getClass 方法
            class2 = new ReflectClass().getClass();
            //java中每個型別都有class 屬性
            class3 = ReflectClass.class;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

以上三種例項化物件（類）的方式，一般我們用的比較多的也就是Class.forName(“xxx”)這種方式了，如果懶得去看包名，也可以用其它的方式。

  • 獲取物件實現的介面和繼承的類
/** 獲取物件實現的介面和繼承的類 */
        System.out.println(
                class1.getSuperclass().getName()+" / "
                        +class2.getSuperclass().getName()+" /  "
                        +class3.getSuperclass().getName()
                );

        Class classes[] = class1.getInterfaces();
        for (int i = 0; i < classes.length; i++) {
            System.out.println(classes[i].getName());
        }

輸出：
com.yd.test.javareflect.BaseReflectClass / com.yd.test.javareflect.BaseReflectClass / com.yd.test.javareflect.BaseReflectClass
java.io.Serializable
Class.getSuperclass().getName()可以獲取繼承了哪些類和實現的介面。

  • 例項化物件並給物件中的屬性賦值

User類程式碼

package com.yd.test.javareflect;

public class User {

    private int age;
    private String name;

    public User(){}

    public User(String name) {
        super();
        this.name = name;
    }

    public User(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return getName()+"/"+getAge();
    }
}
    /* 例項化物件並給物件中的屬性賦值 */
        Class c = null;
        try {
            c = Class.forName("com.yd.test.javareflect.User");
            // 例項化User物件
            User user = (User) c.newInstance();
            user.setAge(25);
            user.setName("danity");
            System.out.println(user.toString());

輸出：
danity/25

  • 獲取每個建構函式所需要的引數型別資訊
            Constructor<?> constructor[] = c.getConstructors();
            // 獲取每個建構函式所需要的引數型別資訊
            for (int i = 0; i < constructor.length; i++) {
            // getParameterTypes():獲取建構函式引數型別
                Class arrayClass[] = constructor[i].getParameterTypes();
                System.out.print("cons[" + i + "] (");
                for (int j = 0; j < arrayClass.length; j++) {
                    if (j == arrayClass.length - 1)
                        System.out.print(arrayClass[j].getName());
                    else
                        System.out.print(arrayClass[j].getName() + ", ");
                }
                System.out.println(")");
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

輸出：
cons[0] (java.lang.String)
cons[1] (int, java.lang.String)
cons[2] ()

以上可以看出，利用反射可以獲取類建構函式的引數型別資訊、對一個物件的屬性進行賦值，這也是比較常用的方法。

  • 獲取類的所有屬性
/* 獲取類的所有屬性 */
        try {
            Class rClass = Class.forName("com.yd.test.javareflect.ReflectClass");
            // Field: 獲取屬性，下面還會講到獲取類的方法，注意區分
            Field field[] = rClass.getDeclaredFields();
            for (int i = 0; i < field.length; i++) {
                System.out.println(field[i].getName());
                // 獲取修飾許可權符
                int mo = field[i].getModifiers();
                System.out.println("mo: "+mo);
                String priv = Modifier.toString(mo);
                // 屬性型別
                Class type = field[i].getType();
                System.out.println(priv + " " + type.getName() + " " + field[i].getName());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

輸出：
serialVersionUID
mo: 26
private static final long serialVersionUID
intValue
mo: 2
private int intValue
stringValue
mo: 2
private java.lang.String stringValue

  • 獲取父類和實現的介面的所有屬性

/* 獲取父類和實現的介面的所有屬性 */
        Class rClass = null;
        try {
            rClass = Class.forName("com.yd.test.javareflect.ReflectClass");
            Field field[] = rClass.getFields();
            for (int j = 0; j < field.length; j++) {
                System.out.println(field[j].getName());
                // 獲取修飾許可權符
                int mo = field[j].getModifiers();
                System.out.println("mo: "+mo);
                String priv = Modifier.toString(mo);
                // 屬性型別
                Class type = field[j].getType();
                System.out.println(priv + " " + type.getName() + " " + field[j].getName());
                }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
  • 獲取類的全部方法
package com.yd.test.javareflect;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Main2 {

    /**
     * @param args
     */
    public static void main(String[] args) {        
        try {
            Class fClass = Class.forName("com.yd.test.javareflect.ReflectClass");
            // Method[]: 方法陣列
            Method method[] = fClass.getMethods();
            for (int i = 0; i < method.length; i++) {
                // returnType :返回型別
                Class returnType = method[i].getReturnType();
                System.out.println("ReturnType: "+returnType);
                // 獲取引數型別
                Class para[] = method[i].getParameterTypes();

                int temp = method[i].getModifiers();
                System.out.print("Modifier.toString: "+Modifier.toString(temp) + " ");
                System.out.print(returnType.getName() + "  ");
                System.out.print(method[i].getName() + " ");
                System.out.print("(");
                for (int j = 0; j < para.length; ++j) {
                    System.out.print(para[j].getName() + " " + "arg" + j);
                    if (j < para.length - 1) {
                        System.out.print(",");
                    }
                }
                // 獲取異常型別
                Class<?> exce[] = method[i].getExceptionTypes();
                if (exce.length > 0) {
                    System.out.print(") throws ");
                    for (int k = 0; k < exce.length; ++k) {
                        System.out.print(exce[k].getName() + " ");
                        if (k < exce.length - 1) {
                            System.out.print(",");
                        }
                    }
                } else {
                    System.out.print(")");
                }
                System.out.println();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

}

輸出：
ReturnType: void
Modifier.toString: public void method01 ()
ReturnType: void
Modifier.toString: public void method02 ()
ReturnType: void
Modifier.toString: public void method03 (int arg0,java.lang.String arg1)
ReturnType: void
Modifier.toString: public void method04 ()
ReturnType: void
Modifier.toString: public void baseMethod ()
ReturnType: void
Modifier.toString: public final void wait () throws java.lang.InterruptedException
ReturnType: void
Modifier.toString: public final void wait (long arg0,int arg1) throws java.lang.InterruptedException
ReturnType: void
Modifier.toString: public final native void wait (long arg0) throws java.lang.InterruptedException
ReturnType: int
Modifier.toString: public native int hashCode ()
ReturnType: class java.lang.Class
Modifier.toString: public final native java.lang.Class getClass ()
ReturnType: boolean
Modifier.toString: public boolean equals (java.lang.Object arg0)
ReturnType: class java.lang.String
Modifier.toString: public java.lang.String toString ()
ReturnType: void
Modifier.toString: public final native void notify ()
ReturnType: void
Modifier.toString: public final native void notifyAll ()

資訊比較多，撿需要的資訊看

下面是Java反射比較重要的用法：

  • 通過反射給物件中的某個方法賦值傳值

ReflectClass 程式碼

package com.yd.test.javareflect;

import java.io.Serializable;

public class ReflectClass extends BaseReflectClass implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private int intValue = 0;
    private String stringValue = null;


    public void method01(){
        System.out.println("ReflectClass_01");
    }

    public void method02(){
        System.out.println("ReflectClass_02");
    }

    public void method03(int intValue, String stringValue){
        System.out.println("ReflectClass_Method03"+" intValue: "+intValue+" stringValue: "+ stringValue);
    }

    public void method04(){
        System.out.println("intValue: "+intValue+"stringValue: "+stringValue);
    }

}

public static void main(String[] args) {

        /**
         * 通過反射給物件類中的某個方法賦值傳值
         */
        try {
            Class<?> fclass = Class.forName("com.yd.test.javareflect.ReflectClass");
            // 呼叫ReflectClass的“method01方法”
            Method method = fclass.getMethod("method01");
            method.invoke(fclass.newInstance());
            // int.class, string.class 對應方法的引數型別，位置不能寫錯
            Method mod = fclass.getMethod("method03", int.class, String.class);
            mod.invoke(fclass.newInstance(),20,"test");

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
}

輸出：
ReflectClass_01
ReflectClass_Method03 intValue: 20 stringValue: test
從輸出內容來看，通過反射呼叫了類中的兩個方法並對方法引數進行了操作

  • 通過反射給物件類中某個屬性賦值
public static void main(String[] args) {
try {
            Class sClass = Class.forName("com.yd.test.javareflect.ReflectClass");
            //例項化這個類賦給obj
            Object obj = sClass.newInstance();
            Field field = sClass.getDeclaredField("intValue");
            //打破封裝 
            //使用反射機制可以打破封裝性，導致了java物件的屬性不安全。
            field.setAccessible(true);
            //給obj物件的intValue屬性賦值"3"
            field.set(obj, 3);
            // 列印值
            System.out.println(field.get(obj));

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
}

輸出：
3

以上是Java反射的基本用法，還有一些動態代理的用法有興趣的可以自己找找資料。
現在，離掌握註解知識又更近了一步……

相關推薦

JavaReflect（Java反射機制）

在我們做專案時有時為了優化開發效率通常會使用一些第三方框架，這些框架有網路請求、圖片處理、json解析、註解框架等等，尤其在我們想簡化程式碼提高開發效率時就會想到使用第三方的註解框架，比較流行的有butterknife、annotations、xutils等，在

軟體測試---私有方法的呼叫（Java反射機制）

1.私有構造方法如何例項化類？ public class MSD { private int a； private String b； //無參構造方法 private MSD() { } //有參構造方法 private MSD（int a, Strin

javase知識點 ----21 （理解反射機制）

1、反射的概念？    JAVA反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意一個方法和屬性；這種動態獲取資訊以及動態呼叫物件的方法的功能稱為java語言的反射機制。 2、如何做到反射？    當一個位元組碼檔

Java反射機制demo（五）—獲得並調用一個類中的方法

color 擁有 oca logs over super getmethod equals() bool 這個demo在使用反射機制操作屬性之前，主要原因是因為在.class文件字節碼中，方法排在屬性的前面。 1，獲得一個類中的方法 先看一下方法和運行結果。獲取所有的方

Java學習總結（十四）——java反射機制，利用反射動態創建對象

Java反射 動態創建對象 一．Java反射機制1.什麽是反射：反射就是把Java類中的各種成份影射成一個個的Java對象。例：一個類有：成員變量，方法，構造方法等，包等等信息，利用反射技術可以對一個類進行剖析，把各個組成部分影射成一個個對象。2.Java反射常用類：（1）Class類—可獲取類和類的

Java反射機制詳解（由淺入深）

一、什麼是Java反射機制？ Java 反射機制在程式執行時，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意一個方法和屬性。這種 動態的獲取資訊 以及 動態呼叫物件的方法 的功能稱為 java 的反

Java 反射機制詳解（一）

Java 反射機制詳解（一） 主要介紹以下幾方面內容 理解 Class 類 理解 Java 的類載入機制 學會使用 ClassLoader 進行類載入 理解反射的機制 掌握 Constructor、Method、Field 類的用法 理解並掌握動態代理&n

Java 反射機制詳解（四）

Java 反射機制詳解（四） 4. 反射與泛型  定義一個泛型類： public class DAO<T> { //根據id獲取一個物件 T get(Integer id){ return null; }

Java反射機制（超詳細）

文章目錄 反射機制是什麼 反射機制能做什麼 案例 通過一個物件獲得完整的包名和類名 例項化Class類物件 獲取一個物件的父類與實現的介面 通過反射機制例項化一個類的物件 獲取某個類的全部屬性 獲得某個

java反射機制一（反射的基本概念和理解）

反射就是對一個類進行解剖，把一個類中的各種成分對映成一個類 java程式執行位元組碼檔案的過程 1啟動jvm程序 2把所有相關的位元組碼加入記憶體（類載入器） 3.系統為每個位元組碼生成一個class物件 4初始化（靜態程式碼塊） 5靜態成員變數 得到一個類的C

Spring學習5（1）：IoC容器之IoC概述，JAVA反射機制，資源訪問器

spring學習5（1）  在經過了對spring框架基本開發的瞭解以及對spring boot流程的學習，《精通spring4.x…》這本書正式開始了spring的講解，我也跟隨著這本書的腳步進行學習。 IoC概述  首先需要學習的是spring的IoC技術，

java反射機制詳解（二）

主要介紹以下幾方面內容 理解 Class 類 理解 Java 的類載入機制 學會使用 ClassLoader 進行類載入 理解反射的機制 掌握 Constructor、Method、Field 類的用法 理解並掌握動態代理 1.理解Class類 　

（小工具）Java反射機制實現任意物件集合按指定任意欄位進行分組通用程式實踐

在應用開發的時候，我們有時候會遇到需要對一個給定集合進行分組的情況。如果該集合的資料記錄是從資料庫的獲取，通常我們最簡單的方案是直接在sql層面select後group by完成。 但是，假如某些場景下該資料不是從資料庫獲取呢？那就需要在應用程式層面進行分

（小工具）Java反射機制實現任意物件集合排序並且獲取排列名次的通用程式實踐

在應用開發的時候，我們有時候會遇到需要對一個給定集合進行排序的情況。如果該集合的資料記錄是從資料庫的獲取，通常我們最簡單的方案是直接在sql層面select後order by完成。 但是，假如某些場景下該資料不是從資料庫獲取呢？那就需要在應用程式層面進行排

通過java反射機制，獲取物件的屬性和值（包括所有繼承的父類）

      java的反射機制提供了兩種方法：    getDeclaredFields() ：該方法能獲取到本類的所有屬性，包括private，protected和public，但不能獲取到繼承的父類的屬性。    getFields()：既能獲取本類的屬性也能得到父類的

Java反射機制（原始碼反射優勢解析）

一、什麼是反射機制          簡單的來說，反射機制指的是程式在執行時能夠獲取自身的資訊。在java中，只要給定類的名字，      那麼就可以通過反射機制來獲得類的所有資訊。  二、哪裡用到反射機制          有些時候，我們用過一些知識，但是並不知道它的專業術語是什麼，在剛剛學jd

Java-反射機制（reflection）

一.概述 反射機制是Java提供的一項比較高階的功能，一般的Java開發者使用它的時候相對比較少。但是，java的反射卻是大多數框架的基礎，例如，Struts，Hibernate，Spring等，反射機制就好像外科醫生的解剖工具，突然從外太空來了一個人，如何知道他的具體構造呢？最好的辦法

Java反射機制與動態代理（一）

導讀： 1. 什麼是反射 2. 反射的基本使用 3. 反射的使用例項 一、什麼是反射？   Java反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意一個方法和屬性；這

Java反射機制與動態代理（二）

導讀： 1. 代理模式 2. 靜態代理 3. 動態代理 4. 小結 一、代理模式 代理模式所涉及的角色有： 抽象主題角色：聲明瞭真實主題和代理主題的共同介面，這樣一來在任何可以使用真實主題的地方都可以使用代理主題。 真實主

java反射機制（2）- 實踐：反射機制+動態代理實現模擬RMI遠端方法呼叫

1 涉及主要知識點   1、RMI(Remote Method Invocation)：遠端方法呼叫是一種計算機之間利用遠端物件互相呼叫實現雙方通訊的一種通訊機制。使用這種機制，某一臺計算機上