反射
反射機制是 Java 語言提供的一種基礎功能，賦予程序在運行時自省（introspect）的能力。簡單來說就是通過反射，可以在運行期間獲取、檢測和調用對象的屬性和方法。
反射的使用場景
在現實中反射的使用場景有很多，比如以下幾個。
使用場景一：編程工具 IDEA 或 Eclipse 等，在寫代碼時會有代碼（屬性或方法名）提示，就是因爲使用了反射。
使用場景二：很多知名的框架，爲了讓程序更優雅更簡潔，也會使用到反射。
例如，Spring 可以通過配置來加載不同的類，調用不同的方法，代碼如下所示：
<bean id="person" class="com.spring.beans.Person" init-method="initPerson">
</bean>
例如，MyBatis 在 Mapper 使用外部類的 Sql 構建查詢時，代碼如下所示：
@SelectProvider(type = PersonSql.class, method = "getListSql")
List<Person> getList();
class PersonSql {
public String getListSql() {
String sql = new SQL() {{
SELECT("*");
FROM("person");
}}.toString();
return sql;
}
}
使用場景三：數據庫連接池，也會使用反射調用不同類型的數據庫驅動，代碼如下所示：
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);
當然反射還有其他很多類似的使用場景，這裏就不一一列舉，讀者可以舉一反三，想想在平常的開發中，還有哪些使用了反射功能的場景。
反射的基本使用
下來我們通過反射調用類中的某個方法，來學習反射的基本使用。
使用反射調用類中的方法，分爲三種情況：
-
調用靜態方法
-
調用公共方法
-
調用私有方法
假設有一個實體類 MyReflect 包含了以上三種方法，代碼如下：
package com.interview.chapter4;
class MyReflect {
// 靜態方法
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");
}
}
下面分別來看，使用反射如何調用以上三種類型的方法。
① 反射調用靜態方法
Class myClass = Class.forName("com.interview.chapter4.MyReflect");
Method method = myClass.getMethod("staticMd");
method.invoke(myClass);
② 反射調用公共方法
Class myClass = Class.forName("com.interview.chapter4.MyReflect");
// 創建實例對象（相當於 new ）
Object instance = myClass.newInstance();
Method method2 = myClass.getMethod("publicMd");
method2.invoke(instance);
③ 反射調用私有方法
Class myClass = Class.forName("com.interview.chapter4.MyReflect");
// 創建實例對象（相當於 new ）
Object object = myClass.newInstance();
Method method3 = myClass.getDeclaredMethod("privateMd");
method3.setAccessible(true);
method3.invoke(object);
反射使用總結
反射獲取調用類可以通過 Class.forName()，反射獲取類實例要通過 newInstance()，相當於 new 一個新對象，反射獲取方法要通過 getMethod()，獲取到類方法之後使用 invoke() 對類方法進行調用。如果是類方法爲私有方法的話，則需要通過 setAccessible(true) 來修改方法的訪問限制，以上的這些操作就是反射的基本使用。
動態代理
動態代理可以理解爲，本來應該自己做的事情，卻交給別人代爲處理，這個過程就叫做動態代理。
動態代理的使用場景
動態代理被廣爲人知的使用場景是 Spring 中的面向切面編程（AOP）。例如，依賴注入 @Autowired 和事務註解 @Transactional 等，都是利用動態代理實現的。
動態代理還可以封裝一些 RPC 調用，也可以通過代理實現一個全局攔截器等。
動態代理和反射的關係
JDK 原生提供的動態代理就是通過反射實現的，但動態代理的實現方式還可以是 ASM（一個短小精悍的字節碼操作框架）、cglib（基於 ASM）等，並不侷限於反射。
下面我們分別來看：JDK 原生動態代理和 cglib 的實現。
1）JDK 原生動態代理
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");
}
}
// 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("調用前");
Object result = method.invoke(target, args); // 方法調用
System.out.println("調用後");
return result;
}
}
public static void main(String[] args) {
// JDK 動態代理調用
AnimalProxy proxy = new AnimalProxy();
Animal dogProxy = (Animal) proxy.getInstance(new Dog());
dogProxy.eat();
}
以上代碼，我們實現了通過動態代理，在所有請求前、後都打印了一個簡單的信息。
注意： JDK Proxy 只能代理實現接口的類（即使是 extends 繼承類也是不可以代理的）。
2）cglib 動態代理
要是用 cglib 實現要添加對 cglib 的引用，如果是 maven 項目的話，直接添加以下代碼：
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.12</version>
</dependency>
cglib 的具體實現，請參考以下代碼：
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();
// 設置父類爲實例類
enhancer.setSuperclass(this.target.getClass());
// 回調方法
enhancer.setCallback(this);
// 創建代理對象
return enhancer.create();
}
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("調用前");
Object result = methodProxy.invokeSuper(o, objects); // 執行方法調用
System.out.println("調用後");
return result;
}
}
public static void main(String[] args) {
// cglib 動態代理調用
CglibProxy proxy = new CglibProxy();
Panda panda = (Panda)proxy.getInstance(new Panda());
panda.eat();
}
以上程序執行的結果：
調用前
The panda is eating
調用後
由以上代碼可以知道，cglib 的調用通過實現 MethodInterceptor 接口的 intercept 方法，調用 invokeSuper 進行動態代理的。它可以直接對普通類進行動態代理，並不需要像 JDK 代理那樣，需要通過接口來完成，值得一提的是 Spring 的動態代理也是通過 cglib 實現的。
注意：cglib 底層是通過子類繼承被代理對象的方式實現動態代理的，因此代理類不能是最終類（final），否則就會報錯 java.lang.IllegalArgumentException: Cannot subclass final class xxx。
相關面試題
1.動態代理解決了什麼問題？
答：首先它是一個代理機制，如果熟悉設計模式中的代理模式，我們會知道，代理可以看作是對調用目標的一個包裝，這樣我們對目標代碼的調用不是直接發生的，而是通過代理完成，通過代理可以讓調用者與實現者之間解耦。比如進行 RPC 調用，通過代理，可以提供更加友善的界面；還可以通過代理，做一個全局的攔截器。
2.動態代理和反射的關係是什麼？
答：反射可以用來實現動態代理，但動態代理還有其他的實現方式，比如 ASM（一個短小精悍的字節碼操作框架）、cglib 等。
3.以下描述錯誤的是？
A：cglib 的性能更高
B：Spring 中有使用 cglib 來實現動態代理
C：Spring 中有使用 JDK 原生的動態代理
D：JDK 原生動態代理性能更高
答：D
題目解析：Spring 動態代理的實現方式有兩種：cglib 和 JDK 原生動態代理。
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 是不能實現動態代理的，因爲 cglib 的底層是通過繼承代理類的子類來實現動態代理的，所以不能被繼承類無法使用 cglib。
6.JDK 原生動態代理和 cglib 有什麼區別？
答：JDK 原生動態代理和 cglib 區別如下：
-
JDK 原生動態代理是基於接口實現的，不需要添加任何依賴，可以平滑的支持 JDK 版本的升級；
-
cglib 不需要實現接口，可以直接代理普通類，需要添加依賴包，性能更高。
7.爲什麼 JDK 原生的動態代理必須要通過接口來完成？
答：這是由於 JDK 原生設計的原因，來看動態代理的實現方法 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{// 省略其他代碼
來看前兩個參數的聲明：
-
loader：爲類加載器，也就是 target.getClass().getClassLoader()
-
interfaces：接口代理類的接口實現列表
看了上面的參數說明，我們就明白了，要使用 JDK 原生的動態只能通過實現接口來完成。
總結
通過本文可以知道 JDK 原生動態代理是使用反射實現的，但動態代理的實現方式不止有反射，還可以是 ASM（一個短小精悍的字節碼操作框架）、cglib（基於 ASM）等。其中 JDK 原生的動態代理是通過接口實現的，而 cglib 是通過子類實現的，因此 cglib 不能代理最終類（final）。而反射不但可以反射調用靜態方法，還可以反射調用普通方法和私有方法，其中調用私有方法時要設置 setAccessible 爲 true。
下一篇：Java 反射和動態代理
在公衆號菜單中可自行獲取專屬架構視頻資料，包括不限於 java架構、python系列、人工智能系列、架構系列，以及最新面試、小程序、大前端均無私奉獻，你會感謝我的哈
往期精選