Skip to content
Tagged articles

Spring

500 articles · Page 1 of 5
IoT Full-Stack Technology
IoT Full-Stack Technology
Nov 14, 2026 · Backend Development

Spring-Smart-DI: Dynamic @Autowired Implementation Switching at Runtime

This article introduces spring-smart-di, a library that extends Spring's @Autowired with @AutowiredProxySPI to dynamically switch service implementations (e.g., SMS providers) via configuration without restart, using proxies that resolve the active bean at each invocation.

@AutowiredProxySPI@EnvironmentProxySPIDependency Injection
0 likes · 7 min read
Spring-Smart-DI: Dynamic @Autowired Implementation Switching at Runtime
Java Tech Workshop
Java Tech Workshop
Nov 2, 2026 · Backend Development

Spring Cache Inconsistency: Write Timing vs Transaction Commit Order

This article explains how Spring's CacheInterceptor and TransactionInterceptor execution order causes cache-database inconsistency when cache writes occur before transaction commit, and presents solutions including explicit order configuration, TransactionAwareCacheManagerProxy, and afterCommit callbacks to ensure cache updates only reflect committed transactions.

CacheCache ConsistencyCacheInterceptor
0 likes · 12 min read
Spring Cache Inconsistency: Write Timing vs Transaction Commit Order
Java Tech Workshop
Java Tech Workshop
Oct 21, 2026 · Backend Development

Spring Circular Dependencies: Why Field Injection Works But Constructor Injection Fails

This article explains Spring's three-level cache mechanism that resolves circular dependencies for field/setter injection, why constructor injection fails with BeanCurrentlyInCreationException, how early exposure and ObjectFactory enable AOP proxy creation, and the impact of Spring Boot 2.6's default circular reference blocking.

AOPBean LifecycleCircular Dependency
0 likes · 14 min read
Spring Circular Dependencies: Why Field Injection Works But Constructor Injection Fails
Java Captain
Java Captain
Oct 16, 2026 · Backend Development

Spring Annotation-Only Integration with MyBatis and JUnit

This tutorial demonstrates how to integrate Spring with MyBatis and JUnit using only annotations, covering Maven dependencies, Druid data source configuration, MyBatis SqlSessionFactory setup, mapper scanning, dynamic SQL with @SelectProvider, service layer wiring, and JUnit test execution with Spring's test context framework.

Annotation ConfigurationDruidDynamic SQL
0 likes · 22 min read
Spring Annotation-Only Integration with MyBatis and JUnit
Java Captain
Java Captain
Oct 14, 2026 · Backend Development

Spring Transaction Management with Pure Annotations: Step-by-Step Implementation

This tutorial demonstrates how to implement Spring declarative transaction management using only annotations, covering project setup, configuration classes, MyBatis integration, service layer @Transactional usage, and JUnit tests verifying commit and rollback behavior.

@EnableTransactionManagementAnnotationsDataSourceTransactionManager
0 likes · 15 min read
Spring Transaction Management with Pure Annotations: Step-by-Step Implementation
Java Captain
Java Captain
Oct 13, 2026 · Backend Development

Spring JdbcTemplate vs NamedParameterJdbcTemplate: Complete Guide with Code Examples

This tutorial demonstrates Spring's JdbcTemplate and NamedParameterJdbcTemplate for database CRUD operations, covering Maven setup, Druid connection pooling, configuration classes, DAO implementations with both positional and named parameters, service layer, and JUnit tests, recommending NamedParameterJdbcTemplate for production use.

BeanPropertyRowMapperDruidJDBC
0 likes · 21 min read
Spring JdbcTemplate vs NamedParameterJdbcTemplate: Complete Guide with Code Examples
Top Architect
Top Architect
Oct 12, 2026 · Backend Development

Universal Async Processing SDK: Spring Transaction Events + Kafka + XXL-Job for Guaranteed Execution

The article presents fc-async, an open-source universal asynchronous processing SDK that uses Spring's @TransactionalEventListener with fallbackExecution to decouple async tasks from business transactions, persists requests in MySQL, retries via XXL-Job, and consumes via Kafka, achieving eventual consistency without invading core code.

KafkaMySQLSpring
0 likes · 12 min read
Universal Async Processing SDK: Spring Transaction Events + Kafka + XXL-Job for Guaranteed Execution
Java Captain
Java Captain
Oct 12, 2026 · Backend Development

Spring RedisTemplate with Pure Annotation Configuration: Complete Tutorial

This tutorial demonstrates configuring Spring Data RedisTemplate using pure Java annotations, covering Maven dependencies, connection pooling, serialization, and CRUD operations for String, List, Hash, Set, and Sorted Set data types with complete code examples.

Annotation ConfigurationConnection PoolingJava
0 likes · 14 min read
Spring RedisTemplate with Pure Annotation Configuration: Complete Tutorial
Java Tech Workshop
Java Tech Workshop
Sep 21, 2026 · Backend Development

Spring factory-method Explained: Bean Instantiation, Source Code & 5 Common Errors

This article explains Spring's factory-method mechanism for Bean instantiation, covering three instantiation types, static vs instance factory methods, XML and annotation configuration, source code internals including CGLIB proxying, five common errors with troubleshooting steps, and best practices for @Bean usage.

@BeanBean instantiationBest Practices
0 likes · 17 min read
Spring factory-method Explained: Bean Instantiation, Source Code & 5 Common Errors
Java Tech Workshop
Java Tech Workshop
Sep 10, 2026 · Backend Development

@Async Deep Dive: Fixing Transaction Loss, MDC Context Loss, and Silent Exception Swallowing

This article explains why Spring's @Async annotation causes transaction rollback failures, MDC traceId loss in async threads, and silent exception swallowing, then provides production-ready solutions including separate service classes, TaskDecorator for MDC propagation, custom AsyncUncaughtExceptionHandler, and proper thread pool configuration.

AOPBackendExceptionHandling
0 likes · 26 min read
@Async Deep Dive: Fixing Transaction Loss, MDC Context Loss, and Silent Exception Swallowing
Programmer1970
Programmer1970
Sep 7, 2026 · Backend Development

12 Spring Transaction Failure Scenarios: Why 90% of Developers Fall for #8

