This article explains how JDK dynamic proxy generates proxy classes at runtime for interfaces using java.lang.reflect.Proxy and InvocationHandler, demonstrates usage with code examples, explores the underlying ProxyGenerator and class‑caching mechanisms, and clarifies why only interface‑based proxies are supported.
The article describes how a commercial testing platform faced three limitations with its RPC client, analyzes Java class‑loading, dynamic proxy, and ThreadLocal concepts, and presents two implementation approaches—one using dynamic proxies and another leveraging ThreadLocal—to enable dynamic loading of multiple rpc.config files without restarting the service.
This article explains the fundamentals of Spring AOP's JDK and CGLib dynamic proxies, compares their implementation details, presents performance test results across Java 1.6‑1.8, and offers practical guidance on choosing the appropriate proxy based on use‑case.
This article explains the proxy design pattern, compares static and dynamic proxy implementations in Java, demonstrates how to use Java reflection and InvocationHandler for dynamic proxies, and shows how these techniques enable AOP features such as logging and transaction handling.
This article explains the fundamentals of Spring AOP by introducing proxy patterns, demonstrating static and dynamic proxy implementations with full Java code examples, and showing how Spring integrates JDK and CGLIB proxies through XML configuration for real‑world cross‑cutting concerns such as transactions and logging.
This article explains Aspect‑Oriented Programming, compares AspectJ's compile‑time static weaving with Spring AOP's runtime dynamic proxies (JDK and CGLIB), and demonstrates both approaches through complete Java code examples and execution results.
This article explains the Proxy design pattern, details Java's dynamic proxy classes and interfaces from JDK 1.6 source, walks through the step‑by‑step creation process, presents a complete demo implementation, and analyzes the underlying Proxy class generation and InvocationHandler mechanisms.
This article examines how JDK dynamic proxies cause Spring transaction methods to lose their transactional behavior, illustrates the issue with four concrete scenarios, and presents three practical solutions to ensure proper rollback and commit semantics.
This article explores the pain points of traditional Java web development, demonstrates how design patterns and JDK dynamic proxies introduce Aspect‑Oriented Programming concepts, explains Spring AOP's relationship to AOP, and compares JDK and CGLib proxy implementations for clean, reusable code.
This article explains Java's reflection mechanism, outlines its capabilities such as runtime class inspection, object instantiation, method invocation, and dynamic proxy creation, and provides numerous code examples demonstrating how to retrieve class information, manipulate fields, invoke methods, and apply reflection in patterns like factories.
This article explains the Proxy design pattern in Java, covering static proxy, dynamic JDK proxy, and Cglib subclass proxy with detailed code examples and discussion of their advantages, limitations, and typical usage in AOP frameworks.
This article explains Java's dynamic proxy mechanism, covering the roles of InvocationHandler and Proxy classes, their APIs, the parameters required for creating proxy instances, and a complete example that demonstrates how method calls are intercepted and delegated through a custom handler.
This article explains the fundamentals of Java dynamic proxy, demonstrates how to use Proxy and InvocationHandler to eliminate repetitive null‑checks in MVP presenters and to create flexible, decoupled module interactions, providing complete code examples and practical insights.
This article introduces Spring's BeanPostProcessor, explains its two callback methods, and demonstrates through a real‑world A/B testing scenario how custom annotations and a post‑processor can inject dynamic proxies to simplify routing logic and improve code maintainability.
This article explains the concept of the Proxy design pattern, demonstrates how to implement static and dynamic proxies in Java with complete source code, and analyzes the advantages, limitations, and internal workings of Java's runtime-generated proxy classes.
This article explains Kotlin's class extension functions, highlights pitfalls of static resolution, demonstrates smart casts, describes companion objects and singleton patterns, and shows how to implement dynamic proxies and pseudo‑multiple inheritance with practical code examples for Android development.
This article explains how to measure the execution time of Java methods by first using an intrusive approach that embeds timing code directly in each method, then introduces a cleaner solution based on Java's dynamic proxy mechanism to separate performance monitoring from business logic.
This article explains how to perform code‑level performance measurement in Java services, compares the traditional intrusive approach with a cleaner solution using JDK dynamic proxies, and demonstrates how to decouple timing logic from business code.
This article explains how large‑scale internet companies replace local service calls with remote procedure calls (RPC), covering Java dynamic proxies, message encoding, serialization, asynchronous response handling, and Zookeeper‑based service registration and discovery to achieve transparent, scalable service communication.