Dynamic Proxies

Dynamic Proxy allows you to create objects at runtime that can intercept method calls and add extra behavior.

It is a powerful feature in Java that works with interfaces and is commonly used in frameworks to implement cross-cutting concerns like logging, security, and transactions.

In simple words: You can add extra logic (like logging, security, or transactions) without modifying the original class.

InvocationHandler

InvocationHandler is an interface that handles method calls on proxy objects.

It acts as the core component where you can define custom behavior that runs whenever a method is invoked on the proxy.

Example:

import java.lang.reflect.*;

class MyHandler implements InvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Method called: " + method.getName());
        return null;
    }
}

Explanation

invoke() method is automatically called whenever a method is invoked on the proxy object
method.getName() → Gets the name of the method being called
You can add custom logic like logging, validation, or security inside this method

Key Points

invoke() runs whenever a method is called
Used to add custom behavior dynamically
Core part of Dynamic Proxy mechanism

Proxy Creation

Proxy objects are created using Proxy.newProxyInstance().

This method creates a dynamic proxy object at runtime, which uses an InvocationHandler to handle method calls.

Example:

import java.lang.reflect.*;

interface Service {
    void execute();
}

public class Main {
    public static void main(String[] args) {

        Service proxy = (Service) Proxy.newProxyInstance(
                Service.class.getClassLoader(),
                new Class[]{Service.class},
                new MyHandler()
        );

        proxy.execute();
    }
}

Output

Methodcalled:execute

Explanation

Proxy.newProxyInstance() → Creates a proxy object at runtime
Service.class.getClassLoader() → Loads the interface class
new Class[]{Service.class} → Defines which interfaces the proxy will implement
new MyHandler() → Handles method calls using InvocationHandler

Key Points

Creates objects dynamically at runtime
No actual class implementation is required
Works only with interfaces

Real-World Example (Spring AOP Concept)

Dynamic proxies are heavily used in frameworks like Spring for AOP (Aspect-Oriented Programming).

They help in adding extra functionality without modifying the original business logic.

What happens:

You call a method → the proxy intercepts the call
The proxy adds extra logic before or after execution
Then the actual method is executed

Example Flow:

UserService.save()
   ↓
Proxy intercepts method call
   ↓
InvocationHandler.invoke()
   ↓
Before Logic executes
   → Logging start
   → Security checks
   → Transaction begin
   ↓
Actual Method Execution
   → method.invoke(target, args)
   ↓
After Logic executes
   → Transaction commit / rollback
   → Success / Error logging
   ↓
Return result to Proxy
   ↓
Proxy returns response to User

Common Use Cases:

Logging (track method calls and execution).
Security checks (authentication and authorization).
Transaction management (start/commit/rollback).
Performance monitoring (measure execution time).

Conclusion

Dynamic Proxies play an important role in modern Java development by allowing developers to add behavior dynamically at runtime.

They help in adding extra functionality without changing the original code.
Support separation of concerns through AOP (Aspect-Oriented Programming).
Help in building flexible, reusable, and maintainable systems.