Java 动态代理笔记 —— JDK动态代理-CSDN博客

代理的问题经常被提到，自己本身也比较模糊，借助慕课网的课程学习下，自己做做笔记，下次不清楚回来在看看，本文主要是介绍下JDK动态代理。

代理分两种：静态代理（代理设计模式里面会涉及到）、动态代理（jdk、cglib）

一、概述

caller -> proxy -> target

JDK动态代理是基于接口的，proxy(runtime 动态生成字节码)和target都会实现相同的接口，proxy可以对target进行包装，如在target调用方法前后做自定义处理。

二、流程

JDK动态代理是利用反射技术，动态生成对应的代理类，利用InvocationHandler接口的invoke实现具体方法调用。

接口

public interface Subject {

    void helloWorld();
}
复制代码

target 目标类

public class RealSubject implements Subject {

    @Override
    public void helloWorld() {
        System.out.println("hello world");
    }
}
复制代码

InvocationHandler

public class JdkProxySubject implements InvocationHandler {

    private RealSubject realSubject;

    public JdkProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = null;
        try {
            result = method.invoke(realSubject, args);
        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            e.printStackTrace();
        }
        System.out.println("after");
        return result;
    }
}
复制代码

结果

public class Client {

    public static void main(String[] args) {
        // 显示动态生成的代理对象的class文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        Subject subject = (Subject) Proxy.newProxyInstance(
            Client.class.getClassLoader(), 
            new Class[]{Subject.class}, 
            new JdkProxySubject(new RealSubject())
        );
        subject.helloWorld();
    }
    
    ／**
    * 运行的结果
    * before
    * hello world
    * after
    *／
}
复制代码

代理对象的class文件

package com.sun.proxy;

import com.juststand.aop.dynamic.Subject;
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 Subject {
    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})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void helloWorld() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    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)).intValue();
        } 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.juststand.aop.dynamic.Subject").getMethod("helloWorld");
            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());
        }
    }
}

复制代码

三、源码解析

3.1 Proxy

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
复制代码

运行时动态生成字节码文件，并且在运行时候加载类，需要三个构造函数

类加载器
需要代理的接口
调用处理器 InvocationHandler

3.2 Proxy.newProxyInstance(..) -> getProxyClass0(..)

/**
 * a cache of proxy classes
 */
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
    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
    return proxyClassCache.get(loader, interfaces);
}
复制代码

如果proxy class已经存在就从缓存中返回，如果没有就通过ProxyClassFactory创建。

WeakCache内部是ConcurrentHashMap

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

内部用反射生成需要的Class对象。

ProxyClassFactory.apply(..) 里面通过ProxyGenerator.generateProxyClass(..)生成代理对象的字节码文件。

 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
复制代码

平时debug看到的一些$Proxy0这样的东西，都是在apply方法里面生成的，ProxyClassFactory有个全局变量


 // prefix for all proxy class names
    private static final String proxyClassNamePrefix = "$Proxy";
        
 // next number to use for generation of unique proxy class names
    private static final AtomicLong nextUniqueNumber = new AtomicLong();
复制代码