jdk动态代理
一般的代码套路
定义接口
public interface ProxyInterface {
void method();
}
定义接口实现类
public class ProxyInterfaceImpl implements ProxyInterface {
@Override
public void method() {
System.out.println("ProxyInterfaceImpl method");
}
}
自定义handler，完成自定义代理的业务逻辑
public class ProxyHandler implements InvocationHandler {
Object proxyObject =null;
public ProxyHandler(Object object){
this.proxyObject = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理开始");
method.invoke(proxyObject,args);
System.out.println("代理结束");
return null;
}
public static void main(String[] args) {
ProxyInterfaceImpl proxyInterface = new ProxyInterfaceImpl();
ProxyHandler proxyHandler= new ProxyHandler(proxyInterface);
ProxyInterface proxyInterface1 =(ProxyInterface) Proxy.newProxyInstance(proxyHandler.getClass().getClassLoader(),proxyInterface.getClass().getInterfaces(),proxyHandler);
proxyInterface1.method();
}
}
核心代码一共做了以下几件事
- 在ProxyHandler中的invoke方法中写上你要添加的业务逻辑，这里我写了两个输出
- 通过Proxy类的静态方法newProxyInstance生成代理类。
- 调用代理类的方法
我们先从代理类的生成开始分析
/** Returns an instance of a proxy class for the specified interfaces
* that dispatches method invocations to the specified invocation
* handler.*/
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
文档的意思：该方法为一个特定的接口（其方法被分发在一个特定的handler，翻译的不是很准）返回一个代理实例
方法接受的参数：
- 指定哪个类加载器去加载生成的代理类
- 代理类所实现的接口
- 实现业务逻辑的InvocationHandler
newProxyInstance方法实现做了两件事
- 获取代理类的class对象（这是我们关注的重点：如何生成代理类的class对象，其里面的方法逻辑又是怎么样的，得到这个之后，后面就实例化，方法调用即可）
- 实例化该class对象
代理类的class对象生成逻辑
Class<?> cl = getProxyClass0(loader, intfs); //传入类加载和接口
/**
* Generate a proxy class. Must call the checkProxyAccess method
* to perform permission checks before calling this.
*/
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
}
这里用到了缓存，其中cache的生成在proxy中
/**
* a cache of proxy classes
*/
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
代理类的生成逻辑就在ProxyClassFactory 这个函数中,精简后代码如下
/**
* A factory function that generates, defines and returns the proxy class given
* the ClassLoader and array of interfaces.
*/
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy";
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
}
}
}
主要做了：
- 为代理类生成name，可以看到代理类name都含有$proxy
- 生成字节数组，说白了就是字节码文件，所以代理类生成的核心就在这，ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);这个方法是如何生成我们所需要的字节码。 - 返回代理类class对象，之后便可以通过这个class对象实例化代理类，然后调用方法。
接下来重点分ProxyGenerator.generateProxyClass(),其主要实现在以下代码中
private byte[] generateClassFile() {
this.addProxyMethod(hashCodeMethod, Object.class);
this.addProxyMethod(equalsMethod, Object.class);
this.addProxyMethod(toStringMethod, Object.class);
Class[] var1 = this.interfaces;
int var2 = var1.length;
int var3;
Class var4;
// 遍历没个实现的接口
for(var3 = 0; var3 < var2; ++var3) {
var4 = var1[var3];
Method[] var5 = var4.getMethods();
int var6 = var5.length;
//遍历每个接口的每个方法
for(int var7 = 0; var7 < var6; ++var7) {
Method var8 = var5[var7];
//将每个接口和方法调用该函数
this.addProxyMethod(var8, var4);
}
}
Iterator var11 = this.proxyMethods.values().iterator();
// 获取每个方法的返回类型
Iterator var15;
try {
this.methods.add(this.generateConstructor());
var11 = this.proxyMethods.values().iterator();
while(var11.hasNext()) {
var12 = (List)var11.next();
var15 = var12.iterator();
while(var15.hasNext()) {
ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
//准备好字段信息
this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
this.methods.add(var16.generateMethod());
}
}
this.methods.add(this.generateStaticInitializer());
} catch (IOException var10) {
throw new InternalError("unexpected I/O Exception", var10);
}
if (this.methods.size() > 65535) {
throw new IllegalArgumentException("method limit exceeded");
} else if (this.fields.size() > 65535) {
throw new IllegalArgumentException("field limit exceeded");
} else {
this.cp.getClass(dotToSlash(this.className));
this.cp.getClass("java/lang/reflect/Proxy");
var1 = this.interfaces;
var2 = var1.length;
ByteArrayOutputStream var13 = new ByteArrayOutputStream();
DataOutputStream var14 = new DataOutputStream(var13);
try {
var14.writeInt(-889275714);
var14.writeShort(0);
var14.writeShort(49);
this.cp.write(var14);
var14.writeShort(this.accessFlags);
var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
var14.writeShort(this.interfaces.length);
Class[] var17 = this.interfaces;
int var18 = var17.length;
for(int var19 = 0; var19 < var18; ++var19) {
Class var22 = var17[var19];
var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
}
var14.writeShort(this.fields.size());
var15 = this.fields.iterator();
while(var15.hasNext()) {
ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
var20.write(var14);
}
var14.writeShort(this.methods.size());
var15 = this.methods.iterator();
while(var15.hasNext()) {
ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
var21.write(var14);
}
var14.writeShort(0);
return var13.toByteArray();
} catch (IOException var9) {
throw new InternalError("unexpected I/O Exception", var9);
}
}
}
总结一下这么长的代码到底在干什么，其实如果对java字节码的格式有了解，一眼就看出来，这段代码拼凑字节码，将方法，字段，常量池等信息按照顺序，按照格式一个一个拼起来。举个例子， var14.writeInt(-889275714);这是写第一个字段，4个字节，这不就是詹爷定义的魔数嘛。
知道了代理类是怎么生成的之后，我们来看下生成的代理类长什么样子
package com.sun.proxy;
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 ProxyInterface {
private static Method m1;
private static Method m2;
private static Method m3;
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 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 method() 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.czj.proxy.ProxyInterface").getMethod("method");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
代理类继承了proxy类，所以jdk的动态代理不能通过继承的方式实现。我们主要关注两个方法
- 构造方法。
- method，我们自定义的方法。
构造方法接受一个InvocationHandler，这个handler肯定是我们实例化时传进去的那个，然后调用父类也就是Proxy的构造方法。再来看我们自己实现的method， super.h.invoke(this, m3, (Object[])null);说白了就是执行handler的invoke方法。
这里肯定就是执行了我们自定义的handler，再贴下代码。
public class ProxyHandler implements InvocationHandler {
Object proxyObject =null;
public ProxyHandler(Object object){
this.proxyObject = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理开始");
method.invoke(proxyObject,args);
System.out.println("代理结束");
return null;
}
这里invoke方法里的invoke用到了反射的原理，其中参数method是接口ProxyInterface声明的方法对象，proxyObject是该接口的实现类，没了解过反射原理的同学想必也知道这里是在调用我们接口实现类proxyObject的method方法。
好了，说完了，总结一下
jdk动态代理流程：
通过继承代理类，实现被代理类的实现的接口，赋值handler，真正执行方法调用时，代理类自己不执行方法而是通过handler执行方法调用，handler的调用方法invoke中除了包含自己要为被代理类提供的业务逻辑，还需要通过反射执行被代理类的方法。
好处：
- 动态代理较于静态代理（类似装饰模式）可以不需要为每一个被代理类都生成一个代理类，只需要为一个接口编写一个handler便可以为实现该接口的所有类生成代理类。这句话很重要，仔细理解。
坏处：
- 无法为不是实现接口的类代理。
思考：
动态的意思：代理类的class是在程序运行时动态生成的，编译时是不存在的，上面的代理类class默认是不会写到本地磁盘的。
handler和代理类的服务域：一个代理类可以为某一类接口的实现类服务，而一个handler可以为所有需要代理的业务逻辑一样的类服务。
生成代理类时，这种直接生成字节码的方式性能好坏或者有没有更好的方式。
第一篇博客，小菜鸡在通往大神的路上需要再接再厉，下一篇分析cglib。
