摘要：在里面，最大的改變使運行時的成為可能。缺省情況下，將會在方法中計算這些，通過在加載這兩個類進入虛擬機時，使用反射來計算。通過重寫方法，更正獲取的方式，改成使用指定的方式進行。

Grays Anatomy源碼淺析

標簽（空格分隔）：JAVA JVM 問題排查

在知乎上看到一個問題,被R大推薦了這個線上排查的工具,就下來用了用,感覺還不錯,知道是Java寫的后,就行看看源碼,相關知識比較欠缺,前后看了一個月左右,才知其大概原理,記錄下來分給大家.

讀源碼前,需要掌握幾點知識,不然硬看是看不懂的.

利用 Java 代碼，即 java.lang.instrument 做動態 Instrumentation 是 Java SE 5 的新特性，它把 Java 的 instrument 功能從本地代碼中解放出來，使之可以用 Java 代碼的方式解決問題。使用 Instrumentation，開發者可以構建一個獨立于應用程序的代理程序（Agent），用來監測和協助運行在 JVM 上的程序，甚至能夠替換和修改某些類的定義。有了這樣的功能，開發者就可以實現更為靈活的運行時虛擬機監控和 Java 類操作了，這樣的特性實際上提供了一種虛擬機級別支持的 AOP 實現方式，使得開發者無需對 JDK 做任何升級和改動，就可以實現某些 AOP 的功能了。

實現方法:

編寫一個 Java 類，包含如下兩個方法當中的任何一個,來指定哪些class需要做AOP

public static void premain(String agentArgs, Instrumentation inst); 
public static void premain(String agentArgs); 

將這個 Java 類打包成一個 jar 文件，并在其中的 manifest 屬性當中加入” Premain-Class”來指定步驟 2 當中編寫的那個帶有 premain 的 Java 類。（可能還需要指定其他屬性以開啟更多功能）

Manifest-Version: 1.0 
Premain-Class: Premain

用如下方式運行帶有 Instrumentation 的 Java 程序：

java -javaagent:jar 文件的位置 [= 傳入 premain 的參數 ]

在 Java SE 6 里面，instrumentation 包被賦予了更強大的功能：啟動后的 instrument、本地代碼（native code）instrument，以及動態改變 classpath 等等。這些改變，意味著 Java 具有了更強的動態控制、解釋能力，它使得 Java 語言變得更加靈活多變。
在 Java SE6 里面，最大的改變使運行時的 Instrumentation 成為可能。在 Java SE 5 中，Instrument 要求在運行前利用命令行參數或者系統參數來設置代理類，在實際的運行之中，虛擬機在初始化之時（在絕大多數的 Java 類庫被載入之前），instrumentation 的設置已經啟動，并在虛擬機中設置了回調函數，檢測特定類的加載情況，并完成實際工作。但是在實際的很多的情況下，我們沒有辦法在虛擬機啟動之時就為其設定代理，這樣實際上限制了 instrument 的應用。而 Java SE 6 的新特性改變了這種情況，通過 Java Tool API 中的 attach 方式，我們可以很方便地在運行過程中動態地設置加載代理類，以達到 instrumentation 的目的。
另外，對 native 的 Instrumentation 也是 Java SE 6 的一個嶄新的功能，這使以前無法完成的功能 —— 對 native 接口的 instrumentation 可以在 Java SE 6 中，通過一個或者一系列的 prefix 添加而得以完成。
最后，Java SE 6 里的 Instrumentation 也增加了動態添加 class path 的功能。所有這些新的功能，都使得 instrument 包的功能更加豐富，從而使 Java 語言本身更加強大。

實現方法:

編寫一個 Java 類，包含如下兩個方法當中的任何一個,來指定哪些class需要做AOP

public static void agentmain (String agentArgs, Instrumentation inst); 
public static void agentmain (String agentArgs);    

將這個 Java 類打包成一個 jar 文件，并在其中的 manifest 屬性當中加入” Agent-Class”來指定步驟 2 當中編寫的那個帶有 agentmain 的 Java 類。（可能還需要指定其他屬性以開啟更多功能）

Manifest-Version: 1.0 
Agent-Class: AgentMain

用如下方式運行帶有 Instrumentation 的 Java 程序：

java -javaagent:jar 文件的位置 [= 傳入 premain 的參數 ]

