Skip to content
Tagged articles

AOP

500 articles · Page 5 of 5
Top Architect
Top Architect
Jun 12, 2022 · Backend Development

How Spring Resolves Circular Dependencies Using Early Exposure and a Three‑Level Cache

This article explains Spring's circular‑dependency solution, detailing the early‑exposure mechanism, the three‑level cache (singletonObjects, earlySingletonObjects, singletonFactories), how BeanPostProcessors and AOP proxies interact during bean creation, and why the third‑level cache is essential for correct bean wiring.

AOPBeanPostProcessorCircular Dependency
0 likes · 14 min read
How Spring Resolves Circular Dependencies Using Early Exposure and a Three‑Level Cache
Top Architect
Top Architect
May 21, 2022 · Backend Development

Understanding Spring Assert and Common Utility Classes in Java

This article introduces Spring's Assert utilities, explains the purpose and usage of various Spring‑provided helper classes such as ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, ReflectionUtils, and AOP utilities, and provides code snippets illustrating their typical methods for validation, conversion, and reflection tasks in Java backend development.

AOPJavaReflection
0 likes · 13 min read
Understanding Spring Assert and Common Utility Classes in Java
Sanyou's Java Diary
Sanyou's Java Diary
May 19, 2022 · Backend Development

Mastering Spring: Core Concepts, Modules, Annotations & Advanced Features

This comprehensive guide walks through Spring’s fundamentals—including IoC, DI, core modules, common annotations, AOP concepts, transaction management, MVC workflow, and Spring Boot auto‑configuration—while also covering advanced topics such as bean lifecycle, circular dependencies, proxy mechanisms, and an introduction to Spring Cloud.

AOPIoCMVC
0 likes · 54 min read
Mastering Spring: Core Concepts, Modules, Annotations & Advanced Features
DaTaobao Tech
DaTaobao Tech
May 19, 2022 · Backend Development

Understanding Proxy Pattern and Spring Transaction Management

The article explains static and dynamic proxy patterns, demonstrates their Java implementations, and shows how Spring’s transaction management relies on dynamic AOP proxies—highlighting that internal calls within the same class bypass the proxy, preventing @Transactional methods from starting or rolling back transactions.

AOPJavaSpring Transaction
0 likes · 21 min read
Understanding Proxy Pattern and Spring Transaction Management
macrozheng
macrozheng
May 18, 2022 · Backend Development

Master Spring’s Assert and Utility Classes: Essential Tips & Code Samples

This guide explains Spring’s Assert utilities and a comprehensive set of core helper classes—including ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, AopUtils, and AopContext—detailing their purpose, typical use cases, and providing concise code examples for each method.

AOPJavaSpring
0 likes · 14 min read
Master Spring’s Assert and Utility Classes: Essential Tips & Code Samples
Code Ape Tech Column
Code Ape Tech Column
May 11, 2022 · Backend Development

Implementing Two-Level Cache with Caffeine and Redis in Spring Boot

This article explains the design and implementation of a two‑level caching architecture using local Caffeine cache as L1 and remote Redis as L2 in Spring Boot, covering manual cache handling, annotation‑based management with Spring Cache, and a custom annotation with AOP to minimize code intrusion.

AOPCache AnnotationCaffeine
0 likes · 17 min read
Implementing Two-Level Cache with Caffeine and Redis in Spring Boot
Programmer DD
Programmer DD
May 5, 2022 · Backend Development

Master Spring Retry: Using @Retryable for Elegant Failure Handling

This guide explains how Spring Boot’s @Retryable annotation enables elegant, annotation‑driven retry logic, covering dependency setup, enabling retry, method annotation with configurable parameters, recovery handling via @Recover, and important AOP‑related considerations to avoid common pitfalls.

@RetryableAOPException Handling
0 likes · 7 min read
Master Spring Retry: Using @Retryable for Elegant Failure Handling
Architecture Digest
Architecture Digest
Apr 26, 2022 · Backend Development

Implementing Request Logging with Spring AOP and Annotations

This article demonstrates how to create a request‑logging aspect in Spring Boot using AOP annotations, shows code for pointcuts, advices, high‑concurrency optimizations, exception handling, and trace‑ID propagation, and explains the underlying concepts and practical tips.

AOPAspectJJava
0 likes · 16 min read
Implementing Request Logging with Spring AOP and Annotations
Java Tech Enthusiast
Java Tech Enthusiast
Apr 23, 2022 · Backend Development

Spring AOP Tutorial with Code Examples

This Spring AOP tutorial explains how to modularize cross‑cutting concerns such as timing by defining an aspect with @Before, @After, @AfterReturning, @AfterThrowing and @Around advice, demonstrates refactoring a calculation service, and compares Spring’s proxy mechanisms to a custom JDK dynamic proxy implementation.

AOPAspectJDynamicProxy
0 likes · 17 min read
Spring AOP Tutorial with Code Examples
Top Architect
Top Architect
Apr 21, 2022 · Backend Development

Understanding AOP: Joinpoint Design, Advice, and Weaving in Java

