深入探索编译插桩技术（四、ASM 探秘，2024年最新kotlin匿名内部类

2401_84002339

于 2024-04-10 18:28:52 发布

阅读量404

点赞数 5

分类专栏： 2024年程序员学习文章标签： kotlin windows 开发语言

本文链接：https://blog.csdn.net/2401_84002339/article/details/137606425

版权

2024年程序员学习专栏收录该内容

214 篇文章 0 订阅

订阅专栏

2）、获取指定字段的节点

获取一个字段节点的代码如下所示：

for(FieldNode fieldNode : (List)classNode.fields) {
// 1
if(fieldNode.name.equals(“password”)) {
// 2
fieldNode.access = Opcodes.ACC_PUBLIC;
}
}

字段节点列表 fields 是一个 ArrayList，它储存着类节点的所有字段。在注释1处，我们通过遍历 fields 集合的方式来找到目标字段节点。接着，在注释2处，我们将目标字段节点的访问权限置为 public。

除此之外，我们还可以为类添加需要的字段，代码如下所示：

FieldNode fieldNode = new FieldNode(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, “JsonChao”, “I”, null, null);
classNode.fields.add(fieldNode);

在上述代码中，我们直接给目标类节点添加了一个 “public static int JsonChao” 的字段，需要注意的是，第三个参数的 “I” 表示的是 int 的类型描述符。

那么，对于一个字段节点，又包含有哪些字段信息呢？

如下所示：

字段信息

类型	名称	说明
int	access	访问级
String	name	字段名
String	signature	签名，通常是 null
String	desc	类型描述，例如 Ljava/lang/String、D（double）、F（float）
Object	value	初始值，通常为 null
List	visibleAnnotations	可见的注解
List	invisibleAnnotations	不可见的注解
List	attrs	字段的 Attribute

接下来，我们看看如何获取一个方法节点。

3）、获取指定的方法节点

获取指定的方法节点的代码如下所示：

for(MethodNode methodNode : (List)classNode.methods) {
// 1、判断方法名是否匹配目标方法
if(methodNode.name.equals(“getName”)) {
// 2、进行操作
}
}

methods 同 fields 一样，也是一个 ArrayList，通过遍历并判断方法名的方式即可匹配到目标方法。

对于一个方法节点来说，它包含有如下信息：

方法节点包含的信息

类型	名称	说明
int	access	访问级
String	name	方法名
String	desc	方法描述，其包含方法的返回值和参数
String	signature	签名，通常是null
List	exceptions	可能返回的异常列表
List	visibleAnnotations	可见的注解列表
List	invisibleAnnotations	不可见的注解列表
List	attrs	方法的Attribute列表
Object	annotationDefault	默认的注解
List[]	visibleParameterAnnotations	可见的参数注解列表
List[]	invisibleParameterAnnotations	不可见的参数注解列表
InsnList	instructions	操作码列表
List	tryCatchBlocks	try-catch块列表
int	maxStack	最大操作栈的深度
int	maxLocals	最大局部变量区的大小
List	localVariables	本地（局部）变量节点列表

4、操控操作码

在操控字节码之前，我们必须先了解下 instructions，即 操作码列表，它是 方法节点中用于存储操作码的地方，其中 每一个元素都代表一行操作码。

ASM 将一行字节码封装为一个 xxxInsnNode（Insn 表示的是 Instruction 的缩写，即指令/操作码），例如 ALOAD/ARestore 指令被封装入变量操作码节点 VarInsnNode，INVOKEVIRTUAL 指令则会被封入方法操作码节点 MethodInsnNode 之中。

对于所有的指令节点 xxxInsnNode 来说，它们都继承自抽象操作码节点 AbstractInsnNode。其所有的派生类使用详情如下所示。

所有的指令码节点说明

名称	说明	参数
FieldInsnNode	用于 GETFIELD 和 PUTFIELD 之类的字段操作的字节码	String owner 字段所在的类
String name 字段的名称
String desc 字段的类型
FrameNode	栈映射帧的对应的帧节点	待补充
IincInsnNode	用于 IINC 变量自加操作的字节码	int var：目标局部变量的位置
int incr：要增加的数

