Java动态代理实现及原理分析

代理模式

给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问

什么是动态代理

运行时动态生成代理类

   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) {
        //这里就生成了我们要的字节码形式的代理类
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
        //defineClass0是个native方法        
        return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
        }
        
}

动态代理我们需要些什么

1. 业务接口（Interface）
   业务的抽象表示
2. 业务具体实现类（concreteManager）
   实现业务接口，执行具体的业务操作
3. 业务代理类（$proxy，在运行的时候动态生成的类）
   进行业务代理，调用业务代理操作类
4. 业务代理操作类（proxyHandler，实现了InvocationHandler接口的类）
   代理方法的直接调用者，通过InvocationHandler中的invoke方法直接发起代理
5. 客户端调用对象（client）
   发起业务

接下来是具体实现

业务接口ICook

public interface ICook {

     void dealWithFood();

     void cook();
}

业务具体实现类CookManager

public class CookManager implements ICook {

    @Override
    public void dealWithFood() {
        System.out.println("food had been dealed with");
    }

    @Override
    public void cook() {
        System.out.println("cook food");
    }
}

业务代理操作类DynamicProxyHandler

public class DynamicProxyHandler implements InvocationHandler{
    Object realCookManager;
    DynamicProxyHandler(ICook realCookManager){
        this.realCookManager = realCookManager;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("invoke start");
        System.out.println(method.getName());
        method.invoke(realCookManager,args);
        System.out.println("invoke end");
        return null;
    }
}

客户端

public class Main {
    public static void main(String[] args){

        CookManager cookManager = new CookManager();
        DynamicProxyHandler dynamicProxyHandler = new DynamicProxyHandler(cookManager);
        ICook iCook =(ICook)Proxy.newProxyInstance(dynamicProxyHandler.getClass().getClassLoader(),cookManager.getClass().getInterfaces(), dynamicProxyHandler);
        //打印一下代理类的类名
        System.out.println(iCook.getClass().getName());
        iCook.dealWithFoot();
        iCook.cook();
    }
}

实现过程很简单，看一下输出的结果吧

com.sun.proxy.$Proxy0
invoke start
dealWithFoot
food had been dealed with
invoke end
invoke start
cook
cook food
invoke end

输出结果分析

输出的业务代理类类名为$Proxy0，DynamicProxyHandler中的invoke方法被调用了，并且method.invoke方法会调用实现类中的具体实现方法，到这里我们其实就已经完成了代理操作了，并且在DynamicProxyHandler的invoke中我们还可以添加自己的操作，比如打印个日志什么的，这里其实就是一次简单的应用层级的hook的实现了。我们可以在客户端发起调用的时候使用代理中的方法替换掉原有的具体实现方法并对其进行扩展，这样我们在不改变原有实现类的情况下增强了原有类的功能，符合开闭原则。

知其然知其所以然，我们必须对自己有追求呀！动态代理实现的技术点主要是反射，为了更好的理解其原理，看源码是少不了的过程~~

来，老板，上盘生肉！

我们从Proxy类中的newProxyInstance这个函数入手，为了更好的理解其原理，以下是精简后的代码

 public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h){
     //所有被实现的业务接口
      final Class<?>[] intfs = interfaces.clone();
     //寻找或生成指定的代理类,关键
      Class<?> cl = getProxyClass0(loader, intfs);
      //通过反射类中的Constructor获取其所有构造方法
      final Constructor<?> cons = cl.getConstructor(constructorParams);
      //通过Constructor返回代理类的实例
      return cons.newInstance(new Object[]{h});
}

先看看这三个参数loader，interfaces，h；ClassLoader是一个抽象类，作用是将字节码文件加载进虚拟机并生成相应的class（注意是小写的），这里得到的loader是其子类AppClassLoader（负责加载应用层字节码）的一个实例，interfaces就是被实现的那些业务接口，h是InvocationHandler接口的实例，具体代理操作就被放在这个InvocationHandler的invoke函数中。

接下来看看生成业务代理类的getProxyClass0（loader，intfs）的实现

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
      // proxyClassCache会缓存所有的代理类，如果缓存中有这个业务代理类，则会从缓存中取出，否则从ProxyClassFactory中生成
        return proxyClassCache.get(loader, interfaces);
    }

ProxyClassFactory是Proxy中的内部类，缓存中如果没有这个代理类则会调用ProxyClassFactory中的apply方法生成

   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) {
        //这里就生成了我们要的字节码形式的代理类
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
        //defineClass0是个native方法        
        return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
        }
        
}

到这里业务代理类就生成了，我们再回到newProxyInstance方法中，它会将InvocationHandler的实例h传入这个业务代理类实例中

   return cons.newInstance(new Object[]{h});

由于业务代理类是以字节码形式存在于内存中，我们想要看到其全貌可以将其保存下来然后反编译查看其源码

   byte[] proxyClassFile =  ProxyGenerator.generateProxyClass(iCook.getClass().getName(),cookManager.getClass().getInterfaces());
   saveToFile(proxyClassFile);

最终我们业务代理类$Proxy0类是这样的！

public final class $Proxy0 extends Proxy implements ICook {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m4;
    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})).booleanValue();
        } 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 cook() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void dealWithFoot() throws  {
        try {
            super.h.invoke(this, m4, (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)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.company.ICook").getMethod("cook", new Class[0]);
            m4 = Class.forName("com.company.ICook").getMethod("dealWithFoot", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

这个流程终于变得清晰了。
当我们将业务接口ICook和业务代理操作类DynamicProxyHandler传入Proxy中后，Proxy会为我们生成一个实现了ICook接口并继承了Proxy的业务代理类$Proxy0。

在我们具体调用方法 iCook.dealWithFood()时它其实是调用了$Proxy0中的dealWithFood方法，然后再调用DynamicProxyHandler类的invoke方法，所以DynamicProxyHandler中的invoke方法才是最终执行的方法，这个方法给了我们扩展的可能并且最终我们实现了代理对象访问原对象的目的，也就是$Proxy0代理了CookManager。

 

引用一张其他博客的图片

引用自：

深入理解系列之JAVA动态代理机制

https://blog.csdn.net/u011552404/article/details/79954199

总结

在jdk动态代理中，美中不足就是整个设计都是针对接口做的代理，如果是普通的类，我们无法通过这个方式代理对象（通过生成的代理类也知道没有接口是不行的），但是我们知道 通过拼接字节码生成新的类 自由度是十分大的，这也就启示我们 设计不管是针对接口类还是普通类的代理类 是完全可行的，比如cglib框架就是通过拼接字节码来实现非接口类的代理。