這里只是簡要概述下,具體請點標題鏈接

ASM是一種字節碼增強技術,即通過修改字節碼來實現修改類的行為的功能.沒有找到講ASM比較好的博客,還是官方文檔明晰透徹還會穿插著講講JVM的方法調用模型,建議閱讀之,這里就舉個ASM的小例子來說明它的使用.

類C如下所示

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

通過ASM動態修改其字節碼將其方法加上計算時間調用的功能

 public class C {
        public static long timer;
        public void m() throws Exception {
          timer -= System.currentTimeMillis();
          Thread.sleep(100);
          timer += System.currentTimeMillis();
} }

ASM方法編寫如下,詳情請見ASM官方文檔Core API,其實若不考慮性能影響的話,Tree API更符合Java程序員的思維

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("")) {
            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();
    }

    public class AddTimerMethodAdapter extends MethodVisitor {
        public AddTimerMethodAdapter(org.objectweb.asm.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);
        }
    }

    public static void main(String[] args) throws IOException {
        ClassReader cr = new ClassReader("com.asm.temp.C");
        ClassWriter cw = new ClassWriter(cr,0);
        TraceClassVisitor classVisitor = new TraceClassVisitor(cw,new PrintWriter(System.out));
        AddTimerAdapter addTimerAdapter = new AddTimerAdapter(classVisitor);
        cr.accept(addTimerAdapter,0);
        System.out.println(cw.toByteArray());
    }

}

通過輸出的字節碼,可以看出其已加上了計算調用的功能

GETSTATIC C.timer : J
INVOKESTATIC java/lang/System.currentTimeMillis()J LSUB
PUTSTATIC C.timer : J
LDC 100
INVOKESTATIC java/lang/Thread.sleep(J)V
GETSTATIC C.timer : J
INVOKESTATIC java/lang/System.currentTimeMillis()J LADD
PUTSTATIC C.timer : J
RETURN
MAXSTACK = 4
MAXLOCALS = 1

Greys要實現的功能,是動態的監測JVM方法的執行.很自然的就想到了它會去實現Instrumentation的preMain和agentMain.AgentLauncher實現了preMain和agentMain方法,其都調用了main方法,其主要功能透過反射實例化一個GaServer.這個Server主要實現的就是接受命令,處理命令,返回響應.

public class AgentLauncher {


    public static void premain(String args, Instrumentation inst) {
        main(args, inst);
    }

    public static void agentmain(String args, Instrumentation inst) {
        main(args, inst);
    }
  private static synchronized void main(final String args, final Instrumentation inst) {
        try {

            // 傳遞的args參數分兩個部分:agentJar路徑和agentArgs
            // 分別是Agent的JAR包路徑和期望傳遞到服務端的參數
            final int index = args.indexOf(";");
            final String agentJar = args.substring(0, index);
            final String agentArgs = args.substring(index, args.length());

            // 將Spy添加到BootstrapClassLoader
            inst.appendToBootstrapClassLoaderSearch(
                    new JarFile(AgentLauncher.class.getProtectionDomain().getCodeSource().getLocation().getFile())
            );

            // 構造自定義的類加載器，盡量減少Greys對現有工程的侵蝕
            final ClassLoader agentLoader = loadOrDefineClassLoader(agentJar);

            // Configure類定義
            final Class classOfConfigure = agentLoader.loadClass("com.github.ompc.greys.core.Configure");

            // GaServer類定義
            final Class classOfGaServer = agentLoader.loadClass("com.github.ompc.greys.core.server.GaServer");

            // 反序列化成Configure類實例
            final Object objectOfConfigure = classOfConfigure.getMethod("toConfigure", String.class)
                    .invoke(null, agentArgs);

            // JavaPid
            final int javaPid = (Integer) classOfConfigure.getMethod("getJavaPid").invoke(objectOfConfigure);

            // 獲取GaServer單例
            final Object objectOfGaServer = classOfGaServer
                    .getMethod("getInstance", int.class, Instrumentation.class)
                    .invoke(null, javaPid, inst);

            // gaServer.isBind()
            final boolean isBind = (Boolean) classOfGaServer.getMethod("isBind").invoke(objectOfGaServer);

            if (!isBind) {
                try {
                    classOfGaServer.getMethod("bind", classOfConfigure).invoke(objectOfGaServer, objectOfConfigure);
                } catch (Throwable t) {
                    classOfGaServer.getMethod("destroy").invoke(objectOfGaServer);
                    throw t;
                }

            }

        } catch (Throwable t) {
            t.printStackTrace();
        }

    }

GaServer的bind方法為啟動服務,啟動后activeSelectorDaemon方法啟動一個Daemon線程負責命令的處理,其中doRead是主要邏輯的實現,其中又委托給了CommandHandler的executeCommand方法解析輸入行并執行命令.

public class GaServer {
/**
     * 啟動Greys服務端
     *
     * @param configure 配置信息
     * @throws IOException 服務器啟動失敗
     */
    public void bind(Configure configure) throws IOException {
        if (!isBindRef.compareAndSet(false, true)) {
            throw new IllegalStateException("already bind");
        }

        try {

            serverSocketChannel = ServerSocketChannel.open();
            selector = Selector.open();

            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.socket().setSoTimeout(configure.getConnectTimeout());
            serverSocketChannel.socket().setReuseAddress(true);
            serverSocketChannel.register(selector, OP_ACCEPT);

            // 服務器掛載端口
            serverSocketChannel.socket().bind(getInetSocketAddress(configure.getTargetIp(), configure.getTargetPort()), 24);
            logger.info("ga-server listening on network={};port={};timeout={};", configure.getTargetIp(),
                    configure.getTargetPort(),
                    configure.getConnectTimeout());

            activeSelectorDaemon(selector, configure);

        } catch (IOException e) {
            unbind();
            throw e;
        }

    }
    
