曹工说Spring Boot源码（25）-- Spring注解扫描的瑞士军刀，ASM + Java Instrumentation，顺便提提Jar包破解

写在前面的话

相关背景及资源：

曹工说Spring Boot源码（1）-- Bean Definition到底是什么，附spring思维导图分享

曹工说Spring Boot源码（2）-- Bean Definition到底是什么，咱们对着接口，逐个方法讲解

曹工说Spring Boot源码（3）-- 手动注册Bean Definition不比游戏好玩吗，我们来试一下

曹工说Spring Boot源码（4）-- 我是怎么自定义ApplicationContext，从json文件读取bean definition的？

曹工说Spring Boot源码（5）-- 怎么从properties文件读取bean

曹工说Spring Boot源码（6）-- Spring怎么从xml文件里解析bean的

曹工说Spring Boot源码（7）-- Spring解析xml文件，到底从中得到了什么（上）

曹工说Spring Boot源码（8）-- Spring解析xml文件，到底从中得到了什么（util命名空间）

曹工说Spring Boot源码（9）-- Spring解析xml文件，到底从中得到了什么（context命名空间上）

曹工说Spring Boot源码（10）-- Spring解析xml文件，到底从中得到了什么（context:annotation-config 解析）

曹工说Spring Boot源码（11）-- context:component-scan，你真的会用吗（这次来说说它的奇技淫巧）

曹工说Spring Boot源码（12）-- Spring解析xml文件，到底从中得到了什么（context:component-scan完整解析)

曹工说Spring Boot源码（13）-- AspectJ的运行时织入（Load-Time-Weaving），基本内容是讲清楚了（附源码）

曹工说Spring Boot源码（14）-- AspectJ的Load-Time-Weaving的两种实现方式细细讲解，以及怎么和Spring Instrumentation集成

曹工说Spring Boot源码（15）-- Spring从xml文件里到底得到了什么（context：load-time-weaver 完整解析）

曹工说Spring Boot源码（16）-- Spring从xml文件里到底得到了什么（aop：config完整解析【上】）

曹工说Spring Boot源码（17）-- Spring从xml文件里到底得到了什么（aop：config完整解析【中】）

曹工说Spring Boot源码（18）-- Spring AOP源码分析三部曲，终于快讲完了 (aop：config完整解析【下】)

曹工说Spring Boot源码（19）-- Spring 带给我们的工具利器，创建代理不用愁（ProxyFactory）

曹工说Spring Boot源码（20）-- 码网恢恢，疏而不漏，如何记录Spring RedisTemplate每次操作日志

曹工说Spring Boot源码（21）-- 为了让大家理解Spring Aop利器ProxyFactory，我已经拼了

曹工说Spring Boot源码（22）-- 你说我Spring Aop依赖AspectJ，我依赖它什么了

曹工说Spring Boot源码（23）-- ASM又立功了，Spring原来是这么递归获取注解的元注解的

曹工说Spring Boot源码（24）-- Spring注解扫描的瑞士军刀，asm技术实战（上）

工程代码地址 思维导图地址

工程结构图：

概要

上一篇，我们讲了ASM基本的使用方法，具体包括：复制一个class、修改class版本号、增加一个field、去掉一个field/method等等；同时，我们也知道了怎么才能生成一个全新的class。

但是，仅凭这点粗浅的知识，我们依然不太理解能干嘛，本篇会带大家实现简单的AOP功能，当然了，学完了之后，可能你像我一样，更困惑了，那说明你变强了。

本篇的核心是，在JVM加载class的时候，去修改class，修改class的时候，加入我们的aop逻辑。JVM加载class的时候，去修改class，这项技术就是load-time-weaver，实现load-time-weaver有两种方式，这两种方式，核心差别在于修改class的时机不同。

• 第一种，定制classloader，在把字节码交给JVM去defineClass之前，去织入切面逻辑
• 第二种，利用Java 官方提供的instrumentation机制，注册一个类转换器到 JVM。JVM在加载class的时候，就会传入class的原始字节码数组，回调我们的类转换器，我们类转换器中可以修改原始字节码，并将修改后的字节码数组返回回去，JVM就会用我们修改后的字节码去defineClass了

在直接开始前，声明本篇文章，是基于下面这篇文章中的代码demo，我自己稍做了修改，并附上源码（原文是贴了代码，但是没有直接提供代码地址，不贴心啊）。

初探 Java agent

要达成的目标

目标就是给下面的测试类，加上一点点切面功能。