This article explains the background, concepts, and implementation details of Aspect‑Oriented Programming in Java, covering joinpoint interface design, advice abstraction, static and dynamic weaving, and how Spring AOP applies these principles with illustrative code and diagrams.

AOPAdviceAspect-Oriented Programming
0 likes · 9 min read
Understanding AOP: Joinpoint Design, Advice, and Weaving in Java
Java Backend Technology
Java Backend Technology
Apr 16, 2022 · Backend Development

Why @Transactional Sometimes Fails in Spring and How to Fix It

This article explains three common situations where Spring's @Transactional annotation becomes ineffective—non‑public methods, internal self‑calls, and swallowed exceptions—detailing the underlying proxy mechanism, code examples, test results, and practical workarounds to ensure proper transaction management.

@TransactionalAOPException Handling
0 likes · 12 min read
Why @Transactional Sometimes Fails in Spring and How to Fix It
Top Architect
Top Architect
Apr 15, 2022 · Backend Development

Implementing Request Logging with Spring AOP and TraceId

This article demonstrates how to create a Spring AOP request‑logging aspect that captures IP, URL, HTTP method, class method, parameters, results and execution time, and extends it with high‑concurrency handling, error logging, and TraceId propagation for better traceability.

AOPJavaLog4j2
0 likes · 13 min read
Implementing Request Logging with Spring AOP and TraceId
Python Programming Learning Circle
Python Programming Learning Circle
Apr 8, 2022 · Fundamentals

A Comprehensive Guide to Python Decorators and Aspect-Oriented Programming (AOP)

This article explains the concept of Aspect‑Oriented Programming (AOP) and demonstrates how Python decorators—both function‑based and class‑based—can be used to implement AOP features such as pre‑ and post‑execution logic, handling arguments, preserving metadata with functools.wraps, and stacking multiple decorators.

AOPAspect-Oriented ProgrammingPython
0 likes · 18 min read
A Comprehensive Guide to Python Decorators and Aspect-Oriented Programming (AOP)
Java Backend Technology
Java Backend Technology
Apr 3, 2022 · Backend Development

Why @Transactional Fails in Spring and How to Fix It

This article explains three common reasons why the @Transactional annotation may not work in Spring—non‑public methods, self‑invocation, and catching exceptions—provides code examples for each case, and details the underlying proxy and transaction management mechanisms to help developers resolve the issues.

@TransactionalAOPDatabase Transaction
0 likes · 11 min read
Why @Transactional Fails in Spring and How to Fix It
Top Architect
Top Architect
Mar 21, 2022 · Backend Development

How Spring Resolves Bean Circular Dependencies with a Three‑Level Cache

This article explains Spring's bean lifecycle, the three‑level cache mechanism (singletonObjects, earlySingletonObjects, singletonFactories) used to break circular dependencies, the role of Aware interfaces and BeanPostProcessor, and why a second‑level cache is essential when AOP proxies are involved.

AOPBean LifecycleCircular Dependency
0 likes · 9 min read
How Spring Resolves Bean Circular Dependencies with a Three‑Level Cache
Top Architect
Top Architect
Mar 20, 2022 · Backend Development

Understanding Spring's @Transactional Annotation and Its AOP Implementation

This article explains how Spring's @Transactional annotation works by leveraging AOP and dynamic proxies, detailing the bean post‑processor, pointcut definition, proxy creation, interceptor chain, TransactionInterceptor logic, and the transaction commit/rollback process with illustrative code snippets and diagrams.

@TransactionalAOPJava
0 likes · 9 min read
Understanding Spring's @Transactional Annotation and Its AOP Implementation
Architecture Digest
Architecture Digest
Mar 16, 2022 · Backend Development

Spring Boot Super Scheduled: Dynamic Management and Enhancement of @Scheduled Tasks

This article introduces a Spring Boot starter that enhances native @Scheduled tasks with dynamic management capabilities, explains how to integrate the dependency, and details the underlying implementation using post‑processors, application runners, custom managers, and CGLIB‑based proxy chains to modify scheduling parameters at runtime.

AOPCGLIBDynamic Management
0 likes · 14 min read
Spring Boot Super Scheduled: Dynamic Management and Enhancement of @Scheduled Tasks
Java High-Performance Architecture
Java High-Performance Architecture
Mar 1, 2022 · Backend Development

Unlocking Spring: Core Principles, Design Patterns, and IoC Explained

This comprehensive guide walks through Spring's lightweight Java framework, covering its core principles, key features, advantages and drawbacks, the design patterns it employs, core modules, IoC container mechanics, bean scopes, lifecycle, dependency injection techniques, and AOP fundamentals, all illustrated with diagrams and code snippets.

AOPIoCJava
0 likes · 48 min read
Unlocking Spring: Core Principles, Design Patterns, and IoC Explained
Java Captain
Java Captain
Feb 24, 2022 · Backend Development

How Spring Solves Bean Circular Dependencies Using a Three-Level Cache

