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

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

JWTSpring Bootaop
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.

Javaannotationaop
0 likes · 8 min read
Using Redisson Distributed Locks with Custom Annotations in Java
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 20, 2023 · Backend Development

Using Javaassist for Bytecode Manipulation: Creating, Modifying, and Enhancing Java Classes

This article introduces Javaassist, a Java library for runtime bytecode manipulation, and demonstrates how to view compiled bytecode, add Maven dependencies, generate new classes, modify existing ones, insert fields and methods, and apply AOP‑style enhancements without changing source code.

Code GenerationJavaJavaassist
0 likes · 6 min read
Using Javaassist for Bytecode Manipulation: Creating, Modifying, and Enhancing Java Classes
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.

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

Bean ValidationJSR-303Parameter Validation
0 likes · 12 min read
Mastering Spring Boot Parameter Validation with JSR‑303, Groups, and AOP
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.

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

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

BackendCustomAnnotationJava
0 likes · 7 min read
Understanding Java Annotations and Custom Annotation Usage with Spring AOP
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.

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

Aspect Oriented ProgrammingJavaSpring Boot
0 likes · 17 min read
Understanding and Implementing AOP in Spring Boot: Concepts, Annotations, and Practical Examples
Java High-Performance Architecture
Java High-Performance Architecture
Oct 2, 2023 · Backend Development

Designing AOP Interfaces: From Joinpoint Basics to Spring Implementation

This article explores how to design module interfaces using Aspect‑Oriented Programming in Java, covering AOP background, definition, pointcut identification, joinpoint interface design, advice abstraction, and both static and dynamic weaving techniques, with practical code examples and diagrams.

Aspect Oriented ProgrammingBackend DevelopmentJava
0 likes · 7 min read
Designing AOP Interfaces: From Joinpoint Basics to Spring Implementation
政采云技术
政采云技术
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.

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

InstrumentationJavaMethodInterception
0 likes · 24 min read
Bytecode Enhancement for Method Call Interception and Performance Monitoring
Architecture Digest
Architecture Digest
Aug 31, 2023 · Backend Development

Understanding AOP: Interface Design, Joinpoint, and Weaving Mechanisms

This article explains the background of Aspect‑Oriented Programming, how to identify and describe join points through interface design, the structure of the AOP Alliance Joinpoint API, and the static and dynamic weaving techniques used by frameworks such as Spring.

Aspect Oriented ProgrammingBackendJava
0 likes · 7 min read
Understanding AOP: Interface Design, Joinpoint, and Weaving Mechanisms
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.

Aspect Oriented ProgrammingDesign 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.

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

API SecurityMicroservicesSpring Cloud
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.

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

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

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

Dynamic ManagementJavaScheduled Tasks
0 likes · 14 min read
Dynamic Management of SpringBoot @Scheduled Tasks with SuperScheduled
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.

JMeterLockQueue
0 likes · 20 min read
High‑Concurrency Seckill Implementation in SpringBoot: Locking Strategies and Performance Testing
政采云技术
政采云技术
Jul 20, 2023 · Backend Development

Redesigning an Operation Log System: Architecture, Implementation Options, and Historical Data Migration

This article describes the challenges of scaling a multi‑system operation log platform, proposes a new unified log schema, compares non‑intrusive and intrusive collection approaches using Canal and AOP/annotations, and outlines a rule‑engine‑driven migration strategy for legacy log data.

Data MigrationJavaMicroservices
0 likes · 10 min read
Redesigning an Operation Log System: Architecture, Implementation Options, and Historical Data Migration
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.

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

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

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

Backendaccess controlaop
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.

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

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

Persistenceaopspring
0 likes · 23 min read
Mastering Spring State Machine: Build Robust Order Workflows with Persistence
Su San Talks Tech
Su San Talks Tech
Jun 14, 2023 · Backend Development

Delegating Authentication to Microservices with Custom Spring Annotations

This article explains how to move authentication from the gateway to individual Spring Cloud microservices by defining three custom annotations and an AOP aspect, while also covering Feign‑based calls and providing practical code examples for implementation.

AuthenticationAuthorizationCustom Annotations
0 likes · 9 min read
Delegating Authentication to Microservices with Custom Spring Annotations
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.

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

Custom ExceptionsException HandlingJava
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.

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

Backend DevelopmentJavaSpring Boot
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.

