Java进阶 - 代理（静态代理、动态代理、动态代理源码分析）

• 代理类：Proxy.java
• 静态代理的命名：
  • 抽象角色     Ixxx
  • 真实角色     xxxImpl
  • 代理角色     xxxProxy

/**
 * 代理逻辑在代理类中，而不是由用户自定义
 */
public class Proxy implements ISubject {
    private RealSubjectImpl realSubjectImpl;

    public Proxy(RealSubjectImpl realSubjectImpl) {
        this.realSubjectImpl = realSubjectImpl;
    }


    /**
     *  前置/后置 处理一旦写完，就固定死了，后续想修改的话需要改此代理类
     * @param something
     * @return
     */

    @Override
    public void doSomething(String something) {
        // 前置处理，例如开启事务
        System.out.println("do something before");

        // 调用目标对象方法
        realSubjectImpl.doSomething(something);

        // 后置处理，例如提交事务或事务回滚
        System.out.println("do something after");
    }
}

• 优点：可以在不修改目标对象的前提下扩展目标对象的功能

• 缺点：

  • 违反开闭原则：因为开闭原则是对修改关闭，对扩展开放，在一对一的情况下代理类在没修改代理接口的情况下进行扩展，这符合开闭原则，但如果多个代理接口的话，或者代理接口有新增功能的话，那就要不断的修改代理对象，这就违反了开闭原则 。
  • 扩展性和可维护性差：如果是多个代理接口类的话，在不违反开闭原则的话，只能创建多个代理类来实现，造成代码冗余。

一个静态代理只能代理一个类，那么有没有什么方式可以实现同一个代理类来代理任意对象呢？肯定有的，也就是下面讲到的：动态代理。

动态代理

面对多个接口使用静态代理，针对每一个接口实现一个代理类的做法肯定不可行了，可不可以让这些代理类的对象自动生成呢？ Jdk提供了invocationHandler接口和Proxy类，借助这两个工具可以达到我们想要的效果。

• 动态代理模式结构图：

• 代码

//被代理接口1
public interface IAppleStore {
    void sellApplePhone();
}
//被代理接口2
public interface IMiStore {
    void sellMiPhone();
}
//实现代理接口1
public class AppleStoreImpl implements IAppleStore {
    @Override
    public void sellApplePhone() {
        System.out.println("出售 苹果 手机..");
    }
}
//实现代理接口2
public class MiStoreImpl implements IMiStore {
    @Override
    public void sellMiPhone() {
        System.out.println("出售 小米 手机....");
    }
}
//动态代理封装类
public class StoryProxy implements InvocationHandler {
    private Object proxyInstance;
    //设置需要被代理的实例
    public void setProxyInstance(Object proxyInstance) {
        this.proxyInstance = proxyInstance;
    }

    //通过Proxy动态代理创建代理实例
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(proxyInstance.getClass().getClassLoader(), proxyInstance.getClass().getInterfaces(), this);
    }

    //代理类通过InvocationHandler真实调用到这个方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
        doBefore();
        Object result = method.invoke(proxyInstance, objects);
        doAfter();
        return result;
    }
    private void doBefore() {
        System.out.println("先推销一波广告....");
    }
    private void doAfter() {
        System.out.println("再收集一波信息....");
    }
}

• 调用

public class MyClass {
    public static void main(String[] args) {
        IAppleStore iAppleStore = new AppleStoreImpl();
        IMiStore    iMiStore    = new MiStoreImpl();

        //创建动态代理工厂
        StoryProxy storyProxy = new StoryProxy();

        System.out.println("===============代理苹果手机=================");
        storyProxy.setProxyInstance(iAppleStore);
        IAppleStore appleStoreProxy = (IAppleStore) storyProxy.getProxyInstance();
        appleStoreProxy.sellApplePhone();

        System.out.println("\n===============代理小米手机=================");
        storyProxy.setProxyInstance(iMiStore);
        IMiStore miStoreProxy = (IMiStore) storyProxy.getProxyInstance();
        miStoreProxy.sellMiPhone();
    }
}

