BestHub
Sign in
Tagged articles

AOP

635 articles · Page 2 of 7
Programmer1970
Programmer1970
Jun 11, 2025 · Backend Development

A Comprehensive Overview of Spring Framework’s Transaction Management

This article dissects Spring's transaction management system, detailing its layered architecture, core interfaces such as PlatformTransactionManager, TransactionDefinition and TransactionSynchronization, the lifecycle of transaction start, commit and rollback, programmatic and declarative usage, advanced features like distributed and nested transactions, common pitfalls, and optimization recommendations.

AOPJTASpring
0 likes · 13 min read
A Comprehensive Overview of Spring Framework’s Transaction Management
Java Tech Enthusiast
Java Tech Enthusiast
Jun 9, 2025 · Backend Development

Eliminate Repetitive Audit Fields in Java: 6 Proven Strategies with MyBatis‑Plus, AOP, and JWT

This article presents a production‑tested, six‑step solution for automatically handling common entity fields such as createTime, updateTime, createUser, and updateUser in Java backend systems, covering MyBatis‑Plus auto‑fill, AOP interception, multi‑data‑source adaptation, distributed ID generation, pitfalls avoidance, performance tuning, and audit logging.

AOPautomatic field fillingbackend development
0 likes · 9 min read
Eliminate Repetitive Audit Fields in Java: 6 Proven Strategies with MyBatis‑Plus, AOP, and JWT
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 9, 2025 · Backend Development

How to Dynamically Enable/Disable Spring Boot Controllers with AOP, Interceptors, and Custom Mappings

This article explains four practical ways to control the availability of Spring Boot controller endpoints at runtime—using @ConditionalOnProperty, a custom AOP annotation, a HandlerInterceptor, and a custom RequestMappingHandlerMapping—detailing code examples, configuration, advantages, and trade‑offs.

AOPCustom MappingInterceptor
0 likes · 9 min read
How to Dynamically Enable/Disable Spring Boot Controllers with AOP, Interceptors, and Custom Mappings
Java Web Project
Java Web Project
Jun 4, 2025 · Backend Development

How to Eliminate Repetitive Common Fields in Java Order Services with MyBatis‑Plus and AOP

This article analyzes the pain points of manually maintaining common fields in order‑related entities and presents a production‑tested solution that combines MyBatis‑Plus automatic filling, custom AOP annotations, multi‑data‑source handling, distributed ID generation, and auditing to dramatically reduce boilerplate code and bugs.

AOPAuditingAutomatic Field Fill
0 likes · 9 min read
How to Eliminate Repetitive Common Fields in Java Order Services with MyBatis‑Plus and AOP
Code Ape Tech Column
Code Ape Tech Column
May 26, 2025 · Backend Development

Automated Management of Common Fields in Order Modules Using MyBatis-Plus, AOP, and JWT

This article presents a production‑validated solution that combines MyBatis‑Plus auto‑fill, AOP, JWT, multi‑data‑source handling, distributed ID generation, performance tuning, and audit logging to eliminate repetitive maintenance of common fields such as createTime, updateTime, createUser, and updateUser in Java backend order services.

AOPAutomationSpring
0 likes · 9 min read
Automated Management of Common Fields in Order Modules Using MyBatis-Plus, AOP, and JWT
Architecture Digest
Architecture Digest
May 21, 2025 · Backend Development

Automating Common Entity Fields in Java Backend with MyBatis-Plus, AOP, and JWT

This article presents a production‑tested solution for automatically handling common entity fields such as createTime, updateTime, createUser, and updateUser in Java backend systems, combining MyBatis‑Plus auto‑fill, AOP interceptors, custom annotations, multi‑datasource support, distributed ID generation, and auditing techniques to eliminate repetitive code and reduce bugs.

AOPmybatis-plus
0 likes · 9 min read
Automating Common Entity Fields in Java Backend with MyBatis-Plus, AOP, and JWT
Code Ape Tech Column
Code Ape Tech Column
May 20, 2025 · Backend Development

Dynamic Chain of Responsibility in Spring: A Practical Implementation

This article explains how to split a multi‑function OpenAPI endpoint into independent steps using the responsibility‑chain pattern in Spring, detailing the abstract component, context sharing, bean retrieval via ApplicationContext, and a controller that dynamically orders execution through a query parameter, with full code examples.