JavaObject Escapeaop
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.

BackendJavaStatemachine
0 likes · 27 min read
Practical Guide to Spring StateMachine: Concepts, Implementation, and Persistence
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.

Bean Creationaopcircular-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.

BackendDesign PatternsJava
0 likes · 13 min read
Unlocking Spring’s Design Patterns: From Proxy to Adapter Explained
Architecture Digest
Architecture Digest
Apr 21, 2023 · Backend Development

Implementing a Distributed Redis Lock with Spring AOP and Automatic Renewal

This article explains how to protect time‑consuming business operations by using Redis as a distributed lock, designing a custom @RedisLock annotation, applying Spring AOP to intercept methods, handling lock acquisition, expiration, renewal via a ScheduledExecutorService, and releasing the lock safely after execution.

JavaSpring Bootaop
0 likes · 12 min read
Implementing a Distributed Redis Lock with Spring AOP and Automatic Renewal
Selected Java Interview Questions
Selected Java Interview Questions
Apr 18, 2023 · Backend Development

Understanding the Spring Bean Lifecycle: Creation, Initialization, Usage, and Destruction

This article explains the complete Spring bean lifecycle—including creation, property filling, initialization, usage, and destruction—detailing how Spring manages object creation, dependency injection, AOP proxy generation, and lifecycle callbacks through various internal phases and extension points.

Javaaopbean-lifecycle
0 likes · 15 min read
Understanding the Spring Bean Lifecycle: Creation, Initialization, Usage, and Destruction
Su San Talks Tech
Su San Talks Tech
Apr 12, 2023 · Backend Development

Build a Switchable SpringBoot Rate Limiter with Guava and Redis

This tutorial walks through creating a reusable SpringBoot starter that combines Guava's local token‑bucket limiter and Redis's distributed limiter, allowing developers to toggle between them via a simple configuration property and integrate the solution seamlessly with AOP and conditional beans.

GuavaJavaSpringBoot
0 likes · 9 min read
Build a Switchable SpringBoot Rate Limiter with Guava and Redis
Architect's Guide
Architect's Guide
Apr 4, 2023 · Backend Development

Implementing Unified User Login, Exception Handling, and Data Response in Spring Boot with AOP and Interceptors

This article demonstrates how to use Spring Boot AOP and HandlerInterceptor to create a unified user login permission check, standardized exception handling with @ControllerAdvice, and consistent JSON response formatting, providing step‑by‑step code examples and configuration details for building robust backend services.

Exception HandlingInterceptorSpring Boot
0 likes · 19 min read
Implementing Unified User Login, Exception Handling, and Data Response in Spring Boot with AOP and Interceptors
Java Architect Essentials
Java Architect Essentials
Apr 3, 2023 · Backend Development

Implementing Internal/External API Isolation with Gateway, Redis Whitelist, and AOP in Java Microservices

This article explains three practical approaches—separate microservices, gateway + Redis whitelist, and gateway + AOP—to restrict external access to internal APIs, and provides a detailed Spring Cloud Gateway and AOP code implementation for Java microservice architectures.

API SecurityMicroservicesSpring Cloud Gateway
0 likes · 7 min read
Implementing Internal/External API Isolation with Gateway, Redis Whitelist, and AOP in Java Microservices
Wukong Talks Architecture
Wukong Talks Architecture
Mar 21, 2023 · Backend Development

Understanding Java Exception Handling: Classification, Bytecode Analysis, Best Practices, and Custom Exceptions

This article provides a comprehensive guide to Java exception handling, covering exception categories, bytecode‑level mechanisms, common pitfalls, Alibaba’s coding standards, best‑practice recommendations, custom exception design, and global handling strategies for RPC and HTTP services in Spring Boot.

Custom ExceptionsException HandlingJava
0 likes · 29 min read
Understanding Java Exception Handling: Classification, Bytecode Analysis, Best Practices, and Custom Exceptions
Architect's Guide
Architect's Guide
Mar 19, 2023 · Backend Development

Implementing Unified Functionality in Spring Boot: Authentication, Data Formatting, Exception Handling, and Interceptors

This article demonstrates how to build a unified processing module in Spring Boot by using AOP and HandlerInterceptor to centralize user login validation, standardize response formats, handle exceptions globally with @ControllerAdvice, and configure path prefixes, providing complete code examples and implementation details.

