java 反射（Reflection）-干貨

看了很多關於java 反射的文章，自己把所看到的總結一下。對自己，對他人或多或少有幫助吧。

• Java Reflection是什么？

首先來看看官方文檔Oracle里面對Reflection的描述：

Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。

簡單的講：

• 反射機制就是可以把一個類,類的成員(函數，屬性)，當成一個對象來操作，希望讀者能理解，也就是說，類，類的成員，我們在運行的時候還可以動態地去操作他們。

再簡單一點的講：

• 我們可以在運行時獲得程序或程序集中每一個類型的成員和成員的信息。

 

舉個例子：

Java是面向對象語言，我們可以把老虎，獅子等具有相同性質的動物歸類(抽象)為貓科動物，他們具有牙齒，胡須等一些屬性。同時具有吃肉()的動作。

同樣的道理，我們所接觸到的類Class，也可以把他們抽象出來，有類名，成員變量，方法等。

那么既然能夠把類看做是對象，那么java就可以對其進行處理。

 

• Java反射（Reflection）框架主要提供以下功能：

1. 在運行時判斷任意一個對象所屬的類；
2. 在運行時構造任意一個類的對象；
3. 在運行時判斷任意一個類所具有的成員變量和方法（通過反射甚至可以調用private方法）；
4. 在運行時調用任意一個對象的方法

 

• Java反射（Reflection）的主要用途

1. 工廠模式：Factory類中用反射的話，添加了一個新的類之后，就不需要再修改工廠類Factory了
2. 數據庫JDBC中通過Class.forName(Driver).來獲得數據庫連接驅動
3. 分析類文件：畢竟能得到類中的方法等等
4. 訪問一些不能訪問的變量或屬性：破解別人代碼

 

• Java反射（Reflection）的基本運用

　　獲取Class有一下三種方法：

1. 使用Class類的forName靜態方法

//在連接數據庫之前，首先要加載想要連接的數據庫的驅動到JVM（Java虛擬機），   
//這通過java.lang.Class類的靜態方法forName(String  className)實現。   
//例如：   
try{   
    //加載MySql的驅動類   
    Class.forName("com.mysql.jdbc.Driver") ;   
}catch(ClassNotFoundException e){   
    //System.out.println("找不到驅動程序類 ，加載驅動失敗！");   
    e.printStackTrace() ;   
}   
//成功加載后，會將Driver類的實例注冊到DriverManager類中。

 

2. 直接獲取某一個對象的class

Class<?> klass = int.class; 
Class<?> classInt = Integer.TYPE;

 

3. 調用某個對象的getClass()方法

public class Test{
    public static void main(String[] args) {
        Demo demo=new Demo();
        System.out.println(demo.getClass().getName());
    }
}

 

 下面是一個完整的Demo展示Java Reflection的操作：

