反射

反射機制是 Java 語言提供的一種基礎(chǔ)功能，賦予程序在運行時自省(introspect)的能力。簡單來說就是通過反射，可以在運行期間獲取、檢測和調(diào)用對象的屬性和方法。

[[323939]]

反射的使用場景

在現(xiàn)實中反射的使用場景有很多，比如以下幾個。

使用場景一：編程工具 IDEA 或 Eclipse 等，在寫代碼時會有代碼(屬性或方法名)提示，就是因為使用了反射。

使用場景二：很多知名的框架，為了讓程序更優(yōu)雅更簡潔，也會使用到反射。

例如，Spring 可以通過配置來加載不同的類，調(diào)用不同的方法，代碼如下所示：

<bean id="person" class="com.spring.beans.Person" init-method="initPerson"> 
</bean> 

例如，MyBatis 在 Mapper 使用外部類的 Sql 構(gòu)建查詢時，代碼如下所示：

@SelectProvider(type = PersonSql.class, method = "getListSql") 
List<Person> getList(); 
class PersonSql { 
    public String getListSql() { 
        String sql = new SQL() {{ 
            SELECT("*"); 
            FROM("person"); 
        }}.toString(); 
        return sql; 
    } 
} 

使用場景三：數(shù)據(jù)庫連接池，也會使用反射調(diào)用不同類型的數(shù)據(jù)庫驅(qū)動，代碼如下所示：

String url = "jdbc:mysql://127.0.0.1:3306/mydb"; 
String username = "root"; 
String password = "root"; 
Class.forName("com.mysql.jdbc.Driver"); 
Connection connection = DriverManager.getConnection(url, username, password); 

當(dāng)然反射還有其他很多類似的使用場景，這里就不一一列舉，讀者可以舉一反三，想想在平常的開發(fā)中，還有哪些使用了反射功能的場景。

反射的基本使用

下來我們通過反射調(diào)用類中的某個方法，來學(xué)習(xí)反射的基本使用。

使用反射調(diào)用類中的方法，分為三種情況：

• 調(diào)用靜態(tài)方法
• 調(diào)用公共方法
• 調(diào)用私有方法

假設(shè)有一個實體類 MyReflect 包含了以上三種方法，代碼如下：

package com.interview.chapter4; 
class MyReflect { 
    // 靜態(tài)方法 
    public static void staticMd() { 
        System.out.println("Static Method"); 
    } 
    // 公共方法 
    public void publicMd() { 
        System.out.println("Public Method"); 
    } 
    // 私有方法 
    private void privateMd() { 
        System.out.println("Private Method"); 
    } 
} 

下面分別來看，使用反射如何調(diào)用以上三種類型的方法。

① 反射調(diào)用靜態(tài)方法

Class myClass = Class.forName("com.interview.chapter4.MyReflect"); 
Method method = myClass.getMethod("staticMd"); 
method.invoke(myClass); 

② 反射調(diào)用公共方法

Class myClass = Class.forName("com.interview.chapter4.MyReflect"); 
// 創(chuàng)建實例對象（相當(dāng)于 new ） 
Object instance = myClass.newInstance(); 
Method method2 = myClass.getMethod("publicMd"); 
method2.invoke(instance); 

③ 反射調(diào)用私有方法

Class myClass = Class.forName("com.interview.chapter4.MyReflect"); 
// 創(chuàng)建實例對象（相當(dāng)于 new ） 
Object object = myClass.newInstance(); 
Method method3 = myClass.getDeclaredMethod("privateMd"); 
method3.setAccessible(true); 
method3.invoke(object); 

反射使用總結(jié)

反射獲取調(diào)用類可以通過 Class.forName()，反射獲取類實例要通過 newInstance()，相當(dāng)于 new 一個新對象，反射獲取方法要通過 getMethod()，獲取到類方法之后使用 invoke() 對類方法進行調(diào)用。如果是類方法為私有方法的話，則需要通過 setAccessible(true) 來修改方法的訪問限制，以上的這些操作就是反射的基本使用。

動態(tài)代理

動態(tài)代理可以理解為，本來應(yīng)該自己做的事情，卻交給別人代為處理，這個過程就叫做動態(tài)代理。

動態(tài)代理的使用場景

