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.
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.
The Meituan Waimai Android team cut crash rates from 0.3% to 0.02% by applying systematic crash governance, null‑pointer and OOM safeguards, AOP bytecode rewriting, dependency checks, modular architecture, and robust monitoring, offering a comprehensive blueprint for other Android teams to improve stability.
The article introduces a Java‑based log instrumentation tool that leverages AOP and the Javassist library to transparently capture interface input, output, and performance metrics, enabling richer test case generation, mock creation, and long‑term performance monitoring for backend services.
This article examines the challenges of traditional code‑based event tracking in iOS, compares code, visual, and no‑tracking approaches, and presents a visual‑tracking solution that uses AOP, unique identifiers, data‑carrying protocols, and version management to improve automation and maintainability.
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 purpose of using a framework, introduces Spring's core concepts of container, inversion of control, and aspect‑oriented programming, and demonstrates them through a Java banking report example with complete code, XML configuration, and annotation‑based AOP to achieve loose coupling and modularity.
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 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 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 provides a detailed English-language overview of the Spring Framework, covering its lightweight nature, IoC container, AOP support, core modules, bean lifecycle, configuration methods, annotations, transaction management, and Spring MVC architecture in a concise yet thorough manner.
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 tutorial explains the fundamentals of Spring AOP, introduces key terminology and pointcut expressions, demonstrates how to configure various advice types, and provides a complete Spring Boot example that uses an aspect to automatically record web request logs with minimal code changes.
This article explains the concept of scalability for web interactive systems, distinguishes platform and module scalability, and demonstrates how Aspect‑Oriented Programming can be used to create flexible, maintainable platform adaptations with concrete NEJ framework examples.
This article introduces Aspect‑Oriented Programming (AOP), explains its core concepts such as aspects, join points, advice, pointcuts, and weaving, outlines common advice types, lists typical cross‑cutting concerns, and demonstrates how AOP can replace repetitive permission checks with declarative annotations, improving modularity and maintainability.
The article presents a comprehensive approach to solving crash and performance issues in large‑scale mobile applications by reconstructing user interaction traces through a no‑track analytics platform, compile‑time AOP instrumentation, and unified data aggregation, ultimately improving debugging efficiency and reducing operational overhead.
The article shares practical experiences from large‑scale mobile client development, covering user crash scenarios, non‑intrusive data collection, AOP‑based interaction and network monitoring, performance instrumentation, and data aggregation techniques to improve debugging efficiency and operational reliability.
This article explains the concept of scalability in web interactive systems, distinguishes platform and module scalability, classifies browser and hybrid platforms, and demonstrates how Aspect‑Oriented Programming can cleanly separate standard business logic from platform‑specific adaptations with practical code examples.
A multi‑person technical discussion explores the reasons behind low cache hit rates, examines memcached LRU mechanisms, proposes AOP‑based caching strategies, and shares practical solutions such as proactive cache invalidation, lock‑based stampede protection, and workload‑aware configuration for backend systems.
This article explains key Java concepts such as compile‑time constant folding, the distinction between compile‑time and runtime calculations, method overloading versus overriding, generics type erasure, annotations, exception handling, and aspect‑oriented programming, while illustrating each topic with clear code examples.
This comprehensive guide explains what Spring is, its advantages, core modules, container architecture, bean factories, dependency injection types, bean scopes, lifecycle, AOP concepts, MVC framework, data access support, and transaction management, providing a solid foundation for Java backend development.
This article explains how to design a robust, zero‑intrusion data fallback component for high‑traffic web services using Nginx, Lua, and AOP principles, covering problem definition, architectural options, detailed execution steps, configuration snippets, storage choices, and performance monitoring.
The article explains how to design clean, decoupled system architectures by isolating concerns, using AOP, dependency injection, factory methods, and DSLs, while illustrating concepts with city‑building analogies and Java code examples.
This article provides a comprehensive collection of 69 Spring interview questions and answers, covering core concepts such as the framework overview, benefits, modules, IoC container, bean scopes, dependency injection, AOP, annotations, JDBC template, DAO support, transaction management, and MVC architecture.
This article provides a comprehensive overview of the Spring framework, covering its low‑invasion design, IoC container, dependency injection types, bean scopes, autowiring options, bean creation methods, post‑processors, zero‑configuration annotations, and AOP support with AspectJ, supplemented by practical code examples.
This article introduces the Spring framework, explaining its purpose as a lightweight Java SE/EE development platform, detailing the many features it provides such as IoC, AOP, transaction management, web integration, and outlining why developers choose Spring and how to effectively learn it.
An in‑depth look at Alipay Wallet’s mobile client monitoring system, detailing strategies for traffic and power optimization, comprehensive diagnostics, dynamic upgrades, AOP‑based instrumentation, and practical techniques for reducing data usage and battery drain on resource‑constrained Android devices.
The article presents Liu Fukang’s technical sharing on building a comprehensive monitoring system for the Alipay Wallet mobile client, detailing resource constraints, AOP‑based diagnostics, dynamic upgrades, and specific strategies for reducing power consumption and network traffic.
This article explains how aspect‑oriented programming can be applied to a backend system by separating cross‑cutting concerns such as request encryption, authentication, and permission handling using Sinatra extensions and Nginx Lua scripts, resulting in a modular, low‑coupling architecture.
This article explains how to apply aspect‑oriented programming principles to a Ruby‑based API service by extracting cross‑cutting concerns such as request encryption, authentication, and permission checks into Nginx Lua middleware, enabling low‑coupling, scalable backend modules.
This article explains why the view layer is the most critical part of an iOS app’s architecture, outlines common pitfalls, proposes a clear code‑structure convention, discusses layout tools, and advises when to use storyboards, nibs, or pure code, while also recommending AOP over inheritance for shared controller behavior.
This article explains how to build a highly configurable, extensible, and maintainable embedded process flow by leveraging Spring AOP and AspectJ to create a lightweight alternative to heavyweight BPM engines, detailing the architecture, design, code examples, and a purchase‑item use case.
This comprehensive guide lists and explains over seventy common Spring framework interview questions, covering core concepts, modules, IoC, AOP, bean scopes, configuration styles, MVC, data access, transaction management, and annotation-based programming to help Java developers prepare effectively.
