java asm库的原理与使用方法（二）

最新推荐文章于 2024-05-28 12:48:39 发布
最新推荐文章于 2024-05-28 12:48:39 发布
阅读量1.7k 收藏 1
点赞数 4
分类专栏： 逆向工程 android性能监测 文章标签： asm classloader jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xysmiracle/article/details/38499097
版权

3、使用ASMAPI生成和转换class中的方法

前面已经简单介绍过已编译的class文件中的方法是由字节码指令序列构成，因此使用ASMAPI生成和转换class文件中的方法需要具备基本的字节码指令知识和基本的字节码指令运行原理。

3.1、执行模型

            我们知道java代码是运行在java虚拟机的线程中，每一个线程拥有各自的执行栈，执行栈由多个帧组成。每个帧可以代表一个方法的运行过程，当方法被触发时，一个新的帧将会被push到当前线程的执行栈中。当方法正常返回或者发生异常，当前线程会将该方法帧pop出执行栈。

            每个帧由本地变量和操作栈两部分组成。本地变量部分由一个数组组成，可通过数据下标访问变量。操作栈部分是由一组字节码指令序列组成，指令序列将按照后进先出的顺序访问。每一个在线程执行栈中的帧都包括它自己的操作栈。

            帧中的本地变量数组和操作栈的大小由类中方法的代码决定，在类编译过程中计算帧的内容并将它以字节码指令的方式储存在已编译的class文件中。在同一方法的执行过程中，该方法对应的每一帧的大小相同，但是不同的方法帧大小可以不同，它们的大小由本地变量数组和操作栈部分的大小决定。

            下图展示了一个执行栈中帧的例子，帧1包含3个本地变量，它的操作栈的最大容量为4；帧2包含2个本地变量，它的操作栈中有2个值；同样的，帧3中包含4个本地变量和2个操作栈值；


图3.1一个执行栈中的3个帧

当非静态(static)方法被创建时，执行栈初始化一个新的帧，该帧初始化它的操作栈并且将this和方法的参数压入到它的本地变量数组中。比如执行a.equals(b)时，线程执行栈中初始化一个帧，初始化帧的操作栈并且将a,b参数压入到帧的本地变量数组中。任何java类型的变量都能被加入到帧的本地变量数组中，但是有别于其他类型的变量只在本地变量数组中占一个单位的位置，long和double类型有点特别，在加入后它们在数组中各占2个单位的位置。因此第i个方法的参数不一定存储在帧本地变量数组的第i个位置。比如Math.max(1L,2L)，在本地变量数组中占4个单位的位置，1L和2L各占2个单位的位置，本地变量数组的长度为4。

3.2、字节码指令

            一个字节码指令由操作码和固定数量个参数组成。操作码是一个非负整数，因此字节码指令的名字由一个数字来标识。比如操作码0使用符号NOP来助记，其中NOP指令不做任何事情。操作码后一般跟参数，用来定义指令具体的行为，比如助记符号GOTO(操作码167)后跟的参数用来指定下一条要执行的指令位置。

            字节码指令主要分成两类，一类用来对变量进行从帧本地变量数组到操作栈之间的正反向转化；另一类在操作栈中对变量进行操作，比如从栈中pop出一个值，做某种计算后再重新把该值push回操作栈中。

1、用来进行做转换的指令：ILOAD,LLOAD, FLOAD, DLOAD,和ALOAD指令用来读取帧本地变量数组中的值然后push到操作栈；ILOAD指令用来读取boolean,byte, char, short或者int类型的变量；LLOAD,FLOAD, DLOAD指令用来读取long,float, double类型的变量；ALOAD指令用来读取非原始类型变量，比如对象，数组的引用等；同时ISTORE,LSTORE, FSTORE, DSTORE和ASTORE指令用来将相应类型的变量从操作栈中pop，然后存储到帧本地变量数组中。

2、用来在操作栈中运算的指令；

l  栈操作：POP, PUSH, DUP, SWAP

l  常量：ACONST_NULL(push null到操作栈)，ICONST_0(pushint类型的0到操作栈)，FCONST_0，DCONST_0，BIPUSHb(push byte类型的b到操作栈)，SIPUSHs(push short类型的s到操作栈)，LDCcst(push int,float,long,double,String,class常量到操作栈)

