詳解Java JDK動態(tài)代理

更新時間：2020年08月18日 11:46:29 作者：弗蘭克的貓

這篇文章主要介紹了Java JDK動態(tài)代理的相關資料，幫助大家更好的理解和學習Java 代理的有關知識，感興趣的朋友可以了解下

　　今天來看看Java的另一種代理方式——JDK動態(tài)代理

　　我們之前所介紹的代理方式叫靜態(tài)代理，也就是靜態(tài)的生成代理對象，而動態(tài)代理則是在運行時創(chuàng)建代理對象。動態(tài)代理有更強大的攔截請求功能，因為可以獲得類的運行時信息，可以根據運行時信息來獲得更為強大的執(zhí)（騷）行（操）力（作）。

　　我們還是以上一個例子為例，這里的IStars接口和Stars類都不需要修改，只需要修改代理類。

　　創(chuàng)建JDK動態(tài)代理需要先實現InvocationHandler接口，并重寫其中的invoke方法，具體步驟如下：

　　1. 創(chuàng)建一個類實現InvocationHandler接口。

　　2. 給Proxy類提供委托類的ClassLoader和Interfaces來創(chuàng)建動態(tài)代理類。

　　3. 利用反射機制得到動態(tài)代理類的構造函數。

　　4. 利用動態(tài)代理類的構造函數創(chuàng)建動態(tài)代理類對象。

　　我們用動態(tài)代理來改造一下之前的類：

　　接口和委托類不需要修改：

public interface IStars {
 void sing();
 void dance();
}

public class Stars implements IStars{
 private String name;

 public Stars(String name) {
  this.name = name;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public void sing(){
  System.out.println(getName() + " 唱了一首歌.");
 }

 public void dance(){
  System.out.println(getName() + " 跳了一支舞.");
 }
}

　　這是使用動態(tài)代理后的代理類：

public class StarsNewProxy implements InvocationHandler {

 //代理類持有委托類的對象引用
 private Object object;

 //保存sing和dance的次數
 private int num;

 public StarsNewProxy(Object object){
  this.object = object;
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  if (!runBefore(method)){
   return null;
  };
  //利用反射機制將請求分派給委托類處理，Method的invoke返回Object對象作為方法執(zhí)行結果
  Object result = method.invoke(object,args);
  runAfter(method);
  return result;
 }

 private boolean runBefore(Method method){
  System.out.println("我是代理，攔截到請求");
  if (method.getName().equals("dance")){
   System.out.println("抱歉，明星腳受傷了，不能跳舞表演了。");
   return false;
  }
  return true;
 }

 private void runAfter(Method method){
  System.out.println("我是代理，請求處理完畢");
 }
}

　　新建一個工廠類來返回代理實例：

public class StarsNewProxyFactory {
 //構建工廠類，客戶類調用此方法獲得代理對象
 //對于客戶類而言，代理類對象和委托類對象是一樣的，不需要知道具體返回的類型
 public static IStars getInstance(String name){
  IStars stars = new Stars(name);
  InvocationHandler handler = new StarsNewProxy(stars);
  IStars proxy = null;
  proxy = (IStars) Proxy.newProxyInstance(
    stars.getClass().getClassLoader(),
    stars.getClass().getInterfaces(),
    handler
  );
  return proxy;
 }
}

　　改寫一下測試類：

public class Test {
 public static void main(String[] args){
//  testA();
  testB();
 }

 /**
  * 靜態(tài)代理
  */
 private static void testA(){
  //創(chuàng)建目標對象
  IStars stars = new Stars("Frank");

  //代理對象，把目標傳給代理對象，建立關系
  IStars starsProxy = new StarsProxy(stars);
  for (int i = 0;i < 5; i++){
   starsProxy.sing();
  }
 }

 /**
  * JDK動態(tài)代理
  */
 private static void testB(){
  IStars proxy = StarsNewProxyFactory.getInstance("Frank");
  proxy.dance();
  proxy.sing();
 }
}

　　輸出如下：

我是代理，攔截到請求
抱歉，明星腳受傷了，不能跳舞表演了。
我是代理，攔截到請求
Frank 唱了一首歌.
我是代理，請求處理完畢

　　使用動態(tài)代理時實現了InvocationHandler接口并重寫了invoke方法，invoke方法的三個參數：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:　　被代理的對象
method:　　被代理對象的某個方法的Method對象
args:　　被代理對象的某個方法接受的參數

　　Proxy的newProxyInstance方法詳情如下：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

loader:　　一個ClassLoader對象，定義了由哪個ClassLoader對象來對生成的代理對象進行加載

interfaces:　　一個Interface對象的數組，表示的是我將要給我需要代理的對象提供一組什么接口，如果我提供了一組接口給它，那么這個代理對象就宣稱實現了該接口(多態(tài))，這樣我就能調用這組接口中的方法了

h:　　一個InvocationHandler對象，表示的是當我這個動態(tài)代理對象在調用方法的時候，會關聯到哪一個InvocationHandler對象上

　　可以看到，這里的動態(tài)代理跟靜態(tài)代理一樣，在代理類內部保存了一個委托類的實例，實際上都是調用原來的委托實例來進行需要的操作，代理類相當于給委托類加上一個外殼，把委托類置于代理類的內部，從而可以控制客戶類對委托類的訪問，就像上例中，代理類攔截了客戶類對Stars類的dance方法的訪問，并且輸出了補充信息。

　　動態(tài)代理跟靜態(tài)代理最大的不同便是生成代理類的時期不同，靜態(tài)代理是在編譯期，而動態(tài)代理則是在運行時根據委托類信息動態(tài)生成。

　　其次，動態(tài)代理實現的是InvocationHandler接口，而靜態(tài)代理則是直接實現公共接口。當然動態(tài)代理也是需要實現相同的接口的，只是將接口信息放在了getInstance內部，相當于代理類跟委托類之間的約定，“這幾個方法幫我代理一下吧”。

　　最后，動態(tài)代理可以獲得更多的運行時信息，使用起來也會更加靈活。

　　至此，JDK動態(tài)代理講解完畢，歡迎大家繼續(xù)關注！

以上就是詳解Java JDK動態(tài)代理的詳細內容，更多關于Java JDK動態(tài)代理的資料請關注腳本之家其它相關文章！

您可能感興趣的文章: