Detecting Invocations of Deprecated Methods in Java with JFR Events

In Java, deprecated methods are those that are no longer recommended for use. They might be removed in future versions of the Java API. Detecting when these deprecated methods are invoked can be crucial for maintaining code quality and preparing for future changes. Java Flight Recorder (JFR) is a powerful tool that can be used to monitor and analyze the behavior of Java applications. In this blog, we'll explore how to use JFR events to detect invocations of deprecated methods.

Table of Contents#

What is JFR?#

Java Flight Recorder (JFR) is a profiling and monitoring tool built into the Java Virtual Machine (JVM). It allows developers to collect detailed runtime data about a Java application, such as method invocations, thread states, and memory allocations. This data can then be analyzed to identify performance bottlenecks, bugs, and other issues.

Deprecated Methods in Java#

Deprecated methods are marked with the @Deprecated annotation. This annotation serves as a warning to developers that the method should no longer be used. There are several reasons why a method might be deprecated:

  • It has been replaced by a more efficient or better-designed method.
  • It has known bugs or security vulnerabilities.
  • It is no longer part of the intended API design.

When a deprecated method is invoked, the JVM can generate a warning message. However, in a large application, it can be difficult to track down all these warnings. This is where JFR comes in handy.

Using JFR to Detect Deprecated Method Invocations#

Enabling JFR#

JFR is enabled by default in Java 11 and later. To start recording JFR data, you can use the following command-line option:

java -XX:StartFlightRecording=duration=10s,filename=recording.jfr YourMainClass

This will record JFR data for 10 seconds and save it to a file named recording.jfr.

Capturing Deprecated Method Events with Java Agent#

JFR events are not automatically generated for deprecated method invocations—you must programmatically create and commit them yourself. To automatically detect deprecated method invocations, you can use a Java Agent with bytecode instrumentation libraries like Byte Buddy to intercept method calls and generate custom JFR events.

Here's a complete example using Byte Buddy to detect invocations of deprecated methods and emit custom JFR events:

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.agent.ByteBuddyAgent;
import net.bytebuddy.asm.AsmVisitorWrapper;
import net.bytebuddy.description.method.MethodDescription;
import net.bytebuddy.matcher.ElementMatchers;
import net.bytebuddy.asm.Advice;
import jdk.jfr.Event;
import jdk.jfr.Label;
import jdk.jfr.Name;
import java.lang.reflect.Field;
 
public class DeprecatedMethodDetector {
    public static void premain(String agentArgs, java.lang.instrument.Instrumentation inst) {
        ByteBuddyAgent.install(inst);
        new ByteBuddy()
            .redefineDeprecatedMethods()
            .visit(new AsmVisitorWrapper.ForDeclaredMethods(
                ElementMatchers.isAnnotatedWith(Deprecated.class),
                (instrumentedType, method, methodAccessorFactory, delegator) -> 
                    Advice.to(method).invoking(method).on(m -> true)
            ))
            .make()
            .load(ClassLoader.getSystemClassLoader(), 
                  ByteBuddyAgent.InjectionStrategy.Default.INJECTION);
    }
}
 
class DeprecatedMethodVisitor extends Advice {
    @Override
    protected void onMethodEnter(MethodDescription.InDefined form, 
                                 MethodAccessorFactory methodAccessorFactory) {
        if (form.isAnnotatedWith(Deprecated.class)) {
            DeprecatedMethodEvent event = new DeprecatedMethodEvent();
            event.methodName = form.getName();
            event.className = form.getDeclaringType().asErasure().getName();
            event.commit();
        }
    }
}
 
@Name("com.example.DeprecatedMethodInvocation")
@Label("Deprecated Method Invocation")
class DeprecatedMethodEvent extends Event {
    @Label("Method Name")
    String methodName;
    
    @Label("Class Name")
    String className;
}

This approach uses a Java Agent to attach at JVM startup, intercept methods annotated with @Deprecated, and emit custom JFR events when these deprecated methods are called.

Analyzing the JFR Data#

Once you have recorded the JFR data, you can use the Java Mission Control (JMC) tool to analyze it. JMC provides a graphical interface for viewing and analyzing JFR recordings.

To view the deprecated method invocation events in JMC:

  1. Open JMC and load the recording.jfr file.
  2. Navigate to the "Events" tab.
  3. Filter the events by the custom event name (e.g., com.example.DeprecatedMethodInvocation).

You will then see a list of all the deprecated method invocations, along with the method name, class name, and stack trace.

Common Practices and Best Practices#

Common Practices#

  • Regularly Review Deprecated Method Warnings: Even with JFR, it's a good practice to review the compiler warnings about deprecated method usage during development.
  • Use Static Analysis Tools: Tools like FindBugs or PMD can also detect deprecated method invocations at compile time.

Best Practices#

  • Refactor Code Promptly: When you detect a deprecated method invocation, refactor the code to use the recommended alternative as soon as possible.
  • Test After Refactoring: Make sure to thoroughly test the application after refactoring to ensure that the functionality is not affected.
  • Document Deprecated Method Usage: If for some reason you cannot refactor immediately (e.g., due to legacy code constraints), document why the deprecated method is still in use.

Example Usage#

Let's say we have a simple Java class with a deprecated method:

public class DeprecatedExample {
    @Deprecated
    public void oldMethod() {
        System.out.println("This is an old method.");
    }
 
    public void newMethod() {
        oldMethod(); // Invoking the deprecated method
    }
 
    public static void main(String[] args) {
        DeprecatedExample example = new DeprecatedExample();
        example.newMethod();
    }
}

To detect the invocation of oldMethod, we can follow the steps above:

  1. Enable JFR and record the data.
  2. Analyze the recording.jfr file in JMC.
  3. In the "Events" tab, we should see an event for com.example.DeprecatedMethodInvocation with methodName = "oldMethod" and className = "DeprecatedExample".

References#

2026-06