前言

上一篇中我们知道动态代理的使用, Javase 专题之静态代理和动态代理
我们只知道其中的使用,但是原理是什么? 不明白原理只知皮毛不是我们的目的,今天看看jdk如何实现的动态代理,我们如何简单实现一个动态代理?

动态代理----demo 案例

接口

public interface Factory {
    public String create(String name);
}

实现类：

public class NicekFactory implements Factory
{
    public String create(String name) {
        System.out.println("生产"+name);
        return name;
    }
}

获取代理对象

public class ProxyFactory {
    public Object getProxy(Class[] cls,Object object){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(), cls, new MyInvocationHandler(object));
    }

}

InvocationHandler

public class MyInvocationHandler implements InvocationHandler {

    private Object object;

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

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("统一颜色");
        Object invoke = method.invoke(object, args);
        System.out.println("统一包装");
        return invoke;
    }
}

使用

public class Application {
    public static void main(String[] args) {
        NicekFactory nicekFactory = new NicekFactory();

        Factory proxy = (Factory)new ProxyFactory().getProxy(new Class[]{Factory.class},nicekFactory );
        proxy.create("nike");
    }
}

代理其实就是为了对自己的实现类进行增强，我们看到最后主要是靠InvocationHandler 的invoke 方法处理
因为代理类最后都会走这个invoke 方法

到这列可以进行运行，我们思考发现：

1.首先要定义接口，我们知道spring cglib 代理是不需要接口的
2.接口需要实现类，我们知道使用的mybatis框架中 mapper是不需要进行写实现的又是如何做到的
3.最后结论：我们给接口写一个实现，jdk根据我们的实现生成代理类，运行的时候使用代理类，对实现做一个增强
4.这样我们需要思考：动态代理生成的代理对象是啥样的？结构又是啥样的？

jdk动态代理源码

带着上面的几个问题我们先分析下动态代理的源码？？？？？

创建代理对象

Proxy.newProxyInstance(this.getClass().getClassLoader(), cls, new MyInvocationHandler(object));

 @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
		
        /*
        * 上面都是检查，下面获取代理类，此时的代理类加载到内存中
        * 1.获取代理对象的Class
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            // 2. 根据Class获取构造函数，进行对象实例化
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

获取类

 Class<?> cl = getProxyClass0(loader, intfs);

上面的代码核心一块：
java.lang.reflect.Proxy.ProxyClassFactory#apply

省略。。。。。。。。
/*
             * Generate the specified proxy class.
             * 生成 代理类二进制流的数据
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
            //加载到内存中。。。。
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {

把二进制流生成文件

生成代码


    public static void main(String[] args) throws Exception {
        /*
         * Generate the specified proxy class.
         */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                "com.sum.proxy.$Proxy0", new Class[]{Factory.class}, 17);
        String path = ClassLoader.getSystemResource("aa.txt").getPath();
        FileOutputStream outputStream = new FileOutputStream("/Users/project/examples/Proxy/src/main/resources/"+"aa.class");
        System.out.println(path);
        outputStream.write(proxyClassFile);
        outputStream.flush();
        outputStream.close();
    }

生成代码如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sum.proxy;

import com.wfg.dynamic.Factory;
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 Factory {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    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 create(String var1) throws  {
        try {
            return (String)super.h.invoke(this, m3, 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);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.wfg.dynamic.Factory").getMethod("create", Class.forName("java.lang.String"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

当我们使用代理类调用方法的时候就是这个

 public final String create(String var1) throws  {
        try {
            return (String)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }