BestHub
Sign in
Tagged articles
585 articles
Page 4 of 6
Code Ape Tech Column
Code Ape Tech Column
Sep 29, 2022 · Backend Development

Implementing a Redis Distributed Lock with AOP and Automatic Renewal in Spring Boot

This article explains how to protect time‑consuming business operations in a Spring Boot application by creating a custom @RedisLock annotation, using Redis as a distributed lock via AOP, implementing automatic lock renewal with a ScheduledExecutorService, and handling lock release and thread interruption.

JavaScheduledExecutorServiceSpring Boot
0 likes · 11 min read
Implementing a Redis Distributed Lock with AOP and Automatic Renewal in Spring Boot
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.

Backend DevelopmentDynamic ProxyJDK
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.

Data MigrationDatabase SecurityPerformance Optimization
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.

DataSource RoutingJavaRead-Write Separation
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.

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

Backend DevelopmentJavaaop
0 likes · 6 min read
Common Pitfalls of Spring Transaction Management and How to Avoid Them
Programmer DD
Programmer DD
Aug 18, 2022 · Backend Development

How to Build an Asynchronous Excel Upload Service with AOP and Thread Pools

This article explains how to handle time‑consuming Excel uploads by using a template‑method design, wrapping the process with an AOP aspect, and executing the actual upload asynchronously in a thread pool, while recording logs and error details for later inspection.

AsynchronousJavaTemplate Method
0 likes · 10 min read
How to Build an Asynchronous Excel Upload Service with AOP and Thread Pools
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.

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

Backend DevelopmentDesign PatternsFactory
0 likes · 13 min read
Spring Framework Design Patterns Overview
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.

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

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

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

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

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

BeanPostProcessorJavaThree-level Cache
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.

Javaaopasynchronous processing
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.

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

Expression LanguageJavaSpEL
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.

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

DistributedLockJavaannotation
0 likes · 14 min read
Implementing Request-Level Locking with a Custom @ApiLock Annotation in Java
Top Architect
Top Architect
Jun 12, 2022 · Backend Development

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

This article explains Spring's circular‑dependency solution, detailing the early‑exposure mechanism, the three‑level cache (singletonObjects, earlySingletonObjects, singletonFactories), how BeanPostProcessors and AOP proxies interact during bean creation, and why the third‑level cache is essential for correct bean wiring.

Backend DevelopmentBeanPostProcessorThree-level Cache
0 likes · 14 min read
How Spring Resolves Circular Dependencies Using Early Exposure and a Three‑Level Cache
Top Architect
Top Architect
May 21, 2022 · Backend Development

Understanding Spring Assert and Common Utility Classes in Java

This article introduces Spring's Assert utilities, explains the purpose and usage of various Spring‑provided helper classes such as ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, ReflectionUtils, and AOP utilities, and provides code snippets illustrating their typical methods for validation, conversion, and reflection tasks in Java backend development.

AssertJavaReflection
0 likes · 13 min read
Understanding Spring Assert and Common Utility Classes in Java
Sanyou's Java Diary
Sanyou's Java Diary
May 19, 2022 · Backend Development

Mastering Spring: Core Concepts, Modules, Annotations & Advanced Features

This comprehensive guide walks through Spring’s fundamentals—including IoC, DI, core modules, common annotations, AOP concepts, transaction management, MVC workflow, and Spring Boot auto‑configuration—while also covering advanced topics such as bean lifecycle, circular dependencies, proxy mechanisms, and an introduction to Spring Cloud.

IoCMVCSpring Boot
0 likes · 54 min read
Mastering Spring: Core Concepts, Modules, Annotations & Advanced Features
DaTaobao Tech
DaTaobao Tech
May 19, 2022 · Backend Development

Understanding Proxy Pattern and Spring Transaction Management

The article explains static and dynamic proxy patterns, demonstrates their Java implementations, and shows how Spring’s transaction management relies on dynamic AOP proxies—highlighting that internal calls within the same class bypass the proxy, preventing @Transactional methods from starting or rolling back transactions.

Dynamic ProxyJavaProxy Pattern
0 likes · 21 min read
Understanding Proxy Pattern and Spring Transaction Management
macrozheng
macrozheng
May 18, 2022 · Backend Development

