BestHub
Sign in
Tagged articles
585 articles
Page 2 of 6
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.

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

Custom AnnotationsJavaSpring 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.

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

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

Database FailoverMaster‑SlaveSpringBoot
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.

Dynamic Data SourceSpring Bootaop
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.

Javaaopin-query
0 likes · 10 min read
Optimizing Large IN Queries with Spring AOP and Multi‑Threaded Splitting
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.

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

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

JavaLog AuditingSpring Boot
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.

JavaOncePerRequestFilterRequest Logging
0 likes · 11 min read
Spring Boot Request Logging, Request/Response Wrappers, OncePerRequestFilter, and AOP Utility Classes
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.

Backend DevelopmentThree-level Cacheaop
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.

AuthenticationJavaSpring Cloud
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.

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

BackendJavaaccess control
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.

JavaReflectionaop
0 likes · 18 min read
Comprehensive Guide to Spring Framework Utility Classes and Their Usage
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Nov 5, 2024 · Backend Development

How CGLIB Powers Faster Java Dynamic Proxies – Inside FastClass and Bytecode Generation

This article explains CGLIB, a high‑performance bytecode library for creating Java dynamic proxies without interfaces, walks through implementation steps and core source‑code analysis, details the FastClass optimization that bypasses reflection, and compares CGLIB with JDK dynamic proxies.

Bytecode GenerationDynamic ProxyFastClass
0 likes · 22 min read
How CGLIB Powers Faster Java Dynamic Proxies – Inside FastClass and Bytecode Generation
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.

BackendJavaaop
0 likes · 20 min read
Why @Transactional Often Fails: 13 Real-World Pitfalls and How to Fix Them
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.

Backend DevelopmentFiltersRequest 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.

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

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

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

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

DynamicDataSourceMyBatis-PlusSpringBoot
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.

Code ExampleDecorator PatternJavaScript
0 likes · 11 min read
Understanding the Decorator Pattern and AOP in JavaScript
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.

Custom AnnotationError LoggingJava
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.

AspectProHarmonyOSHook Framework
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.

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

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

API SecurityMicroservicesSpringBoot
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.

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

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

ControllerException HandlingJava
0 likes · 12 min read
Standardizing Java API Interfaces and Controller Practices with ResultBean and AOP
Java Architect Essentials
Java Architect Essentials
Jun 11, 2024 · Backend Development

Why Consistent API Responses Matter: A Java Controller & AOP Guide

The article explains common pitfalls in Java API design—such as inconsistent return formats, missing error handling, irrelevant parameters, and improper use of maps or JSON strings—and demonstrates how adopting a unified ResultBean structure together with AOP can improve readability, error management, and testability of backend services.

BackendControllerJava
0 likes · 10 min read
Why Consistent API Responses Matter: A Java Controller & AOP Guide
Top Architect
Top Architect
Jun 4, 2024 · Backend Development

Dynamic Hot‑Pluggable AOP Implementation in Spring

This article explains how to let users dynamically enable or disable logging by managing Spring AOP advice at runtime, covering prerequisite concepts, core hot‑plug logic, detailed Java code for installing and removing plugins, a step‑by‑step demo, and a concise summary of the approach.

Dynamic PluginHot PlugJava
0 likes · 12 min read
Dynamic Hot‑Pluggable AOP Implementation in Spring
Architecture Digest
Architecture Digest
Jun 3, 2024 · Backend Development

Spring Statemachine for Order State Management with Persistence, Exception Handling, and AOP Logging

This article explains the fundamentals of finite state machines, introduces Spring Statemachine, demonstrates how to model order lifecycle states, configure persistence with memory and Redis, handle exceptions during state transitions, and use AOP to log transition results, providing complete Java code examples.

BackendJavaPersistence
0 likes · 23 min read
Spring Statemachine for Order State Management with Persistence, Exception Handling, and AOP Logging
Cognitive Technology Team
Cognitive Technology Team
May 23, 2024 · Backend Development

