BestHub
Sign in
Tagged articles

AOP

635 articles · Page 3 of 7
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.

AOPAPI designController
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.

AOPDynamic PluginHot Plug
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.

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

AOPBytecode ManipulationJavassist
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.

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

AOPPersistenceRedis
0 likes · 25 min read
Comprehensive Guide to Spring State Machine: Concepts, Implementation, Persistence, and Troubleshooting
Shepherd Advanced Notes
Shepherd Advanced Notes
May 13, 2024 · Backend Development

Master Java Web Filters and Interceptors: Tutorials, Implementation Details, and Key Differences

This article explains the purpose, lifecycle, and configuration of Java Servlet Filters and Spring MVC Interceptors, compares their execution order with Spring AOP aspects, provides complete code examples for each component, and offers guidance on choosing the right mechanism for specific business requirements.

AOPInterceptoraspect
0 likes · 22 min read
Master Java Web Filters and Interceptors: Tutorials, Implementation Details, and Key Differences
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.

AOPAsyncCommon pitfalls
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.

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

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

AOPBeanFactoryCircular Dependency
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.

AOPSpring BootTransactional
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.

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

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

AOPThread Safetyannotations
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.

AOPSpring Bootannotations
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.

AOPSpring Bootcaching
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.

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

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

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

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

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

AOPSpringaspect-oriented-programming
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.

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

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

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

AOPCustom AnnotationData Permission
0 likes · 22 min read
Design and Implementation of a Flexible Data Permission System in Java
IT Niuke
IT Niuke
Jan 8, 2024 · Backend Development

How to Gracefully Switch Data Sources Dynamically in a SpringBoot Project

This article walks through implementing dynamic data‑source switching in SpringBoot by combining ThreadLocal with AbstractRoutingDataSource, covering manual code, configuration, annotation‑driven AOP, and runtime addition of new data sources, complete with test cases and sample code.

AOPAnnotationSpringBoot
0 likes · 17 min read
How to Gracefully Switch Data Sources Dynamically in a SpringBoot Project
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.

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

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

AOPDesign PatternsSpring
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.

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

AOPDARTFull‑Stack Logging
0 likes · 18 min read
Dart AOP‑Based Full Instrumentation for Flutter Applications
Architecture Digest
Architecture Digest
Nov 28, 2023 · Backend Development

Unified User Login Permission Validation, Exception Handling, and Data Formatting in Spring Boot

This article demonstrates how to implement unified user login permission checks, centralized exception handling, and consistent response formatting in Spring Boot using AOP, HandlerInterceptor, @ControllerAdvice, and ResponseBodyAdvice, providing step‑by‑step code examples and configuration details.

AOPException HandlingInterceptor
0 likes · 12 min read
Unified User Login Permission Validation, Exception Handling, and Data Formatting in Spring Boot
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 27, 2023 · Backend Development

Secure Spring Boot APIs with AOP and Spring Security: A Step‑by‑Step Guide

This article explains how to combine Spring AOP and Spring Security in a Spring Boot 2.7.12 application to implement permission verification, covering concepts, required dependencies, custom filters, annotations, aspect logic, global exception handling, test endpoints, JWT token handling, and extensions for SpEL‑based role checks.

AOPJWTPermission
0 likes · 11 min read
Secure Spring Boot APIs with AOP and Spring Security: A Step‑by‑Step Guide
Architecture Digest
Architecture Digest
Nov 23, 2023 · Backend Development

Using Redisson Distributed Locks with Custom Annotations in Java

This article explains how to apply Redisson's distributed lock in Java, demonstrates the basic lock and tryLock APIs, shows how to create a custom @DistributedLock annotation and an AOP aspect to handle locking automatically, and provides a practical usage example with two services.

AOPAnnotationRedisson
0 likes · 8 min read
Using Redisson Distributed Locks with Custom Annotations in Java
IT Architects Alliance
IT Architects Alliance
Nov 17, 2023 · Backend Development

Design and Implementation of a Generic Asynchronous Processing SDK

This article introduces a generic asynchronous processing SDK for Java Spring applications, covering its purpose, advantages, underlying principles, component choices such as Kafka, XXL‑Job, MySQL, design patterns, database schema, configuration via Apollo, usage instructions, safety considerations, and provides code examples and a GitHub repository link.

