Bytecode Enhancement for Method Call Interception and Performance Monitoring

When a system grows to a large scale, especially in To‑C internet businesses, a single service failure can quickly propagate across the whole micro‑service architecture. Using the 5‑why method, the article identifies the core problem: preventing a single system fault from affecting the entire system.

The proposed solution is to intercept target methods, record their execution time, and aggregate the data to locate performance bottlenecks. Instead of traditional AOP proxies, the implementation uses direct bytecode weaving (code injection) to avoid creating proxy classes and to achieve lower overhead.

Key components :

/** * Abstract plugin for code enhancement */ public abstract class EnhancedPlugin { public abstract ElementMatcher.Junction typeMatcher(); public abstract ElementMatcher.Junction methodMatcher(); public abstract Class interceptorClass(); }

/** * Interceptor that records method call information */ public class MethodCallInterceptor implements InstanceMethodInterceptor { private static final ThreadLocal methodEnterStackOrderThreadLocal = new TransmittableThreadLocal () { @Override protected AtomicInteger initialValue() { return new AtomicInteger(0); } }; private static final ThreadLocal > methodStackThreadLocal = new ThreadLocal >() { @Override protected Deque initialValue() { return new ArrayDeque<>(); } }; private static final ThreadLocal > methodCallThreadLocal = new ThreadLocal >() { @Override protected ArrayList initialValue() { return new ArrayList<>(); } }; // beforeMethod and afterMethod implementations omitted for brevity }

The interceptor uses three ThreadLocal variables to store the call stack, the order of entry, and the final list of MethodCall objects. A normal ThreadLocal is used for the stack to avoid the sharing behavior of TransmittableThreadLocal that would merge parent‑child thread data.

Testing scenarios :

1. Normal methods – a sample class MethodCallExample defines several synchronous methods. After enabling the enhancer, the output shows each method’s execution time and call hierarchy.

2. Asynchronous methods – when a method spawns a new Thread , only the Thread.start() call is measured; the actual runnable body is not intercepted unless lambda weaving is enabled.

3. Lambda expressions – by turning on the ByteBuddy lambda strategy, anonymous methods generated from lambdas become interceptable. Otherwise, developers can replace the lambda with a named method.

4. TransmittableThreadLocal usage – switching the stack storage to TransmittableThreadLocal causes parent and child thread stacks to merge, which is undesirable for accurate call‑stack clearing.

To link calls across threads, a Tracer interface is introduced to provide a traceId . The tracer can be set in the global Configuration and used by the interceptor to correlate parent‑child executions.

Performance benchmark – the MethodCallInterceptorBench class uses JMH to measure the overhead of beforeMethod . Results show an average cost of ~0.592 ms per call and a throughput of ~83 calls per millisecond.

Usage :

Add the Maven dependency:

<dependency> <groupId>com.shizhuang.duapp</groupId> <artifactId>commodity-common-enhancer</artifactId> <version>${commodity-common-enhancer-version}</version> </dependency>

Start the enhancer in the application entry point:

public class CommodityAdminApplication { public static void main(String[] args) { SpringApplication.run(CommodityAdminApplication.class, args); Enhancer enhancer = Enhancer.Default.INSTANCE; enhancer.enhance(null); // or pass a custom Configuration } }

Custom plugins can be created by extending EnhancedPlugin and providing a matching Interceptor . The interceptor implements beforeMethod and afterMethod to perform any business logic, such as filtering by cost time or toggling collection via a MethodCallSwitcher .

In summary, the article presents a lightweight, generic bytecode‑enhancement framework that enables fine‑grained performance diagnostics for Java services, supports synchronous and asynchronous scenarios, offers extensibility through custom plugins and interceptors, and can be integrated with tracing systems and monitoring dashboards.