BestHub
Sign in
Tagged articles

AOP

621 articles · Page 6 of 7
Code Ape Tech Column
Code Ape Tech Column
Dec 7, 2020 · Backend Development

Unlock Spring’s Power: 9 Design Patterns Every Java Developer Should Master

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.

AOPBackend DevelopmentDependency Injection
0 likes · 16 min read
Unlock Spring’s Power: 9 Design Patterns Every Java Developer Should Master
Architect
Architect
Dec 6, 2020 · Backend Development

Do Service Layers Need Interfaces? A Critical Discussion on Spring‑Based Projects

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.

AOPDependency InjectionInterface
0 likes · 7 min read
Do Service Layers Need Interfaces? A Critical Discussion on Spring‑Based Projects
Programmer DD
Programmer DD
Dec 5, 2020 · Backend Development

Mastering Spring Retry: Deep Dive into Retry and Back‑off Strategies

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.

AOPBackoffJava
0 likes · 20 min read
Mastering Spring Retry: Deep Dive into Retry and Back‑off Strategies
Top Architect
Top Architect
Dec 2, 2020 · Backend Development

Understanding MyBatis Plugins: Mechanisms, Use Cases, and Design Patterns

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.

AOPJavaMyBatis
0 likes · 9 min read
Understanding MyBatis Plugins: Mechanisms, Use Cases, and Design Patterns
Top Architect
Top Architect
Nov 30, 2020 · Backend Development

Understanding AOP in Spring: Concepts, Annotations, and Practical Examples

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.

AOPJavaSpring
0 likes · 19 min read
Understanding AOP in Spring: Concepts, Annotations, and Practical Examples
IT Xianyu
IT Xianyu
Nov 26, 2020 · Backend Development

Spring Interview Questions and Answers: IoC, AOP, Bean Lifecycle, Circular Dependency, Transactions, Annotations, MVC Flow and Thread Concurrency

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.

AOPBean Lifecycledependency-injection
0 likes · 12 min read
Spring Interview Questions and Answers: IoC, AOP, Bean Lifecycle, Circular Dependency, Transactions, Annotations, MVC Flow and Thread Concurrency
GrowingIO Tech Team
GrowingIO Tech Team
Nov 26, 2020 · Mobile Development

Mastering iOS AOP: From Method Swizzling to Fishhook and Beyond

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.

AOPMethod SwizzlingMobile Development
0 likes · 21 min read
Mastering iOS AOP: From Method Swizzling to Fishhook and Beyond
Top Architect
Top Architect
Nov 1, 2020 · Backend Development

Implementing Operation and Exception Logging with Spring Boot AOP

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.

AOPJavaLogging
0 likes · 11 min read
Implementing Operation and Exception Logging with Spring Boot AOP
Java Architect Essentials
Java Architect Essentials
Oct 28, 2020 · Backend Development

Implementing Read/Write Splitting with Spring's AbstractRoutingDataSource

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.

AOPDataSource RoutingMyBatis
0 likes · 17 min read
Implementing Read/Write Splitting with Spring's AbstractRoutingDataSource
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 20, 2020 · Backend Development

Programmatic vs Declarative Transactions in Spring: Advantages, Pitfalls, and Recommendations

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.

AOPDeclarative TransactionJava
0 likes · 8 min read
Programmatic vs Declarative Transactions in Spring: Advantages, Pitfalls, and Recommendations
Top Architect
Top Architect
Sep 6, 2020 · Backend Development

Understanding Spring @Transactional: Common Pitfalls and Proper Usage

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.

@TransactionalAOPAnnotation
0 likes · 8 min read
Understanding Spring @Transactional: Common Pitfalls and Proper Usage
Top Architect
Top Architect
Aug 30, 2020 · Backend Development

Using Spring Cache with Redis for Efficient Data Caching in Java Applications

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.

AOPCacheJava
0 likes · 12 min read
Using Spring Cache with Redis for Efficient Data Caching in Java Applications
Su San Talks Tech
Su San Talks Tech
Aug 27, 2020 · Backend Development

Unveiling Spring Transaction Mechanics: From Annotations to Core Interceptors

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.

AOPSpringTransaction
0 likes · 32 min read
Unveiling Spring Transaction Mechanics: From Annotations to Core Interceptors
macrozheng
macrozheng
Aug 21, 2020 · Backend Development

