JDK动态代理学习心得

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逻辑

实际逻辑