This article systematically breaks down 12 common scenarios where Spring @Transactional fails, from non-public methods and self-invocation to exception swallowing, wrong propagation, controller-layer annotations, long transactions, and misconfigured transaction managers. Each scenario includes code examples, root-cause analysis, and practical fixes.

@TransactionalAOPBackend Development
0 likes · 14 min read
12 Spring Transaction Failure Scenarios: Why 90% of Developers Fall for #8
Java Architect Handbook
Java Architect Handbook
Sep 4, 2026 · Backend Development

Dynamic Service Provider Switching with Spring-Smart-DI's @AutowiredProxySPI

This tutorial demonstrates how to use Spring-Smart-DI's @AutowiredProxySPI annotation to dynamically switch between multiple service implementations (e.g., SMS providers) at runtime by changing configuration values, without application restarts, using proxy-based injection that resolves the active implementation on each call.

@AutowiredBackend DevelopmentDependency Injection
0 likes · 8 min read
Dynamic Service Provider Switching with Spring-Smart-DI's @AutowiredProxySPI
Java Tech Workshop
Java Tech Workshop
Aug 30, 2026 · Backend Development

Why Spring Needs a Three‑Level Cache for Circular Dependencies (Two Levels Lose AOP Proxies)

Spring resolves singleton circular dependencies by using a three‑level cache—singletonObjects, earlySingletonObjects, and singletonFactories—to expose early bean references and generate AOP proxies on demand, avoiding the loss of proxies that occurs with a two‑level cache while preserving performance.

AOP ProxyBackendBean Lifecycle
0 likes · 19 min read
Why Spring Needs a Three‑Level Cache for Circular Dependencies (Two Levels Lose AOP Proxies)
Coder Trainee
Coder Trainee
Aug 29, 2026 · Backend Development

When @Transactional Goes Wrong: Misusing Transaction Propagation Leads to Deadlocks

A real‑world case shows that using @Transactional with the default REQUIRED propagation caused a long‑running transaction, frequent deadlocks, data inconsistency and higher timeout rates, and the article walks through the root cause, investigation steps, and practical fixes such as REQUIRES_NEW, self‑proxy calls, and async eventual consistency.

@TransactionalBackendDeadlock
0 likes · 9 min read
When @Transactional Goes Wrong: Misusing Transaction Propagation Leads to Deadlocks
WeiLi Technology Team
WeiLi Technology Team
Aug 28, 2026 · Backend Development

Disconf Auto-Decryption: Fixing Hot-Update Ciphertext Leakage

The article details implementing automatic decryption for sensitive Disconf configurations by extending Spring's PropertyPlaceholderConfigurer, revealing why hot updates bypassed decryption and how overriding mergeProperties ensures consistent decryption at startup and runtime.

Configuration ManagementDisconfKMS
0 likes · 16 min read
Disconf Auto-Decryption: Fixing Hot-Update Ciphertext Leakage
Coder Trainee
Coder Trainee
Aug 24, 2026 · Backend Development

How a Silent Infinite Loop Drained Our Database Connection Pool

The article walks through a real incident where a scheduled batch job contained an infinite while‑true loop, causing all 500 HikariCP connections to be held, slowing the application dramatically; it details the investigation steps, root‑cause analysis, and both emergency and long‑term fixes, plus a checklist to avoid similar bugs.

Connection PoolDebuggingHikariCP
0 likes · 7 min read
How a Silent Infinite Loop Drained Our Database Connection Pool
LuTiao Programming
LuTiao Programming
Aug 21, 2026 · Backend Development

Spring’s New Multitenancy: Serving 1,000 Tenants with One Spring Boot App Without Hand‑Writing tenant_id

The article explains how Spring’s latest multitenancy support, combined with Spring Security, JWT and Hibernate’s @TenantId, lets a single Spring Boot application safely serve thousands of SaaS tenants by automatically isolating data, avoiding manual tenant_id filters, and handling indexes, native SQL, and async tasks.

HibernateSaaSSpring
0 likes · 11 min read
Spring’s New Multitenancy: Serving 1,000 Tenants with One Spring Boot App Without Hand‑Writing tenant_id
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 20, 2026 · Backend Development

12 Spring @Transactional Failure Scenarios: Root Causes, Fixes & Interview Deep Dive

This article categorizes 12 Spring @Transactional failure scenarios across 8 root-cause groups — including self-invocation bypassing proxies, swallowed exceptions, checked exceptions not rolling back, non-public methods, static/final methods, wrong propagation or isolation, unsupported storage engines, multi-threading, unmanaged beans, and incorrect transaction managers — providing code-level fixes, debugging mnemonics, and a simulated interview walkthrough.

@TransactionalAOPException Handling
0 likes · 23 min read
12 Spring @Transactional Failure Scenarios: Root Causes, Fixes & Interview Deep Dive
MeowKitty Programming
MeowKitty Programming
Aug 18, 2026 · Backend Development

When AI Writes Whole Projects, What Jobs Remain for Java Backend Developers?

After an AI mistakenly removed three reflection‑based Spring beans from a 5,000‑line service, the author reflects on how AI‑driven code generation is reshaping Java backend roles—from writing code to focusing on architecture, requirements, and AI‑orchestrated testing—highlighting recent survey data and upcoming Spring AI 2.0 features.

AI code generationBackend DevelopmentJava
0 likes · 5 min read
When AI Writes Whole Projects, What Jobs Remain for Java Backend Developers?
Java Architect Handbook
Java Architect Handbook
Aug 18, 2026 · Backend Development

Why Misusing Spring Event Can Destroy Your Service Performance

The article analyzes common pitfalls of Spring Event—such as publishing during shutdown or early startup, unsuitability for strong‑consistency use cases, and the need for graceful shutdown, idempotent listeners, and extra reliability measures—while comparing it with message‑queue solutions.

IdempotencyPublish‑SubscribeSpring
0 likes · 12 min read
Why Misusing Spring Event Can Destroy Your Service Performance
Architect's Guide
Architect's Guide
Aug 16, 2026 · Backend Development

How Architects Can Achieve Unified Login Across Company Products

The article explains why traditional session mechanisms break in clustered and multi‑service environments, compares session replication and centralized storage, introduces CAS‑based single sign‑on with ticket flow, contrasts it with OAuth2, and provides a complete Spring‑Boot demo with Redis‑backed session handling.