InsnNode	一切无参数值操作的字节码，例如 ALOAD_0，DUP（注意不包含 POP）	无
IntInsnNode	用于 BIPUSH、SIPUSH 和 NEWARRAY 这三个直接操作整数的操作	int operand：操作的整数值
InvokeDynamicInsnNode	用于 Java7 新增的 INVOKEDYNAMIC 操作的字节码	String name：方法名称
String desc：方法描述
Handle bsm：句柄
Object[] bsmArgs：参数常量
JumpInsnNode	用于 IFEQ 或 GOTO 等跳转操作字节码	LabelNode lable：目标 lable
LabelNode	一个用于表示跳转点的 Label 节点	无
LdcInsnNode	使用 LDC 加载常量池中的引用值并进行插入的字节码	Object cst：引用值
LineNumberNode	表示行号的节点	int line：行号
LabelNode start：对应的第一个 Label
LookupSwitchInsnNode	用于实现 LOOKUPSWITCH 操作的字节码	LabelNode dflt：default 块对应的 Lable
List keys 键列表
List labels：对应的 Label 节点列表
MethodInsnNode	用于 INVOKEVIRTUAL 等传统方法调用操作的字节码，不适用于 Java7 新增的 INVOKEDYNAMIC	String owner ：方法所在的类
String name ：方法名称
String desc：方法描述
MultiANewArrayInsnNode	用于 MULTIANEWARRAY 操作的字节码	String desc：类型描述
int dims：维数
TableSwitchInsnNode	用于实现 TABLESWITCH 操作的字节码	int min：键的最小值
int max：键的最大值
LabelNode dflt：default 块对应的 Lable
List labels：对应的 Label 节点列表
TypeInsnNode	用于实现 NEW、ANEWARRAY 和 CHECKCAST 等类型相关操作的字节码	String desc：类型

VarInsnNode	用于实现 ALOAD、ASTORE 等局部变量操作的字节码	int var：局部变量

下面，我们就开始来讲解下字节码操控有哪几种常见的方式。

1、获取操作码的位置

获取指定操作码位置的代码如下所示：

for(AbstractInsnNode ainNode : methodNode.instructions.toArray()) {
if(ainNode.getOpcode() == Opcodes.SIPUSH && ((IntInsnNode)ainNode).operand == 16) {
…//进行操作
}
}

由于一般情况下我们都无法确定操作码在列表中的具体位置，因此 通常会通过遍历的方式去判断其关键特征，以此来定位指定的操作码，上述代码就能定位到一个 SIPUSH 16 的字节码，需要注意的是，有时一个方法中会有多个相同的指令，这是我们需要靠判断前后字节码识别其特征来定位，也可以记下其命中次数然后设定在某一次进行操作，一般情况下我们都是使用的第二种。

2、替换指定的操作码

替换指定的操作码的代码如下所示：

这里我们 直接调用了 InsnList 的 set 方法就能替换指定的操作码对象，我们在获取了 “BIPUSH 64” 字节码的位置后，便将封装它的操作码替换为一个新的 VarInsnNode 操作码，这个新操作码封装了 “ALOAD 1” 字节码，将原程序中 将值设为16 替换为 将值设为局部变量1。

3、删除指定的操作码

methodNode.instructions.remove(xxx);

xxx 表示的是要删除的操作码实例，我们直接调用用 InsnList 的 remove 方法将它移除掉即可。

4、插入指定的操作码

InsnList 主要提供了四类方法用于插入字节码，如下所示：

1）、add(AbstractInsnNode insn)： 将一个操作码添加到 InsnList 的末尾。
2）、insert(AbstractInsnNode insn)： 将一个操作码插入到这个 InsnList 的开头。
3）、insert(AbstractInsnNode insnNode，AbstractInsnNode insn)： 将一个操作码插入到另一个操作码的下面。
4）、insertBefore(AbstractInsnNode insnNode，AbstractInsnNode insn) 将一个操作码插入到另一个操作码的上面

接下来看看如何使用这些方法插入指定的操作码，代码如下所示：

for(AbstractInsnNode ainNode : methodNode.instructions.toArray()) {
if(ainNode.getOpcode() == Opcodes.BIPUSH && ((IntInsnNode)ainNode).operand == 16) {
methodNode.instructions.insert(ainNode, new MethodInsnNode(Opcodes.INVOKEVIRTUAL, “java/awt/image/BufferedImage”, “getWidth”, “(Ljava/awt/image/ImageObserver;)I”));
methodNode.instructions.insert(ainNode, new InsnNode(Opcodes.ACONSTNULL));
methodNode.instructions.set(ainNode, new VarInsnNode(Opcodes.ALOAD, 1));
}
}