Master Spring’s Assert and Utility Classes: Essential Tips & Code Samples

This guide explains Spring’s Assert utilities and a comprehensive set of core helper classes—including ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, AopUtils, and AopContext—detailing their purpose, typical use cases, and providing concise code examples for each method.

JavaUtility Classesaop
0 likes · 14 min read
Master Spring’s Assert and Utility Classes: Essential Tips & Code Samples
Code Ape Tech Column
Code Ape Tech Column
May 11, 2022 · Backend Development

Implementing Two-Level Cache with Caffeine and Redis in Spring Boot

This article explains the design and implementation of a two‑level caching architecture using local Caffeine cache as L1 and remote Redis as L2 in Spring Boot, covering manual cache handling, annotation‑based management with Spring Cache, and a custom annotation with AOP to minimize code intrusion.

Cache AnnotationCaffeineSpring Boot
0 likes · 17 min read
Implementing Two-Level Cache with Caffeine and Redis in Spring Boot
Programmer DD
Programmer DD
May 5, 2022 · Backend Development

Master Spring Retry: Using @Retryable for Elegant Failure Handling

This guide explains how Spring Boot’s @Retryable annotation enables elegant, annotation‑driven retry logic, covering dependency setup, enabling retry, method annotation with configurable parameters, recovery handling via @Recover, and important AOP‑related considerations to avoid common pitfalls.

Exception HandlingJavaRetryable
0 likes · 7 min read
Master Spring Retry: Using @Retryable for Elegant Failure Handling
Architecture Digest
Architecture Digest
Apr 26, 2022 · Backend Development

Implementing Request Logging with Spring AOP and Annotations

This article demonstrates how to create a request‑logging aspect in Spring Boot using AOP annotations, shows code for pointcuts, advices, high‑concurrency optimizations, exception handling, and trace‑ID propagation, and explains the underlying concepts and practical tips.

Javaaopaspectj
0 likes · 16 min read
Implementing Request Logging with Spring AOP and Annotations
Java Tech Enthusiast
Java Tech Enthusiast
Apr 23, 2022 · Backend Development

Spring AOP Tutorial with Code Examples

This Spring AOP tutorial explains how to modularize cross‑cutting concerns such as timing by defining an aspect with @Before, @After, @AfterReturning, @AfterThrowing and @Around advice, demonstrates refactoring a calculation service, and compares Spring’s proxy mechanisms to a custom JDK dynamic proxy implementation.

DynamicProxyJavaaop
0 likes · 17 min read
Spring AOP Tutorial with Code Examples
Top Architect
Top Architect
Apr 21, 2022 · Backend Development

Understanding AOP: Joinpoint Design, Advice, and Weaving in Java

This article explains the background, concepts, and implementation details of Aspect‑Oriented Programming in Java, covering joinpoint interface design, advice abstraction, static and dynamic weaving, and how Spring AOP applies these principles with illustrative code and diagrams.

AdviceAspect Oriented ProgrammingBackend Development
0 likes · 9 min read
Understanding AOP: Joinpoint Design, Advice, and Weaving in Java
Java Backend Technology
Java Backend Technology
Apr 16, 2022 · Backend Development

Why @Transactional Sometimes Fails in Spring and How to Fix It

This article explains three common situations where Spring's @Transactional annotation becomes ineffective—non‑public methods, internal self‑calls, and swallowed exceptions—detailing the underlying proxy mechanism, code examples, test results, and practical workarounds to ensure proper transaction management.

Exception HandlingJavaaop
0 likes · 12 min read
Why @Transactional Sometimes Fails in Spring and How to Fix It
Top Architect
Top Architect
Apr 15, 2022 · Backend Development

Implementing Request Logging with Spring AOP and TraceId

This article demonstrates how to create a Spring AOP request‑logging aspect that captures IP, URL, HTTP method, class method, parameters, results and execution time, and extends it with high‑concurrency handling, error logging, and TraceId propagation for better traceability.

JavaRequest Loggingaop
0 likes · 13 min read
Implementing Request Logging with Spring AOP and TraceId
Python Programming Learning Circle
Python Programming Learning Circle
Apr 8, 2022 · Fundamentals

A Comprehensive Guide to Python Decorators and Aspect-Oriented Programming (AOP)