CASJavaOAuth2
0 likes · 15 min read
How Architects Can Achieve Unified Login Across Company Products
Dabaoshi
Dabaoshi
Aug 13, 2026 · Fundamentals

Design Patterns 23 – Final Overview: Mapping All 23 Patterns onto One Diagram

The article wraps up the "Design Pattern Dissection" series by showing how the 23 GoF patterns appear in JDK, Spring and MyBatis, clarifying the most confusing pattern pairs, warning against over‑design, and presenting a comprehensive map that links each pattern to the seven core design principles.

Design PatternsGoFJava
0 likes · 12 min read
Design Patterns 23 – Final Overview: Mapping All 23 Patterns onto One Diagram
Architecture Digest
Architecture Digest
Aug 10, 2026 · Artificial Intelligence

Spring Founder Returns with Embabel: A Production‑Grade Java Agent Orchestration Framework

Embabel, announced by Spring creator Rod Johnson, brings a production‑grade, strongly‑typed agent orchestration layer to the JVM, addressing AI nondeterminism with classic planning algorithms and seamless Spring integration, while contrasting its approach with Python‑centric frameworks like LangGraph.

AI agentsAgent OrchestrationEmbabel
0 likes · 9 min read
Spring Founder Returns with Embabel: A Production‑Grade Java Agent Orchestration Framework
Architect's Guide
Architect's Guide
Aug 7, 2026 · Backend Development

A Clear Diagram of the User Login Verification Process

This article walks through a complete user login flow—including client verification, token generation, expiration policies, gateway validation, logout handling, anonymous access, rate‑limiting via authorized tokens, regex path checks, and blacklist management—illustrated with diagrams and Spring‑Redis code examples.

RedisSpringauthentication
0 likes · 9 min read
A Clear Diagram of the User Login Verification Process
CodeSmart Hoops
CodeSmart Hoops
Aug 6, 2026 · Backend Development

Spring Container Full-Stack Walkthrough: 12 Interview Questions & Answers

This article provides a comprehensive Spring container walkthrough covering the full lifecycle—from bean definition scanning and proxy creation during startup to request handling, AOP interception, transaction and caching mechanisms—plus detailed answers to 12 common interview questions with code examples and best‑practice recommendations.

AOPBackendCache
0 likes · 21 min read
Spring Container Full-Stack Walkthrough: 12 Interview Questions & Answers
Java Tech Workshop
Java Tech Workshop
Jul 29, 2026 · Backend Development

Why Spring Boot’s Built‑in StopWatch Is a Cleaner Way to Measure Execution Time

The article explains the drawbacks of manually using System.currentTimeMillis for multi‑stage timing, introduces Spring’s StopWatch utility from spring‑core, demonstrates its API and code examples, shows three common usage scenarios, warns about pitfalls, compares it with raw timers, and argues why Spring itself adopts StopWatch for concise, structured performance monitoring.

AOPJavaPerformance
0 likes · 12 min read
Why Spring Boot’s Built‑in StopWatch Is a Cleaner Way to Measure Execution Time
dbaplus Community
dbaplus Community
Jul 27, 2026 · Backend Development

Why Java AI Coding Feels Slower and How to Build a Harness Environment in Five Steps

The article explains that Java micro‑service projects feel a whole order of magnitude slower for AI‑assisted coding because they rely on cloud‑only infrastructure, and it presents a five‑principle methodology—dependency inversion, zero‑intrusion profiles, CLI‑first tools, local adapters, and verification scripts—to create a local Harness environment that lets AI agents verify and iterate code autonomously.

AI codingCLIJava
0 likes · 24 min read
Why Java AI Coding Feels Slower and How to Build a Harness Environment in Five Steps
LuTiao Programming
LuTiao Programming
Jul 25, 2026 · Backend Development

Why Delayed Double Delete Fails: A Hierarchical Java Design for MySQL‑Redis Consistency

The article analyzes why MySQL and Redis cannot guarantee strong consistency with simple cache‑aside patterns, explains the pitfalls of delayed double delete, and presents a tiered Java design—including transaction‑after‑commit deletion, retryable invalidation, CDC/Outbox pipelines, TTL safeguards, and multi‑level cache considerations—to achieve reliable cache consistency.

CDCConsistencyJava
0 likes · 22 min read
Why Delayed Double Delete Fails: A Hierarchical Java Design for MySQL‑Redis Consistency
Top Architect
Top Architect
Jul 24, 2026 · Backend Development

Stop Manually Deploying JARs: Embrace Dynamic Hot Deployment

The article demonstrates how to let users upload a JAR that implements a given interface, then hot‑replace the implementation at runtime using either reflection or Spring annotation‑based loading, covering class loading, bean registration, and cleanup with concrete code examples.

Dynamic LoadingHot DeploymentJava
0 likes · 10 min read
Stop Manually Deploying JARs: Embrace Dynamic Hot Deployment
LuTiao Programming
LuTiao Programming
Jul 24, 2026 · Backend Development

Why Scheduled Tasks Run Multiple Times in a Cluster – The Real Issue Isn’t Quartz but Poor Architecture

When a Java application that uses Spring’s @Scheduled moves from a single server to a cluster, the same job may execute on every node, causing duplicate orders, messages, and data; the article explains why this happens, examines common lock‑based fixes and their pitfalls, and proposes a robust, idempotent, sharded task architecture.

@ScheduledBackendIdempotency
0 likes · 15 min read
Why Scheduled Tasks Run Multiple Times in a Cluster – The Real Issue Isn’t Quartz but Poor Architecture
java1234
java1234
Jul 21, 2026 · Backend Development

Why Spring 7 Is Moving Away From Feign (And What to Use Instead)

Spring 7 doesn’t remove Feign from the classpath but officially discourages its use, labeling OpenFeign as feature‑complete and recommending the new Spring Framework HTTP Service Client, with a detailed comparison, migration steps, and guidance on when Feign may still be viable.

FeignHTTP Service ClientSpring
0 likes · 10 min read
Why Spring 7 Is Moving Away From Feign (And What to Use Instead)
Java Tech Workshop
Java Tech Workshop
Jul 21, 2026 · Backend Development