这样，我们就能将

BIPUSH 16

替换为

ALOAD 1
ACONSTNULL
INVOKEVIRTUAL java/awt/image/BufferedImage.getWidth(Ljava/awt/image/ImageObserver;)I

当我们操控完指定的类节点之后，就可以使用 ASM 的 ClassWriter 类来输出字节码，代码如下所示：

// 1、让 ClassWriter 自行计算最大栈深度和栈映射帧等信息
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTEFRAMES);
classNode.accept(classWriter);
return classWriter.toByteArray();

关于 ClassWriter 的具体用法，我们会在 ASM Core API 这部分来进行逐步讲解。下面👇，我们就先来看看 ASM 的事件模型。

三、ASM 的事件模型（ASM Core API）

对象模型是由事件模型封装而成，因此事件模型的上手难度会更大一些。

对于事件模型来说，它 采用了设计模式中的访问者模式。它的出现是为了更好地解决这样一种需求：有 A 个元素和 N 种算法，每个算法都能作用于任意一个元素，并且在不同的元素上有不同的运行方式。

在访问者模式出现之前，我们通常会在每一个元素对应的类中添加 N 个方法，然后在每一个方法中去实现一个算法，但是，这样的做法容易导致代码耦合性过高，并且可维护性差。

因此，访问者模式应运而生，我们可以建立 N 个访问者，并且每一个访问者拥有一个算法及其内部的 A 种运行方式。当我们需要调用一个算法时，就让相应的访问者去访问元素，然后让访问者根据被访问对象选择相应的算法。

需要注意的是，访问者并没有直接去操作元素，而是先让元素类调用 accept 方法接收访问者，然后，访问者在元素类的内部方法中开始调用 visit 方法访问当前的元素类。这样，访问者便能直接访问元素类中的内部私有成员，其优势在于 避免了暴露不必要的内部细节。

要理解 ASM 的事件模型，我们就需要对其中的 两个重要成员的工作原理 有较深的了解。它们便是 类访问者 ClassVisitor 与类读取（解析）者 ClassReader。

从字节码的视角中，一个 Java 类由很多组件凝聚而成，而这之中便包括超类、接口、属性、域和方法等等。当我们在使用 ASM 进行操控时，可以将它们视为一个个与之对应的事件。因此 ASM 提供了一个类访问者 ClassVisitor，以通过它来访问当前类的各个组件，当解析器 ClassReader 依次遇到上述的各个组件时，ClassVisitor 上对应的 visitor 事件处理器方法均会被一一调用。

与类相似，方法也是由多个组件凝聚而成的，其对应着方法属性、注解及编译后的代码（Class 字节码）。ASM 的 MethodVisitor 提供了一种 hook（钩子）机制，以便能够访问方法中的每一个操作码，这样我们便能够对字节码文件进行细粒度地修改。

下面，我们便来一一分析下它们。

1、类访问者 ClassVisitor

通常我们在使用 ASM 的访问者模式有一个模板代码，如下所示：

InputStream is = new FileInputStream(classFile);
// 1
ClassReader classReader = new ClassReader(is);
// 2
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
// 3
ClassVisitor classVisitor = new TraceClassAdapter(Opcodes.ASM5, classWriter);
// 4
classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES);

首先，在注释1处，我们 将目标文件转换为流的形式，并将它融入类读取器 ClassReader 之中。然后，在注释2处，我们 构建了一个类写入器 ClassWriter，其参数 COMPUTE_MAXS 的作用是将自动计算本地变量表最大值和操作数栈最大值的任务托付给了ASM。接着，在注释3处，新建了一个自定义的类访问器，这个自定义的 ClassVisitor 的作用是为了在每一个方法的开始和结尾处插入相应的记时代码，以便统计出每一个方法的耗时。最后，在注释4处，类读取器 ClassReader 实例这个被访问者调用了自身的 accept 方法接收了一个 classVisitor 实例，需要注意的是，第二个参数指定了 EXPAND_FRAMES，旨在说明在读取 class 的时候需要同时展开栈映射帧（StackMap Frame），如果我们需要使用自定义的 MethodVisitor 去修改方法中的指令时必须要指定这个参数，。

