如果被拦截的方法调用另一个被拦截的方法，会发生什么

Question

使用bytepal拦截类Foo，有两种方法A、B

在A方法中，B方法被调用。如果我们在intercetpor类栏中同时删除A和B到C方法，它们在第一行调用callable#call

会发生什么？这些方法的执行顺序是什么？

Answer 1

你当然可以尝试一下，但会发生的是，内部调用将再次被拦截。方法不知道谁在调用它们。为了避免这种情况，可以通过StackWalker或使用异常生成堆栈跟踪来发现调用方。

Answer 2

package org.wxt.xtools.agents;

import static net.bytebuddy.matcher.ElementMatchers.isAbstract;
import static net.bytebuddy.matcher.ElementMatchers.named;
import static net.bytebuddy.matcher.ElementMatchers.namedOneOf;
import static net.bytebuddy.matcher.ElementMatchers.not;

import java.io.IOException;
import java.lang.instrument.Instrumentation;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;

import net.bytebuddy.agent.ByteBuddyAgent;
import net.bytebuddy.agent.builder.AgentBuilder;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.dynamic.DynamicType;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.implementation.bind.annotation.Origin;
import net.bytebuddy.implementation.bind.annotation.RuntimeType;
import net.bytebuddy.implementation.bind.annotation.SuperCall;
import net.bytebuddy.utility.JavaModule;

class Foo {
    public void methodA() {
        System.out.println("method A");
        methodB();
    }
    
    public void methodB() {
        System.out.println("method B");
    }
}

class Bar {
    @RuntimeType
    public static void interceptor(@Origin Class<?> clazz, @Origin Method method, @SuperCall Callable<?> callable,
            @net.bytebuddy.implementation.bind.annotation.This Object inst) throws Exception {
        callable.call();
        System.out.println("intercepting " + method.getName());
    }
}

public class Test {
    
    public static void premain(String agentArgs, Instrumentation inst) throws IOException {
        AgentBuilder.Transformer methodsTransformer = new AgentBuilder.Transformer() {
            @Override
            public DynamicType.Builder<?> transform(DynamicType.Builder<?> builder, TypeDescription typeDescription,
                    ClassLoader classLoader, JavaModule javaModule) {
                return builder.method(namedOneOf("methodA", "methodB").and(not(isAbstract())))
                        .intercept(MethodDelegation.to(Bar.class));
            }
        };

        AgentBuilder.Listener listener = new AgentBuilder.Listener.WithErrorsOnly(
                new AgentBuilder.Listener.StreamWriting(System.out));

        new AgentBuilder.Default().type(named("org.wxt.xtools.agents.Foo")).transform(methodsTransformer)
                .with(listener).installOn(inst);
    }

    public static void main(String[] args) throws IOException {
        premain(null, ByteBuddyAgent.install());
        new Foo().methodA();
    }

}

结果

method A
method B
intercepting methodB
intercepting methodA