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.
This article examines common operation‑log types and compares two implementation approaches—traditional AOP with annotations and a database binlog‑based solution—detailing their advantages, drawbacks, code examples, database design, future enhancements, and practical deployment considerations.
This article explains how to achieve non‑intrusive, efficient full‑record data change auditing in a Spring‑based backend by leveraging Aspect‑Oriented Programming, custom annotations, and reflection to automatically capture before‑and‑after values for both primary and related tables.
This article explains the typical scenarios, internal implementation details, design patterns, and step‑by‑step development of MyBatis plugins, helping backend developers grasp how to intercept Executor, ParameterHandler, ResultSetHandler, and StatementHandler methods for pagination, auditing, performance monitoring, and other custom logic.
This article explains how to modify the default OAuth2 token response format in Spring Security by adding custom fields using a HandlerMethodReturnValueHandler implementation or an AOP advice, and discusses the implications of deviating from the OAuth2 specification.
This article explains Spring Boot’s @Transactional implementation, covers transaction isolation levels and propagation, walks through the core source code of TransactionInterceptor and PlatformTransactionManager, and guides you step‑by‑step to create a custom annotation that rolls back on specified exceptions using JDBC and AOP.
This article introduces the background and necessity of rate limiting, explains the leaky bucket and token bucket algorithms with visual diagrams, and provides a comprehensive Java implementation using Guava's RateLimiter, custom annotations, AOP interception, and controller integration to protect high‑traffic applications.
This article explains the purpose of Spring's @Transactional annotation, details its configurable attributes, and enumerates six typical scenarios—such as non‑public methods, wrong propagation settings, self‑invocation, and unsupported database engines—that cause the annotation to become ineffective, providing code examples and solutions.
Learn how to resolve performance bottlenecks in a Spring‑based mall project by caching user and permission data in Redis, adding cache logic with RedisTemplate, and using AOP to gracefully handle Redis failures, ensuring stable authentication even when the cache is unavailable.
This article explains several typical pitfalls that cause Spring's @Transactional annotation to be ineffective, such as unsupported database engines, unmanaged service beans, internal method calls, non‑public methods, default rollback rules, and missing transaction manager configuration, and provides practical solutions for each case.
This article explains how Spring's @EnableAsync annotation activates asynchronous method execution, detailing the roles of AsyncConfigurationSelector, ProxyAsyncConfiguration, AbstractAsyncConfiguration, and AsyncAnnotationBeanPostProcessor, and showing the underlying code that creates proxies, advisors, and executors for async processing.
This article explains how the Spring framework implements various classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation mechanisms, underlying principles, and practical significance within Spring's bean lifecycle and extension points.
This article demonstrates how to achieve read‑write splitting in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, using AOP to switch between master and slave databases, and integrating the routing data source with MyBatis for transparent database operations.
This article presents the design, architecture, and performance evaluation of a lightweight aspect‑oriented plugin framework developed by 58 Real Estate, detailing its motivation, module decomposition, integration with SCF and WF, benchmark results, practical usage scenarios, and guidelines for extending it with custom plugins.
This article explains the source‑level principles of Spring AOP and walks through the step‑by‑step request processing flow of Spring MVC, providing code snippets and design insights for backend developers preparing for interviews.
This article demonstrates how to create a reusable, method‑level parameter validation mechanism in SpringBoot using custom @Check annotations, covering the motivation, usage examples, Maven dependencies, annotation definition, core AOP logic, validation algorithm, and future enhancements.
This article provides a comprehensive introduction to the Spring ecosystem, covering its core concepts such as IoC and AOP, detailing each of the seven framework modules, and explaining related projects like Spring MVC, Spring Security, Spring Data, Spring Boot, and Spring Cloud for modern Java backend development.
This article demonstrates how to implement database read‑write splitting in a Spring Boot application by configuring multiple MySQL data sources, creating a custom AbstractRoutingDataSource, using ThreadLocal routing keys, and applying AOP to switch between master and slave databases for CRUD operations.
This article explains Java annotation fundamentals, explores built‑in meta‑annotations, demonstrates how to create compile‑time and runtime custom annotations, and shows how to integrate them with Spring Boot AOP for automatic logging and request handling.
An in‑depth overview of the Spring ecosystem explains its core container, modules such as AOP, MVC, Data, Security, Boot and Cloud, detailing how IoC and dependency injection simplify Java enterprise development, and guides readers through configuration, architecture, and the advantages of using Spring for modern backend applications.
This article explains the challenges of applying aspect‑oriented programming in Flutter, introduces the open‑source AspectD framework for Dart, and walks through its design, supported syntax, code examples, and integration steps for both debug and release builds.
ARetrofit is an Android routing framework that enables concise, component‑to‑component communication by generating compile‑time route metadata via annotation processing, injecting bytecode with the Transform API, creating service proxies through dynamic proxies, and applying an OkHttp‑style interceptor chain for flexible, cross‑module extensions.
This tutorial explains the fundamentals of Aspect Oriented Programming (AOP) and demonstrates how to create a logging aspect in a Spring MVC application, covering AOP terminology, Spring annotations, pointcut expressions, a WebLog DTO, the WebLogAspect implementation, and how to test the logging output via Swagger UI.
AspectD is a compile‑time Aspect‑Oriented Programming framework for Dart that traverses Flutter’s dill intermediate files to inject, call, or execute advice code, allowing non‑intrusive instrumentation, logging, and UI event injection without modifying source, and integrates into the build pipeline via a toolchain patch.
This tutorial demonstrates how to integrate an AOP logging module into a Spring Boot project by adding required dependencies, creating a custom aspect that extends LBaseWebLogAspect, defining a pointcut, and exposing a sample REST endpoint that returns user data while logging detailed request information.
This article provides an in‑depth, English‑language overview of the Spring framework, covering its purpose, core modules, IoC and AOP principles, bean scopes and lifecycle, transaction management, MVC architecture, and the design patterns it employs, all without heavy code examples.
This article provides a comprehensive guide to using AspectJ for aspect‑oriented programming in Android, covering core concepts such as aspects, join points, pointcuts and advice, demonstrating matching expressions, custom annotations, and detailing step‑by‑step integration with Gradle plugins and plugin implementation for seamless code weaving.
This article reviews the most frequently applied design patterns in Spring—including IoC/DI, Factory, Singleton, Proxy (AOP), Template Method, Observer, Adapter, and Decorator—explaining their purpose, how Spring implements them, and providing concise code examples for each.
This article explains how Java's Load‑Time Weaving (LTW) enables static AOP via the java.lang.instrument package, details the core interfaces, demonstrates a complete code example with custom transformers and proxy classes, and shares practical tips for packaging the agent JAR.
The article introduces Aspect‑Oriented Programming, explains its core concepts and compile‑time versus runtime models, and demonstrates how Android developers can employ compile‑time AOP (using AspectJ) to implement method‑level hot‑fixes, performance monitoring, logging, and other cross‑cutting features while weighing benefits, overhead, and optimization strategies.
This article explains how to use ASM to instrument Android bytecode for automatic click event tracking and OkHttp network request monitoring, detailing the Transform API, AOP/ASM techniques, custom ClassVisitor and MethodVisitor implementations, code injection strategies, and provides a complete open‑source example on GitHub.
This article provides a comprehensive tutorial on Spring Boot, covering its purpose, key advantages, project setup with Maven, essential configuration files, integration of JdbcTemplate, JPA, MyBatis, JSP, AOP, and task scheduling, all illustrated with complete Java code snippets.
This article explains why front‑end monitoring is essential for user experience, outlines the key data types to collect, and provides practical AOP‑based implementations for route changes, JavaScript errors, performance metrics, resource failures, API calls, and reliable log reporting.
This article explains how Spring enables transaction management through @EnableTransactionManagement, details the internal configuration selectors, bean registrations, AOP pointcuts, and the TransactionInterceptor implementation, illustrating the flow of transaction attribute detection, method interception, and exception‑based commit or rollback.
DroidAssist, an open‑source, configuration‑driven framework from Didi, lets developers replace or augment Android Java bytecode at compile time via simple XML rules—enabling non‑intrusive mocking such as swapping SharedPreferences implementations without source changes or extra dependencies, while supporting incremental builds and rich transformation capabilities.
This article explains how to simplify Spring service method parameter checks by encapsulating inputs in POJOs, applying bean‑validation annotations, and using a custom AOP aspect or standard @AssertTrue to automatically enforce validation logic.
This article explains the essential principles of Spring transaction management, covering transaction propagation, the impact of proxy-based AOP, multithreading safety with ThreadLocal, BeanPostProcessor roles, and common misconceptions illustrated through practical code examples.
This article explains how to replace invasive, manually‑invoked SDKs in Android with a unified, non‑intrusive solution using Aspect‑Oriented Programming, Gradle Transform plugins, and ASM bytecode manipulation, improving control, readability, and performance for large‑scale mobile platforms.
This comprehensive guide walks Java developers through Spring Framework’s essential features—including its modular architecture, dependency injection mechanisms, bean lifecycle, annotation‑based configuration, data‑access support, AOP concepts, and MVC workflow—providing clear explanations, code examples, and visual diagrams to deepen understanding.
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 how to use Java Instrumentation, the Attach API, JVMTI, and the ASM bytecode manipulation framework to inject AOP logic that measures and logs method execution time, providing a step‑by‑step guide with code examples and a discussion of practical considerations.
This article presents an AOP‑based system‑level test decoupling solution that splits large systems into independent subsystems, detailing background, existing approaches, the proposed architecture, recording and playback processes, practical deployment steps, case studies, and future plans to improve test efficiency, stability, and scalability.
This article provides a comprehensive overview of the Spring framework, detailing its lightweight nature, modular architecture, core features such as AOP, dependency injection, transaction management, integration capabilities, and the major enhancements introduced in Spring 5.0, including Java 8/9 support, reactive programming, and testing improvements.
This article explains how to use Aspect‑Oriented Programming (AOP) in Java backend controllers by defining a unified ResultBean response format, outlining controller coding conventions, and providing complete Java and XML examples for logging, exception handling, and AOP configuration.
This article provides a systematic summary of Spring's core concepts—including IoC, AOP, bean configuration via XML and annotations, dependency injection mechanisms, transaction management, and web integration—offering Java developers a clear guide to effectively using the framework in real-world projects.
The article critiques badly written Spring controller and service code, explains how poor coding habits cause maintenance headaches, and demonstrates a cleaner, AOP‑based approach that reduces boilerplate and improves code quality for backend Java applications.
Qunar built a fault‑injection platform that dynamically injects runtime errors into its densely coupled backend services, enabling verification of degradation and circuit‑breaker strategies, with a four‑part architecture comprising a web UI, deployment system, command server, and Java agents using Instrumentation‑API for bytecode weaving.
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 describes the motivation, architecture, and implementation details of a fault‑injection platform that uses Java Instrumentation and dynamic bytecode weaving to validate high‑availability strategies, isolate failures, and support zero‑cost, runtime fault injection for complex distributed backend services.
This article provides a comprehensive overview of the Spring Framework, covering its version history, core features, dependency injection, bean definitions and scopes, annotation‑based configuration, data‑access support, aspect‑oriented programming, and the MVC request‑handling workflow, all illustrated with code examples.
The Meituan Android team built an automated, non‑intrusive page‑speed plugin that injects SDK calls at compile time via a Gradle Transform, measures cold‑start, first render, network request and second render for Activities and Fragments—including ViewPager lazy loading—fetches real‑time config from a server and reports metrics to their monitoring platform.