上面，我们说到了栈映射帧（StackMap Frame），它到底是什么呢？

栈映射帧 StackMap Frame

它是 Java 6 以后引入的一种验证机制，用于 检验 Java 字节码的正确性。它的工作方式是 记录每一个关键步骤完成后其方法中操作数栈的理论状态，然后，在实际运行的时候，ASM 会将其实际状态和理论状态对比，如果状态不一致则表明出现了错误。

但栈映射帧的实现并不简单，因此通过调用 classReader 实例的 accept 方法我们便可以让 ASM 自动去计算栈映射帧，尽管这 会增加 50% 的额外运算。此外，可能会有小概率的情况遇到 栈映射帧验证失败 的情况，例如：VerifyError: Inconsistent stackmap frames at branch target 这个错误。

最常见的原因可能就是由于 字节码写错造成的，此时，我们应该去检查对应的字节码实现代码。此外，也可能是 JDK 版本的支持问题或是 ASM 自身的缺陷，但是，这种情况几乎不会发生。

2、类读取（解析）者 ClassVisitor

现在，让我们再回到上述注释4处的代码，在这里，我们调用了 classReader 的 accept 方法接收了一个访问者 classVisitor，下面，我们来看看其内部的实现，代码如下所示（源码实现较长，这里我们只需关注注释处的代码即可：

/**

Makes the given visitor visit the Java class of this {@link ClassReader}
. This class is the one specified in the constructor (see
{@link #ClassReader(byte[]) ClassReader}).
@param classVisitor

       the visitor that must visit this class.

@param flags

       option flags that can be used to modify the default behavior

       of this class. See {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES}

       , {@link #SKIP_FRAMES}, {@link #SKIP_CODE}.

*/
public void accept(final ClassVisitor classVisitor, final int flags) {
accept(classVisitor, new Attribute[0], flags);
}

在 accept 方法中又继续调用了 classReader 的另一个 accept 重载方法，如下所示：

