This article demonstrates how to recreate Spring's @Lookup method injection by writing a custom BeanFactoryPostProcessor and CGLIB proxy, enabling singleton beans to dynamically obtain prototype or named beans at runtime, with a complete payment‑service example and full source code.
The article provides a step‑by‑step analysis of Spring AOP’s proxy creation process, explaining why some beans are proxied, how @Order, @EnableAspectJAutoProxy, proxyTargetClass and exposeProxy affect proxying, the differences between JDK and CGLIB proxies, and why private, static or final methods cannot be intercepted.
The article explains that Spring AOP cannot intercept methods marked as private, static, or final because JDK dynamic proxies only work on public interface methods and CGLIB subclasses cannot override such methods, leading to static matching but dynamic execution failure, self‑invocation bypass, and complete loss of advice for these method types.
Spring AOP enables cross‑cutting concerns like logging and transactions without altering business code by leveraging dynamic proxies and method interceptor chains, and this article explains its core concepts, proxy selection (JDK vs CGLIB), call‑chain flow, key source classes, and provides a complete Java example.
This article explains how Lombok generates getter and setter method names for fields with a lowercase first letter and uppercase second letter, causing mismatches with MyBatis property parsing and EasyExcel’s cglib reflection, and provides practical solutions.
This article walks through various Java retry mechanisms—including manual loops, static and dynamic proxies, AOP, Spring Retry annotations, and Guava‑retry—explaining their implementations, advantages, drawbacks, and when to choose each approach for robust remote service calls.
This article explains how Lombok’s automatic getter/setter generation can cause MyBatis to store enum fields as null, details the underlying JavaBeans naming conflict, and also reveals why EasyExcel fails with @Accessor(chain=true) annotations, offering practical solutions for both problems.
This article explains the differences between static and dynamic proxies in Java, demonstrates how to implement static proxies, JDK dynamic proxies, and CGLib proxies with complete code examples, and compares their advantages, limitations, and typical use cases in backend development.
This article compares the performance of several Java bean‑mapping utilities—including Spring BeanUtils, Apache BeanUtils, Orika, Cglib BeanCopier, ModelMapper, MapStruct, and manual getter/setter code—by converting a sample Entity to a DTO 10,000 times and summarizing the results and best‑use recommendations.
This article explains CGLIB, a high‑performance bytecode library for creating Java dynamic proxies without interfaces, walks through implementation steps and core source‑code analysis, details the FastClass optimization that bypasses reflection, and compares CGLIB with JDK dynamic proxies.
This article explains why generic Java bean property copy utilities like Spring BeanUtils, Apache Commons BeanUtils, and CGLIB can cause runtime type conversion errors and performance issues, demonstrates the problems with code examples, and recommends using custom converters or IDE‑generated mapping code such as MapStruct for safe and efficient object transformation.
This article explains the concept of dynamic proxies, compares Spring's JDK‑based and CGLIB‑based proxy implementations with code examples, and shows how they power Spring AOP for cross‑cutting concerns such as transactions and logging.
This article explains Spring AOP fundamentals, demonstrates XML‑based and annotation‑based configurations, and provides a comprehensive guide to using ProxyFactoryBean—including its properties, proxy‑interface and proxy‑class scenarios, CGLIB considerations, and wildcard interceptor matching—complete with runnable code examples.
This article explains Spring's @Lookup method injection, shows how to define the annotation, register beans, run examples, and dives into the underlying CGLIB proxy mechanism and bean creation process for dynamic bean lookup.
This article explains why manual property copying in Java is inefficient, compares several runtime bean‑copy utilities, and demonstrates how MapStruct provides a compile‑time, type‑safe, high‑performance solution for shallow and deep object mapping, including handling of collections and ignored fields.
This article explains how Spring's @Configuration annotation triggers CGLIB proxy generation to manage @Bean methods, ensuring that internal calls return the same singleton instance, and contrasts this behavior with using @Component for configuration classes.
This article demonstrates how ASM is used to generate dynamic proxies with cglib and to create high‑performance JSON deserializers in Fastjson, providing code examples, explanation of the underlying bytecode generation, and practical tips for developers.
This article explains why retry mechanisms are essential for remote service calls, compares several implementation approaches—including manual loops, static and dynamic proxies, AOP, Spring Retry annotations, and Guava‑Retry—provides complete Java code examples, and discusses the advantages and drawbacks of each method.
This article walks through seven retry implementations for Java services—manual loops, static proxy, JDK dynamic proxy, CGLib proxy, custom AOP, Spring Retry annotations, and Guava‑retry—showing code examples, analyzing their pros and cons, and recommending the best fit for different project contexts.
This article explains how to enhance SpringBoot's native @Scheduled tasks with the spring-boot-starter-super-scheduled library, allowing dynamic creation, modification, and cancellation of scheduled jobs at runtime without altering existing annotations, and details the underlying implementation using BeanPostProcessor, CGLIB proxies, and a custom task manager.
This article explains why transaction control is essential for database‑backed applications, compares native JDBC/MyBatis handling with Spring's unified approach, details the core transaction APIs, and walks through the AOP‑based mechanism—including @EnableTransactionManagement, proxy generation, and CGLIB interception—that automatically opens, commits, and rolls back transactions at runtime.
This article explains how Spring AOP integrates AspectJ using CGLIB or JDK dynamic proxies, walks through a complete logging aspect example, and details the internal registration, proxy creation, and invocation processes that enable cross‑cutting concerns without modifying business code.
This article explores how Lombok’s auto‑generated getter/setter methods can conflict with MyBatis property naming conventions and cause null values, examines the underlying reflection logic in MyBatis, and also reveals why the @Accessor(chain=true) annotation disrupts EasyExcel’s CGLIB‑based mapping, offering practical solutions.
This article explains how Lombok's generated getter and setter method names can conflict with MyBatis property resolution and cause issues when using EasyExcel's @Accessor(chain=true) annotation, and provides detailed code examples and solutions to resolve these incompatibilities.
This article explains how to use Spring's ProxyFactoryBean to create AOP proxies, covering its properties, the choice between JDK and CGLIB proxies, bean configuration examples, global advisors, and practical considerations for proxying classes versus interfaces.
This article explains the differences between static and dynamic proxies in Java, provides complete code examples for static proxy, JDK native dynamic proxy, and CGLib dynamic proxy, shows their execution results, and compares their usage scenarios, especially in backend development.
This article explains why using automatic property copy utilities like Spring BeanUtils, CGLIB BeanCopier, or MapStruct can lead to hidden type conversion errors in Java, compares their performance, demonstrates pitfalls with generic type erasure, and recommends writing explicit conversion classes to avoid runtime bugs.
This article explains the Proxy design pattern, covering its definition, use cases, static proxy implementation in Nacos, step‑by‑step guides for JDK dynamic proxies and Cglib dynamic proxies, and how Spring AOP leverages both approaches for method interception.
This article explains why private controller methods in Spring Boot fail when AOP logging is enabled, revealing that CGLIB proxies cannot intercept private methods, which leads to null service injection, and provides code examples and a final conclusion.
This article explains the concepts, advantages, and limitations of Java's JDK dynamic proxy and CGLIB proxy, provides step‑by‑step code examples for user registration validation, compares their mechanisms, and summarizes when to choose each approach in real‑world applications.
This article explores Java's proxy patterns, detailing static proxy implementation, various dynamic proxy techniques—including JDK, Cglib, Javassist, and ByteBuddy—providing code examples, performance comparisons, and practical guidance for integrating these proxies into backend development for cleaner, more flexible code.
This article explains the principles, advantages, and implementation details of Java's JDK dynamic proxy and CGLIB proxy mechanisms, providing step‑by‑step code examples that demonstrate how to enhance method calls such as user registration with validation logic.
This article presents a one‑stop solution that uses dynamic proxies, Spring extensions, and Dubbo generic invocation to let overseas applications call domestic Dubbo services via HTTP without refactoring existing callers, reducing workload and eliminating previous drawbacks.
This article introduces the SpringBoot‑Super‑Scheduled starter, explains how it dynamically manages native @Scheduled tasks without code changes, shows quick integration steps, and details the underlying implementation—including configuration management, post‑processor interception, dynamic proxy chaining, and runtime task control—complete with code examples.
This article introduces Super‑Scheduled, a Spring Boot starter that enhances native @Scheduled tasks by enabling dynamic runtime management, explains quick integration steps, and details the underlying implementation using configuration components, post‑processors, CGLIB proxies, and a flexible execution chain.
This article introduces a Spring Boot starter that enhances native @Scheduled tasks with dynamic management capabilities, explains how to integrate the dependency, and details the underlying implementation using post‑processors, application runners, custom managers, and CGLIB‑based proxy chains to modify scheduling parameters at runtime.
This article explains the proxy and decorator design patterns using a coffee analogy, provides complete Java code examples for static and dynamic proxies, discusses their differences, and shows how to implement a Spring‑like AOP mechanism with JDK InvocationHandler and cglib, while also warning about their limitations.
This article walks through the proxy and decorator design patterns using a coffee‑ordering example, compares their differences, explains how Spring AOP relies on proxy mechanisms, and demonstrates building a custom dynamic proxy for SMS cost tracking with JDK InvocationHandler and cglib.
This tutorial explains Java's proxy design pattern, bytecode manipulation, static proxies using AspectJ and JDK, dynamic proxies with JDK and CGLIB, and demonstrates how Spring AOP selects between these mechanisms, providing complete code examples for each approach.
This article explains how Spring AOP weaves aspect code using dynamic proxies, why internal calls via this bypass proxy logic, and how to correctly configure and obtain proxied beans using JDK/CGLIB proxies, @EnableAspectJAutoProxy, @Autowired injection, and AopContext.
This article explains why Spring AOP proxies are not applied when a bean invokes its own methods via the this reference, compares JDK and CGLIB proxy mechanisms, and shows how to enable proxy exposure or use AopContext to achieve the desired AOP behavior.
This article explains the behavior of Spring Boot’s @Configuration and @Import annotations, the reasons a custom PointcutAdvisor may not be applied when using JDK proxies, and provides two solutions—adding the @DS annotation to interface methods or forcing CGLIB proxying with proxyTargetClass=true—to ensure the advice executes correctly.
This article explains how CGLIB creates proxy classes, decompiles them, sets thread callbacks, and uses MethodInterceptor and FastClass to efficiently intercept and invoke methods in a Java 8 environment, complete with code examples and diagram illustrations.
This article examines the drawbacks of using Java property copy utilities such as Spring BeanUtils, CGLIB BeanCopier, and Apache Commons BeanUtils, demonstrates type‑conversion errors through code examples, compares their performance, and recommends defining explicit conversion classes or using MapStruct for safer, compile‑time‑checked mappings.
This tutorial demonstrates how to create JavaBeans, DAO interfaces, and implementations, use JDK dynamic proxies to expose proxy classes, troubleshoot method‑level proxy failures, and apply Spring AOP with ProxyFactory or @Aspect, while also covering transaction pitfalls and best‑practice configurations.
This article explains Java's proxy pattern, compares static and dynamic proxies, and provides detailed examples of JDK dynamic proxy, CGLIB, Javassist, and ASM implementations, highlighting their mechanisms, code samples, and practical considerations for backend development.
This article explains why using generic property copy utilities like Apache Commons BeanUtils, Spring BeanUtils, CGLIB BeanCopier, or MapStruct can lead to performance degradation, type‑conversion errors, and hidden bugs in Java applications, and recommends defining explicit conversion classes with IDE‑generated getters and setters for safer, compile‑time‑checked mappings.
This article examines the hidden risks and performance drawbacks of Java bean property copy utilities such as Spring BeanUtils, CGLIB BeanCopier, and MapStruct, demonstrates concrete examples of type‑conversion errors, and recommends custom converters or IDE‑generated mapping code for reliable data transfer.
This article explains how Aspect‑Oriented Programming (AOP) can replace repetitive try‑catch blocks in Dubbo services, introduces core AOP concepts such as JoinPoint, Pointcut, and Advice, and compares static, JDK dynamic, and CGLIB dynamic proxy implementations with practical Java code examples.
This article explains the proxy design pattern in Java, demonstrates how to create static proxies, uses JDK dynamic proxies with InvocationHandler, and shows how CGLIB can generate class‑based proxies, highlighting their implementations, usage examples, and limitations.
This article explains the proxy pattern in Java, compares static and dynamic proxy implementations, provides complete code examples for JDK dynamic proxies, CGLIB, Javassist, and ASM proxies, and discusses their characteristics, performance considerations, and practical usage scenarios.
This article explains how Spring's @Enable annotations are driven by @Import, walks through the entry points in spring.handlers, details the processing flow of ConfigurationClassPostProcessor, distinguishes full and lightweight configuration modes, and describes the CGLIB enhancement that ensures proper @Bean method semantics.
This article explains the Java proxy pattern using a real‑world analogy, compares static and dynamic proxies, details implementations with JDK Proxy and CGLIB (including code samples), and discusses how dynamic proxies support the Open‑Closed principle and are applied in Spring AOP for transaction management.
This article explains the Proxy design pattern, covering its purpose, static, dynamic (JDK), and CGLIB implementations in Java, provides complete code examples, discusses advantages and disadvantages, and outlines typical use cases such as lazy initialization, access control, remote services, logging, and caching.
This article explains the concepts, implementation mechanisms, performance considerations, and practical code examples of Java static and dynamic proxies, covering both JDK's proxy based on interfaces and CGLIB's subclass‑based proxy, and compares their suitable use cases.
These seven Java coding pitfalls—from improper object comparison and ternary‑operator null handling to generic type mismatches, BeanUtils copying errors, missing equals/hashCode, and CGLIB proxy issues—are explained with bytecode insights and concrete avoidance strategies such as consistent types, proper generics, correct overrides, and avoiding final members.
This article reveals common Java pitfalls—from using Objects.equals versus ==, ternary operator type conversion, generic type mismatches, Set deduplication, BeanUtils property copying, to CGLIB proxy quirks—and provides concrete analysis and practical avoidance techniques for each case.
This tutorial explains how to use CGLIB to create Java dynamic proxies, compares it with JDK proxies, shows step‑by‑step code examples, and demonstrates how to inspect generated classes via decompilation.
This article explains how JDK and CGLib dynamic proxies work in Java, provides complete implementation examples, compares their mechanisms, usage scenarios in Spring, and discusses performance differences across JDK versions.
This article explains how using @Configuration(proxyBeanMethods=false) in Spring Boot 2.2 reduces bean proxy generation, cuts startup time by several seconds, and provides step‑by‑step code examples, performance logs, and best‑practice recommendations for modern Java microservices.
The article presents a bytecode‑generation technique that creates dynamic wrapper classes to invoke arbitrary Java methods with near‑native speed, avoiding reflection’s overhead, and details the CallerWrap base, generator, and thread‑safe cache implementation that together enable high‑performance middleware calls.
This article explains how Spring implements declarative transaction management using proxies, compares JDK dynamic proxies and CGLIB, demonstrates their behavior with code examples, and clarifies which method modifiers support transactional annotations in Spring applications.
This article provides a comprehensive analysis of Spring AOP's core proxy mechanisms, detailing the roles of advisor, advice, and pointcut classes, the annotation‑driven configuration process, and how Spring Boot automatically creates proxies using JDK or CGLIB based on configuration flags.
This article explains the core concepts of Spring AOP, the proxy design pattern, and provides detailed Java examples of static proxy, JDK dynamic proxy, and CGLIB dynamic proxy, helping readers answer common interview questions and understand how Spring chooses the appropriate proxy implementation.
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 walks through the evolution from plain Java implementations of a DAO interface to using the Decorator pattern, Java dynamic proxies, CGLIB proxies, and finally Spring AOP, demonstrating how each approach adds reusable timing logic while discussing their advantages and drawbacks.
This article explains Aspect‑Oriented Programming (AOP) as a complement to OOP, introduces core AOP concepts such as aspects, join points, pointcuts, advice, weaving and introductions, and provides a step‑by‑step Spring XML configuration with Java code examples demonstrating time‑logging and logging aspects, ordering, selective pointcuts, and forced CGLIB proxy usage.
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 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.