AOPKafkaMySQL
0 likes · 9 min read
Design and Implementation of a Generic Asynchronous Processing SDK
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 8, 2023 · Backend Development

Mastering Spring Boot Parameter Validation with JSR‑303, Groups, and AOP

Learn how to implement comprehensive parameter validation in Spring Boot 2.6.12 using JSR‑303 Bean Validation, covering simple checks, validation groups, single‑parameter validation, nested objects, custom utilities, internationalization, and unified AOP‑based handling with practical code examples and configuration steps.

AOPBean ValidationJSR-303
0 likes · 12 min read
Mastering Spring Boot Parameter Validation with JSR‑303, Groups, and AOP
Shepherd Advanced Notes
Shepherd Advanced Notes
Nov 1, 2023 · Backend Development

Implementing a Dynamic AOP Log Aspect for Unified API Parameter Logging in Spring Boot

The article explains why logging API request and response parameters is essential for debugging, shows how to configure environment‑ and interface‑level switches, defines a simple @ApiLog annotation, implements an AOP aspect that records request details and response results, and demonstrates separating logs via Logback configuration while noting performance considerations.

AOPApiLogAspectJ
0 likes · 15 min read
Implementing a Dynamic AOP Log Aspect for Unified API Parameter Logging in Spring Boot
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 23, 2023 · Backend Development

Boost Spring Performance: AOP Logging, Caching, Thread Pools & DB Optimizations

This article presents practical Spring performance optimization techniques—including AOP‑based logging, second‑level caching with @Cacheable, reducing database queries via fetch strategies, employing thread‑pool executors, and general database query tuning—to improve application speed and resource efficiency.

AOPDatabaseSpring
0 likes · 9 min read
Boost Spring Performance: AOP Logging, Caching, Thread Pools & DB Optimizations
Architect
Architect
Oct 17, 2023 · Backend Development

Ensuring DB‑Redis Consistency with a Delayed Double‑Delete Strategy in Spring Boot

The article explains how concurrent database updates can cause Redis cache inconsistency, introduces the delayed double‑delete solution, details each step of the algorithm, provides full Spring Boot AOP implementation code, demonstrates verification with test cases, and shares the complete project repository.

AOPCache ConsistencyDelayed Delete
0 likes · 11 min read
Ensuring DB‑Redis Consistency with a Delayed Double‑Delete Strategy in Spring Boot
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 13, 2023 · Fundamentals

Understanding Java Annotations and Custom Annotation Usage with Spring AOP

This article explains Java annotations, their purposes such as providing compiler metadata, generating code, runtime processing, and documentation, introduces built‑in and meta‑annotations, and demonstrates how to create and use custom annotations both via reflection and with Spring AOP for logging, including full code examples.

AOPCustomAnnotationSpring
0 likes · 7 min read
Understanding Java Annotations and Custom Annotation Usage with Spring AOP
LouZai
LouZai
Oct 7, 2023 · Backend Development

How Spring Resolves Circular Dependencies – In‑Depth Interview Guide

This article walks through Spring's three‑level cache mechanism and source‑code flow that break circular dependencies, illustrating each step with a concrete demo, explaining the role of AOP, and showing why each cache level is necessary.

AOPBeanFactoryCircular Dependency
0 likes · 14 min read
How Spring Resolves Circular Dependencies – In‑Depth Interview Guide
Java Architect Essentials
Java Architect Essentials
Oct 6, 2023 · Backend Development

Implementing Order Workflow with Spring Statemachine and Persistent State Storage

This article explains the fundamentals of finite‑state machines, introduces Spring Statemachine, demonstrates how to model an order lifecycle, configure persistence with in‑memory and Redis stores, and provides complete Java code for enums, configuration, services, controllers, listeners, testing, and exception‑handling improvements.

AOPPersistenceRedis
0 likes · 26 min read
Implementing Order Workflow with Spring Statemachine and Persistent State Storage
Java Architect Essentials
Java Architect Essentials
Oct 5, 2023 · Backend Development

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