public void accept(final ClassVisitor classVisitor,
final Attribute[] attrs, final int flags) {
int u = header; // current offset in the class file
char[] c = new char[maxStringLength]; // buffer used to read strings

Context context = new Context();
context.attrs = attrs;
context.flags = flags;
context.buffer = c;

// 1、读取类的描述信息，例如 access、name 等等
int access = readUnsignedShort(u);
String name = readClass(u + 2, c);
String superClass = readClass(u + 4, c);
String[] interfaces = new String[readUnsignedShort(u + 6)];
u += 8;
for (int i = 0; i < interfaces.length; ++i) {
interfaces[i] = readClass(u, c);
u += 2;
}

// 2、读取类的属性信息，例如签名 signature、sourceFile 等等。
String signature = null;
String sourceFile = null;
String sourceDebug = null;
String enclosingOwner = null;
String enclosingName = null;
String enclosingDesc = null;
int anns = 0;
int ianns = 0;
int tanns = 0;
int itanns = 0;
int innerClasses = 0;
Attribute attributes = null;

u = getAttributes();
for (int i = readUnsignedShort(u); i > 0; --i) {
String attrName = readUTF8(u + 2, c);
// tests are sorted in decreasing frequency order
// (based on frequencies observed on typical classes)
if (“SourceFile”.equals(attrName)) {
sourceFile = readUTF8(u + 8, c);
} else if (“InnerClasses”.equals(attrName)) {
innerClasses = u + 8;
} else if (“EnclosingMethod”.equals(attrName)) {
enclosingOwner = readClass(u + 8, c);
int item = readUnsignedShort(u + 10);
if (item != 0) {
enclosingName = readUTF8(items[item], c);
enclosingDesc = readUTF8(items[item] + 2, c);
}
} else if (SIGNATURES && “Signature”.equals(attrName)) {
signature = readUTF8(u + 8, c);
} else if (ANNOTATIONS
&& “RuntimeVisibleAnnotations”.equals(attrName)) {
anns = u + 8;
} else if (ANNOTATIONS
&& “RuntimeVisibleTypeAnnotations”.equals(attrName)) {
tanns = u + 8;
} else if (“Deprecated”.equals(attrName)) {
access |= Opcodes.ACC_DEPRECATED;
} else if (“Synthetic”.equals(attrName)) {
access |= Opcodes.ACC_SYNTHETIC
| ClassWriter.ACC_SYNTHETIC_ATTRIBUTE;
} else if (“SourceDebugExtension”.equals(attrName)) {
int len = readInt(u + 4);
sourceDebug = readUTF(u + 8, len, new char[len]);
} else if (ANNOTATIONS
&& “RuntimeInvisibleAnnotations”.equals(attrName)) {
ianns = u + 8;
} else if (ANNOTATIONS
&& “RuntimeInvisibleTypeAnnotations”.equals(attrName)) {
itanns = u + 8;
} else if (“BootstrapMethods”.equals(attrName)) {
int[] bootstrapMethods = new int[readUnsignedShort(u + 8)];
for (int j = 0, v = u + 10; j < bootstrapMethods.length; j++) {
bootstrapMethods[j] = v;
v += 2 + readUnsignedShort(v + 2) << 1;
}
context.bootstrapMethods = bootstrapMethods;
} else {
Attribute attr = readAttribute(attrs, attrName, u + 8,
readInt(u + 4), c, -1, null);
if (attr != null) {
attr.next = attributes;
attributes = attr;
}
}
u += 6 + readInt(u + 4);
}

// 3、访问类的描述信息
classVisitor.visit(readInt(items[1] - 7), access, name, signature,
superClass, interfaces);

// 4、访问源码和 debug 信息
if ((flags & SKIP_DEBUG) == 0
&& (sourceFile != null || sourceDebug != null)) {
classVisitor.visitSource(sourceFile, sourceDebug);
}

// 5、访问外部类
if (enclosingOwner != null) {
classVisitor.visitOuterClass(enclosingOwner, enclosingName,
enclosingDesc);
}

// 6、访问类注解和类型注解
if (ANNOTATIONS && anns != 0) {
for (int i = readUnsignedShort(anns), v = anns + 2; i > 0; --i) {
v = readAnnotationValues(v + 2, c, true,
classVisitor.visitAnnotation(readUTF8(v, c), true));
}
}
if (ANNOTATIONS && ianns != 0) {
for (int i = readUnsignedShort(ianns), v = ianns + 2; i > 0; --i) {
v = readAnnotationValues(v + 2, c, true,
classVisitor.visitAnnotation(readUTF8(v, c), false));
}
}
if (ANNOTATIONS && tanns != 0) {
for (int i = readUnsignedShort(tanns), v = tanns + 2; i > 0; --i) {
v = readAnnotationTarget(context, v);
v = readAnnotationValues(v + 2, c, true,
classVisitor.visitTypeAnnotation(context.typeRef,
context.typePath, readUTF8(v, c), true));
}
}
if (ANNOTATIONS && itanns != 0) {
for (int i = readUnsignedShort(itanns), v = itanns + 2; i > 0; --i) {
v = readAnnotationTarget(context, v);
v = readAnnotationValues(v + 2, c, true,
classVisitor.visitTypeAnnotation(context.typeRef,
context.typePath, readUTF8(v, c), false));
}
}

// 7、访问类的属性
while (attributes != null) {
Attribute attr = attributes.next;
attributes.next = null;
classVisitor.visitAttribute(attributes);
attributes = attr;
}

// 8、访问内部类
if (innerClasses != 0) {
int v = innerClasses + 2;
for (int i = readUnsignedShort(innerClasses); i > 0; --i) {
classVisitor.visitInnerClass(readClass(v, c),
readClass(v + 2, c), readUTF8(v + 4, c),
readUnsignedShort(v + 6));
v += 8;
}
}

// 9、访问字段和方法
u = header + 10 + 2 * interfaces.length;
for (int i = readUnsignedShort(u - 2); i > 0; --i) {
u = readField(classVisitor, context, u);
}
u += 2;
for (int i = readUnsignedShort(u - 2); i > 0; --i) {
u = readMethod(classVisitor, context, u);
}

// 访问当前类结束时调用
classVisitor.visitEnd();
}

首先，在 classReader 实例的 accept 方法中的注释1和注释2处，我们会 先开始进行类相关的字节码解析的工作：读取了类的描述和属性信息。接着，在注释3 ~ 注释8处，我们调用了 classVisitor 一系列的 visitxxx 方法访问 classReader 解析完字节码后保存在内存的信息。然后，在注释9处，分别调用了 readField 方法和 readMethod 方法去访问类中的方法和字段。最后，调用 classVisitor 的 visitEnd 标识已访问结束。

