JDK动态代理的意义和用法

一、JDK动态代理的意义

1.什么是代理？

代理模式的主要作用是为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式的思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信。

2.java代理模式

静态代理

• 静态代理类：由程序员创建或者由第三方工具生成，再进行编译；在程序运行之前，代理类的.class文件已经存在了。
• 静态代理类通常只代理一个类。
• 静态代理事先知道要代理的是什么。

动态代理

• 动态代理类：在程序运行时，通过反射机制动态生成。
• 动态代理类通常代理接口下的所有类。
• 动态代理事先不知道要代理的是什么，只有在运行的时候才能确定。
• 动态代理的调用处理程序必须实现InvocationHandler接口，并使用Proxy类中的newProxyInstance方法动态的创建代理类。
• JDK动态代理只能代理接口（java的单继承特性），cglib只能代理类（本质生成了一个子类，所以要被代理的不能是final，本文不讲）。

3.代理的意义

JDK动态代理：代理对象=增强内容+原对象。（其实就是spring中的aop）

意义：在编程中我们希望自己的代码是灵活的而不是死板的，能动态配置的东西就不要写死。这样来提高程序的可扩展性。如果不使用代理模式，将来我们想在当前的业务逻辑下添加一些其他的处理，比如日志、校验等等，就不得不侵入原有的业务代码，尤其是在重重继承关系复杂的类中，需要增加一些内容，并不清楚会不会影响到其他功能，所以使用代理来实现需要增加的内容。

二、JDK动态代理实现

写一个接口和实现类：

public interface Movie {
    void  play();
}
public class NoVipMovie implements Movie {
    public void play(){
        System.out.println("播放非vip电影");
    }
}

 实现InvocationHandler接口：

public class MyInvocationHandler implements InvocationHandler {
    private Object object;
    public MyInvocationHandler(Object object){
        this.object=object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        ad();
        Object invoke = method.invoke(object, args);
        return invoke;
    }
    public void ad(){
        System.out.println("播放广告");
    }

}

 测试类调用Proxy类中的newProxyInstance：

public class Test {
    public static void main(String[] args) {
         Movie movie = new NoVipMovie();
         MyInvocationHandler myInvocationHandler = new MyInvocationHandler(movie);
         //注掉的代码为将生成的代理对象存在磁盘上
         // System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
         Movie proxyObject  =(Movie) Proxy.newProxyInstance(NoVipMovie.class.getClassLoader(),NoVipMovie.class.getInterfaces(),myInvocationHandler);
        proxyObject.play();
    }
}

测试结果：

播放广告
播放非vip电影

三、部分源码分析 

动态代理实现流程

1、为接口创建代理类的字节码文件

2、使用ClassLoader将字节码文件加载到JVM

3、创建代理类实例对象，执行对象的目标方法

源码跟踪

跟踪顺序：

Proxy.newProxyInstance()-> getProxyClass0()->proxyClassCache->ProxyClassFactory->apply()->

ProxyGenerator.generateProxyClass()

进入Proxy.newProxyInstance()方法

 @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);
        }

         //生成或返回代理类（缓存有就返回，没有则生成新的）
        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;
                    }
                });
            }
               //创建动态代理类对象实例, 有参构造方法参数为InvocationHandler
            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);
        }
    }

进入getProxyClass0()方法

 private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

       //通过ProxyClassFactory创建代理类，看一下proxyClassCache是什么
        return proxyClassCache.get(loader, interfaces);
    }

查看 proxyClassCache，发现缓存使用的是WeakCache实现的

 private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

 进入new ProxyClassFactory()对象

 private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // 代理类前缀
        private static final String proxyClassNamePrefix = "$Proxy";

        // 代理类计数器
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
        
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
   
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;     
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // public代理接口，使用com.sun.proxy包名
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            long num = nextUniqueNumber.getAndIncrement();
                //代理类名称
            String proxyName = proxyPkg + proxyClassNamePrefix + num;
                //代理类class文件
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                 //使用类加载器将代理类的字节码文件加载到JVM中
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
               
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

进入ProxyGenerator.generateProxyClass()方法 

 public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
         //生成代理类class文件
        final byte[] var4 = var3.generateClassFile();
        //是否保存到磁盘
        if (saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    try {
                        int var1 = var0.lastIndexOf(46);
                        Path var2;
                        if (var1 > 0) {
                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
                            Files.createDirectories(var3);
                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class");
                        }

                        Files.write(var2, var4, new OpenOption[0]);
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError("I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }

        return var4;
    }

到这里有一个是否保存到磁盘的参数，我们通过测试类进行设置，回到自己写的测试类，增加这句设置

 System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

public class Test {
    public static void main(String[] args) {
         Movie movie = new NoVipMovie();
         MyInvocationHandler myInvocationHandler = new MyInvocationHandler(movie);
         System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
         Movie proxyObject  =(Movie) Proxy.newProxyInstance(NoVipMovie.class.getClassLoader(),NoVipMovie.class.getInterfaces(),myInvocationHandler);
         proxyObject.play();
    }
}

再运行一下测试类，发现多了一个class文件。

 

查看 $Proxy0

public final class $Proxy0 extends Proxy implements Movie {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    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 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 void play() throws  {
        try {
            super.h.invoke(this, m3, (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"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.y20.chuan.test.jdkProxy.Movie").getMethod("play");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

通过观察class文件内容可知；

1、代理类继承了Proxy类并且实现了要代理的接口，由于java不支持多继承，所以这就是JDK动态代理为什么不能代理类

2、重写了equals、hashCode、toString方法

3、有一个静态代码块，通过反射或者代理类的所有方法

4、通过invoke执行代理类中的目标方法

四、JDK动态代理的一些问题

1.JDK动态代理为什么只能代理接口？

因为java不支持多继承，所以只能通过实现接口来实现。

2.为什么要重写equals、hashCode、toString方法？

因为如果不重写这三个方法，而被代理类重写了这三个方法，那么代理类则会去调用object里面的这三个方法，代理类重写的方法就无用了。

3.为什么动态代理类要继承 Proxy？

因为Proxy对所有的代理类进行了一层抽象，它们有一个共同点，都持有一个InvocationHandle对象。当然，不要Proxy也可以，但是需要每个代理类自己要有一个InvocationHandle对象，从性能方面看，通过继承，可以减少生成代理类时的损耗。