java動態代理爲何須要基於接口

面試的時候，經常面試官會問spring 的aop底層原理，而aop的底層原理就是動態代理，每一個JAVA程序員基本都能耳熟能詳，對jdk動態代理和cglib動態代理的區別也瞭然於胸，jdk動態代理只能基於接口，而cglib並不須要。

那麼jdk的動態代理爲何要基於接口呢？

下面咱們先實現一個簡單的jdk動態代理

接口類

public interface Person {
    void say();
}
複製代碼

實現類

public class Man implements Person{
    @Override
    public void say() {
        System.out.println("man");
    }
}
複製代碼

代理類實現InvocationHandler接口，並重寫invoke方法

public class JDKDynamicProxy implements InvocationHandler {
    private Object target;

    public JDKDynamicProxy(Object target) {
        this.target = target;
    }

    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Do something before");
        Object result = method.invoke(target, args);
        System.out.println("Do something after");
        return result;
    }
}
複製代碼

調用一下

public class Test {
    public static void main(String[] args) {
        Person person = new JDKDynamicProxy(new Man()).getProxy();
        person.say();
    }
}
複製代碼

調用結果以下

Do something before
man
Do something after
複製代碼

說明動態代理生效了。

那麼問題來了，jdk動態代理要求代理類實現InvocationHandler接口，重寫invoke方法就能夠實現動態代理，且構造函數注入Object便可，並沒有要求Object必須基於接口，並且重本質上說getProxy()獲代理類（Object的原類），徹底能夠經過繼承對象的方式。

所以再定義一個WonMan.class，不實現接口，在來測試一下

public class Woman {
    public void say(){
        System.out.println("woman");
    }
}
複製代碼

調用接口

Woman woman = new JDKDynamicProxy(new Woman()).getProxy();
woman.say();
複製代碼

結果以下

Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to com.ganhuojun.demo.proxy.Woman
	at com.ganhuojun.demo.proxy.Test.main(Test.java:8)
複製代碼

說明，確實不支持沒有接口的object動態代理。

接下來咱們來分析下源碼，探究下爲何只支持接口。由於動態代理的核心是獲取代理類，咱們下面方法開始看

Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
複製代碼

因爲源碼不少，只說簡單說下核心部分，源碼以下，紅色部分是獲取代理類

再看getProxyClass0方法，爲了方便理解，將核心部分抽出來，以下

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);
}
複製代碼

proxyClassCache是WeakCache，再看get方法，一步一步往下看，最終會看到調用到ProxyClassFactory類的apply()方法，以下

此處發現紅色部分是生成真正的代理類的方法，繼續進去看一下，發現只須要將saveGeneratedFiles設置true，便可本地查看生成的代理類，以下

saveGeneratedFiles的值以下，

private static final boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"));
複製代碼

此時咱們將測試代碼改爲以下樣子

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
Person person = new JDKDynamicProxy(new Man()).getProxy();
person.say();
複製代碼

執行後發現本地多了一個代理類，以下圖

打開看一下，源碼以下，發現$Proxy0自己就繼承了一個Proxy類，因爲java不支持多繼承，所以沒法實現動態代理

public final class $Proxy0 extends Proxy implements Person {
    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 say() 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.ganhuojun.demo.proxy.Person").getMethod("say");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}
複製代碼

結論：

生成的代理類繼承了Proxy，因爲java是單繼承，因此只能實現接口，經過接口實現