AOPChain of ResponsibilityDesign Pattern
0 likes · 9 min read
Dynamic Chain of Responsibility in Spring: A Practical Implementation
Selected Java Interview Questions
Selected Java Interview Questions
May 14, 2025 · Backend Development

Enterprise Java Core Features: Full‑Chain Logging, Unified Exception Handling, Permission Interceptor, and Thread Context Management

This article presents a comprehensive guide to implementing full‑chain log tracing, unified exception handling, permission interception, request latency monitoring, and standardized log formats in enterprise‑level Java projects using Spring AOP, thread‑local context, and Redis caching.

AOPExceptionHandlingSpring
0 likes · 23 min read
Enterprise Java Core Features: Full‑Chain Logging, Unified Exception Handling, Permission Interceptor, and Thread Context Management
Java Tech Enthusiast
Java Tech Enthusiast
May 14, 2025 · Backend Development

Understanding SpringBoot Interceptors: Filters, HandlerInterceptor, AOP, RestTemplate, Feign, and WebFilter

This article introduces the six main types of interceptors in SpringBoot—Filter, HandlerInterceptor, AOP, RestTemplate, Feign, and WebFilter—explaining their typical use‑cases, implementation details, common pitfalls, and best‑practice ordering to help developers choose the right tool for each scenario.

AOPFeignInterceptor
0 likes · 8 min read
Understanding SpringBoot Interceptors: Filters, HandlerInterceptor, AOP, RestTemplate, Feign, and WebFilter
Su San Talks Tech
Su San Talks Tech
May 9, 2025 · Backend Development

Master Spring Boot Interceptors: Filters, Handlers, AOP, RestTemplate & Feign

This article explores the hierarchy of Spring Boot interception mechanisms—Filter, HandlerInterceptor, AOP, RestTemplate, Feign, and WebFilter—detailing their typical use cases, implementation code, pitfalls, and best‑practice ordering, while providing practical tips and performance monitoring advice for robust backend development.

AOPFeignInterceptor
0 likes · 8 min read
Master Spring Boot Interceptors: Filters, Handlers, AOP, RestTemplate & Feign
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 6, 2025 · Backend Development

Why @Transactional Fails with @Async in Spring Boot 3 – A Deep Dive

This article explains how @Transactional and @Async normally cooperate in Spring Boot, demonstrates cases where the transaction does not roll back when @EnableAsync order is changed, analyzes the underlying AOP proxy creation and bean post‑processor execution order, and introduces new Spring 6.2 transaction‑rollback configuration options.

AOPSpring BootTransaction Management
0 likes · 9 min read
Why @Transactional Fails with @Async in Spring Boot 3 – A Deep Dive
Java Captain
Java Captain
May 2, 2025 · Databases

Implementing Dynamic MySQL Master‑Slave Switching in SpringBoot Using AOP and Custom Annotations

This article demonstrates how to use SpringBoot 3.0.4 with AOP and a custom @DataSource annotation to dynamically switch between MySQL master and slave databases, ensuring high availability by automatically falling back to the master when a slave fails, and provides configuration and code examples for multiple data sources.

AOPDatabase SwitchingMySQL
0 likes · 14 min read
Implementing Dynamic MySQL Master‑Slave Switching in SpringBoot Using AOP and Custom Annotations
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 1, 2025 · Backend Development

Master Spring Boot TargetSource: Custom, HotSwappable, Pooled & More

This article explains Spring Boot's TargetSource mechanism, covering the default SingletonTargetSource and demonstrating how to implement custom, hot‑swappable, pooled, prototype, and thread‑local TargetSources with full code examples and execution results, helping developers manage bean instances dynamically in AOP proxies.

AOPSpring BootTargetSource
0 likes · 8 min read
Master Spring Boot TargetSource: Custom, HotSwappable, Pooled & More
Java Tech Enthusiast
Java Tech Enthusiast
Apr 29, 2025 · Backend Development

Implementing Data Isolation with MyBatis Interceptor and Custom Annotations

The article describes how to enforce environment‑based data isolation in a shared database by adding an env column, using a MyBatis interceptor to inject and filter this field at runtime, and employing a custom @InvokeChainSkipEnvRule annotation with AOP to selectively bypass the rule, keeping existing code untouched.

AOPCustom AnnotationData Isolation
0 likes · 9 min read
Implementing Data Isolation with MyBatis Interceptor and Custom Annotations
Architect
Architect
Apr 12, 2025 · Backend Development