BackendException HandlingInterceptor
0 likes · 17 min read
Implementing Unified Functionality in Spring Boot: Authentication, Data Formatting, Exception Handling, and Interceptors
Java High-Performance Architecture
Java High-Performance Architecture
Mar 17, 2023 · Backend Development

Master Unified Login, Exception, and Response Handling in Spring Boot with AOP and Interceptors

This article walks through building a Spring Boot application that centralizes user login verification, exception handling, and response formatting by leveraging AOP, custom HandlerInterceptors, @ControllerAdvice, and ResponseBodyAdvice to create clean, maintainable backend code.

Exception HandlingInterceptorSpring Boot
0 likes · 20 min read
Master Unified Login, Exception, and Response Handling in Spring Boot with AOP and Interceptors
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 16, 2023 · Backend Development

Unlock Non‑Spring AOP with JVM‑Sandbox: A Practical Guide for Java Backend

JVM‑Sandbox provides a non‑intrusive, runtime AOP solution for Java backend applications, enabling developers to instrument code outside the Spring container, record traffic, hot‑fix vulnerabilities, simulate failures, and monitor Spring bean initialization, all through JVMTI, Instrumentation, and event‑driven modules.

InstrumentationJVMaop
0 likes · 17 min read
Unlock Non‑Spring AOP with JVM‑Sandbox: A Practical Guide for Java Backend
Top Architect
Top Architect
Dec 29, 2022 · Backend Development

Understanding Spring Bean Lifecycle and Circular Dependency Resolution

This article explains the core concepts of the Spring framework—including its container, bean definition readers, bean factories, and three‑level cache mechanism—while detailing how Spring resolves circular dependencies and integrates AOP during bean creation.

Javaaopbean-lifecycle
0 likes · 8 min read
Understanding Spring Bean Lifecycle and Circular Dependency Resolution
Su San Talks Tech
Su San Talks Tech
Dec 17, 2022 · Information Security

Integrating Data Permissions into RBAC: A Practical Guide

This article explains how to extend the classic Role‑Based Access Control (RBAC) model with fine‑grained data permissions, detailing rule definition, database design, role‑rule binding, and AOP‑based enforcement, and offers optimization tips such as rule groups for complex scenarios.

Data PermissionRBACRole-Based Access
0 likes · 8 min read
Integrating Data Permissions into RBAC: A Practical Guide
Top Architect
Top Architect
Dec 15, 2022 · Databases

Implementing Database Read‑Write Separation with Spring Boot and Dynamic DataSource Routing

This article explains how to achieve database read‑write separation in high‑concurrency scenarios using Spring Boot, Druid connection pool, dynamic DataSource routing, a ThreadLocal context holder, custom annotations, and AOP, providing complete configuration code and usage examples for both read and write operations.

DataSourceRoutingJavaReadWriteSplitting
0 likes · 12 min read
Implementing Database Read‑Write Separation with Spring Boot and Dynamic DataSource Routing
IT Architects Alliance
IT Architects Alliance
Dec 13, 2022 · Backend Development

Understanding Spring Transaction Management: @EnableTransactionManagement, Execution Principles, Propagation Mechanisms, and Forced Rollback

This article explains how Spring's @EnableTransactionManagement activates transaction support by registering advisors and proxy beans, details the core execution flow of transactional methods, explores various propagation scenarios with code examples, and demonstrates forced rollback and transaction synchronization techniques.

Javaaoppropagation
0 likes · 10 min read
Understanding Spring Transaction Management: @EnableTransactionManagement, Execution Principles, Propagation Mechanisms, and Forced Rollback
Top Architect
Top Architect
Dec 9, 2022 · Backend Development

Understanding Spring Transaction Management: @EnableTransactionManagement, Execution Flow, Propagation, and Forced Rollback

This article explains how Spring enables transaction management through @EnableTransactionManagement, details the underlying advisor and proxy mechanisms, describes the basic and detailed execution steps, explores propagation types with practical code examples, and shows how to force rollbacks and use TransactionSynchronization for lifecycle callbacks.

Javaaoppropagation
0 likes · 13 min read
Understanding Spring Transaction Management: @EnableTransactionManagement, Execution Flow, Propagation, and Forced Rollback
转转QA
转转QA
Dec 8, 2022 · Backend Development

