【动态代理】JDK动态代理为什么要基于接口

我们都知道CGLIB动态代理是基于继承的，而JDK动态代理是基于接口的，为什么不能也基于继承呢？现在通过代码来看看原因，至于面试的时候可能会被问到为什么不通过聚合或者组合来实现，原因很明显就是为了降低耦合性。

// 定义目标对象的接口
public interface UserDao {
	/**
	 *
	 */
	void query();
}

// 目标对象
@Repository("userDao")
public class UserDaoImpl implements UserDao {
	@Override
	public void query() {
		System.out.println("UserDaoImpl");
	}
}

// 声明一个切面
@Component
@Aspect
public class MyAspect {
	@Pointcut("execution(public * *(..))")
	public void executionPointcut(){}

	@Before(value = "executionPointcut()")
	public void log() {
		System.out.println("log");
	}
}

/**
	 * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
	 * to standard Java interface-based proxies. The default is {@code false}.
	 */
	boolean proxyTargetClass() default false;

// 这里通过proxyTargetClass = true来指定使用JDK动态代理
@Configuration
@ComponentScan("com.depthmind.proxy")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AppConfig {
}

// 通过ProxyGenerator拿到代理对象的字节码，通过流生成代理对象的class文件
byte[] generateProxyClass = ProxyGenerator.generateProxyClass("UserDao", new Class[]{UserDao.class});

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
/**
 * 用IDEA反编译生成的代理对象类
 */
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class UserDao extends Proxy implements com.depthmind.proxy.UserDao {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public UserDao(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 void query() 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);
        } 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.depthmind.proxy.UserDao").getMethod("query");
            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());
        }
    }
}

可以看到代理类继承了Proxy类，而Java是单继承的，就无法通过继承目标类来实现代理，所以JDK动态代理是基于接口的。