This article explains the concept of Aspect‑Oriented Programming (AOP) and demonstrates how Python decorators—both function‑based and class‑based—can be used to implement AOP features such as pre‑ and post‑execution logic, handling arguments, preserving metadata with functools.wraps, and stacking multiple decorators.

Aspect Oriented ProgrammingPythonaop
0 likes · 18 min read
A Comprehensive Guide to Python Decorators and Aspect-Oriented Programming (AOP)
Java Backend Technology
Java Backend Technology
Apr 3, 2022 · Backend Development

Why @Transactional Fails in Spring and How to Fix It

This article explains three common reasons why the @Transactional annotation may not work in Spring—non‑public methods, self‑invocation, and catching exceptions—provides code examples for each case, and details the underlying proxy and transaction management mechanisms to help developers resolve the issues.

JavaSpring Bootaop
0 likes · 11 min read
Why @Transactional Fails in Spring and How to Fix It
Top Architect
Top Architect
Mar 21, 2022 · Backend Development

How Spring Resolves Bean Circular Dependencies with a Three‑Level Cache

This article explains Spring's bean lifecycle, the three‑level cache mechanism (singletonObjects, earlySingletonObjects, singletonFactories) used to break circular dependencies, the role of Aware interfaces and BeanPostProcessor, and why a second‑level cache is essential when AOP proxies are involved.

Backend DevelopmentThree-level Cacheaop
0 likes · 9 min read
How Spring Resolves Bean Circular Dependencies with a Three‑Level Cache
Top Architect
Top Architect
Mar 20, 2022 · Backend Development

Understanding Spring's @Transactional Annotation and Its AOP Implementation

This article explains how Spring's @Transactional annotation works by leveraging AOP and dynamic proxies, detailing the bean post‑processor, pointcut definition, proxy creation, interceptor chain, TransactionInterceptor logic, and the transaction commit/rollback process with illustrative code snippets and diagrams.

Javaaopspring
0 likes · 9 min read
Understanding Spring's @Transactional Annotation and Its AOP Implementation
Architecture Digest
Architecture Digest
Mar 16, 2022 · Backend Development

Spring Boot Super Scheduled: Dynamic Management and Enhancement of @Scheduled Tasks

This article introduces a Spring Boot starter that enhances native @Scheduled tasks with dynamic management capabilities, explains how to integrate the dependency, and details the underlying implementation using post‑processors, application runners, custom managers, and CGLIB‑based proxy chains to modify scheduling parameters at runtime.

Dynamic ManagementJavaScheduled Tasks
0 likes · 14 min read
Spring Boot Super Scheduled: Dynamic Management and Enhancement of @Scheduled Tasks
Java High-Performance Architecture
Java High-Performance Architecture
Mar 1, 2022 · Backend Development

Unlocking Spring: Core Principles, Design Patterns, and IoC Explained

This comprehensive guide walks through Spring's lightweight Java framework, covering its core principles, key features, advantages and drawbacks, the design patterns it employs, core modules, IoC container mechanics, bean scopes, lifecycle, dependency injection techniques, and AOP fundamentals, all illustrated with diagrams and code snippets.

Design PatternsIoCJava
0 likes · 48 min read
Unlocking Spring: Core Principles, Design Patterns, and IoC Explained
Java Captain
Java Captain
Feb 24, 2022 · Backend Development

How Spring Solves Bean Circular Dependencies Using a Three-Level Cache

This article explains how Spring's bean lifecycle and its three-level caching mechanism—singletonObjects, earlySingletonObjects, and singletonFactories—work together to resolve circular dependencies, especially when AOP proxies are involved, highlighting why a three‑cache approach is necessary.

Backend DevelopmentThree-level Cacheaop
0 likes · 9 min read
How Spring Solves Bean Circular Dependencies Using a Three-Level Cache
Java Backend Technology
Java Backend Technology
Feb 24, 2022 · Backend Development

Master Spring’s Core Utility Classes: Assertions, ObjectUtils, StringUtils, and More

This article provides a comprehensive overview of Spring Framework’s core utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—detailing their purpose and key method signatures for developers working on Java backend projects.

JavaReflectionaop
0 likes · 13 min read
Master Spring’s Core Utility Classes: Assertions, ObjectUtils, StringUtils, and More
Top Architect
Top Architect
Feb 16, 2022 · Backend Development

