Understanding Java Dynamic Proxies: Principles, Implementation, and Use Cases

Introduction

Java dynamic proxies are a technique that creates proxy classes and instantiates objects at runtime, allowing developers to encapsulate and extend object behavior. This article details the principles, implementation methods, and application scenarios of Java dynamic proxies.

1. Principles of Dynamic Proxies

Proxy Pattern: A design pattern that controls access to a real object via a proxy, enabling additional logic such as permission checks or logging before delegating to the real object, without modifying the original code.

Dynamic Proxy Mechanism: At runtime, a proxy class is generated that implements the same interfaces as the target class and overrides its methods. The proxy can execute extra logic before and after invoking the target's methods, allowing behavior changes without source modification.

2. Implementing Dynamic Proxies

Creating the Target Class public interface UserService { String getUsername(); } public class UserServiceImpl implements UserService { @Override public String getUsername() { return "Tom"; } }

Implementing the Dynamic Proxy Use Java reflection and the InvocationHandler interface. Steps: (1) Create a class that implements InvocationHandler to handle method calls on the proxy. public class UserServiceInvocationHandler implements InvocationHandler { private Object target; public UserServiceInvocationHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // Additional logic before method call System.out.println("Before call method: " + method.getName()); // Invoke the actual method on the target object Object result = method.invoke(target, args); // Additional logic after method call System.out.println("After call method: " + method.getName()); return result; } } (2) Use the InvocationHandler to create the proxy instance. public class Main { public static void main(String[] args) { UserService userService = new UserServiceImpl(); UserServiceInvocationHandler handler = new UserServiceInvocationHandler(userService); UserService proxy = (UserService) Proxy.newProxyInstance( UserService.class.getClassLoader(), new Class []{UserService.class}, handler); String username = proxy.getUsername(); System.out.println(username); } } The Proxy.newProxyInstance method requires the target class loader, the interfaces to implement, and the InvocationHandler. When the proxy's method is called, the handler's invoke method runs, allowing pre‑ and post‑processing around the actual method execution.

3. Application Scenarios

Dynamic proxies are useful in the following situations:

Logging: Insert logging logic before and after method execution to aid debugging and tracing.

Transaction Management: Add transaction start/commit or rollback logic around method calls to ensure data consistency.

Access Control: Perform permission checks before invoking methods to restrict resource access.