Modifying Bytecode Before Class Loading in Spring Cloud Using Javassist

This article demonstrates how to use Spring's ApplicationContextInitializer together with Javassist to intercept class loading in a Spring Cloud environment, modify the bytecode of org.apache.commons.lang3.RandomStringUtils, and record method calls, handling parent‑child container initialization nuances.

ApplicationContextInitializerBytecode ManipulationJava
0 likes · 5 min read
Modifying Bytecode Before Class Loading in Spring Cloud Using Javassist
Architect
Architect
May 15, 2024 · Backend Development

Hot‑Pluggable AOP in Spring: Dynamically Adding and Removing Advice

This article demonstrates how to implement a hot‑pluggable AOP solution in Spring by exposing endpoints that let users dynamically add or remove Advice, covering the underlying concepts, core implementation code, a demo service, and test scenarios that show logging being enabled and disabled at runtime.

BackendDynamicAdviceHotPluggable
0 likes · 10 min read
Hot‑Pluggable AOP in Spring: Dynamically Adding and Removing Advice
Code Ape Tech Column
Code Ape Tech Column
May 14, 2024 · Backend Development

Comprehensive Guide to Spring State Machine: Concepts, Implementation, Persistence, and Troubleshooting

This article explains the fundamentals of finite‑state machines, introduces Spring Statemachine’s core features, walks through a complete Java implementation with database schema, persistence (memory and Redis), REST APIs, exception handling, and an AOP‑based solution for reliable state transitions.

JavaPersistenceaop
0 likes · 25 min read
Comprehensive Guide to Spring State Machine: Concepts, Implementation, Persistence, and Troubleshooting
Su San Talks Tech
Su San Talks Tech
May 7, 2024 · Backend Development

9 Common Reasons Why @Async Doesn’t Work in Spring and How to Fix Them

This article explains nine typical scenarios that cause the Spring @Async annotation to fail—ranging from missing @EnableAsync to improper method visibility, return types, static or final modifiers, missing @Service, manual object creation, and incorrect component scanning—providing clear explanations and code examples for each case.

AsyncAsyncJava
0 likes · 10 min read
9 Common Reasons Why @Async Doesn’t Work in Spring and How to Fix Them
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 30, 2024 · Backend Development

Mastering Spring AOP: XML, Annotations, and ProxyFactoryBean Deep Dive

This article explains Spring AOP fundamentals, demonstrates XML‑based and annotation‑based configurations, and provides a comprehensive guide to using ProxyFactoryBean—including its properties, proxy‑interface and proxy‑class scenarios, CGLIB considerations, and wildcard interceptor matching—complete with runnable code examples.

ProxyFactoryBeanXMLannotations
0 likes · 9 min read
Mastering Spring AOP: XML, Annotations, and ProxyFactoryBean Deep Dive
DaTaobao Tech
DaTaobao Tech
Apr 29, 2024 · Backend Development

Refactoring Cache Logic with Spring Cache Annotations

The article explains how moving cache operations out of business code and into Spring Cache annotations—@Cacheable, @CachePut, and @CacheEvict—creates a clean, loosely‑coupled design, simplifies maintenance, and enables custom extensions such as breakdown protection and multi‑level caching for high‑concurrency applications.

Javaaopspring
0 likes · 6 min read
Refactoring Cache Logic with Spring Cache Annotations
Architect
Architect
Apr 28, 2024 · Backend Development

Understanding Spring's Circular Dependency Resolution with a Three‑Level Cache

This article explains how Spring solves circular dependencies by using a three‑level cache system, walks through the underlying source‑code execution flow, clarifies the purpose of each cache level, and discusses why the design is essential for AOP‑enabled beans.

Backend DevelopmentBeanFactoryJava
0 likes · 12 min read
Understanding Spring's Circular Dependency Resolution with a Three‑Level Cache
Cognitive Technology Team
Cognitive Technology Team
Apr 25, 2024 · Backend Development