動態(tài)代理被廣為人知的使用場景是 Spring 中的面向切面編程(AOP)。例如，依賴注入 @Autowired 和事務(wù)注解 @Transactional 等，都是利用動態(tài)代理實現(xiàn)的。

動態(tài)代理還可以封裝一些 RPC 調(diào)用，也可以通過代理實現(xiàn)一個全局攔截器等。

動態(tài)代理和反射的關(guān)系

JDK 原生提供的動態(tài)代理就是通過反射實現(xiàn)的，但動態(tài)代理的實現(xiàn)方式還可以是 ASM(一個短小精悍的字節(jié)碼操作框架)、cglib(基于 ASM)等，并不局限于反射。

下面我們分別來看：JDK 原生動態(tài)代理和 cglib 的實現(xiàn)。

1)JDK 原生動態(tài)代理

interface Animal { 
    void eat(); 
} 
class Dog implements Animal { 
    @Override 
    public void eat() { 
        System.out.println("The dog is eating"); 
    } 
} 
class Cat implements Animal { 
    @Override 
    public void eat() { 
        System.out.println("The cat is eating"); 
    } 
} 
  
Java 反射以及動態(tài)代理，來看就懂了 
// JDK 代理類 
class AnimalProxy implements InvocationHandler { 
    private Object target; // 代理對象 
    public Object getInstance(Object target) { 
        this.target = target; 
        // 取得代理對象 
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); 
    } 
    @Override 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        System.out.println("調(diào)用前"); 
        Object result = method.invoke(target, args); // 方法調(diào)用 
        System.out.println("調(diào)用后"); 
        return result; 
    } 
} 
Java 反射以及動態(tài)代理，來看就懂了 
  
public static void main(String[] args) { 
    // JDK 動態(tài)代理調(diào)用 
    AnimalProxy proxy = new AnimalProxy(); 
    Animal dogProxy = (Animal) proxy.getInstance(new Dog()); 
    dogProxy.eat(); 
} 

以上代碼，我們實現(xiàn)了通過動態(tài)代理，在所有請求前、后都打印了一個簡單的信息。

注意： JDK Proxy 只能代理實現(xiàn)接口的類(即使是 extends 繼承類也是不可以代理的)。

2)cglib 動態(tài)代理

要是用 cglib 實現(xiàn)要添加對 cglib 的引用，如果是 maven 項目的話，直接添加以下代碼：

<dependency> 
    <groupId>cglib</groupId> 
    <artifactId>cglib</artifactId> 
    <version>3.2.12</version> 
</dependency> 

cglib 的具體實現(xiàn)，請參考以下代碼：

class Panda { 
    public void eat() { 
        System.out.println("The panda is eating"); 
    } 
} 
class CglibProxy implements MethodInterceptor { 
    private Object target; // 代理對象 
    public Object getInstance(Object target) { 
        this.target = target; 
        Enhancer enhancer = new Enhancer(); 
        // 設(shè)置父類為實例類 
        enhancer.setSuperclass(this.target.getClass()); 
        // 回調(diào)方法 
        enhancer.setCallback(this); 
        // 創(chuàng)建代理對象 
        return enhancer.create(); 
    } 
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
        System.out.println("調(diào)用前"); 
        Object result = methodProxy.invokeSuper(o, objects); // 執(zhí)行方法調(diào)用 
        System.out.println("調(diào)用后"); 
        return result; 
    } 
} 
public static void main(String[] args) { 
    // cglib 動態(tài)代理調(diào)用 
    CglibProxy proxy = new CglibProxy(); 
    Panda panda = (Panda)proxy.getInstance(new Panda()); 
    panda.eat(); 
} 

以上程序執(zhí)行的結(jié)果：

調(diào)用前 
 
The panda is eating 
 
調(diào)用后 

由以上代碼可以知道，cglib 的調(diào)用通過實現(xiàn) MethodInterceptor 接口的 intercept 方法，調(diào)用 invokeSuper 進行動態(tài)代理的。它可以直接對普通類進行動態(tài)代理，并不需要像 JDK 代理那樣，需要通過接口來完成，值得一提的是 Spring 的動態(tài)代理也是通過 cglib 實現(xiàn)的。

注意：cglib 底層是通過子類繼承被代理對象的方式實現(xiàn)動態(tài)代理的，因此代理類不能是最終類(final)，否則就會報錯 java.lang.IllegalArgumentException: Cannot subclass final class xxx。