A Lighter‑Than‑MQ Async Solution: Spring’s Hidden Transactional Event Feature

The article explains how Spring’s built‑in @Async and TransactionalEventListener mechanisms provide a lightweight, zero‑dependency alternative to external message queues for local asynchronous processing, detailing their advantages, limitations, and production‑grade enhancements such as custom thread pools, dead‑letter persistence, and clustering strategies.

JavaMessage QueueSpring
0 likes · 17 min read
A Lighter‑Than‑MQ Async Solution: Spring’s Hidden Transactional Event Feature
samdeepthink
samdeepthink
Jul 20, 2026 · Fundamentals

Good Architecture Means Cutting Components, Not Adding More

The article argues that seasoned developers improve system architecture by removing unnecessary components—such as redundant Redis caches or message queues—rather than continuously adding new ones, because each addition raises complexity and maintenance overhead, while simpler designs are easier to manage and evolve.

Message QueueRedisSpring
0 likes · 3 min read
Good Architecture Means Cutting Components, Not Adding More
Su San Talks Tech
Su San Talks Tech
Jul 19, 2026 · Backend Development

Why Is Spring Dropping Feign for @HttpExchange?

The article analyzes Spring Framework’s new native HTTP Interface (@HttpExchange), comparing it with OpenFeign in terms of architecture, dependency management, performance, and suitability for reactive programming, and provides migration guidance and practical code examples.

@HttpExchangeBackendFeign
0 likes · 16 min read
Why Is Spring Dropping Feign for @HttpExchange?
Java Architect Handbook
Java Architect Handbook
Jul 17, 2026 · Backend Development

Interview Question: What’s the Relationship Between BeanFactory and FactoryBean?

This article explains the distinction between Spring's BeanFactory and FactoryBean, covering their roles, core APIs, typical implementations, key differences in registration and retrieval, classic use cases, common pitfalls, and frequent interview follow‑up questions, with concrete code examples and comparison tables.

BeanFactoryFactoryBeanInterview
0 likes · 10 min read
Interview Question: What’s the Relationship Between BeanFactory and FactoryBean?
Coder Trainee
Coder Trainee
Jul 16, 2026 · Backend Development

Complete Summary of the Six‑Part Java Interview High‑Frequency Questions Series

This article compiles all 60 high‑frequency Java interview questions from six core backend topics—basics, collections, concurrency, JVM, Spring, and microservices—provides a quick‑reference table, outlines the most common and hardest questions, and shares a five‑layer answering technique for interview success.

BackendConcurrencyInterview
0 likes · 10 min read
Complete Summary of the Six‑Part Java Interview High‑Frequency Questions Series
Coder Trainee
Coder Trainee
Jul 16, 2026 · Interview Experience

Java Interview Essentials: 10 Must‑Ask Microservice Questions

This article presents ten essential microservice interview questions, covering service registration and discovery, API gateways, fault tolerance, distributed transactions, tracing, configuration management, messaging, ID generation, and service decomposition, each explained with principles, diagrams, code snippets, and tips for impressing interviewers.

BackendInterviewJava
0 likes · 14 min read
Java Interview Essentials: 10 Must‑Ask Microservice Questions
Coder Trainee
Coder Trainee
Jul 14, 2026 · Backend Development

Top 10 Must‑Know Spring Interview Questions for Java Developers

This article walks through the ten most frequently asked Spring interview topics—including IoC/DI concepts, bean lifecycle, AOP mechanics, circular‑dependency resolution, @Transactional behavior, Spring Boot startup steps, auto‑configuration, @Autowired vs @Resource, bean scopes, and the differences between servlet filters and Spring interceptors—providing concrete code examples and key points that can earn interviewers' extra credit.

AOPBean ScopeDependency Injection
0 likes · 12 min read
Top 10 Must‑Know Spring Interview Questions for Java Developers
Java Tech Workshop
Java Tech Workshop
Jul 11, 2026 · Backend Development

Mastering @Valid and @Validated: Practical Group Validation in Spring

This article explains the fundamental differences between Spring's @Valid and @Validated annotations, demonstrates how to apply group validation, nested object checks, and custom validation annotations, and provides a complete strategy for global exception handling and production‑grade best practices.

Custom AnnotationException HandlingJava
0 likes · 17 min read
Mastering @Valid and @Validated: Practical Group Validation in Spring
IoT Full-Stack Technology
IoT Full-Stack Technology
Jul 9, 2026 · Backend Development

Comprehensive Collection of Java Backend Architecture Diagrams

This article compiles a comprehensive set of 31 Java‑related architecture diagrams, covering core components such as the class loader, JVM, threading, Spring, Hibernate, as well as related technologies like Android, Linux kernel, cloud computing, and enterprise solutions, each illustrated with detailed images.

AndroidBackend ArchitectureHibernate
0 likes · 5 min read
Comprehensive Collection of Java Backend Architecture Diagrams
IoT Full-Stack Technology
IoT Full-Stack Technology
Jul 8, 2026 · Backend Development

Comprehensive Collection of Java Backend Architecture Diagrams

This article presents a curated list of 31 Java backend architecture diagrams, covering class loader, JVM, technology stack, thread runtime, compilation, JMS, JMX, Spring, Hibernate, iBATIS, Struts, EJB, portal, Android, cloud, Linux kernel, VMware, SAP, SOA, GIS ESB, CRM, and OA, each illustrated with detailed images.

BackendHibernateJVM
0 likes · 6 min read
Comprehensive Collection of Java Backend Architecture Diagrams
Three Knives
Three Knives
Jul 4, 2026 · Backend Development

Why Faster Java Frameworks Lose to Spring: The Economics of User Experience

The article explains that despite superior startup speed and lower memory usage, alternatives to Spring such as Vert.x, Quarkus, and Micronaut fail to displace it because developers prioritize familiar APIs, easy debugging, and a rich ecosystem, while the new Feat project demonstrates a way to keep Spring's developer experience and still achieve dramatic performance gains.

FeatJavaPerformance
0 likes · 9 min read
Why Faster Java Frameworks Lose to Spring: The Economics of User Experience
Java Tech Workshop
Java Tech Workshop
Jul 4, 2026 · Backend Development

Why Spring Chooses Its Own SPI Over Java’s Native ServiceLoader