l  算数逻辑，从操作栈中pop出值做完相应的算数逻辑运算后再push回操作栈，涉及到的指令有：xADD,xSUB, xMUL, xDIV和xREM(分别对应+，-，*，/，%计算逻辑)

l  类型转换，从操作栈中pop出值做完相应的类型转换后再push回操作栈，涉及到的指令有：I2F,F2D, L2D(分别对应int转float，float转double，long转double操作)，CHECKCASTt(将原引用类型转换成t类型)

l  对象，创建,锁定,测试一个对象：NEW type(push 一个新的type类型的对象到操作栈中)

l  fields：GETFIELD owner name desc(pop对象的引用，pushname的值到操作栈中)，PUTFIELDowner name desc(pop对象的值和引用，将值存储到name的field)，GETSTATIC和PUTSTATIC指令用来操作静态对象，作用一样；

l  方法，该类指令用来触发一个方法或者构造函数，先pop出对应数量的参数，方法运算后，push方法的返回值到操作栈中：INVOKEVIRTUALowner name desc(指令用来触发ownerclass中的name方法)，INVOKESTATICowner name desc(指令用来触发静态方法)，同理INVOKESPECIAL指令用来触发类中的私有方法和构造函数，INVOKEINTERFACE指令用来触发接口方法

l  数组，用来读写数组中的值；xALOAD(pop index和array,push array中index个位置值到操作栈中)，xASTORE(popindex, value和array，存储value到array中的index个位置上)

l  条件判断：IFEQ label(pop出一个int值然后判断是否为0，若为0则跳转到label位置)，同理IFGE，IFNE，TABLESWITCH，LOOKUPSWITCH

l  返回，终止一个方法的执行并返回结果给caller：xRETURN和RETURN分别返回对应类型的值和void


3.3、例子

package pkg;
public class Bean {
    private int f;
    public int getF() {
        return this.f;
    }
    public void setF(int f) {
        this.f = f; 
    }
}

1)、getF方法的字节码指令：

ALOAD 0
GETFIELD pkg/Bean f I
IRETURN

具体执行过程：首先从帧本地变量数组中读取下标为0的值(初始化帧时设置为this)push到操作栈中，然后pop出this，pushthis的pkg/Bean类f对象到操作栈中(this.f)，最后从操作栈中pop出值并返回给caller，该帧每阶段的变化如下图所示。


图3.2(a)初始化状态,(b)执行ALOAD0后,(c)执行GETFIELD指令后


2)、setF方法的字节码指令：

ALOAD 0
ILOAD 1
PUTFIELD pkg/Bean f I
RETURN

具体执行过程：第一条指令从帧本地变量数组中读取下标为0的值(初始化帧时设置为this)push到操作栈中；第二条指令从帧本地变量数组中读取下标为1的值push到操作栈中用作赋值的int值；第三条指令pop出this和int值， 存储pkg/Bean类f对象的引用(也就是this.f)到本地变量数组中，第四条指令返回void到caller，该帧每阶段的变化如下图所示。


图3.3(a)初始化状态,(b)执行ALOAD0后,(c)执行LOAD1后,(c)执行PUTFIELD指令后


3)、Bean的默认构造函数Bean(){ super(); }字节码指令：

ALOAD 0
INVOKESPECIAL java/lang/Object <init> ()V
RETURN

具体执行过程：第一条指令从帧本地变量数组中读取下标为0的值(初始化帧时设置为this)push到操作栈中；第二条指令pop出this调用java/lang/Object类的<init>方法；第三条指令返回void到caller。


3.4、更复杂的例子

public void checkAndSetF(int f) {
    if (f >= 0) {
        this.f = f;
    } else {
        throw new IllegalArgumentException();
    }
}

字节码指令如下：

ILOAD 1					//从本地变量数组中读入下标1的int变量f
    IFLT label					//判断f<0 跳label标记处
    ALOAD 0					//从本地变量数组中读入下标0的this
    ILOAD 1					//读入下标1的参数f
PUTFIELD pkg/Bean f I 	//pop this和f值，赋值给this.f，存储到本地变量数组中
GOTO end					//跳end标记处
label:
    NEW java/lang/IllegalArgumentException	//new一个exception，push到操作栈
    DUP						//复制一份操作栈中的内容
    INVOKESPECIAL java/lang/IllegalArgumentException <init> ()V		//pop出操作栈中的一份拷贝内容，call java/lang/IllegalArgumentException的构造函数
    ATHROW					//pop出剩下的一份操作栈拷贝内容，然后抛出一个异常，这样就不会再执行下面的指令