Applying AOP to Reduce Coupling in a Data Construction Platform

This article explains how Aspect‑Oriented Programming (AOP) was introduced into a data construction platform to address high development effort, strong business coupling, and maintenance difficulty by isolating cross‑cutting concerns such as logging, thereby improving modularity, development speed, and code maintainability.

Aspect Oriented ProgrammingData PlatformSoftware Architecture
0 likes · 5 min read
Applying AOP to Reduce Coupling in a Data Construction Platform
ITPUB
ITPUB
Dec 5, 2022 · Information Security

Extending RBAC with Fine-Grained Data Permissions Using AOP

This article explains how to augment the classic Role‑Based Access Control (RBAC) model with row‑level data permissions, detailing rule definition, database design, role‑rule binding, and an AOP‑based implementation for dynamic SQL filtering.

Backend SecurityData PermissionRBAC
0 likes · 8 min read
Extending RBAC with Fine-Grained Data Permissions Using AOP
Su San Talks Tech
Su San Talks Tech
Nov 22, 2022 · Backend Development

Deep Dive into Spring Transaction: Source Code Walkthrough and Execution Flow

This article walks through the fundamentals of Spring's transaction management, presenting a practical example, detailed execution workflow, and step‑by‑step source‑code analysis—including bean creation, AOP proxy generation, transaction attribute retrieval, transaction start, commit, and rollback – to help developers master Spring transaction internals.

Backend DevelopmentJavaaop
0 likes · 12 min read
Deep Dive into Spring Transaction: Source Code Walkthrough and Execution Flow
Selected Java Interview Questions
Selected Java Interview Questions
Nov 17, 2022 · Backend Development

Spring Boot Login Authentication: Filters, Interceptors, AOP, ThreadLocal, and Parameter Resolver

This article presents a comprehensive Spring Boot tutorial on implementing non‑intrusive login authentication using three techniques—Filter, Interceptor, and AOP with custom annotations—plus extensions such as ThreadLocal storage and a Spring MVC argument resolver, complete with project setup, Maven dependencies, and test screenshots.

InterceptorParameter ResolverSpring Boot
0 likes · 13 min read
Spring Boot Login Authentication: Filters, Interceptors, AOP, ThreadLocal, and Parameter Resolver
Zhuanzhuan Tech
Zhuanzhuan Tech
Nov 16, 2022 · Backend Development

Design and Implementation of HunterConsumer and HunterProducer Components for RocketMQ Integration

This article explains the background of RocketMQ clusters, demonstrates typical Java consumer and producer usage, and introduces the AOP‑based HunterConsumer and HunterProducer components that simplify lifecycle management, configuration, and code reuse for backend developers working with messaging systems.

Component DesignJavaRocketMQ
0 likes · 15 min read
Design and Implementation of HunterConsumer and HunterProducer Components for RocketMQ Integration
Programmer DD
Programmer DD
Nov 15, 2022 · Backend Development

How to Restrict API Access to Internal Services Using Gateway and AOP

This article compares three approaches—microservice isolation, gateway with Redis whitelist, and a gateway‑plus‑AOP header strategy—to enforce internal‑only API access, and provides a complete Spring Cloud implementation with code examples and a diagram.

MicroservicesSpring Cloudaop
0 likes · 6 min read
How to Restrict API Access to Internal Services Using Gateway and AOP
Java Architect Essentials
Java Architect Essentials
Nov 6, 2022 · Backend Development

Implementing a Distributed Redis Lock with AOP and Automatic Renewal in Java

This article explains how to design and implement a distributed lock using Redis, Spring AOP annotations, and a scheduled executor to automatically extend lock expiration, providing complete Java code examples, configuration details, testing procedures, and best‑practice recommendations for handling long‑running business operations safely.

ScheduledExecutorServiceSpring Bootaop
0 likes · 12 min read
Implementing a Distributed Redis Lock with AOP and Automatic Renewal in Java
Top Architect
Top Architect
Oct 26, 2022 · Backend Development

Implementing Database Read‑Write Splitting with Spring Boot and Dynamic DataSource Routing

This article explains how to achieve database read‑write separation in high‑concurrency Java applications by configuring master and slave data sources, implementing a routing DataSource, managing context with ThreadLocal, defining a custom @DataSourceSwitcher annotation, and applying AOP to switch between read and write operations.