Common Spring @Transactional Pitfalls and How to Fix Them

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.

@TransactionalAOPRollback
0 likes · 13 min read
Common Spring @Transactional Pitfalls and How to Fix Them
Programmer DD
Programmer DD
Aug 19, 2020 · Backend Development

Unlocking Spring’s @Async: Deep Dive into Mechanics, Pitfalls, and Solutions

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.

AOPDependencyInjectionSpring
0 likes · 15 min read
Unlocking Spring’s @Async: Deep Dive into Mechanics, Pitfalls, and Solutions
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 16, 2020 · Mobile Development

Boost iOS AOP Performance: Inside Alibaba’s Lokie Framework

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.

AOPC#iOS
0 likes · 15 min read
Boost iOS AOP Performance: Inside Alibaba’s Lokie Framework
Architect's Tech Stack
Architect's Tech Stack
Aug 9, 2020 · Backend Development

Creating a Spring Boot Starter to Log Method Execution Time

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.

AOPSpring BootStarter
0 likes · 9 min read
Creating a Spring Boot Starter to Log Method Execution Time
Programmer DD
Programmer DD
Aug 8, 2020 · Backend Development

How to Build a Custom Spring Boot Starter that Logs Method Execution Time

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.

AOPCustom StarterSpring Boot
0 likes · 9 min read
How to Build a Custom Spring Boot Starter that Logs Method Execution Time
macrozheng
macrozheng
Jul 16, 2020 · Backend Development

Master Spring’s Circular Dependency: How the Three‑Level Cache Resolves It

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.

AOPBean LifecycleThree-level Cache
0 likes · 19 min read
Master Spring’s Circular Dependency: How the Three‑Level Cache Resolves It
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 13, 2020 · Fundamentals

Understanding the Proxy Design Pattern in Java: Static, Dynamic, and CGLIB Implementations

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.

AOPCGLIBDynamic Proxy
0 likes · 14 min read
Understanding the Proxy Design Pattern in Java: Static, Dynamic, and CGLIB Implementations
JD Tech Talk
JD Tech Talk
Jul 9, 2020 · Backend Development

Designing a Java Agent for Performance Profiling and Monitoring in Java Applications

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.

AOPJava Agentbytecode instrumentation
0 likes · 12 min read
Designing a Java Agent for Performance Profiling and Monitoring in Java Applications
Top Architect
Top Architect
Jun 3, 2020 · Backend Development

Understanding MyBatis Plugins: Use Cases, Mechanism, and Development Guide

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.

AOPJavaPlugin
0 likes · 8 min read
Understanding MyBatis Plugins: Use Cases, Mechanism, and Development Guide
Architect's Tech Stack
Architect's Tech Stack
Jun 1, 2020 · Backend Development

Fundamentals and Advanced Concepts of Spring Transaction Management

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.

AOPSpringTransaction
0 likes · 14 min read
Fundamentals and Advanced Concepts of Spring Transaction Management
Java Backend Technology
Java Backend Technology
May 26, 2020 · Backend Development

How to Build Scalable Operation Logs: AOP vs Binlog Implementation

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.

AOPBinlogLogging
0 likes · 10 min read
How to Build Scalable Operation Logs: AOP vs Binlog Implementation
Architecture Digest
Architecture Digest
May 13, 2020 · Backend Development

Understanding MyBatis Plugins: Use Cases, Mechanism, and Development Guide

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.

AOPJavaMyBatis
0 likes · 8 min read
Understanding MyBatis Plugins: Use Cases, Mechanism, and Development Guide
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 5, 2020 · Backend Development

How Spring’s @Transactional Works Under the Hood and Build Your Own Transaction Annotation

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.

AOPAnnotationJDBC
0 likes · 15 min read
How Spring’s @Transactional Works Under the Hood and Build Your Own Transaction Annotation
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 28, 2020 · Backend Development

Master Rate Limiting: Algorithms, Guava RateLimiter, and Java Implementation

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.

AOPGuavarate limiting
0 likes · 10 min read
Master Rate Limiting: Algorithms, Guava RateLimiter, and Java Implementation
macrozheng
macrozheng
Mar 27, 2020 · Backend Development