Understanding Spring AOP Annotations and Their Execution Order

This article explains the common Spring AOP annotations such as @Before, @After, @AfterReturning, @AfterThrowing and @Around, demonstrates how to set up a Spring Boot project, write an interface, implementation, aspect, and discusses execution order, multiple aspects, and proxy‑failure scenarios.

JavaProxyannotations
0 likes · 8 min read
Understanding Spring AOP Annotations and Their Execution Order
Top Architect
Top Architect
Feb 14, 2022 · Backend Development

Common Spring Framework Utility Classes: Assertions, ObjectUtils, StringUtils, CollectionUtils, File/Resource IO, Reflection and AOP Helpers

This article presents a curated collection of Spring Framework utility classes—including assertion helpers, object/array/collection utilities, file and resource IO tools, as well as reflection and AOP utilities—providing ready‑to‑use methods that replace many custom helper functions in Java backend development.

Backend DevelopmentJavaReflection
0 likes · 13 min read
Common Spring Framework Utility Classes: Assertions, ObjectUtils, StringUtils, CollectionUtils, File/Resource IO, Reflection and AOP Helpers
Zhongtong Tech
Zhongtong Tech
Jan 10, 2022 · Backend Development

How ZTO Built a Unified Test Tool Platform to Boost Efficiency

This article describes how ZTO's testing team created a centralized test‑tool platform that integrates front‑end and back‑end services, standardizes tool access, tracks usage via AOP, supports data generation, order creation, tracking, MQ messaging, and other platform integrations to dramatically improve testing productivity.

Backend DevelopmentData GenerationMQ
0 likes · 11 min read
How ZTO Built a Unified Test Tool Platform to Boost Efficiency
Top Architect
Top Architect
Dec 23, 2021 · Backend Development

Implementing Custom Logging with Spring AOP and Annotations

This article explains how to create a custom logging solution in Spring by defining annotation-based AOP aspects, configuring pointcuts, handling various advice types, and persisting log details such as user, operation, parameters, and results into a database using Java code examples.

Custom AnnotationJavaaop
0 likes · 14 min read
Implementing Custom Logging with Spring AOP and Annotations
Java Interview Crash Guide
Java Interview Crash Guide
Dec 21, 2021 · Backend Development

How to Implement Custom Logging with Spring AOP and Annotations

This guide explains how to create a custom Spring AOP logging solution by defining a @SystemCrmlog annotation, extracting its parameters via pointcuts, and persisting detailed log entries—including user, method, parameters, and execution results—to a database using aspect advice methods.

Custom AnnotationJavaaop
0 likes · 15 min read
How to Implement Custom Logging with Spring AOP and Annotations
Su San Talks Tech
Su San Talks Tech
Dec 15, 2021 · Backend Development

Top 18 Spring Interview Questions and Answers You Must Know

Explore a comprehensive list of 18 essential Spring interview questions covering design patterns, core modules, IoC, DI, AOP, proxy types, bean lifecycle, circular dependency resolution, transaction management, and Spring Boot auto‑configuration, complete with concise explanations and illustrative diagrams to help you ace your interview.

BackendIoCaop
0 likes · 17 min read
Top 18 Spring Interview Questions and Answers You Must Know
Top Architect
Top Architect
Dec 11, 2021 · Backend Development

Proxy vs. Decorator Patterns and DIY Spring AOP Implementation in Java

This article explains the proxy and decorator design patterns using a coffee analogy, provides complete Java code examples for static and dynamic proxies, discusses their differences, and shows how to implement a Spring‑like AOP mechanism with JDK InvocationHandler and cglib, while also warning about their limitations.

DecoratorDynamic ProxyJava
0 likes · 11 min read
Proxy vs. Decorator Patterns and DIY Spring AOP Implementation in Java
Sohu Tech Products
Sohu Tech Products
Dec 8, 2021 · Mobile Development

Understanding Android App Routing: Concepts, Requirements, and Implementation

This article explains the concept of routing in Android applications, discusses why third‑party routing frameworks are often needed for large, componentized apps, outlines the essential features of a routing framework, and details the implementation techniques such as annotation processing, AOP injection, and service routing with concrete code examples.