DataSource RoutingJavaSpring Boot
0 likes · 11 min read
Implementing Database Read‑Write Splitting with Spring Boot and Dynamic DataSource Routing
Java High-Performance Architecture
Java High-Performance Architecture
Oct 15, 2022 · Backend Development

How to Handwrite Spring AOP: From Concepts to Code Implementation

This article walks through the design and implementation of a hand‑written Spring AOP module, covering core concepts such as Advice, Pointcut, weaving, proxy creation, and the integration of these components into a bean lifecycle to enable method‑level enhancements without modifying source code.

Aspect Oriented ProgrammingBackend DevelopmentJava
0 likes · 17 min read
How to Handwrite Spring AOP: From Concepts to Code Implementation
Top Architect
Top Architect
Oct 11, 2022 · Backend Development

Implementing Distributed Locks with Redis and AOP in Spring Boot

This article explains how to protect time‑consuming business operations by using Redis as a distributed lock together with Spring AOP, covering annotation design, aspect implementation, lock acquisition, automatic renewal via a scheduled executor, and practical testing examples.

JavaScheduledExecutorServiceSpring Boot
0 likes · 15 min read
Implementing Distributed Locks with Redis and AOP in Spring Boot
37 Interactive Technology Team
37 Interactive Technology Team
Oct 10, 2022 · Frontend Development

AOP Techniques for Ajax and Jsonp in Front-End Development

The article explains how to use Aspect‑Oriented Programming to globally intercept and rewrite Ajax and JSONP requests—both native and framework based—by extending Function.prototype, overriding DOM methods, and employing ajax‑hook and Axios interceptors, culminating in a runnable demo that redirects traffic from a‑domain to b‑domain.

HookJSONPJavaScript
0 likes · 19 min read
AOP Techniques for Ajax and Jsonp in Front-End Development
Java Backend Technology
Java Backend Technology
Oct 10, 2022 · Backend Development

8 Hidden Spring Transaction Pitfalls That Can Break Your Java Apps

This article reveals ten common Spring transaction pitfalls—including private methods, final modifiers, self‑invocation, missing @Service, wrong propagation, non‑transactional databases, swallowed or wrong exceptions, multi‑threaded calls, and nested transaction rollbacks—that can silently disable transaction management in Java backend projects.

JavaPitfallsSpringBoot
0 likes · 9 min read
8 Hidden Spring Transaction Pitfalls That Can Break Your Java Apps
Code Ape Tech Column
Code Ape Tech Column
Oct 10, 2022 · Backend Development

Implementing Internal‑Only APIs in Spring Cloud: Microservice Isolation, Gateway Whitelist, and AOP Approaches

This article explains three practical solutions for exposing internal‑only APIs in a Spring Cloud environment—separating services, using a gateway with a Redis whitelist, and applying a gateway‑plus‑AOP strategy—complete with code examples and deployment tips.

Backend DevelopmentMicroservicesSpring Cloud
0 likes · 7 min read
Implementing Internal‑Only APIs in Spring Cloud: Microservice Isolation, Gateway Whitelist, and AOP Approaches
Programmer DD
Programmer DD
Oct 9, 2022 · Backend Development

Mastering Java Dynamic Proxies: JDK vs CGLIB Implementation and Pitfalls

This article explains the concepts, advantages, and limitations of Java's JDK dynamic proxy and CGLIB proxy, provides step‑by‑step code examples for user registration validation, compares their mechanisms, and summarizes when to choose each approach in real‑world applications.

Dynamic ProxyJDKJava
0 likes · 11 min read
Mastering Java Dynamic Proxies: JDK vs CGLIB Implementation and Pitfalls
Cognitive Technology Team
Cognitive Technology Team
Oct 3, 2022 · Backend Development

Spring Boot 2.7.1 Upgrade Alters AOP Advice Execution Order and Causes ThreadLocal Loss

After upgrading to Spring Boot 2.7.1 (Spring Framework 5.3.21), the execution order of @Around, @Before, and @After advice changes, leading to ThreadLocal data loss inside @Around, and the article explains the cause, reproduces the issue, and recommends using only @Around for reliable logic.

Advice OrderBackend DevelopmentSpring Boot
0 likes · 4 min read
Spring Boot 2.7.1 Upgrade Alters AOP Advice Execution Order and Causes ThreadLocal Loss