This article explains how Spring's bean lifecycle and its three-level caching mechanism—singletonObjects, earlySingletonObjects, and singletonFactories—work together to resolve circular dependencies, especially when AOP proxies are involved, highlighting why a three‑cache approach is necessary.

AOPBean LifecycleCircular Dependency
0 likes · 9 min read
How Spring Solves Bean Circular Dependencies Using a Three-Level Cache
Java Backend Technology
Java Backend Technology
Feb 24, 2022 · Backend Development

Master Spring’s Core Utility Classes: Assertions, ObjectUtils, StringUtils, and More

This article provides a comprehensive overview of Spring Framework’s core utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—detailing their purpose and key method signatures for developers working on Java backend projects.

AOPJavaReflection
0 likes · 13 min read
Master Spring’s Core Utility Classes: Assertions, ObjectUtils, StringUtils, and More
Top Architect
Top Architect
Feb 16, 2022 · Backend Development

Understanding Spring AOP Annotations and Their Execution Order

This article explains the common Spring AOP annotations such as @Before, @After, @AfterReturning, @AfterThrowing and @Around, demonstrates how to set up a Spring Boot project, write an interface, implementation, aspect, and discusses execution order, multiple aspects, and proxy‑failure scenarios.

AOPAnnotationsAspectJ
0 likes · 8 min read
Understanding Spring AOP Annotations and Their Execution Order
Top Architect
Top Architect
Feb 14, 2022 · Backend Development

Common Spring Framework Utility Classes: Assertions, ObjectUtils, StringUtils, CollectionUtils, File/Resource IO, Reflection and AOP Helpers

This article presents a curated collection of Spring Framework utility classes—including assertion helpers, object/array/collection utilities, file and resource IO tools, as well as reflection and AOP utilities—providing ready‑to‑use methods that replace many custom helper functions in Java backend development.

AOPJavaReflection
0 likes · 13 min read
Common Spring Framework Utility Classes: Assertions, ObjectUtils, StringUtils, CollectionUtils, File/Resource IO, Reflection and AOP Helpers
Zhongtong Tech
Zhongtong Tech
Jan 10, 2022 · Backend Development

How ZTO Built a Unified Test Tool Platform to Boost Efficiency

This article describes how ZTO's testing team created a centralized test‑tool platform that integrates front‑end and back‑end services, standardizes tool access, tracks usage via AOP, supports data generation, order creation, tracking, MQ messaging, and other platform integrations to dramatically improve testing productivity.

AOPData GenerationMQ
0 likes · 11 min read
How ZTO Built a Unified Test Tool Platform to Boost Efficiency
Top Architect
Top Architect
Dec 23, 2021 · Backend Development

Implementing Custom Logging with Spring AOP and Annotations

This article explains how to create a custom logging solution in Spring by defining annotation-based AOP aspects, configuring pointcuts, handling various advice types, and persisting log details such as user, operation, parameters, and results into a database using Java code examples.

AOPAspectJCustom Annotation
0 likes · 14 min read
Implementing Custom Logging with Spring AOP and Annotations
Java Interview Crash Guide
Java Interview Crash Guide
Dec 21, 2021 · Backend Development

How to Implement Custom Logging with Spring AOP and Annotations

This guide explains how to create a custom Spring AOP logging solution by defining a @SystemCrmlog annotation, extracting its parameters via pointcuts, and persisting detailed log entries—including user, method, parameters, and execution results—to a database using aspect advice methods.

AOPCustom AnnotationJava
0 likes · 15 min read
How to Implement Custom Logging with Spring AOP and Annotations
Su San Talks Tech
Su San Talks Tech
Dec 15, 2021 · Backend Development

Top 18 Spring Interview Questions and Answers You Must Know

Explore a comprehensive list of 18 essential Spring interview questions covering design patterns, core modules, IoC, DI, AOP, proxy types, bean lifecycle, circular dependency resolution, transaction management, and Spring Boot auto‑configuration, complete with concise explanations and illustrative diagrams to help you ace your interview.

AOPBackendInterview
0 likes · 17 min read
Top 18 Spring Interview Questions and Answers You Must Know
Top Architect
Top Architect
Dec 11, 2021 · Backend Development

Proxy vs. Decorator Patterns and DIY Spring AOP Implementation in Java

This article explains the proxy and decorator design patterns using a coffee analogy, provides complete Java code examples for static and dynamic proxies, discusses their differences, and shows how to implement a Spring‑like AOP mechanism with JDK InvocationHandler and cglib, while also warning about their limitations.

AOPCGLIBDecorator
0 likes · 11 min read
Proxy vs. Decorator Patterns and DIY Spring AOP Implementation in Java
Sohu Tech Products
Sohu Tech Products
Dec 8, 2021 · Mobile Development

Understanding Android App Routing: Concepts, Requirements, and Implementation

This article explains the concept of routing in Android applications, discusses why third‑party routing frameworks are often needed for large, componentized apps, outlines the essential features of a routing framework, and details the implementation techniques such as annotation processing, AOP injection, and service routing with concrete code examples.