Why @Transactional Fails: 6 Common Pitfalls and How to Fix Them

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.

@TransactionalAOPJava
0 likes · 12 min read
Why @Transactional Fails: 6 Common Pitfalls and How to Fix Them
macrozheng
macrozheng
Mar 23, 2020 · Backend Development

Boost Spring Security Performance with Redis Caching and AOP Exception Handling

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.

AOPBackend DevelopmentCaching
0 likes · 13 min read
Boost Spring Security Performance with Redis Caching and AOP Exception Handling
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 22, 2020 · Backend Development

Common Reasons Why Spring @Transactional May Not Work

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.

AOPJavaSpring
0 likes · 4 min read
Common Reasons Why Spring @Transactional May Not Work
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 9, 2020 · Backend Development

How Spring Enables Asynchronous Execution with @EnableAsync – Deep Dive

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.

AOPBackend DevelopmentEnableAsync
0 likes · 18 min read
How Spring Enables Asynchronous Execution with @EnableAsync – Deep Dive
Java Captain
Java Captain
Mar 1, 2020 · Backend Development

Summary of Design Patterns Used in the Spring Framework

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.

AOPBeanFactoryDependency Injection
0 likes · 14 min read
Summary of Design Patterns Used in the Spring Framework
Architecture Digest
Architecture Digest
Feb 29, 2020 · Backend Development

Implementing Read‑Write Splitting in Spring Boot with AbstractRoutingDataSource

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.

AOPDataSource RoutingMyBatis
0 likes · 15 min read
Implementing Read‑Write Splitting in Spring Boot with AbstractRoutingDataSource
58 Tech
58 Tech
Feb 18, 2020 · Backend Development

Design and Implementation of an Aspect‑Oriented Plugin Framework at 58 Real Estate

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.

AOPJavaPlugin Framework
0 likes · 13 min read
Design and Implementation of an Aspect‑Oriented Plugin Framework at 58 Real Estate
Java Captain
Java Captain
Dec 29, 2019 · Backend Development

Comprehensive Overview of the Spring Framework and Its Ecosystem

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.

AOPBackend DevelopmentDependency Injection
0 likes · 18 min read
Comprehensive Overview of the Spring Framework and Its Ecosystem
Programmer DD
Programmer DD
Dec 20, 2019 · Backend Development

Mastering Java Annotations: From Basics to Custom AOP Integration

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.

AOPJavaSpring Boot
0 likes · 8 min read
Mastering Java Annotations: From Basics to Custom AOP Integration
Programmer DD
Programmer DD
Nov 22, 2019 · Backend Development

Mastering Spring: A Comprehensive Guide to Java’s Leading Backend Framework

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.

AOPBackend DevelopmentDependency Injection
0 likes · 19 min read
Mastering Spring: A Comprehensive Guide to Java’s Leading Backend Framework
vivo Internet Technology
vivo Internet Technology
Jul 29, 2019 · Mobile Development

ARetrofit: Android Component Communication Routing Framework

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.

AOPAndroidAnnotation Processor
0 likes · 13 min read
ARetrofit: Android Component Communication Routing Framework
macrozheng
macrozheng
Jun 27, 2019 · Backend Development

How to Implement Unified Logging with AOP in a Spring MVC Project

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.

AOPJavaLogging
0 likes · 10 min read
How to Implement Unified Logging with AOP in a Spring MVC Project
Xianyu Technology
Xianyu Technology
Jun 18, 2019 · Mobile Development

AspectD – A Dart AOP Framework for Flutter

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.

AOPAspectDDART
0 likes · 13 min read
AspectD – A Dart AOP Framework for Flutter
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 17, 2019 · Backend Development

Implementing AOP Logging in a Spring Boot Application

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.

AOPAspectJJava
0 likes · 4 min read
Implementing AOP Logging in a Spring Boot Application
Sohu Tech Products
Sohu Tech Products
May 29, 2019 · Mobile Development

Introduction to AspectJ for Android Development and Gradle Plugin Integration

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.

AOPAndroidAspectJ
0 likes · 16 min read
Introduction to AspectJ for Android Development and Gradle Plugin Integration
Java Captain
Java Captain
May 29, 2019 · Backend Development

Common Design Patterns Used in the Spring Framework

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.