package com.b510.hongten.test.reflex;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ReflectionDemo {
    /**
     * 為了看清楚Java反射部分代碼，所有異常我都最后拋出來給虛擬機處理！
     * 
     * @param args
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     * @throws IllegalArgumentException
     * @throws NoSuchFieldException
     * @throws SecurityException
     * @throws NoSuchMethodException
     */
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, SecurityException, NoSuchFieldException, NoSuchMethodException {
        // Demo1. 通過Java反射機制得到類的包名和類名
        Demo1();
        System.out.println("===============================================");

        // Demo2. 驗證所有的類都是Class類的實例對象
        Demo2();
        System.out.println("===============================================");

        // Demo3. 通過Java反射機制，用Class 創建類對象[這也就是反射存在的意義所在]，無參構造
        Demo3();
        System.out.println("===============================================");

        // Demo4: 通過Java反射機制得到一個類的構造函數，並實現構造帶參實例對象
        Demo4();
        System.out.println("===============================================");

        // Demo5: 通過Java反射機制操作成員變量, set 和 get
        Demo5();
        System.out.println("===============================================");

        // Demo6: 通過Java反射機制得到類的一些屬性： 繼承的接口，父類，函數信息，成員信息，類型等
        Demo6();
        System.out.println("===============================================");

        // Demo7: 通過Java反射機制調用類中方法
        Demo7();
        System.out.println("===============================================");

        // Demo8: 通過Java反射機制獲得類加載器
        Demo8();
        System.out.println("===============================================");

    }

    /**
     * Demo1: 通過Java反射機制得到類的包名和類名
     */
    public static void Demo1() {
        Person person = new Person();
        System.out.println("Demo1: 包名: " + person.getClass().getPackage().getName() + "，" + "完整類名: " + person.getClass().getName());
        
        /**
        運行結果：
        Demo1: 包名: com.b510.hongten.test.reflex，完整類名: com.b510.hongten.test.reflex.Person
        */
    }

    /**
     * Demo2: 驗證所有的類都是Class類的實例對象 
     * 
     * @throws ClassNotFoundException
     */
    public static void Demo2() throws ClassNotFoundException {
        // 定義兩個類型都未知的Class , 設置初值為null, 看看如何給它們賦值成Person類
        Class<?> class1 = null;
        Class<?> class2 = null;

        // 寫法1, 可能拋出 ClassNotFoundException [多用這個寫法]
        class1 = Class.forName("com.b510.hongten.test.reflex.Person");
        System.out.println("Demo2:(寫法1) 包名: " + class1.getPackage().getName() + "，" + "完整類名: " + class1.getName());

        /**
        運行結果：
        Demo2:(寫法1) 包名: com.b510.hongten.test.reflex，完整類名: com.b510.hongten.test.reflex.Person
        */
        
        // 寫法2
        class2 = Person.class;
        System.out.println("Demo2:(寫法2) 包名: " + class2.getPackage().getName() + "，" + "完整類名: " + class2.getName());
        
        /**
        運行結果：
        Demo2:(寫法2) 包名: com.b510.hongten.test.reflex，完整類名: com.b510.hongten.test.reflex.Person
        */
    }

    /**
     * Demo3: 通過Java反射機制，用Class 創建類對象[這也就是反射存在的意義所在]
     * 
     * @throws ClassNotFoundException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static void Demo3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class<?> class1 = null;
        class1 = Class.forName("com.b510.hongten.test.reflex.Person");
        // 由於這里不能帶參數，所以你要實例化的這個類Person，一定要有無參構造函數哈～
        Person person = (Person) class1.newInstance();
        person.setAge(20);
        person.setName("Hongten");
        System.out.println("Demo3: " + person.getName() + " : " + person.getAge());
        
        /**
        運行結果：
        Demo3: Hongten : 20
        */
    }

    /**
     * Demo4: 通過Java反射機制得到一個類的構造函數，並實現創建帶參實例對象
     * 
     * @throws ClassNotFoundException
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws IllegalArgumentException
     */
    public static void Demo4() throws ClassNotFoundException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
        Class<?> class1 = null;
        Person person1 = null;
        Person person2 = null;

        class1 = Class.forName("com.b510.hongten.test.reflex.Person");
        // 得到一系列構造函數集合
        Constructor<?>[] constructors = class1.getConstructors();

        person1 = (Person) constructors[0].newInstance();
        person1.setAge(30);
        person1.setName("Hongten");

        person2 = (Person) constructors[1].newInstance(20, "Hongten");

        System.out.println("Demo4: " + person1.getName() + " : " + person1.getAge() + "  ,   " + person2.getName() + " : " + person2.getAge());

        /**
        運行結果：
        Demo4: Hongten : 30  ,   Hongten : 20
        */
    }

    /**
     * Demo5: 通過Java反射機制操作成員變量, set 和 get
     * 
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws NoSuchFieldException
     * @throws SecurityException
     * @throws InstantiationException
     * @throws ClassNotFoundException
     */
    public static void Demo5() throws IllegalArgumentException, IllegalAccessException, SecurityException, NoSuchFieldException, InstantiationException, ClassNotFoundException {
        Class<?> class1 = null;
        class1 = Class.forName("com.b510.hongten.test.reflex.Person");
        Object obj = class1.newInstance();

        Field personNameField = class1.getDeclaredField("name");
        personNameField.setAccessible(true);
        personNameField.set(obj, "HONGTEN");

        System.out.println("Demo5: 修改屬性之后得到屬性變量的值：" + personNameField.get(obj));

        /**
        運行結果：
        Demo5: 修改屬性之后得到屬性變量的值：HONGTEN
        */
    }

    /**
     * Demo6: 通過Java反射機制得到類的一些屬性： 繼承的接口，父類，函數信息，成員信息，類型等
     * 
     * @throws ClassNotFoundException
     */
    public static void Demo6() throws ClassNotFoundException {
        Class<?> class1 = null;
        class1 = Class.forName("com.b510.hongten.test.reflex.SuperMan");

        // 取得父類名稱
        Class<?> superClass = class1.getSuperclass();
        System.out.println("Demo6:  SuperMan類的父類名: " + superClass.getName());

        /**
        運行結果：
        Demo6:  SuperMan類的父類名: com.b510.hongten.test.reflex.Person
        */
        
        System.out.println("===============================================");

        Field[] fields = class1.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            System.out.println("類中的成員: " + fields[i]);
        }
        /**
        運行結果：
        類中的成員: private boolean com.b510.hongten.test.reflex.SuperMan.BlueBriefs
        */
        
        System.out.println("===============================================");

        // 取得類方法
        Method[] methods = class1.getDeclaredMethods();
        for (int i = 0; i < methods.length; i++) {
            System.out.println("Demo6,取得SuperMan類的方法：");
            System.out.println("函數名：" + methods[i].getName());
            System.out.println("函數返回類型：" + methods[i].getReturnType());
            System.out.println("函數訪問修飾符：" + Modifier.toString(methods[i].getModifiers()));
            System.out.println("函數代碼寫法： " + methods[i]);
        }

        /**
        運行結果：
        Demo6,取得SuperMan類的方法：
        函數名：isBlueBriefs
        函數返回類型：boolean
        函數訪問修飾符：public
        函數代碼寫法： public boolean com.b510.hongten.test.reflex.SuperMan.isBlueBriefs()
        Demo6,取得SuperMan類的方法：
        函數名：setBlueBriefs
        函數返回類型：void
        函數訪問修飾符：public
        函數代碼寫法： public void com.b510.hongten.test.reflex.SuperMan.setBlueBriefs(boolean)
        Demo6,取得SuperMan類的方法：
        函數名：fly
        函數返回類型：void
        函數訪問修飾符：public
        函數代碼寫法： public void com.b510.hongten.test.reflex.SuperMan.fly()
        Demo6,取得SuperMan類的方法：
        函數名：walk
        函數返回類型：void
        函數訪問修飾符：public
        函數代碼寫法： public void com.b510.hongten.test.reflex.SuperMan.walk(int)
        */
        
        System.out.println("===============================================");

        // 取得類實現的接口,因為接口類也屬於Class,所以得到接口中的方法也是一樣的方法得到哈
        Class<?> interfaces[] = class1.getInterfaces();
        for (int i = 0; i < interfaces.length; i++) {
            System.out.println("實現的接口類名: " + interfaces[i].getName());
        }
        
        /**
        運行結果：
        實現的接口類名: com.b510.hongten.test.reflex.ActionInterface
        */

    }

    /**
     * Demo7: 通過Java反射機制調用類方法
     * 
     * @throws ClassNotFoundException
     * @throws NoSuchMethodException
     * @throws SecurityException
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InstantiationException
     */
    public static void Demo7() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<?> class1 = null;
        class1 = Class.forName("com.b510.hongten.test.reflex.SuperMan");

        System.out.println("Demo7: \n調用無參方法fly()");
        Method method = class1.getMethod("fly");
        method.invoke(class1.newInstance());

        System.out.println("調用有參方法walk(int m)");
        method = class1.getMethod("walk", int.class);
        method.invoke(class1.newInstance(), 100);
        
        /**
        運行結果：
        Demo7: 
        調用無參方法fly()
        fly method....
        調用有參方法walk(int m)
        fly in 100 m
        */
        
    }

    /**
     * Demo8: 通過Java反射機制得到類加載器信息
     * 
     * 在java中有三種類類加載器。[這段資料網上截取]
     * 
     * 1）Bootstrap ClassLoader 此加載器采用c++編寫，一般開發中很少見。
     * 
     * 2）Extension ClassLoader 用來進行擴展類的加載，一般對應的是jre\lib\ext目錄中的類
     * 
     * 3）AppClassLoader 加載classpath指定的類，是最常用的加載器。同時也是java中默認的加載器。
     * 
     * @throws ClassNotFoundException
     */
    public static void Demo8() throws ClassNotFoundException {
        Class<?> class1 = null;
        class1 = Class.forName("com.b510.hongten.test.reflex.SuperMan");
        String nameString = class1.getClassLoader().getClass().getName();

        System.out.println("Demo8: 類加載器類名: " + nameString);
        
        /**
        運行結果：
        Demo8: 類加載器類名: sun.misc.Launcher$AppClassLoader
        */
    }

}