Secure Spring Boot APIs with Hybrid AES‑RSA Encryption, Transparent Request Wrappers, and Response‑Encryption AOP

This article walks through a complete solution for protecting data in Spring Boot applications, covering symmetric, asymmetric, and hybrid encryption schemes, utility classes for AES and RSA, a custom HttpServletRequestWrapper to enable multiple reads of the request body, a filter that transparently decrypts incoming parameters, and an AOP‑based response‑encryption mechanism triggered by a custom annotation.

AESAOPRSA
0 likes · 45 min read
Secure Spring Boot APIs with Hybrid AES‑RSA Encryption, Transparent Request Wrappers, and Response‑Encryption AOP
Java Architect Essentials
Java Architect Essentials
Apr 10, 2025 · Backend Development

Master Dynamic Data Source Switching in SpringBoot: A Step‑by‑Step Guide

This article walks through the complete process of implementing dynamic data source switching in a SpringBoot application, covering the core concepts of thread‑local context, abstract routing, custom annotations with AOP, configuration, code examples, and important considerations such as transaction management and performance.

AOPDatabaseSpringBoot
0 likes · 6 min read
Master Dynamic Data Source Switching in SpringBoot: A Step‑by‑Step Guide
Top Architect
Top Architect
Apr 9, 2025 · Backend Development

Spring Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ReflectionUtils, and AOP Utilities

This article provides a comprehensive guide to Spring's built‑in utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ReflectionUtils, and AopUtils—showing their purpose, typical usage patterns, and example method signatures for developers working on Java backend projects.

AOPSpringUtility
0 likes · 17 min read
Spring Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ReflectionUtils, and AOP Utilities
Java Captain
Java Captain
Apr 9, 2025 · Backend Development

Implementing Dynamic MySQL Master‑Slave Data Source Switching in SpringBoot with AOP and Custom Annotations

This tutorial explains how to use SpringBoot, AOP, and a custom @DataSource annotation to dynamically switch between MySQL master and slave databases—covering configuration, code implementation, multiple slave handling, and an Oracle example—to ensure high availability and flexible data source management.

AOPMulti-DataSourceMySQL
0 likes · 13 min read
Implementing Dynamic MySQL Master‑Slave Data Source Switching in SpringBoot with AOP and Custom Annotations
Selected Java Interview Questions
Selected Java Interview Questions
Apr 2, 2025 · Backend Development

Implementing Environment-Based Data Isolation in MyBatis with Custom Interceptors and Annotations

This article describes a practical approach to achieve environment-based data isolation in a Java application by adding an 'env' field to tables, using a custom MyBatis interceptor to rewrite SQL, and defining annotations with AOP to control environment filtering, while discussing challenges and refactoring considerations.

AOPCustom InterceptorData Isolation
0 likes · 12 min read
Implementing Environment-Based Data Isolation in MyBatis with Custom Interceptors and Annotations
Java Backend Technology
Java Backend Technology
Mar 31, 2025 · Backend Development

Boost Database Query Performance with Spring AOP: Parallel IN Splitting Technique

This article explains how to improve slow PostgreSQL IN queries caused by large parameter lists by defining a custom Spring AOP annotation that automatically splits the parameter set, runs the sub‑queries concurrently in multiple threads, and merges the results back together, complete with code examples and usage guidelines.

AOPAnnotationSpring
0 likes · 11 min read
Boost Database Query Performance with Spring AOP: Parallel IN Splitting Technique
Java Backend Technology
Java Backend Technology
Mar 17, 2025 · Backend Development

Mastering Business Operation Logging: From AOP to Binlog with Spring

This article explores comprehensive strategies for capturing business operation logs in a Spring‑based system, comparing three solutions—from a simple AOP‑annotation approach, through an enhanced AOP + SpEL method, to a robust Binlog‑plus‑time‑window architecture—while weighing their advantages, drawbacks, and implementation details.

AOPSpELSpringBoot
0 likes · 16 min read
Mastering Business Operation Logging: From AOP to Binlog with Spring
Lobster Programming
Lobster Programming
Mar 13, 2025 · Backend Development

Why Spring @Transactional Sometimes Fails: 12 Common Pitfalls and Fixes