Alibaba Java Interview: Does annotating the same Spring Boot service method with @Transactional and @Async cause transaction failure?

In Spring Boot, using @Transactional and @Async on the same service method does not invalidate the transaction, but the asynchronous execution runs in a separate thread with its own transaction, isolated from the original thread's transaction due to AOP interceptor ordering.

AsyncJavaSpring Boot
0 likes · 1 min read
Alibaba Java Interview: Does annotating the same Spring Boot service method with @Transactional and @Async cause transaction failure?
Java Architect Essentials
Java Architect Essentials
Apr 9, 2024 · Backend Development

Implementing Data Isolation in Java Applications Using MyBatis Interceptor and Custom Annotations

This article describes a Java data isolation solution that adds an 'env' field to tables, uses a MyBatis interceptor to rewrite SQL for environment‑aware queries, and introduces custom annotations with AOP to selectively skip environment checks, detailing implementation, challenges, and best practices.

BackendCustom AnnotationData Isolation
0 likes · 13 min read
Implementing Data Isolation in Java Applications Using MyBatis Interceptor and Custom Annotations
Code Ape Tech Column
Code Ape Tech Column
Mar 8, 2024 · Backend Development

Implementing Environment Isolation in MyBatis with a Custom Interceptor and Annotation

This article describes how to achieve data environment isolation in a Java application by creating a custom MyBatis interceptor and annotation, allowing automatic SQL modification to handle env fields, reducing code changes, improving safety, and supporting flexible deployment across pre‑release, gray, and production environments.

InterceptorJavaMyBatis
0 likes · 11 min read
Implementing Environment Isolation in MyBatis with a Custom Interceptor and Annotation
Java Captain
Java Captain
Mar 7, 2024 · Backend Development

Applying Java Annotations in Concurrent Programming

This article explores how Java's annotation mechanism, introduced in JDK 5.0, can be leveraged to address concurrency challenges by providing thread-safety, locking, timeout, and asynchronous execution annotations, and discusses their integration with AOP for enhanced thread management and performance.

JavaTimeoutannotations
0 likes · 5 min read
Applying Java Annotations in Concurrent Programming
Architect's Guide
Architect's Guide
Feb 25, 2024 · Backend Development

Understanding AOP in Spring Boot with Practical Code Examples

This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes its core concepts such as pointcuts, advice, aspects, join points and weaving, and provides multiple Spring Boot examples—including simple @GetMapping logging, custom permission annotations, and the use of various AOP annotations—complete with full source code snippets.

Aspect Oriented ProgrammingBackend DevelopmentJava
0 likes · 18 min read
Understanding AOP in Spring Boot with Practical Code Examples
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Feb 23, 2024 · Backend Development

Master Spring Boot 2.7: Bean Lifecycle, DI, AOP, Caching & More

This guide walks through essential Spring Boot 2.7.16 features—including bean lifecycle annotations, dependency injection methods, Java‑based configuration, conditional beans, event listeners, AOP, scheduled tasks, data access with Spring Data JPA, caching, exception handling, security, SpEL, configuration management, performance monitoring, and micro‑service components—providing concise code examples for each.

JavaMicroservicesSpring Boot
0 likes · 10 min read
Master Spring Boot 2.7: Bean Lifecycle, DI, AOP, Caching & More
Top Architect
Top Architect
Feb 18, 2024 · Backend Development

Designing Business Operation Logging: From AOP Annotations to Binlog‑Based Solutions

This article explores the motivations, benefits, and step‑by‑step implementations of business operation logging, starting with a simple AOP‑annotation approach, advancing to AOP combined with Spring Expression Language for richer context, and finally leveraging MySQL binlog and time‑window techniques for low‑level, reliable change capture.

BackendBinlogSpEL
0 likes · 18 min read
Designing Business Operation Logging: From AOP Annotations to Binlog‑Based Solutions
Architect
Architect
Feb 14, 2024 · Backend Development

Implementing Order Lifecycle Management with Spring Statemachine, Persistence, and AOP