package org.xunche.app;
public class HelloXunChe {
    public static void main(String[] args) throws InterruptedException {
        HelloXunChe helloXunChe = new HelloXunChe();
        helloXunChe.sayHi();
    }
    public void sayHi() throws InterruptedException {
        System.out.println("hi, xunche");
        sleep();
    }
    public void sleep() throws InterruptedException {
        Thread.sleep((long) (Math.random() * 200));
    }
}

我们希望，class在执行的时候，能够打印方法执行的耗时，也就是，最终的class，需要是下面这样的。

package org.xunche.app;
import org.xunche.agent.TimeHolder;
public class HelloXunChe {
    public HelloXunChe() {
    }
    public static void main(String[] args) throws InterruptedException {
        TimeHolder.start(args.getClass().getName() + "." + "main");
        // 业务逻辑开始
        HelloXunChe helloXunChe = new HelloXunChe();
        helloXunChe.sayHi();
        //业务逻辑结束
        HelloXunChe helloXunChe = args.getClass().getName() + "." + "main";
        System.out.println(helloXunChe + ": " + TimeHolder.cost(helloXunChe));
    }
    public void sayHi() throws InterruptedException {
        TimeHolder.start(this.getClass().getName() + "." + "sayHi");
        System.out.println("hi, xunche");
        // 业务逻辑开始
        this.sleep();
        //业务逻辑结束
        String var1 = this.getClass().getName() + "." + "sayHi";
        System.out.println(var1 + ": " + TimeHolder.cost(var1));
    }
    public void sleep() throws InterruptedException {
        TimeHolder.start(this.getClass().getName() + "." + "sleep");
        // 业务逻辑开始
        Thread.sleep((long)(Math.random() * 200.0D));
        //业务逻辑结束
        String var1 = this.getClass().getName() + "." + "sleep";
        System.out.println(var1 + ": " + TimeHolder.cost(var1));
    }
}

所以，我们大概就是，要做下面的这样一个切面：

@Override
protected void onMethodEnter() {
    //在方法入口处植入
    String className = getClass().getName();
    String s = className + "." + methodName;
    TimeHolder.start(s);
}
@Override
protected void onMethodExit(int i) {
    //在方法出口植入
    String className = getClass().getName();
    String s = className + "." + methodName;
    long cost = TimeHolder.cost(s);
    System.out.println(s + ": " + cost);
}

但是，习惯了动态代理的我们，看上面的代码可能会有点误解。上面的代码，不是在执行目标方法前，调用切面；而是：直接把切面代码嵌入了目标方法。

想必大家都明确了要达成的目标了，下面说，怎么做。

java agent/instrumentation机制

这部分，大家可以结合开头那个链接一起学习。

首先，我请大家看看java命令行的选项。直接在cmd里敲java，出现如下：

看了和没看一样，那我们再看一张图，在大家破解某些java编写的软件时，可能会涉及到jar包破解，比如：

大家可以使用jad这类反编译软件，打开jar包看下，看看里面是啥：

可以发现，里面有一个MANIFEST.MF文件，里面指定了Premain-Class这个key-value，从这个名字，大家可能知道了，我们平时运行java程序，都是运行main方法，这里来个premain，那这意思，就是在main方法前面插个队呗？

你说的没有错，确实是插队了，拿上面的破解jar包举例，里面的Premain-Class方法，对应的Agent类，反编译后的代码如下：

核心代码就是图里那一行：

java.lang.instrument.Instrumentation
public interface Instrumentation {
    /**
     * Registers the supplied transformer. All future class definitions
     * will be seen by the transformer, except definitions of classes upon which any
     * registered transformer is dependent.
     * The transformer is called when classes are loaded, when they are
     * {@linkplain #redefineClasses redefined}. and if <code>canRetransform</code> is true,
     * when they are {@linkplain #retransformClasses retransformed}.
     * See {@link java.lang.instrument.ClassFileTransformer#transform
     * ClassFileTransformer.transform} for the order
     * of transform calls.
     * If a transformer throws
     * an exception during execution, the JVM will still call the other registered
     * transformers in order. The same transformer may be added more than once,
     * but it is strongly discouraged -- avoid this by creating a new instance of
     * transformer class.
     * <P>
     * This method is intended for use in instrumentation, as described in the
     * {@linkplain Instrumentation class specification}.
     *
     * @param transformer          the transformer to register
     * @param canRetransform       can this transformer's transformations be retransformed
     * @throws java.lang.NullPointerException if passed a <code>null</code> transformer
     * @throws java.lang.UnsupportedOperationException if <code>canRetransform</code>
     * is true and the current configuration of the JVM does not allow
     * retransformation ({@link #isRetransformClassesSupported} is false)
     * @since 1.6
     */
    void
    addTransformer(ClassFileTransformer transformer, boolean canRetransform);