This article explains how Spring's declarative transaction management works, why the @Transactional annotation can unexpectedly become ineffective, and presents twelve typical scenarios—such as internal method calls, non‑public methods, final/static modifiers, proxy issues, and incorrect propagation settings—along with practical solutions to ensure reliable transaction handling.

AOPSpringSpringBoot
0 likes · 12 min read
Why Spring @Transactional Sometimes Fails: 12 Common Pitfalls and Fixes
Code Ape Tech Column
Code Ape Tech Column
Mar 12, 2025 · Backend Development

AviatorScript: Features, Usage, and Spring Boot Integration for Expression Evaluation and Validation

This article introduces AviatorScript, a lightweight high‑performance JVM‑based scripting language, outlines its core features and limitations, demonstrates how to add it to a Maven project, shows expression evaluation, variable handling, custom functions, script files, and provides a practical Spring Boot AOP validation example with full code snippets.

AOPExpression EngineSpring Boot
0 likes · 18 min read
AviatorScript: Features, Usage, and Spring Boot Integration for Expression Evaluation and Validation
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 9, 2025 · Backend Development

Spring Boot 3 Security Tutorial: AOP, Custom Annotations & JWT

This article presents a continuously updated collection of over 100 Spring Boot 3 practical cases, demonstrating how to implement permission authentication using Spring AOP, custom annotations, JWT utilities, interceptors, a global exception handler, a security context, and a custom argument resolver, complete with test examples and screenshots.

AOPJWTSpring Boot
0 likes · 12 min read
Spring Boot 3 Security Tutorial: AOP, Custom Annotations & JWT
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Mar 3, 2025 · Backend Development

Implement Custom Annotations in Spring Boot for Logging, Security & Caching

This guide explains common scenarios for using custom Java annotations—such as logging, permission control, data validation, and caching—and walks through the step-by-step process of defining an annotation, applying it in Spring services, handling it with an AOP aspect, and testing the implementation in a Spring Boot application.

AOPCustom AnnotationsSpring Boot
0 likes · 7 min read
Implement Custom Annotations in Spring Boot for Logging, Security & Caching
Java Tech Enthusiast
Java Tech Enthusiast
Mar 2, 2025 · Backend Development

Simplify File Downloads in SpringBoot with a Single @Download Annotation

The Concept‑Download library lets SpringBoot developers replace verbose download code with a single @Download annotation that automatically handles classpath resources, local files, HTTP URLs, custom objects, compression and reactive streaming, simplifying batch and QR‑code ZIP exports.

AOPAnnotationFileDownload
0 likes · 8 min read
Simplify File Downloads in SpringBoot with a Single @Download Annotation
Top Architecture Tech Stack
Top Architecture Tech Stack
Feb 25, 2025 · Backend Development

Implementing Dynamic MySQL Master‑Slave Switching in SpringBoot Using AOP and Custom Annotations

This tutorial explains how to implement dynamic master‑slave MySQL switching in a SpringBoot 3.0.4 project using AOP and a custom @DataSource annotation, covering configuration, enum definitions, utility classes, aspect handling, and usage examples for both single and multiple data sources, including Oracle integration.

AOPMySQLSpringBoot
0 likes · 15 min read
Implementing Dynamic MySQL Master‑Slave Switching in SpringBoot Using AOP and Custom Annotations
macrozheng
macrozheng
Feb 17, 2025 · Backend Development

Master Dynamic MySQL Master‑Slave Switching in Spring Boot with AOP

This guide explains how to use Spring Boot, AOP, and custom annotations to implement dynamic MySQL master‑slave data source switching, automatically falling back to the master when a slave fails, covering configuration, Maven dependencies, enum definitions, data source beans, routing logic, and usage examples.

AOPDynamic Data SourceMySQL
0 likes · 16 min read
Master Dynamic MySQL Master‑Slave Switching in Spring Boot with AOP
Architect's Guide
Architect's Guide
Feb 6, 2025 · Backend Development

Optimizing Large IN Queries with Spring AOP and Multi‑Threaded Splitting

This article explains how to improve performance of massive IN‑list database queries in Java by defining custom Spring AOP annotations that automatically split the parameter list, execute the sub‑queries concurrently in a thread pool, and merge the results using a configurable return‑handling strategy.

AOPSpringin-query
0 likes · 10 min read
Optimizing Large IN Queries with Spring AOP and Multi‑Threaded Splitting
Shepherd Advanced Notes
Shepherd Advanced Notes
Jan 13, 2025 · Backend Development

