Dynamic Proxy Logging for Method Calls

The Anatomy of a Logging Aspect

The goal is to wrap an object with a proxy that performs logging before and after every method call. The core of this functionality will reside within our custom InvocationHandler.

Here's the plan for our invoke method:

1. Record the start time.
2. Log a message indicating which method is being called, including its arguments.
3. Use reflection to invoke the actual method on the original, "target" object.
4. Wrap the invocation in a try...finally block to ensure our "after" logic runs even if the method throws an exception.
5. In the finally block, record the end time and log the execution duration.
6. Return the result from the original method call.

Let's start with a simple service we want to add logging to. Imagine a basic data-access interface and its implementation:

// The interface we want to proxy
public interface DataRepository {
    String fetchData(String id);
    void saveData(String id, String data);
}

// The real object with business logic
public class SimpleDataRepository implements DataRepository {
    @Override
    public String fetchData(String id) {
        // Simulate a database call
        System.out.println(">> Inside SimpleDataRepository.fetchData: fetching data for id " + id);
        try {
            Thread.sleep(100); // Simulate latency
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Data for " + id;
    }

    @Override
    public void saveData(String id, String data) {
        // Simulate writing to a database
        System.out.println(">> Inside SimpleDataRepository.saveData: saving data for id " + id);
        try {
            Thread.sleep(50); // Simulate latency
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Notice the System.out.println calls within the methods. Our goal is to replace this kind of intrusive logging with an external, dynamic solution.

Implementing the LoggingInvocationHandler

Now, we'll create the InvocationHandler that contains our logging logic. This handler needs a reference to the real object so it can delegate the actual method call to it.

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;

public class LoggingInvocationHandler implements InvocationHandler {

    private final Object target; // The real object we are proxying

    public LoggingInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.nanoTime();

        System.out.printf("[PROXY] Calling method: %s(%s)%n",
                method.getName(), Arrays.toString(args));

        Object result = null;
        try {
            // Delegate the call to the real object
            result = method.invoke(target, args);
        } catch (Exception e) {
            System.out.printf("[PROXY] Exception in method %s: %s%n", method.getName(), e.getCause());
            throw e; // Re-throw the exception
        } finally {
            long endTime = System.nanoTime();
            long duration = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
            System.out.printf("[PROXY] Finished method: %s, execution time: %d ms%n",
                    method.getName(), duration);
        }
        return result;
    }
}

Tying It All Together

With the interface, implementation, and handler ready, the final step is to use Proxy.newProxyInstance() to create our logging proxy and see it in action.

import java.lang.reflect.Proxy;

public class ProxyDemo {
    public static void main(String[] args) {
        // 1. Create the real object
        DataRepository realRepository = new SimpleDataRepository();

        // 2. Create the invocation handler, passing the real object to it
        InvocationHandler loggingHandler = new LoggingInvocationHandler(realRepository);

        // 3. Create the dynamic proxy instance
        DataRepository proxyRepository = (DataRepository) Proxy.newProxyInstance(
                DataRepository.class.getClassLoader(),
                new Class<?>[] { DataRepository.class },
                loggingHandler
        );

        // 4. Use the proxy object just like the real one
        System.out.println("--- Calling fetchData through proxy ---");
        String data = proxyRepository.fetchData("123");
        System.out.println("Result from proxy: " + data);

        System.out.println("\n--- Calling saveData through proxy ---");
        proxyRepository.saveData("456", "Some new data");

        System.out.println("\n--- Proxying is complete ---");
    }
}

When you run ProxyDemo, you will see output that clearly separates the proxy's logging from the actual business logic's output, demonstrating that our aspect is working correctly.

Expected Output:

--- Calling fetchData through proxy ---
[PROXY] Calling method: fetchData([123])
>> Inside SimpleDataRepository.fetchData: fetching data for id 123
[PROXY] Finished method: fetchData, execution time: 102 ms
Result from proxy: Data for 123

--- Calling saveData through proxy ---
[PROXY] Calling method: saveData([456, Some new data])
>> Inside SimpleDataRepository.saveData: saving data for id 456
[PROXY] Finished method: saveData, execution time: 51 ms

--- Proxying is complete ---

Real-World Examples and Framework Connections

What you've just built is the fundamental concept behind Aspect-Oriented Programming (AOP) in major Java frameworks. The logging, timing, or transaction logic is the "advice," and the dynamic proxy is the mechanism that "weaves" this advice around your code at runtime.

The official Java documentation provides a similar example.

The Baeldung article you've seen before also contains a TimingDynamicInvocationHandler which is another slight variation on this theme, focusing purely on performance measurement.

This is precisely how frameworks like Spring handle concerns that apply to many methods.

To see this principle applied to a different, but equally important cross-cutting concern—transaction management—the following video is extremely insightful. It walks through the evolution from a clunky, manual proxy to a clean, dynamic proxy solution.

Conclusion

In this lesson, you've moved from theory to practice by implementing a functional logging aspect using Java's dynamic proxies. This hands-on experience solidifies your understanding of how to intercept and add behavior to method calls dynamically.

Key Takeaways:

• Dynamic proxies are an ideal mechanism for implementing cross-cutting concerns like logging, security, and transactions.
• The InvocationHandler is the centerpiece of the implementation, containing the "advice" or extra logic you want to apply.
• The core pattern involves creating the handler with a reference to the target object and using method.invoke(target, args) to delegate the original call.
• This proxy-based approach is the foundation of Aspect-Oriented Programming (AOP) in popular frameworks like Spring.
• Understanding the limitations, such as the self-invocation issue, is crucial for correctly using proxy-based systems.

In our final lesson for this module, we will expand on these ideas. We will use reflection not just for interception, but for dynamic object creation and wiring to build a miniature dependency injection (DI) container, giving you a glimpse into the heart of an application framework.