JDK動態代理機制
阿新 • • 發佈：2019-01-22
代理的概念
動態代理技術就是用來產生一個物件的代理物件的。在開發中為什麼需要為一個物件產生代理物件呢？
舉一個現實生活中的例子：歌星或者明星都有一個自己的經紀人，這個經紀人就是他們的代理人，當我們需要找明星表演時，不能直接找到該明星，只能是找明星的代理人。比如劉德華在現實生活中非常有名，會唱歌，會跳舞，會拍戲，劉德華在沒有出名之前，我們可以直接找他唱歌，跳舞，拍戲，劉德華出名之後，他乾的第一件事就是找一個經紀人，這個經紀人就是劉德華的代理人(代理)，當我們需要找劉德華表演時，不能直接找到劉德華了(劉德華說，你找我代理人商談具體事宜吧!)，只能是找劉德華的代理人，因此劉德華這個代理人存在的價值就是攔截我們對劉德華的直接訪問！這個現實中的例子和我們在開發中是一樣的，我們在開發中之所以要產生一個物件的代理物件，主要用於攔截對真實業務物件的訪問。那麼代理物件應該具有什麼方法呢？代理物件應該具有和目標物件相同的方法
所以在這裡明確代理物件的兩個概念：
1、代理物件存在的價值主要用於攔截對真實業務物件的訪問。
2、代理物件應該具有和目標物件(真實業務物件)相同的方法。劉德華(真實業務物件)會唱歌，會跳舞，會拍戲，我們現在不能直接找他唱歌，跳舞，拍戲了，只能找他的代理人(代理物件)唱歌，跳舞，拍戲，一個人要想成為劉德華的代理人，那麼他必須具有和劉德華一樣的行為(會唱歌，會跳舞，會拍戲)，劉德華有什麼方法，他(代理人)就要有什麼方法，我們找劉德華的代理人唱歌，跳舞，拍戲，但是代理人不是真的懂得唱歌，跳舞，拍戲的，真正懂得唱歌，跳舞，拍戲的是劉德華，在現實中的例子就是我們要找劉德華唱歌，跳舞，拍戲，那麼只能先找他的經紀人，交錢給他的經紀人，然後經紀人再讓劉德華去唱歌，跳舞，拍戲。
相比於靜態代理，動態代理避免了開發人員編寫各個繁鎖的靜態代理類，只需簡單地指定一組介面及目標類物件就能動態的獲得代理物件
代理模式
使用代理模式必須要讓代理類和目標類實現相同的介面，客戶端通過代理類來呼叫目標方法，代理類會將所有的方法呼叫分派到目標物件上反射執行，還可以在分派過程中新增"前置通知"和後置處理（如在呼叫目標方法前校驗許可權，在呼叫完目標方法後列印日誌等）等功能。
使用動態代理的五大步驟
1.通過實現InvocationHandler介面來自定義自己的InvocationHandler;2.通過Proxy.getProxyClass獲得動態代理類
3.通過反射機制獲得代理類的構造方法，方法簽名為getConstructor(InvocationHandler.class)
4.通過建構函式獲得代理物件並將自定義的InvocationHandler例項物件傳為引數傳入
5.通過代理物件呼叫目標方法
動態代理的使用
程式碼示例：
public class MyProxy {
public interface IHello{
void sayHello();
}
static class Hello implements IHello{
public void sayHello() {
System.out.println("Hello world!!");
}
}
//自定義InvocationHandler
static class HWInvocationHandler implements InvocationHandler{
//目標物件
private Object target;
public HWInvocationHandler(Object target){
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("------插入前置通知程式碼-------------");
//執行相應的目標方法
Object rs = method.invoke(target,args);
System.out.println("------插入後置處理程式碼-------------");
return rs;
}
}
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetExc eption, InstantiationException {
//生成$Proxy0的class檔案
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
//獲取動態代理類
Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);
//獲得代理類的建構函式，並傳入引數型別InvocationHandler.class
Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);
//通過建構函式來建立動態代理物件，將自定義的InvocationHandler例項傳入
IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello()));
//通過代理物件呼叫目標方法
iHello.sayHello();
}
}輸出：
------插入前置通知程式碼-------------
Hello world!!
------插入後置處理程式碼-------------Proxy類中還有個將2~4步驟封裝好的簡便方法來建立動態代理物件，其方法簽名為：
newProxyInstance(ClassLoaderloader,Class<?>[]instance, InvocationHandler h)，如下例：
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//生成$Proxy0的class檔案
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
IHello ihello = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), //載入介面的類載入器
new Class[]{IHello.class}, //一組介面
new HWInvocationHandler(new Hello())); //自定義的InvocationHandler
ihello.sayHello();
}輸出結果一樣.
下面以newProxyInstance方法為切入點來剖析代理類的生成及代理方法的呼叫
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) { //如果h為空直接丟擲異常，所以InvocationHandler例項物件是必須的
throw new NullPointerException();
}
//物件的拷貝,暫不知道這裡拷貝下的意義是啥？
final Class<?>[] intfs = interfaces.clone();
//一些安全的許可權檢查
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//產生代理類
Class<?> cl = getProxyClass0(loader, intfs);
//獲取代理類的建構函式物件
//引數constructorParames為常量值：private static final Class<?>[] constructorParams = { InvocationHandler.class };
final Constructor<?> cons = cl.getConstructor(constructorParames);
final InvocationHandler ih = h;
//根據代理類的建構函式物件來建立代理類物件
return newInstance(cons, ih);
}
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
//介面數不得超過65535個
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//代理類快取，如果快取中有代理類了直接返回，否則將由ProxyClassFactory建立代理類
return proxyClassCache.get(loader, interfaces);
}看看ProxyClassFactory是怎樣生成代理類的?
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
//統一代理類的字首名都以$Proxy開關
private static final String proxyClassNamePrefix = "$Proxy";
//使用唯一的編號給作為代理類名的一部分，如$Proxy0,$Proxy1等
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
//驗證指定的類載入器(loader)載入介面所得到的Class物件(interfaceClass)是否與intf物件相同
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
//驗證該Class物件是不是介面
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
// 驗證該介面是否重複了
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
//宣告代理類所在包
String proxyPkg = null;
/*驗證你傳入的介面中是否有非public介面，只要有一個介面是非public的，那麼這些介面都必須在同一包中
這裡的介面修飾符直接影響到System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true")所生成
的代理類的路徑，往下看！！*/
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
String name = intf.getName();
int n = name.lastIndexOf('.');
//擷取完整包名
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) {
/*如果都是public介面，那麼生成的代理類就在com.sun.proxy包下如果報java.io.FileNotFoundException: com\sun\proxy\$Proxy0.c lass (系統找不到指定的路徑。)的錯誤，就先在你專案中建立com.sun.proxy路徑*/
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
//將當前nextUniqueNumber的值以原子的方式的加1，所以第一次生成代理類的名字為$Proxy0.class
long num = nextUniqueNumber.getAndIncrement();
//代理類的完全限定名，如com.sun.proxy.$Proxy0.calss,
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//生成代理類位元組碼檔案
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}而生成代理類位元組碼檔案又主要通過ProxyGenerate的generateProxyClass(proxyName，interfaces)
public static byte[] generateProxyClass(final String var0, Class[] var1) {
ProxyGenerator var2 = new ProxyGenerator(var0, var1);
//生成代理類位元組碼檔案的真正方法
final byte[] var3 = var2.generateClassFile();
//儲存檔案
if(saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction() {
public Void run() {
try {
FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");
var1.write(var3);
var1.close();
return null;
} catch (IOException var2) {
throw new InternalError("I/O exception saving generated file: " + var2);
}
}
});
}
return var3;
}層層呼叫後，最終generateClassFile才是真正生成代理類位元組碼檔案的方法。
注意開頭的三個addProxyMethod方法是隻將Object的hashcode,equals,toString方法新增到代理方法容器中，代理類除此之外並沒有重寫其他Object的方法，所以除這三個方法外，代理類呼叫其他方法的行為與Object呼叫這些方法的行為一樣不通過Invoke
private byte[] generateClassFile() {
/addProxyMethod系列方法就是將介面的方法和Object的hashCode,equals,toString方法新增到代理方法容器(proxyMethods),
其中方法簽名作為key,proxyMethod作為value*/
/*hashCodeMethod方法位於靜態程式碼塊中通過Object物件獲得，hashCodeMethod=Object.class.getMethod("hashCode",new Class[0]),
相當於從Object中繼承過來了這三個方法equalsMethod,toStringMethod*/
this.addProxyMethod(hashCodeMethod, Object.class); -->
this.addProxyMethod(equalsMethod, Object.class);
this.addProxyMethod(toStringMethod, Object.class);
int var1;
int var3;
//獲得所有介面中的所有方法，並將方法新增到代理方法中
for(var1 = 0; var1 < this.interfaces.length; ++var1) {
Method[] var2 = this.interfaces[var1].getMethods();
for(var3 = 0; var3 < var2.length; ++var3) {
this.addProxyMethod(var2[var3], this.interfaces[var1]);
}
}
Iterator var7 = this.proxyMethods.values().iterator();
List var8;
while(var7.hasNext()) {
var8 = (List)var7.next();
checkReturnTypes(var8); //驗證具有相同方法簽名的的方法的返回值型別是否一致，因為不可能有兩個方法名相同,引數相同，而返回值卻不同的方法
};
//接下來就是寫代理類檔案的步驟了
Iterator var11
try {
//生成代理類的建構函式
this.methods.add(this.generateConstructor());
var7 = this.proxyMethods.values().iterator();
while(var7.hasNext()) {
var8 = (List)var7.next();
var11 = var8.iterator();
while(var11.hasNext()) {
ProxyGenerator.ProxyMethod var4 = (ProxyGenerator.ProxyMethod)var11.next();
/將代理欄位宣告為Method，10為ACC_PRIVATE和ACC_STATAIC的與運算，表示該欄位的修飾符為private static
所以代理類的欄位都是private static Method XXX*/
this.fields.add(new ProxyGenerator.FieldInfo(var4.methodFieldName, "Ljava/lang/reflect/Method;", 10));
//生成代理類的代理方法
this.methods.add(var4.generateMethod());
}
}
//為代理類生成靜態程式碼塊，對一些欄位進行初始化
this.methods.add(this.generateStaticInitializer());
} catch (IOException var6) {
throw new InternalError("unexpected I/O Exception");
}
if(this.methods.size() > '\uffff') { //代理方法超過65535將丟擲異常
throw new IllegalArgumentException("method limit exceeded");
} else if(this.fields.size() > '\uffff') { //代理類的欄位超過65535將丟擲異常
throw new IllegalArgumentException("field limit exceeded");
} else {
//這裡開始就是一些代理類檔案的過程，此過程略過
this.cp.getClass(dotToSlash(this.className));
this.cp.getClass("java/lang/reflect/Proxy");
for(var1 = 0; var1 < this.interfaces.length; ++var1) {
this.cp.getClass(dotToSlash(this.interfaces[var1].getName()));
}
this.cp.setReadOnly();
ByteArrayOutputStream var9 = new ByteArrayOutputStream();
DataOutputStream var10 = new DataOutputStream(var9);
try {
var10.writeInt(-889275714);
var10.writeShort(0);
var10.writeShort(49);
this.cp.write(var10);
var10.writeShort(49);
var10.writeShort(this.cp.getClass(dotToSlash(this.className)));
var10.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
var10.writeShort(this.interfaces.length);
for(var3 = 0; var3 < this.interfaces.length; ++var3) {
var10.writeShort(this.cp.getClass(dotToSlash(this.interfaces[var3].getName())));
}
var10.writeShort(this.fields.size());
var11 = this.fields.iterator();
while(var11.hasNext()) {
ProxyGenerator.FieldInfo var12 = (ProxyGenerator.FieldInfo)var11.next();
var12.write(var10);
}
var10.writeShort(this.methods.size());
var11 = this.methods.iterator();
while(var11.hasNext()) {
ProxyGenerator.MethodInfo var13 = (ProxyGenerator.MethodInfo)var11.next();
var13.write(var10);
}
var10.writeShort(0);
return var9.toByteArray();
} catch (IOException var5) {
throw new InternalError("unexpected I/O Exception");
}
}
}addProxyMethod方法剖析
private void addProxyMethod(Method var1, Class var2) {
String var3 = var1.getName(); //方法名
Class[] var4 = var1.getParameterTypes(); //方法引數型別陣列
Class var5 = var1.getReturnType(); //返回值型別
Class[] var6 = var1.getExceptionTypes(); //異常型別
String var7 = var3 + getParameterDescriptors(var4); //方法簽名
Object var8 = (List)this.proxyMethods.get(var7); //根據方法簽名卻獲得proxyMethods的Value
if(var8 != null) { //處理多個代理介面中重複的方法的情況
Iterator var9 = ((List)var8).iterator();
while(var9.hasNext()) {
ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();
if(var5 == var10.returnType) {
/*歸約異常型別以至於讓重寫的方法丟擲合適的異常型別，我認為這裡可能是多個介面中有相同的方法，而這些相同的方法丟擲的異常類 型又不同，所以對這些相同方法丟擲的異常進行了歸約*/
ArrayList var11 = new ArrayList();
collectCompatibleTypes(var6, var10.exceptionTypes, var11);
collectCompatibleTypes(var10.exceptionTypes, var6, var11);
var10.exceptionTypes = new Class[var11.size()];
//將ArrayList轉換為Class物件陣列
var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);
return;
}
}
} else {
var8 = new ArrayList(3);
this.proxyMethods.put(var7, var8);
}
((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null));
/*24~27行的意思就是如果var8為空，就建立一個數組，並以方法簽名為key,proxymethod物件陣列為value新增到proxyMethods*/
} 在動態代理中InvocationHandler是核心，每個代理例項都具有一個關聯的呼叫處理程式(InvocationHandler)。對代理例項呼叫方法時，將對方法呼叫進行編碼並將其指派到它的呼叫處理程式(InvocationHandler)的 invoke 方法。所以對代理方法的呼叫都是通InvocationHadler的invoke來實現中，而invoke方法根據傳入的代理物件，方法和引數來決定呼叫代理的哪個方法
invoke方法簽名：invoke（Object Proxy，Method method，Object[] args）
$Proxy0.class
來看看例1(MyProxy)的代理類是怎樣的？
public final class $Proxy0 extends Proxy implements IHello { //繼承了Proxy類和實現IHello介面
//變數，都是private static Method XXX
private static Method m3;
private static Method m1;
private static Method m0;
private static Method m2;
//代理類的建構函式，其引數正是是InvocationHandler例項，Proxy.newInstance方法就是通過通過這個建構函式來建立代理例項的
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
//介面代理方法
public final void sayHello() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
//以下Object中的三個方法
public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final int hashCode() throws {
try {
return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
} 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);
}
}
//對變數進行一些初始化工作
static {
try {
m3 = Class.forName("com.mobin.proxy.IHello").getMethod("sayHello", new Class[0]);
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}