ARouterAndroidAnnotation Processing
0 likes · 14 min read
Understanding Android App Routing: Concepts, Requirements, and Implementation
TikTok Frontend Technology Team
TikTok Frontend Technology Team
Dec 3, 2021 · Backend Development

Designing a Microservice Node.js Framework Based on Koa

This article explores Koa’s core AOP‑based architecture, demonstrates minimal implementations using koa‑compose and Node.js http, and proposes a microservice‑oriented framework that extends Koa to support HTTP, Thrift, WebSocket and other services, complete with abstract server designs and example code.

KoaMicroservicesNode.js
0 likes · 14 min read
Designing a Microservice Node.js Framework Based on Koa
Architect
Architect
Nov 29, 2021 · Backend Development

Common Scenarios Where Spring Transactions Fail and How to Fix Them

This article explains why Spring's @Transactional annotation can silently fail in many typical situations—such as incorrect method visibility, final methods, self‑invocation, unmanaged beans, multithreading, non‑transactional tables, missing configuration, wrong propagation or rollback settings, nested transaction behavior, and oversized transaction scopes—and provides practical solutions to ensure reliable transaction management.

aopexception-handlingspring
0 likes · 16 min read
Common Scenarios Where Spring Transactions Fail and How to Fix Them
Programmer DD
Programmer DD
Nov 16, 2021 · Backend Development

Why @Transactional Might Fail in Spring and How to Fix It

This article explains common reasons why Spring's @Transactional annotation can become ineffective—such as self‑invocation, non‑public methods, multiple data sources, incorrect rollback settings, and unsupported database engines—and provides concrete code examples and solutions to ensure proper transaction management.

BackendJavaaop
0 likes · 7 min read
Why @Transactional Might Fail in Spring and How to Fix It
Top Architect
Top Architect
Nov 14, 2021 · Backend Development

Implementing a Request Logging Aspect with Spring AOP

This article demonstrates how to create a Spring AOP request‑logging aspect that captures request details, parameters, results, execution time, and error information, and discusses enhancements for high‑concurrency environments by aggregating log data into a single JSON object.

JavaRequest Loggingaop
0 likes · 12 min read
Implementing a Request Logging Aspect with Spring AOP
Code Ape Tech Column
Code Ape Tech Column
Nov 13, 2021 · Backend Development

Spring Framework Interview Questions and Answers Overview

This article compiles a comprehensive set of Spring interview questions covering design patterns, core modules, IoC, DI, AOP, proxy mechanisms, bean lifecycle, circular dependency resolution, transaction isolation and propagation, as well as Spring Boot auto‑configuration principles, providing concise explanations for each topic.

Design PatternsIoCJava
0 likes · 16 min read
Spring Framework Interview Questions and Answers Overview
macrozheng
macrozheng
Nov 11, 2021 · Backend Development

Mastering Spring Boot Read/Write Splitting with Custom Routing DataSource

This tutorial explains how to implement read/write splitting in Spring Boot by configuring multiple data sources, creating a custom AbstractRoutingDataSource, and using AOP to dynamically route queries to master or slave databases based on method patterns and annotations.

MyBatisRouting DataSourceSpring Boot
0 likes · 17 min read
Mastering Spring Boot Read/Write Splitting with Custom Routing DataSource
21CTO
21CTO
Nov 9, 2021 · Backend Development

Mastering Elegant Operation Log Design with AOP and SpEL in Java

This article explains how to implement clean, decoupled operation logs in Java applications using AOP, SpEL, custom annotations, and dynamic templates, covering use cases, implementation methods, code examples, parsing logic, context handling, and integration with Spring Boot.

JavaOperation LogSpEL
0 likes · 27 min read
Mastering Elegant Operation Log Design with AOP and SpEL in Java
dbaplus Community
dbaplus Community
Nov 8, 2021 · Backend Development

How to Elegantly Implement Decoupled Operation Logging with AOP in Spring

This article explains the difference between system and operation logs, presents common log formats, and provides step‑by‑step implementations—including Canal binlog listening, log‑file recording, LogUtil helpers, and a full AOP‑based @LogRecord solution—while detailing template parsing, context handling, custom functions, and persistence in a Spring Boot environment.