This article explains the fundamentals of finite state machines, demonstrates how to model order states using Spring Statemachine, shows persistence options with in‑memory and Redis stores, and provides advanced techniques such as exception handling, extended state tracking, and AOP‑based result logging for reliable state transitions.

JavaOrder ManagementPersistence
0 likes · 23 min read
Implementing Order Lifecycle Management with Spring Statemachine, Persistence, and AOP
Architect
Architect
Feb 8, 2024 · Backend Development

From AOP Annotations to Binlog: Evolving Business Operation Logging Strategies

This article examines the progressive design of business operation logging—from a basic AOP‑annotation approach, through an AOP‑SpEL enhancement, to a binlog‑based time‑window solution—detailing each method's implementation steps, trade‑offs, and practical considerations for robust audit and monitoring in enterprise systems.

BackendBinlogSpEL
0 likes · 19 min read
From AOP Annotations to Binlog: Evolving Business Operation Logging Strategies
Selected Java Interview Questions
Selected Java Interview Questions
Feb 5, 2024 · Backend Development

Designing Business Operation Logging with AOP, SpEL, and Binlog: From Basic to Advanced Solutions

This article explores the evolution of business operation logging in a Java backend, starting from a simple AOP‑annotation approach, advancing to AOP combined with Spring Expression Language for richer context, and finally leveraging MySQL binlog with time‑window processing to achieve comprehensive, low‑intrusion audit trails.

BackendBinlogJava
0 likes · 15 min read
Designing Business Operation Logging with AOP, SpEL, and Binlog: From Basic to Advanced Solutions
Java Captain
Java Captain
Feb 4, 2024 · Backend Development

Understanding and Implementing Idempotency in Backend Services with Java and Redis

This article explains the concept of idempotency, identifies which API requests are naturally idempotent, discusses why idempotency is essential for retries, asynchronous callbacks, and message queues, and provides a step‑by‑step Java Spring implementation using custom annotations, AOP, and Redis for token management.

BackendIdempotencyJava
0 likes · 9 min read
Understanding and Implementing Idempotency in Backend Services with Java and Redis
Java Captain
Java Captain
Feb 4, 2024 · Fundamentals

Understanding Aspect-Oriented Programming (AOP) with a Spring Example

Aspect-Oriented Programming (AOP) separates cross‑cutting concerns such as logging, transactions, and security from core business logic, improving modularity, maintainability, and reusability, and the article explains its concepts, benefits, implementation methods (dynamic/static proxies, dedicated languages) and provides a Spring AOP code example.

Aspect Oriented ProgrammingJavaaop
0 likes · 4 min read
Understanding Aspect-Oriented Programming (AOP) with a Spring Example
Architect
Architect
Jan 31, 2024 · Backend Development

How to Build Distributed Multi‑Rule Rate Limiting with Redis and Spring AOP

This article explains how to implement multi‑rule rate limiting in a distributed Java application using Redis, covering String‑based counters, Zset timestamp storage, Lua scripts for atomic checks, custom @RateLimiter annotations, key generation logic, and an AOP interceptor that enforces the limits.

Distributed SystemsJavaLua
0 likes · 12 min read
How to Build Distributed Multi‑Rule Rate Limiting with Redis and Spring AOP
Architect
Architect
Jan 26, 2024 · Backend Development

Dynamic Hot‑Pluggable AOP in Spring: Managing Advice at Runtime

This article explains how to implement a hot‑pluggable AOP mechanism in Spring by dynamically adding or removing Advice through custom endpoints and event listeners, covering core concepts, implementation code, a demonstration, and best‑practice considerations for backend developers.

AdviceBackend DevelopmentDynamic Plugin
0 likes · 10 min read
Dynamic Hot‑Pluggable AOP in Spring: Managing Advice at Runtime
High Availability Architecture
High Availability Architecture
Jan 17, 2024 · Backend Development

Rate Limiting Algorithms: Fixed Window, Sliding Window, Leaky Bucket, and Token Bucket – Principles, Java Implementations, Pros & Cons