    ...
}

这个类，就是官方jdk提供的类，官方的本意呢，肯定是让大家，在加载class的时候，给大家提供一个机会，去修改class，比如，某个第三方jar包，我们需要修改，但是没有源码，就可以这么干；或者是一些要统一处理，不方便在应用中耦合的功能：比如埋点、性能监控、日志记录、安全监测等。

说回这个方法，参数为ClassFileTransformer，这个接口，就一个方法，大家看看注释：

	/**
     * ...
     *
	 * @param classfileBuffer       the input byte buffer in class file format - must not be modified
     *
     * @throws IllegalClassFormatException if the input does not represent a well-formed class file
     * @return  a well-formed class file buffer (the result of the transform),
                or <code>null</code> if no transform is performed.
     * @see Instrumentation#redefineClasses
     */
    byte[]
    transform(  ClassLoader         loader,
                String              className,
                Class<?>            classBeingRedefined,
                ProtectionDomain    protectionDomain,
                byte[]              classfileBuffer)
        throws IllegalClassFormatException;

• classfileBuffer，就是原始class字节码数组，官方注释说：一定不能修改它
• 返回的byte[]数组，注释：一个格式正确的class文件数组，或者null，表示没有进行转换

别的也不多说了，反正就是：jvm给你原始class，你自己修改，还jvm一个改后的class。

所以，大家估计也能猜到破解的原理了，但我还是希望大家：有能力支持正版的话，还是要支持。

接下来，我们回到我们的目标的实现上。

agent模块开发

完整代码：https://gitee.com/ckl111/all-simple-demo-in-work/tree/master/java-agent-premain-demo

增加类转换器

package org.xunche.agent;
import org.objectweb.asm.*;
import org.objectweb.asm.commons.AdviceAdapter;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;

public class TimeAgentByJava {
    public static void premain(String args, Instrumentation instrumentation) {
        instrumentation.addTransformer(new TimeClassFileTransformer());
    }
}

类转换器的详细代码如下：

private static class TimeClassFileTransformer implements ClassFileTransformer {
        @Override
        public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
            if (className.startsWith("java") || className.startsWith("jdk") || className.startsWith("javax") || className.startsWith("sun") || className.startsWith("com/sun")|| className.startsWith("org/xunche/agent")) {
                //return null或者执行异常会执行原来的字节码
                return null;
            }
            // 1
            System.out.println("loaded class: " + className);
            ClassReader reader = new ClassReader(classfileBuffer);
            // 2
            ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
            // 3
            reader.accept(new TimeClassVisitor(writer), ClassReader.EXPAND_FRAMES);
            // 4
            return writer.toByteArray();
        }
    }

• 1处，将原始的类字节码加载到classReader中

  ClassReader reader = new ClassReader(classfileBuffer);

• 2处，将reader传给ClassWriter，这个我们没讲过，大概就是使用classreader中的东西，来构造ClassWriter；可以差不多理解为复制classreader的东西到ClassWriter中。

  大家可以看如下代码：

  public ClassWriter(final ClassReader classReader, final int flags) {
      super(Opcodes.ASM6);
      symbolTable = new SymbolTable(this, classReader);
      ...
    }
  

  这里new了一个对象，SymbolTable。

  SymbolTable(final ClassWriter classWriter, final ClassReader classReader) {
      this.classWriter = classWriter;
      this.sourceClassReader = classReader;
  
      // Copy the constant pool binary content.
      byte[] inputBytes = classReader.b;
      int constantPoolOffset = classReader.getItem(1) - 1;
      int constantPoolLength = classReader.header - constantPoolOffset;
      constantPoolCount = classReader.getItemCount();
      constantPool = new ByteVector(constantPoolLength);
      constantPool.putByteArray(inputBytes, constantPoolOffset, constantPoolLength);
      ...
  }
  

  大家直接看上面的注释吧，Copy the constant pool binary content。反正吧，基本可以理解为，classwriter拷贝了classreader中的一部分东西，应该不是全部。

  为什么不是全部，因为我试了下:

      public static void main(String[] args) throws IOException {
          ClassReader reader = new ClassReader("org.xunche.app.HelloXunChe");
          ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
          byte[] bytes = writer.toByteArray();
  
          File file = new File(
  "F:\\gitee-ckl\\all-simple-demo-in-work\\java-agent-premain-demo\\test-agent\\src\\main\\java\\org\\xunche\\app\\HelloXunChe.class");
          FileOutputStream fos = new FileOutputStream(file);
          fos.write(bytes);
          fos.close();
      }
  

  上面这样，出来的class文件，是破损的，格式不正确的，无法反编译。