CanalJavaLogRecord
0 likes · 27 min read
How to Elegantly Implement Decoupled Operation Logging with AOP in Spring
Selected Java Interview Questions
Selected Java Interview Questions
Nov 5, 2021 · Backend Development

Implementing a Generic Appkey Whitelist Validation in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter Approaches

This article explains how to add a reusable appkey whitelist check to a Spring‑Boot web framework by comparing four implementation methods—traditional AOP, Spring Interceptor, custom ArgumentResolver, and Servlet Filter—detailing their code, configuration steps, extensions, and execution order.

ArgumentResolverInterceptorJava
0 likes · 10 min read
Implementing a Generic Appkey Whitelist Validation in Spring Boot: AOP, Interceptor, ArgumentResolver, and Filter Approaches
Top Architect
Top Architect
Oct 22, 2021 · Backend Development

Understanding AOP: AspectJ, Spring AOP, and CGLIB – A Practical Guide

This article explains the fundamentals of Aspect‑Oriented Programming, introduces AspectJ as a standalone AOP solution, demonstrates how to implement a HelloWorld example with compile‑time weaving, compares it with Spring AOP’s runtime proxies, and shows how CGLIB can be used for proxy generation.

Javaaopaspectj
0 likes · 9 min read
Understanding AOP: AspectJ, Spring AOP, and CGLIB – A Practical Guide
macrozheng
macrozheng
Oct 22, 2021 · Backend Development

Mastering API Rate Limiting in Spring Boot: Algorithms, Guava & AOP

This tutorial explains why API rate limiting is essential for high‑traffic Spring Boot services, introduces counter, leaky‑bucket, and token‑bucket algorithms, shows how to use Guava's RateLimiter, and demonstrates a clean custom‑annotation AOP solution to decouple rate‑limiting logic from business code.

GuavaJavaSpring Boot
0 likes · 13 min read
Mastering API Rate Limiting in Spring Boot: Algorithms, Guava & AOP
Programmer DD
Programmer DD
Oct 19, 2021 · Backend Development

Mastering Read/Write Splitting in Spring Boot with Custom Routing DataSource

This article explains how to implement read/write separation in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, using AOP to switch between master and slave databases, and demonstrates the setup with Maven, MyBatis, and JUnit tests.

Multi-DataSourceMyBatisRouting DataSource
0 likes · 16 min read
Mastering Read/Write Splitting in Spring Boot with Custom Routing DataSource
Code Ape Tech Column
Code Ape Tech Column
Oct 9, 2021 · Backend Development

Common Scenarios Where Spring Transactions Fail and How to Fix Them

This article explains why Spring @Transactional may become ineffective or fail to roll back in various situations—such as wrong method visibility, final modifiers, internal calls, missing Spring bean registration, multithreading, unsupported table engines, misconfigured propagation, swallowed exceptions, and improper rollback settings—while also offering practical solutions and best‑practice recommendations.

BackendJavaaop
0 likes · 19 min read
Common Scenarios Where Spring Transactions Fail and How to Fix Them
Top Architect
Top Architect
Oct 6, 2021 · Backend Development

Understanding Spring AOP Proxy Creation and Common Pitfalls

This article explains how Spring AOP weaves aspect code using dynamic proxies, why internal calls via this bypass proxy logic, and how to correctly configure and obtain proxied beans using JDK/CGLIB proxies, @EnableAspectJAutoProxy, @Autowired injection, and AopContext.

JavaProxyaop
0 likes · 4 min read
Understanding Spring AOP Proxy Creation and Common Pitfalls
High Availability Architecture
High Availability Architecture
Sep 28, 2021 · Backend Development

Elegant Design and Implementation of Operation Logging Using AOP and Dynamic Templates

This article explains the differences between system and operation logs, explores various implementation methods such as Canal, file logging, LogUtil, and method annotations, and demonstrates how to achieve clean, dynamic, and decoupled operation logging in Java Spring applications using AOP, SpEL, custom functions, and a well‑structured logging context.

BackendJavaSpEL
0 likes · 25 min read
Elegant Design and Implementation of Operation Logging Using AOP and Dynamic Templates
Java Architect Essentials
Java Architect Essentials
Sep 25, 2021 · Backend Development

Implementing Read‑Write Splitting in Spring Boot with AbstractRoutingDataSource and AOP