This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes key concepts such as pointcuts, advice, aspects, and weaving, and provides step‑by‑step code examples—including simple and advanced use cases and detailed annotation usage—to help developers integrate AOP effectively into their Spring Boot applications.

AOPSpring AOPSpring Boot
0 likes · 17 min read
Understanding and Implementing AOP in Spring Boot: Concepts, Annotations, and Practical Examples
政采云技术
政采云技术
Sep 28, 2023 · Backend Development

Common Scenarios Where Spring @Transactional Fails and How to Avoid Them

This article explains the fundamentals of database transactions, introduces Spring's @Transactional annotation, and enumerates nine typical situations—such as incorrect method visibility, final methods, self‑invocation, unmanaged beans, multithreading, wrong propagation, swallowed exceptions, unsupported exception types, and non‑transactional storage engines—where transactions may not work as expected, offering guidance to prevent these pitfalls.

AOPSpringTransaction
0 likes · 13 min read
Common Scenarios Where Spring @Transactional Fails and How to Avoid Them
DeWu Technology
DeWu Technology
Sep 11, 2023 · Backend Development

Bytecode Enhancement for Method Call Interception and Performance Monitoring

The article introduces a lightweight bytecode‑enhancement framework that weaves interceptors directly into Java methods to record execution times and call hierarchies, avoiding proxy overhead, supporting synchronous, asynchronous and lambda scenarios, and enabling precise performance monitoring and tracing across micro‑service architectures.

AOPBytecodeInstrumentation
0 likes · 24 min read
Bytecode Enhancement for Method Call Interception and Performance Monitoring
Architect
Architect
Aug 29, 2023 · Fundamentals

Understanding AOP: From Joinpoint Design to Spring’s Dynamic Weaving

This article analyzes AOP’s origins, defines join points and cross‑cutting logic, designs interfaces based on the AOP Alliance specifications, and compares static versus dynamic weaving approaches, illustrating each step with Java code examples and diagrams to show how Spring implements AOP.

AOPDesign PatternsDynamic Weaving
0 likes · 10 min read
Understanding AOP: From Joinpoint Design to Spring’s Dynamic Weaving
Su San Talks Tech
Su San Talks Tech
Aug 24, 2023 · Backend Development

Simplify JWT Token Handling in Spring Using Custom Annotations & ThreadLocal

This article walks through the evolution of a Spring‑based JWT token validation solution, from passing HttpServletRequest into service methods to using a custom @NeedToken annotation, reflection, a base class, and finally ThreadLocal to ensure each request’s token is safely isolated in high‑concurrency environments.

AOPJWTSpring
0 likes · 13 min read
Simplify JWT Token Handling in Spring Using Custom Annotations & ThreadLocal
Architect
Architect
Aug 23, 2023 · Backend Development

How to Restrict Certain APIs to Internal Calls Only in a Microservice Architecture

This article examines three practical approaches for preventing external exposure of specific APIs—service isolation, gateway‑based Redis whitelist, and gateway‑plus‑AOP—evaluates their trade‑offs, and provides step‑by‑step Java code to implement the preferred AOP solution in a Spring Cloud environment.

AOPAPI securityGateway
0 likes · 8 min read
How to Restrict Certain APIs to Internal Calls Only in a Microservice Architecture
Su San Talks Tech
Su San Talks Tech
Aug 17, 2023 · Backend Development

Ensuring API Idempotency with Spring, Redis, and Custom Annotations

This article explains the concept of idempotency, identifies which HTTP methods are naturally idempotent, and demonstrates a complete Java Spring solution—including custom annotations, AOP handling, token generation, and Redis storage—to guarantee safe retry and duplicate‑request protection.

AOPAnnotationIdempotency
0 likes · 11 min read
Ensuring API Idempotency with Spring, Redis, and Custom Annotations
Architecture Digest
Architecture Digest
Aug 16, 2023 · Backend Development

Implementing Retry Mechanisms in Java: Manual Loops, Static Proxy, JDK Dynamic Proxy, CGLib, AOP, Spring Retry and Guava‑Retry