• 运行结果

===============代理苹果手机=================
先推销一波广告....
出售 苹果 手机..
再收集一波信息....

===============代理小米手机=================
先推销一波广告....
出售 小米 手机....
再收集一波信息....

• 优点：只需要1个动态代理类就可以解决创建多个静态代理的问题，避免重复、多余代码，更强的灵活性
• 缺点：
  • 效率低，相比静态代理中直接调用目标对象方法，动态代理则需要先通过Java反射机制从而间接调用目标对象方法
  • 应用场景局限，因为 Java 的单继承特性（每个代理类都继承了 Proxy 类），即只能针对接口创建代理类，不能针对类创建代理类（如果想针对类创建代理类，可以了解下CGLIB）。

动态代理源码分析

1 Proxy类的静态方法newProxyInstance方法和InvocationHandler类

/**
 * 返回一个受调用处理器 (InvocationHandler) 管理，实现了指定接口的代理类的实例
 *
 * @param   loader 声明这个代理类的 ClassLoader
 * @param   interfaces 代理类实现的接口列表
 * @param   h 处理代理类的调用的调用处理器
 * @return  一个受调用处理器 (InvocationHandler) 管理，实现了指定接口的代理类的实例
 * @throws  IllegalArgumentException 违反了 getProxyClass 函数的参数限制条件
 * @throws  SecurityException 如果安全管理器存在并且下面的任意条件满足：
 *               (1) 传入的 loader 是 null 且调用者的类加载器非空，
 *               使用 RuntimePermission("getClassLoader")权限
 *               调用 SecurityManager#checkPermission禁止访问
 *
 *               (2) 对于每一个代理接口，调用者的类加载器与接口类加载器不同或不是其父类,
 *               并且调用 SecurityManager#checkPackageAccess 无权访问接口
 *
 *               (3) 所有传入的代理接口都是非公共的，且调用者类与非公共接口不在同一个包下，
 *               使用 ReflectPermission("newProxyInPackage.{package name}") 调用
 *               SecurityManager#checkPermission 无访问权限
 * @throws  NullPointerException interfaces 数组参数或其中的元素为 null，以及调用处理器 h 为 null
 */
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentExceptio{
    //验证传入的InvocationHandler是否为空
    Objects.requireNonNull(h);
    
    //克隆代理类实现的接口
    final Class<?>[] intfs = interfaces.clone();
    //获得安全管理器
    final SecurityManager sm = System.getSecurityManager();
    //检查创建代理类所需的权限
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }
    
    /*
     * 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);
        }
        //获取参数类型是InvocationHandler.class的代理类构造器
        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实例去构造一个代理类的实例,
       //所有代理类都继承自Proxy,而Proxy构造方法需要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);
    }
}

/**
* InvocationHandler是代理实例的调用处理器实现的接口。
* 每个代理实例都有一个关联的调用处理器。
* 在调用代理实例的方法时，方法调用将被编码并分派给其调用处理程序的 invoke 方法。
*
* @author      Peter Jones
* @see         Proxy
* @since       1.3
*/
public interface InvocationHandler {

   /**
    * 在代理实例上处理方法调用并返回结果。当在与其关联的代理实例上调用
    * 方法时，将调用处理期上的此方法。
    *
    * @param   proxy 该方法被调用的代理实例
    *
    * @param   method Method 对象将是代理接口声明的方法，它可能是代理
    *                 类继承方法的代理接口的超级接口。
    * @param   args 包含在代理实例的方法调用中传递的参数值的对象数组，
    *               如果interface方法不带参数，则为null。基本类型的参
    *               数被封装在适当的基本封装类的实例中，比如
    *               java.lang.Integer 或者 java.lang.Boolean。
    * @return  调用代理实例上的方法获得的返回值。如果接口方法的声明返
    *          回类型是基本类型，则此方法返回的值必须是相应基本包装类
    *          的实例;否则，它必须是转换为声明的返回类型的类型。如果
    *          此方法返回的值为null，并且接口方法的返回类型为原始类型，
    *          则代理实例上的方法调用将引发NullPointerException。如果
    *          此方法返回的值与上面所述的接口方法的声明返回类型不兼容，
    *          则将通过代理实例上的方法调用抛出ClassCastException。
    *
    * @throws  抛出调用代理实例的方法时抛出的异常。异常的类型必须可以
    *          转化为接口方法的 throws 子句中声明的异常类型，也可以分
    *          配给不强制检查的异常类型 java.lang.RuntimeException 或
    *          java.lang.Error。如果这个方法抛出一个强制检查的异常，
    *          这个异常不能转化为接口方法的 throws 子句中声明的异常类
    *          型，那么将会抛出包含这个异常的
    *          UndeclaredThrowableException 异常。
    *
    * @see     UndeclaredThrowableException
    */
   public Object invoke(Object proxy, Method method, Object[] args)
       throws Throwable;
}

从newProxyInstance方法看出，产生代理类核心代码在getProxyClass0

2 Proxy类的静态方法getProxyClass0方法

private static Class<?> getProxyClass0(ClassLoader loader,Class<?>... interfaces) {
    //目标类实现的接口不能大于65535
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    //如果由实现给定接口的代理类存在，这将简单地返回缓存的副本;否则,将通过ProxyClassFactory创建代理类
    return proxyClassCache.get(loader, interfaces);
}

3 proxyClassCache.get方法

public V get(K key, P parameter) {
    // Cache 置换、检查等实现均已省略，以下是 Cache 未命中时，创建新实现类的代码
    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    V value = supplier.get();
    return value;
}

proxyClassCache通过类加载器和接口集合去缓存里面获取，如果能找到代理类就直接返回，否则就会调用ProxyClassFactory这个工厂去生成一个代理类，下面我们看下Proxy的静态内部类ProxyClassFactory

4 ProxyClassFactory

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

    // next number to use for generation of unique proxy class names, 
    // 用原子类来生成代理类的序号, 保证序号唯一
    // 所以生成的代理类都是 $Proxy0 $Proxy1 $Proxy2
    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) {
            /*
             * Verify that the class loader resolves the name of this
             * interface to the same Class object.
             */
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(intf.getName(), false, loader);
            } catch (ClassNotFoundException e) {
            }
            //intf是否可以由指定的类加载进行加载
            if (interfaceClass != intf) {
                throw new IllegalArgumentException(
                    intf + " is not visible from class loader");
            }
            /*
             * Verify that the Class object actually represents an
             * interface.
             * intf是否是一个接口
             */
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            /*
             * Verify that this interface is not a duplicate.
             * intf在数组中是否有重复
             */
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }
        // package to define proxy class in 生成代理类的包名
        String proxyPkg = null;
        // 代理类的访问标志, 默认是public final
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
        /*
         * Record the package of a non-public proxy interface so that the
         * proxy class will be defined in the same package.  Verify that
         * all non-public proxy interfaces are in the same package.
         * 验证所有非公共代理接口都在同一个包中
         */
        for (Class<?> intf : interfaces) {
            //获取接口的访问标志
            int flags = intf.getModifiers();
            //如果接口的访问标志不是public, 那么生成代理类的包名和接口包名相同
            if (!Modifier.isPublic(flags)) {
                //生成的代理类的访问标志设置改为final
                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)) {
                    //代理类如果实现不同包的接口, 并且接口都不是public的, 那么就会在这里报错
                    throw new IllegalArgumentException(
                        "non-public interfaces from different packages");
                }
            }
        }

        if (proxyPkg == null) {
            // if no non-public proxy interfaces,
            // use com.sun.proxy package 
            // 如果没有非公共代理接口，
            // 那生成的代理类都放到默认的包下：com.sun.proxy
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }
        /*
         * Choose a name for the proxy class to generate.
         * 生成代理类的全限定名, 包名+前缀+序号, 例如：com.sun.proxy.$Proxy0
         */
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;
        /*
         * Generate the specified proxy class.
         * 这里是核心, 用ProxyGenerator来生成字节码, 该类放在sun.misc包下
         */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        //根据二进制文件生成相应的Class实例
        try {
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            /*
             * A ClassFormatError here means that (barring bugs in the
             * proxy class generation code) there was some other
             * invalid aspect of the arguments supplied to the proxy
             * class creation (such as virtual machine limitations
             * exceeded).
             */
            throw new IllegalArgumentException(e.toString());
        }
    }
}

5 ProxyGenerator.generateProxyClass

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        //构造ProxyGenerator对象
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        //核心代码，生成代理类字节码文件
        final byte[] var4 = var3.generateClassFile();
        //如果需要保存生成的字节码文件，则将字节码文件写入磁盘
        if(saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction() {
                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)
                                , new String[0]);
                            Files.createDirectories(var3, new FileAttribute[0]);
                            var2 = var3.resolve(
                                var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class", new String[0]);
                        }
                        //将字节码文件写入磁盘
                        Files.write(var2, var4, new OpenOption[0]);
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError(
                            "I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }
        //返回字节码文件
        return var4;
    }

6 ProxyGenerator.generateClassFile

跟踪了这么久源码，大boss终于出现了，下面我们分析ProxyGenerator.generateClassFile方法

private byte[] generateClassFile() {
    //1、将所有的方法组装成ProxyMethod对象
    //首先为代理类生成toString, hashCode, equals等代理方法
    this.addProxyMethod(hashCodeMethod, Object.class);
    this.addProxyMethod(equalsMethod, Object.class);
    this.addProxyMethod(toStringMethod, Object.class);
    Class[] var1 = this.interfaces;
    int var2 = var1.length;

    int var3;
    Class var4;
    //遍历每一个接口的每一个方法, 并生成ProxyMethod对象
    for(var3 = 0; var3 < var2; ++var3) {
        var4 = var1[var3];
        Method[] var5 = var4.getMethods();
        int var6 = var5.length;

        for(int var7 = 0; var7 < var6; ++var7) {
            Method var8 = var5[var7];
            this.addProxyMethod(var8, var4);
        }
    }

    Iterator var11 = this.proxyMethods.values().iterator();

    List var12;
    while(var11.hasNext()) {
        var12 = (List)var11.next();
        checkReturnTypes(var12);
    }

    //2、组装要生成的class文件的所有的字段信息和方法信息
    Iterator var15;
    try {
        //添加构造器方法
        this.methods.add(this.generateConstructor());
        var11 = this.proxyMethods.values().iterator();

        //遍历缓存中的代理方法
        while(var11.hasNext()) {
            var12 = (List)var11.next();
            var15 = var12.iterator();

            while(var15.hasNext()) {
                ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
                //添加代理类的静态字段, 例如:private static Method m1;
                this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
                //添加代理类的代理方法
                this.methods.add(var16.generateMethod());
            }
        }

        //添加代理类的静态字段初始化方法
        this.methods.add(this.generateStaticInitializer());
    } catch (IOException var10) {
        throw new InternalError("unexpected I/O Exception", var10);
    }

    if(this.methods.size() > '\uffff') {
        throw new IllegalArgumentException("method limit exceeded");
    } else if(this.fields.size() > '\uffff') {
        throw new IllegalArgumentException("field limit exceeded");
    } else {
        //3、写入最终的class文件
        //验证常量池中存在代理类的全限定名
        this.cp.getClass(dotToSlash(this.className));
        //验证常量池中存在代理类父类的全限定名
        this.cp.getClass("java/lang/reflect/Proxy");
        var1 = this.interfaces;
        var2 = var1.length;

        //验证常量池存在代理类接口的全限定名
        for(var3 = 0; var3 < var2; ++var3) {
            var4 = var1[var3];
            this.cp.getClass(dotToSlash(var4.getName()));
        }

        //接下来要开始写入文件了,设置常量池只读
        this.cp.setReadOnly();
        ByteArrayOutputStream var13 = new ByteArrayOutputStream();
        DataOutputStream var14 = new DataOutputStream(var13);

        try {
            //1.写入魔数
            var14.writeInt(-889275714);
            //2.写入次版本号
            var14.writeShort(0);
            //3.写入主版本号
            var14.writeShort(49);
            //4.写入常量池
            this.cp.write(var14);
            //5.写入访问修饰符
            var14.writeShort(this.accessFlags);
            //6.写入类索引
            var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
            //7.写入父类索引, 生成的代理类都继承自Proxy
            var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
            //8.写入接口计数值
            var14.writeShort(this.interfaces.length);
            
            Class[] var17 = this.interfaces;
            int var18 = var17.length;

            //9.写入接口集合
            for(int var19 = 0; var19 < var18; ++var19) {
                Class var22 = var17[var19];
                var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
            }
            //10.写入字段计数值
            var14.writeShort(this.fields.size());
            var15 = this.fields.iterator();
            //11.写入字段集合 
            while(var15.hasNext()) {
                ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
                var20.write(var14);
            }
            //12.写入方法计数值
            var14.writeShort(this.methods.size());
            var15 = this.methods.iterator();
            //13.写入方法集合
            while(var15.hasNext()) {
                ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
                var21.write(var14);
            }
            //14.写入属性计数值, 代理类class文件没有属性所以为0
            var14.writeShort(0);
            //转换成二进制数组输出
            return var13.toByteArray();
        } catch (IOException var9) {
            throw new InternalError("unexpected I/O Exception", var9);
        }
    }
}

动态代理的本质：通过类加载器获取类字节码，通过类实现的接口反射获得该类的属性，方法等，并生成新的字节码文件

代理类字节码深入

通过上面查看源码得知，最终通过generateProxyClass()创建类的字节码，而且它返回的是一个字节数组，我们用这个方法把我们上面例子的IAppleStore实例通过这个方法获取他的字节码数组，并把它写到本地我们通过工具来查看一下，通过动态代理生成的代理类到底是什么样子的。

1.创建一个工具类来通过generateProxyClass()获取代理接口的字节码文件，并写入本地

public static void generateClassFile(Class clazz,String proxyName){
    /*ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);*/
    byte[] proxyClassFile =ProxyGenerator.generateProxyClass(
            proxyName, new Class[]{clazz});
    String paths = clazz.getResource(".").getPath();
    System.out.println(paths);
    FileOutputStream out = null;

    try {
        out = new FileOutputStream(paths+proxyName+".class");
        out.write(proxyClassFile);
        out.flush();
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        try {
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.调用获取代理类字节码

public static void main(String[] args) {
    IAppleStore iAppleStore = new AppleStoreImpl();

    //创建动态代理工厂
    StoryProxy storyProxy = new StoryProxy();
    storyProxy.setProxyInstance(iAppleStore);

    IAppleStore appleStoreProxy = (IAppleStore) storyProxy.getProxyInstance();
    appleStoreProxy.sellApplePhone();

    ProxyUtils.generateClassFile(iAppleStore.getClass(),
            appleStoreProxy.getClass().getSimpleName());
}

3.查看代理类字节码(通过反编译工具jadx-gui)

• 在输入目录下我们发现了$Proxy0.class，它的命名就是通过ProxyClassFactory中的
• private static final String proxyClassNamePrefix = "$Proxy";
• private static final AtomicLong nextUniqueNumber = new AtomicLong();