The article compares Java’s native SPI with Spring’s custom SPI, explains the fundamental flaws of ServiceLoader, details SpringFactoriesLoader’s lazy loading and conditional filtering, and shows why SpringBoot auto‑configuration relies entirely on its own SPI mechanism.

AutoConfigurationJavaSPI
0 likes · 13 min read
Why Spring Chooses Its Own SPI Over Java’s Native ServiceLoader
Cloud Architecture
Cloud Architecture
Jul 1, 2026 · Backend Development

8 Asynchronous Programming Techniques: From Thread Pools and MQ to Virtual Threads

The article examines eight practical ways to implement asynchronous programming—thread pools, CompletableFuture, Spring @Async, message queues, event‑driven architecture, reactive streams, the Actor model, and coroutines/virtual threads—explaining their core mechanisms, trade‑offs, production‑grade configurations, and when each should be chosen.

Asynchronous ProgrammingConcurrencyJava
0 likes · 53 min read
8 Asynchronous Programming Techniques: From Thread Pools and MQ to Virtual Threads
Java Tech Workshop
Java Tech Workshop
Jul 1, 2026 · Backend Development

Resolving AOP + IOC Circular Dependency Conflicts in Spring

The article explains why Spring's three‑level cache solves simple circular dependencies but fails for AOP‑enhanced beans, describes the timeline mismatch that causes BeanCurrentlyInCreationException, and presents tiered solutions including @Lazy injection, setter refactoring, early proxy processing, and architectural redesign.

@BeanAOPCircular Dependency
0 likes · 14 min read
Resolving AOP + IOC Circular Dependency Conflicts in Spring
Java Tech Workshop
Java Tech Workshop
Jun 28, 2026 · Backend Development

Inside Spring AOP: Full Lifecycle of Proxy Object Creation

The article provides a step‑by‑step analysis of Spring AOP’s proxy creation process, explaining why some beans are proxied, how @Order, @EnableAspectJAutoProxy, proxyTargetClass and exposeProxy affect proxying, the differences between JDK and CGLIB proxies, and why private, static or final methods cannot be intercepted.

AOPAspectJBean Lifecycle
0 likes · 15 min read
Inside Spring AOP: Full Lifecycle of Proxy Object Creation
Coder Trainee
Coder Trainee
Jun 27, 2026 · Backend Development

Mastering Java Thread‑Pool Tuning: Practical Performance Tips

This article explains why Java thread pools need tuning, walks through the seven core ThreadPoolExecutor parameters, provides formula‑based sizing, offers configuration templates for different workloads, shows monitoring and dynamic adjustment techniques, and highlights common pitfalls with concrete code examples.

ConcurrencyJavaSpring
0 likes · 8 min read
Mastering Java Thread‑Pool Tuning: Practical Performance Tips
Cloud Architecture
Cloud Architecture
Jun 27, 2026 · Backend Development

Spring Multi-Level Cache: Production Design & Management with Caffeine + Redis

Spring’s multi‑level caching combines Caffeine’s ultra‑fast local store with Redis’s distributed capacity to tackle high‑concurrency challenges such as read amplification, cache storms, consistency, and capacity management, offering a production‑grade design, implementation details, risk boundaries, and evolution paths for robust Spring applications.

CacheCaffeineMulti-level Cache
0 likes · 36 min read
Spring Multi-Level Cache: Production Design & Management with Caffeine + Redis
Java Tech Workshop
Java Tech Workshop
Jun 27, 2026 · Backend Development

Why Do final, static, and private Methods Escape Spring AOP Proxying?

The article explains that Spring AOP cannot intercept methods marked as private, static, or final because JDK dynamic proxies only work on public interface methods and CGLIB subclasses cannot override such methods, leading to static matching but dynamic execution failure, self‑invocation bypass, and complete loss of advice for these method types.

AOPCGLIBJDK Proxy
0 likes · 11 min read
Why Do final, static, and private Methods Escape Spring AOP Proxying?
Three Knives
Three Knives
Jun 26, 2026 · Backend Development

The Three Fatal Flaws of the Servlet Spec That Pushed Spring to Dominance

The article examines three outdated provisions in the Servlet specification—full‑annotation scanning that slows startup, an overreaching security model, and a half‑baked async API—explaining how they hinder modern cloud‑native development and how Spring’s ecosystem has filled each gap, while also suggesting lightweight alternatives.

Cloud NativeJavaServlet
0 likes · 10 min read
The Three Fatal Flaws of the Servlet Spec That Pushed Spring to Dominance
Tinker Programmer
Tinker Programmer
Jun 25, 2026 · Interview Experience

Singleton Pattern: 6 Implementations, DCL Volatile Pitfall, Spring vs GoF

The article examines the evolution of six singleton implementations in Java, explains why the double‑checked locking pattern requires the volatile keyword to prevent instruction reordering bugs, compares Spring container‑managed singletons with classic GoF singletons, and highlights common pitfalls such as mutable state in singleton beans.

ConcurrencyDesign PatternJava
0 likes · 13 min read
Singleton Pattern: 6 Implementations, DCL Volatile Pitfall, Spring vs GoF
Linyb Geek Road
Linyb Geek Road
Jun 25, 2026 · Backend Development

8 Hard‑Earned Rules for Using Spring @Transactional Correctly

Drawing on a decade of production experience, the article presents eight concrete rules for Spring @Transactional—covering transaction duration, proxy limitations, rollback settings, exception handling, read‑only flags, method visibility, bean separation for retries, and logging—to prevent common bugs and ensure reliable database operations.

@TransactionalBest PracticesJava
0 likes · 12 min read
8 Hard‑Earned Rules for Using Spring @Transactional Correctly
Tinker Programmer
Tinker Programmer
Jun 24, 2026 · Fundamentals

Master Strategy, Observer, and Chain of Responsibility with Spring & MQ examples

This article walks through the three core behavioral design patterns—Strategy, Observer, and Chain of Responsibility—explaining their intent, showing problematic anti‑patterns, providing step‑by‑step Spring and MQ code implementations, mapping them to real‑world frameworks, and offering interview‑style comparison questions to solidify understanding.