end:
RETURN					//返回void给caller

3.4.1、捕获异常的例子

public static void sleep(long d) {
    try {
        Thread.sleep(d);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

字节码指令如下：

TRYCATCHBLOCK try catch catch java/lang/InterruptedException  //指定一个exception的handler用来处理try和catch label之间的指令
try:
    LLOAD 0
    INVOKESTATIC java/lang/Thread sleep (J)V
    RETURN
catch:
    INVOKEVIRTUAL java/lang/InterruptedException printStackTrace ()V
RETURN


3.5、ASM接口和组件

使用ASMAPI产生和转换class文件的方法是基于MethodVisitor抽象类进行的，其中MethodVisitor通过ClassVisitor的visitMethod方法返回。MethodVisitor类中定义了许多访问class文件的方法内容和属性的方法；其中，使用继承自MethodVisitor的类对class文件的方法内容和属性的访问顺序如下；class文件的方法的注释和属性被先访问，随后才是访问目标method的bytecode；另外，visitCode和visitMaxs方法可以被用来判断class文件方法字节码指令序列的开始和结束；

visitAnnotationDefault?
( visitAnnotation | visitParameterAnnotation | visitAttribute )* 
( visitCode
    ( visitTryCatchBlock | visitLabel | visitFrame | visitXxxInsn | 
        visitLocalVariable | visitLineNumber )*
    visitMaxs )? 
visitEnd

MethodVisitor类的主要方法：

abstract class MethodVisitor { // public accessors ommited MethodVisitor(int api);
    MethodVisitor(int api, MethodVisitor mv);
    AnnotationVisitor visitAnnotationDefault();
    AnnotationVisitor visitAnnotation(String desc, boolean visible); AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible);
    void visitAttribute(Attribute attr);
    void visitCode();
    void visitFrame(int type, int nLocal, Object[] local, int nStack, Object[] stack);
    void visitInsn(int opcode);
    void visitIntInsn(int opcode, int operand);
    void visitVarInsn(int opcode, int var);
    void visitTypeInsn(int opcode, String desc);
    void visitFieldInsn(int opc, String owner, String name, String desc); void visitMethodInsn(int opc, String owner, String name, String desc); void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs);
    void visitJumpInsn(int opcode, Label label);
    void visitLabel(Label label);
    void visitLdcInsn(Object cst);
    void visitIincInsn(int var, int increment);
    void visitTableSwitchInsn(int min, int max, Label dflt, Label[] labels); void visitLookupSwitchInsn(Label dflt, int[] keys, Label[] labels);
    void visitMultiANewArrayInsn(String desc, int dims);
    void visitTryCatchBlock(Label start, Label end, Label handler, String type);
    void visitLocalVariable(String name, String desc, String signature, Label start, Label end, int index);
    void visitLineNumber(int line, Label start); void visitMaxs(int maxStack, int maxLocals); void visitEnd();
}

ClassVisitor和MethodVisitor结合起来使用，产生一个class文件的大概过程；

ClassVisitor cv = ...;
cv.visit(...);
MethodVisitor mv1 = cv.visitMethod(..., "m1", ...);
mv1.visitCode();
mv1.visitInsn(...);
...
mv1.visitMaxs(...);
mv1.visitEnd();
MethodVisitor mv2 = cv.visitMethod(..., "m2", ...);
mv2.visitCode();
mv2.visitInsn(...);
...
mv2.visitMaxs(...);
mv2.visitEnd();
cv.visitEnd();

ClassReader、ClassWriter和MethodVisitor结合起来使用，转换一个class文件方法；ClassReader载入class文件，在调visitMethod方法时会返回一个继承自MethodVisitor类的对象，在这里用自己实现的MethodVisitor子类对象作为返回值返回即可，其中，在自己的类中实现各种对目标class方法的指令转换工作；最后ClassWriter输出新的class字节码文件。


3.6、产生方法

package pkg;
public class Bean {
    private int f;
    public int getF() {
        return this.f;
    }
    public void setF(int f) {
        this.f = f; 
    }
}

产生getF()方法：(方法的字节码指令请见3.3.1)