class Person {
    private int age;
    private String name;

    public Person() {

    }

    public Person(int age, String name) {
        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;
    }
}

class SuperMan extends Person implements ActionInterface {
    private boolean BlueBriefs;

    public void fly() {
        System.out.println("fly method....");
    }

    public boolean isBlueBriefs() {
        return BlueBriefs;
    }

    public void setBlueBriefs(boolean blueBriefs) {
        BlueBriefs = blueBriefs;
    }

    public void walk(int m) {
        System.out.println("fly in " + m + " m");
    }
}

interface ActionInterface {
    public void walk(int m);
}

 

•  說說工廠模式和Java 反射（Reflection）機制

 如果在工廠模式下面，我們不使用Java 反射（Reflection）機制，會是什么樣子呢？

package com.b510.hongten.test.reflex;

/**
 * @author hongten
 * @created Apr 18, 2018
 */
public class FactoryTest {

    public static void main(String[] args) {
        Cats cats = FactoryTest.getInstance("Tiger");
        cats.eatMeat();

        /*
         * The Result : The tiger eat meat.
         */
    }

    public static Cats getInstance(String name) {
        Cats cats = null;
        if ("Tiger".equals(name)) {
            cats = new Tiger();
        }
        if ("Lion".equals(name)) {
            cats = new Lion();
        }
        return cats;
    }
}

