JDK动态代理为什么需要接口？

        回答这个问题之前需要首先由JDK动态代理的基础，可以查看大佬写的这篇文章：Java JDK 动态代理（AOP）使用及实现原理分析，然后再来深入思考这个问题。

       还有一点，需要特别注意的是，当我们在介绍静态代理的时候，都知道需要被代理的类和代理的类都需要实现同一个接口，这样才能完成静态代理，关于静态代理的内容上面的那篇博客也介绍了，这里只是提一下这个点。

       关于JDK动态代理准确的说是对接口进行的代理，创建一个该接口的子类，这个重点突出的是这个接口，而不是某个类需要有接口才能实现动态代理，因为在使用JDK动态代理时，你可以只声明一个接口，就可以使用JDK的动态代理。

       例如上面博客所讲的例子：

       定义一个Subject接口：

package jiankunking;
 
/**
 * 需要动态代理的接口
 */
public interface Subject
{
    /**
     * 你好
     *
     * @param name
     * @return
     */
    public String SayHello(String name);
 
    /**
     * 再见
     *
     * @return
     */
    public String SayGoodBye();
}

        测试类：

package jiankunking;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxyDemonstration {

    public static void main(String[] args) {
        Subject subject = (Subject) Proxy.newProxyInstance(
                Subject.class.getClassLoader(),
                new Class[]{Subject.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        return "haha，我没有实现类，照样可以用";
                    }
                });

        System.out.println("动态代理对象的类型："+subject.getClass().getName());
        System.out.println("===============");
        String hello = subject.SayHello("jiankunking");
        System.out.println(hello);
    }

}
/*
输出结果：
动态代理对象的类型：com.sun.proxy.$Proxy0
===============
haha，我没有实现类，照样可以用
*/

         可以看到，在使用JDK动态代理的时候，即使这个接口没有任何的实现类，也可以根据这个接口，创建一个代理类，所以，可以说JDK动态代理关注的重点的接口，而不是实现了接口的具体实现类，这一点要清楚。

         所以对于JDK动态代理为什么需要接口？相信你已经有答案了，因为JDK动态代理关注的重点的接口。考虑静态代理如果要使用代理，有两种方法：

         一：继承需要代理的类，然后在代理类中进行一些相应的操作，然后调用被代理类（也就是父类的方法即可）

         二：使用接口的方法，代理类和被代理类实现相同的接口，然后代理类内部有被代理类的实例对象的引用，然后代理类执行完相应的逻辑之后，调用被代理类的相应方法。

        以上两种静态方式都有其对应的动态代理的实现，CGLIB和JDK的动态代理。

        一般我们使用JDK的动态代理时，被代理类都需要持有代理类的对象引用，这样才能完成相应的操作，具体的操作还是看上面介绍那篇博客。

        分析一下InvocationHandler接口：

public interface InvocationHandler {
    /**
     * 该方法负责集中处理动态代理类上的所有方法调用。
     * 调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行
     *
     * @param proxy  代理类实例
     * @param method 被调用的方法对象
     * @param args   调用参数
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

         可以看出invoke方法里面没有关于被代理的参数传递过来，只有被代理类对象参数。这个具体可以查看源码。

         对于上篇博客的例子，对于我之前有迷惑的点拿出来进行分析一下：

1、需要动态代理的接口：

package jiankunking;
 
/**
 * 需要动态代理的接口
 */
public interface Subject
{
    public String SayHello(String name);
 
    public String SayGoodBye();
}

2、需要代理的实际对象

package jiankunking;
 
/**
 * 实际对象
 */
public class RealSubject implements Subject{
 
    public String SayHello(String name){
        return "hello " + name;
    }
 
    public String SayGoodBye(){
        return " good bye ";
    }
}

3、调用处理器实现类（有木有感觉这里就是传说中的AOP啊）

package jiankunking;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
 
 
/**
 * 调用处理器实现类
 * 每次生成动态代理类对象时都需要指定一个实现了该接口的调用处理器对象
 */
public class InvocationHandlerImpl implements InvocationHandler{
 
