溫馨提示×
您好，登錄后才能下訂單哦！
點(diǎn)擊 登錄注冊(cè) 即表示同意《億速云用戶服務(wù)條款》
您好，登錄后才能下訂單哦！
摘要
相比于靜態(tài)代理，動(dòng)態(tài)代理避免了開(kāi)發(fā)人員編寫各個(gè)繁鎖的靜態(tài)代理類，只需簡(jiǎn)單地指定一組接口及目標(biāo)類對(duì)象就能動(dòng)態(tài)的獲得代理對(duì)象。
代理模式
使用代理模式必須要讓代理類和目標(biāo)類實(shí)現(xiàn)相同的接口，客戶端通過(guò)代理類來(lái)調(diào)用目標(biāo)方法，代理類會(huì)將所有的方法調(diào)用分派到目標(biāo)對(duì)象上反射執(zhí)行，還可以在分派過(guò)程中添加"前置通知"和后置處理（如在調(diào)用目標(biāo)方法前校驗(yàn)權(quán)限，在調(diào)用完目標(biāo)方法后打印日志等）等功能。
使用動(dòng)態(tài)代理的五大步驟
1.通過(guò)實(shí)現(xiàn)InvocationHandler接口來(lái)自定義自己的InvocationHandler;
2.通過(guò)Proxy.getProxyClass獲得動(dòng)態(tài)代理類
3.通過(guò)反射機(jī)制獲得代理類的構(gòu)造方法，方法簽名為getConstructor(InvocationHandler.class)
4.通過(guò)構(gòu)造函數(shù)獲得代理對(duì)象并將自定義的InvocationHandler實(shí)例對(duì)象傳為參數(shù)傳入
5.通過(guò)代理對(duì)象調(diào)用目標(biāo)方法
動(dòng)態(tài)代理的使用
例1(方式一)
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{
//目標(biāo)對(duì)象
private Object target;
public HWInvocationHandler(Object target){
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("------插入前置通知代碼-------------");
//執(zhí)行相應(yīng)的目標(biāo)方法
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");
//獲取動(dòng)態(tài)代理類
Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);
//獲得代理類的構(gòu)造函數(shù)，并傳入?yún)?shù)類型InvocationHandler.class
Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);
//通過(guò)構(gòu)造函數(shù)來(lái)創(chuàng)建動(dòng)態(tài)代理對(duì)象，將自定義的InvocationHandler實(shí)例傳入
IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello()));
//通過(guò)代理對(duì)象調(diào)用目標(biāo)方法
iHello.sayHello();
}
}
輸出：
------插入前置通知代碼-------------
Hello world!!
------插入后置處理代碼-------------
Proxy類中還有個(gè)將2~4步驟封裝好的簡(jiǎn)便方法來(lái)創(chuàng)建動(dòng)態(tài)代理對(duì)象，其方法簽名為：newProxyInstance(ClassLoader loader,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();
}
輸出結(jié)果一樣.
下面以newProxyInstance方法為切入點(diǎn)來(lái)剖析代理類的生成及代理方法的調(diào)用
（為了篇幅整潔去掉了次要的代碼）
public static Object newProxyInstance(ClassLoader loader,
Class<!--?-->[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) { //如果h為空直接拋出異常，所以InvocationHandler實(shí)例對(duì)象是必須的
throw new NullPointerException();
}
//對(duì)象的拷貝,暫不知道這里拷貝下的意義是啥？
final Class<!--?-->[] intfs = interfaces.clone();
//一些安全的權(quán)限檢查
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//產(chǎn)生代理類
Class<!--?--> cl = getProxyClass0(loader, intfs);
//獲取代理類的構(gòu)造函數(shù)對(duì)象
//參數(shù)constructorParames為常量值：private static final Class<!--?-->[] constructorParams = { InvocationHandler.class };
final Constructor<!--?--> cons = cl.getConstructor(constructorParames);
final InvocationHandler ih = h;
//根據(jù)代理類的構(gòu)造函數(shù)對(duì)象來(lái)創(chuàng)建代理類對(duì)象
return newInstance(cons, ih);
}
這段代碼就是對(duì)代理類對(duì)象的創(chuàng)建，就是對(duì)例1中34~38行封裝，其中g(shù)etProxyClass0就是生成代理類的方法
getProxyClass0方法剖析
private static Class<!--?--> getProxyClass0(ClassLoader loader,
Class<!--?-->... interfaces) {
//接口數(shù)不得超過(guò)65535個(gè)
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//代理類緩存，如果緩存中有代理類了直接返回，否則將由ProxyClassFactory創(chuàng)建代理類
return proxyClassCache.get(loader, interfaces);
}
看看ProxyClassFactory是怎樣生成代理類的?
private static final class ProxyClassFactory
implements BiFunction<classloader, class<?="">[], Class<!--?-->>
{
//統(tǒng)一代理類的前綴名都以$Proxy開(kāi)關(guān)
private static final String proxyClassNamePrefix = "$Proxy";
//使用唯一的編號(hào)給作為代理類名的一部分，如$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) {
//驗(yàn)證指定的類加載器(loader)加載接口所得到的Class對(duì)象(interfaceClass)是否與intf對(duì)象相同
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");
}
//驗(yàn)證該Class對(duì)象是不是接口
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
// 驗(yàn)證該接口是否重復(fù)了
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
//聲明代理類所在包
String proxyPkg = null;
/*驗(yàn)證你傳入的接口中是否有非public接口，只要有一個(gè)接口是非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包下如果報(bào)java.io.FileNotFoundException: com\sun\proxy\$Proxy0.c lass (系統(tǒng)找不到指定的路徑。)的錯(cuò)誤，就先在你項(xiàng)目中創(chuàng)建com.sun.proxy路徑*/
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
//將當(dāng)前nextUniqueNumber的值以原子的方式的加1，所以第一次生成代理類的名字為$Proxy0.class
long num = nextUniqueNumber.getAndIncrement();
//代理類的完全限定名，如com.sun.proxy.$Proxy0.calss,
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//生成代理類字節(jié)碼文件
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}</class<?></classloader,>
而生成代理類字節(jié)碼文件又主要通過(guò)ProxyGenerate的generateProxyClass(proxyName，interfaces)
public static byte[] generateProxyClass(final String var0, Class[] var1) {
ProxyGenerator var2 = new ProxyGenerator(var0, var1);
//生成代理類字節(jié)碼文件的真正方法
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;
}
層層調(diào)用后，最終generateClassFile才是真正生成代理類字節(jié)碼文件的方法，注意開(kāi)頭的三個(gè)addProxyMethod方法是只將Object的hashcode,equals,toString方法添加到代理方法容器中，代理類除此之外并沒(méi)有重寫其他Object的方法，所以除這三個(gè)方法外，代理類調(diào)用其他方法的行為與Object調(diào)用這些方法的行為一樣不通過(guò)Invoke
private byte[] generateClassFile() {
/addProxyMethod系列方法就是將接口的方法和Object的hashCode,equals,toString方法添加到代理方法容器(proxyMethods),
其中方法簽名作為key,proxyMethod作為value*/
/*hashCodeMethod方法位于靜態(tài)代碼塊中通過(guò)Object對(duì)象獲得，hashCodeMethod=Object.class.getMethod("hashCode",new Class[0]),
相當(dāng)于從Object中繼承過(guò)來(lái)了這三個(gè)方法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); //驗(yàn)證具有相同方法簽名的的方法的返回值類型是否一致，因?yàn)椴豢赡苡袃蓚€(gè)方法名相同,參數(shù)相同，而返回值卻不同的方法
};
//接下來(lái)就是寫代理類文件的步驟了
Iterator var11
try {
//生成代理類的構(gòu)造函數(shù)
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的與運(yùn)算，表示該字段的修飾符為private static
所以代理類的字段都是private static Method XXX*/
this.fields.add(new ProxyGenerator.FieldInfo(var4.methodFieldName, "Ljava/lang/reflect/Method;", 10));
//生成代理類的代理方法
this.methods.add(var4.generateMethod());
}
}
//為代理類生成靜態(tài)代碼塊，對(duì)一些字段進(jìn)行初始化
this.methods.add(this.generateStaticInitializer());
} catch (IOException var6) {
throw new InternalError("unexpected I/O Exception");
}
if(this.methods.size() > '\uffff') { //代理方法超過(guò)65535將拋出異常
throw new IllegalArgumentException("method limit exceeded");
} else if(this.fields.size() > '\uffff') { //代理類的字段超過(guò)65535將拋出異常
throw new IllegalArgumentException("field limit exceeded");
} else {
//這里開(kāi)始就是一些代理類文件的過(guò)程，此過(guò)程略過(guò)
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(); //方法參數(shù)類型數(shù)組
Class var5 = var1.getReturnType(); //返回值類型
Class[] var6 = var1.getExceptionTypes(); //異常類型
String var7 = var3 + getParameterDescriptors(var4); //方法簽名
Object var8 = (List)this.proxyMethods.get(var7); //根據(jù)方法簽名卻獲得proxyMethods的Value
if(var8 != null) { //處理多個(gè)代理接口中重復(fù)的方法的情況
Iterator var9 = ((List)var8).iterator();
while(var9.hasNext()) {
ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();
if(var5 == var10.returnType) {
/*歸約異常類型以至于讓重寫的方法拋出合適的異常類型，我認(rèn)為這里可能是多個(gè)接口中有相同的方法，而這些相同的方法拋出的異常類 型又不同，所以對(duì)這些相同方法拋出的異常進(jìn)行了歸約*/
ArrayList var11 = new ArrayList();
collectCompatibleTypes(var6, var10.exceptionTypes, var11);
collectCompatibleTypes(var10.exceptionTypes, var6, var11);
var10.exceptionTypes = new Class[var11.size()];
//將ArrayList轉(zhuǎn)換為Class對(duì)象數(shù)組
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為空，就創(chuàng)建一個(gè)數(shù)組，并以方法簽名為key,proxymethod對(duì)象數(shù)組為value添加到proxyMethods*/
}
InvocationHandler的作用
在動(dòng)態(tài)代理中InvocationHandler是核心，每個(gè)代理實(shí)例都具有一個(gè)關(guān)聯(lián)的調(diào)用處理程序(InvocationHandler)。對(duì)代理實(shí)例調(diào)用方法時(shí)，將對(duì)方法調(diào)用進(jìn)行編碼并將其指派到它的調(diào)用處理程序(InvocationHandler)的 invoke 方法。所以對(duì)代理方法的調(diào)用都是通InvocationHadler的invoke來(lái)實(shí)現(xiàn)中，而invoke方法根據(jù)傳入的代理對(duì)象，方法和參數(shù)來(lái)決定調(diào)用代理的哪個(gè)方法
invoke方法簽名：invoke（Object Proxy，Method method，Object[] args）
$Proxy0.class
來(lái)看看例1(MyProxy)的代理類是怎樣的？
public final class $Proxy0 extends Proxy implements IHello { //繼承了Proxy類和實(shí)現(xiàn)IHello接口
//變量，都是private static Method XXX
private static Method m3;
private static Method m1;
private static Method m0;
private static Method m2;
//代理類的構(gòu)造函數(shù)，其參數(shù)正是是InvocationHandler實(shí)例，Proxy.newInstance方法就是通過(guò)通過(guò)這個(gè)構(gòu)造函數(shù)來(lái)創(chuàng)建代理實(shí)例的
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中的三個(gè)方法
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);
}
}
//對(duì)變量進(jìn)行一些初始化工作
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());
}
}
}
以上就是對(duì)代理類如何生成，代理類方法如何被調(diào)用的分析！在很多框架都使用了動(dòng)態(tài)代理如Spring,HDFS的RPC調(diào)用等等，分析過(guò)程中收獲很多，如果想深入的了解JDK動(dòng)態(tài)代理機(jī)制一定要深入到源碼去剖析??！希望對(duì)大家的學(xué)習(xí)有所幫助，也希望大家多多支持億速云。
免責(zé)聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如果涉及侵權(quán)請(qǐng)聯(lián)系站長(zhǎng)郵箱：is@yisu.com進(jìn)行舉報(bào)，并提供相關(guān)證據(jù)，一經(jīng)查實(shí)，將立刻刪除涉嫌侵權(quán)內(nèi)容。
億速云公眾號(hào)
手機(jī)網(wǎng)站二維碼