mv.visitCode();
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, "pkg/Bean", "f", "I");
mv.visitInsn(IRETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();


public void checkAndSetF(int f) {
    if (f >= 0) {
        this.f = f;
    } else {
        throw new IllegalArgumentException();
    }
}

产生checkAndSetF方法：(方法的字节码指令请见3.4)

mv.visitCode();
mv.visitVarInsn(ILOAD, 1);
Label label = new Label();
mv.visitJumpInsn(IFLT, label);
mv.visitVarInsn(ALOAD, 0);
mv.visitVarInsn(ILOAD, 1);
mv.visitFieldInsn(PUTFIELD, "pkg/Bean", "f", "I");
Label end = new Label();
mv.visitJumpInsn(GOTO, end);
mv.visitLabel(label);
mv.visitFrame(F_SAME, 0, null, 0, null);
mv.visitTypeInsn(NEW, "java/lang/IllegalArgumentException");
mv.visitInsn(DUP);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/IllegalArgumentException", "<init>", "()V");
mv.visitInsn(ATHROW);
mv.visitLabel(end);
mv.visitFrame(F_SAME, 0, null, 0, null);
mv.visitInsn(RETURN);
mv.visitMaxs(2, 2);
mv.visitEnd();

3.7、转换方法

去掉class方法（非构造函数）中NOP指令的例子

实现继承自MethodVisitor的类适配器(methodadapter)

public class RemoveNopAdapter extends MethodVisitor {
    public RemoveNopAdapter(MethodVisitor mv) {
        super(ASM4, mv);
    }
    @Override
    public void visitInsn(int opcode) {
        if (opcode != NOP) {
            mv.visitInsn(opcode);
        }
    } 
}

实现继承自ClassVisitor的类适配器(classadapter)

public class RemoveNopClassAdapter extends ClassVisitor {
    public RemoveNopClassAdapter(ClassVisitor cv) {
        super(ASM4, cv);
    }
    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { MethodVisitor mv;
        mv = cv.visitMethod(access, name, desc, signature, exceptions); 
        if (mv != null && !name.equals("<init>")) {
            mv = new RemoveNopAdapter(mv);
        }
        return mv; 
    }
}

class文件的方法转换时序图；


图3.4RemoveNopAdapter的时序图


3.8、无状态的转换（当前指令执行状态不依赖其他指令状态，不需要在methodAdapter中保存指令状态）

为class文件中方法增加计时器的例子；

实现效果相当：

public class C {
    public void m() throws Exception {
        Thread.sleep(100);
    } 
}

<strong><span style="color:#ff0000;">转换成</span></strong>
public class C {
    public static long timer;
    public void m() throws Exception {
        timer -= System.currentTimeMillis();
        Thread.sleep(100);
        timer += System.currentTimeMillis();
    } 
}

AddTimerAdapter的实现；

public class AddTimerAdapter extends ClassVisitor {
    private String owner;
    private boolean isInterface;
    public AddTimerAdapter(ClassVisitor cv) {
        super(ASM4, cv);
    }
    @Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        cv.visit(version, access, name, signature, superName, interfaces);
        owner = name;
        isInterface = (access & ACC_INTERFACE) != 0;
    }
    @Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);
        if (!isInterface && mv != null && !name.equals("<init>")) {
            mv = new AddTimerMethodAdapter(mv);
        }
        return mv; 
    }
    @Override public void visitEnd() {
        if (!isInterface) {
            FieldVisitor fv = cv.visitField(ACC_PUBLIC + ACC_STATIC, "timer", "J", null, null);
            if (fv != null) {
                fv.visitEnd();
            }
        }
        cv.visitEnd();
    }

    class AddTimerMethodAdapter extends MethodVisitor {
        public AddTimerMethodAdapter(MethodVisitor mv) {
            super(ASM4, mv);
        }
        @Override public void visitCode() {
            mv.visitCode();
            mv.visitFieldInsn(GETSTATIC, owner, "timer", "J");
            mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J");
            mv.visitInsn(LSUB);
            mv.visitFieldInsn(PUTSTATIC, owner, "timer", "J");
        }
        @Override public void visitInsn(int opcode) {
            if ((opcode >= IRETURN && opcode <= RETURN) || opcode == ATHROW) {
                mv.visitFieldInsn(GETSTATIC, owner, "timer", "J");
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J");
                mv.visitInsn(LADD);
                mv.visitFieldInsn(PUTSTATIC, owner, "timer", "J");
            }
            mv.visitInsn(opcode);
        }
        @Override public void visitMaxs(int maxStack, int maxLocals) {
            mv.visitMaxs(maxStack + 4, maxLocals); 
        }
    } 
}