Chain of ResponsibilityDesign PatternsJava
0 likes · 19 min read
Master Strategy, Observer, and Chain of Responsibility with Spring & MQ examples
Java Tech Workshop
Java Tech Workshop
Jun 24, 2026 · Backend Development

Mastering Spring AOP: All Four Types of Advice Explained

Spring AOP provides five distinct advice types—@Before, @AfterReturning, @AfterThrowing, @After, and @Around—each with specific execution timing; this guide explains their purposes, execution order, common pitfalls, and offers a complete SpringBoot example with code, Maven setup, and logging demonstrations.

AOPAspect-Oriented ProgrammingBackend
0 likes · 13 min read
Mastering Spring AOP: All Four Types of Advice Explained
Cloud Architecture
Cloud Architecture
Jun 21, 2026 · Backend Development

How to Build a Production‑Ready AI Service with Spring 7.0 and Spring AI for High‑Concurrency Microservices

This article explains how to integrate large language models into enterprise Java microservices using Spring 7.0 and Spring AI, covering architectural layers, design principles, code structure, resilience, observability, and a step‑by‑step production checklist to turn AI capabilities into a maintainable, high‑throughput service.

AIBackendJava
0 likes · 38 min read
How to Build a Production‑Ready AI Service with Spring 7.0 and Spring AI for High‑Concurrency Microservices
Java Tech Workshop
Java Tech Workshop
Jun 21, 2026 · Backend Development

Mastering Spring’s BeanPostProcessor: The Ultimate Hook for Advanced Container Customization

Spring’s BeanPostProcessor is a global container hook that intercepts every bean’s lifecycle, enabling custom initialization, dynamic proxying, annotation processing, and resource cleanup; the article explains its three-tier hierarchy, execution order, priority rules, practical use‑cases like auto‑injection, logging, data masking, and common pitfalls.

AOPBeanPostProcessorDependency Injection
0 likes · 18 min read
Mastering Spring’s BeanPostProcessor: The Ultimate Hook for Advanced Container Customization
Java Tech Workshop
Java Tech Workshop
Jun 20, 2026 · Backend Development

How Custom Spring Converters Eliminate Date and Enum Parameter Pain Points

The article explains why front‑end date and enum parameters often cause parsing errors in Spring applications, describes the two independent conversion mechanisms in Spring MVC and Jackson, and provides a step‑by‑step guide to building global custom converters that unify date formats and enum mappings across the whole project.

Backend DevelopmentCustom ConverterEnum Mapping
0 likes · 17 min read
How Custom Spring Converters Eliminate Date and Enum Parameter Pain Points
Java Tech Workshop
Java Tech Workshop
Jun 19, 2026 · Backend Development

BeanFactory vs ApplicationContext: The Real Differences You Must Know

The article explains how BeanFactory is a minimal, lazy‑loading container that only creates and caches beans, while ApplicationContext extends it with eager pre‑loading, full annotation, AOP, transaction, environment and event support, and outlines their respective use cases and pitfalls.

ApplicationContextBeanFactoryDependency Injection
0 likes · 9 min read
BeanFactory vs ApplicationContext: The Real Differences You Must Know
Java Tech Workshop
Java Tech Workshop
Jun 18, 2026 · Backend Development

Understanding @Lazy in Spring: Solving Circular Dependencies and Accelerating Startup

The article explains that Spring's @Lazy annotation has two distinct mechanisms—class‑level lazy bean creation and dependency‑level proxy placeholders—detailing how each works, when to apply them, common pitfalls such as transaction and aspect failures, and best‑practice scenarios for reducing startup time while safely handling circular dependencies.

@LazyBean ProxyCircular Dependency
0 likes · 12 min read
Understanding @Lazy in Spring: Solving Circular Dependencies and Accelerating Startup
Java Tech Workshop
Java Tech Workshop
Jun 17, 2026 · Backend Development

Step‑by‑Step Source Code Walkthrough of Spring’s Singleton Bean Creation

This article dissects Spring’s singleton bean creation process, explaining the three‑level cache system, the doGetBean and doCreateBean workflows, circular‑dependency handling, proxy generation timing, and common pitfalls such as multithreaded duplicate creation and hot‑deployment cache issues.

Bean LifecycleCacheCircular Dependency
0 likes · 11 min read
Step‑by‑Step Source Code Walkthrough of Spring’s Singleton Bean Creation
Java Tech Workshop
Java Tech Workshop
Jun 16, 2026 · Backend Development

How Spring’s Third‑Level Cache Resolves Circular Dependencies

The article explains Spring’s three kinds of circular dependencies, the role of the first, second, and third‑level caches in the DefaultSingletonBeanRegistry, how the third‑level cache works with AOP proxies, why constructor injection cannot be solved, the @Lazy workaround, and the hidden bugs and best‑practice recommendations.

AOPBean LifecycleCircular Dependency
0 likes · 12 min read
How Spring’s Third‑Level Cache Resolves Circular Dependencies
Java Tech Workshop
Java Tech Workshop
Jun 15, 2026 · Backend Development

Understanding the Full Spring Bean Lifecycle: From Instantiation to Destruction

This article walks through the complete Spring Bean lifecycle—covering scanning, instantiation, dependency injection, initialization, AOP proxy creation, and destruction—while highlighting common pitfalls, the differences for prototype and lazy‑loaded beans, and practical debugging tips.

AOPBean LifecycleDependency Injection
0 likes · 10 min read
Understanding the Full Spring Bean Lifecycle: From Instantiation to Destruction
Programmer XiaoFu
Programmer XiaoFu
Jun 15, 2026 · Backend Development

Why a Simple Redis Mutex Lock Isn’t Enough for Cache Breakdown – When to Use Never‑Expire or Logical Expiration

The article analyzes why a basic Redis mutex lock can cause thread blocking, latency spikes, and service collapse under high concurrency, and compares it with logical expiration and never‑expire with proactive updates, explaining their trade‑offs and how to choose the right cache‑breakdown mitigation strategy.

CacheJavaNever Expire
0 likes · 12 min read
Why a Simple Redis Mutex Lock Isn’t Enough for Cache Breakdown – When to Use Never‑Expire or Logical Expiration
Java Tech Workshop
Java Tech Workshop
Jun 14, 2026 · Backend Development

Spring Bean Scopes: 5 Types, Common Pitfalls and Concurrency Gotchas