AOPARouterAndroid
0 likes · 14 min read
Understanding Android App Routing: Concepts, Requirements, and Implementation
TikTok Frontend Technology Team
TikTok Frontend Technology Team
Dec 3, 2021 · Backend Development

Designing a Microservice Node.js Framework Based on Koa

This article explores Koa’s core AOP‑based architecture, demonstrates minimal implementations using koa‑compose and Node.js http, and proposes a microservice‑oriented framework that extends Koa to support HTTP, Thrift, WebSocket and other services, complete with abstract server designs and example code.

AOPKoaNode.js
0 likes · 14 min read
Designing a Microservice Node.js Framework Based on Koa
Architect
Architect
Nov 29, 2021 · Backend Development

Common Scenarios Where Spring Transactions Fail and How to Fix Them

This article explains why Spring's @Transactional annotation can silently fail in many typical situations—such as incorrect method visibility, final methods, self‑invocation, unmanaged beans, multithreading, non‑transactional tables, missing configuration, wrong propagation or rollback settings, nested transaction behavior, and oversized transaction scopes—and provides practical solutions to ensure reliable transaction management.

AOPSpringexception-handling
0 likes · 16 min read
Common Scenarios Where Spring Transactions Fail and How to Fix Them
Programmer DD
Programmer DD
Nov 16, 2021 · Backend Development

Why @Transactional Might Fail in Spring and How to Fix It

This article explains common reasons why Spring's @Transactional annotation can become ineffective—such as self‑invocation, non‑public methods, multiple data sources, incorrect rollback settings, and unsupported database engines—and provides concrete code examples and solutions to ensure proper transaction management.

@TransactionalAOPBackend
0 likes · 7 min read
Why @Transactional Might Fail in Spring and How to Fix It
Top Architect
Top Architect
Nov 14, 2021 · Backend Development

Implementing a Request Logging Aspect with Spring AOP

This article demonstrates how to create a Spring AOP request‑logging aspect that captures request details, parameters, results, execution time, and error information, and discusses enhancements for high‑concurrency environments by aggregating log data into a single JSON object.

AOPAspectJJava
0 likes · 12 min read
Implementing a Request Logging Aspect with Spring AOP
Code Ape Tech Column
Code Ape Tech Column
Nov 13, 2021 · Backend Development

Spring Framework Interview Questions and Answers Overview

This article compiles a comprehensive set of Spring interview questions covering design patterns, core modules, IoC, DI, AOP, proxy mechanisms, bean lifecycle, circular dependency resolution, transaction isolation and propagation, as well as Spring Boot auto‑configuration principles, providing concise explanations for each topic.

AOPIoCJava
0 likes · 16 min read
Spring Framework Interview Questions and Answers Overview
macrozheng
macrozheng
Nov 11, 2021 · Backend Development

Mastering Spring Boot Read/Write Splitting with Custom Routing DataSource

This tutorial explains how to implement read/write splitting in Spring Boot by configuring multiple data sources, creating a custom AbstractRoutingDataSource, and using AOP to dynamically route queries to master or slave databases based on method patterns and annotations.

AOPMyBatisRouting DataSource
0 likes · 17 min read
Mastering Spring Boot Read/Write Splitting with Custom Routing DataSource
21CTO
21CTO
Nov 9, 2021 · Backend Development

Mastering Elegant Operation Log Design with AOP and SpEL in Java

This article explains how to implement clean, decoupled operation logs in Java applications using AOP, SpEL, custom annotations, and dynamic templates, covering use cases, implementation methods, code examples, parsing logic, context handling, and integration with Spring Boot.

AOPJavaLogging
0 likes · 27 min read
Mastering Elegant Operation Log Design with AOP and SpEL in Java
dbaplus Community
dbaplus Community
Nov 8, 2021 · Backend Development

How to Elegantly Implement Decoupled Operation Logging with AOP in Spring

This article explains the difference between system and operation logs, presents common log formats, and provides step‑by‑step implementations—including Canal binlog listening, log‑file recording, LogUtil helpers, and a full AOP‑based @LogRecord solution—while detailing template parsing, context handling, custom functions, and persistence in a Spring Boot environment.

AOPCanalJava
0 likes · 27 min read
How to Elegantly Implement Decoupled Operation Logging with AOP in Spring
Selected Java Interview Questions
Selected Java Interview Questions
Nov 5, 2021 · Backend Development

Implementing a Generic Appkey Whitelist Validation in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter Approaches

This article explains how to add a reusable appkey whitelist check to a Spring‑Boot web framework by comparing four implementation methods—traditional AOP, Spring Interceptor, custom ArgumentResolver, and Servlet Filter—detailing their code, configuration steps, extensions, and execution order.

AOPArgumentResolverInterceptor
0 likes · 10 min read
Implementing a Generic Appkey Whitelist Validation in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter Approaches
Top Architect
Top Architect
Oct 22, 2021 · Backend Development

Understanding AOP: AspectJ, Spring AOP, and CGLIB – A Practical Guide

This article explains the fundamentals of Aspect‑Oriented Programming, introduces AspectJ as a standalone AOP solution, demonstrates how to implement a HelloWorld example with compile‑time weaving, compares it with Spring AOP’s runtime proxies, and shows how CGLIB can be used for proxy generation.

