介绍
代理模式涉及到三个对象
行为接口
真实对象
代理对象
行为接口
/**
* 代理抽象角色: 定义了服务的接口
*/
public interface Massage {
void massage();
}
真实对象
/**
* 实实现类: Qit
*/
public class Qit implements Massage, Wash {
@Override
public void massage() {
System.out.println("Qit发了个消息");
}
@Override
public void wash() {
}
}
代理对象
/**
* 代理对象:经纪人
*/
public class Agent implements Massage {
private final Massage massage;
public Agent(Massage massage) {
this.massage = massage;
}
//....前置处理
public void before() {
System.out.println("前置处理");
}
//....后置处理
public void after() {
System.out.println("后置处理");
}
@Override
public void massage() {
before();
massage.massage();
after();
}
}
ok~
静态代理
public static void main(String[] args) throws Exception {
//静态代理
Massage message = new Qit();
Agent agent = new Agent(message);
agent.massage();
}
> Task :lib:MyClass.main()
前置处理
Qit发了个消息
后置处理
代理成功。我们可以看到Qit不只实现了Message接口,还实现了Wash接口,若要代理Wash接口就需要再创建一个经纪人代理对象,如何才能不增加类的同事代理多个接口呢?
动态代理
public static void main(String[] args) {
Qit qit = new Qit();
Object o = Proxy.newProxyInstance(MyClass.class.getClassLoader(),
new Class[]{Massage.class,Wash.class}, new InvocationHandler() {
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
// System.out.println(o.toString());//会导致无限进入此回调,栈溢出。
System.out.println("前置处理");
method.invoke(qit,objects);
System.out.println("后置处理");
return o;
}
});
Massage massage = (Massage) o;
massage.massage();
Wash wash = (Wash) o;
wash.wash();
}
> Task :lib:MyClass.main()
前置处理
Qit发了个消息
后置处理
前置处理
后置处理
动态代理源码分析
先贴源码$Proxy
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
// Android-removed: SecurityManager calls
/*
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
*/
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
// Android-removed: SecurityManager / permission checks.
/*
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
*/
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
// BEGIN Android-removed: Excluded AccessController.doPrivileged call.
/*
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
*/
cons.setAccessible(true);
// END Android-removed: Excluded AccessController.doPrivileged call.
}
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
调用newProxyInstance
只能代理接口,拷贝接口得到Class[]
final Class<?>[] intfs = interfaces.clone();
查找或生成指定的代理类
Class<?> cl = getProxyClass0(loader, intfs);
获取Class的构造方法
final Constructor<?> cons = cl.getConstructor(constructorParams);
类的完整生命周期
动态代理会帮助我们在内存中生成一个Class对象
通过Proxy.class$class ProxyClassFactory生成.class也就是byte[]
byte[] var22 = ProxyGenerator.generateProxyClass(var23, var2, var17);
再由byte[]生成Class对象
return Proxy.defineClass0(var1, var23, var22, 0, var22.length);
我们通过IO流写入查看动态代理生成的.class
String name = Qit.class.getName() + "$Proxy0";
byte[] bytes = ProxyGenerator.generateProxyClass(name, new Class[]{TestProxy.class});
FileOutputStream fos = new FileOutputStream("lib/" + name + ".class");
fos.write(bytes);
fos.close();
得到.class文件,可以看出构造时传入InvocationHandler对象,由他调用invoke方法触发回调
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.enjoy.lib;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class Massage$Proxy0 extends Proxy implements Massage {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public Massage$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 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 massage() throws {
try {
super.h.invoke(this, m3, (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"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.enjoy.lib.Massage").getMethod("massage");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}