This article explains how to achieve read‑write splitting in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, managing routing keys with ThreadLocal, and using AOP to automatically switch between master and slave databases for different CRUD operations.

DataSource RoutingJavaMyBatis
0 likes · 12 min read
Implementing Read‑Write Splitting in Spring Boot with AbstractRoutingDataSource and AOP
JavaEdge
JavaEdge
Sep 25, 2021 · Backend Development

Why Spring AOP Doesn’t Apply to ‘this’ Calls and How to Fix It

This article explains why Spring AOP proxies are not applied when a bean invokes its own methods via the this reference, compares JDK and CGLIB proxy mechanisms, and shows how to enable proxy exposure or use AopContext to achieve the desired AOP behavior.

JDKJavaProxy
0 likes · 5 min read
Why Spring AOP Doesn’t Apply to ‘this’ Calls and How to Fix It
Beike Product & Technology
Beike Product & Technology
Sep 17, 2021 · Frontend Development

Flutter for Web: Architecture, Platform Issues, and Disaster‑Recovery Solutions at Beike

This article describes how Beike's Flutter team leveraged Flutter for Web to enable rapid online issue mitigation, detailing the compilation pipeline, platform‑specific challenges such as operating‑system detection and dart:io limitations, and the multi‑module disaster‑recovery architecture they built.

Platform ChannelWebaop
0 likes · 13 min read
Flutter for Web: Architecture, Platform Issues, and Disaster‑Recovery Solutions at Beike
Meituan Technology Team
Meituan Technology Team
Sep 16, 2021 · Backend Development

Elegant Operation Log Recording in Backend Systems Using AOP and Annotations

The article demonstrates how to implement elegant, business‑logic‑independent operation logging in Java back‑ends by using AOP‑driven annotations, SpEL dynamic templates, custom parse functions, thread‑local context, and a Spring Boot starter, offering flexible persistence and automatic operator retrieval.

BackendJavaOperation Log
0 likes · 27 min read
Elegant Operation Log Recording in Backend Systems Using AOP and Annotations
Architect's Guide
Architect's Guide
Sep 10, 2021 · Backend Development

Implementing Database Read‑Write Separation with Spring Boot

This article explains how to achieve database read‑write separation in high‑concurrency scenarios using Spring Boot, covering the concepts of master‑slave architecture, configuration of multiple data sources, routing logic with AbstractRoutingDataSource, context management, custom annotations, AOP handling, and practical usage examples with code snippets.

DataSource RoutingJavaSpring Boot
0 likes · 11 min read
Implementing Database Read‑Write Separation with Spring Boot
Su San Talks Tech
Su San Talks Tech
Sep 4, 2021 · Backend Development

Why Spring Transactions Fail: 7 Common Pitfalls and How to Fix Them

This article explores why Spring transactions may fail, covering seven common pitfalls such as incorrect method visibility, final methods, internal calls, missing Spring management, multithreading, unsupported table engines, and misconfigured propagation, and provides practical solutions to ensure reliable transaction handling.

Backendaopspring
0 likes · 19 min read
Why Spring Transactions Fail: 7 Common Pitfalls and How to Fix Them
Code Ape Tech Column
Code Ape Tech Column
Aug 29, 2021 · Backend Development

Understanding Idempotency and Preventing Duplicate Submissions in Backend Systems

This article explains the concept of idempotency, the common causes of duplicate submissions in web applications, and presents multiple backend solutions—including frontend button disabling, Post‑Redirect‑Get, session tokens, local locks with Content‑MD5, AOP aspects, and Redis distributed locks—accompanied by complete Java code examples.

Javaaopdistributed-lock
0 likes · 15 min read
Understanding Idempotency and Preventing Duplicate Submissions in Backend Systems
Architecture Digest
Architecture Digest
Aug 27, 2021 · Backend Development

Four Ways to Implement a Generic AppKey Whitelist in Spring Boot

This article explains four approaches to adding a generic appkey whitelist check in a Spring Boot web framework—traditional AOP, HandlerInterceptor, custom HandlerMethodArgumentResolver, and Servlet Filter—providing implementation steps, code examples, and a discussion of their execution order and extensibility.

ArgumentResolverAuthenticationInterceptor
0 likes · 12 min read
Four Ways to Implement a Generic AppKey Whitelist in Spring Boot