相關(guān)面試題

1.動態(tài)代理解決了什么問題?

答：首先它是一個代理機制，如果熟悉設(shè)計模式中的代理模式，我們會知道，代理可以看作是對調(diào)用目標(biāo)的一個包裝，這樣我們對目標(biāo)代碼的調(diào)用不是直接發(fā)生的，而是通過代理完成，通過代理可以讓調(diào)用者與實現(xiàn)者之間解耦。比如進行 RPC 調(diào)用，通過代理，可以提供更加友善的界面;還可以通過代理，做一個全局的攔截器。

2.動態(tài)代理和反射的關(guān)系是什么?

答：反射可以用來實現(xiàn)動態(tài)代理，但動態(tài)代理還有其他的實現(xiàn)方式，比如 ASM(一個短小精悍的字節(jié)碼操作框架)、cglib 等。

3.以下描述錯誤的是?

A：cglib 的性能更高B：Spring 中有使用 cglib 來實現(xiàn)動態(tài)代理C：Spring 中有使用 JDK 原生的動態(tài)代理D：JDK 原生動態(tài)代理性能更高

答：D

題目解析：Spring 動態(tài)代理的實現(xiàn)方式有兩種：cglib 和 JDK 原生動態(tài)代理。

4.請補全以下代碼?

class MyReflect { 
    // 私有方法 
    private void privateMd() { 
        System.out.println("Private Method"); 
    } 
} 
class ReflectTest { 
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException { 
        Class myClass = Class.forName("MyReflect"); 
        Object object = myClass.newInstance(); 
        // 補充此行代碼 
        method.setAccessible(true); 
        method.invoke(object); 
    } 
} 

答：Method method = myClass.getDeclaredMethod("privateMd");

題目解析：此題主要考的是私有方法的獲取，私有方法的獲取并不是通過 getMethod() 方式，而是通過 getDeclaredMethod() 獲取的。

5.cglib 可以代理任何類這句話對嗎?為什么?

答：這句話不完全對，因為 cglib 只能代理可以有子類的普通類，對于像最終類(final)，cglib 是不能實現(xiàn)動態(tài)代理的，因為 cglib 的底層是通過繼承代理類的子類來實現(xiàn)動態(tài)代理的，所以不能被繼承類無法使用 cglib。

6.JDK 原生動態(tài)代理和 cglib 有什么區(qū)別?

答：JDK 原生動態(tài)代理和 cglib 區(qū)別如下：

JDK 原生動態(tài)代理是基于接口實現(xiàn)的，不需要添加任何依賴，可以平滑的支持 JDK 版本的升級;

cglib 不需要實現(xiàn)接口，可以直接代理普通類，需要添加依賴包，性能更高。

7.為什么 JDK 原生的動態(tài)代理必須要通過接口來完成?

答：這是由于 JDK 原生設(shè)計的原因，來看動態(tài)代理的實現(xiàn)方法 newProxyInstance() 的源碼：

/** 
 * ...... 
 * @param   loader the class loader to define the proxy class 
 * @param   interfaces the list of interfaces for the proxy class to implement 
 * ...... 
 */ @CallerSensitivepublic static Object newProxyInstance(ClassLoader loader, 
                                      Class<?>[] interfaces, 
                                      InvocationHandler h) 
    throws IllegalArgumentException{// 省略其他代碼 

來看前兩個參數(shù)的聲明：

• loader：為類加載器，也就是 target.getClass().getClassLoader()
• interfaces：接口代理類的接口實現(xiàn)列表

看了上面的參數(shù)說明，我們就明白了，要使用 JDK 原生的動態(tài)只能通過實現(xiàn)接口來完成。

總結(jié)

通過本文可以知道 JDK 原生動態(tài)代理是使用反射實現(xiàn)的，但動態(tài)代理的實現(xiàn)方式不止有反射，還可以是 ASM(一個短小精悍的字節(jié)碼操作框架)、cglib(基于 ASM)等。其中 JDK 原生的動態(tài)代理是通過接口實現(xiàn)的，而 cglib 是通過子類實現(xiàn)的，因此 cglib 不能代理最終類(final)。而反射不但可以反射調(diào)用靜態(tài)方法，還可以反射調(diào)用普通方法和私有方法，其中調(diào)用私有方法時要設(shè)置 setAccessible 為 true。