AOPAspectJJava
0 likes · 9 min read
Understanding AOP: AspectJ, Spring AOP, and CGLIB – A Practical Guide
macrozheng
macrozheng
Oct 22, 2021 · Backend Development

Mastering API Rate Limiting in Spring Boot: Algorithms, Guava & AOP

This tutorial explains why API rate limiting is essential for high‑traffic Spring Boot services, introduces counter, leaky‑bucket, and token‑bucket algorithms, shows how to use Guava's RateLimiter, and demonstrates a clean custom‑annotation AOP solution to decouple rate‑limiting logic from business code.

AOPGuavaJava
0 likes · 13 min read
Mastering API Rate Limiting in Spring Boot: Algorithms, Guava & AOP
Programmer DD
Programmer DD
Oct 19, 2021 · Backend Development

Mastering Read/Write Splitting in Spring Boot with Custom Routing DataSource

This article explains how to implement read/write separation in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, using AOP to switch between master and slave databases, and demonstrates the setup with Maven, MyBatis, and JUnit tests.

AOPMulti-DataSourceMyBatis
0 likes · 16 min read
Mastering Read/Write Splitting in Spring Boot with Custom Routing DataSource
Code Ape Tech Column
Code Ape Tech Column
Oct 9, 2021 · Backend Development

Common Scenarios Where Spring Transactions Fail and How to Fix Them

This article explains why Spring @Transactional may become ineffective or fail to roll back in various situations—such as wrong method visibility, final modifiers, internal calls, missing Spring bean registration, multithreading, unsupported table engines, misconfigured propagation, swallowed exceptions, and improper rollback settings—while also offering practical solutions and best‑practice recommendations.

@TransactionalAOPBackend
0 likes · 19 min read
Common Scenarios Where Spring Transactions Fail and How to Fix Them
Top Architect
Top Architect
Oct 6, 2021 · Backend Development

Understanding Spring AOP Proxy Creation and Common Pitfalls

This article explains how Spring AOP weaves aspect code using dynamic proxies, why internal calls via this bypass proxy logic, and how to correctly configure and obtain proxied beans using JDK/CGLIB proxies, @EnableAspectJAutoProxy, @Autowired injection, and AopContext.

AOPAspectJCGLIB
0 likes · 4 min read
Understanding Spring AOP Proxy Creation and Common Pitfalls
High Availability Architecture
High Availability Architecture
Sep 28, 2021 · Backend Development

Elegant Design and Implementation of Operation Logging Using AOP and Dynamic Templates

This article explains the differences between system and operation logs, explores various implementation methods such as Canal, file logging, LogUtil, and method annotations, and demonstrates how to achieve clean, dynamic, and decoupled operation logging in Java Spring applications using AOP, SpEL, custom functions, and a well‑structured logging context.

AOPBackendJava
0 likes · 25 min read
Elegant Design and Implementation of Operation Logging Using AOP and Dynamic Templates
Java Architect Essentials
Java Architect Essentials
Sep 25, 2021 · Backend Development

Implementing Read‑Write Splitting in Spring Boot with AbstractRoutingDataSource and AOP

This article explains how to achieve read‑write splitting in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, managing routing keys with ThreadLocal, and using AOP to automatically switch between master and slave databases for different CRUD operations.

AOPDataSource RoutingJava
0 likes · 12 min read
Implementing Read‑Write Splitting in Spring Boot with AbstractRoutingDataSource and AOP
JavaEdge
JavaEdge
Sep 25, 2021 · Backend Development

Why Spring AOP Doesn’t Apply to ‘this’ Calls and How to Fix It

This article explains why Spring AOP proxies are not applied when a bean invokes its own methods via the this reference, compares JDK and CGLIB proxy mechanisms, and shows how to enable proxy exposure or use AopContext to achieve the desired AOP behavior.

AOPCGLIBJDK
0 likes · 5 min read
Why Spring AOP Doesn’t Apply to ‘this’ Calls and How to Fix It
Beike Product & Technology
Beike Product & Technology
Sep 17, 2021 · Frontend Development

Flutter for Web: Architecture, Platform Issues, and Disaster‑Recovery Solutions at Beike

This article describes how Beike's Flutter team leveraged Flutter for Web to enable rapid online issue mitigation, detailing the compilation pipeline, platform‑specific challenges such as operating‑system detection and dart:io limitations, and the multi‑module disaster‑recovery architecture they built.

AOPPlatform ChannelWeb
0 likes · 13 min read
Flutter for Web: Architecture, Platform Issues, and Disaster‑Recovery Solutions at Beike
Architect's Guide
Architect's Guide
Sep 10, 2021 · Backend Development

Implementing Database Read‑Write Separation with Spring Boot

This article explains how to achieve database read‑write separation in high‑concurrency scenarios using Spring Boot, covering the concepts of master‑slave architecture, configuration of multiple data sources, routing logic with AbstractRoutingDataSource, context management, custom annotations, AOP handling, and practical usage examples with code snippets.