This article explains why retry mechanisms are essential for remote service calls, compares several implementation approaches—including manual loops, static and dynamic proxies, AOP, Spring Retry annotations, and Guava‑Retry—provides complete Java code examples, and discusses the advantages and drawbacks of each method.

AOPCGLIBGuava
0 likes · 15 min read
Implementing Retry Mechanisms in Java: Manual Loops, Static Proxy, JDK Dynamic Proxy, CGLib, AOP, Spring Retry and Guava‑Retry
Architect
Architect
Aug 15, 2023 · Backend Development

Mastering Retry Strategies in Java: From Manual Loops to Spring Retry and Guava

This article walks through seven retry implementations for Java services—manual loops, static proxy, JDK dynamic proxy, CGLib proxy, custom AOP, Spring Retry annotations, and Guava‑retry—showing code examples, analyzing their pros and cons, and recommending the best fit for different project contexts.

AOPCGLIBGuava
0 likes · 18 min read
Mastering Retry Strategies in Java: From Manual Loops to Spring Retry and Guava
Architect
Architect
Aug 9, 2023 · Backend Development

Dynamic Management of SpringBoot @Scheduled Tasks with SuperScheduled

This article explains how to enhance SpringBoot's native @Scheduled tasks with the spring-boot-starter-super-scheduled library, allowing dynamic creation, modification, and cancellation of scheduled jobs at runtime without altering existing annotations, and details the underlying implementation using BeanPostProcessor, CGLIB proxies, and a custom task manager.

AOPCGLIBDynamic Management
0 likes · 14 min read
Dynamic Management of SpringBoot @Scheduled Tasks with SuperScheduled
Shepherd Advanced Notes
Shepherd Advanced Notes
Jul 31, 2023 · Backend Development

How Spring Uses AOP to Implement Transaction Management

This article explains why transaction control is essential for database‑backed applications, compares native JDBC/MyBatis handling with Spring's unified approach, details the core transaction APIs, and walks through the AOP‑based mechanism—including @EnableTransactionManagement, proxy generation, and CGLIB interception—that automatically opens, commits, and rolls back transactions at runtime.

AOPCGLIBPlatformTransactionManager
0 likes · 20 min read
How Spring Uses AOP to Implement Transaction Management
Code Ape Tech Column
Code Ape Tech Column
Jul 25, 2023 · Backend Development

High‑Concurrency Seckill Implementation in SpringBoot: Locking Strategies and Performance Testing

This article demonstrates how to simulate a high‑concurrency flash‑sale scenario using SpringBoot, MySQL and JMeter, analyzes why naive lock‑and‑transaction code causes overselling, and presents six refined solutions—including controller‑level locking, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches—along with performance test results.

AOPJMeterLock
0 likes · 20 min read
High‑Concurrency Seckill Implementation in SpringBoot: Locking Strategies and Performance Testing
Shepherd Advanced Notes
Shepherd Advanced Notes
Jul 24, 2023 · Backend Development

Understanding the Core Principles of Spring AOP Aspect Programming

This article explains how Spring AOP integrates AspectJ using CGLIB or JDK dynamic proxies, walks through a complete logging aspect example, and details the internal registration, proxy creation, and invocation processes that enable cross‑cutting concerns without modifying business code.

AOPAspectJCGLIB
0 likes · 15 min read
Understanding the Core Principles of Spring AOP Aspect Programming
Selected Java Interview Questions
Selected Java Interview Questions
Jul 11, 2023 · Backend Development

Design and Implementation of a High‑Performance Distributed Cache with Redis and Caffeine for Spring Boot Services

This article outlines the design goals, architecture, and implementation details of a high‑performance distributed caching solution for Spring Boot applications, combining Redis as a first‑level cache with Caffeine as a second‑level cache, and provides configuration, usage examples, and future enhancement plans.

AOPCaffeineRedis
0 likes · 11 min read
Design and Implementation of a High‑Performance Distributed Cache with Redis and Caffeine for Spring Boot Services
Java High-Performance Architecture
Java High-Performance Architecture
Jul 9, 2023 · Backend Development

Master Spring Assert & Utility Classes: Essential Java Backend Tools

This article provides a comprehensive overview of Spring’s Assert utilities and a wide range of Spring Framework helper classes—including ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP utilities—detailing their purpose and key method signatures for Java backend development.