3.9、有状态的转换（本指令依赖上个指令的内容）

例子，去掉ALOAD0 ALOAD 0 GETFIELD f PUTFIELD f这样的指令

状态机图如下；


图3.5 ALOAD0 ALOAD 0 GETFIELD f PUTFIELD f指令的状态机


代码实现：

public abstract class PatternMethodAdapter extends MethodVisitor {
    ...
    @Override public void visitFrame(int type, int nLocal, Object[] local, int nStack, Object[] stack) {
        visitInsn();
        mv.visitFrame(type, nLocal, local, nStack, stack);
    }
    @Override public void visitLabel(Label label) { visitInsn();
        mv.visitLabel(label);
    }
    @Override public void visitMaxs(int maxStack, int maxLocals) { visitInsn();
        mv.visitMaxs(maxStack, maxLocals);
    }
}

class RemoveGetFieldPutFieldAdapter extends PatternMethodAdapter {
    private final static int SEEN_ALOAD_0 = 1;
    private final static int SEEN_ALOAD_0ALOAD_0 = 2;
    private final static int SEEN_ALOAD_0ALOAD_0GETFIELD = 3;
    private String fieldOwner;
    private String fieldName;
    private String fieldDesc;
    public RemoveGetFieldPutFieldAdapter(MethodVisitor mv) {
        super(mv); 
    }
    @Override
    public void visitVarInsn(int opcode, int var) {
        switch (state) {
            case SEEN_NOTHING: // S0 -> S1
                if (opcode == ALOAD && var == 0) {
                    state = SEEN_ALOAD_0;
                    return; 
                }
                break;
            case SEEN_ALOAD_0: // S1 -> S2
                if (opcode == ALOAD && var == 0) {
                    state = SEEN_ALOAD_0ALOAD_0;
                    return; 
                }
            break;
            case SEEN_ALOAD_0ALOAD_0: // S2 -> S2
                if (opcode == ALOAD && var == 0) {
                    mv.visitVarInsn(ALOAD, 0);
                    return; 
                }
                break; 
        }
        visitInsn();
        mv.visitVarInsn(opcode, var);
    }
    @Override
    public void visitFieldInsn(int opcode, String owner, String name, String desc) {
        switch (state) {
            case SEEN_ALOAD_0ALOAD_0: // S2 -> S3
                if (opcode == GETFIELD) {
                    state = SEEN_ALOAD_0ALOAD_0GETFIELD;
                    fieldOwner = owner;
                    fieldName = name;
                    fieldDesc = desc;
                    return;
                }
                break;
            case SEEN_ALOAD_0ALOAD_0GETFIELD: // S3 -> S0
                if (opcode == PUTFIELD && name.equals(fieldName)) {
                    state = SEEN_NOTHING;
                    return; 
                }
                break; 
        }
        visitInsn();
        mv.visitFieldInsn(opcode, owner, name, desc);
    }
    @Override protected void visitInsn() {
        switch (state) {
            case SEEN_ALOAD_0: // S1 -> S0
                mv.visitVarInsn(ALOAD, 0);
                break;
            case SEEN_ALOAD_0ALOAD_0: // S2 -> S0
                mv.visitVarInsn(ALOAD, 0);
                mv.visitVarInsn(ALOAD, 0);
                break;
            case SEEN_ALOAD_0ALOAD_0GETFIELD: // S3 -> S0
                mv.visitVarInsn(ALOAD, 0);
                mv.visitVarInsn(ALOAD, 0);
                mv.visitFieldInsn(GETFIELD, fieldOwner, fieldName, fieldDesc);
                break; 
        }
        state = SEEN_NOTHING;
    }
}