• 3处，使用TimeClassVisitor作为writer的中间商，此时，顺序变成了：

  classreader --> TimeClassVisitor --> classWriter

• 4处，返回writer的字节码，给jvm；jvm使用该字节码，去redefine一个class出来

类转换器的具体实现

public static class TimeClassVisitor extends ClassVisitor {
        public TimeClassVisitor(ClassVisitor classVisitor) {
            super(Opcodes.ASM6, classVisitor);
        }
    	// 1
        @Override
        public MethodVisitor visitMethod(int methodAccess, String methodName, String methodDesc, String signature, String[] exceptions) {
            MethodVisitor methodVisitor = cv.visitMethod(methodAccess, methodName, methodDesc, signature, exceptions);
            // 2
            return new TimeAdviceAdapter(Opcodes.ASM6, methodVisitor, methodAccess, methodName, methodDesc);
        }
    }
}

• 1处，visitMethod方法，会返回一个MethodVisitor，ASM会拿着我们返回的methodVisitor，去访问当前这个方法
• 2处，new了一个适配器，TimeAdviceAdapter。

我们这里的TimeAdviceAdapter，主要是希望在方法执行前后做点事，类似于切面，所以继承了一个AdviceAdapter，这个AdviceAdaper，帮我们实现了MethodVisitor的全部方法，我们只需要覆写我们想要覆盖的方法即可。

比如，AdviceAdaper，因为继承了MethodVisitor，其visitCode方法，会在访问方法体时被回调：

@Override
  public void visitCode() {
    super.visitCode();
    // 1
    onMethodEnter();
  }
  //2
  protected void onMethodEnter() {}

• 1处，回调本来的onMethodEnter，是一个空实现，就是留给子类去重写的。
• 2处，可以看到，空实现。

所以，我们最终的TimeAdviceAdaper，代码如下：

public static class TimeAdviceAdapter extends AdviceAdapter {
        private String methodName;
        protected TimeAdviceAdapter(int api, MethodVisitor methodVisitor, int methodAccess, String methodName, String methodDesc) {
            super(api, methodVisitor, methodAccess, methodName, methodDesc);
            this.methodName = methodName;
        }
        @Override
        protected void onMethodEnter() {
            //在方法入口处植入
            if ("<init>".equals(methodName)|| "<clinit>".equals(methodName)) {
                return;
            }
            String className = getClass().getName();
            String s = className + "." + methodName;
            TimeHolder.start(s);
        }
        @Override
        protected void onMethodExit(int i) {
            //在方法出口植入
            if ("<init>".equals(methodName) || "<clinit>".equals(methodName)) {
                return;
            }
            String className = getClass().getName();
            String s = className + "." + methodName;
            long cost = TimeHolder.cost(s);
            System.out.println(s + ": " + cost);
        }
    }

这份代码看着可还行？可惜啊，是假的，是错误的！写asm这么简单的话，那我要从梦里笑醒。

为啥是假的，因为：真正的代码，是长下面这样的：

看到这里，是不是想溜了，这都啥玩意，看不懂啊，不过不要着急，办法总比困难多。

类转换器的真正实现方法

我们先装个idea插件，叫：asm-bytecode-outline。这个插件的作用，简而言之，就是帮你把java代码翻译成ASM的写法。在线装不了的，可以离线装：

asm-bytecode-outline

装好插件后，只要在我们的TimeAdviceAdapter类，点右键：

就会生成我们需要的ASM代码，然后拷贝：

什么时候拷贝结束呢？

基本上，这样就可以了。

填坑指南

作为一个常年掉坑的人，我在这个坑里也摸爬了整整一天。

大家可以看到，我们的java写的方法里，是这样的：

        @Override
        protected void onMethodEnter() {
            //在方法入口处植入
            if ("<init>".equals(methodName)|| "<clinit>".equals(methodName)) {
                return;
            }
            String className = getClass().getName();
            // 1.
            String s = className + "." + methodName;
            TimeHolder.start(s);
        }

