Java中的動態反射機制和動態代理

一、什么是反射機制？

在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。簡單來說，就是Java對每一個類和類中的所有成員都進行了封裝，這樣每個類都有一個與之對應的Class對象，通過這個對象可以直接訪問類中的所有成員。

 

二、Class類

1.在一個Class類中，將被封裝類的方法（構造器之外）封裝為Method類，將字段封裝為Filed類，將構造器封裝為Constructor類。這三個類都是定義在java.lang.reflect這個類庫中。

2.（定義一個Person類，需要得到Person類對應的Class對象）要想通過Class對象對被封裝類進行訪問，就必須首先獲得一個Class對象。獲取Class對象有三種方式：（1）通過Person類的對象，調用getClass方法獲得；（2）通過Person類的class常量直接獲得；（3）通過Class類中的forName(String className)方法。注意這種方法中需要傳入類的全名（包名.類名），而且會拋出異常。同時，這三種方式得到的Class對象是一樣的。代碼示例如下：

//Person類定義
public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    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;
    }

    void eat(String food) {
        System.out.println("eat " + food);
    }

    protected void drink(String drink) {
        System.out.println("drink " + drink);
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return ("name: " + name + "age: " + age);
    }
}

 

/**
 * 前兩種方式必須指定類名，而第三種方式雖然也需要類名），但是可以通過一個字符串傳入
 * @author hr
 *
 */
public class getClassName {
    public static void main(String[] args) throws Exception {
        Class clazz1 = getClass1();
        Class clazz2 = getClass2();
        Class clazz3 = getClass3();
        System.out.println(((clazz1 == clazz2) && (clazz2 == clazz3)));
    }

    /**
     * 第一種方法：通過Person類的對象，調用getClass方法獲得
     * 
     * @return
     */
    public static Class getClass1() {
        // TODO Auto-generated method stub
        Person person = new Person();
        return person.getClass();
    }

    /**
     * 第二種方法：通過Person類的class常量直接獲得
     * 
     * @return
     */
    public static Class getClass2() {
        // TODO Auto-generated method stub
        return Person.class;
    }

    /**
     * 第三種方法：通過Class類中的forName(String className)方法。
     * 注意這種方法中需要傳入類的全名（包名.類名），而且會拋出異常。
     * @return
     * @throws Exception
     */
    public static Class getClass3() throws Exception {
        // TODO Auto-generated method stub
        return Class.forName("reflect.Person");
    }
}

3.如上所述，可以通過一個類的Class對象得到這個類中的方法、數據和構造器。對於類中的所有對象，Class都提供了返回單個對象或者是對象集合的方法。例如，getMethod()方法，通過參數返回類中的某一個public方法（包括繼承方法），而getMethods()方法則返回類中所有的public方法（包括繼承方法）——通過getDeclaredMethod()和getDeclaredMethods()方法則可以返回本類中的所有方法（包括private方法，但是不包括繼承來的方法）。對於類中的構造器和數據也是一樣。

有兩種方法可以用來新建類的對象：通過Class對象的newInstance()方法，這樣得到的對象沒有初始參數；首先通過Class對象getConstructor()方法得到對應的構造器（注意傳入的參數代表該構造器的參數類型），然后通過得到的構造器創建新的對象（可以傳入初始化參數）。

類中的方法可以通過Class中的invoke方法直接執行。對於非private方法，都是先通過getDeclaredMethod()或者getMethod()方法得到方法名（兩種方法傳入的參數，第一個是方法名，后面是方法需要的參數類型），然后通過方法名調用invoke()方法執行該方法（傳入形式參數）；對於private()方法，在得到方法名之后，需要先通過setAccessible()方法設置訪問權限，然后通過方法名調用invoke()方法執行該方法（傳入形式參數）。

代碼示例如下：

public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Class<Person> clazz = (Class<Person>) Class.forName("reflect.Person");
        // 獲取除父類方法之外的所有方法
        Method[] declaredMethods = clazz.getDeclaredMethods();
        // 獲取所有的public方法，包括繼承的方法
        Method[] publicMethods = clazz.getMethods();
        // 獲取一個除父類方法之外的方法
        Method read = clazz.getDeclaredMethod("read", String.class);
        // 獲取一個本類中的public方法，包括繼承的方法
        Method toString = clazz.getMethod("toString", null);
        // 創建類的一個無參對象
        Object obj1 = clazz.newInstance();
        // 創建類的一個帶參對象
        // 需要首先得到該類的一個帶參構造器，getConstructor傳入的參數代表該構造器需要的數據類型
        // 然后通過構造器構造該類的一個對象
        Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);
        Object obj2 = constructor.newInstance("Sara", 14);
        // 顯示兩個對象
        System.out.println(obj1);
        System.out.println(obj2);
        // 運行類中的一個public方法
        // 需要先得到該方法（pay）
        Method pay = clazz.getMethod("pay", double.class);
        pay.invoke(obj2, 5.4);
        // 運行類中的一個protect方法
        Method drink = clazz.getDeclaredMethod("drink", String.class);
        drink.invoke(obj2, "water");
        // 運行類中的一個default方法
        Method eat = clazz.getDeclaredMethod("eat", String.class);
        eat.invoke(obj2, "noodles");
        // 運行類中的一個private方法,read方法之前已得到
        // 需要先將read方法的訪問權限設置為可見
        read.setAccessible(true);
        read.invoke(obj2, "Thinking in Java");

        for (Method method : declaredMethods) {
            System.out.println(method);
        }

        System.out.println("---------------");

        for (Method method : publicMethods) {
            System.out.println(method);
        }
    }

 三、反射機制的作用

