ASM、Javassist、JDK、CGLIB
ASM/Javassist/JDK/CGLIB
简介
ASM是一款基于java字节码层面的代码分析和修改工具。
ASM的目标是生成，转换和分析已编译的java class文件，可使用ASM工具读／写／转换JVM指令集。
ASM工具提供两种方式来产生和转换已编译的class文件，它们分别是基于事件和基于对象的表示模型。
其中，基于事件的表示模型使用一个有序的事件序列表示一个class文件，class文件中的每一个元素使用一个事件来表示，比如class的头部，变量，方法声明，JVM指令都有相对应的事件表示
ASM使用自带的事件解析器能将每一个class文件解析成一个事件序列。而基于对象的表示模型则使用对象树结构来解析每一个class文件。
起点和终点分别是ClassReader（Class文件解析器）、ClassWriter（class事件序列转换到class字节码），中间的过程由若干个自定义的事件过滤器组成
JAVA动态性的两种常见实现方式
- 字节码操作
- 反射
运行时操作字节码可以让我们实现如下功能
- 动态生成新的类
- 动态改变某个类的结构（添加/删除/修改/添加新的属性/方法）
常见的字节码操作类库
- BCEL
- ASM
- CGLIB
- javassist
操作java字节码的工具有两个比较流行，一个是ASM，一个是Javassit 。
ASM ：直接操作字节码指令，执行效率高，要是使用者掌握Java字节码文件格式及指令，对使用者的要求比较高。
Javassit ：提供了更高级的API，执行效率相对较差，对使用者要求较低.
ASM转换原理
ASM工具生产和转换class文件内容的所有工作都是基于ClassVisitor这个抽象类进行的。
ClassVisitor抽象类中的每一个方法会对应到class文件的相应区域，每个方法负责处理class文件相应区域的字节码内容
我们可以把继承ClassVisitor的抽象类的自定义类看作负责class文件各个区域内容的修改和生成
1、遍历Class字节码类信息
//官网案例
public class ClassPrinter extends ClassVisitor {
public ClassPrinter() {
super(ASM4);
}
public void visit(int version, int access, String name,
String signature, String superName, String[] interfaces) {
System.out.println(name + " extends " + superName + " {");
}
public void visitSource(String source, String debug) {}
public void visitOuterClass(String owner, String name, String desc) {}
public AnnotationVisitor visitAnnotation(String desc,boolean visible) {
return null;
}
public void visitAttribute(Attribute attr) {
}
public void visitInnerClass(String name, String outerName,
String innerName, int access) {
}
public FieldVisitor visitField(int access, String name, String desc,String signature, Object value) {
System.out.println(" " + desc + " " + name);
return null;
}
public MethodVisitor visitMethod(int access, String name,
String desc, String signature, String[] exceptions) {
System.out.println(" " + name + desc);
return null;
}
public void visitEnd() {
System.out.println("}");
}
}
ClassPrinter cp = new ClassPrinter();
ClassReader cr = new ClassReader("java.lang.Runnable");
cr.accept(cp, 0);
result：
java/lang/Runnable extends java/lang/Object {
run()V
}2、生成自定义类对应的class字节码内容
package pkg;
public interface Comparable extends Mesurable {
int LESS = -1;
int EQUAL = 0;
int GREATER = 1;
int compareTo(Object o);
}test.java内容：
ClassWriter cw = new ClassWriter(0);
cw.visit(V1_5, ACC_PUBLIC + ACC_ABSTRACT + ACC_INTERFACE, "pkg/Comparable", null, "java/lang/Object", new String[] { "pkg/Mesurable" });
cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "LESS", "I", null, new Integer(-1)).visitEnd();
cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "EQUAL", "I", null, new Integer(0)).visitEnd();
cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "GREATER", "I", null, new Integer(1)).visitEnd(); cw.visitMethod(ACC_PUBLIC + ACC_ABSTRACT, "compareTo", "(Ljava/lang/Object;)I", null, null).visitEnd();
cw.visitEnd();
byte[] b = cw.toByteArray();3、动态加载2生产出的class字节码并实例化该类，使用继承自ClassLoader的类，并重写defineClass方法
//第一种方法：通过ClassLoader的defineClass动态加载字节码
class MyClassLoader extends ClassLoader {
public Class defineClass(String name, byte[] b) {
return defineClass(name, b, 0, b.length);
}
}
//直接调用方法
Class c = myClassLoader.defineClass("pkg.Comparable", b);使用继承自ClassLoader的类，并重写findClass内部类
class StubClassLoader extends ClassLoader {
@Override
protected Class findClass(String name) throws ClassNotFoundException {
if (name.endsWith("_Stub")) {
ClassWriter cw = new ClassWriter(0);
...
byte[] b = cw.toByteArray();
return defineClass(name, b, 0, b.length);
}
return super.findClass(name);
}
}4、ClassReader生产者生产的class字节码bytes可以被ClassWriter直接消费
byte[] b1 = ...;
ClassWriter cw = new ClassWriter(0);
ClassReader cr = new ClassReader(b1);
cr.accept(cw, 0);
byte[] b2 = cw.toByteArray(); //这里的b2与b1表示同一个类且值一样5、ClassReader生产者生产的字节码bytes可以先被继承自ClassVisitor的自定义类过滤，最后被ClassWrite消费
byte[] b1 = ...;
ClassWriter cw = new ClassWriter(0);
// cv forwards all events to cw
ClassVisitor cv = new ChangeVersionAdapter (cw) { };
ClassReader cr = new ClassReader(b1);
cr.accept(cv, 0);
byte[] b2 = cw.toByteArray(); //这里的b2与b1表示同一个类但值不一样
整个字节码转换过程的时序图如下
public class ChangeVersionAdapter extends ClassVisitor { //只是继承了ClassVisitor
public ChangeVersionAdapter(ClassVisitor cv) {
super(ASM4, cv);
}
@Override //重写visit()
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
//过滤出类中的方法并指定方法的版本号(v1.5)
cv.visit(V1_5, access, name, signature, superName, interfaces);
}
}相比Javassist
java字节码以二进制的形式存储在.class文件中，每一个.class文件包含一个java类或者接口。
javassist就是一个用来处理java字节码的类库。可以在一个编译好的类中添加方法（也就是我们说的增强），或者修改已有方法。
而且也可以生成一个新的类对象，手动方式。
在javassist中，类Javassist.CtClass表示class文件。
ClassPool是CtClass对象的容器。ClassPool会在内存中维护创建过的CtClass对象，该对象过多时，占有内存也就会多，可以调用CtClass的detach()方法释放内存
CtClass相关方法：
- freeze : 冻结一个类，使其不可修改；
- isFrozen : 判断一个类是否已被冻结；
- toClass : 通过类加载器加载该CtClass。
- prune : 删除类不必要的属性，以减少内存占用。调用该方法后，许多方法无法将无法正常使用，慎用；
- defrost : 解冻一个类，使其可以被修改。如果事先知道一个类会被defrost， 则禁止调用 prune 方法；
- writeFile : 根据CtClass生成
.class文件； - detach : 将该class从ClassPool中删除；
创建新的方法可以使用CtMethod：
- insertBefore : 在方法的起始位置插入代码；
- insterAfter : 在方法的所有 return 语句前插入代码以确保语句能够被执行，除非遇到exception；
- insertAt : 在指定的位置插入代码；
- setBody : 将方法的内容设置为要写入的代码，当方法被 abstract修饰时，该修饰符被移除；
- make : 创建一个新的方法。
JDK，CGLIB
由于JVM通过字节码的二进制信息加载类的，那么，如果我们在运行期系统中，遵循Java编译系统组织.class文件的格式和结构，生成相应的二进制数据，然后再把这个二进制数据加载转换成对应的类，这样，就完成了在代码中，动态创建一个类的能力了
JDK代理底层实现
代理接口
public interface PrintService {
void print(String message);
}代理接口实现类
public class PrintServiceImpl implements PrintService {
@Override
public void print(String message) {
System.out.println("message : "+message);
}
}编写Proxy的调用处理程序 InvocationHandler
public class MyInvocationHandler implements InvocationHandler {
private Object proxyTarget;//要代理的真实对象
public MyInvocationHandler(Object proxyTarget) {
this.proxyTarget = proxyTarget;
}
//为PrintService 生成代理对象
public Object getProxy(){
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), proxyTarget.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before proxy invoke ================"+method.getName());
Object invoke = method.invoke(proxyTarget, args);
System.out.println("after proxy invoke ================="+method.getName());
return invoke;
}
}Test代码
public static void main(String[] args) {
PrintServiceImpl printService = new PrintServiceImpl();
MyInvocationHandler invokeHandler = new MyInvocationHandler(printService);
PrintService proxy =(PrintService) invokeHandler.getProxy();
System.out.println("proxy class : "+proxy.getClass().getName());
proxy.print("my proxy test");
}
/******************************************************************************************/
/**
proxy class : com.sun.proxy.$Proxy0
before proxy invoke ================print
message : my proxy test
after proxy invoke =================print
*/Proxy类以及接口 InvocationHandler是实现JDK动态代理的核心。看下newProxyInstance
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader, //类加载器loader
Class[] interfaces, //代理类所实现的接口
InvocationHandler h)//当前动态代理对象调用的方法关联InvokerHandler对象
throws IllegalArgumentException
{
.........
/*
*省略其他代码，关注下getProxyClass0这个方法
*/
Class cl = getProxyClass0(loader, intfs);
} //getProxyClass0这个方法获取代理类的字节码
private static Class getProxyClass0(ClassLoader loader,
Class... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//这里缓存的对象proxyClassCache采用weakReference实现，GC回收会被回收，属于堆外内存
return proxyClassCache.get(loader, interfaces);
//看下get方法
}
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
expungeStaleEntries();
Object cacheKey = CacheKey.valueOf(key, refQueue);
// lazily install the 2nd level valuesMap for the particular cacheKey
ConcurrentMap> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
ConcurrentMap> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
// 着重看下subKeyFactory.apply方法，最终调用ProxyClassFactory.apply
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
} public Class apply(ClassLoader loader, Class[] interfaces) {
Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
} apply首先加载要实现的接口，然后做了一系列配置，接着通过ProxyGenerator.generateProxyClass来生成Class字节码文件，再调用defineClass0(native方法)对其进行加载。
public static byte[] generateProxyClass(final String var0, Class[] var1, int var2) {
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
final byte[] var4 = var3.generateClassFile();
if (saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction() {
public Void run() {
try {
int var1 = var0.lastIndexOf(46);
Path var2;
if (var1 > 0) {
Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
Files.createDirectories(var3);
var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
} else {
var2 = Paths.get(var0 + ".class");
}
Files.write(var2, var4, new OpenOption[0]);
return null;
} catch (IOException var4x) {
throw new InternalError("I/O exception saving generated file: " + var4x);
}
}
});
}
return var4;
} 总结
1、缓存的对象proxyClassCache采用weakReference实现，GC回收会被回收
2、将InvocationHanlder h 作为参数，创建实例对象，所有constructorParams的类型肯定是InvocationHandler.class。
3、最后会调用native关键字的defineClass0这个方法
4、至此整代理类的生成过程已经全部完成，可以看出 JDK生成代理类时是基于接口生成代理类把目标类 当做属性放在代理类里面
CGLIB代理底层实现
代理对象（不需要接口）
public class PrintServiceImpl {
public void print(String message) {
System.out.println("message : "+message);
}
}编写MethodInterceptor
public class MyMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, //所生成的代理对象
Method method, //要被拦截的方法
Object[] objects, //方法参数
MethodProxy methodProxy //要触发的父类的方法对象(即父类方法代理)
) throws Throwable {
System.out.println("proxy by cglib ....."+method.getName());
//此处一定要是methodProxy来调用，不然会死循环
Object res = methodProxy.invokeSuper(o, objects);
return res;
}
}测试
public static void main(String[] args) {
//将生成的代理class写入到文件夹下
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\Cglib");
Enhancer enhancer = new Enhancer();
//设置代理类的对象
enhancer.setSuperclass(PrintServiceImpl.class);
//设置代理
enhancer.setCallback(new MyMethodInterceptor());
PrintServiceImpl printServiceProxy = (PrintServiceImpl)enhancer.create();
System.out.println(printServiceProxy.getClass().getName());
printServiceProxy.print("print aaa ");
}
/*************************************************************************************/
/**
leonardo.ezio.boot.demo.proxy.PrintServiceImpl$$EnhancerByCGLIB$$f8e5363
proxy by cglib .....print
message : print aaa
*/CGLIB原理
create()
public Object create() {
this.classOnly = false;
this.argumentTypes = null;
return this.createHelper();
}
private Object createHelper() {
this.preValidate();
//private static final Enhancer.EnhancerKey KEY_FACTORY 创建了一个EnhancerKey对象
Object key = KEY_FACTORY.newInstance(this.superclass != null ? this.superclass.getName() : null, ReflectUtils.getNames(this.interfaces), this.filter == ALL_ZERO ? null : new WeakCacheKey(this.filter), this.callbackTypes, this.useFactory, this.interceptDuringConstruction, this.serialVersionUID);
this.currentKey = key;
//调用父类AbstractClassGenerator方法
Object result = super.create(key);
return result;
}
protected Object create(Object key) {
try {
ClassLoader loader = this.getClassLoader();
Map cache = CACHE;
AbstractClassGenerator.ClassLoaderData data = (AbstractClassGenerator.ClassLoaderData)cache.get(loader);
if (data == null) {
Class var5 = AbstractClassGenerator.class;
synchronized(AbstractClassGenerator.class) {
cache = CACHE;
data = (AbstractClassGenerator.ClassLoaderData)cache.get(loader);
if (data == null) {
Map newCache = new WeakHashMap(cache);
data = new AbstractClassGenerator.ClassLoaderData(loader);
newCache.put(loader, data);
CACHE = newCache;
}
}
}
this.key = key;
Object obj = data.get(this, this.getUseCache());
return obj instanceof Class ? this.firstInstance((Class)obj) : this.nextInstance(obj);
} catch (Error | RuntimeException var9) {
throw var9;
} catch (Exception var10) {
throw new CodeGenerationException(var10);
}
} newInstance
public Object newInstance(Class[] argumentTypes, Object[] arguments, Callback[] callbacks) {
this.setThreadCallbacks(callbacks);
Object var4;
try {
if (this.primaryConstructorArgTypes == argumentTypes || Arrays.equals(this.primaryConstructorArgTypes, argumentTypes)) {
var4 = ReflectUtils.newInstance(this.primaryConstructor, arguments);
return var4;
}
//最终通过newInstance0反射生成代理对象
var4 = ReflectUtils.newInstance(this.generatedClass, argumentTypes, arguments);
} finally {
this.setThreadCallbacks((Callback[])null);
}
return var4;
}通过反射来生成代理对象，阅读源码的过程中我们可以发现cglib生成动态代理的过程中使用了WeakHashMap做为缓存，与jdk中的ProxyClassCache有相似之处，都是采用弱引用实现的
JDK、CGLIB总结
-
JDK基于接口生成代理类 把目标类当做属性放在代理类里面
-
CGLIB基于class生成实现类 继承目标对象加强
-
CGLIB通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑，所以final方法无法处理
-
实现CGLIB动态代理必须实现MethodInterceptor
javassist部分引用，来自https://blog.csdn.net/ShuSheng0007/article/details/81269295