AOPDependency InjectionFactory
0 likes · 17 min read
Common Design Patterns Used in the Spring Framework
NetEase Media Technology Team
NetEase Media Technology Team
May 20, 2019 · Mobile Development

Aspect-Oriented Programming (AOP) and Its Application in Android Client Development

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.

AOPAndroidAspectJ
0 likes · 14 min read
Aspect-Oriented Programming (AOP) and Its Application in Android Client Development
Qunar Tech Salon
Qunar Tech Salon
May 9, 2019 · Mobile Development

Deep Dive into ASM for Android Bytecode Instrumentation and OkHttp Monitoring

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.

AOPASMAndroid
0 likes · 13 min read
Deep Dive into ASM for Android Bytecode Instrumentation and OkHttp Monitoring
Java Captain
Java Captain
May 6, 2019 · Backend Development

Introduction to Spring Boot with Code Examples

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.

AOPBackend DevelopmentJava
0 likes · 12 min read
Introduction to Spring Boot with Code Examples
Mafengwo Technology
Mafengwo Technology
Apr 18, 2019 · Frontend Development

How to Build an Efficient Front‑End Monitoring Data Collection System

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.

AOPJavaScriptMonitoring
0 likes · 14 min read
How to Build an Efficient Front‑End Monitoring Data Collection System
Java Captain
Java Captain
Apr 6, 2019 · Backend Development

Understanding Spring Transaction Management and AOP Mechanism

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.

AOPBackend DevelopmentDeclarative Transactions
0 likes · 9 min read
Understanding Spring Transaction Management and AOP Mechanism
Didi Tech
Didi Tech
Apr 4, 2019 · Mobile Development

DroidAssist – A Lightweight, Configuration‑Based Java Bytecode Manipulation Framework for Android

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.

AOPAndroidDroidAssist
0 likes · 8 min read
DroidAssist – A Lightweight, Configuration‑Based Java Bytecode Manipulation Framework for Android
58 Tech
58 Tech
Jan 23, 2019 · Mobile Development

Implementing AOP‑Based Unified Processing in Android via Gradle Transform Plugins

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.

AOPASMAndroid
0 likes · 8 min read
Implementing AOP‑Based Unified Processing in Android via Gradle Transform Plugins
Senior Brother's Insights
Senior Brother's Insights
Jan 3, 2019 · Backend Development

Mastering Spring Framework: Core Concepts, Modules, and Practical Guides

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.

AOPDependency InjectionIOC
0 likes · 26 min read
Mastering Spring Framework: Core Concepts, Modules, and Practical Guides
Qunar Tech Salon
Qunar Tech Salon
Nov 27, 2018 · Backend Development

Implementing AOP Method Timing with Java Instrumentation and ASM

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.

AOPASMJVMTI
0 likes · 16 min read
Implementing AOP Method Timing with Java Instrumentation and ASM
Baidu Intelligent Testing
Baidu Intelligent Testing
Nov 6, 2018 · Fundamentals

AOP‑Based System‑Level Test Decoupling: Design, Implementation, and Benefits

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.

AOPAutomationJava
0 likes · 15 min read
AOP‑Based System‑Level Test Decoupling: Design, Implementation, and Benefits
Programmer DD
Programmer DD
Oct 27, 2018 · Backend Development

Why Spring Framework Dominates Java Development: Key Features Explained

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.

AOPBackend DevelopmentDependency Injection
0 likes · 10 min read
Why Spring Framework Dominates Java Development: Key Features Explained
Java Captain
Java Captain
Oct 15, 2018 · Backend Development

Implementing AOP in Java Controllers: Guidelines and Code Example

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.

AOPBackend DevelopmentJava
0 likes · 5 min read
Implementing AOP in Java Controllers: Guidelines and Code Example
Java Captain
Java Captain
Oct 7, 2018 · Backend Development

A Comprehensive Overview of Spring Framework Concepts and Practices

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.

AOPBean ConfigurationDependency Injection
0 likes · 9 min read
A Comprehensive Overview of Spring Framework Concepts and Practices
Java Captain
Java Captain
Sep 19, 2018 · Backend Development

Refactoring Poor Spring MVC Code: Lessons on Clean Backend Development

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.