1.在運行時判斷任意一個對象所屬的類；

2.在運行時構造任意一個類的對象；

3.在運行時判斷任意一個類所具有的成員變量和方法；

4.在運行時調用任意一個對象的方法；

5.生成動態代理。

前四個作用已經在上文中介紹了，下面主要說一下動態代理。

四、靜態代理

在了解動態代理之前，我們首先需要介紹一下靜態代理。簡單來說，代理就是用一個代理類來封裝一個委托類，這樣做有兩個好處：可以隱藏委托類的具體實現；可以在不改變委托類的情況下增加額外的操作。而靜態代理，就是在程序運行之前，代理類就已經存在了。靜態代理一般的實現方式為：委托類和代理類都實現同一個接口或者是繼承自同一個父類，然后在代理類中保存一個委托類的對象引用（父類或者父類接口的對象引用），通過給構造器傳入委托類的對象進行初始化，在同名方法中通過調用委托類的方法實現靜態代理。除此之外，在代理類同名方法中還可以實現一些額外的功能。代碼示例如下（借用Java編程思想中的實例），RealObject類為委托類，SimpleProxy類為代理類：

interface Interface {
    void doSomething();

    void somethingElse(String arg);
}

class RealObject implements Interface {
    @Override
    public void doSomething() {
        // TODO Auto-generated method stub
        System.out.println("doSomething");
    }

    @Override
    public void somethingElse(String arg) {
        // TODO Auto-generated method stub
        System.out.println("somethingElse " + arg);
    }
}

class SimpleProxy implements Interface {
    // 保存委托類（父接口的引用）
    private Interface proxied;

    // 傳入委托類的對象用於初始化
    public SimpleProxy(Interface proxied) {
        this.proxied = proxied;
    }

    // 兩個同名方法中還實現了其他的功能
    @Override
    public void doSomething() {
        // TODO Auto-generated method stub
        System.out.println("SimpleProxy doSomething");
        proxied.doSomething();
    }

    @Override
    public void somethingElse(String arg) {
        // TODO Auto-generated method stub
        System.out.println("SimpleProxy somethingElse " + arg);
        proxied.somethingElse(arg);
    }
}

public class SimpleProxyDemo {
    public static void main(String[] args) {
        consumer(new RealObject());
        consumer(new SimpleProxy(new RealObject()));
    }

    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }
}

五、動態代理

靜態代理的局限性在於，代理類需要在程序運行之前就編寫好，而動態代理則可以在程序運行的過程中動態創建並處理對所代理方法的調用。在動態代理中，需要定義一個中介類，這個類實現InvocationHandle接口（主要是里面的invoke方法）。這個中介類位於委托類和代理類之間，作為一個調用處理器而存在。它保存一個委托類的引用，通過傳入委托類對象進行初始化；然后在invoke方法中，實現對委托類方法的調用，並增加需要的額外操作。在需要使用動態代理時，首先通過Proxy類中的newProxyInstance方法得到代理類對象（方法的三個參數分別是：（通常是委托類實現接口的）類加載器，希望代理類實現的接口列表（通常也是委托類實現的接口），以及一個調用處理器的對象），然后通過這個代理類對象直接調用代理類的方法。這種調用實際上會通過調用處理器調用invoke方法，進而實現對委托類相應方法的調用。

注意在動態代理中，只實現了一個調用處理器，而沒有真正實現代理類。代理類對象是通過Proxy類中的newProxyInstance方法得到的。這樣，不管你在調用委托類任何方法時需要加入的額外操作都可以僅僅在調用處理器中的invoke方法中實現就可以了。代碼示例如下（來自Java編程思想）：

 

public class SimpleDynamiProxyDemo {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }

    public static void main(String[] args) {
        RealObject real = new RealObject();
        consumer(real);
        // 通過Proxy.newProxyInstance方法得到代理類對象
        Interface proxy = (Interface) Proxy.newProxyInstance(Interface.class.getClassLoader(),
                new Class[] { Interface.class }, new DynamicProxyHandler(real));
        // 通過代理類對象直接調用方法，會被重定向到調用處理器上的invoke方法
        consumer(proxy);

    }
}

// 中介類（調用處理器）
class DynamicProxyHandler implements InvocationHandler {
    // 保存一個委托類的對象
    private Object proxied;

    public DynamicProxyHandler(Object proxied) {
        this.proxied = proxied;
    }

    // 三個參數：代理類的引用，方法名和方法的參數列表
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("**** proxy: " + proxy.getClass() + ", method: " + method + ", args: " + args);
        if (args != null) {
            for (Object arg : args) {
                System.out.println(" " + arg);
            }
        }
        // 實現對委托類方法的調用，參數表示委托類對象和參數
        return method.invoke(proxied, args);
    }
}