引言

动态代理非常的重要，虽然我们在日常的工作中没有非常底层的编写过动态代理的代码，但是动态代理却起着非常重要的功能，想一下我们经常使用的框架：日志框架、AOP等等，所以，如果我们需要看一些框架的源码的时候，还是需要非常熟悉的掌握动态代理的原理。

基本的使用这里就不在介绍了，前面的的博客已经介绍过了《java动态代理》，本篇博客主要解决下面几个问题：

1、JDK动态代理基本原理

2、如何调用到我们自己的myInvoerCationHandler中的invoke方法

3、被代理的类位为什么要实现接口？

例子

package com.jack.springmvc.proxy.JDK;
public interface MapperI {
    void  jdbcOperate();
}
class  Mapper implements  MapperI{
    @Override
    public void jdbcOperate() {
        System.out.println("执行数据库连接操作");
    }
}

package com.jack.springmvc.proxy.JDK;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInovercationHandler implements InvocationHandler {
    private Object target;
    public MyInovercationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("数据库连接前");
        //执行目标对象的目标方法
        method.invoke(target,args);
        System.out.println("数据库连接后");
        return null;
    }
}

package com.jack.springmvc.proxy.JDK;
import java.lang.reflect.Proxy;
public class Test {
    public static void main(String[] args) throws  Exception {
        Mapper mapper = new Mapper();
        MyInovercationHandler myInovercationHandler = new MyInovercationHandler(mapper);
        MapperI o = (MapperI)Proxy.newProxyInstance(Mapper.class.getClassLoader(), Mapper.class.getInterfaces(), myInovercationHandler);
        o.jdbcOperate();
        System.out.println(o.getClass());
//        ProxyClassUtils.createClassFile(MapperI.class);
    }
}

1、基本原理

我们运行上面的测试方法，得到的是MapperI的一个代理对象，class com.sun.proxy.$Proxy0，执行o.jdbcOperate();这一句代码的基本流程，其实就是上图中的执行流程。为什么会按照和这个流程执行代码呢，在后面我们将生成的代理类的内容输出到文件中，我们打开看看这个类的内容就完全明白了。

2、源码执行流程

3、代理类的内容

我们都知道动态代理生成的代理里我们在项目中看不到的，因为它保存中内存中，所以我们需要编写代码输出到代码内存中。我们从源代码中能看到下面代码：

    if (proxyPkg == null) {
                // if no non-public proxy interfaces, use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }
            /*
             * Choose a name for the proxy class to generate.
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;
            /*
             * Generate the specified proxy class.
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);

最后一个方法中已经得到了代理类的字节数组，所以我们可以模拟这个方法将生成的代理内输入到文件中。

import java.io.FileOutputStream;
public class ProxyClassUtils {
    public static void  createClassFile(Class clazz) throws  Exception{
        String className="$Proxy0";
        byte[] classFile = ProxyGenerator.generateProxyClass(
                className, new Class[]{clazz});
        String path ="C:\\project\\luban\\springmvc\\src\\main\\java\\com\\jack\\springmvc\\proxy\\JDK";
        FileOutputStream out = new FileOutputStream(path + className + ".class");
        out.write(classFile);
        out.flush();
        out.close();
    }
}

开头的代码中 ProxyClassUtils.createClassFile(MapperI.class) 就可以将内容输出到文件中。代理类内容如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
import com.jack.springmvc.proxy.JDK.MapperI;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements MapperI {
    private static Method m1;
    private static Method m2;
    private static Method m0;
    private static Method m3;
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }
    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    public final void jdbcOperate() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m3 = Class.forName("com.jack.springmvc.proxy.JDK.MapperI").getMethod("jdbcOperate");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

我们看到了生成的代理类的内容，我们就能明白非常多的事情了

1、我们看到了生成的代理类继承了Proxy，但是java是单继承的机制，所以如果代理类和被代理类之间产生关联，只能通过实现同一个接口的方式，这就是为什么，jdk代理要求被代理类必须实现接口。

2、我们还看到了一个核心的方法 jdbcOperate()，这个方法就是我们被代理类实现的接口中的方法，所以我们生成的代理类可以调用和被代理类同一个方法。

这个方法中有一个核心的代码：super.h.invoke(this, m3, (Object[])null); 这里面有几个参数：

1、h.invoke()中的 h 是什么呢，我们从源码中可以看到，cons.newInstance(new Object[]{h}); h就是我们传入的自己定义的 MyInovercationHandler ，看到这个参数我们也就明白了，为什么我们调用生成的代理类的jdbcOperate()方法会进入到我们自己定义的MyInovercationHandler 中。

2、m3 我们从代理类的末端可以看到m3 其实就是我们接口中的方法，看到这我们也就能明白在我们自己的定义的MyInovercationHandler中通过method.invoke(target,args)可以调用目标对象的目标方法了。

分析到这我们也就充分的解答了开头我们提出的几个问题，重要的是我们将动态生成的代理类从内存中拿到本地自己看一看，就会明白了很多原来不是很懂的地方，这也是看源码的快乐。

从源码分析JDK动态代理

引言

1、基本原理

2、源码执行流程

3、代理类的内容

热门文章

最新文章

相关课程

相关电子书