AOPJavaSpring
0 likes · 6 min read
Refactoring Poor Spring MVC Code: Lessons on Clean Backend Development
dbaplus Community
dbaplus Community
Sep 11, 2018 · Operations

How Qunar’s Fault Injection Platform Ensures High‑Availability in Complex Backend Systems

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.

AOPFault InjectionJava Instrumentation
0 likes · 13 min read
How Qunar’s Fault Injection Platform Ensures High‑Availability in Complex Backend Systems
Java Backend Technology
Java Backend Technology
Sep 10, 2018 · Backend Development

JDK vs CGLib in Spring AOP: Which Proxy Is Faster?

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.

AOPCGLIBDynamic Proxy
0 likes · 7 min read
JDK vs CGLib in Spring AOP: Which Proxy Is Faster?
Qunar Tech Salon
Qunar Tech Salon
Aug 8, 2018 · Backend Development

Design and Implementation of a Fault Injection Platform for High‑Availability Backend Systems

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.

AOPFault InjectionHigh Availability
0 likes · 12 min read
Design and Implementation of a Fault Injection Platform for High‑Availability Backend Systems
Java Captain
Java Captain
Aug 5, 2018 · Backend Development

Spring Framework Overview: Core Concepts, IoC, Beans, AOP, MVC, and Configuration

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.

AOPBeansDependency Injection
0 likes · 20 min read
Spring Framework Overview: Core Concepts, IoC, Beans, AOP, MVC, and Configuration
Meituan Technology Team
Meituan Technology Team
Jul 12, 2018 · Mobile Development

Automated Page Speed Measurement Plugin for Android Apps

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.

AOPAndroidInstrumentation
0 likes · 22 min read
Automated Page Speed Measurement Plugin for Android Apps
Java Captain
Java Captain
Jun 19, 2018 · Fundamentals

Understanding the Proxy Pattern: Static vs Dynamic Proxy and AOP in Java

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.

AOPDynamic ProxyJava
0 likes · 12 min read
Understanding the Proxy Pattern: Static vs Dynamic Proxy and AOP in Java
Meituan Technology Team
Meituan Technology Team
Jun 14, 2018 · Mobile Development

Practices for Reducing Crash Rate in Meituan Waimai Android App

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.

AOPAndroidcrash management
0 likes · 30 min read
Practices for Reducing Crash Rate in Meituan Waimai Android App
JD Retail Technology
JD Retail Technology
May 11, 2018 · Mobile Development

Exploring Automated Visual Event Tracking (埋点) for iOS Applications

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.

AOPAutomationevent tracking
0 likes · 18 min read
Exploring Automated Visual Event Tracking (埋点) for iOS Applications
Java Captain
Java Captain
Apr 30, 2018 · Backend Development

Spring AOP Tutorial: Concepts, XML Configuration, and Sample Implementation

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.

AOPCGLIBJava
0 likes · 14 min read
Spring AOP Tutorial: Concepts, XML Configuration, and Sample Implementation
Java Captain
Java Captain
Apr 25, 2018 · Backend Development

Understanding Spring Framework: IoC, AOP, and Modular Design with Java Example

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.

AOPDependency InjectionIOC
0 likes · 17 min read
Understanding Spring Framework: IoC, AOP, and Modular Design with Java Example
Java Captain
Java Captain
Apr 11, 2018 · Backend Development

Step‑by‑Step Guide to Spring AOP: Proxy Patterns, Static and Dynamic Proxies, and Practical Implementation

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.

AOPCGLIBDynamic Proxy
0 likes · 12 min read
Step‑by‑Step Guide to Spring AOP: Proxy Patterns, Static and Dynamic Proxies, and Practical Implementation
Java Backend Technology
Java Backend Technology
Dec 25, 2017 · Backend Development

Why Spring Needs AOP: Solving Repetitive Code with Dynamic Proxies

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.

AOPDynamic ProxyJava
0 likes · 9 min read
Why Spring Needs AOP: Solving Repetitive Code with Dynamic Proxies
Java Captain
Java Captain
Sep 12, 2017 · Backend Development

Understanding Java Dynamic Proxy Mechanism

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.

AOPDynamic ProxyInvocationHandler
0 likes · 11 min read
Understanding Java Dynamic Proxy Mechanism