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负责统一拦截所有的代理方法,在方法执行前,执行后,执行前后,执行发生异常时做统一的拦截动作。