靜態(tài)代理和動態(tài)代理的區(qū)別
image.png
靜態(tài)代理：
在代理之前，所有方法都是已知的，且如果被代理的類新增新的方法，代理的類也需要更改。
動態(tài)代理：
在代理之前，所有的方法都是未知的，如果被代理的類新增新的方法，動態(tài)代理的類不需要更改（因為是動態(tài)生成的）
靜態(tài)代理繞過，僅僅介紹動態(tài)代理：
假設(shè)成武這個人需要找對象，租房子，買東西，然后找工作，需要找人代理做這些
public interface Person {
public void findLove();
public void zufangzi();
public void buy();
public void findJob();
}
然后一個被代理的類（成武類）需要實現(xiàn)這個接口
public class Chengwu implements Person{
public void findLove(){
System.out.println("白富美");
System.out.println("溫柔");
System.out.println("身材好");
}
@Override
public void zufangzi() {
System.out.println("租房子");
}
@Override
public void buy() {
System.out.println("買東西");
}
@Override
public void findJob() {
System.out.println("月薪20K-50k");
System.out.println("找工作");
}
}
接下來創(chuàng)建一個JDK58代理的類
public class JDK58 implements InvocationHandler{
//被代理的對象，把引用給保存下來
private Person target;
public Object getInstance(Person target) throws Exception{
this.target = target;
Class<?> clazz = target.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//這里就是調(diào)用方法之前做的事情
System.out.println("我是58：我要給你找工作，現(xiàn)在已經(jīng)拿到你的簡歷");
System.out.println("開始投遞");
method.invoke(this.target,args);
//這里是調(diào)用方法之后做的事情
System.out.println("安排面試");
return null;
}
}
調(diào)用者（客戶端）類
public class JDKProxyTest {
public static void main(String[] args) {
try {
Person obj = (Person)new JDK58().getInstance(new Chengwu ());
//該類是$開頭，而JDK中有個規(guī)范，只要要是$開頭的一般都是自動生成的
System.out.println(obj.getClass());
obj.findJob();
//通過反編譯工具可以查看class文件源代碼
/*
byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{Person.class});
FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
os.write(bytes);
os.close();*/
} catch (Exception e) {
e.printStackTrace();
}
}
}
如果去掉客戶端的代碼注釋，會在E盤生成一個Person動態(tài)代理的class文件，名為$Proxy0,用反編譯工具查看如下：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
import com.demo.Person;
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 Person {
private static Method m1;
private static Method m5;
private static Method m2;
private static Method m6;
private static Method m3;
private static Method m4;
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 findLove() throws {
try {
super.h.invoke(this, m5, (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 void zufangzi() throws {
try {
super.h.invoke(this, m6, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void buy() 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 findJob() throws {
try {
super.h.invoke(this, m4, (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"));
m5 = Class.forName("com.demo.Person").getMethod("findLove");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m6 = Class.forName("com.demo.Person").getMethod("zufangzi");
m3 = Class.forName("com.demo.Person").getMethod("buy");
m4 = Class.forName("com.demo.Person").getMethod("findJob");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
該class文件會被裝載到JVM中執(zhí)行。
總結(jié)一下JDK動態(tài)代理的原理：
1、拿到被代理對象的引用，并且獲取到它的所有的接口，反射獲取
2、JDK Proxy類重新生成一個新的類、同時新的類要實現(xiàn)被代理類所有實現(xiàn)的所有的接口
3、動態(tài)生成Java代碼，把新加的業(yè)務(wù)邏輯方法由一定的邏輯代碼去調(diào)用（在代碼中體現(xiàn)）
4、編譯新生成的Java代碼.class，下面的代碼就實現(xiàn)了
5、再重新加載到JVM中運行
以上這個過程也叫字節(jié)碼重組
