背景

   為了掌握鏈路中方法的執行情況，通過鏈路分析可以知道程式碼邏輯實現。

技術

   顯然，為了需要跟蹤方法的執行情況，需要對方法進行aop攔截

   生成位元組碼技術的方式有兩種，一種類於javaproxy產生的位元組碼樣式。一種是在進入方法和限出方法時注入程式碼實現aop程式碼增強（2）。具體實現見asm實現AOP的兩篇文章

另外，對於程式碼的跟蹤，還需要一個數據結構來記錄一個鏈路的程式碼執行情況。

 具體實現

   靜態AOP基於java agent方式載入

java-javaagent:myagent.jar

   基中myagent.jar就是實現鏈路方法跟蹤的jar包。

   鏈路跟蹤類的實現

public class InvokeTree {
    static ThreadLocal<InvokeTree> localTree = new ThreadLocal<InvokeTree>();

    public static class InvokeNode {
        public InvokeNode(int deep) {
            this.deep = deep;
            this.invokeCount = 1;
        }
        public InvokeNode parentNode;
        public List<InvokeNode> childNodes;
        public String invokeMethod;
        public int deep;
        public int invokeCount
        public boolean equals(InvokeNode other) {
            if (other == null) {
                return false;
            }
            if (!invokeMethod.equals(other.invokeMethod)) {
                return false;
            }
            if (childNodes == null && other.childNodes == null) {
                return true;
            }
            if (childNodes == null || other.childNodes == null) {
                return false;
            }
            int size = childNodes.size();
            if (size != other.childNodes.size()) {
                return false;
            }

            for (int i = 0; i < size; i++) {
                InvokeNode x = childNodes.get(i);
                InvokeNode y = other.childNodes.get(i);
                if (!x.equals(y)) {
                    return false;
                }
            }
            return true;
        }
    }


    public static void start(String invokeMethod) {
        ClientConfig clientConfig = Doom.getClientConfig();
        if (!clientConfig.isOpenInvokeTreeAnalyse()) {
            return;
        }
        InvokeTree tree = new InvokeTree();
        InvokeNode rootNode = new InvokeNode(0);
        rootNode.invokeMethod = invokeMethod;
        tree.rootNode = rootNode;
        tree.curNode = rootNode;
        localTree.set(tree);
    }


    public static void exit() {
        InvokeTree tree = localTree.get();
        if (tree != null) {
            tree.curNode = tree.curNode.parentNode;
        }
    }

    public static void enter(String invokeMethod) {
        InvokeTree tree = localTree.get();
        if (tree == null) {
            return;
        }
        InvokeNode parentNode = tree.curNode;
        InvokeNode newNode = new InvokeNode(parentNode.deep + 1);
        newNode.invokeMethod = invokeMethod;
        newNode.parentNode = parentNode;
        if (parentNode.childNodes == null) {
            parentNode.childNodes = new ArrayList<InvokeNode>();
        }
        parentNode.childNodes.add(newNode);

        tree.curNode = newNode;

        //
 
重複呼叫整理
        cleanRepeatNode(parentNode);
    }


    public static void cleanRepeatNode(InvokeNode parentNode) {
        if (parentNode == null) {
            return;
        }
        int len = parentNode.childNodes.size();
        if (len <= 1) {
            cleanRepeatNode(parentNode.parentNode);
            return;
        }
        InvokeNode a = parentNode.childNodes.get(len - 2);
        InvokeNode b = parentNode.childNodes.get(len - 1);
        if (a.equals(b)) {
            parentNode.childNodes.remove(len - 1);
            a.invokeCount++;
        }
        cleanRepeatNode(parentNode.parentNode);
    }


    public static void clear() {
        localTree.set(null);
    }

    public InvokeNode rootNode;

    public InvokeNode curNode;

    public static InvokeTree getCurrentTree() {
        return localTree.get();
    }

    public String toString() {
        if (rootNode == null) {
            rootNode = curNode;
        }
        if (rootNode == null) {
            return "Empty Tree";
        } else {
            StringBuilder sb = new StringBuilder();
            buildShow(rootNode, "", sb, true);
            return sb.toString();
        }
    }

    private void buildShow(InvokeNode node, String space, StringBuilder sb, boolean isParentLastNode) {

        if (node != null) {

            sb.append(space);
            if (node.parentNode != null) {
                sb.append("|-");
            }
            sb.append(node.invokeMethod).append(node.invokeCount > 1 ? ("[
 
[email protected]" + node.invokeCount) + "]\n" : "\n");
            if (node.deep <= 8) {
                if (node.childNodes != null && node.childNodes.size() > 0) {

                    for (int i = 0; i < node.childNodes.size(); i++) {
                        InvokeNode chNode = node.childNodes.get(i);
                        buildShow(chNode, space + ((node.parentNode != null
                                        && isParentLastNode) ? "|   " : "    "),
                                sb, (i != node.childNodes.size() - 1));

                    }

                }
            }
        }
    }

    public static void main(String[] args) {
        ClientConfig clientConfig = new ClientConfig();
        clientConfig.setOpenInvokeTreeAnalyse(true);
        BootConfig.clientConfig = clientConfig;
        InvokeTree.start("test");
        InvokeTree.enter("hello");
        InvokeTree.enter("invoke1");
        InvokeTree.enter("invokeSub1");
        InvokeTree.exit();
        InvokeTree.enter("invokeSub2");
        InvokeTree.exit();
        InvokeTree.enter("invokeSub2");
        InvokeTree.exit();
        InvokeTree.exit();

        InvokeTree.enter("invoke2");
        InvokeTree.enter("invoke21");
        InvokeTree.exit();
        InvokeTree.exit();

        InvokeTree.enter("invoke2");
        InvokeTree.enter("invoke21");
        InvokeTree.exit();
        InvokeTree.exit();

        InvokeTree.exit();
        InvokeTree.exit();
        System.out.println(InvokeTree.getCurrentTree().toString());
    }
}

最後結合原生剛剛實現的AOP攔截

public class AutoMocker implements AsmMocker {

    private String name;

    @Override
    public String getClassName() {
        return name;
    }


    public AutoMocker(String name) {
        this.name = name;
    }

    @Override
    public List<String> getMethodPatterns() {

//攔截所有方法

   List<String> patterns = new ArrayList<String>();
        patterns.add("* *(*)");
        return patterns;
    }

    @Override
    public InvocationInterceptor getInterceptor() {
        return new InvocationInterceptor() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//獲取方法名
                String invokeMethod = InvokeBuilder.buildIdentity(method.getDeclaringClass(), method);
                InvokeTree.enter(invokeMethod);
                try {
                    return AsmInjector.invoke(proxy, method, args);
                } finally {
                    InvokeTree.exit();
                }
            }
        };
    }

    @Override
    public boolean isIgnorePrivate() {
        return true;
    }

    @Override
    public boolean isIgnoreProtected() {
        return false;
    }

    @Override
    public List<String> getExcludePatterns() {
        return null;
    }

}

//生成相關AOP程式碼並載入到記憶體中。

AutoMocker autoMocker = new AutoMocker(className);

//對所攔截的類生成AOP增強位元組碼
byte[] classBytes = AopUtils.buildMockedByeWithAsmMocker(autoMocker, classLoader, bytes);