AOPDataSource RoutingJava
0 likes · 11 min read
Implementing Database Read‑Write Separation with Spring Boot
Su San Talks Tech
Su San Talks Tech
Sep 4, 2021 · Backend Development

Why Spring Transactions Fail: 7 Common Pitfalls and How to Fix Them

This article explores why Spring transactions may fail, covering seven common pitfalls such as incorrect method visibility, final methods, internal calls, missing Spring management, multithreading, unsupported table engines, and misconfigured propagation, and provides practical solutions to ensure reliable transaction handling.

@TransactionalAOPBackend
0 likes · 19 min read
Why Spring Transactions Fail: 7 Common Pitfalls and How to Fix Them
Code Ape Tech Column
Code Ape Tech Column
Aug 29, 2021 · Backend Development

Understanding Idempotency and Preventing Duplicate Submissions in Backend Systems

This article explains the concept of idempotency, the common causes of duplicate submissions in web applications, and presents multiple backend solutions—including frontend button disabling, Post‑Redirect‑Get, session tokens, local locks with Content‑MD5, AOP aspects, and Redis distributed locks—accompanied by complete Java code examples.

AOPDistributed LockJava
0 likes · 15 min read
Understanding Idempotency and Preventing Duplicate Submissions in Backend Systems
Architecture Digest
Architecture Digest
Aug 27, 2021 · Backend Development

Four Ways to Implement a Generic AppKey Whitelist in Spring Boot

This article explains four approaches to adding a generic appkey whitelist check in a Spring Boot web framework—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order and extensibility.

AOPArgumentResolverAuthentication
0 likes · 12 min read
Four Ways to Implement a Generic AppKey Whitelist in Spring Boot
Tencent Cloud Developer
Tencent Cloud Developer
Aug 25, 2021 · Fundamentals

A Comprehensive Guide to JavaScript/TypeScript Decorators and Their Practical Use

The guide explains JavaScript/TypeScript decorators—an ECMAScript stage‑2 proposal used in frameworks like Angular, Nest.js, and TypeORM—by distinguishing the decorator pattern, function, and @syntax, demonstrating a four‑step manual implementation that logs execution time, and linking decorators to AOP, IoC, and DI concepts.

AOPDecoratorIoC
0 likes · 10 min read
A Comprehensive Guide to JavaScript/TypeScript Decorators and Their Practical Use
Xianyu Technology
Xianyu Technology
Aug 5, 2021 · Backend Development

Applying SWAK Framework in Xianyu Search: Architecture and Implementation

The article explains how Xianyu’s search service refactors tightly‑coupled, if‑else‑heavy code by applying the lightweight SWAK framework—defining @SwakInterface and @SwakTag annotations, registering proxy beans, using AOP and CGLIB proxies to route business logic via request‑derived tag groups, achieving clean, modular routing.

AOPBackendDynamicProxy
0 likes · 13 min read
Applying SWAK Framework in Xianyu Search: Architecture and Implementation
Java Interview Crash Guide
Java Interview Crash Guide
Jul 29, 2021 · Backend Development

Spring Boot Auth Whitelist: AOP, Interceptor, Resolver, and Filter

This article compares four Spring Boot techniques—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—for implementing a generic appkey whitelist validation, explains their implementation steps with code examples, and clarifies their execution order within the request processing pipeline.

AOPAuthenticationJava
0 likes · 11 min read
Spring Boot Auth Whitelist: AOP, Interceptor, Resolver, and Filter
Selected Java Interview Questions
Selected Java Interview Questions
Jul 28, 2021 · Backend Development

Four Ways to Implement a Generic Auth Whitelist in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter

This article explains four Spring‑Boot techniques—traditional AOP, HandlerInterceptor, HandlerMethodArgumentResolver, and Servlet Filter—to implement a reusable appkey whitelist validation, provides complete code examples for each, and clarifies their execution order within the request processing pipeline.

AOPArgumentResolverInterceptor
0 likes · 10 min read
Four Ways to Implement a Generic Auth Whitelist in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter
JD Retail Technology
JD Retail Technology
Jul 28, 2021 · Mobile Development

Applying Aspect‑Oriented Programming (AOP) for Privacy Compliance and Thread Optimization in Android Apps

This article explains how Aspect‑Oriented Programming is applied in Android development to achieve non‑intrusive privacy compliance checks and thread‑usage optimization, detailing the use of compile‑time ASM bytecode instrumentation and runtime Xposed/epic hooks, along with code examples and measured performance gains.

AOPASMAndroid
0 likes · 14 min read
Applying Aspect‑Oriented Programming (AOP) for Privacy Compliance and Thread Optimization in Android Apps
Java Interview Crash Guide
Java Interview Crash Guide
Jul 27, 2021 · Backend Development

Mastering Spring AOP: From Basics to Advanced Real‑World Examples

This article introduces Aspect‑Oriented Programming in Spring, explains core concepts such as pointcut, advice, aspect, join point and weaving, and provides step‑by‑step code examples—including a simple @GetMapping logger, a custom permission annotation with multiple aspects, and detailed usage of @Pointcut, @Around, @Before, @After, @AfterReturning and @AfterThrowing annotations—illustrated with diagrams and runnable snippets.