    private void activeSelectorDaemon(final Selector selector, final Configure configure) {

        final ByteBuffer byteBuffer = ByteBuffer.allocate(BUFFER_SIZE);

        final Thread gaServerSelectorDaemon = new Thread("ga-selector-daemon") {
            @Override
            public void run() {

                while (!isInterrupted()
                        && isBind()) {

                    try {

                        while (selector.isOpen()
                                && selector.select() > 0) {
                            final Iterator it = selector.selectedKeys().iterator();
                            while (it.hasNext()) {
                                final SelectionKey key = it.next();
                                it.remove();

                                // do ssc accept
                                if (key.isValid() && key.isAcceptable()) {
                                    doAccept(key, selector, configure);
                                }

                                // do sc read
                                if (key.isValid() && key.isReadable()) {
                                    doRead(byteBuffer, key);
                                }

                            }
                        }

                    } catch (IOException e) {
                        logger.warn("selector failed.", e);
                    } catch (ClosedSelectorException e) {
                        logger.debug("selector closed.", e);
                    }


                }

            }
        };
        gaServerSelectorDaemon.setDaemon(true);
        gaServerSelectorDaemon.start();
    }


private void doRead(final ByteBuffer byteBuffer, SelectionKey key) {
        final GaAttachment attachment = (GaAttachment) key.attachment();
        final SocketChannel socketChannel = (SocketChannel) key.channel();
        final Session session = attachment.getSession();
        try {

            // 若讀到EOF，則說明SocketChannel已經關閉
            if (EOF == socketChannel.read(byteBuffer)) {
                logger.info("client={}@session[{}] was closed.", socketChannel, session.getSessionId());
                // closeSocketChannel(key, socketChannel);
                session.destroy();
                if(session.isLocked()) {
                    session.unLock();
                }
                return;
            }

            // decode for line
            byteBuffer.flip();
            while (byteBuffer.hasRemaining()) {
                switch (attachment.getLineDecodeState()) {
                    case READ_CHAR: {
                        final byte data = byteBuffer.get();

                        if ("
" == data) {
                            attachment.setLineDecodeState(READ_EOL);
                        }

                        // 遇到中止命令(CTRL_D)，則標記會話為不可寫，讓后臺任務停下
                        else if (CTRL_D == data
                                || CTRL_X == data) {
                            session.unLock();
                            break;
                        }

                        // 普通byte則持續放入到緩存中
                        else {
                            if ("
" != data) {
                                attachment.put(data);
                            }
                            break;
                        }

                    }

                    case READ_EOL: {
                        final String line = attachment.clearAndGetLine(session.getCharset());

                        executorService.execute(new Runnable() {
                            @Override
                            public void run() {

                                // 會話只有未鎖定的時候才能響應命令
                                if (session.tryLock()) {
                                    try {

                                        // 命令執行
                                        commandHandler.executeCommand(line, session);

                                        // 命令結束之后需要傳輸EOT告訴client命令傳輸已經完結，可以展示提示符
                                        socketChannel.write(ByteBuffer.wrap(new byte[]{EOT}));

                                    } catch (IOException e) {
                                        logger.info("network communicate failed, session[{}] will be close.",
                                                session.getSessionId());
                                        session.destroy();
                                    } finally {
                                        session.unLock();
                                    }
                                } else {
                                    logger.info("session[{}] was locked, ignore this command.",
                                            session.getSessionId());
                                }
                            }
                        });

                        attachment.setLineDecodeState(READ_CHAR);
                        break;
                    }
                }
            }//while for line decode

            byteBuffer.clear();

        }

        // 處理
        catch (IOException e) {
            logger.warn("read/write data failed, session[{}] will be close.", session.getSessionId(), e);
            closeSocketChannel(key, socketChannel);
            session.destroy();
        }
    }
}

接下來看看CommandHandler接口的默認實現DefaultCommandHandler,其executeCommand方法的主邏輯由excute實現,我們最關心的類增強部分是通過EnhancerAffect實現的.

public class DefaultCommandHandler implements CommandHandler {