The article explains the five Spring Bean scopes, clarifies that scope only controls instance count and not thread safety, and walks through real‑world concurrency bugs such as mutable singleton fields, prototype beans losing their prototype nature, and request‑scoped beans failing in async threads, offering concrete fixes and usage recommendations.

Bean ScopeConcurrencyJava
0 likes · 10 min read
Spring Bean Scopes: 5 Types, Common Pitfalls and Concurrency Gotchas
Java Tech Workshop
Java Tech Workshop
Jun 13, 2026 · Backend Development

Which DI Injection Method Should You Use in Production? Field vs Setter vs Constructor

The article compares Spring's three dependency‑injection styles—field, setter, and constructor—showing code, execution order, source‑code mechanics, risks such as null‑pointer windows and reflection tampering, and concludes that constructor injection (preferably with Lombok @RequiredArgsConstructor) is the production‑grade choice.

Constructor InjectionDependency InjectionField Injection
0 likes · 10 min read
Which DI Injection Method Should You Use in Production? Field vs Setter vs Constructor
ITPUB
ITPUB
Jun 9, 2026 · Backend Development

How to Prevent Server Crashes from Concurrent Excel Exports with a Queue

The article explains why simultaneous Excel exports can overload a server, proposes a fixed‑size FIFO queue to serialize export tasks, and provides a complete Spring‑Boot implementation—including the ExportQueue, abstract export logic with EasyExcel, and a test controller—to demonstrate the queuing mechanism in action.

BackendConcurrencyEasyExcel
0 likes · 11 min read
How to Prevent Server Crashes from Concurrent Excel Exports with a Queue
The Dominant Programmer
The Dominant Programmer
Jun 7, 2026 · Backend Development

Executing Asynchronous Operations After Spring Transaction Commit: Principles, Pitfalls, and Best Practices

The article explains why sending messages before a Spring transaction commits can cause data inconsistency, and demonstrates how to reliably execute asynchronous actions such as MQ notifications after a successful commit using TransactionSynchronization, custom collectors, and @TransactionalEventListener, while highlighting common pitfalls and mitigation strategies.

JavaMQSpring
0 likes · 16 min read
Executing Asynchronous Operations After Spring Transaction Commit: Principles, Pitfalls, and Best Practices
Cloud Architecture
Cloud Architecture
Jun 4, 2026 · Backend Development

Kafka Backlog Mastery: Root Causes, Emergency Fixes, and Production‑Grade Governance

This comprehensive guide explains why Kafka message backlog occurs, how to diagnose its root causes, and provides a step‑by‑step 5‑minute emergency response and production‑grade consumer architecture, including back‑pressure control, idempotent processing, capacity planning, observability, and cloud‑native deployment strategies.

ConsumerKafkaObservability
0 likes · 48 min read
Kafka Backlog Mastery: Root Causes, Emergency Fixes, and Production‑Grade Governance
IoT Full-Stack Technology
IoT Full-Stack Technology
Jun 3, 2026 · Backend Development

Can We Achieve Seamless Account Interoperability Across Multiple Company Systems?

The article examines the challenges of multiple corporate systems requiring separate logins, explains traditional session mechanisms and their limitations in clustered environments, compares session replication versus centralized storage, and presents a complete Java Spring implementation of CAS‑based single sign‑on with code samples and a discussion of differences from OAuth2.

CASJavaOAuth2
0 likes · 13 min read
Can We Achieve Seamless Account Interoperability Across Multiple Company Systems?
CodeSmart Hoops
CodeSmart Hoops
Jun 3, 2026 · Backend Development

Spring Event-Driven Architecture: Interview Self-Test with Observer Pattern and Decoupling Design

This article provides a comprehensive interview self‑test on Spring's event‑driven mechanism, covering the three core components, synchronous vs asynchronous handling, the role and default implementation of ApplicationEventMulticaster, adapter flow, async configuration options, @TransactionalEventListener phases, exception propagation, @Order ordering, SpEL condition filtering, a comparison with MQ, POJO events, and the listenerCache optimization.

ApplicationEventBackendSpEL
0 likes · 21 min read
Spring Event-Driven Architecture: Interview Self-Test with Observer Pattern and Decoupling Design
CodeSmart Hoops
CodeSmart Hoops
Jun 1, 2026 · Backend Development

Spring Cache Interview Self‑Test: Full Deep Dive, Correct Usage & Performance Boost

This article provides a comprehensive interview self‑test on Spring Cache, covering annotation differences, AOP internals, SpEL expressions, key generation, Redis serialization, multi‑level caching, consistency strategies, and Caffeine eviction policies, complete with code examples, diagrams, and practical recommendations.

AOPCacheCaffeine
0 likes · 29 min read
Spring Cache Interview Self‑Test: Full Deep Dive, Correct Usage & Performance Boost
CodeSmart Hoops
CodeSmart Hoops
May 31, 2026 · Backend Development

Hands‑On Unit Testing of Spring’s Full Event‑Driven Architecture

This guide walks through comprehensive unit tests for Spring Boot 3.x / Spring Framework 6.x event‑driven features—covering @EventListener, ApplicationListener, @Order, @Async, TransactionalEventListener, exception propagation, multiple event publishing, POJO events, and a comparison of three asynchronous handling approaches—using JDK 17+, JUnit 5, and Spring Boot Test.

@TransactionalJavaSpring
0 likes · 25 min read
Hands‑On Unit Testing of Spring’s Full Event‑Driven Architecture
Programmer XiaoFu
Programmer XiaoFu
May 29, 2026 · Backend Development

Why Does Spring Use a Third-Level Cache When the Second-Level Cache Can Resolve Circular Dependencies?

Spring’s bean factory uses a three‑level cache—singletonObjects, earlySingletonObjects, and singletonFactories—to handle circular dependencies, but only the third level is needed when AOP proxies are involved, allowing lazy proxy creation without breaking the standard bean lifecycle.

AOPBean LifecycleCircular Dependency
0 likes · 9 min read
Why Does Spring Use a Third-Level Cache When the Second-Level Cache Can Resolve Circular Dependencies?
ITPUB
ITPUB
May 28, 2026 · Backend Development

Skipping Spring Upgrades: Hidden Risks or Upgrade Hazards? Tanzu Spring’s Answer