AOPSpringUtility
0 likes · 13 min read
Master Spring Assert & Utility Classes: Essential Java Backend Tools
Architecture Digest
Architecture Digest
Jun 30, 2023 · Backend Development

Comprehensive Guide to Implementing Rate Limiting in Java Microservices Using Guava, Sentinel, Redis, and a Custom Spring Boot Starter

This article explains why rate limiting is critical for microservice architectures, reviews common limiting algorithms, and provides step‑by‑step implementations using Dubbo, Spring Cloud, Guava token‑bucket, Sentinel, Redis+Lua, and a reusable Spring Boot starter with custom annotations and AOP.

AOPGuavaRedis
0 likes · 27 min read
Comprehensive Guide to Implementing Rate Limiting in Java Microservices Using Guava, Sentinel, Redis, and a Custom Spring Boot Starter
Selected Java Interview Questions
Selected Java Interview Questions
Jun 27, 2023 · Backend Development

Implementing Internal‑Only APIs with Microservice Isolation, Redis Whitelist, and Gateway + AOP

This article explores three practical solutions for exposing APIs only to internal services—microservice isolation, a Redis‑based whitelist via the gateway, and a gateway‑plus‑AOP approach—detailing their trade‑offs and providing complete Java code examples for the chosen method.

AOPGatewayaccess control
0 likes · 7 min read
Implementing Internal‑Only APIs with Microservice Isolation, Redis Whitelist, and Gateway + AOP
Architect's Tech Stack
Architect's Tech Stack
Jun 24, 2023 · Backend Development

Implementing Multi‑threaded Transactions in Spring Boot with Custom Annotations and AOP

This article explains why @Transactional fails in multithreaded Spring Boot scenarios, then demonstrates how to combine @Async, a custom thread‑pool, @MainTransaction and @SonTransaction annotations with AOP logic to achieve reliable multi‑threaded transaction control, complete with code examples and usage guidelines.

AOPCustom AnnotationTransaction
0 likes · 12 min read
Implementing Multi‑threaded Transactions in Spring Boot with Custom Annotations and AOP
Architect
Architect
Jun 22, 2023 · Backend Development

Understanding Spring’s Core Concepts: IoC, DI, AOP and Bean Management

The article explains how Spring’s IoC container, dependency injection, singleton beans, and AOP simplify Java backend development by abstracting object creation, configuration, and cross‑cutting concerns, illustrated with code examples and practical scenarios such as conditional bean loading and Redis client selection.

AOPIoCSpring
0 likes · 12 min read
Understanding Spring’s Core Concepts: IoC, DI, AOP and Bean Management
21CTO
21CTO
Jun 20, 2023 · Backend Development

Mastering Spring State Machine: Build Robust Order Workflows with Persistence

This article introduces the fundamentals of finite state machines, explains their four core concepts, demonstrates how to model order workflows with state diagrams, and provides a comprehensive guide to implementing, configuring, persisting, and testing Spring Statemachine in a Java backend, including solutions for exception handling and AOP enhancements.

AOPPersistenceSpring
0 likes · 23 min read
Mastering Spring State Machine: Build Robust Order Workflows with Persistence
Cognitive Technology Team
Cognitive Technology Team
Jun 11, 2023 · Backend Development

Unified Handling of ThreadLocal Issues in Java Projects

This article explains why ThreadLocal can cause information loss, corruption, or OOM in Java applications and presents two practical approaches—Java agent bytecode manipulation and proxy‑based thread‑pool wrappers—along with concrete Spring Sleuth implementations and testing results to ensure safe propagation and cleanup.

AOPSpringThreadLocal
0 likes · 5 min read
Unified Handling of ThreadLocal Issues in Java Projects
macrozheng
macrozheng
May 30, 2023 · Backend Development

Mastering Java Exception Handling: From Basics to Advanced Practices

This article explores Java's exception hierarchy, demonstrates proper use of try‑catch‑finally and return statements, shows how to define custom system, business, and third‑party exceptions, implements global handling with @RestControllerAdvice, and discusses monitoring and alerting strategies for robust backend development.

