Skip to content
Tagged articles

AOP

500 articles · Page 4 of 5
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.

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

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

AOPGuavaJava
0 likes · 27 min read
Comprehensive Guide to Implementing Rate Limiting in Java Microservices Using Guava, Sentinel, Redis, and a Custom Spring Boot Starter
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 AnnotationJava
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.

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

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

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

AOPOrder Processingpersistence
0 likes · 26 min read
Understanding Finite State Machines and Spring Statemachine for Order Processing in Java
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.

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

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

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

AOPConcurrencyDistributed Lock
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.

AOPBean LifecycleJava
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.

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

AOPException HandlingInterceptor
0 likes · 19 min read
Implementing Unified User Login, Exception Handling, and Data Response in Spring Boot with AOP and Interceptors
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.

AOPBest PracticesException Handling
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.

AOPBackendException Handling
0 likes · 17 min read
Implementing Unified Functionality in Spring Boot: Authentication, Data Formatting, Exception Handling, 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.

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

AOPBean LifecycleJava
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.

AOPData PermissionRBAC
0 likes · 8 min read
Integrating Data Permissions into RBAC: A Practical Guide
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.

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

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

AOPAspect-Oriented ProgrammingData Platform
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.

AOPBackend SecurityData Permission
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.

AOPJavaSource Code Analysis
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.

AOPInterceptorLogin Authentication
0 likes · 13 min read
Spring Boot Login Authentication: Filters, Interceptors, AOP, ThreadLocal, and Parameter Resolver
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.

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

AOPConcurrencyDistributed Lock
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.

AOPDataSource RoutingJava
0 likes · 11 min read
Implementing Database Read‑Write Splitting with Spring Boot and Dynamic DataSource Routing
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.

AOPDistributed LockJava
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.

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

AOPJavaSpring
0 likes · 9 min read
8 Hidden Spring Transaction Pitfalls That Can Break Your Java Apps
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.

AOPCGLIBJDK
0 likes · 11 min read
Mastering Java Dynamic Proxies: JDK vs CGLIB Implementation and Pitfalls
Top Architect
Top Architect
Sep 24, 2022 · Backend Development

Understanding JDK and CGLIB Dynamic Proxies in Java

This article explains the principles, advantages, and implementation details of Java's JDK dynamic proxy and CGLIB proxy mechanisms, providing step‑by‑step code examples that demonstrate how to enhance method calls such as user registration with validation logic.

AOPCGLIBJDK
0 likes · 11 min read
Understanding JDK and CGLIB Dynamic Proxies in Java
Tencent Cloud Developer
Tencent Cloud Developer
Sep 13, 2022 · Databases

Implementing a Transparent Data Encryption Framework for Database Security

The article presents a transparent data‑encryption framework for database security that uses an AOP‑based driver interceptor to rewrite SQL, encrypt/decrypt sensitive fields, manage performance with locks and caching, support configurable algorithms via SPI/YAML, and guide a three‑phase migration with minimal code intrusion.

AOPDatabase SecuritySPI
0 likes · 11 min read
Implementing a Transparent Data Encryption Framework for Database Security
Architect's Guide
Architect's Guide
Aug 30, 2022 · Backend Development

Implementing Database Read‑Write Separation with Spring Boot

This article explains how to achieve database read‑write separation in high‑concurrency Java applications by configuring master‑slave data sources, implementing a routing datasource, managing context with ThreadLocal, and using custom annotations with AOP to switch between read and write databases at runtime.

AOPDataSource RoutingJava
0 likes · 10 min read
Implementing Database Read‑Write Separation with Spring Boot
Su San Talks Tech
Su San Talks Tech
Aug 25, 2022 · Backend Development

Mastering Spring Transactions: From Basics to Advanced Propagation Types

This article explains the origins and purpose of Spring transactions, demonstrates how to quickly set them up with code examples, explores key features and common pitfalls, and provides an in‑depth comparison of the REQUIRED, REQUIRES_NEW, and NESTED propagation types for robust backend development.

AOPBackendJava
0 likes · 21 min read
Mastering Spring Transactions: From Basics to Advanced Propagation Types
Cognitive Technology Team
Cognitive Technology Team
Aug 20, 2022 · Backend Development

Common Pitfalls of Spring Transaction Management and How to Avoid Them