公公公愚
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java ASM,learn-java-asm-main.zip
05-19
学习 ASM 需要对 Java 字节码有一定的了解，同时，熟悉 JVM 工作原理也是必要的。`learn-java-asm-main.zip` 文件很可能是包含一个示例项目，用来演示如何使用 ASM。通过阅读和运行这个示例，你将能更好地理解 ASM ...
Java字节码框架ASM简介
靖节先生的博客
01-25 8949
Java字节码框架ASM简介1. ASM概述1.1 ASM简介1.2 ASM提供API1.3 ASM核心模块2. ASM应用2.1 ASM依赖2.2 代码实现2.3 测试验证 1. ASM概述 1.1 ASM简介 ASM 是一个通用的 Java 字节码操作和分析框架。一般用来动态生成类或者增强既有类的功能。也就是既可以创建class文件，也可以修改class文件。 ASM官网地址：https://asm.ow2.io/index.html 1.2 ASM提供API ASM提供了两种API Core API
Java 字节码操作框架——ASM
Dc253061007的博客
07-10 2236
上面的代码中，ClassReader 负责读取类文件字节数组，accept 调用之后 ClassReader 会把解析字节码过程的事件源源不断的通知给 ClassVisitor 对象调用不同的 visit 方法，ClassVisitor 可以在这些 visit 方法中对字节码进行修改，ClassWriter 可以生成最终修改过的自己字节码。SAX运行时是单向的、流式的，解析过的部分无法在不重新开始的情况下再次读取，ASM 的 Core API 类似于这种方式。
Java核心: 使用asm操作字节码
最新发布
你若盛开，清风自来
05-28 913
在上一篇中我们提到，通过实现AbstractProcessor，并调用javac -processor能够生成代码来实现特殊逻辑。这一篇我们讲解ASM的目的就是解决问题1，它不但能建新类，还能修改已有类，比如为POJO类生成toString方法，为Service类的业务方法提供类似AOP的增强。本文的讲解思路如下。
Java ASM 框架：字节码操作的常见用法（生成类，修改类,方法插桩，方法注入）
uuqaz的博客
04-11 9088
前言 ASM是一款读写Java字节码的工具，可以达到跳过源码编写，编译，直接以字节码的形式创建类，修改已经存在类(或者jar中的class)的属性，方法等。 通常用来开发一些Java开发的辅助框架,其做法是在你编写的Java代码中注入一些特定代码（俗称字节码插装）达到特定目的，以Android开发为例最常用的方法通过字节码插装实现热修复，事件监听，埋点，开源框架等非常规操作,当然在Android开发中通常辅以Gradle插件一起使用，这个改天在写。 背景 早就听说过ASM和字节码插桩技术，但是工...
AOP 的利器：ASM 3.0 介绍
Andrew LD
09-30 447
一、什么是ASM 　　ASM是一个java字节码操纵框架，它能被用来动态生成类或者增强既有类的功能。ASM 可以直接产生二进制 class 文件，也可以在类被加载入 Java 虚拟机之前动态改变类行为。Java class 被存储在严格格式定义的 .class文件里，这些类文件拥有足够的元数据来解析类中的所有元素：类名称、方法、属性以及 Java 字节码（指令）。ASM从类文件中
Java的字节码操作框架ASM详解
qq_43456605的博客
12-20 2014
ASM是一个用于在Java字节码级别进行操作的框架，它运行你在不破坏原有逻辑的情况下修改、生成和转换字节码。ASM提供类一种灵活高效的方式，用于在编译器运行时动态生成字节码，这对于许多Java框架和工具来说是非常有用的。要实现自定义类加载器，我们需要扩展Java标准裤的ClassLoader，并重写findClass方法。try {// 加载原始字节码 String resourceName = name . replace('.' , '/') . concat(".class");
asm_java.rar_asm_java
09-23
通过深入研究这个项目，用户不仅可以了解ASM模型的工作原理，还能学习到如何使用Java进行复杂系统建模，以及如何利用ASM库进行字节码级别的编程。这对于提升编程技能、理解金融市场以及进行相关研究都非常有价值。
java字节码框架ASM的深入学习
08-31
二、使用ASM的关键类 ASM框架中的几个核心类包括： 1. ClassReader：这个类负责读取和解析已编译的`.class`文件。通过`ClassReader`，开发者可以获得类的所有元数据，包括类结构、方法、字段等信息。 2. Class...
java-asm:java asm原始解析
03-23
ASM库被广泛用于构建工具，如Java代理、AOP（面向切面编程）框架、字节码生成器以及性能分析工具等。在这个“java-asm:java asm原始解析”主题中，我们将深入探讨ASM的核心概念、使用场景和具体实践。 **核心概念**...
ASM操作字节码，动态生成Java类class文件
02-03
在Java开发中，ASM库允许我们直接操作字节码，这对于理解和实践AOP（面向切面编程）的概念尤其有用，就像Spring框架中的AOP实现。 面向切面编程（AOP）是一种编程范式，它允许程序员定义“切面”，这些切面封装了...
asm-lambda:使用ASM生成Lambda运行时
05-06
标题 "asm-lambda: 使用ASM生成Lambda运行时" 指出的是一个开源项目，它利用ASM库来创建和理解Java的Lambda表达式在运行时的字节码表示。ASM是一个流行的Java字节码操控和分析框架，常用于动态代理、代码混淆、AOP...
ASM使用指南-中文版
11-08
这份中文指南将帮助开发者快速入门，通过实例和详细的解释，深入理解ASM的使用方法和最佳实践。 在阅读“ASM4使用指南.pdf”时，重点关注以下部分： - ASM的基本架构和核心组件介绍 - 如何使用ClassWriter和...
JMod:objectweb asm 库中缺少的东西
06-19
JMod是针对Java平台的一种模块化工具，它与ObjectWeb ASM库有关，ASM是一个流行的Java字节码操作和分析框架。ASM库广泛用于动态代理、代码生成和转换，以及一些性能优化工具。然而，尽管ASM功能强大，但在某些特定...
asm-commons.rar_Java__Java_
08-09
ASM库在Java编程中主要用于动态代理、代码生成以及对运行时Java类进行低级别操作，例如性能优化、调试或分析。 ASM库的核心组件分为以下几个部分： 1. **ASM Core**：这是ASM的基础模块，提供了对Java字节码的解析...
Java字节码和asm入门资料
08-09
提到的“mastering-java-bytecode.pdf”可能是一本关于Java字节码和ASM的教程，它可能涵盖了字节码的结构、ASM库的使用方法、实际案例分析等内容，是深入理解这两个主题的好资源。 7. **应用实例**： - Spring ...
ASM字节码处理工具原理及实践（一）
深海流浪汉
04-13 1154
我们知道程序的分析。生成和转换是很有用的技术，可以用于很多场景。ASM作为一个Java字节码处理工具，它被设计用于处理已编译的Java类。ASM不是生成和转变已编译的Java类的唯一工具，但它是最新且最有效的工具之一。特点是体积小，速度快，开源。它的作用和JVM的动态性相辅相成，在许多场景下有很好的表现，例如相比于AOP的编译期织入，ASM的操作速度更快。
打开java语言世界通往字节码世界的大门——ASM字节码操作类库
JDDTechTalk的博客
02-05 1522
ASM是一个通用的Java字节码操作和分析框架。它可以用于修改现有类或直接以二进制形式动态生成类。ASM提供了一些常见的字节码转换和分析算法，可以从中构建定制的复杂转换和代码分析工具。ASM提供了与其他Java字节码框架类似的功能，但侧重于性能。由于它的设计和实现尽可能小和快，因此非常适合在动态系统中使用（但当然也可以以静态方式使用，例如在编译器中）。一个.java文件经过Java编译器（javac）编译之后会生成一个.class文件。在.class文件中，存储的是字节码（ByteCode）数据。
java中lombok生成get/set方法的实现原理
06-02
Lombok是一个Java库，可以通过注解来简化Java代码，其中包括生成get/set方法的注解。Lombok通过在编译期间自动生成Java字节码来实现自动生成get/set方法的功能。 具体来说，当我们在Java类中使用Lombok的@Getter和@Setter注解时，Lombok会在编译期间自动为该类生成对应的get/set方法。在生成字节码的过程中，Lombok会使用Java的注解处理器来解析注解，然后根据注解的信息生成相应的字节码。 例如，当我们在Java类中使用@Getter注解时，Lombok会在编译期间为该类中的所有属性自动生成对应的get方法。具体实现过程如下： 1. Lombok解析@Getter注解，并获取该类中所有属性的名称和类型。 2. Lombok使用Java的反射机制获取该类中所有属性的值，并生成对应的get方法的字节码。 3. 在生成字节码的过程中，Lombok会调用Java字节码操作库ASM来生成字节码。 4. 最终，Lombok将生成的字节码插入到编译后的Java类文件中，从而实现自动生成get方法的功能。 总的来说，Lombok生成get/set方法的实现原理是利用Java的注解处理器和反射机制，在编译期间自动生成对应的Java字节码，并将其插入到编译后的Java类文件中。这种方式可以大大简化Java代码，提高开发效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值