Practical Issues and Solutions for Spring Boot Scheduled Tasks, Plus Implementation Details

The article examines common pitfalls of Spring Boot scheduled tasks—such as missing logs, single‑threaded execution, and distributed conflicts—offers trace‑ID logging via AOP, discusses async handling, outlines multi‑threading and distributed scheduling options, and explains the inner workings of @Scheduled and cron expressions.

AOPCron ExpressionScheduled Tasks
0 likes · 16 min read
Practical Issues and Solutions for Spring Boot Scheduled Tasks, Plus Implementation Details
Code Ape Tech Column
Code Ape Tech Column
Jan 8, 2025 · Backend Development

Implementing High‑Concurrency Flash‑Sale (Seckill) in SpringBoot: Locking Strategies, Queue Solutions, and Performance Testing

This article demonstrates how to simulate a high‑concurrency flash‑sale scenario using SpringBoot, MySQL, Mybatis‑Plus and JMeter, analyzes the overselling problem caused by premature lock release, and presents seven solutions—including lock‑first strategies, AOP, pessimistic and optimistic locks, and queue‑based approaches—along with code samples and test results.

AOPDatabaseJMeter
0 likes · 19 min read
Implementing High‑Concurrency Flash‑Sale (Seckill) in SpringBoot: Locking Strategies, Queue Solutions, and Performance Testing
Architecture Digest
Architecture Digest
Jan 6, 2025 · Backend Development

Optimizing Large IN Queries with Spring AOP and Multithreaded Splitting

This article explains how to improve performance of massive IN‑list queries in PostgreSQL by splitting the parameter list, executing the sub‑queries concurrently with a custom Spring AOP annotation, and merging the results using a configurable thread pool and return‑handling strategy.

AOPPostgreSQLSpring
0 likes · 9 min read
Optimizing Large IN Queries with Spring AOP and Multithreaded Splitting
Zhuanzhuan Tech
Zhuanzhuan Tech
Dec 18, 2024 · Backend Development

Design and Implementation of a Spring Boot Log Auditing Plugin Using AOP

This article details the design, architecture, and step‑by‑step implementation of a Spring Boot log auditing plugin built with AOP, Maven plugins, auto‑configuration, thread‑pool execution, and optional message‑queue streaming to improve operation logging and exception tracing in backend services.

AOPLog AuditingMaven
0 likes · 18 min read
Design and Implementation of a Spring Boot Log Auditing Plugin Using AOP
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 14, 2024 · Backend Development

Spring Boot Request Logging, Request/Response Wrappers, OncePerRequestFilter, and AOP Utility Classes

This article explains how Spring Boot's built‑in logging filter, request and response caching wrappers, the OncePerRequestFilter base class, and AOP helper classes such as AopContext, AopUtils, and ReflectionUtils can be configured and used to record, modify, and monitor HTTP traffic and simplify proxy‑based programming.

AOPOncePerRequestFilterRequest Logging
0 likes · 11 min read
Spring Boot Request Logging, Request/Response Wrappers, OncePerRequestFilter, and AOP Utility Classes
Programmer1970
Programmer1970
Dec 8, 2024 · Backend Development

Advanced Spring Interview Questions: Bean Lifecycle, AOP, Transactions, ApplicationContext vs BeanFactory, Type Conversion

This article compiles twelve advanced Spring interview questions covering bean initialization and lifecycle, AOP implementation, transaction management, the differences between ApplicationContext and BeanFactory, type conversion mechanisms, dependency injection, circular dependency resolution with three‑level caches, the event system, @Transactional and @Async annotations, and the inner workings of DispatcherServlet.

AOPBean LifecycleSpring
0 likes · 21 min read
Advanced Spring Interview Questions: Bean Lifecycle, AOP, Transactions, ApplicationContext vs BeanFactory, Type Conversion
Architect's Guide
Architect's Guide
Dec 6, 2024 · Backend Development

Why Spring Requires a Three‑Level Cache to Resolve Circular Dependencies Instead of a Two‑Level Cache

This article explains how Spring's bean lifecycle uses a three‑level cache (singletonObjects, earlySingletonObjects, singletonFactories) to break circular dependencies, especially when AOP proxies are involved, and why a two‑level cache alone cannot guarantee correct singleton behavior.