AOPAnnotationsAspect-Oriented Programming
0 likes · 19 min read
Mastering Spring AOP: From Basics to Advanced Real‑World Examples
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 24, 2021 · Backend Development

Enable Placeholder Expressions in Custom SpringBoot Annotations

Learn how to create a custom SpringBoot annotation that supports ${…} placeholder expressions by adding AspectJ dependencies, defining the annotation, implementing an AOP aspect that resolves placeholders via EnvironmentAware, storing the result in a ThreadLocal, and using it in a service and controller.

AOPCustom AnnotationEnvironment
0 likes · 4 min read
Enable Placeholder Expressions in Custom SpringBoot Annotations
Selected Java Interview Questions
Selected Java Interview Questions
Jul 24, 2021 · Backend Development

Understanding AOP in Spring Boot: Concepts, Code Examples, and Annotation Guide

This article explains Aspect‑Oriented Programming (AOP) in Spring Boot, covering its core concepts, why it simplifies cross‑cutting concerns like logging and permission checks, provides step‑by‑step code examples of simple and advanced AOP implementations, and details the most commonly used AOP annotations.

AOPAnnotationsAspect-Oriented Programming
0 likes · 18 min read
Understanding AOP in Spring Boot: Concepts, Code Examples, and Annotation Guide
Top Architect
Top Architect
Jul 21, 2021 · Backend Development

Understanding Spring's @Transactional Annotation: Implementation and AOP Mechanics

This article explains the purpose and inner workings of Spring's @Transactional annotation, detailing how AOP and dynamic proxies create transactional proxies, the role of BeanPostProcessor, advisors, TransactionInterceptor, and the transaction lifecycle, accompanied by code examples and diagrams for deeper insight.

@TransactionalAOPJava
0 likes · 10 min read
Understanding Spring's @Transactional Annotation: Implementation and AOP Mechanics
Top Architect
Top Architect
Jul 11, 2021 · Backend Development

Implementing Request Logging with Spring AOP: A Practical Guide

This article demonstrates how to use Spring AOP to create a request‑logging aspect that captures request parameters, response data, execution time, and error information, while also addressing high‑concurrency logging issues and integrating trace‑ID tracking for easier debugging.

AOPAspectJJava
0 likes · 12 min read
Implementing Request Logging with Spring AOP: A Practical Guide
Java High-Performance Architecture
Java High-Performance Architecture
Jul 6, 2021 · Backend Development

How to Implement Fine‑Grained Operation Logging in Spring Boot with BizLog SDK

This article explains how the BizLog component records who performed which action at what time in Spring Boot applications, covering Maven setup, annotation usage, custom operators, detail fields, category segregation, SpEL expressions, custom parse functions, and extension points for persistence and operator retrieval.

AOPBizLogJava
0 likes · 16 min read
How to Implement Fine‑Grained Operation Logging in Spring Boot with BizLog SDK
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 29, 2021 · Backend Development

Why Your Custom Spring AOP Advisor Isn’t Triggered and How to Fix It

This article explains the behavior of Spring Boot’s @Configuration and @Import annotations, the reasons a custom PointcutAdvisor may not be applied when using JDK proxies, and provides two solutions—adding the @DS annotation to interface methods or forcing CGLIB proxying with proxyTargetClass=true—to ensure the advice executes correctly.

AOPAnnotationsCGLIB
0 likes · 10 min read
Why Your Custom Spring AOP Advisor Isn’t Triggered and How to Fix It
The Dominant Programmer
The Dominant Programmer
Jun 27, 2021 · Backend Development

Cache Database Data in Redis with Custom SpringBoot AOP Annotations

This guide demonstrates how to add a custom AOP‑based caching layer to a SpringBoot application, using Redis to store frequently queried MySQL table data, defining @AopCacheEnable and @AopCacheEvict annotations, implementing an aspect, handling key generation, expiration, and cache eviction on CRUD operations.

AOPCacheCustom Annotation
0 likes · 9 min read
Cache Database Data in Redis with Custom SpringBoot AOP Annotations
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 25, 2021 · Backend Development

How Spring AOP Creates Proxies: Inside AnnotationAwareAspectJAutoProxyCreator

This article walks through Spring’s AOP proxy creation process, detailing how enabling @EnableAspectJAutoProxy registers AnnotationAwareAspectJAutoProxyCreator, how it decides whether to wrap a bean, and the internal methods—wrapIfNecessary, isInfrastructureClass, shouldSkip, and advisor discovery—that together generate the dynamic proxies used at runtime.

AOPAspectJProxy
0 likes · 15 min read
How Spring AOP Creates Proxies: Inside AnnotationAwareAspectJAutoProxyCreator
Code Ape Tech Column
Code Ape Tech Column
Jun 17, 2021 · Backend Development

Four Ways to Implement Generic Auth in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter

This article explains how to add a generic app‑key whitelist authentication feature to a Spring Boot web framework using four different mechanisms—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order.

AOPArgumentResolverAuthentication
0 likes · 12 min read
Four Ways to Implement Generic Auth in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter
Top Architect
Top Architect
Jun 16, 2021 · Backend Development

Implementing Request Logging with Spring AOP: Aspect Code and Best Practices

This article demonstrates how to use Spring AOP to create a request‑logging aspect that captures IP, URL, HTTP method, parameters, results, execution time, and error details, while also addressing high‑concurrency logging issues and integrating trace‑ID tracking for easier debugging.

AOPAspectJJava
0 likes · 12 min read
Implementing Request Logging with Spring AOP: Aspect Code and Best Practices
Programmer DD
Programmer DD
Jun 14, 2021 · Backend Development

Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained

This comprehensive guide explores the Spring framework’s fundamentals, including its lightweight architecture, core IoC container, dependency injection mechanisms, bean scopes and lifecycle, annotation‑based configuration, data‑access support, and aspect‑oriented programming features, providing developers with a solid foundation for building robust Java applications.

AOPBean LifecycleIoC
0 likes · 45 min read
Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained
Top Architect
Top Architect
Jun 13, 2021 · Backend Development

Implementing AOP in a Custom Spring‑like Framework

This article explains the principles and step‑by‑step implementation of Aspect‑Oriented Programming (AOP) in a lightweight Spring‑style container, covering core concepts, advice and pointcut design, weaving mechanisms, proxy creation, observer integration, and practical code examples.

AOPAspect-Oriented ProgrammingJava
0 likes · 16 min read
Implementing AOP in a Custom Spring‑like Framework
Programmer DD
Programmer DD
Jun 13, 2021 · Backend Development

Four Ways to Implement Generic Auth in Spring Boot: AOP, Interceptor, Resolver, Filter

This article explains how to add a generic appkey whitelist authentication feature to a Spring Boot web framework using four approaches—traditional AOP, HandlerInterceptor, HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order.

AOPArgumentResolverInterceptor
0 likes · 11 min read
Four Ways to Implement Generic Auth in Spring Boot: AOP, Interceptor, Resolver, Filter
Tencent Music Tech Team
Tencent Music Tech Team
Jun 10, 2021 · Mobile Development

iOS Crash Protection: Motivation, Process, and Implementation

After a massive crash caused by a malformed Facebook SDK payload highlighted the lack of fault‑tolerance, this article explains why iOS crash protection is essential, outlines a four‑step handling workflow, and details two main techniques—Aspect‑Oriented Programming hooks and managed zombie objects—along with their pitfalls, performance impact, and memory‑threshold formulas for safe production deployment.

AOPZombie Objectscrash protection
0 likes · 11 min read
iOS Crash Protection: Motivation, Process, and Implementation
Java Tech Enthusiast
Java Tech Enthusiast
Jun 8, 2021 · Backend Development

Introduction to AOP (Aspect Oriented Programming) in Java

This article introduces Aspect‑Oriented Programming in Java, explaining how AOP separates cross‑cutting concerns like logging using join points, pointcuts, advice, and aspects, and demonstrates dynamic proxies, various advice types, XML configuration, and aspect ordering within Spring AOP.

AOPAdviceAspect-Oriented Programming
0 likes · 20 min read
Introduction to AOP (Aspect Oriented Programming) in Java
Programmer DD
Programmer DD
Jun 8, 2021 · Backend Development

Mastering Request Logging with Spring AOP: A Complete Guide

Learn how to implement a robust request logging aspect in Spring using AOP annotations, covering pointcut definition, before/around/after advice, handling high concurrency, serializing logs, capturing errors, and adding traceId support for better traceability in backend services.

AOPBackendJava
0 likes · 14 min read
Mastering Request Logging with Spring AOP: A Complete Guide
Code Ape Tech Column
Code Ape Tech Column
Jun 8, 2021 · Backend Development

Why Spring @Transactional on a Called Method Doesn’t Rollback and How to Fix It

The article analyzes a Spring Boot transaction issue where a @Transactional method called from another non‑transactional method fails to roll back, explains the underlying propagation and proxy mechanisms, and presents two practical solutions—including using the bean’s proxy via AopContext with exposeProxy enabled—to ensure proper rollback.

@TransactionalAOPSpring
0 likes · 8 min read
Why Spring @Transactional on a Called Method Doesn’t Rollback and How to Fix It
Java Captain
Java Captain
Jun 5, 2021 · Backend Development

Spring Framework Basics: Core Concepts, Modules, Dependency Injection, Beans, Annotations, AOP, MVC, and Data Access

An extensive overview of the Spring Framework covering its core concepts, version features, lightweight architecture, IoC container, dependency injection methods, bean definitions and scopes, configuration styles, annotation usage, AOP principles, MVC workflow, data access mechanisms, and related implementation details with code examples.

AOPJavaMVC
0 likes · 19 min read
Spring Framework Basics: Core Concepts, Modules, Dependency Injection, Beans, Annotations, AOP, MVC, and Data Access