This article explains common pitfalls of Spring's transaction management—including AOP proxy limitations, unchecked exception handling, self‑invocation, asynchronous execution, multiple data sources, and large transaction issues—and provides practical solutions such as using class‑based proxies, configuring rollback rules, and splitting transactions into smaller units.

AOPJavaSpring
0 likes · 6 min read
Common Pitfalls of Spring Transaction Management and How to Avoid Them
Architecture & Thinking
Architecture & Thinking
Aug 16, 2022 · Backend Development

Unveiling Spring AOP: A Deep Dive into Source Code and Proxy Mechanics

This article provides a comprehensive analysis of Spring AOP, covering its core concepts, configuration parsing, BeanFactoryPostProcessor and BeanPostProcessor mechanisms, namespace handling, the creation of advisors and advice from @Aspect annotations, and the proxy generation process that enables method interception.

AOPAspectJJava
0 likes · 32 min read
Unveiling Spring AOP: A Deep Dive into Source Code and Proxy Mechanics
Selected Java Interview Questions
Selected Java Interview Questions
Aug 16, 2022 · Backend Development

Spring Framework Design Patterns Overview

This article explains how Spring implements various design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation approaches, underlying principles, and practical code examples within the Spring container.

AOPSpringbackend development
0 likes · 13 min read
Spring Framework Design Patterns Overview
Java Backend Technology
Java Backend Technology
Aug 16, 2022 · Backend Development

Mastering Spring @Transactional: Propagation, Rollback, and Proxy Pitfalls

This article explains Spring’s transaction propagation behaviors, rollback mechanisms, common pitfalls such as self‑invocation and non‑public methods, and demonstrates how to correctly use @Transactional with AOP proxies, including practical code examples and solutions for ensuring transaction consistency.

@TransactionalAOPJava
0 likes · 9 min read
Mastering Spring @Transactional: Propagation, Rollback, and Proxy Pitfalls
Top Architect
Top Architect
Aug 6, 2022 · Backend Development

Practical Coding Techniques: Kafka Transaction Commit, Redis Distributed Lock Simplification, and Business Log Decoupling

This article shares several practical coding techniques for backend development, including how to commit Kafka transactions safely, simplify Redis distributed lock usage with Redisson, implement AOP-based method locking, and decouple business logging using thread pools and asynchronous processing.

AOPDistributed LockRedis
0 likes · 13 min read
Practical Coding Techniques: Kafka Transaction Commit, Redis Distributed Lock Simplification, and Business Log Decoupling
IT Architects Alliance
IT Architects Alliance
Aug 6, 2022 · Backend Development

Practical Coding Tips: Kafka Transaction Commit, Redis Distributed Lock Simplification, AOP Lock Annotation, and Business Log Decoupling

This article shares practical development techniques, including how to safely commit Kafka messages within transactions, simplify Redis distributed locks with Redisson, implement an AOP‑based lock annotation for method-level locking, and decouple business logging using asynchronous thread pools and helper utilities.

AOPDistributed LockJava
0 likes · 14 min read
Practical Coding Tips: Kafka Transaction Commit, Redis Distributed Lock Simplification, AOP Lock Annotation, and Business Log Decoupling
Top Architect
Top Architect
Aug 2, 2022 · Backend Development

Best Practices for API Design and Controller Standards in Java Backend Development

The article explains why a unified response format like ResultBean is essential for Java backend APIs, outlines common interface design mistakes, provides concrete coding guidelines for controllers, and demonstrates how to use AOP for exception handling and logging, all illustrated with practical code examples.

AOPJavaSpring
0 likes · 10 min read
Best Practices for API Design and Controller Standards in Java Backend Development
Wukong Talks Architecture
Wukong Talks Architecture
Jul 31, 2022 · Backend Development

Understanding Java Reflection, Class Loading, and Dynamic Proxy Mechanisms

This article provides a comprehensive guide to Java's reflection mechanism, class loading process, ClassLoader usage, and dynamic proxy techniques, illustrating how to inspect class structures, create objects, access fields and methods, retrieve generic type information, and implement both static and dynamic proxies with practical code examples.

AOPClassLoaderDynamicProxy
0 likes · 45 min read
Understanding Java Reflection, Class Loading, and Dynamic Proxy Mechanisms
Top Architect
Top Architect
Jul 28, 2022 · Backend Development

