鸡汤
在超凡入圣与无恶不作之间还有第三种抉择，这是所有成熟的成年人都会选择的一条路。因此你会在得失之间求得平衡，两害相权取其轻，尽力将善意放在前面。。
--《肖申克的救赎》
我们都知道JAVA实现动态代理最常用的两种方式就是JDK动态代理和CGLIB动态代理。
JDK动态代理
JDK动态代理是基于reflect包下的Proxy类等实现的，只能代理接口方法。
CGLIB动态代理
CGLIB封装了ASM，通过非常底层的字节码技术织入横切逻辑。CGLIB代理的对象无需实现接口。
Javassist
相对于ASM直接操作字节码指令，需要使用者掌握Java类字节码文件格式及指令，Javassist提供了更高级的API，执行效率相对较差，但不需要掌握字节码指令的知识。
动态代理的实现
接下来我们使用Javassist模仿JDK动态代理的实现。以此来了解动态代理的实现原理（JDK和CGLIB在代理类生成的原理上都是差不多的，个人理解）
先看演示效果：
定义接口Move：
public interface Move {
void move();
}
定义类Walk实现Move接口：
public class Walk implements Move {
@Override
public void move() {
System.out.println("I'm Walking");
}
}
实现自定义接口InvocationHandler：
public class DefaultInvocation implements InvocationHandler {
private Object target;
public DefaultInvocation(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
System.out.println("before invoke ");
Object obj = method.invoke(target,args);
System.out.println("after invoke ");
return obj;
}
}
代理测试：
public class Test {
public static void main(String[] args) throws Exception {
Object proxy = Proxy.newProxyInstance(Walk.class.getClassLoader(),
Walk.class, new DefaultInvocation(new Walk()));
((Move) proxy).move();
}
}
运行结果：
before invoke
I'm Walking
after invoke
我们来看编译后的class文件
image.png
发现程序编译后会生成一个dynagent$Proxy0.class文件，这个文件就是我们动态生成的字节码文件，反编译后如下:
public class dynagent$Proxy0 extends Proxy implements Move {
private Method method0 = Class.forName("org.liuhao.javassist.dynagent.Move").getDeclaredMethods()[0];
public void move() {
Proxy.invocationHandler.invoke(this, this.method0, new Object[0]);
}
public dynagent$Proxy0(InvocationHandler var1) {
super(var1);
}
}
这便是动态代理的原理了，method0属性实际上就是被代理接口Move的move()方法，动态生成的代理类会生成一个同样的move()方法，当我们调用move()方法时，实际上是调用了invocationHandler的invoke()方法，由此实现了方法的横切。
通过Javassist组件能够让字节码的织入变得非常的简单，并且拥有更高的可读性。具体的实现如下：
定义接口InvocationHandler：
public interface InvocationHandler {
Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException;
}
定义核心代理类Proxy：
public class Proxy {
private static final String PREFIX = "$Proxy";
private static final AtomicInteger SUFFIX = new AtomicInteger(0);
protected static InvocationHandler invocationHandler;
protected Proxy(InvocationHandler invocationHandler) {
this.invocationHandler = invocationHandler;
}
public static Object newProxyInstance(ClassLoader loader, Class<?> targetClass, InvocationHandler h) throws Exception {
invocationHandler = h;
ClassPool pool = ClassPool.getDefault();
CtClass ctClass = pool.get(targetClass.getName());
CtClass proxyCls = pool.makeClass(generateName(ctClass));
int methodIndex = 0;
CtClass[] interfaces = ctClass.getInterfaces();
//将Proxy类设置成父类 关键！！！
proxyCls.setSuperclass(pool.get(Proxy.class.getName()));
for (int i = 0; i < interfaces.length; i++) {
CtClass ctInter = interfaces[i];
proxyCls.addInterface(ctInter);
CtMethod[] methods = ctInter.getDeclaredMethods();
for (int j = 0; j < methods.length; j++) {
String fieldSrc = String.format("private java.lang.reflect.Method method%d = " +
"Class.forName(\"%s\").getDeclaredMethods()[%d];", methodIndex, ctInter.getName(), i);
CtField field = CtField.make(fieldSrc, proxyCls);
proxyCls.addField(field);
CtMethod ctMethod = methods[i];
generateMethod(proxyCls, ctMethod, pool, methodIndex);
}
methodIndex++;
}
//生成构造函数
generateConstructor(pool, proxyCls);
// 持久化class到硬盘
proxyCls.writeFile(Proxy.class.getResource("/").getPath());
return proxyCls.toClass(loader, null).getConstructor(InvocationHandler.class).newInstance(invocationHandler);
}
private static void generateConstructor(ClassPool pool, CtClass proxy) throws NotFoundException, CannotCompileException {
CtConstructor ctConstructor = new CtConstructor(new CtClass[]{pool.get(InvocationHandler.class.getName())}, proxy);
String methodBodySrc = String.format("super(%s);", "$1");
ctConstructor.setBody(methodBodySrc);
proxy.addConstructor(ctConstructor);
}
/**
* 生成代理方法
* 横切的实现
* @param proxyClass
* @param ctMethod
* @param pool
* @param methodIndex
*/
private static void generateMethod(CtClass proxyClass, CtMethod ctMethod, ClassPool pool, int methodIndex) throws Exception {
String body = String.format("super.invocationHandler.invoke(this,method%d,$args);", methodIndex);
CtMethod method = CtNewMethod.make(ctMethod.getModifiers(), ctMethod.getReturnType(),
ctMethod.getName(), ctMethod.getParameterTypes(), ctMethod.getExceptionTypes(), body, proxyClass);
proxyClass.addMethod(method);
}
/**
* 生成全限定代理类名
*
* @param ctClass
* @return
*/
private static String generateName(CtClass ctClass) {
String packageName = ctClass.getPackageName();
return packageName + PREFIX + SUFFIX.getAndIncrement();
}
到此，我们的动态代理功能就已经全部实现。当然，了解原理之后，要实现无需接口的动态代理也就是很简单的事情了。