    /**
     * 这个就是我们要代理的真实对象
     */
    private Object subject;
 
    /**
     * 构造方法，给我们要代理的真实对象赋初值
     */
    public InvocationHandlerImpl(Object subject)
    {
        this.subject = subject;
    }
 
    /**
     * 该方法负责集中处理动态代理类上的所有方法调用。
     * 调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行
     *
     * @param proxy  代理类实例
     * @param method 被调用的方法对象
     * @param args   调用参数
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    {
        //在代理真实对象前我们可以添加一些自己的操作
        System.out.println("在调用之前，我要干点啥呢？");
 
        System.out.println("Method:" + method);
 
        //当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
        Object returnValue = method.invoke(subject, args);
 
        //在代理真实对象后我们也可以添加一些自己的操作
        System.out.println("在调用之后，我要干点啥呢？");
 
        return returnValue;
    }
}

4、测试

package jiankunking;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
 
/**
 * 动态代理演示
 */
public class DynamicProxyDemonstration{
    public static void main(String[] args){
        //代理的真实对象
        Subject realSubject = new RealSubject();
        
        /**
         * InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
         * 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用.
         * 即：要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法
         */
        InvocationHandler handler = new InvocationHandlerImpl(realSubject);
 
        ClassLoader loader = realSubject.getClass().getClassLoader();
        Class[] interfaces = realSubject.getClass().getInterfaces();
        /**
         * 该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
         */
        Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);
 
        System.out.println("动态代理对象的类型："+subject.getClass().getName());
 
        String hello = subject.SayHello("jiankunking");
        System.out.println(hello);
//        String goodbye = subject.SayGoodBye();
//        System.out.println(goodbye);
    }
 
}

5、输出结果如下：

 

可以看一下这里代理对象的类型：

我们用jd-jui 工具将生成的字节码反编译：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class ProxySubject
        extends Proxy
        implements Subject
{
    private static Method m1;
    private static Method m3;
    private static Method m4;
    private static Method m2;
    private static Method m0;

    public ProxySubject(InvocationHandler paramInvocationHandler) {
        super(paramInvocationHandler);
    }

    public final boolean equals(Object paramObject) {
        try {
            return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
        }
        catch (Error|RuntimeException localError) {
            throw localError;
        }
        catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    public final String SayGoodBye() {
        try {
            return (String)this.h.invoke(this, m3, null);
        }
        catch (Error|RuntimeException localError) {
            throw localError;
        }
        catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    public final String SayHello(String paramString) {
        try {
            return (String)this.h.invoke(this, m4, new Object[] { paramString });
        }
        catch (Error|RuntimeException localError) {
            throw localError;
        }
        catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    public final String toString() {
        try {
            return (String)this.h.invoke(this, m2, null);
        }
        catch (Error|RuntimeException localError) {
            throw localError;
        }
        catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    public final int hashCode() {
        try {
            // this.h为Proxy类的成员变量
            // 其为protected InvocationHandler h;
            // 也就是创建代理类时传过来的InvocationHandler的子类实现，
            // 第一个参数传递的是this，也就是当前这个代理类本身，这时我们就知道了InvocationHandler接口的
            //invoke方法的第一个参数传递的就是代理类
            return ((Integer)this.h.invoke(this, m0, null)).intValue();
        }
        catch (Error|RuntimeException localError) {
            throw localError;
        }
        catch (Throwable localThrowable) {
            throw new UndeclaredThrowableException(localThrowable);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
            m3 = Class.forName("jiankunking.Subject").getMethod("SayGoodBye", new Class[0]);
            m4 = Class.forName("jiankunking.Subject").getMethod("SayHello", new Class[] { Class.forName("java.lang.String") });
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        }
        catch (NoSuchMethodException localNoSuchMethodException) {
            throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException localClassNotFoundException) {
            throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
        }
    }
}

       可以看到每一个方法都会调用this.h.invoke方法，也就是创建代理类时传递过来的InvocationHandler的子类实现，这样对于this.h.invoke方法的每个参数也能知道代表的含义了。