    @Override
    public void executeCommand(final String line, final Session session) throws IOException {
            final Command command = Commands.getInstance().newCommand(line);
            execute(session, command);
    }
    
     /*
     * 執行命令
     */
    private void execute(final Session session, final Command command) throws GaExecuteException, IOException {
            

            // 需要做類增強的動作
            else if (action instanceof GetEnhancerAction) {

                affect = new EnhancerAffect();

                // 執行命令動作 & 獲取增強器
                final Command.GetEnhancer getEnhancer = ((GetEnhancerAction) action).action(session, inst, printer);
                final int lock = session.getLock();
                final AdviceListener listener = getEnhancer.getAdviceListener();
                final EnhancerAffect enhancerAffect = Enhancer.enhance(
                        inst,
                        lock,
                        listener instanceof InvokeTraceable,
                        getEnhancer.getPointCut()
                );
            }
    }
}

其增強其是AdviceListener的實現類,AdviceListener由before,afterReturning等圍繞著方法執行階段的方法組成,按道理這時候就該是ASM登場,修改類行為的時刻了.

     /**
     * 前置通知
     *
     * @param loader     類加載器
     * @param className  類名
     * @param methodName 方法名
     * @param methodDesc 方法描述
     * @param target     目標類實例
     *                   若目標為靜態方法,則為null
     * @param args       參數列表
     * @throws Throwable 通知過程出錯
     */
    void before(
            ClassLoader loader, String className, String methodName, String methodDesc,
            Object target, Object[] args) throws Throwable;

    /**
     * 返回通知
     *
     * @param loader       類加載器
     * @param className    類名
     * @param methodName   方法名
     * @param methodDesc   方法描述
     * @param target       目標類實例
     *                     若目標為靜態方法,則為null
     * @param args         參數列表
     * @param returnObject 返回結果
     *                     若為無返回值方法(void),則為null
     * @throws Throwable 通知過程出錯
     */
    void afterReturning(
            ClassLoader loader, String className, String methodName, String methodDesc,
            Object target, Object[] args,
            Object returnObject) throws Throwable;              

接下來看起增強方法,可見真正的增強class是Enhancer

    public static synchronized EnhancerAffect enhance(
            final Instrumentation inst,
            final int adviceId,
            final boolean isTracing,
            final PointCut pointCut) throws UnmodifiableClassException {

        final EnhancerAffect affect = new EnhancerAffect();
        final Map, Matcher> enhanceMap = toEnhanceMap(pointCut);

        // 構建增強器
        final Enhancer enhancer = new Enhancer(adviceId, isTracing, enhanceMap, affect);
        try {
            inst.addTransformer(enhancer, true);

            // 批量增強
            if (GlobalOptions.isBatchReTransform) {
                final int size = enhanceMap.size();
                final Class[] classArray = new Class[size];
                arraycopy(enhanceMap.keySet().toArray(), 0, classArray, 0, size);
                if (classArray.length > 0) {
                    inst.retransformClasses(classArray);
                }
            }


            // for each 增強
            else {
                for (Class clazz : enhanceMap.keySet()) {
                    try {
                        inst.retransformClasses(clazz);
                    } catch (Throwable t) {
                        logger.warn("reTransform {} failed.", clazz, t);
                        if (t instanceof UnmodifiableClassException) {
                            throw (UnmodifiableClassException) t;
                        } else if (t instanceof RuntimeException) {
                            throw (RuntimeException) t;
                        } else {
                            throw new RuntimeException(t);
                        }
                    }
                }
            }
        } finally {
            inst.removeTransformer(enhancer);
        }
        return affect;
    }

Enhancer實現了Java Instrumentation的接口ClassFileTransformer,來看其核心方法transform