AOPBean LifecycleCircular Dependency
0 likes · 10 min read
Why Spring Requires a Three‑Level Cache to Resolve Circular Dependencies Instead of a Two‑Level Cache
Code Ape Tech Column
Code Ape Tech Column
Nov 30, 2024 · Cloud Native

Implementing Distributed Authentication in Spring Cloud Alibaba Using Custom Annotations

This article demonstrates how to move authentication from the gateway to downstream microservices in a Spring Cloud Alibaba setup by disabling the gateway’s ReactiveAuthorizationManager, defining three custom security annotations, creating an AOP aspect to enforce them, and showing practical usage examples with role‑based access control and Feign calls.

AOPSpring Cloudannotations
0 likes · 9 min read
Implementing Distributed Authentication in Spring Cloud Alibaba Using Custom Annotations
Architecture Digest
Architecture Digest
Nov 28, 2024 · Backend Development

Automatic Insertion of UserId and OrderId into Logs Using Spring AOP and MDC

This article explains how to automatically embed userId and orderId into log statements by defining log placeholders, storing these values in MDC via ThreadLocal, and using a custom @UserLog annotation together with Spring AOP to inject the data before method execution, complete with configuration and test examples.

AOPAnnotationMDC
0 likes · 8 min read
Automatic Insertion of UserId and OrderId into Logs Using Spring AOP and MDC
Selected Java Interview Questions
Selected Java Interview Questions
Nov 27, 2024 · Backend Development

Designing a Flexible Permission Control System with Java Annotations and Spring AOP

This article explains how to build a scalable, maintainable permission control framework in Java by defining custom annotations, designing relational database tables, and using Spring AOP to intercept method calls for organization‑level, personal, limit, and special‑role checks, while providing implementation details and best‑practice recommendations.

AOPPermissionSpring
0 likes · 21 min read
Designing a Flexible Permission Control System with Java Annotations and Spring AOP
Top Architect
Top Architect
Nov 18, 2024 · Backend Development

Comprehensive Guide to Spring Framework Utility Classes and Their Usage

This article presents a detailed overview of Spring's utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—provides code examples for each, and also contains promotional information about ChatGPT services and a developer community.

AOPSpringassertions
0 likes · 18 min read
Comprehensive Guide to Spring Framework Utility Classes and Their Usage
macrozheng
macrozheng
Oct 18, 2024 · Backend Development

Why @Transactional Often Fails: 13 Real-World Pitfalls and How to Fix Them

An in‑depth guide reveals thirteen common pitfalls that cause Spring’s @Transactional annotation to malfunction—ranging from unnecessary usage and proxy limitations to propagation misconfigurations and exception handling—plus practical demos and solutions to ensure reliable transaction rollbacks in Java backend development.

AOPExceptionHandlingSpring
0 likes · 20 min read
Why @Transactional Often Fails: 13 Real-World Pitfalls and How to Fix Them
Programmer XiaoFu
Programmer XiaoFu
Oct 18, 2024 · Backend Development

Unlock Spring Boot’s Powerful Built‑In Features You’re Not Using

This article walks through Spring Boot’s built‑in utilities—including request logging with CommonsRequestLoggingFilter, request/response wrappers, the OncePerRequestFilter base class, and AOP helpers like AopContext, AopUtils, and ReflectionUtils—showing how to configure and apply them in real code.

AOPContentCachingWrapperOncePerRequestFilter
0 likes · 12 min read
Unlock Spring Boot’s Powerful Built‑In Features You’re Not Using
macrozheng
macrozheng
Oct 16, 2024 · Backend Development

Master Spring Boot Request Logging, Wrappers, and AOP Utilities in One Guide

This article explains how to use Spring Boot's built‑in request logging, request/response wrappers, OncePerRequestFilter, and AOP utility classes such as AopContext, AopUtils, and ReflectionUtils, providing configuration snippets and practical code examples for backend developers.

AOPFiltersRequest Logging
0 likes · 13 min read
Master Spring Boot Request Logging, Wrappers, and AOP Utilities in One Guide
Top Architect
Top Architect
Sep 15, 2024 · Backend Development

Overview of Common Spring Utility Classes

This article presents a comprehensive collection of frequently used Spring framework utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, ReflectionUtils, and AopUtils—explaining their purpose, typical use cases, and providing code snippets for each method to help developers avoid redundant implementations.

