最后
我一直以来都有整理练习大厂面试题的习惯，有随时跳出舒服圈的准备，也许求职者已经很满意现在的工作，薪酬，觉得习惯而且安逸。
不过如果公司突然倒闭，或者部门被裁减，还能找到这样或者更好的工作吗？
我建议各位，多刷刷面试题，知道最新的技术，每三个月可以去面试一两家公司，因为你已经有不错的工作了，所以可以带着轻松的心态去面试，同时也可以增加面试的经验。
我可以将最近整理的一线互联网公司面试真题+解析分享给大家，大概花了三个月的时间整理2246页，帮助大家学习进步。
由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！以下是部分内容截图：
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
如果 class文件可以按照某种固定的格式来解析，那么我们不就可以写出一个程序来解析所有的class文件了吗？
没错，是这样的。
解析了之后，我们还可以将各个区域存放在我们设定的数据格式中，我们对外暴露接口去修改这些数据结构，最后按照 class 文件格式，再反向输出到文件。
这样，我们这套程序不但能够解析 class 文件，还能够修改 class 文件。
没错，当然了，这套程序我们都能想到，市面上肯定已经有成熟的方案了：
所以，我们今天文章的主角出来了：
ASM，就是其中一个非常成熟的开源库，它可以充当「这套程序」的角色，帮助我们解析 class 文件、修改 class 文件。
你可能会疑惑，当我们熟悉了 class文件夹的结构，做一下修改，就能够完成 class 文件的编辑吗？
没错。
下面我们演示一下class 文件的修改，当然我不准备用 ASM，我们准备手工修改一下。
还是刚才的例子：
public class Hello{
public static void main(String[] args){
System.out.println(Hello.class.getSuperclass().getName());
}
}
我们 main()方法中输出了其父类的类名。
所以…我准备修改掉 Hello 的父类，目前 Hello继承自Object。
按照我们前面的描述，我们只要能够找到这个 Hello.class 文件中表示其父类的字段区域，对它就行修改就行了。
恩，为了大家能够看明白我们怎么找到 class文件的对应区域，我们可以借助 010 Editor，它内部有 class 文件模板，可以帮助我们较为清晰的看到每一部分的结构：
可以看到我们class 文件在一系列的常量池之后，会包含访问修饰符，当前类名，以及父类名。
父类名对应的值为 7，7 代表了常量池中的第 7 个元素，我们找到第 7 个常量：
u1 tag =7代表这个是Class 类型常量，常量值的索引为25。
我们再往下看第 25 个常量：
长度为 16，字符数组为：106，97…这一串数字。
这一串数字其实就是 ASCII 码，你可以随便找到个码表：
对应查出来，即为java/lang/Object。
历经这么多流程我们终于找到了对应父类的 16 进制代码的代码和编码了。
我们现在把 Hello 的继承类换成java/lang/Number。
那么只需要把 Object对应的 16 进制代码换成 Number 就可以了。
换之前：
换之后：
详细的你可以看到 4F 换成了 4E，换算为 10 进制为：79，79 对应的 ASCII 码为 N，你可以按照如果规律，发现我们把 Object 换成了 Number。
然后我们保存后，执行一下：
在更换前后，我分别执行了 java，可以看到我们输出的父类名已经完成了更换。
我们甚至可以 javap 一下：
没错吧，确实继承关系发生了改变。
可以看到，只要我们能够找到指定区域，去修改这个区域的二进制代码，这样我们就能对 class 文件为所欲为。
是不是很简单。
不过事实上并不是那么简单。
因为我们修改的这个文件极其简单，如果内容非常多，发生字符串常量池复用的时候，我们就不能这么随意的修改某个常量池的内容了。
二来刚好java/lang/Number与java/lang/Object长度完全一致，否则我们还要做非常多的对齐工作。
所以，修改 class 文件也不是那么容易的事情。
别担心，我们有 ASM。
不过，即使有 ASM 这样的类库，也不代表我们不需要了解 class 文件就可以完成 class 文件的修改了。
最起码，从我来看 ASM 类库的本意并不像 hibernate 那样，让不了解 sql 的开发者也能写出操作数据库的代码。
我们还是要了解 class 文件内部的组成，并且在修改代码时，我们还要了解代码执行时，局部变量表是如何工作的，指令对栈帧的影响等等。
我们往下看，你就明白了。
引入 ASM
好了，下面我们开始正式学习 ASM。
首先我们找到ASM 的官网：
https://asm.ow2.io/
在官网你可以看到目前最新的版本，还有一份详细的 User guide，基本包含了所有 API 的介绍。
看官网上版本迭代目前已经跟新到9.1了，那就试用最新版本吧：
// https://mvnrepository.com/artifact/org.ow2.asm/asm-commons
implementation group: ‘org.ow2.asm’, name: ‘asm-commons’, version: ‘9.1’
从学习的角度来说，在修改 class文件之前，我们可以先学习下怎么读取 class 文件内部的各个部分。
比如我想在编译期间通过编译的*.class的文件，获取其内部的所有方法名称，字段名称。
Tree Api
对于分析class 文件，我们最希望的方式是什么？
肯定是：我给你个 class 文件，然后你给我返回个 ClassNode对象，这个对象最好有个 类似List，List这样的方法或者字段。
恩…想得倒美，ASM 是这么简单的东西吗？
不过，ASM 还真就这么简单，我们来看一个类 ClassNode，这个类上注释是：
A node that represents a class.
用来指代一个 class 文件。
那么我们想要的 class 内部的一切，应该可以通过这个类的 API 直接或者间接的获取。
没错，是的，看一眼：
我们只要通过 class 文件构造这么个 ClassNode 对象，好像就可以为所欲为了。
来看下代码把：
首先我们编写一个 User:
public class User {
private String name;
private int age;
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
然后我们希望获取 User.class 中包含的所有方法以及字段：
public class TreeApiTest {
public static void main(String[] args) throws Exception {
Class clazz = User.class;
String clazzFilePath = Utils.getClassFilePath(clazz);
ClassReader classReader = new ClassReader(new FileInputStream(clazzFilePath));
ClassNode classNode = new ClassNode(Opcodes.ASM5);
classReader.accept(classNode, 0);
List methods = classNode.methods;
List fields = classNode.fields;
System.out.println(“methods:”);
for (MethodNode methodNode : methods) {
System.out.println(methodNode.name + ", " + methodNode.desc);
}
System.out.println(“fields:”);
for (FieldNode fieldNode : fields) {
System.out.println(fieldNode.name + ", " + fieldNode.desc);
}
}
}
上述代码有个辅助类Utils.getClassFilePath方法我贴一下，主要是可以通过Class 对象，找到其在 AS 中具体的路径。
public static String getClassFilePath(Class clazz) {
// file:/Users/zhy/hongyang/repo/BlogDemo/app/build/intermediates/javac/debug/classes/
String buildDir = clazz.getProtectionDomain().getCodeSource().getLocation().getFile();
String fileName = clazz.getSimpleName() + “.class”;
File file = new File(buildDir + clazz.getPackage().getName().replaceAll(“[.]”, “/”) + “/”, fileName);
return file.getAbsolutePath();
}
看下我们代码的流程：
-
首先我们拿到 class 文件的路径；
-
然后交给 ClassReader
-
再构造一个 ClassNode 对象
-
调用 ClassReader.accept()方法完成对 class 遍历，并把相关信息记录到 ClassNode 对象中；
这个时候，我们就能够通过 ClassNode 去拿我们所想要的信息了，看一下输出：
methods:
, ()V
getName, ()Ljava/lang/String;
getAge, ()I
fields:
name, Ljava/lang/String;
age, I
到这里，有没有发现，如果只是读取 class 文件，是不是简单得不能再简单了？
上述的 API，称为 Tree Api，即我们分析完成 class 文件，把信息存储到 ClassNode，然后通过 ClassNode 再读取即可，有点类似 xml 文件解析时，把整个 xml 文件读取到内存中的方式。
Core Api
不过大家如果看博客，其实上述写法在博客中并不多见，更多的博客上书写的还是基于“事件驱动”的 API，即解析class 文件过程中，每遇到一个“节点”，把节点信息交给你，我们类似于监听“节点”的解析事件，我们看下代码：
public class VisitApiTest {
public static void main(String[] args) throws Exception {
Class clazz = User.class;
String clazzFilePath = Utils.getClassFilePath(clazz);
ClassReader classReader = new ClassReader(new FileInputStream(clazzFilePath));
ClassVisitor classVisitor = new ClassVisitor(Opcodes.ASM5) {
@Override
public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
System.out.println(“visit field:” + name + " , desc = " + descriptor);
return super.visitField(access, name, descriptor, signature, value);
}
@Override
public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
System.out.println(“visit method:” + name + " , desc = " + descriptor);
return super.visitMethod(access, name, descriptor, signature, exceptions);
}
};
classReader.accept(classVisitor, 0);
}
}
我们看下输出：
visit field:name , desc = Ljava/lang/String;
visit field:age , desc = I
visit method: , desc = ()V
visit method:getName , desc = ()Ljava/lang/String;
visit method:getAge , desc = ()I
我们再次梳理下步骤：
-
首先我们拿到 class 文件的路径；
-
然后交给 ClassReader；
-
再构造一个 ClassVisitor 对象；
-
将 ClassVisitor 对象传入 ClassReader.accept()方法来接受对 class文件解析时的“节点”回调信息；
可以看到，其实和上面的 Tree Api还是比较类似的，一个是解析完成了，将所有信息保存到一个具体的对象，我们去读取；一个是参与到解析的流程中，监听解析节点的回调，输出结构。
稍微脑洞一下，假设我们自定义一个 ClassVisitor，在 visitMethod方法中，把监听到的方法声明信息存储下来，放到一个 List 结合，那么我们是不是我们就实现了一个简单的ClassNode实现呢？
所以 ClassNode 也是 ClassVisitor 的子类？
没错！
public class ClassNode extends ClassVisitor
到这里，你应该已经掌握了如何去读取一个 class 文件的内容：
class-> ClassReader.accept(ClassVisitor)
甚至一不小心掌握了 ClassNode 的原理，真是太开心了，那，我们继续。
修改字节码，就不会这么简单了哈，做好心理准备。
我们看个官方的例子：
public class C {
public void m() throws Exception {
Thread.sleep(100);
}
}
修改为：
public class C {
public static long timer;
public void m() throws Exception {
timer -= System.currentTimeMillis();
Thread.sleep(100);
timer += System.currentTimeMillis();
}
}
有点像我们给添加耗时操作的代码。
我们前面学习了，如何读取、遍历解析一个 class 文件，我们还没有尝试过如果回写一个 class文件，即我们对 class 文件做了一些修改，我们要尝试写回去覆盖原来的 class 文件。
初识 ClassWriter
看代码前，我们想一下，如果让我们来实现读取后写入，你会怎么做：
我们首先遍历的时候，拿到了 class 中所有的信息，然后调用个writeToFile 方法，直接写入不就行了么。
所以 ClassWriter 就是个 ClassVisitor？
他做的事情，就是遍历的时候保存信息，然后支持按照 class 文件格式写文件就行了。
恩…猜测正确的七七八八了。
我们先看下 ClassWriter 是不是 ClassVisitor:
public class ClassWriter extends ClassVisitor
我脑子里面已经有接下来代码的画面了：
public class ClassWriterTest {
public static void main(String[] args) throws Exception {
Class clazz = C.class;
String clazzFilePath = Utils.getClassFilePath(clazz);
ClassReader classReader = new ClassReader(new FileInputStream(clazzFilePath));
ClassWriter classWriter = new ClassWriter(0);
classReader.accept(classWriter, 0);
// 写入文件
byte[] bytes = classWriter.toByteArray();
FileOutputStream fos = new FileOutputStream(“/Users/zhy/Desktop/copyed.class”);
fos.write(bytes);
fos.flush();
fos.close();
}
}
上述代码，我们就完成了一个类的复制，如果我们传入相同的路径，那就完成了类的修改（当然了，目前我们还没修改）。
原理刚才都猜过了，唯一不同的就是没有 writeToFile，而是有个 toByteArray 方法，毕竟 byte数组更加通用一些。
开始尝试添加字段
虽然我们学会了 ClassWriter 的基础用法，但是我好像发现了一个问题。
ClassReader.accept 方法，只能接受一个 ClassVisitor 对象，因为我们必须要修改字节码，所以 ClassWriter 肯定是要传入的。
那么我们怎么传入另一个 ClassVisitor 对象去修改字节码呢？
我们看一个 ClassVisitor 的构造方法：
public ClassVisitor(final int api, final ClassVisitor classVisitor)
是不是瞬间明白了，我们可以给 ClassVisitor 传入一个实际对象，自己作为代理对象，需要拦截的方法，我们复写做操作，有点类似 ContextWrapper。
首先我们尝试添加一个字段，如果是 Tree API，其实通过 ClassNode 去 add 一个 FieldNode 就可以了。
不过我们选择用 visit API来实现，我们先编写一个 ClassVisitor 的子类：
public class AddTimerClassVisitor extends ClassVisitor {
public AddTimerClassVisitor(int api, ClassVisitor classVisitor) {
super(api, classVisitor);
}
}
这个时候，我们先代理下真正的 ClassVisitor 对象，我们要做的就是：
找个合适的位置插入一个字段；
剩下的都交给传入的 ClassVisitor 去做。
那么什么是合适的位置呢？
其实就是复写哪个方法了，那我们得知道 ClassVisitor 大概会执行哪些方法，这些方法的执行顺序是什么样子的：
visit visitSource? visitOuterClass? ( visitAnnotation |
visitAttribute )*
( visitInnerClass | visitField | visitMethod )*
visitEnd
可以看到 ClassVistor 在遍历一个类的时候，相关调用顺序如上，?代表这个方法可能不会调用，*标识可能会调用 0 次或者多次。
那么我们这个合适的位置，首先要选择一定会调用的地方；其次最好能只执行一次；最后因为本身其内部可能就有 field，我们可以收集信息，防止插入重名 field 的情况，所以最终我们选择 visitEnd 方法中。
选择了方法，那么如何才能插入一个 field 呢？
我们思考下：
其实我们的 class 最终是由 ClassWriter 去生成的，它会通过 visitField 去收集相关信息，也就是说，你调用一次 ClassWriter.visitField 方法，他就会以为真有这个 field，然后记录下来。
那就简单了，我们看代码：
public class AddTimerClassVisitor extends ClassVisitor {
public AddTimerClassVisitor(int api, ClassVisitor classVisitor) {
super(api, classVisitor);
}
@Override
public void visitEnd() {
FieldVisitor fv = cv.visitField(Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, “timer”,
“J”, null, null);
if (fv != null) {
fv.visitEnd();
}
cv.visitEnd();
}
}
demo 代码，实际生产环境需要做更严格的条件校验。
我们给原类添加了一个 timer 字段，访问修饰符是 public static，并且其类型是 J 也就是 long 类型。
我们把代码组装到一起：
public class ClassWriterTest {
public static void main(String[] args) throws Exception {
Class clazz = C.class;
String clazzFilePath = Utils.getClassFilePath(clazz);
ClassReader classReader = new ClassReader(new FileInputStream(clazzFilePath));
ClassWriter classWriter = new ClassWriter(0);
AddTimerClassVisitor addTimerClassVisitor = new AddTimerClassVisitor(Opcodes.ASM5, classWriter);
classReader.accept(addTimerClassVisitor, 0);
// 写入文件
byte[] bytes = classWriter.toByteArray();
FileOutputStream fos = new FileOutputStream(“/Users/zhy/Desktop/copyed.class”);
fos.write(bytes);
fos.flush();
fos.close();
}
}
然后我们运行下。
运行生成的类，反编译看一下：
开心…
接下来我们要尝试修改字节码了，为方法添加耗时信息打印了。
修改方法
通过上文的学习，我们之前对于方法的遍历，会执行 ClassVisitor的 visitMethod 方法，修改方法肯定是离不开这个方法了，所以我们详细的看下这个方法：
ClassVisitor
public MethodVisitor visitMethod(
final int access,
final String name,
final String descriptor,
final String signature,
final String[] exceptions) {
if (cv != null) {
return cv.visitMethod(access, name, descriptor, signature, exceptions);
}
return null;
}
可以看到，这个方法的参数中包含了方法所有声明相关的信息，但是没有包含实际运行的代码相关信息，即指令信息。
不过可以看到，这个方法的返回值并不是 null，而是一个 MethodVisitor，所以我们 ClassReader 遍历class 文件的思路肯定是：先给你方法声明相关信息，然后我们给它返回一个 MethodVisitor，它拿到这个 MethodVisitor，再通过 MethodVisitor开始遍历这个方法内部的所有信息。
所以…我们需要自定义一个 MethodVisitor 完成代码的插入。
先撸一点代码：
public class AddTimerClassVisitor extends ClassVisitor {
public AddTimerClassVisitor(int api, ClassVisitor classVisitor) {
super(api, classVisitor);
}
@Override
public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
MethodVisitor methodVisitor = super.visitMethod(access, name, descriptor, signature, exceptions);
MethodVisitor newMethodVisitor = new MethodVisitor(api, methodVisitor) {
};
return newMethodVisitor;
}
…
我们在刚才的AddTimerClassVisitor中复写了visitMethod，再其内部我们自定义了一个 MethodVisitor 代理一波本来的对象。
问题又来了？通过举一反三的思想，我们应该能够猜到 MethodVisitor 跟 ClassVisitor 设计应该是类似的，里面一堆 visitXXX 方法，我们这次修改字节码是在方法前后分别注入代码，那么到底该选择复写哪些方法呢？
这就要求我们知道 MethodVisitor 中各种 visitXXX 方法的执行顺序了：
visitAnnotationDefault?
(visitAnnotation |visitParameterAnnotation |visitAttribute )* ( visitCode
(visitTryCatchBlock |visitLabel |visitFrame |visitXxxInsn | visitLocalVariable |visitLineNumber )*
visitMaxs )? visitEnd
首先是遍历一些注解、参数相关信息；从 visitCode 开始遍历一整个方法。
我们的注入是：
-
方法开始：我们选择复写 visitCode 方法；
-
RETURN 之前：我们选择复写 visitXxxInsn，再其内部判断当前指令是否是 RETURN；
选择好了注入的时机，问题来了，我们好像还不知道注入的代码怎么写呢？
是的，这里其实要求大家对字节码是有足够的掌握，不然我怎么写估计都不太好理解，但是我尽量用推导的方式，引导大家去理解。
首先我们要了解我们添加的代码，会以字节码指令的方式注入进去，所以我们要先大概看下在字节码的层面上变化是怎样的。
所以修改之前，我们要看分别看一下修改前与修改后对应的方法字节码：
public void m() throws Exception {
Thread.sleep(100);
}
对应字节码：
public void m() throws java.lang.Exception;
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: ldc2_w #2 // long 100l
3: invokestatic #4 // Method java/lang/Thread.sleep:(J)V
6: return
LocalVariableTable:
Start Length Slot Name Signature
0 7 0 this Lcom/imooc/blogdemo/blog03/C;
Exceptions:
throws java.lang.Exception
}
public void m() throws Exception {
timer -= System.currentTimeMillis();
学习宝典
对我们开发者来说，一定要打好基础，随时准备战斗。不论寒冬是否到来，都要把自己的技术做精做深。虽然目前移动端的招聘量确实变少了，但中高端的职位还是很多的，这说明行业只是变得成熟规范起来了。竞争越激烈，产品质量与留存就变得更加重要，我们进入了技术赋能业务的时代。
不论遇到什么困难，都不应该成为我们放弃的理由！
很多人在刚接触这个行业的时候或者是在遇到瓶颈期的时候，总会遇到一些问题，比如学了一段时间感觉没有方向感，不知道该从那里入手去学习，对此我针对Android程序员，我这边给大家整理了一套学习宝典！包括不限于高级UI、性能优化、移动架构师、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter等全方面的Android进阶实践技术；希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！
【Android核心高级技术PDF文档，BAT大厂面试真题解析】
【算法合集】
【延伸Android必备知识点】
【Android部分高级架构视频学习资源】
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
, locals=1, args_size=1
0: ldc2_w #2 // long 100l
3: invokestatic #4 // Method java/lang/Thread.sleep:(J)V
6: return
LocalVariableTable:
Start Length Slot Name Signature
0 7 0 this Lcom/imooc/blogdemo/blog03/C;
Exceptions:
throws java.lang.Exception
}
public void m() throws Exception {
timer -= System.currentTimeMillis();
学习宝典
对我们开发者来说，一定要打好基础，随时准备战斗。不论寒冬是否到来，都要把自己的技术做精做深。虽然目前移动端的招聘量确实变少了，但中高端的职位还是很多的，这说明行业只是变得成熟规范起来了。竞争越激烈，产品质量与留存就变得更加重要，我们进入了技术赋能业务的时代。
不论遇到什么困难，都不应该成为我们放弃的理由！
很多人在刚接触这个行业的时候或者是在遇到瓶颈期的时候，总会遇到一些问题，比如学了一段时间感觉没有方向感，不知道该从那里入手去学习，对此我针对Android程序员，我这边给大家整理了一套学习宝典！包括不限于高级UI、性能优化、移动架构师、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter等全方面的Android进阶实践技术；希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！
【Android核心高级技术PDF文档，BAT大厂面试真题解析】
[外链图片转存中…(img-n4Lt9uxw-1715343917873)]
【算法合集】
[外链图片转存中…(img-FdQqfDO2-1715343917873)]
【延伸Android必备知识点】
[外链图片转存中…(img-QKusbOL9-1715343917873)]
【Android部分高级架构视频学习资源】
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
扫一扫
946
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