Spring @Transactional: Propagation Behaviors, Rollback Mechanism, and Self‑Invocation Pitfalls

This article explains Spring's @Transactional annotation, detailing the various transaction propagation options, the default rollback behavior for unchecked exceptions, common pitfalls such as self‑invocation and non‑public methods, and how to use AOP proxies like AopContext.currentProxy and @EnableAspectJAutoProxy to ensure proper transaction management.

@TransactionalAOPProxy
0 likes · 9 min read
Spring @Transactional: Propagation Behaviors, Rollback Mechanism, and Self‑Invocation Pitfalls
Java Backend Technology
Java Backend Technology
Jul 22, 2022 · Backend Development

Why Unified API Responses Matter: Mastering Spring Boot Controllers and AOP

This article explains common pitfalls in Java API design—such as inconsistent return formats, missing error handling, and inappropriate parameters—and demonstrates how a unified ResultBean, strict controller conventions, and AOP logging can dramatically improve code readability, maintainability, and error management in Spring Boot projects.

AOPAPI DesignJava
0 likes · 10 min read
Why Unified API Responses Matter: Mastering Spring Boot Controllers and AOP
Top Architect
Top Architect
Jul 19, 2022 · Backend Development

How Spring Resolves Circular Dependencies Using Early Exposure and Three‑Level Caches

The article explains Spring's three‑level cache mechanism—singletonObjects, earlySingletonObjects, and singletonFactories—and how early exposure combined with BeanPostProcessor hooks enables the framework to break circular dependencies while still applying AOP proxies before full bean initialization.

AOPBeanPostProcessorCircular Dependency
0 likes · 13 min read
How Spring Resolves Circular Dependencies Using Early Exposure and Three‑Level Caches
Architect's Tech Stack
Architect's Tech Stack
Jul 19, 2022 · Backend Development

Asynchronous Excel Import with Thread Pool and AOP in Java

This article explains how to handle large Excel uploads in Java by offloading parsing and validation to a thread pool, using the Template Method pattern to reduce boilerplate, and finally applying a custom AOP annotation to manage logging, error handling, and asynchronous execution in a clean, reusable way.

AOPAsynchronous ProcessingDesign Pattern
0 likes · 10 min read
Asynchronous Excel Import with Thread Pool and AOP in Java
Top Architect
Top Architect
Jul 11, 2022 · Backend Development

Spring Core Concepts and Building a Mini Framework Without Spring

This article explains Spring's core features such as IoC, DI and AOP, demonstrates creating a simple Hello World service with Spring Boot, then shows how to implement the same functionality using raw Servlets and finally builds a miniature Spring‑like framework with custom annotations, an IOC container and a dispatcher servlet.

AOPIoCJava
0 likes · 19 min read
Spring Core Concepts and Building a Mini Framework Without Spring
Zhuanzhuan Tech
Zhuanzhuan Tech
Jul 6, 2022 · Backend Development

Spring Expression Language (SpEL) Overview and Practical Usage

This article introduces Spring Expression Language (SpEL), explains its common syntax, demonstrates quick-start examples, shows real-world usage with AOP monitoring, and outlines its internal implementation, providing a concise guide for backend developers working with Spring.

AOPExpression LanguageJava
0 likes · 9 min read
Spring Expression Language (SpEL) Overview and Practical Usage
IT Architects Alliance
IT Architects Alliance
Jun 19, 2022 · Backend Development

Four Ways to Implement Generic Auth in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter

This article explains how to add a universal app‑key whitelist authentication feature to a Spring‑Boot web framework by using four different mechanisms—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and a Servlet Filter—while comparing their execution order and extensibility.

AOPArgumentResolverAuthentication
0 likes · 10 min read
Four Ways to Implement Generic Auth in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter
Top Architect
Top Architect
Jun 15, 2022 · Backend Development

Implementing Request-Level Locking with a Custom @ApiLock Annotation in Java

This article explains how to prevent duplicate backend requests caused by rapid user clicks by creating a reusable @ApiLock annotation that leverages distributed locks, generates lock keys from request parameters, and integrates an AOP aspect to acquire and release locks around controller methods.

AOPDistributedLockJava
0 likes · 14 min read
Implementing Request-Level Locking with a Custom @ApiLock Annotation in Java