    @Override
    public byte[] transform(
            final ClassLoader inClassLoader,
            final String className,
            final Class classBeingRedefined,
            final ProtectionDomain protectionDomain,
            final byte[] classfileBuffer) throws IllegalClassFormatException {

        // 過濾掉不在增強集合范圍內的類
        if (!enhanceMap.containsKey(classBeingRedefined)) {
            return null;
        }

        final ClassReader cr;

        // 首先先檢查是否在緩存中存在Class字節碼
        // 因為要支持多人協作,存在多人同時增強的情況
        final byte[] byteOfClassInCache = classBytesCache.get(classBeingRedefined);
        if (null != byteOfClassInCache) {
            cr = new ClassReader(byteOfClassInCache);
        }

        // 如果沒有命中緩存,則從原始字節碼開始增強
        else {
            cr = new ClassReader(classfileBuffer);
        }

        // 獲取這個類所對應的asm方法匹配
        final Matcher asmMethodMatcher = enhanceMap.get(classBeingRedefined);

        // 字節碼增強
        final ClassWriter cw = new ClassWriter(cr, COMPUTE_FRAMES | COMPUTE_MAXS) {

            /*
             * 注意，為了自動計算幀的大小，有時必須計算兩個類共同的父類。
             * 缺省情況下，ClassWriter將會在getCommonSuperClass方法中計算這些，通過在加載這兩個類進入虛擬機時，使用反射API來計算。
             * 但是，如果你將要生成的幾個類相互之間引用，這將會帶來問題，因為引用的類可能還不存在。
             * 在這種情況下，你可以重寫getCommonSuperClass方法來解決這個問題。
             *
             * 通過重寫 getCommonSuperClass() 方法，更正獲取ClassLoader的方式，改成使用指定ClassLoader的方式進行。
             * 規避了原有代碼采用Object.class.getClassLoader()的方式
             */
            @Override
            protected String getCommonSuperClass(String type1, String type2) {
                Class c, d;
                try {
                    c = Class.forName(type1.replace("/", "."), false, inClassLoader);
                    d = Class.forName(type2.replace("/", "."), false, inClassLoader);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                if (c.isAssignableFrom(d)) {
                    return type1;
                }
                if (d.isAssignableFrom(c)) {
                    return type2;
                }
                if (c.isInterface() || d.isInterface()) {
                    return "java/lang/Object";
                } else {
                    do {
                        c = c.getSuperclass();
                    } while (!c.isAssignableFrom(d));
                    return c.getName().replace(".", "/");
                }
            }

        };

        try {

            // 生成增強字節碼
            cr.accept(new AdviceWeaver(adviceId, isTracing, cr.getClassName(), asmMethodMatcher, affect, cw), EXPAND_FRAMES);
            final byte[] enhanceClassByteArray = cw.toByteArray();

            // 生成成功,推入緩存
            classBytesCache.put(classBeingRedefined, enhanceClassByteArray);

            // dump the class
            dumpClassIfNecessary(className, enhanceClassByteArray, affect);

            // 成功計數
            affect.cCnt(1);

            // 排遣間諜
            try {
                spy(inClassLoader);
            } catch (Throwable t) {
                logger.warn("print spy failed. classname={};loader={};", className, inClassLoader, t);
                throw t;
            }

            return enhanceClassByteArray;
        } catch (Throwable t) {
            logger.warn("transform loader[{}]:class[{}] failed.", inClassLoader, className, t);
        }

        return null;
    }

其最主要的邏輯應該是派遣間諜了

     /*
     * 派遣間諜混入對方的classLoader中
     */
    private void spy(final ClassLoader targetClassLoader)
            throws IOException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {

        // 如果對方是bootstrap就算了
        if (null == targetClassLoader) {
            return;
        }


        // Enhancer類只可能從greysClassLoader中加載
        // 所以找他要ClassLoader是靠譜的
        final ClassLoader greysClassLoader = Enhancer.class.getClassLoader();

        final String spyClassName = GaStringUtils.SPY_CLASSNAME;

        // 從GreysClassLoader中加載Spy
        final Class spyClassFromGreysClassLoader = loadSpyClassFromGreysClassLoader(greysClassLoader, spyClassName);
        if (null == spyClassFromGreysClassLoader) {
            return;
        }

        // 從目標ClassLoader中嘗試加載或定義ClassLoader
        Class spyClassFromTargetClassLoader = null;
        try {

            // 去目標類加載器中找下是否已經存在間諜
            // 如果間諜已經存在就算了
            spyClassFromTargetClassLoader = targetClassLoader.loadClass(spyClassName);
            logger.info("Spy already in targetClassLoader : " + targetClassLoader);

        }

        // 看來間諜不存在啊
        catch (ClassNotFoundException cnfe) {

            try {// 在目標類加載起中混入間諜
                spyClassFromTargetClassLoader = defineClass(
                        targetClassLoader,
                        spyClassName,
                        toByteArray(Enhancer.class.getResourceAsStream("/" + spyClassName.replace(".", "/") + ".class"))
                );
            } catch (InvocationTargetException ite) {
                if (ite.getCause() instanceof java.lang.LinkageError) {
                    // CloudEngine 由于 loadClass 不到,會導致 java.lang.LinkageError: loader (instance of  com/alipay/cloudengine/extensions/equinox/KernelAceClassLoader): attempted  duplicate class definition for name: "com/taobao/arthas/core/advisor/Spy"
                    // 這里嘗試忽略
                    logger.debug("resolve #112 issues", ite);
                } else {
                    throw ite;
                }
            }

        }


        // 無論從哪里取到spyClass，都需要重新初始化一次
        // 用以兼容重新加載的場景
        // 當然，這樣做會給渲染的過程帶來一定的性能開銷，不過能簡化編碼復雜度
        finally {

            if (null != spyClassFromTargetClassLoader) {
                // 初始化間諜
                invokeStaticMethod(
                        spyClassFromTargetClassLoader,
                        "init",
                        greysClassLoader,
                        getField(spyClassFromGreysClassLoader, "ON_BEFORE_METHOD").get(null),
                        getField(spyClassFromGreysClassLoader, "ON_RETURN_METHOD").get(null),
                        getField(spyClassFromGreysClassLoader, "ON_THROWS_METHOD").get(null),
                        getField(spyClassFromGreysClassLoader, "BEFORE_INVOKING_METHOD").get(null),
                        getField(spyClassFromGreysClassLoader, "AFTER_INVOKING_METHOD").get(null),
                        getField(spyClassFromGreysClassLoader, "THROW_INVOKING_METHOD").get(null)
                );
            }

        }

    }

接下來看Spy的實現,發現其沒什么特別的啊,怎么實現織入呢,期間在這迷了很久

    public class Spy {
    // -- 各種Advice的鉤子引用 --
    public static volatile Method ON_BEFORE_METHOD;
    public static volatile Method ON_RETURN_METHOD;
    public static volatile Method ON_THROWS_METHOD;
    public static volatile Method BEFORE_INVOKING_METHOD;
    public static volatile Method AFTER_INVOKING_METHOD;
    public static volatile Method THROW_INVOKING_METHOD;

    /**
     * 代理重設方法
     */
    public static volatile Method AGENT_RESET_METHOD;

    /*
     * 用于普通的間諜初始化
     */
    public static void init(
            @Deprecated
            ClassLoader classLoader,
            Method onBeforeMethod,
            Method onReturnMethod,
            Method onThrowsMethod,
            Method beforeInvokingMethod,
            Method afterInvokingMethod,
            Method throwInvokingMethod) {
        ON_BEFORE_METHOD = onBeforeMethod;
        ON_RETURN_METHOD = onReturnMethod;
        ON_THROWS_METHOD = onThrowsMethod;
        BEFORE_INVOKING_METHOD = beforeInvokingMethod;
        AFTER_INVOKING_METHOD = afterInvokingMethod;
        THROW_INVOKING_METHOD = throwInvokingMethod;
    }

    /*
     * 用于啟動線程初始化
     */
    public static void initForAgentLauncher(
            @Deprecated
            ClassLoader classLoader,
            Method onBeforeMethod,
            Method onReturnMethod,
            Method onThrowsMethod,
            Method beforeInvokingMethod,
            Method afterInvokingMethod,
            Method throwInvokingMethod,
            Method agentResetMethod) {
        ON_BEFORE_METHOD = onBeforeMethod;
        ON_RETURN_METHOD = onReturnMethod;
        ON_THROWS_METHOD = onThrowsMethod;
        BEFORE_INVOKING_METHOD = beforeInvokingMethod;
        AFTER_INVOKING_METHOD = afterInvokingMethod;
        THROW_INVOKING_METHOD = throwInvokingMethod;
        AGENT_RESET_METHOD = agentResetMethod;
    }


    public static void clean() {
        ON_BEFORE_METHOD = null;
        ON_RETURN_METHOD = null;
        ON_THROWS_METHOD = null;
        BEFORE_INVOKING_METHOD = null;
        AFTER_INVOKING_METHOD = null;
        THROW_INVOKING_METHOD = null;
        AGENT_RESET_METHOD = null;
    }

}

迷久了,偶爾查看其方法的調用,發現奧妙,其真正值得織入邏輯原來是在AdviceWeaver的相關方法內

   private static ClassLoader loadOrDefineClassLoader(String agentJar) throws Throwable {

        final ClassLoader classLoader;

        // 如果已經被啟動則返回之前啟動的classloader
        if (null != greysClassLoader) {
            classLoader = greysClassLoader;
        }

        // 如果未啟動則重新加載
        else {
            classLoader = new AgentClassLoader(agentJar);

            // 獲取各種Hook
            final Class adviceWeaverClass = classLoader.loadClass("com.github.ompc.greys.core.advisor.AdviceWeaver");

            // 初始化全局間諜
            Spy.initForAgentLauncher(
                    classLoader,
                    adviceWeaverClass.getMethod("methodOnBegin",
                            int.class,
                            ClassLoader.class,
                            String.class,
                            String.class,
                            String.class,
                            Object.class,
                            Object[].class),
                    adviceWeaverClass.getMethod("methodOnReturnEnd",
                            Object.class,
                            int.class),
                    adviceWeaverClass.getMethod("methodOnThrowingEnd",
                            Throwable.class,
                            int.class),
                    adviceWeaverClass.getMethod("methodOnInvokeBeforeTracing",
                            int.class,
                            Integer.class,
                            String.class,
                            String.class,
                            String.class),
                    adviceWeaverClass.getMethod("methodOnInvokeAfterTracing",
                            int.class,
                            Integer.class,
                            String.class,
                            String.class,
                            String.class),
                    adviceWeaverClass.getMethod("methodOnInvokeThrowTracing",
                            int.class,
                            Integer.class,
                            String.class,
                            String.class,
                            String.class,
                            String.class),
                    AgentLauncher.class.getMethod("resetGreysClassLoader")
            );
        }

        return greysClassLoader = classLoader;
    }

抽出一個方法來看,其最終還是委托listner的before來實現的,MonitorCommand只是實現一個invokeCost.Begin.可是沒有字節碼增強啊,怎么能動態實現呢

     /**
     * 方法開始

     * 用于編織通知器,外部不會直接調用
     *
     * @param loader     類加載器
     * @param adviceId   通知ID
     * @param className  類名
     * @param methodName 方法名
     * @param methodDesc 方法描述
     * @param target     返回結果
     *                   若為無返回值方法(void),則為null
     * @param args       參數列表
     */
    public static void methodOnBegin(
            int adviceId,
            ClassLoader loader, String className, String methodName, String methodDesc,
            Object target, Object[] args) {

        if (!advices.containsKey(adviceId)) {
            return;
        }

        if (isSelfCallRef.get()) {
            return;
        } else {
            isSelfCallRef.set(true);
        }

        try {
            // 構建執行幀棧,保護當前的執行現場
            final GaStack