JDK动态代理是代理模式的一种实现方式，其只能代理接口。应用甚为广泛，比如我们的Spring的AOP底层就有涉及到JDK动态代理（此处后面可能会分享）
1、首先来说一下原生的JDK动态代理如何实现： 首先声明一个接口：
然后一个实现类实现了接口的方法：
然后申明一个类实现InvocationHandler接口，实现里卖弄的invoke方法：红框中的内容就是我们的代理内容
最后上一个测试类：
我们可以看出运行结果：
看源码分析：
根据Proxy类里面的newProxyInstance方法着手跟踪源码可以看出，通过接口反射的到字节码byte[]，然后通过一个native（本地） 方法把字节码转成class 这个方法在openJDK 中有 用c++写的（到此就研究不到了）
下面我们就原生的JDK动态代理来手写一个山寨版的JDK动态代理：
1、首先创建一个接口类CoustomInvocationHandler，定义一个invoke方法，传递参数是Method类型：
package com.jdkproxy.myjdkprpoxy;
import java.lang.reflect.Method;
//模拟InvocationHandler
public interface CoustomInvocationHandler {
public Object invoke(Method method);
}
2、创建目标接口
package com.jdkproxy.jdkproxy;
public interface TestDao
{
public String proxy() throws Exception;
public String proxy1(String a) throws Exception;
public String proxy2(String a, int b) throws Exception;
}
3、创建目标接口实现类
package com.jdkproxy.jdkproxy;
public class TestDaoImpl implements TestDao{
public String proxy()throws Exception {
System.out.println("实际逻辑");
return "proxy";
}
public String proxy1(String a)throws Exception {
System.out.println("实际逻辑1");
return "proxy";
}
public String proxy2(String a,int b)throws Exception {
System.out.println("实际逻辑2");
return "proxy";
}
}
3、然后写一个该接口的实现类，实现invoke方法，通过参数传递一个Object的对象（其实就是要代理的目标对象）创建他的构造方法，invoke方法里面通过目标方法和目标对象实现方法的反射调用，在调用目标方法之前就可以写代理的逻辑代码了；也就是说该实现类里面只要拿到要执行的方法和目标对象，就可以调用到目标方法；
package com.jdkproxy.myjdkprpoxy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestCustomHandler implements CoustomInvocationHandler {
Object target;
public TestCustomHandler(Object target){//此处得到的是传递进来的接口的实现类
this.target=target;
}
public Object invoke(Method method) {
try {
System.out.println("proxy逻辑");
return method.invoke(target);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return null;
}
}
4、然后根据上面一步的分析可以知道，我们可以通过一个携带了目标对象的CoustomInvocationHandler类型的对象.invoke(传入方法)的方式就可以调用调用到我们的目标方法，解释一下这句话：就是说我们可以通过传入目标对象的方式，new一个实现了CoustomInvocationHandler接口的对象，然后拿到目标对象类里面的所有方法（此处传递一个接口，通过接口得到里面的所有方法），再通过这个CoustomInvocationHandler对象去调用invoke方法，动态传递mothod，就可以实现目标对象的方法的调用了。所以我们需要动态的创建这个么一个类，类里面包含了目标对象的所有方法和携带了目标对象的CoustomInvocationHandler的实现类对象；
需要这么一个类：
package com.jdkproxy.myjdkprpoxy;
import com.jdkproxy.jdkproxy.TestDao;
import java.lang.Exception;import java.lang.reflect.Method;
public class $Proxy implements TestDao {
private CoustomInvocationHandler h;
public $Proxy (CoustomInvocationHandler h){
this.h =h;
}
public String proxy()throws Exception {
Method method = Class.forName("com.luban.proxy.dao.LubanDao").getDeclaredMethod("proxy");
return (String)h.invoke(method);
}
public String proxy1(String a)throws Exception {
Method method = Class.forName("com.luban.proxy.dao.LubanDao").getDeclaredMethod("proxy1");
return (String)h.invoke(method);
}
public String proxy2(String a,int b)throws Exception {
Method method = Class.forName("com.luban.proxy.dao.LubanDao").getDeclaredMethod("proxy2");
return (String)h.invoke(method);
}
}
我们需要编写代码实现动态生成上面这个类文件的方法：
package com.jdkproxy.myjdkprpoxy;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
public class ProxyUtil {
/**
*
* @param targetInf
* @param h
* @return
*/
public static Object newInstance(Class targetInf, CoustomInvocationHandler h){
Object proxy=null;
Method methods[] =targetInf.getDeclaredMethods();//得到目标接口里面的所有方法
String line="\n";
String tab ="\t";
String infName = targetInf.getSimpleName();//得到目标接口的类名
String content ="";
String packageContent = "package com.google;"+line;//声明包路径
String importContent = "import "+targetInf.getName()+";"+line
+"import com.luban.proxy.dao.CoustomInvocationHandler;"+line
+"import java.lang.Exception;"+line
+"import java.lang.reflect.Method;"+line;//申明import依赖类
String clazzFirstLineContent = "public class $Proxy implements "+infName+"{"+line;
String filedContent =tab+"private CoustomInvocationHandler h;"+line;
String constructorContent =tab+"public $Proxy (CoustomInvocationHandler h){" +line
+tab+tab+"this.h =h;"
+line+tab+"}"+line;
String methodContent = "";
for (Method method : methods) {
String returnTypeName = method.getReturnType().getSimpleName();
String methodName =method.getName();
Class args[] = method.getParameterTypes();
String argsContent = "";
String paramsContent="";
int flag =0;
for (Class arg : args) {
String temp = arg.getSimpleName();
argsContent+=temp+" p"+flag+",";
paramsContent+="p"+flag+",";
flag++;
}
if (argsContent.length()>0){
argsContent=argsContent.substring(0,argsContent.lastIndexOf(",")-1);
paramsContent=paramsContent.substring(0,paramsContent.lastIndexOf(",")-1);
}
methodContent+=tab+"public "+returnTypeName+" "+methodName+"("+argsContent+")throws Exception {"+line
+tab+tab+"Method method = Class.forName(\""+targetInf.getName()+"\").getDeclaredMethod(\""+methodName+"\");"+line
+tab+tab+"return ("+returnTypeName+")h.invoke(method);"+line;
methodContent+=tab+"}"+line;
}
content=packageContent+importContent+clazzFirstLineContent+filedContent+constructorContent+methodContent+"}";
File file =new File("d:\\com\\google\\$Proxy.java");
try {
if (!file.exists()) {
file.createNewFile();
}
FileWriter fw = new FileWriter(file);
fw.write(content);
fw.flush();
fw.close();
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();
URL[] urls = new URL[]{new URL("file:D:\\\\")};
URLClassLoader urlClassLoader = new URLClassLoader(urls);
Class clazz = urlClassLoader.loadClass("com.google.$Proxy");
Constructor constructor = clazz.getConstructor(CoustomInvocationHandler.class);
proxy = constructor.newInstance(h);
}catch (Exception e){
e.printStackTrace();
}
return proxy;
}
}
5、最后创建测试类：
package com.jdkproxy.myjdkprpoxy;
import com.jdkproxy.jdkproxy.TestDao;
import com.jdkproxy.jdkproxy.TestDaoImpl;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
//自定义实现 通过传递目标接口（可以拿到方法）、目标对象
TestDao proxy = (TestDao) ProxyUtil.newInstance(TestDao.class,new TestCustomHandler(new TestDaoImpl()));
try {
proxy.proxy();
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行得到结果如下：
proxy逻辑
实际逻辑