Enterprise Java teams face mounting technical debt and accelerating security vulnerabilities from outdated Spring versions, a problem amplified by AI‑driven attacks, and Tanzu Spring offers a six‑year extended lifecycle, automated upgrade tooling, AI‑integrated governance, and 24/7 vendor support to safely modernize their applications.

AIJavaLifecycle
0 likes · 11 min read
Skipping Spring Upgrades: Hidden Risks or Upgrade Hazards? Tanzu Spring’s Answer
Architect's Guide
Architect's Guide
May 27, 2026 · Backend Development

Comprehensive Collection of Java Backend Architecture Diagrams

This article compiles over thirty detailed architecture diagrams covering Java class loaders, JVM, Spring, Hibernate, Android, Linux kernel, cloud computing, and various enterprise technologies, offering developers a visual reference library for understanding and designing Java backend systems.

Backend ArchitectureHibernateJVM
0 likes · 5 min read
Comprehensive Collection of Java Backend Architecture Diagrams
CodeSmart Hoops
CodeSmart Hoops
May 25, 2026 · Backend Development

Hands‑On Unit Tests for Full Spring Cache Features

This guide walks through setting up a Spring Boot 3.x project with JDK 17+, adding the necessary Maven dependencies, and implementing a comprehensive JUnit 5 test suite that demonstrates @Cacheable, @CachePut, @CacheEvict (single‑key and all‑entries), SpEL‑based keys, condition/unless caching, and the AOP proxy pitfall of same‑class calls, plus instructions for running the tests via Maven or IntelliJ IDEA.

CacheJUnit5Java
0 likes · 19 min read
Hands‑On Unit Tests for Full Spring Cache Features
Java Architect Handbook
Java Architect Handbook
May 23, 2026 · Backend Development

How to Preheat Cache During Spring Startup – Interview Guide

The article explains four ways to preheat caches in Spring during startup, recommends CommandLineRunner/ApplicationRunner as the safest option, and discusses timing, async handling, error protection, and distributed‑lock strategies to avoid common pitfalls in production environments.

CommandLineRunnerInterviewSpring
0 likes · 13 min read
How to Preheat Cache During Spring Startup – Interview Guide
samdeepthink
samdeepthink
May 22, 2026 · Backend Development

How to Answer Bean Thread‑Safety Questions from an Architecture‑Responsibility Perspective

The article breaks down Bean thread‑safety into container‑level creation safety and business‑level usage safety, explains Spring's four concurrency strategies, details the implementation of Singleton, Prototype, Request and Session scopes, compares them with other DI frameworks, and argues why Spring's division of responsibilities is appropriate.

@BeanDependency InjectionSpring
0 likes · 14 min read
How to Answer Bean Thread‑Safety Questions from an Architecture‑Responsibility Perspective
Programmer1970
Programmer1970
May 19, 2026 · Interview Experience

What Do Interviewers Really Test When They Ask About Design Patterns?

The article shows that interviewers don’t just want you to list design patterns; they assess your ability to identify real scenarios, solve concrete problems, justify trade‑offs, and discuss implementation details, illustrated with payment and order‑processing examples in Java and Spring.

Chain of ResponsibilityDesign PatternsFactory Pattern
0 likes · 11 min read
What Do Interviewers Really Test When They Ask About Design Patterns?
Java Tech Enthusiast
Java Tech Enthusiast
May 13, 2026 · Backend Development

Why Adding Spring HATEOAS Stops Front‑End Teams From Chasing Swagger Updates

The article explains how integrating Spring HATEOAS transforms a Level‑2 REST API into a hypermedia‑driven Level‑3 API, automatically exposing actionable links, reducing front‑end state‑handling, enabling type‑safe URL generation, and simplifying RBAC integration, thereby eliminating the need for constant Swagger revisions.

API designRESTSpring
0 likes · 7 min read
Why Adding Spring HATEOAS Stops Front‑End Teams From Chasing Swagger Updates
CodeSmart Hoops
CodeSmart Hoops
May 13, 2026 · Backend Development

Spring Circular Dependency Unit Tests: Full Analysis and Hands‑On Demo

This article provides a comprehensive set of JUnit 5 unit tests that demonstrate how Spring Boot 3.x and Spring Framework 6.x handle various circular dependency scenarios—including field, setter, constructor, @Lazy, prototype beans, three‑bean cycles, and AOP proxy interactions—along with Maven and IDE run instructions.

AOPCircular DependencyJava
0 likes · 12 min read
Spring Circular Dependency Unit Tests: Full Analysis and Hands‑On Demo
samdeepthink
samdeepthink
May 10, 2026 · Backend Development

Why Debugging Is the Best Way to Master Framework Source Code

The author argues that understanding frameworks through a debugging mindset and concise demo programs—such as inspecting Redis’s single‑threaded model, Spring’s circular‑dependency resolution, ThreadPoolExecutor’s rejection policy, and HashMap’s resize behavior—provides deeper insight than memorization, and shows how to isolate problems into minimal, testable units.

DebuggingFrameworksHashMap
0 likes · 4 min read
Why Debugging Is the Best Way to Master Framework Source Code
samdeepthink
samdeepthink
May 9, 2026 · Backend Development

When You Can’t Understand Someone Else’s Code, Is It Their Skill or Yours?

The article explains that difficulty reading code often stems from unfamiliar design patterns and complex construction logic rather than poor code quality, illustrating with factory and strategy patterns in inventory systems, and provides a checklist to distinguish between genuinely bad code and gaps in a developer’s knowledge.

Design PatternsFactory PatternJava
0 likes · 9 min read
When You Can’t Understand Someone Else’s Code, Is It Their Skill or Yours?
Coder Trainee
Coder Trainee
May 8, 2026 · Backend Development

How Spring Boot Instantiates Beans and Resolves Circular Dependencies

This article walks through Spring Boot's bean creation pipeline—from the initial getBean call through doGetBean, the three‑level singleton cache, and the detailed steps of createBean, populateBean, and initializeBean—explaining how circular dependencies are safely resolved and where AOP proxies are generated.

@BeanAOPBean Lifecycle
0 likes · 14 min read
How Spring Boot Instantiates Beans and Resolves Circular Dependencies