手動模擬JDK動態(tài)代理的方法

更新時間：2020年11月25日 15:52:12 作者：賜我白日夢

這篇文章主要介紹了手動模擬JDK動態(tài)代理的方法，幫助大家更好的了解和學(xué)習(xí)Java 代理的相關(guān)知識，感興趣的朋友可以了解下

為哪些方法代理?

實現(xiàn)自己動態(tài)代理,首先需要關(guān)注的點就是,代理對象需要為哪些方法代理? 原生JDK的動態(tài)代理的實現(xiàn)是往上抽象出一層接口,讓目標(biāo)對象和代理對象都實現(xiàn)這個接口,怎么把接口的信息告訴jdk原生的動態(tài)代理呢? 如下代碼所示,Proxy.newProxyInstance()方法的第二個參數(shù)將接口的信息傳遞了進去第一個參數(shù)的傳遞進去一個類加載器,在jdk的底層用它對比對象是否是同一個,標(biāo)準就是相同對象的類加載器是同一個

ServiceInterface) Proxy.newProxyInstance(service.getClass().getClassLoader()
        , new Class[]{ServiceInterface.class}, new InvocationHandler() {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置通知");
        method.invoke(finalService,args);
        System.out.println("后置通知");
        return proxy;
      }
    });

我們也效仿它的做法. 代碼如下:

public class Test {
  public static void main(String[] args) {
    IndexDao indexDao = new IndexDao();
    Dao dao =(Dao) ProxyUtil.newInstance(Dao.class,new MyInvocationHandlerImpl(indexDao));
    assert dao != null;
    System.out.println(dao.say("changwu"));
  }
}

拿到了接口的Class對象后,通過反射就得知了接口中有哪些方法描述對象Method,獲取到的所有的方法,這些方法就是我們需要增強的方法

如何將增強的邏輯動態(tài)的傳遞進來呢?

JDK的做法是通過InvocationHandler的第三個參數(shù)完成,他是個接口,里面只有一個抽象方法如下: 可以看到它里面有三個入?yún)?分別是代理對象,被代理對象的方法,被代理對象的方法的參數(shù)

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

當(dāng)我們使用jdk的動態(tài)代理時,就是通過這個重寫這個鉤子函數(shù),將邏輯動態(tài)的傳遞進去,并且可以選擇在適當(dāng)?shù)牡胤阶屇繕?biāo)方法執(zhí)行

InvocationHandler接口必須存在必要性1:

為什么不傳遞進去Method,而是傳遞進去InvocationHandler對象呢? 很顯然,我們的初衷是借助ProxyUtil工具類完成對代理對象的拼串封裝,然后讓這個代理對象去執(zhí)行method.invoke(), 然而事與愿違,傳遞進來的Method對象的確可以被ProxyUtil使用,調(diào)用method.invoke(), 但是我們的代理對象不能使用它,因為代理對象在這個ProxyUtil還以一堆等待拼接字符串, ProxyUtil的作用只能是往代理對象上疊加字符串,卻不能直接傳遞給它一個對象,所以只能傳遞一個對象進來,然后通過反射獲取到這個對象的實例,繼而有可能實現(xiàn)method.invoke()

InvocationHandler接口必須存在必要性2:

通過這個接口的規(guī)范,我們可以直接得知回調(diào)方法的名字就是invoke()所以說,在拼接字符串完成對代理對象的拼接時,可以直接寫死它

思路

我們需要通過上面的ProxyUtil.newInstance(Dao.class,new MyInvocationHandlerImpl(indexDao))方法完成如下幾件事

根據(jù)入?yún)⑽恢玫男畔?提取我們需要的信息,如包名,方法名,等等
根據(jù)我們提取的信息通過字符串的拼接完成一個全新的java的拼接
這個java類就是我們的代理對象
拼接好的java類是一個String字符串,我們將它寫入磁盤取名XXX.java
通過ProxyUtil使用類加載器,將XXX.java讀取JVM中,形成Class對象
通過Class對象反射出我們需要的代理對象
ProxyUtil的實現(xiàn)如下:

public static Object newInstance(Class targetInf, MyInvocationHandler invocationHandler) {

  Method methods[] = targetInf.getDeclaredMethods();
  String line = "\n";
  String tab = "\t";
  String infName = targetInf.getSimpleName();
  String content = "";
  String packageContent = "package com.myproxy;" + line;
  //  導(dǎo)包,全部導(dǎo)入接口層面,換成具體的實現(xiàn)類就會報錯
  //  
  String importContent = "import " + targetInf.getName() + ";" + line
              + "import com.changwu.代理技術(shù).模擬jdk實現(xiàn)動態(tài)代理.MyInvocationHandler;" + line
              + "import java.lang.reflect.Method;" + line
              + "import java.lang.Exception;" + line;

  String clazzFirstLineContent = "public class $Proxy implements " + infName +"{"+ line;
  String filedContent = tab + "private MyInvocationHandler handler;"+ line;
  String constructorContent = tab + "public $Proxy (MyInvocationHandler handler){" + line
      + tab + tab + "this.handler =handler;"
      + line + tab + "}" + line;
  String methodContent = "";
  // 遍歷它的全部方法,接口出現(xiàn)的全部方法進行增強
  for (Method method : methods) {
    String returnTypeName = method.getReturnType().getSimpleName();     method.getReturnType().getSimpleName());

    String methodName = method.getName();
    Class<?>[] parameterTypes = method.getParameterTypes();

    // 參數(shù)的.class
    String paramsClass = "";
    for (Class<?> parameterType : parameterTypes) {
      paramsClass+= parameterType.getName()+",";
    }

    String[] split = paramsClass.split(",");

    //方法參數(shù)的類型數(shù)組 Sting.class String.class
    String argsContent = "";
    String paramsContent = "";
    int flag = 0;
    for (Class arg : parameterTypes) {
      // 獲取方法名
      String temp = arg.getSimpleName();
      argsContent += temp + " p" + flag + ",";
      paramsContent += "p" + flag + ",";
      flag++;
    }
    // 去掉方法參數(shù)中最后面多出來的,
    if (argsContent.length() > 0) {
      argsContent = argsContent.substring(0, argsContent.lastIndexOf(",") - 1);
      paramsContent = paramsContent.substring(0, paramsContent.lastIndexOf(",") - 1);
    }
    methodContent += tab + "public " + returnTypeName + " " + methodName + "(" + argsContent + ") {" + line
        + tab + tab+"Method method = null;"+line
        + tab + tab+"String [] args0 = null;"+line
        + tab + tab+"Class<?> [] args1= null;"+line

        // invoke入?yún)⑹荕ethod對象,而不是上面的字符串,所以的得通過反射創(chuàng)建出Method對象
        + tab + tab+"try{"+line
        // 反射得到參數(shù)的類型數(shù)組
         + tab + tab + tab + "args0 = \""+paramsClass+"\".split(\",\");"+line
         + tab + tab + tab + "args1 = new Class[args0.length];"+line
         + tab + tab + tab + "for (int i=0;i<args0.length;i++) {"+line
         + tab + tab + tab + "  args1[i]=Class.forName(args0[i]);"+line
         + tab + tab + tab + "}"+line
        // 反射目標(biāo)方法
        + tab + tab + tab + "method = Class.forName(\""+targetInf.getName()+"\").getDeclaredMethod(\""+methodName+"\",args1);"+line
        + tab + tab+"}catch (Exception e){"+line
        + tab + tab+ tab+"e.printStackTrace();"+line
        + tab + tab+"}"+line
        + tab + tab + "return ("+returnTypeName+") this.handler.invoke(method,\"暫時不知道的方法\");" + line; //
         methodContent+= tab + "}"+line;
  }

  content = packageContent + importContent + clazzFirstLineContent + filedContent + constructorContent + methodContent + "}";

  File file = new File("d:\\com\\myproxy\\$Proxy.java");
  try {
    if (!file.exists()) {
      file.createNewFile();
    }

    FileWriter fw = new FileWriter(file);
    fw.write(content);
    fw.flush();
    fw.close();

    // 將生成的.java的文件編譯成 .class文件
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
    Iterable units = fileMgr.getJavaFileObjects(file);
    JavaCompiler.CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
    t.call();
    fileMgr.close();

    // 使用類加載器將.class文件加載進jvm
    // 因為產(chǎn)生的.class不在我們的工程當(dāng)中
    URL[] urls = new URL[]{new URL("file:D:\\\\")};
    URLClassLoader urlClassLoader = new URLClassLoader(urls);
    Class clazz = urlClassLoader.loadClass("com.myproxy.$Proxy");
    return clazz.getConstructor(MyInvocationHandler.class).newInstance(invocationHandler);
  } catch (Exception e) {
    e.printStackTrace();
  }
    return null;
}
}

運行的效果:

package com.myproxy;
import com.changwu.myproxy.pro.Dao;
import com.changwu.myproxy.pro.MyInvocationHandler;
import java.lang.reflect.Method;
import java.lang.Exception;
public class $Proxy implements Dao{
	private MyInvocationHandler handler;
	public $Proxy (MyInvocationHandler handler){
		this.handler =handler;
	}
	public String say(String p) {
		Method method = null;
		String [] args0 = null;
		Class<?> [] args1= null;
		try{
			args0 = "java.lang.String,".split(",");
			args1 = new Class[args0.length];
			for (int i=0;i<args0.length;i++) {
			  args1[i]=Class.forName(args0[i]);
			}
			method = Class.forName("com.changwu.myproxy.pro.Dao").getDeclaredMethod("say",args1);
		}catch (Exception e){
			e.printStackTrace();
		}
		return (String) this.handler.invoke(method,"暫時不知道的方法");
	}
}

解讀

通過newInstance()用戶獲取到的代理對象就像上面的代理一樣,這個過程是在java代碼運行時生成的,但是直接看他的結(jié)果和靜態(tài)代理差不錯,這時用戶再去調(diào)用代理對象的say(), 實際上就是在執(zhí)行用戶傳遞進去的InvocationHandeler里面的invoke方法, 但是亮點是我們把目標(biāo)方法的描述對象Method同時給他傳遞進去了,讓用戶可以執(zhí)行目標(biāo)方法+增強的邏輯

當(dāng)通過反射區(qū)執(zhí)行Method對象的invoke()方法時,指定的哪個對象的當(dāng)前方法呢? 這個參數(shù)其實是我們手動傳遞進去的代理對象代碼如下

public class MyInvocationHandlerImpl implements MyInvocationHandler {
  private Object obj;
  public MyInvocationHandlerImpl(Object obj) {
    this.obj = obj;
  }
  @Override
  public Object invoke(Method method, Object[] args) {
    System.out.println("前置通知");
    try {
      method.invoke(obj,args);
    } catch (Exception e) {
      e.printStackTrace();
    } 
    System.out.println("后置通知");
    return null;
  }
}