概述
文章源自http://www.iteye.com/topic/1123350
使用ASM实现AOP功能，根据现有的CLASS类文件，动态生成它的代理类文件，并在所有的方法前后添加拦截处理，具体如下：
1.生成被代理类的子类,并重写所有方法（除java.lang.Object类定义的方法和main）,增加before和after拦截。
2.重新定义被代理类的所有属性（不包括属性的赋值及父类属性）。
jdk自带的代理（InvocationHandler）的不足:
1.jdk只能代理接口（被代理的类必须实现至少一个接口）。
2.jdk提供的代理方法，不能拦截同一类中方法的调用。如A.method1(){this.method2();}
此时method2将不会被拦截。
下面是简单的被代理类及父类(也可以不要父类)：
public class Service{
public String name;
public void insert(Object o) {}
}
public class RoleService extends Service{
public String roleName;
public String executeOuter(Integer name) {
System.out.println("executeOuter call super.query()");
return query();
}
public String query() {
System.out.println("execute (RoleService): query");
return "query result (RoleService)";
}
}
核心类ClassAdapter用于生成一个类的子类，并为所有代理类方法添加拦截方法，如下：
public class ClassAdapter extends ClassVisitor implements Opcodes{
public static final String INIT = "<init>";
private ClassWriter classWriter;
private String originalClassName;
private String enhancedClassName;
private Class<?> originalClass;
public ClassAdapter(String enhancedClassName,
Class<?> targetClass, ClassWriter writer) {
super(Opcodes.ASM4,writer);
this.classWriter = writer;
this.originalClassName = targetClass.getName();
this.enhancedClassName = enhancedClassName;
this.originalClass = targetClass;
}
@Override
public void visit(int version, int access, String name, String signature,
String superName, String[] interfaces) {
cv.visit(version, Opcodes.ACC_PUBLIC,
toAsmCls(enhancedClassName), signature, name,interfaces);
}
@Override
public FieldVisitor visitField(int access, String name, String desc,
String signature, Object value) {
// 拷贝所有属性 可使用java反射给属性赋值（生成class后newInstance在赋值）
return super.visitField(access, name, desc, signature, value);
}
@Override
public MethodVisitor visitMethod(int access, String name, String desc,
String signature, String[] exceptions) {
// 删除所有方法
return null;
}
private static String toAsmCls(String className) {
return className.replace('.', '/');
}
private static void doBefore(MethodVisitor mWriter,String methodInfo) {
mWriter.visitFieldInsn(GETSTATIC,"java/lang/System","out","Ljava/io/PrintStream;");
mWriter.visitLdcInsn("before method : " + methodInfo);
mWriter.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
// 或者直接调用静态方法
// mWriter.visitLdcInsn(methodInfo);
// mWriter.visitMethodInsn(INVOKESTATIC,toAsmCls(TxHandler.class.getName()),"before","(Ljava/lang/String;)V");
}
private static void doAfter(MethodVisitor mWriter,String methodInfo) {
mWriter.visitFieldInsn(GETSTATIC,"java/lang/System","out","Ljava/io/PrintStream;");
mWriter.visitLdcInsn("after method : " + methodInfo);
mWriter.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println",
"(Ljava/lang/String;)V");
}
public static boolean needOverride(Method m) {
// object类本身的方法不做重写
if (m.getDeclaringClass().getName().equals(Object.class.getName())) {
return false;
}
// "main" 方法不做重写
if (Modifier.isPublic(m.getModifiers())
&& Modifier.isStatic(m.getModifiers())
&& m.getReturnType().getName().equals("void")
&& m.getName().equals("main")) {
return false;
}
return true;
}
@Override
public void visitEnd() {
// 如果originalClass定义了私有成员变量，那么直接在visitMethod中复制originalClass的<init>会报错。
// 创建<init>并调用父类的<init>
// 调用originalClassName的<init>方法，否则class不能实例化
MethodVisitor mvInit = classWriter.visitMethod(ACC_PUBLIC, INIT, "()V", null, null);
// pushes the 'this' variable
mvInit.visitVarInsn(ALOAD, 0);
mvInit.visitMethodInsn(INVOKESPECIAL, toAsmCls(originalClassName), INIT, "()V");
mvInit.visitInsn(RETURN);
// this code uses a maximum of one stack element and one local variable
mvInit.visitMaxs(0, 0);
mvInit.visitEnd();
// 获取所有方法，并重写(main方法 和 Object的方法除外)
Method[] methods = originalClass.getMethods();
for(Method m : methods) {
if(!needOverride(m)) {
continue;
}
// mt.toString() == ()Ljava/lang/String
Type mt = Type.getType(m);
// 生成打印信息
StringBuilder methodInfo = new StringBuilder(originalClassName);
methodInfo.append(".").append(m.getName());
methodInfo.append("|");
Class<?>[] paramTypes = m.getParameterTypes();
for(Class<?> t : paramTypes) {
methodInfo.append(t.getName()).append(",");
}
if(paramTypes.length > 0) {
methodInfo.deleteCharAt(methodInfo.length() - 1);
}
// 方法 description
MethodVisitor mWriter = classWriter.visitMethod(ACC_PUBLIC, m.getName(), mt.toString(), null, null);
// insert code here (before)
doBefore(mWriter,methodInfo.toString());
int i = 0;
// 如果不是静态方法 load this对象
if(!Modifier.isStatic(m.getModifiers())) {
mWriter.visitVarInsn(ALOAD, i++);
}
//StringBuilder sb = new StringBuilder(m.getName());
// load 出方法的所有参数
for(Class<?> tCls : m.getParameterTypes()) {
Type t = Type.getType(tCls);
//sb.append(loadCode(t)).append(",");
mWriter.visitVarInsn(loadCode(t), i++);
// long和double 用64位表示，要后移一个位置，否则会报错
if(t.getSort() == Type.LONG || t.getSort() == Type.DOUBLE) {
i++;
}
}
// 方法所属类全名
String declaringCls = toAsmCls(m.getDeclaringClass().getName());
// super.xxx();
mWriter.visitMethodInsn(INVOKESPECIAL,declaringCls,m.getName(),mt.toString());
// 处理返回值类型
Type rt = Type.getReturnType(m);
// 没有返回值
if(rt.toString().equals("V")) {
doAfter(mWriter,methodInfo.toString());
mWriter.visitInsn(RETURN);
}
// 把return xxx() 转变成 ： Object o = xxx(); return o;
// store/load 存储并载入变量
else {
int storeCode = storeCode(rt);
int loadCode = loadCode(rt);
int returnCode = rtCode(rt);
mWriter.visitVarInsn(storeCode, i);
doAfter(mWriter,methodInfo.toString());
mWriter.visitVarInsn(loadCode, i);
mWriter.visitInsn(returnCode);
}
mWriter.visitMaxs(i, ++i);
mWriter.visitEnd();
}
cv.visitEnd();
}
public static int storeCode(Type type) {
int sort = type.getSort();
switch (sort) {
case Type.ARRAY:
sort = ASTORE;
break;
case Type.BOOLEAN:
sort = ISTORE;
break;
case Type.BYTE:
sort = ISTORE;
break;
case Type.CHAR:
sort = ISTORE;
break;
case Type.DOUBLE:
sort = DSTORE;
break;
case Type.FLOAT:
sort = FSTORE;
break;
case Type.INT:
sort = ISTORE;
break;
case Type.LONG:
sort = LSTORE;
break;
case Type.OBJECT:
sort = ASTORE;
break;
case Type.SHORT:
sort = ISTORE;
break;
default:
break;
}
return sort;
}
public static int loadCode(Type type) {
int sort = type.getSort();
switch (sort) {
case Type.ARRAY:
sort = ALOAD;
break;
case Type.BOOLEAN:
sort = ILOAD;
break;
case Type.BYTE:
sort = ILOAD;
break;
case Type.CHAR:
sort = ILOAD;
break;
case Type.DOUBLE:
sort = DLOAD;
break;
case Type.FLOAT:
sort = FLOAD;
break;
case Type.INT:
sort = ILOAD;
break;
case Type.LONG:
sort = LLOAD;
break;
case Type.OBJECT:
sort = ALOAD;
break;
case Type.SHORT:
sort = ILOAD;
break;
default:
break;
}
return sort;
}
public static int rtCode(Type type) {
int sort = type.getSort();
switch (sort) {
case Type.ARRAY:
sort = ARETURN;
break;
case Type.BOOLEAN:
sort = IRETURN;
break;
case Type.BYTE:
sort = IRETURN;
break;
case Type.CHAR:
sort = IRETURN;
break;
case Type.DOUBLE:
sort = DRETURN;
break;
case Type.FLOAT:
sort = FRETURN;
break;
case Type.INT:
sort = IRETURN;
break;
case Type.LONG:
sort = LRETURN;
break;
case Type.OBJECT:
sort = ARETURN;
break;
case Type.SHORT:
sort = IRETURN;
break;
default:
break;
}
return sort;
}
}具体调用类如下：
public class AsmFactory {
public static final String SUFIX = "$EnhancedByCc";
public static BytecodeLoader classLoader = new BytecodeLoader();
/**
* 根据字节码加载class
*/
public static class BytecodeLoader extends ClassLoader {
public Class<?> defineClass(String className, byte[] byteCodes) {
return super.defineClass(className, byteCodes, 0, byteCodes.length);
}
}
/**
* 返回代理类
*/
@SuppressWarnings("unchecked")
protected static <T> Class<T> getEnhancedClass(Class<T> clazz){
String enhancedClassName = clazz.getName() + SUFIX;
try {
return (Class<T>) classLoader.loadClass(enhancedClassName);
} catch (ClassNotFoundException classNotFoundException) {
ClassReader reader = null;
try {
reader = new ClassReader(clazz.getName());
} catch (IOException ioexception) {
throw new RuntimeException(ioexception);
}
ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
ClassVisitor visitor = new ClassAdapter(enhancedClassName, clazz,
writer);
reader.accept(visitor, 0);
byte[] byteCodes = writer.toByteArray();
writeClazz(enhancedClassName, byteCodes);
Class<T> result = (Class<T>) classLoader.defineClass(
enhancedClassName, byteCodes);
return result;
}
}
public static void writeClazz(String name, byte[] data) {
try {
File file = new File("D:/com/" + name + ".class");
FileOutputStream fout = new FileOutputStream(file);
fout.write(data);
fout.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
Class<RoleService> rsCls = getEnhancedClass(RoleService.class);
rsCls.newInstance().executeOuter(1);
}
}使用反编译工具查看生成的字节码，如下：
public class RoleService$EnhancedByCc extends RoleService
{
public String roleName;
public String query()
{
System.out.println("before method : org.cc.demo2.RoleService.query|");
String str = super.query();
System.out.println("after method : org.cc.demo2.RoleService.query|");
return str;
}
public String executeOuter(Integer paramInteger)
{
System.out.println("before method : org.cc.demo2.RoleService.executeOuter|java.lang.Integer,");
String str = super.executeOuter(paramInteger);
System.out.println("after method : org.cc.demo2.RoleService.executeOuter|java.lang.Integer,");
return str;
}
public void insert(Object paramObject)
{
System.out.println("before method : org.cc.demo2.RoleService.insert|java.lang.Object,");
super.insert(paramObject);
System.out.println("after method : org.cc.demo2.RoleService.insert|java.lang.Object,");
}
}
最后
以上就是精明小笼包为你收集整理的使用ASM动态生成类的拦截代理类的全部内容，希望文章能够帮你解决使用ASM动态生成类的拦截代理类所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复