AOPSpringUtility
0 likes · 18 min read
Overview of Common Spring Utility Classes
IT Services Circle
IT Services Circle
Sep 14, 2024 · Backend Development

Spring Transaction Pitfalls: Common Scenarios Where Transactions Fail and How to Fix Them

This article explains the most common reasons why Spring @Transactional annotations may become ineffective or fail to roll back, covering access‑modifier issues, final methods, internal calls, self‑injection, multithreading, unsupported table engines, mis‑configured propagation, exception handling, nested transactions, large‑transaction problems, and the advantages of programmatic transaction management.

AOPDatabaseExceptionHandling
0 likes · 20 min read
Spring Transaction Pitfalls: Common Scenarios Where Transactions Fail and How to Fix Them
macrozheng
macrozheng
Sep 10, 2024 · Backend Development

Automate User and Order ID Logging in Spring Boot with MDC and AOP

This guide explains how to automatically inject userId and orderId into log statements in a Spring Boot microservice by configuring Log4j2 patterns, using MDC to store context variables, and creating a custom @UserLog annotation with an AOP aspect that populates the MDC before method execution.

AOPAnnotationMDC
0 likes · 9 min read
Automate User and Order ID Logging in Spring Boot with MDC and AOP
Su San Talks Tech
Su San Talks Tech
Sep 9, 2024 · Backend Development

Why Your Spring @Transactional Might Fail: 7 Common Pitfalls and How to Fix Them

This article explains why Spring transactions can become ineffective or fail to roll back, covering issues such as wrong method visibility, final methods, internal calls, missing Spring bean registration, multithreading, unsupported table engines, misconfigured propagation, exception handling, and offers practical solutions for each case.

AOPDatabaseSpring
0 likes · 21 min read
Why Your Spring @Transactional Might Fail: 7 Common Pitfalls and How to Fix Them
Architect's Guide
Architect's Guide
Sep 6, 2024 · Backend Development

Implementing Dynamic Data Source Switching in Spring Boot with ThreadLocal and AbstractRoutingDataSource

This article demonstrates how to implement dynamic data source switching in a Spring Boot application by leveraging ThreadLocal and AbstractRoutingDataSource, providing step‑by‑step code examples for context holders, custom routing, annotation‑driven switching, and runtime addition of new data sources.

AOPDynamicDataSourceMyBatis-Plus
0 likes · 14 min read
Implementing Dynamic Data Source Switching in Spring Boot with ThreadLocal and AbstractRoutingDataSource
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 3, 2024 · Frontend Development

Understanding the Decorator Pattern and AOP in JavaScript

This article explains the decorator pattern and how Aspect‑Oriented Programming (AOP) can be used in JavaScript to dynamically extend object behavior, provides classic and Vue‑based code examples, discusses advantages and drawbacks, and outlines practical scenarios for applying decorators in front‑end development.

AOPCode ExampleDecorator Pattern
0 likes · 11 min read
Understanding the Decorator Pattern and AOP in JavaScript
Ubiquitous Tech
Ubiquitous Tech
Sep 1, 2024 · Backend Development

Mastering Advanced Spring Boot Starter Configurations: 4 Essential Techniques

This article walks through four advanced Spring Boot Starter design patterns—Customizer, Enable/ConditionalOnProperty, SPI file migration, and AOP interception—showing concrete code examples, the reasoning behind each approach, and practical tips for learning and applying these techniques.

AOPConditionalOnPropertyCustomizer
0 likes · 16 min read
Mastering Advanced Spring Boot Starter Configurations: 4 Essential Techniques
Programmer XiaoFu
Programmer XiaoFu
Aug 29, 2024 · Backend Development

Why @Transactional Often Fails: 13 Real‑World Pitfalls from 6 Years of Experience

This article analyses thirteen common mistakes that cause Spring's @Transactional annotation to be ineffective or not roll back, covering unnecessary usage, private/final/static methods, self‑invocation, wrong propagation settings, async threads, unmanaged beans, exception handling and more, with concrete code demos and solutions.

AOPException HandlingSpring
0 likes · 21 min read
Why @Transactional Often Fails: 13 Real‑World Pitfalls from 6 Years of Experience
Programmer DD
Programmer DD
Aug 28, 2024 · Backend Development

How to Create Custom Spring Boot Annotations for Automatic Error Logging