This article explains why rate limiting is essential for high‑concurrency systems, defines rate limiting, introduces four common algorithms (fixed‑window, sliding‑window, leaky‑bucket, token‑bucket), provides Java code examples for each, compares their advantages and disadvantages, and shows practical usage with Guava's RateLimiter and AOP annotations.

BackendJavaalgorithm
0 likes · 17 min read
Rate Limiting Algorithms: Fixed Window, Sliding Window, Leaky Bucket, and Token Bucket – Principles, Java Implementations, Pros & Cons
Selected Java Interview Questions
Selected Java Interview Questions
Jan 11, 2024 · Backend Development

Design and Implementation of a Flexible Data Permission System in Java

This article presents a comprehensive design and implementation of a customizable data permission framework for Java backend applications, detailing the requirements, rule table structure, strategy pattern handling, custom annotations, AOP integration, and practical examples with full source code snippets.

Custom AnnotationData PermissionJava
0 likes · 22 min read
Design and Implementation of a Flexible Data Permission System in Java
Selected Java Interview Questions
Selected Java Interview Questions
Jan 4, 2024 · Backend Development

Preventing Duplicate Form Submissions with a Redis‑Based Request Lock in Spring Boot

This article explains why duplicate form submissions occur, the risks they pose, and demonstrates a Spring Boot solution that uses a custom @RequestLock annotation together with Redis SETNX to generate a unique key and block rapid repeated requests, complete with project setup, code examples, and usage instructions.

JavaRequest LockSpring Boot
0 likes · 12 min read
Preventing Duplicate Form Submissions with a Redis‑Based Request Lock in Spring Boot
HomeTech
HomeTech
Jan 3, 2024 · Backend Development

Design and Implementation of a Generic Data‑Change Tracking and Dynamic Display System

This article presents a comprehensive solution for decoupled operation‑log recording in multi‑project backend systems, detailing the design goals, technology choices such as AOP, annotations, SpringEL and MongoDB, the system architecture, implementation steps, a practical case study, and future enhancements.

MongoDBannotationaop
0 likes · 11 min read
Design and Implementation of a Generic Data‑Change Tracking and Dynamic Display System
DaTaobao Tech
DaTaobao Tech
Dec 29, 2023 · Backend Development

Design Patterns and Practices for Fast, Stable Development in Taobao Innovation Projects

The article outlines how the Taobao “Calm Guard” project accelerates rapid‑iteration development by employing reusable patterns—including a Spring‑based Strategy registry, a hierarchical fatigue‑control framework, generic cache upsert via functional parameters, and precise AOP aspects—resulting in faster, more stable, and maintainable code.

Backend DevelopmentDesign PatternsJava
0 likes · 29 min read
Design Patterns and Practices for Fast, Stable Development in Taobao Innovation Projects
Architect
Architect
Dec 28, 2023 · Backend Development

How to Implement Distributed Multi‑Rule Rate Limiting with Redis and Lua

This article explains how to design and implement a distributed rate‑limiting solution that supports multiple concurrent rules—such as per‑minute and per‑hour limits—by analyzing the shortcomings of simple string counters, introducing atomic Lua scripts and Zset structures, and providing complete Java annotation and AOP code examples.

Distributed SystemsJavaLua
0 likes · 13 min read
How to Implement Distributed Multi‑Rule Rate Limiting with Redis and Lua
DeWu Technology
DeWu Technology
Dec 13, 2023 · Mobile Development

Dart AOP‑Based Full Instrumentation for Flutter Applications

By inserting a custom AopTransformer into Flutter’s front‑end compilation pipeline before optimization, the proposed Dart AOP solution automatically injects logging hooks that capture full‑stack user interaction paths and business state without modifying business code, delivering zero‑impact, maintainable instrumentation for improved debugging and app stability.

Code GenerationDARTFlutter
0 likes · 18 min read
Dart AOP‑Based Full Instrumentation for Flutter Applications