This article explains TypeScript’s @Decorator syntax sugar, showing basic examples, how the compiler transforms them into the __decorate helper, the various decorator types and factories, execution order, and the benefits and pitfalls of using decorators in frameworks like Angular and Nest.js.
The guide explains JavaScript/TypeScript decorators—an ECMAScript stage‑2 proposal used in frameworks like Angular, Nest.js, and TypeORM—by distinguishing the decorator pattern, function, and @syntax, demonstrating a four‑step manual implementation that logs execution time, and linking decorators to AOP, IoC, and DI concepts.
This article explains Spring's pointcut implementations, covering static and dynamic pointcuts, regular‑expression based pointcuts, the RegexpMethodPointcutAdvisor, control‑flow pointcuts, and how to create custom pointcuts by subclassing Spring’s abstract pointcut classes, with full XML and Java code examples.
This article explains why a custom AOP annotation like @MyMonitor may not trigger advice in Spring Boot, analyzes the proxy‑based limitation of Spring AOP, and provides practical solutions such as self‑injection or AspectJ mode to ensure the advice executes correctly.
The article explains how Xianyu’s search service refactors tightly‑coupled, if‑else‑heavy code by applying the lightweight SWAK framework—defining @SwakInterface and @SwakTag annotations, registering proxy beans, using AOP and CGLIB proxies to route business logic via request‑derived tag groups, achieving clean, modular routing.
This article compares four Spring Boot techniques—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—for implementing a generic appkey whitelist validation, explains their implementation steps with code examples, and clarifies their execution order within the request processing pipeline.
This article explains four Spring‑Boot techniques—traditional AOP, HandlerInterceptor, HandlerMethodArgumentResolver, and Servlet Filter—to implement a reusable appkey whitelist validation, provides complete code examples for each, and clarifies their execution order within the request processing pipeline.
This article explains how Aspect‑Oriented Programming is applied in Android development to achieve non‑intrusive privacy compliance checks and thread‑usage optimization, detailing the use of compile‑time ASM bytecode instrumentation and runtime Xposed/epic hooks, along with code examples and measured performance gains.
This article introduces Aspect‑Oriented Programming in Spring, explains core concepts such as pointcut, advice, aspect, join point and weaving, and provides step‑by‑step code examples—including a simple @GetMapping logger, a custom permission annotation with multiple aspects, and detailed usage of @Pointcut, @Around, @Before, @After, @AfterReturning and @AfterThrowing annotations—illustrated with diagrams and runnable snippets.
Learn how to create a custom SpringBoot annotation that supports ${…} placeholder expressions by adding AspectJ dependencies, defining the annotation, implementing an AOP aspect that resolves placeholders via EnvironmentAware, storing the result in a ThreadLocal, and using it in a service and controller.
This article explains Aspect‑Oriented Programming (AOP) in Spring Boot, covering its core concepts, why it simplifies cross‑cutting concerns like logging and permission checks, provides step‑by‑step code examples of simple and advanced AOP implementations, and details the most commonly used AOP annotations.
This article explains the purpose and inner workings of Spring's @Transactional annotation, detailing how AOP and dynamic proxies create transactional proxies, the role of BeanPostProcessor, advisors, TransactionInterceptor, and the transaction lifecycle, accompanied by code examples and diagrams for deeper insight.
This article explains the purpose and inner workings of Spring's @Transactional annotation, detailing how AOP creates proxy objects, the role of BeanPostProcessor, advisors, interceptors, and the TransactionInterceptor, and walks through key source code snippets that manage transaction boundaries.
This article demonstrates how to use Spring AOP to create a request‑logging aspect that captures request parameters, response data, execution time, and error information, while also addressing high‑concurrency logging issues and integrating trace‑ID tracking for easier debugging.
This article explains how the BizLog component records who performed which action at what time in Spring Boot applications, covering Maven setup, annotation usage, custom operators, detail fields, category segregation, SpEL expressions, custom parse functions, and extension points for persistence and operator retrieval.
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 Spring 5.3.3 creates AOP proxy objects using Advisors, details the internal methods for locating and applying both bean-defined and @Aspect advisors, and demonstrates how to implement a custom Advisor to intercept methods annotated with @DS, including common pitfalls and solutions.
This guide demonstrates how to add a custom AOP‑based caching layer to a SpringBoot application, using Redis to store frequently queried MySQL table data, defining @AopCacheEnable and @AopCacheEvict annotations, implementing an aspect, handling key generation, expiration, and cache eviction on CRUD operations.
This article walks through Spring’s AOP proxy creation process, detailing how enabling @EnableAspectJAutoProxy registers AnnotationAwareAspectJAutoProxyCreator, how it decides whether to wrap a bean, and the internal methods—wrapIfNecessary, isInfrastructureClass, shouldSkip, and advisor discovery—that together generate the dynamic proxies used at runtime.
This article explains how to add a generic app‑key whitelist authentication feature to a Spring Boot web framework using four different mechanisms—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order.
This article demonstrates how to use Spring AOP to create a request‑logging aspect that captures IP, URL, HTTP method, parameters, results, execution time, and error details, while also addressing high‑concurrency logging issues and integrating trace‑ID tracking for easier debugging.
This comprehensive guide explores the Spring framework’s fundamentals, including its lightweight architecture, core IoC container, dependency injection mechanisms, bean scopes and lifecycle, annotation‑based configuration, data‑access support, and aspect‑oriented programming features, providing developers with a solid foundation for building robust Java applications.
This article explains the principles and step‑by‑step implementation of Aspect‑Oriented Programming (AOP) in a lightweight Spring‑style container, covering core concepts, advice and pointcut design, weaving mechanisms, proxy creation, observer integration, and practical code examples.
This article explains how to add a generic appkey whitelist authentication feature to a Spring Boot web framework using four approaches—traditional AOP, HandlerInterceptor, HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order.
After a massive crash caused by a malformed Facebook SDK payload highlighted the lack of fault‑tolerance, this article explains why iOS crash protection is essential, outlines a four‑step handling workflow, and details two main techniques—Aspect‑Oriented Programming hooks and managed zombie objects—along with their pitfalls, performance impact, and memory‑threshold formulas for safe production deployment.
This article introduces Aspect‑Oriented Programming in Java, explaining how AOP separates cross‑cutting concerns like logging using join points, pointcuts, advice, and aspects, and demonstrates dynamic proxies, various advice types, XML configuration, and aspect ordering within Spring AOP.
Learn how to implement a robust request logging aspect in Spring using AOP annotations, covering pointcut definition, before/around/after advice, handling high concurrency, serializing logs, capturing errors, and adding traceId support for better traceability in backend services.
The article analyzes a Spring Boot transaction issue where a @Transactional method called from another non‑transactional method fails to roll back, explains the underlying propagation and proxy mechanisms, and presents two practical solutions—including using the bean’s proxy via AopContext with exposeProxy enabled—to ensure proper rollback.
An extensive overview of the Spring Framework covering its core concepts, version features, lightweight architecture, IoC container, dependency injection methods, bean definitions and scopes, configuration styles, annotation usage, AOP principles, MVC workflow, data access mechanisms, and related implementation details with code examples.
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 the purpose and inner workings of Spring’s @Transactional annotation, detailing how AOP creates proxies, defines pointcuts, and orchestrates transaction management through BeanPostProcessors, advisors, interceptors, and the TransactionInterceptor, illustrated with source code snippets and diagrams.
This article explains the purpose of Spring's @Transactional annotation, how it leverages AOP and dynamic proxies to manage transactions, and walks through the core source‑code components—including BeanPostProcessor, advisors, TransactionInterceptor, and the transaction lifecycle—illustrated with concrete code examples.
This article explores using AOP techniques such as Method Swizzle and NSProxy‑based delegate proxies to instrument iOS view controllers and collection view delegates, analyzes crashes caused by multiple setDelegate hooks—including interactions with RxCocoa—and proposes several practical solutions to ensure stable hooking in complex app environments.
This article explains how to implement read‑write separation in Spring Boot by extending AbstractRoutingDataSource, using ThreadLocal for key storage, and creating AOP aspects that prioritize datasource switching over transaction management.
This article explains how Spring Cloud Sentinel’s @SentinelResource annotation works, detailing its AOP interception, the responsibility‑chain slot mechanism, flow‑control and circuit‑breaker processing, and shows the relevant configuration and code examples for integrating Sentinel into a Spring Boot backend.
This article explains typical situations where Spring @Transactional annotations fail—such as non‑public methods, beans not managed by the container, internal method calls, non‑RuntimeException throws, caught exceptions without rethrow, incorrect propagation settings, and unsupported MyISAM storage—and provides concrete code examples and fixes to ensure proper transaction behavior.
This article provides a comprehensive overview of the Spring framework, covering its core modules, version compatibility, core concepts such as IoC and AOP, proxy implementations, bean factories, lifecycle management, transaction handling, MVC architecture, Spring Boot, Spring Cloud, and common annotations for Java backend development.
This article explains how to achieve database read‑write separation in a Spring application by using AbstractRoutingDataSource for routing, ThreadLocal for context, AOP interceptors for automatic switching, and provides a complete example with configuration, service code, and test cases.
This article explains typical reasons why @Transactional may not work in Spring applications—such as non‑public methods, beans not managed by the container, internal method calls, non‑RuntimeException throws, swallowed exceptions, wrong propagation settings, and unsupported MySQL storage engines—and provides concrete code examples and fixes for each case.
This article explains three typical situations where Spring's @Transactional annotation fails—non‑public methods, internal method calls, and caught exceptions—detailing the proxy‑based AOP mechanism, source code examples, and how to diagnose and resolve each issue.
This article explains three typical situations in which Spring's @Transactional annotation becomes ineffective—non‑public methods, internal self‑calls, and caught exceptions—illustrates each case with runnable code examples, and dives into the underlying AOP and transaction‑management source code to show why the proxy logic is bypassed.
The article analyzes three typical situations—non‑public methods, internal self‑calls, and caught exceptions—that cause Spring's @Transactional annotation to be ineffective, explains the underlying proxy and AOP mechanisms, and provides Java code samples and test cases to illustrate each case.
An in‑depth guide to the Spring framework covering its lightweight architecture, core principles such as IoC, DI, and AOP, key design patterns, module structure, bean lifecycle, circular dependency handling, and essential annotations for building robust Java backend applications.
This article provides a comprehensive overview of the Spring framework, covering its lightweight architecture, core principles such as Inversion of Control and Dependency Injection, AOP mechanisms, design goals, module structure, common design patterns, bean lifecycle, circular dependency handling, and the most frequently used Spring annotations with code examples.
This article outlines common situations that cause Spring @Transactional to fail—such as non‑public methods, internal method calls, unmanaged beans, non‑runtime exceptions, silent catches, incorrect propagation settings, and unsupported MySQL storage engines—and provides practical solutions to ensure transaction reliability.
This tutorial explains how to reduce repetitive validation code in a ThinkPHP project by creating a reusable BaseValidate class that leverages AOP principles, automatically handles request data, and centralizes error handling for cleaner, more maintainable backend code.
This article explains the main reasons why Spring's @Transactional annotation may become ineffective—including non‑public method modifiers, internal method calls, and swallowed exceptions—provides code examples, test cases, and a deep dive into the underlying proxy and AOP mechanisms.
The article demonstrates how to create a custom @ValidShop annotation and an AOP aspect that intercepts Spring MVC controller methods, extracts the annotated parameter via reflection, validates the shop code through a helper service, and proceeds only when the check succeeds.
This article introduces the BizLog SDK for Spring Boot, explaining how to add Maven dependencies, enable logging with @EnableLogRecord, configure log records using @LogRecordAnnotation for success, failure, categories, details, operators, custom parsing functions, and shows how to extend the framework with custom services and implementations.
This article explains the core principles of Spring transaction management, covering basic JDBC transaction steps, declarative @Transactional usage, AOP proxy mechanisms (JDK dynamic proxy and CGLIB), transaction propagation attributes, isolation levels, nested transactions, and Spring Boot support, with practical code examples.
This article explains how to implement database read‑write splitting in a Spring Boot application by configuring master and slave data sources, creating a dynamic routing datasource, using a ThreadLocal context holder, defining a custom annotation with AOP for automatic switching, and demonstrates usage with sample code.
This article explains the five Spring AOP advice types, their execution order when combined in a single aspect, and provides a complete Java code example demonstrating before, after, after‑returning, after‑throwing, and around advices with normal and exceptional flows.
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 how to achieve database read‑write separation in high‑concurrency Java applications by configuring master‑slave data sources, implementing a routing data source, managing context with ThreadLocal, defining a custom @DataSourceSwitcher annotation, and applying AOP to dynamically switch between read and write databases.
This article explains how to achieve read‑write separation in high‑concurrency Java applications by configuring master‑slave data sources, routing with AbstractRoutingDataSource, managing context via ThreadLocal, defining a custom @DataSourceSwitcher annotation, and applying AOP to switch databases at runtime.
This article walks through the fundamentals of Spring AOP, showing how to replace repetitive logging code with AspectJ‑driven aspects, explains core AOP concepts, pointcut expressions, proxy creation mechanisms, advice types, caching behavior, and common pitfalls for Java backend developers.
This article explains how to achieve database read‑write separation in high‑concurrency scenarios using Spring Boot, Druid connection pool, and MySQL, covering master‑slave data source configuration, routing via AbstractRoutingDataSource, context holder management, custom annotations, AOP switching, and usage examples with code snippets.
This article explains how Spring transaction management works, details its declarative and programmatic integration methods, examines core implementation classes and AOP proxies, and highlights frequent pitfalls such as ineffective transactions, rollback failures, and timeout issues, providing code examples and solutions for Java backend developers.
This article provides a comprehensive guide to the Spring framework, covering its core modules, the concepts of Inversion of Control and Aspect‑Oriented Programming, various container implementations, proxy mechanisms, bean lifecycle, design patterns, MVC architecture, Spring Boot, Spring Cloud, and common annotations for Java backend development.
This article presents Beike's comprehensive analysis of Flutter image memory consumption, explains the underlying decoding process, evaluates cache and sampling strategies, and proposes an external texture approach with native integration to effectively reduce OOM incidents on both iOS and Android platforms.
This article explains how to protect time‑consuming business operations using a Redis‑based distributed lock in a Spring Boot application, covering annotation design, AOP pointcuts, lock acquisition and release, timeout handling, automatic renewal via a ScheduledExecutorService, and practical testing results.
This article demonstrates how to create a Spring AOP request‑logging aspect that captures request parameters, response data, execution time, and error information, while also handling high‑concurrency scenarios and integrating traceId support for easier log tracing.
The article explains Service Provider Interface (SPI) concepts, shows how the JDK’s built‑in SPI works, and details Dubbo’s extended SPI mechanism—including named and adaptive extensions, dependency injection, AOP wrappers, and activation filtering—highlighting its richer features and implementation compared to standard Java SPI.
This article describes how JD Mall’s Android team designed a custom first‑screen latency monitoring system, collected lifecycle, network and rendering metrics via AOP and configuration, and applied a series of optimizations—including plugin preloading, network parallelism, layout inflation tricks, and hardware acceleration—to achieve over 30% faster app start‑up and significantly reduced user churn.
This article explores nine core design patterns implemented in Spring—simple factory, factory method, singleton, adapter, decorator, proxy, observer, strategy, and template method—detailing their implementation mechanisms, underlying principles, code examples, and practical significance for building loosely coupled, extensible Java applications.
This article examines whether a Service layer in a Spring‑based application truly requires an interface, analyzes common arguments for and against using interfaces, explores project structuring options, and offers practical recommendations based on real‑world development experience.
This article explains Spring Retry's architecture, how @EnableRetry, @Retryable, @Backoff and @Recover work together, details the available retry and back‑off policies, and walks through the core implementation using RetryTemplate and interceptors to provide flexible, AOP‑based retry handling in Java backend applications.
This article provides a comprehensive overview of MyBatis plugins, explaining their interception capabilities, typical use cases such as pagination, common field assignment, and performance monitoring, while detailing the underlying dynamic‑proxy implementation, configuration loading, and relevant design patterns for backend Java development.
This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes its core concepts and terminology, and provides step‑by‑step code examples for creating pointcuts, advices, and custom annotations, while also detailing the use of common AOP annotations such as @Pointcut, @Around, @Before, @After, @AfterReturning and @AfterThrowing.
This article provides comprehensive explanations of Spring framework concepts—including IoC/AOP principles, bean lifecycle, circular dependency resolution, transaction pitfalls, annotation configuration, MVC processing flow, advice types, and thread‑safety mechanisms—along with illustrative code snippets for interview preparation.
This article explains the fundamentals of Aspect‑Oriented Programming on iOS, compares major AOP techniques such as Method Swizzle, Aspects, MPSwizzler, ISA‑swizzle KVO, Fishhook, Thunk and Clang instrumentation, and provides practical code examples and best‑practice guidelines.
This article explains the AOP mechanism behind Spring's @Transactional, why only unchecked exceptions trigger automatic rollbacks, illustrates common pitfalls with code examples, and provides practical fixes such as using rollbackFor or manually marking the transaction for rollback.
This article explains how to create and use custom Java annotations together with Spring AOP to implement unified logging, method‑level parameter validation, and other cross‑cutting concerns, providing practical code examples and best‑practice recommendations for backend developers.
This article explains why Spring AOP advice does not trigger when a method calls itself via this, demonstrates how to reproduce the problem, and provides a solution using AopContext.currentProxy() together with proper proxy configuration to ensure the aspect executes correctly.
This tutorial explains the core concepts of Spring AOP, shows how to integrate AOP in Spring Boot to create custom annotations and interceptors, and provides practical solutions for the common self‑invocation issue that causes AOP advice to be ignored.
This article demonstrates how to create a Spring AOP request‑logging aspect that captures request details, execution time, and errors, optimizes log output for high‑concurrency environments, and integrates trace‑ID tracking for easier debugging across distributed services.
This article demonstrates how to use Spring Boot AOP to automatically record operation and exception logs by defining log tables, adding the AOP starter dependency, creating a custom @OperLog annotation, implementing an aspect that captures request details and errors, and applying the annotation to controller methods, providing a clean, reusable logging solution for Java backend applications.
This article demonstrates how to implement read/write splitting in a Spring Boot application by configuring multiple data sources, using AbstractRoutingDataSource for dynamic routing, and applying AOP and custom annotations to direct read operations to slave databases and write operations to the master, with full Maven and MyBatis setup.
This article explains the concept of idempotency, common causes of duplicate submissions, and presents several practical solutions—including PRG, token validation, local locks using ConcurrentHashMap, and distributed locks with Redis—accompanied by Spring Boot AOP annotations and full code examples.
This article compares Spring's programmatic and declarative transaction management, explains how each works with code examples, outlines the benefits and limitations of declarative transactions—including granularity and failure scenarios—and argues why developers should consider programmatic transactions for clearer control and fewer hidden bugs.
The article explains how to enhance Java bytecode using a javaagent, covering bytecode fundamentals, agent loading during JVM startup, implementation steps, transformation via ClassFileTransformer, and popular tools such as ASM, Javassist, and ByteBuddy for non‑intrusive runtime instrumentation and monitoring.
This article introduces the open‑source Spring framework for Java, explains the core concepts of Inversion of Control (IOC) and Aspect‑Oriented Programming (AOP), and walks through creating a Spring Boot web project with MVC layers, annotations, and a runnable example.
Umajs is a lightweight Node.js web framework written in TypeScript that offers rich built‑in decorators, IOC, AOP, a flexible plugin system, and a unified Result API, enabling developers to build high‑performance, maintainable backend services with minimal boilerplate.
This article explains the concept of AOP, its typical use cases, the underlying mechanisms of Spring AOP (JDK dynamic proxy and CGLIB), the relationship with AspectJ, and provides a complete XML‑free code example that demonstrates aspects, pointcuts, join points and advice.
This article explains the concept of circular dependencies in Spring, reviews related fundamentals, demonstrates how Spring's three-level cache resolves singleton circular references, discusses limitations with prototype and constructor injection, and provides code examples and detailed source analysis for developers.
This article explains how Spring's @Transactional annotation works, common pitfalls such as using it on private methods, and the correct ways to configure propagation, isolation, and bean injection to ensure proper transaction rollback and non‑rollback behavior.
This article explains how to accelerate service response by integrating Redis as a key‑value cache with Spring Cache, covering the three‑step implementation, required Maven dependencies, XML configuration, property settings, a custom Cache implementation class, and common Spring Cache annotations.
This article dives deep into Spring's transaction infrastructure, explaining how @EnableTransactionManagement activates transaction support, detailing the roles of key configuration classes, core interceptors, transaction attribute resolution, propagation behaviors, and the commit‑and‑rollback processes that power reliable data operations in Spring and Spring Boot applications.
This article examines frequent Spring transaction problems—including ineffective transactions, rollback anomalies, and issues when combining read‑write separation with @Transactional—explains their root causes, and provides practical solutions such as engine changes, bean configuration, proxy usage, rollback settings, and proper propagation levels.
This article explores Spring’s @Async annotation in depth, detailing its basic usage, underlying proxy creation, pointcut logic, and asynchronous execution, while highlighting common issues such as circular dependencies and inefficient default thread pools, and providing practical solutions like lazy injection and custom executors.
Lokie is a high‑performance iOS AOP framework written in C++14 that replaces the slow Aspect library by using libffi‑based trampolines, offering thread‑safe method interception, detailed API usage, runtime internals, and assembly‑level trampoline implementation with significant speed improvements.
This article explains Spring's circular dependency problem, the conditions under which it can be resolved, and how Spring's three‑level cache—combined with AOP proxy handling—enables beans to reference each other without causing creation failures, providing a comprehensive answer for interview scenarios.
This tutorial explains how to build a custom Spring Boot starter in four steps—setting up a Maven project, defining auto‑configuration with AOP, registering the starter via spring.factories, and packaging it—so that methods annotated with a custom @AspectLog annotation automatically log their execution duration.
Learn how to create a custom Spring Boot starter named aspectlog-spring-boot-starter that automatically logs method execution times using AOP, covering project setup, Maven configuration, conditional loading, annotation definition, auto‑configuration class, META‑INF registration, and packaging for reuse in other projects.
This article explains what circular dependency means in Spring, the conditions under which it can be resolved, and walks through the three‑level cache mechanism—including simple cases and AOP‑enhanced scenarios—providing code examples, diagrams, and a clear summary for interview preparation.
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 how to build a Java Agent that leverages bytecode instrumentation, class‑loader mechanisms, and AOP techniques to provide lightweight, configurable performance profiling and monitoring for Java services, covering requirements, technical foundations, implementation steps, and testing procedures.
This article describes how Bilibili's Membership Purchase team built a Java‑based traffic replay platform using JVM‑Sandbox AOP, Kafka, and MySQL to capture real‑world request/response data, serialize it with JSON, and replay it for comprehensive regression testing of complex backend services.
This article explains the typical use cases of MyBatis plugins, introduces the concept of MyBatis interceptors, details the supported interception points and execution stages, describes how plugin configuration is loaded and proxy objects are generated, and provides a practical example of implementing a pagination plugin.
This article explains the core principles of Spring transaction management, including JDBC transaction steps, declarative @Transactional usage, AOP proxy mechanisms, propagation behaviors, isolation levels, nested transactions, and Spring Boot support, while also providing code examples and practical guidance for developers.