• 1处，访问了本地field，methodName

所以，asm也帮我们贴心地生成了这样的语句：

mv.visitFieldInsn(Opcodes.GETFIELD, "org/xunche/agent/TimeAgentByJava$TimeAdviceAdapter", "methodName", "Ljava/lang/String;");

看起来就像是说，访问org/xunche/agent/TimeAgentByJava$TimeAdviceAdapter类的methodName字段。

但是，这是有问题的。因为，这段代码，最终aop切面会被插入到target：

public class HelloXunChe {
    private String methodName = "abc";
    public static void main(String[] args) throws InterruptedException {
        HelloXunChe helloXunChe = new HelloXunChe();
        helloXunChe.sayHi();
    }
    public void sayHi() throws InterruptedException {
        System.out.println("hi, xunche");
        sleep();
    }

    public void sleep() throws InterruptedException {
        Thread.sleep((long) (Math.random() * 200));
    }

}

我实话跟你说，这个target类里，压根访问不到org/xunche/agent/TimeAgentByJava$TimeAdviceAdapter类的methodName字段。

我是怎么发现这个问题的，之前一直报错，直到我在target后来加了这么一行：

public class HelloXunChe {
    private String methodName = "abc";
    ...
}

哎，没个大佬带我，真的难。

当然，我是通过这个确认了上述问题，最终解决的思路呢，就是：把你生成的class，反编译出来看看，看看是不是你想要的。

所以，我专门写了个main测试类，来测试改后的class是否符合预期。

public class SaveGeneratedClassWithOriginAgentTest {

    public static void main(String[] args) throws IOException {
        //1
        ClassReader reader = new ClassReader("org.xunche.app.HelloXunChe");
        ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
        reader.accept(new TimeAgentByJava.TimeClassVisitor(writer), ClassReader.EXPAND_FRAMES);
        byte[] bytes = writer.toByteArray();

        // 2
        File file = new File(
"F:\\ownprojects\\all-simple-demo-in-work\\java-agent-premain-demo\\test-agent\\src\\main\\java\\org\\xunche\\app\\HelloXunCheCopy2.class");
        FileOutputStream fos = new FileOutputStream(file);
        fos.write(bytes);
        fos.close();
    }
}

• 1处这段代码，就是模拟在classTransformer中的那段。
• 2处，将最终要返回给jvm的那段class字节码，写到一个文件里，然后我们就可以反编译，看看有问题没。

所以，上面那段asm，大家如果看：

初探 Java agent

会发现，访问methodname那句代码，是这么写的：

mv.visitLdcInsn(methodName);

这就是，相当于直接把methodName写死到最终的class里去了；最终的class就会是想要的样子：

public void sayHi() throws InterruptedException {
        //1
        TimeHolder.start(this.getClass().getName() + "." + "sayHi");
        System.out.println("hi, xunche");
        this.sleep();
        // 2
        String var1 = this.getClass().getName() + "." + "sayHi";
        System.out.println(var1 + ": " + TimeHolder.cost(var1));
    }

• 1/2处，直接把sayHi写死到target了，而不是此时再去访问field。

maven插件配置premain-class

插件中，配置Premain-Class

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.3.1</version>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                        </manifest>
                        <manifestEntries>
                            <Premain-Class>
                                org.xunche.agent.TimeAgent
                            </Premain-Class>
                        </manifestEntries>
                    </archive>
                </configuration>
            </plugin>

测试模块开发

测试模块，没啥开发的，就只有那个target那个类。

运行

最终我是这么运行的：

java -javaagent:agent.jar -classpath lib/*;java-agent-premain-demo.jar org/xunche/app/He
lloXunChe

这里指定了lib目录，主要是agent模块需要的jar包：

简单的运行效果如下：

loaded class: org/xunche/app/HelloXunChe
methodName = 0 <init>
methodName = 0 main
methodName = 0 sayHi
methodName = 0 sleep
hi, xunche
org.xunche.app.HelloXunChe.abc: 129
org.xunche.app.HelloXunChe.abc: 129

总结

ASM这个东西，想要不熟悉字节码就去像我上面这样傻瓜操作，坑还是比较多的，比较难趟。回头有空再介绍字节码吧。我也是半桶水，大家一起学习吧。

本节源码：

https://gitee.com/ckl111/all-simple-demo-in-work/tree/master/java-agent-premain-demo