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是单继承，所以只能实现接口，通过接口实现