1）、类内字段的解析

这里，我们先来看看 readField 的源码实现，如下所示：

/**

Reads a field and makes the given visitor visit it.
@param classVisitor

       the visitor that must visit the field.

@param context

       information about the class being parsed.

@param u

       the start offset of the field in the class file.

@return the offset of the first byte following the field in the class.
*/
private int readField(final ClassVisitor classVisitor,
final Context context, int u) {
// 1、读取字段的描述信息
char[] c = context.buffer;
int access = readUnsignedShort(u);
String name = readUTF8(u + 2, c);
String desc = readUTF8(u + 4, c);
u += 6;

// 2、读取字段的属性
String signature = null;
int anns = 0;
int ianns = 0;
int tanns = 0;
int itanns = 0;
Object value = null;
Attribute attributes = null;

for (int i = readUnsignedShort(u); i > 0; --i) {
String attrName = readUTF8(u + 2, c);
// tests are sorted in decreasing frequency order
// (based on frequencies observed on typical classes)
if (“ConstantValue”.equals(attrName)) {
int item = readUnsignedShort(u + 8);
value = item == 0 ? null : readConst(item, c);
} else if (SIGNATURES && “Signature”.equals(attrName)) {
signature = readUTF8(u + 8, c);
} else if (“Deprecated”.equals(attrName)) {
access |= Opcodes.ACC_DEPRECATED;
} else if (“Synthetic”.equals(attrName)) {
access |= Opcodes.ACC_SYNTHETIC
| ClassWriter.ACC_SYNTHETIC_ATTRIBUTE;
} else if (ANNOTATIONS
&& “RuntimeVisibleAnnotations”.equals(attrName)) {
anns = u + 8;
} else if (ANNOTATIONS
&& “RuntimeVisibleTypeAnnotations”.equals(attrName)) {
tanns = u + 8;
} else if (ANNOTATIONS
&& “RuntimeInvisibleAnnotations”.equals(attrName)) {
ianns = u + 8;
} else if (ANNOTATIONS
&& “RuntimeInvisibleTypeAnnotations”.equals(attrName)) {
itanns = u + 8;
} else {
Attribute attr = readAttribute(context.attrs, attrName, u + 8,
readInt(u + 4), c, -1, null);
if (attr != null) {
attr.next = attributes;
attributes = attr;
}
}
u += 6 + readInt(u + 4);
}
u += 2;

// 3、访问字段的声明
FieldVisitor fv = classVisitor.visitField(access, name, desc,
signature, value);
if (fv == null) {
return u;
}

// 4、访问字段的注解和类型注解
if (ANNOTATIONS && anns != 0) {
for (int i = readUnsignedShort(anns), v = anns + 2; i > 0; --i) {
v = readAnnotationValues(v + 2, c, true,
fv.visitAnnotation(readUTF8(v, c), true));
}
}
if (ANNOTATIONS && ianns != 0) {
for (int i = readUnsignedShort(ianns), v = ianns + 2; i > 0; --i) {
v = readAnnotationValues(v + 2, c, true,
fv.visitAnnotation(readUTF8(v, c), false));
}
}
if (ANNOTATIONS && tanns != 0) {
for (int i = readUnsignedShort(tanns), v = tanns + 2; i > 0; --i) {
v = readAnnotationTarget(context, v);
v = readAnnotationValues(v + 2, c, true,
fv.visitTypeAnnotation(context.typeRef,
context.typePath, readUTF8(v, c), true));
}
}
if (ANNOTATIONS && itanns != 0) {
for (int i = readUnsignedShort(itanns), v = itanns + 2; i > 0; --i) {
v = readAnnotationTarget(context, v);
v = readAnnotationValues(v + 2, c, true,
fv.visitTypeAnnotation(context.typeRef,
context.typePath, readUTF8(v, c), false));
}
}

// 5、访问字段的属性
while (attributes != null) {
Attribute attr = attributes.next;
attributes.next = null;
fv.visitAttribute(attributes);
attributes = attr;
}

// 访问字段结束时调用
fv.visitEnd();

return u;
}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。