BestHub
Sign in
Tagged articles

AOP

647 articles · Page 2 of 7
Programmer XiaoFu
Programmer XiaoFu
Jul 14, 2025 · Backend Development

Free Your Hands: 6 SpringBoot Techniques for Automatic Common Field Filling

The article analyzes the repetitive maintenance of common fields like createTime and updateUser in SpringBoot CRUD services, presents six production‑tested strategies—including MyBatis‑Plus meta‑object handling, AOP with custom annotations, multi‑data‑source adaptation, distributed ID generation, caching, batch optimization, and audit logging—detailing implementations, pitfalls, and best‑practice recommendations that can cut code by 90% and boost development efficiency.

AOPBackendMyBatis-Plus
0 likes · 9 min read
Free Your Hands: 6 SpringBoot Techniques for Automatic Common Field Filling
Java Captain
Java Captain
Jul 10, 2025 · Backend Development

Mastering AOP in Spring Boot: From Basics to Practical Code

This article explains Aspect Oriented Programming, contrasts it with Object Oriented Programming, illustrates cross‑cutting concerns with real‑world examples, and provides a step‑by‑step guide—including Maven dependencies, annotation definitions, and execution expressions—to implement AOP in a Spring Boot application.

AOPJavaSpring Boot
0 likes · 6 min read
Mastering AOP in Spring Boot: From Basics to Practical Code
Top Architect
Top Architect
Jul 8, 2025 · Backend Development

How to Build a Robust Redis Distributed Lock with AOP and Auto‑Renewal

This article explains how to protect time‑consuming business operations using a Redis‑based distributed lock implemented with a custom annotation, Spring AOP interception, automatic lock renewal via a scheduled executor, and proper lock release, ensuring data consistency across concurrent requests.

AOPConcurrencyRedis
0 likes · 14 min read
How to Build a Robust Redis Distributed Lock with AOP and Auto‑Renewal
Cognitive Technology Team
Cognitive Technology Team
Jul 8, 2025 · Backend Development

Why Your Spring @Transactional Doesn’t Rollback: AOP Aspect Order Conflict Explained

An in‑depth analysis of a Spring transaction failure caused by a custom AOP aspect interfering with the default TransactionInterceptor, detailing the symptom, root cause, and step‑by‑step solutions—including adjusting aspect order, rethrowing exceptions, and manual rollback—to ensure reliable transaction management.

AOPAspect PrioritySpring
0 likes · 8 min read
Why Your Spring @Transactional Doesn’t Rollback: AOP Aspect Order Conflict Explained
IT Services Circle
IT Services Circle
Jul 6, 2025 · Backend Development

Must‑Know Spring & Java Interview Questions from Xiaomi Car Hiring

The article first marvels at the record‑breaking sales of Xiaomi's YU7 electric SUV, then provides a comprehensive set of Java and Spring interview questions—including B‑tree differences, MySQL hash indexes, ReentrantLock internals, Spring's circular‑dependency resolution, AOP principles, and Spring Cloud components—to help candidates prepare for Xiaomi's upcoming campus recruitment.

AOPJavaMySQL
0 likes · 24 min read
Must‑Know Spring & Java Interview Questions from Xiaomi Car Hiring
Architect
Architect
Jul 5, 2025 · Backend Development

Implementing a Robust Redis Distributed Lock with AOP and Auto-Extension in Java

Learn how to design and implement a Redis-based distributed lock in Java using custom annotations, AOP interception, and a scheduled executor to automatically extend lock expiration, ensuring safe concurrent access to critical resources while handling timeouts, retries, and thread interruptions.

AOPConcurrencyJava
0 likes · 12 min read
Implementing a Robust Redis Distributed Lock with AOP and Auto-Extension in Java
Java Architect Essentials
Java Architect Essentials
Jul 4, 2025 · Backend Development

5 Common Spring Transaction Pitfalls and How to Fix Them

This article explains five frequent scenarios where Spring @Transactional fails—such as internal method calls, non‑public methods, swallowed exceptions, final/static methods, and unsupported MySQL engines—and provides concrete solutions and best‑practice rules for reliable transaction management.