AOPException HandlingSpringBoot
0 likes · 15 min read
Mastering Java Exception Handling: From Basics to Advanced Practices
Top Architect
Top Architect
May 29, 2023 · Backend Development

Understanding Finite State Machines and Spring Statemachine for Order Processing in Java

This article explains the fundamentals of finite state machines, introduces the four core concepts of state, event, action, and transition, demonstrates how to model an order lifecycle with a state‑machine diagram, and provides a complete Spring Statemachine implementation—including enums, configuration, persistence (memory and Redis), listeners, testing, and solutions to common exception‑handling issues—complete with runnable Java code examples.

AOPPersistenceorder processing
0 likes · 26 min read
Understanding Finite State Machines and Spring Statemachine for Order Processing in Java
Java Interview Crash Guide
Java Interview Crash Guide
May 29, 2023 · Backend Development

How to Build a Clean Business Operation Log System with Spring AOP

This article explains the design and implementation of a business operation logging feature in a Spring Boot application, contrasting flawed hard‑coded approaches with a clean AOP‑based solution, and provides full code snippets, configuration, database schema, and testing tips.

AOPSpring Bootbackend development
0 likes · 16 min read
How to Build a Clean Business Operation Log System with Spring AOP
Cognitive Technology Team
Cognitive Technology Team
May 21, 2023 · Backend Development

Concurrency Safety Issues Caused by AOP Object Escape and Incorrect Advice Order in Spring

This article explains how improper use of AOP in Spring can cause object escape leading to concurrency safety problems, discusses issues such as asynchronous thread modifications, caching, and incorrect advice ordering with @Transaction, @Retryable, and dynamic datasource switching, and provides practical guidance to avoid these pitfalls.

AOPObject EscapeSpring
0 likes · 5 min read
Concurrency Safety Issues Caused by AOP Object Escape and Incorrect Advice Order in Spring
Code Ape Tech Column
Code Ape Tech Column
May 16, 2023 · Backend Development

Practical Guide to Spring StateMachine: Concepts, Implementation, and Persistence

This article introduces the fundamentals of finite‑state machines, explains the four core concepts of state, event, action and transition, and provides a step‑by‑step Spring Statemachine implementation with database schema, enum definitions, configuration, persistence options, testing, common pitfalls and an AOP‑based solution for reliable transaction handling.

AOPSpringStateMachine
0 likes · 27 min read
Practical Guide to Spring StateMachine: Concepts, Implementation, and Persistence
Shepherd Advanced Notes
Shepherd Advanced Notes
May 8, 2023 · Backend Development

Elegant Ways to Boost API Data Security in Spring Boot

The article explains how to protect Spring Boot APIs from unauthorized data access by adding data‑level permission checks, encrypting request parameters with AES and RSA, signing requests with SHA1WithRSA, and encapsulating the logic in a reusable @ApiSecurity annotation and AOP aspect.

AOPAPI securityAnnotation
0 likes · 22 min read
Elegant Ways to Boost API Data Security in Spring Boot
Alibaba Cloud Developer
Alibaba Cloud Developer
May 6, 2023 · Backend Development

Why Spring Throws Circular Dependency Errors and How to Fix Them

This article explains the causes of Spring circular dependency exceptions, details how Spring's three‑level cache and AOP proxy mechanisms contribute to the problem, and provides practical solutions such as using @Lazy, refactoring code, and ensuring a single AutoProxyCreator to prevent bean creation failures.

AOPBean CreationCircular Dependency
0 likes · 22 min read
Why Spring Throws Circular Dependency Errors and How to Fix Them
Su San Talks Tech
Su San Talks Tech
Apr 25, 2023 · Backend Development

Unlocking Spring’s Design Patterns: From Proxy to Adapter Explained

This article explores how Spring implements classic design patterns—Proxy, Strategy, Decorator, Singleton, Simple Factory, Factory Method, Observer, Template, and Adapter—detailing their purpose, core code snippets, and the way Spring leverages them to provide flexible, extensible, and maintainable backend functionality.

AOPDesign PatternsSpring
0 likes · 13 min read
Unlocking Spring’s Design Patterns: From Proxy to Adapter Explained