Java动态代理深究

1、动态代理类的特性

              1、必须有一个参数类型为InvocationHandler类型的构建函数

              2、是Proxy类的子类

              3、如果代理的接口是non-public，则InvocationHandler实现类和被代理的接口要在同一个包中。

              4、必须有一个InvocationHandler实现类，来拦截代理方法的调用。

              5、代理类的名字以$Proxy开头

2、 动态代理类的创建方式

 

3、InvocationHandler深究

InvocationHandler被真实代理类作为方法调用转发器，生成的代理类的每个方法都调用InvocationHandler的invoke方法，将生成真实代理类实例，调用方法名和调用方法的参数传送给invoke方法，invoke方法拦截所有的方法调用，可以在被代理的方法调用前，调用后，以及调用前后，调用出现异常后做相应的拦截处理。这样就注定要将被代理类传送给InvocationHandler，InvocationHandler在其上调用拦截的所有方法。
    1、实现InvocationHandler时必须提供一个参数为被代理类实例构造函数，将被代理类传入，以便在方法调用时，在其上调用。
    2、不能在真实代理类上调用方法，因为这样后构成一个递归死循环调用。真实代理类可以用于方法返回。
    3、invoke方法中，可以将调用的方法的返回值返回，可以返回真实代理类，调用者可以在真实代理类上做一些操作。
    
/**
 * {@code InvocationHandler} is the interface implemented by
 * the <i>invocation handler</i> of a proxy instance.
 *  
 * <p>Each proxy instance has an associated invocation handler.
 * When a method is invoked on a proxy instance, the method
 * invocation is encoded and dispatched to the {@code invoke}
 * method of its invocation handler.
 *
 * @author      Peter Jones
 * @see         Proxy
 * @since       1.3
 */
public interface InvocationHandler {

    /**
     * Processes a method invocation on a proxy instance and returns
     * the result.  This method will be invoked on an invocation handler
     * when a method is invoked on a proxy instance that it is
     * associated with.
     *
     * @param   proxy the proxy instance that the method was invoked on 真实代理类
     *
     * @param   method the {@code Method} instance corresponding to
     * the interface method invoked on the proxy instance.  The declaring
     * class of the {@code Method} object will be the interface that
     * the method was declared in, which may be a superinterface of the
     * proxy interface that the proxy class inherits the method through.
     *
     * @param   args an array of objects containing the values of the
     * arguments passed in the method invocation on the proxy instance,
     * or {@code null} if interface method takes no arguments.
     * Arguments of primitive types are wrapped in instances of the
     * appropriate primitive wrapper class, such as
     * {@code java.lang.Integer} or {@code java.lang.Boolean}.
     *
     * @return  the value to return from the method invocation on the
     * proxy instance.  If the declared return type of the interface
     * method is a primitive type, then the value returned by
     * this method must be an instance of the corresponding primitive
     * wrapper class; otherwise, it must be a type assignable to the
     * declared return type.  If the value returned by this method is
     * {@code null} and the interface method's return type is
     * primitive, then a {@code NullPointerException} will be
     * thrown by the method invocation on the proxy instance.  If the
     * value returned by this method is otherwise not compatible with
     * the interface method's declared return type as described above,
     * a {@code ClassCastException} will be thrown by the method
     * invocation on the proxy instance.
     *
     * @throws  Throwable the exception to throw from the method
     * invocation on the proxy instance.  The exception's type must be
     * assignable either to any of the exception types declared in the
     * {@code throws} clause of the interface method or to the
     * unchecked exception types {@code java.lang.RuntimeException}
     * or {@code java.lang.Error}.  If a checked exception is
     * thrown by this method that is not assignable to any of the
     * exception types declared in the {@code throws} clause of
     * the interface method, then an
     * {@link UndeclaredThrowableException} containing the
     * exception that was thrown by this method will be thrown by the
     * method invocation on the proxy instance.
     *
     * @see     UndeclaredThrowableException
     */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
    
}

invoke方法的参数proxy真实代理类的应用：

4、查看JDK生成的动态代理类：

            在系统启动前设置保存生成代理文件的开关：

                 System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

            在应用的com.sun.proxy目录下查询生成的代理类：

                  

被代理的接口：
     public interface UserDao {
          void getName();
     }
     public interface UsersDao {
          void getPassword();
     }

    
生成的动态代理类
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import com.water.core.proxyresearch.UserDao;
import com.water.core.proxyresearch.UsersDao;
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 UserDao, UsersDao {
    private static Method m1;
    private static Method m3;
    private static Method m4;
    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});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

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

    public final void getPassword() throws  {
        try {
            super.h.invoke(this, m4, (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.water.core.proxyresearch.UserDao").getMethod("getName");
            m4 = Class.forName("com.water.core.proxyresearch.UsersDao").getMethod("getPassword");
            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());
        }
    }
}

动态代理类的本质，就是为代理接口的每个方法生成一个代理方法，代理方法里调用InvocationHandler实现类，转发代码的调用。也就是InvocationHandler的invoke负责统一拦截所有的代理方法，在方法执行前，执行后，执行前后，执行发生异常时做统一的拦截动作。