AOPBackendJava
0 likes · 9 min read
5 Common Spring Transaction Pitfalls and How to Fix Them
Architect
Architect
Jul 3, 2025 · Backend Development

Eliminate Repetitive Common Fields in Java Order Services with MyBatis-Plus, AOP, and JWT

This article presents a production‑tested, six‑step automation strategy—combining MyBatis‑Plus auto‑fill, AOP interceptors, JWT‑based user retrieval, multi‑data‑source handling, distributed ID generation, and audit logging—to completely remove manual maintenance of common fields like create_time and update_by in Java order modules, boosting efficiency and reducing bugs.

AOPMyBatis-Plusautomatic-fill
0 likes · 9 min read
Eliminate Repetitive Common Fields in Java Order Services with MyBatis-Plus, AOP, and JWT
Top Architect
Top Architect
Jun 18, 2025 · Backend Development

Unlock Spring Boot’s Hidden Power: Master Built‑in Features for Faster Development

This article explores Spring Boot’s powerful built‑in utilities—including request logging, content caching, once‑per‑request filters, AOP helpers, starter auto‑configuration, flexible property binding, asynchronous execution, Actuator monitoring, and SpEL expressions—showing how they streamline development, improve maintainability, and boost production‑grade reliability.

@AsyncAOPConfiguration
0 likes · 15 min read
Unlock Spring Boot’s Hidden Power: Master Built‑in Features for Faster Development
Architect's Guide
Architect's Guide
Jun 15, 2025 · Backend Development

Mastering Read‑Write Splitting in Spring Boot: A Complete Guide

This article explains how to implement database read‑write separation in a Spring Boot application by configuring master and slave data sources, creating a routing datasource, managing thread‑local context, and using an AOP‑based annotation to switch between read and write operations.

AOPDataSource RoutingJava
0 likes · 10 min read
Mastering Read‑Write Splitting in Spring Boot: A Complete Guide
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.

AOPBackendJTA
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.

AOPJavaMyBatis-Plus
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.

AOPAutomatic Field FillBackend
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.

AOPBackendJava
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.

AOPExceptionHandlingSecurity
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.

@Async@TransactionalAOP
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.

AOPJavaSpring Boot
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.

AOPJavaSpringBoot
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.

AOPJavaSpring
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.

AOPJavaMaster‑Slave
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.

AOPConcurrencyDatabase Optimization
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.

AOPBackendBinlog
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.

AOPJavaSpring
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 EngineJava
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.

AOPJWTJava
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 AnnotationsJava
0 likes · 7 min read
Implement Custom Annotations in Spring Boot for Logging, Security & Caching
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.

AOPJavaMySQL
0 likes · 15 min read
Implementing Dynamic MySQL Master‑Slave Switching in SpringBoot Using AOP and Custom Annotations
Java Backend Technology
Java Backend Technology
Feb 19, 2025 · Backend Development

Mastering Dynamic MySQL Master‑Slave Switching in SpringBoot with AOP

Learn how to implement dynamic MySQL master‑slave switching in a SpringBoot project using AOP and custom annotations, ensuring automatic failover to the master when a slave fails, with detailed configuration, code examples, and guidance for multiple data sources and Oracle integration.

AOPDatabase FailoverMaster‑Slave
0 likes · 15 min read
Mastering Dynamic MySQL Master‑Slave Switching in SpringBoot with AOP
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.

AOPJavaPerformance
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 ExpressionSpring Boot
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.

AOPConcurrencyJMeter
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.

AOPJavaPerformance
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.

AOPJavaLog Auditing
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.

AOPJavaOncePerRequestFilter
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 LifecycleDependency Injection
0 likes · 21 min read
Advanced Spring Interview Questions: Bean Lifecycle, AOP, Transactions, ApplicationContext vs BeanFactory, Type Conversion
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.

AOPAuthenticationJava
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.

AOPJavaMDC
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.

AOPAccess ControlBackend
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.

AOPJavaSpring
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.

@TransactionalAOPBackend
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.

AOPBackendContentCachingWrapper
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.

AOPJavaSpring
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.

@TransactionalAOPExceptionHandling
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.

AOPJavaMDC
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.

AOPJavaSpring
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.

AOPAbstractRoutingDataSourceDynamicDataSource
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