Learn how to simplify repetitive error-handling code in Spring Boot by creating a custom @ErrorHandler annotation that leverages Spring AOP to automatically log exceptions, with step-by-step instructions, required dependencies, annotation definition, aspect implementation, and usage examples.

AOPCustom AnnotationError Logging
0 likes · 8 min read
How to Create Custom Spring Boot Annotations for Automatic Error Logging
Huolala Tech
Huolala Tech
Aug 23, 2024 · Fundamentals

Mastering AspectPro: A Lightweight HarmonyOS Hook Framework for Seamless AOP

AspectPro is a lightweight HarmonyOS runtime hook framework that, together with aspectProPlugin, enables comprehensive AOP capabilities such as method interception, parameter manipulation, and handling of non-writable properties, while the article details its core functions, limitations of system Aspect, and step‑by‑step implementation strategies.

AOPAspectProHarmonyOS
0 likes · 22 min read
Mastering AspectPro: A Lightweight HarmonyOS Hook Framework for Seamless AOP
Java Tech Enthusiast
Java Tech Enthusiast
Aug 14, 2024 · Backend Development

Customizing JSON Serialization and Deserialization in Spring Boot

In Spring Boot you can customize JSON request and response handling by annotating fields with @JsonSerialize/@JsonDeserialize, registering a global ObjectMapper module, adding a PropertyEditor via @ControllerAdvice, creating a custom HttpMessageConverter, or using AOP interception, selecting the approach that matches your project’s complexity.

AOPDeserializationJackson
0 likes · 7 min read
Customizing JSON Serialization and Deserialization in Spring Boot
Code Ape Tech Column
Code Ape Tech Column
Aug 5, 2024 · Backend Development

Design and Implementation of a Generic Asynchronous Processing SDK for Java Backend

This article describes a Java‑based asynchronous processing SDK that leverages Spring AOP, transactional event listeners, Kafka, XXL‑Job, and MySQL to provide non‑intrusive, reliable, and eventually consistent background execution of business methods while preserving transaction integrity and offering configurable retry and compensation strategies.

AOPAsyncKafka
0 likes · 8 min read
Design and Implementation of a Generic Asynchronous Processing SDK for Java Backend
macrozheng
macrozheng
Jul 4, 2024 · Backend Development

How to Secure Internal‑Only APIs with SpringBoot, Gateway, Redis, and AOP

This article explores three practical approaches—microservice isolation, Redis‑based whitelist, and gateway‑AOP header checks—to restrict certain APIs to internal network calls, and provides step‑by‑step SpringBoot code examples for implementing the preferred gateway‑AOP solution.

AOPAPI securitySpringBoot
0 likes · 7 min read
How to Secure Internal‑Only APIs with SpringBoot, Gateway, Redis, and AOP
Architect's Guide
Architect's Guide
Jul 3, 2024 · Backend Development

Hot‑Pluggable AOP Implementation in Spring: Dynamically Managing Advice

This article demonstrates how to implement hot‑pluggable AOP in Spring by allowing users to dynamically add or remove advice at runtime, covering prerequisite concepts, core logic, complete code examples, and test scenarios that show logging activation and deactivation without restarting the application.

AOPAdviceDynamic Plugin
0 likes · 9 min read
Hot‑Pluggable AOP Implementation in Spring: Dynamically Managing Advice
Top Architect
Top Architect
Jun 22, 2024 · Backend Development

Understanding Idempotency and Its Implementation with Custom Annotations in Java

This article explains the concept of idempotency, identifies which HTTP requests are naturally idempotent, discusses why idempotency is essential for retries, async callbacks, and message queues, and demonstrates a practical Java implementation using custom annotations, AOP, and Redis for token management.

AOPIdempotencyRedis
0 likes · 11 min read
Understanding Idempotency and Its Implementation with Custom Annotations in Java
Top Architect
Top Architect
Jun 19, 2024 · Backend Development

Standardizing Java API Interfaces and Controller Practices with ResultBean and AOP

The article explains common pitfalls in Java API design—such as inconsistent return formats, missing error handling, unnecessary parameters, and complex inputs—then proposes a unified ResultBean response model, controller conventions, and AOP-based logging and exception handling to improve code readability and maintainability.

AOPAPI designController
0 likes · 12 min read
Standardizing Java API Interfaces and Controller Practices with ResultBean and AOP