interface Cats {
    public abstract void eatMeat();
}

class Tiger implements Cats {

    public void eatMeat() {
        System.out.println("The tiger eat meat.");
    }

}

class Lion implements Cats {

    public void eatMeat() {
        System.out.println("The lion eat meat.");
    }

}

我們會發現：

當我們在添加一個子類（Puma-美洲獅）的時候，就需要修改工廠類了。如果我們添加太多的子類的時候，改的就會很多。

我們對程序進行修改，加入反射機制。

package com.b510.hongten.test.reflex;

/**
 * @author hongten
 * @created Apr 18, 2018
 */
public class FactoryTest {

    public static void main(String[] args) {
        //Cats cats = FactoryTest.getInstance("com.b510.hongten.test.reflex.Lion");
        Cats cats = FactoryTest.getInstance("com.b510.hongten.test.reflex.Tiger");
        cats.eatMeat();

        /*
         * The Result : The tiger eat meat.
         */
    }

    public static Cats getInstance(String name) {
        Cats cats = null;
        try {
            try {
                //use Class.forName() with java reflection
                cats = (Cats) Class.forName(name).newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return cats;
    }
}

interface Cats {
    public abstract void eatMeat();
}

class Tiger implements Cats {

    public void eatMeat() {
        System.out.println("The tiger eat meat.");
    }

}

class Lion implements Cats {

    public void eatMeat() {
        System.out.println("The lion eat meat.");
    }

}

我們會發現利用了Java Reflection以后，現在就算我們添加任意多個子類的時候，工廠類就不需要修改。我們只需要傳遞工廠類的實現類的名稱即可。

然而，在這樣的情況下面，如果我們需要運行Lion實例的時候，我們還需要去修改java代碼。

Cats cats = FactoryTest.getInstance("com.b510.hongten.test.reflex.Lion");

上面的代碼雖然可以通過反射取得接口的實例，但是需要傳入完整的包和類名。而且用戶也無法知道一個接口有多少個可以使用的子類，所以我們通過屬性文件的形式配置所需要的子類。

能不能不需要修改java代碼，同樣可以完成相同的操作呢？是可以的。

我們可以讓工廠模式結合屬性文件（如：*.properties, *.xml文件）

 屬性文件：/reflex/cats.properties

lion=com.b510.hongten.test.reflex.Lion
tiger=com.b510.hongten.test.reflex.Tiger

測試文件：/reflex/FactoryTest.java

package com.b510.hongten.test.reflex;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

/**
 * @author hongten
 * @created Apr 18, 2018
 */
public class FactoryTest {

    public static void main(String[] args) {
        Cats cats;
        try {
            cats = FactoryTest.getInstance(getPro().getProperty("tiger"));
            if (cats != null) {
                cats.eatMeat();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        /*
         * The Result : The tiger eat meat.
         */
    }

    public static Cats getInstance(String name) {
        Cats cats = null;
        try {
            try {
                // use Class.forName() with java reflection
                cats = (Cats) Class.forName(name).newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return cats;
    }

    public static Properties getPro() throws FileNotFoundException, IOException {
        Properties pro = new Properties();
        File f = new File("cats.properties");
        if (f.exists()) {
            pro.load(new FileInputStream(f));
        } else {
            pro.setProperty("lion", "com.b510.hongten.test.reflex.Lion");
            pro.setProperty("tiger", "com.b510.hongten.test.reflex.Tiger");
            pro.store(new FileOutputStream(f), "FRUIT CLASS");
        }
        return pro;
    }
}

interface Cats {
    public abstract void eatMeat();
}

class Tiger implements Cats {

    public void eatMeat() {
        System.out.println("The tiger eat meat.");
    }

}

class Lion implements Cats {

    public void eatMeat() {
        System.out.println("The lion eat meat.");
    }

}

作為開發者，我們只需要配置cats.properties屬性文件即可。極大的提高了程序的擴展性能。

• Java反射（Reflection）的一些注意事項

1. 由於反射會額外消耗一定的系統資源，因此如果不需要動態地創建一個對象，那么就不需要用反射。
2. 另外，反射調用方法時可以忽略權限檢查，因此可能會破壞封裝性而導致安全問題。

 

========================================================

More reading,and english is important.

I'm Hongten

 

大哥哥大姐姐，覺得有用打賞點哦！多多少少沒關系，一分也是對我的支持和鼓勵。謝謝。
Hongten博客排名在100名以內。粉絲過千。
Hongten出品，必是精品。

E | [e-mail]  B | http://www.cnblogs.com/hongten

========================================================