BestHub
Sign in
Tagged articles
146 articles
Page 1 of 2
Coder Trainee
Coder Trainee
May 10, 2026 · Backend Development

Spring Boot Source Code Deep Dive (Part 7): Full Recap and Ultimate Interview Guide

The final installment of the Spring Boot source‑code series consolidates the previous six episodes—covering startup flow, auto‑configuration, IoC container, bean lifecycle, circular dependencies, and SPI—while providing a complete knowledge map, 20 interview‑question templates, practical study tips, and a roadmap for further learning and contribution.

ConfigurationDebuggingSpring Boot
0 likes · 14 min read
Spring Boot Source Code Deep Dive (Part 7): Full Recap and Ultimate Interview Guide
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 30, 2026 · Backend Development

5 Common Spring Boot Anti‑Patterns You Must Avoid

The article examines five high‑frequency Spring Boot anti‑patterns—field injection, returning entities from controllers, overusing @Transactional, generic exception handling, and embedding business logic in controllers—showing problematic code snippets, real‑world consequences, and concise refactored examples to improve testability, performance, and maintainability.

Anti‑PatternController DesignException Handling
0 likes · 9 min read
5 Common Spring Boot Anti‑Patterns You Must Avoid
SpringMeng
SpringMeng
Apr 11, 2026 · Backend Development

How a New Tech Lead Crafted an Elegant Payment System Architecture

The article breaks down the complexities of payment processing by outlining business background, decomposing the workflow into modular steps, illustrating sequence diagrams, designing data structures, and addressing related domains such as product and coupon management, while highlighting key technical challenges like TCC transactions, locking, and retry mechanisms.

Backend Architecturecoupon rulesorder processing
0 likes · 8 min read
How a New Tech Lead Crafted an Elegant Payment System Architecture
Coder Trainee
Coder Trainee
Apr 7, 2026 · Backend Development

Setting Up Seata (pre‑1.0) for Distributed Transactions in Microservices

This guide explains what a distributed transaction is and walks through the complete setup of a Seata server (version 0.9.0), including downloading, configuring file.conf and registry.conf for Nacos, initializing the database, starting services, and creating the required undo_log table.

Distributed TransactionsMicroservicesNacos
0 likes · 4 min read
Setting Up Seata (pre‑1.0) for Distributed Transactions in Microservices
Top Architect
Top Architect
Apr 3, 2026 · Backend Development

Why Did My Payment Service Lose Data? Uncovering Hidden Transaction Bugs in Spring

A mysterious payment failure where orders appeared successful but were never persisted was traced to a missing transaction commit in a special code path, leading to polluted connections that silently broke subsequent transactions, and the article explains the root cause, debugging steps, fix, and preventive measures.

Connection PoolDebuggingdatabase
0 likes · 11 min read
Why Did My Payment Service Lose Data? Uncovering Hidden Transaction Bugs in Spring
Top Architect
Top Architect
Feb 15, 2026 · Backend Development

Why Did My Payment Service Lose Data? Uncovering Hidden Transaction Bugs in Spring

A payment service failed to insert orders despite successful payments, showing no errors, occasional lock timeouts, and intermittent success, which was traced to a missing transaction commit that polluted reused connections, causing unrelated business failures until the bug was fixed and preventive measures were added.

Connection PoolJavadatabase
0 likes · 11 min read
Why Did My Payment Service Lose Data? Uncovering Hidden Transaction Bugs in Spring
java1234
java1234
Feb 7, 2026 · Backend Development

Why Service Layer Should Not Return a Result Object in Java

The article explains why returning a generic Result wrapper from a Java service layer breaks responsibility separation, harms reusability, complicates exception handling and testing, and obscures transaction boundaries, advocating for returning pure domain objects instead.

Domain-Driven DesignException HandlingJava
0 likes · 13 min read
Why Service Layer Should Not Return a Result Object in Java
Java Companion
Java Companion
Feb 7, 2026 · Backend Development

Why Should the Service Layer in Java Not Return a Result Object Directly?

The article explains that returning a Result wrapper from the Service layer mixes business logic with presentation concerns, leading to tighter coupling, reduced reusability, cumbersome error handling, harder testing, poorer DDD alignment, limited interface flexibility, and ambiguous transaction boundaries.

Domain-Driven DesignException HandlingJava
0 likes · 11 min read
Why Should the Service Layer in Java Not Return a Result Object Directly?
Su San Talks Tech
Su San Talks Tech
Dec 31, 2025 · Backend Development

When Spring @Transactional Fails: Common Pitfalls and Fixes

This article explains why Spring @Transactional may not work as expected, covering issues such as wrong method visibility, final methods, internal calls, missing bean registration, multithreading, unsupported table engines, incorrect propagation settings, swallowed exceptions, and how to resolve each problem.

Backendtransaction-management
0 likes · 20 min read
When Spring @Transactional Fails: Common Pitfalls and Fixes
Architect's Tech Stack
Architect's Tech Stack
Dec 24, 2025 · Backend Development

10 Proven Techniques to Supercharge API Performance in Java Applications

This article presents a comprehensive, step‑by‑step guide to optimizing Java‑based API interfaces, covering batch processing, asynchronous execution, caching, pre‑processing, pooling, transaction handling, pagination, SQL tuning, lock granularity, and code restructuring, with practical code examples and diagrams.

API optimizationAsynchronousBatch Processing
0 likes · 10 min read
10 Proven Techniques to Supercharge API Performance in Java Applications
Top Architect
Top Architect
Dec 4, 2025 · Backend Development

Designing Robust Payment Systems: Architecture, Flow, and Data Modeling

This article examines the challenges of implementing payment functionality in business systems, breaking down the process into detailed steps, outlining sequence diagrams, proposing a data structure design, and discussing related e‑commerce components such as product and coupon management to ensure reliable, scalable transactions.

System Designarchitecturee‑commerce
0 likes · 10 min read
Designing Robust Payment Systems: Architecture, Flow, and Data Modeling
Selected Java Interview Questions
Selected Java Interview Questions
Dec 3, 2025 · Backend Development

Coexisting Multiple DataSources in Spring Boot: No Switching Needed

This guide explains how to configure Spring Boot applications to use multiple coexisting DataSource beans—such as MySQL and TDengine—without runtime switching, covering bean definitions, MyBatis mapper scanning, transaction manager setup, custom @Transactional annotations, and common pitfalls, enabling clean separation of business, log, and time‑series data.

Backend DevelopmentMyBatisSpring Boot
0 likes · 12 min read
Coexisting Multiple DataSources in Spring Boot: No Switching Needed
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 3, 2025 · Backend Development

Mastering Spring Boot 3 TransactionExecutionListener with Real‑World Code

This article introduces Spring Boot 3's TransactionExecutionListener, explains its purpose compared to traditional transaction hooks, provides a complete code example—including entity, service, custom listener, and test cases—and demonstrates how to observe transaction phases and handle both successful commits and rollbacks.

BackendJavaSpring Boot
0 likes · 10 min read
Mastering Spring Boot 3 TransactionExecutionListener with Real‑World Code
IT Architects Alliance
IT Architects Alliance
Nov 4, 2025 · Backend Development

Mastering Distributed Data Consistency: Strategies, Patterns, and Best Practices

This article explores the challenges of maintaining data consistency in distributed microservice architectures, covering CAP theory, consistency models, replication strategies, transaction patterns like Saga and TCC, tooling choices, monitoring practices, and actionable best‑practice recommendations.

CAP theoremData ConsistencyDistributed Systems
0 likes · 13 min read
Mastering Distributed Data Consistency: Strategies, Patterns, and Best Practices
IT Services Circle
IT Services Circle
Oct 2, 2025 · Backend Development

How Spring Simplifies Transaction Management and Solves Common Pitfalls

This article explains the challenges of manual JDBC transaction handling, introduces Spring's unified transaction API with PlatformTransactionManager, TransactionDefinition, and TransactionStatus, demonstrates code examples for programmatic and declarative transactions, and discusses common pitfalls such as non‑public methods, self‑invocation, and exception handling.

JDBCJavaaop
0 likes · 17 min read
How Spring Simplifies Transaction Management and Solves Common Pitfalls
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 23, 2025 · Backend Development

Spring Boot 3 Concurrency: Locks, Optimistic & Pessimistic Updates

This article explains common problems of concurrent database updates in Spring Boot 3 and demonstrates five practical solutions—including database locks, optimistic and pessimistic locking, transaction isolation levels, and application‑level locks—accompanied by complete code examples and test results.

Spring Bootconcurrencyoptimistic lock
0 likes · 10 min read
Spring Boot 3 Concurrency: Locks, Optimistic & Pessimistic Updates
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 15, 2025 · Backend Development

Master Spring’s Core: IoC, DI, AOP & Transaction Explained

This article provides a comprehensive overview of the Spring framework, covering its core principles such as Inversion of Control, Dependency Injection, Aspect‑Oriented Programming, and transaction management, while illustrating each concept with diagrams and practical code examples for Java developers.

Backend DevelopmentJavaaop
0 likes · 7 min read
Master Spring’s Core: IoC, DI, AOP & Transaction Explained
Cognitive Technology Team
Cognitive Technology Team
Jul 16, 2025 · Databases

Mastering Dynamic Multi‑DataSource Management in Spring Boot: A Deep Dive

Dynamic‑datasource 4.3.1 offers a powerful AOP‑based, annotation‑driven solution for seamless multi‑database routing, read‑write separation, and load‑balancing in Spring Boot applications, while addressing common pitfalls such as transaction boundaries, connection‑pool configuration, health‑check failures, and version compatibility.

Multi-DataSourcedynamic-datasourcehealth check
0 likes · 18 min read
Mastering Dynamic Multi‑DataSource Management in Spring Boot: A Deep Dive
Cognitive Technology Team
Cognitive Technology Team
Jul 8, 2025 · Backend Development

Why Your Spring @Transactional Doesn’t Rollback: AOP Aspect Order Conflict Explained

An in‑depth analysis of a Spring transaction failure caused by a custom AOP aspect interfering with the default TransactionInterceptor, detailing the symptom, root cause, and step‑by‑step solutions—including adjusting aspect order, rethrowing exceptions, and manual rollback—to ensure reliable transaction management.

Aspect PriorityException Handlingaop
0 likes · 8 min read
Why Your Spring @Transactional Doesn’t Rollback: AOP Aspect Order Conflict Explained
Java Interview Crash Guide
Java Interview Crash Guide
Jul 3, 2025 · Backend Development

10 Proven Strategies to Supercharge API Performance in Java

This article presents a comprehensive, step‑by‑step guide to optimizing API latency by applying batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelism, indexing, transaction management, code refactoring, pagination, SQL tuning, and fine‑grained locking techniques.

API optimizationBatch ProcessingSQL Tuning
0 likes · 10 min read
10 Proven Strategies to Supercharge API Performance in Java
IT Services Circle
IT Services Circle
Jun 19, 2025 · Backend Development

Why We Skipped TCC: Using Compensation and Local Message Tables for Distributed Transactions

This article explains common distributed‑transaction solutions, describes the author’s own compensation‑plus‑local‑message‑table approach for merging customers across databases, outlines the TCC model with its Try‑Confirm‑Cancel phases, and details why TCC was rejected due to complexity, long resource locks, and rollback issues.

CompensationDistributed Transactionstcc
0 likes · 9 min read
Why We Skipped TCC: Using Compensation and Local Message Tables for Distributed Transactions
Su San Talks Tech
Su San Talks Tech
Jun 7, 2025 · Backend Development

10 Proven Strategies to Supercharge API Performance in Java Applications

This article presents a comprehensive set of practical techniques—including batch processing, asynchronous execution, caching, preprocessing, pooling, parallelization, indexing, pagination, SQL tuning, and lock granularity—to dramatically reduce API latency and improve overall backend system efficiency.

API optimizationAsynchronousBackend Performance
0 likes · 12 min read
10 Proven Strategies to Supercharge API Performance in Java Applications
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 1, 2025 · Backend Development

Master Spring Boot 3 DataSource: 8 Practical Connection Management Techniques

This article presents a comprehensive Spring Boot 3 tutorial that explains how the framework manages database connections, introduces eight built‑in DataSource control methods, and provides detailed code examples for configuring HikariCP, using DataSourceUtils, SmartDataSource, TransactionAwareDataSourceProxy, and transaction managers.

Backend DevelopmentDataSourceJava
0 likes · 12 min read
Master Spring Boot 3 DataSource: 8 Practical Connection Management Techniques
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 28, 2025 · Databases

Mastering Database Sharding: Design Strategies and Practical Cases

This article introduces the fundamentals of database sharding, outlines architectural evolution, explains vertical and horizontal splitting dimensions and strategies, discusses middleware choices, and presents real‑world case studies while addressing common challenges such as ID generation, join queries, pagination, and distributed transactions.

Scalabilitydatabase shardingmiddleware
0 likes · 8 min read
Mastering Database Sharding: Design Strategies and Practical Cases
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 6, 2025 · Backend Development

Why @Transactional Fails with @Async in Spring Boot 3 – A Deep Dive

This article explains how @Transactional and @Async normally cooperate in Spring Boot, demonstrates cases where the transaction does not roll back when @EnableAsync order is changed, analyzes the underlying AOP proxy creation and bean post‑processor execution order, and introduces new Spring 6.2 transaction‑rollback configuration options.

AsyncSpring Bootaop
0 likes · 9 min read
Why @Transactional Fails with @Async in Spring Boot 3 – A Deep Dive
Code Ape Tech Column
Code Ape Tech Column
Apr 15, 2025 · Backend Development

Understanding the Compatibility of @Transactional and @Async in Spring

This tutorial explains how Spring's @Transactional and @Async annotations work, explores their interaction in various scenarios such as bank‑transfer examples, discusses thread‑context propagation, highlights pitfalls when mixing them, and provides best‑practice recommendations for maintaining data integrity.

AsyncAsynchronous ExecutionBackend Development
0 likes · 11 min read
Understanding the Compatibility of @Transactional and @Async in Spring
Architect's Tech Stack
Architect's Tech Stack
Mar 17, 2025 · Backend Development

Comprehensive Interface Performance Optimization Strategies

This article presents a systematic guide to improving API response times by applying batch processing, asynchronous execution, caching, pooling, parallelism, indexing, transaction management, pagination, SQL tuning, and proper lock granularity, supplemented with practical Java code examples and diagrams.

AsynchronousBatch ProcessingSQL pagination
0 likes · 10 min read
Comprehensive Interface Performance Optimization Strategies
Top Architect
Top Architect
Mar 13, 2025 · Databases

Choosing Between NewSQL Databases and Middleware‑Based Sharding: Advantages, Trade‑offs and Practical Guidance

The article objectively compares NewSQL distributed databases with middleware‑plus‑sharding solutions, covering architectural differences, distributed transaction handling, high‑availability, scaling, SQL support, storage engines, maturity, and provides a decision‑making checklist to help engineers select the most suitable approach for their workloads.

NewSQLScalabilitydistributed databases
0 likes · 23 min read
Choosing Between NewSQL Databases and Middleware‑Based Sharding: Advantages, Trade‑offs and Practical Guidance
Pan Zhi's Tech Notes
Pan Zhi's Tech Notes
Jan 26, 2025 · Backend Development

Mastering Spring Transaction Management: From JDBC to @Transactional

This article explains the fundamentals of transaction handling in Spring Boot, covering both programmatic approaches with PlatformTransactionManager and TransactionTemplate and declarative management using @Transactional, while detailing common pitfalls, propagation and isolation settings, and providing concrete code examples.

Declarative TransactionJDBCProgrammatic Transaction
0 likes · 23 min read
Mastering Spring Transaction Management: From JDBC to @Transactional
Su San Talks Tech
Su San Talks Tech
Jan 7, 2025 · Databases

7 Common Pitfalls of Database Sharding and How to Solve Them

This article examines seven typical challenges that arise after implementing database sharding—such as global ID conflicts, cross‑shard queries, distributed transactions, shard‑key design, data migration, pagination, and operational overhead—and provides practical solutions and code examples to address each issue.

Distributed SystemsID generationdatabase scaling
0 likes · 12 min read
7 Common Pitfalls of Database Sharding and How to Solve Them
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 26, 2024 · Backend Development

Programmatic vs Declarative Transactions in Spring Boot 3: When Performance Matters

This article compares Spring Boot's declarative @Transactional annotation with programmatic transaction management using TransactionTemplate, TransactionalOperator, and TransactionManager, explains their suitable scenarios, provides code examples, and presents JMeter performance tests that show how the right choice can dramatically improve throughput.

Declarative TransactionsPerformance TestingProgrammatic Transactions
0 likes · 10 min read
Programmatic vs Declarative Transactions in Spring Boot 3: When Performance Matters
Su San Talks Tech
Su San Talks Tech
Oct 19, 2024 · Backend Development

Master Distributed Transactions with Seata: From Theory to AT Mode Implementation

This article explains the fundamentals of distributed transactions, the CAP theorem, various transaction patterns such as 2PC, 3PC, TCC, Saga, and introduces Seata's AT mode with step‑by‑step setup of the TC coordinator and microservice clients, culminating in a working e‑commerce example and key best‑practice takeaways.

AT ModeDistributed TransactionsMicroservices
0 likes · 41 min read
Master Distributed Transactions with Seata: From Theory to AT Mode Implementation
Top Architect
Top Architect
Oct 8, 2024 · Backend Development

Design and Architecture of Payment Business Systems

This article analyzes the complexities of payment business logic, breaks down the workflow into modular components, illustrates sequence diagrams, discusses related domains such as product and coupon management, and summarizes key technical considerations like transaction handling, locking, and settlement.

Backend Architecturee‑commercepayment
0 likes · 10 min read
Design and Architecture of Payment Business Systems
Lobster Programming
Lobster Programming
Sep 21, 2024 · Backend Development

Mastering Spring Boot Transaction Hooks for Advanced Business Logic

This article explains how Spring Boot’s @Transactional annotation works, introduces programmatic transaction management, and demonstrates how to create custom transaction hook functions with TransactionSynchronizationManager and TransactionSynchronization to execute custom logic at each transaction phase, improving robustness and maintainability.

Backend DevelopmentJavaSpring Boot
0 likes · 4 min read
Mastering Spring Boot Transaction Hooks for Advanced Business Logic
WeiLi Technology Team
WeiLi Technology Team
Aug 19, 2024 · Backend Development

How to Upgrade Spring Boot for MongoDB Transaction Support

This guide explains why upgrading from Spring Boot 1.5 to 2.1 is essential for MongoDB transaction management, outlines version requirements, highlights key feature changes, and provides step‑by‑step instructions with code examples to enable reliable transactional operations in a Spring‑based backend.

Backend DevelopmentMongoDBSpring Boot
0 likes · 11 min read
How to Upgrade Spring Boot for MongoDB Transaction Support
Tencent Cloud Developer
Tencent Cloud Developer
Jul 5, 2024 · Databases

Database Systems Reading List: Fundamentals, Design, Engines, and Optimizations

This curated bibliography compiles seminal database‑system papers—spanning foundational relational theory, system design for RDBMS and NoSQL, SQL engine optimization, storage structures, transaction and scheduling mechanisms, plus workload, networking, quality, and tuning research—each entry listing title, authors, year and a PDF link for scholars and practitioners.

Storage Enginedatabase systemsquery optimization
0 likes · 25 min read
Database Systems Reading List: Fundamentals, Design, Engines, and Optimizations
Su San Talks Tech
Su San Talks Tech
Jun 30, 2024 · Backend Development

How to Ensure Transaction Rollback Across Asynchronous Threads in Spring

This article explains how to guarantee that when any asynchronous thread fails during a large Excel import, the main thread can roll back all related transactions, covering the limitations of @Transactional and @Async, thread‑local propagation, and practical solutions using Future, CompletableFuture, custom ForkJoinPool, and manual transaction management.

Excel ImportJavaasynchronous programming
0 likes · 20 min read
How to Ensure Transaction Rollback Across Asynchronous Threads in Spring
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 14, 2024 · Backend Development

How Spring 6.2 Eliminates Bean Initialization Blocking and Boosts Startup Speed

Spring 6.2 introduces asynchronous bean initialization, a new addSingletonCallback mechanism, global transaction rollback settings, and injection performance optimizations, eliminating blocking during multi‑threaded event publishing and dramatically reducing startup time, as demonstrated with code examples and performance test results.

Bean InitializationPerformance Optimizationmultithreading
0 likes · 9 min read
How Spring 6.2 Eliminates Bean Initialization Blocking and Boosts Startup Speed
Architect
Architect
Mar 25, 2024 · Backend Development

Designing Payment Business Architecture: Process Decomposition, Sequence Diagram, and Structural Design

The article explains how to analyze, decompose, and design a payment system by breaking the workflow into modules, illustrating pre‑payment, third‑party integration, and post‑payment stages with sequence diagrams, and proposing a data‑structure model that covers account management, transaction records, order handling, and related business components.

Sequence Diagramarchitecturedata modeling
0 likes · 10 min read
Designing Payment Business Architecture: Process Decomposition, Sequence Diagram, and Structural Design
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 29, 2024 · Backend Development

Why Spring Transactions Fail and How to Fix Them

This article examines common scenarios that cause Spring transaction management to fail—such as non‑public methods, swallowed exceptions, incorrect rollback settings, self‑invocation, final methods, wrong propagation, asynchronous threads, unsupported database engines, and misuse of @Transactional—and provides concrete code‑level solutions to ensure reliable transactional behavior.

Backend DevelopmentJavaspring
0 likes · 10 min read
Why Spring Transactions Fail and How to Fix Them
Java Architect Essentials
Java Architect Essentials
Dec 22, 2023 · Backend Development

A Comprehensive Overview of MyBatis Architecture and Core Components

This article provides a detailed, global‑level review of MyBatis, covering its main features such as SQL mapping, dynamic SQL, parameter and result mapping, transaction management, connection‑pool integration, second‑level cache, as well as the three‑layer architecture, configuration parsing, proxy creation, and SQL execution process.

BackendJavaMyBatis
0 likes · 9 min read
A Comprehensive Overview of MyBatis Architecture and Core Components
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 16, 2023 · Backend Development

Master Spring Bean Injection: Prototype in Singleton, Lazy, Transactions & More

This guide explains how to handle various Spring bean injection and transaction challenges, including injecting prototype beans into singletons, using @Lazy, registering abstract beans, resolving multiple bean conflicts, forcing rollback without exceptions, injecting static fields, ensuring transaction consistency, enabling non‑public transactional methods, custom component scanning, and adding interfaces via AOP.

Bean ScopeJavadependency-injection
0 likes · 12 min read
Master Spring Bean Injection: Prototype in Singleton, Lazy, Transactions & More
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 8, 2023 · Backend Development

Spring Transaction Deep Dive: Thread‑Bound Connections and Multithreaded Consistency

This article explains Spring's transaction core, showing how TransactionInterceptor and TransactionAspectSupport use AOP to bind a Connection to ThreadLocal, walks through key code snippets for creating, committing, and rolling back transactions, and demonstrates a JUC‑based solution for maintaining transaction consistency across multiple threads.

JavaJdbcTemplateThreadLocal
0 likes · 9 min read
Spring Transaction Deep Dive: Thread‑Bound Connections and Multithreaded Consistency
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 18, 2023 · Backend Development

Why MyBatis SqlSession Crashes with Multiple Threads and How Spring Fixes It

This article examines the ClassCastException that occurs when 100 threads concurrently query MyBatis using a shared SqlSession, analyzes the root cause in DefaultSqlSession and BaseExecutor, and explains how Spring Boot’s MyBatis integration employs SqlSessionTemplate, ThreadLocal binding, and transaction management to guarantee thread‑safe SqlSession usage.

MyBatisSpring BootSqlSession
0 likes · 21 min read
Why MyBatis SqlSession Crashes with Multiple Threads and How Spring Fixes It
JD Cloud Developers
JD Cloud Developers
Aug 31, 2023 · Backend Development

Mastering Spring Transaction Management: From Basics to Advanced Scenarios

This article explains why transaction management is essential, how Spring abstracts resource handling, supports nested transactions and propagation behaviors, and compares declarative (annotation) and programmatic approaches, providing practical code examples and a deep dive into the underlying TransactionManager model.

Backend DevelopmentJavaspring
0 likes · 18 min read
Mastering Spring Transaction Management: From Basics to Advanced Scenarios
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 19, 2023 · Backend Development

Master Spring Boot Transaction Management with TransactionTemplate and PlatformTransactionManager

This guide explains Spring Boot's programmatic transaction management using TransactionTemplate, TransactionCallback, and PlatformTransactionManager, covering configuration, rollback handling, event listeners, and when to prefer programmatic versus declarative approaches, complete with code examples.

Backend DevelopmentJavaPlatformTransactionManager
0 likes · 8 min read
Master Spring Boot Transaction Management with TransactionTemplate and PlatformTransactionManager
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 1, 2023 · Backend Development

Boost Spring Boot Throughput: Programmatic Transaction Management vs @Transactional

This article demonstrates how using Spring Boot's TransactionTemplate to programmatically control transactions can prevent long‑running non‑transactional operations from blocking database connections, thereby increasing system throughput compared to the traditional @Transactional annotation, with detailed code examples and performance observations.

JavaSpring Bootjpa
0 likes · 6 min read
Boost Spring Boot Throughput: Programmatic Transaction Management vs @Transactional
Sanyou's Java Diary
Sanyou's Java Diary
Jul 13, 2023 · Backend Development

Mastering Distributed Transactions with Seata: Theory, Options, and Hands‑On Practice

This article explains the concept of distributed transactions, compares common solutions such as 2PC, 3PC, TCC, and message‑based eventual consistency, and provides a detailed walkthrough of configuring and using the Seata middleware—including AT mode workflow, server and client setup, and real‑world testing—so developers can confidently implement reliable cross‑service transactions.

2PCAT ModeMicroservices
0 likes · 18 min read
Mastering Distributed Transactions with Seata: Theory, Options, and Hands‑On Practice
Shopee Tech Team
Shopee Tech Team
Jul 13, 2023 · Backend Development

Design and Implementation of seadt-SAGA Distributed Transaction Framework

The article details Shopee’s seadt‑SAGA framework—a Go‑based distributed transaction solution that implements the SAGA pattern via two modes, orchestration with a central coordinator and collaboration with embedded logic, explains their state‑machine designs, compares rollback ordering using vector clocks versus sequence numbers, and discusses each mode’s trade‑offs.

CollaborationDistributed TransactionsGo
0 likes · 23 min read
Design and Implementation of seadt-SAGA Distributed Transaction Framework
Su San Talks Tech
Su San Talks Tech
Jul 11, 2023 · Backend Development

Why MyBatis‑Plus’s saveBatch Triggers Unexpected Transaction Rollbacks and How to Fix It

The article explains why the error "Transaction rolled back because it has been marked as rollback‑only" occurs in a Java Spring service when using MyBatis‑Plus saveBatch, how hidden @Transactional annotations cause hidden nested transactions, and presents a practical workaround by replacing the batch operation with a custom mapper.

Backend DevelopmentJavaMyBatis-Plus
0 likes · 7 min read
Why MyBatis‑Plus’s saveBatch Triggers Unexpected Transaction Rollbacks and How to Fix It
Selected Java Interview Questions
Selected Java Interview Questions
Jun 25, 2023 · Backend Development

Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions

This article explains how to execute two dependent tasks in parallel with CompletableFuture, why the usual @Transactional annotation fails in a multi‑threaded environment, and provides a programmatic transaction solution that copies Spring's transaction resources between threads to guarantee atomic commit or rollback across all parallel operations.

Backend DevelopmentCompletableFutureProgrammatic Transaction
0 likes · 19 min read
Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions
Architect's Guide
Architect's Guide
Jun 15, 2023 · Databases

Splitting a Massive MySQL Financial Transaction Table: Challenges, Design, and Implementation

The article describes how a finance team tackled a 50‑million‑row MySQL transaction table by analyzing the pain points, defining split goals, selecting sharding‑jdbc, designing multi‑source transaction handling, pagination across shards, data migration strategies, and a staged rollout to ensure stability and performance.

Backend DevelopmentData MigrationTable Sharding
0 likes · 10 min read
Splitting a Massive MySQL Financial Transaction Table: Challenges, Design, and Implementation
ITPUB
ITPUB
May 21, 2023 · Databases

Mastering Database Sharding: When, How, and Pitfalls of Partitioning

This article explains the concept, motivations, design methods, common patterns, and trade‑offs of database sharding (both table and database level), offering practical code examples, scalability criteria, and guidance on avoiding over‑engineering while considering alternatives like TiDB.

Hash ShardingPartitioningRange Sharding
0 likes · 19 min read
Mastering Database Sharding: When, How, and Pitfalls of Partitioning
MaGe Linux Operations
MaGe Linux Operations
May 14, 2023 · Backend Development

10 Proven Strategies to Supercharge API Performance in Legacy Projects

Discover a comprehensive set of ten practical techniques—including batch processing, asynchronous execution, caching, pooling, parallelization, indexing, transaction management, and SQL tuning—to dramatically reduce API latency and improve efficiency in legacy backend systems, illustrated with real-world examples and code snippets.

API performanceCode Optimizationasynchronous processing
0 likes · 8 min read
10 Proven Strategies to Supercharge API Performance in Legacy Projects
Architecture Digest
Architecture Digest
Apr 26, 2023 · Backend Development

Common API Performance Optimization Strategies

This article outlines a comprehensive set of backend API performance optimization techniques—including batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction handling, SQL tuning, and lock granularity—to reduce latency and improve system efficiency.

API performanceAsynchronous ExecutionSQL indexing
0 likes · 9 min read
Common API Performance Optimization Strategies
IT Architects Alliance
IT Architects Alliance
Apr 23, 2023 · Backend Development

Common Interface Performance Optimization Strategies

This article outlines a comprehensive set of backend interface optimization techniques—including batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction sizing, code restructuring, deep pagination, SQL tuning, and lock granularity—to reduce latency and improve overall system efficiency.

API optimizationAsynchronous ExecutionBatch Processing
0 likes · 8 min read
Common Interface Performance Optimization Strategies
Architect
Architect
Apr 20, 2023 · Backend Development

Common Interface Performance Optimization Strategies

This article summarizes practical techniques for reducing API latency, including batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction size control, program structure refactoring, deep pagination handling, SQL tuning, and proper lock granularity.

API optimizationBackend Performanceindexing
0 likes · 9 min read
Common Interface Performance Optimization Strategies
Top Architect
Top Architect
Apr 10, 2023 · Databases

Dynamic Multi‑DataSource Management and Transaction Handling in Spring

The article explains how to dynamically manage multiple data sources and ensure transaction consistency in Spring applications by extending AbstractRoutingDataSource, using configuration‑file or database‑table approaches, and applying AOP‑based switching with custom transaction management.

DynamicDataSourceJavaabstractroutingdatasource
0 likes · 16 min read
Dynamic Multi‑DataSource Management and Transaction Handling in Spring
Code Ape Tech Column
Code Ape Tech Column
Apr 7, 2023 · Backend Development

Dynamic Multi-DataSource Management and Transaction Handling in Spring

This article explains how to dynamically manage multiple data sources and ensure transaction consistency across them in Spring applications, covering both configuration‑file and database‑table approaches, custom AOP switching, and a bespoke multi‑database transaction mechanism.

Backend DevelopmentJavadynamic-datasource
0 likes · 14 min read
Dynamic Multi-DataSource Management and Transaction Handling in Spring
macrozheng
macrozheng
Apr 3, 2023 · Backend Development

Boost API Performance: 11 Proven Backend Optimization Techniques

This article presents a comprehensive set of backend API optimization strategies—including batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction management, code restructuring, deep pagination, SQL tuning, and lock granularity—to dramatically reduce response times and improve system efficiency.

API optimizationBackend Performanceasynchronous processing
0 likes · 10 min read
Boost API Performance: 11 Proven Backend Optimization Techniques
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 27, 2023 · Backend Development

Master Spring Transaction Abstraction: Platform & Reactive Managers

This article explains Spring's transaction abstraction, detailing the roles of PlatformTransactionManager and ReactiveTransactionManager, the TransactionDefinition attributes, TransactionStatus interface, resource synchronization techniques, declarative transaction management with AOP, rollback rules, and provides XML and Java configuration examples for both JDBC and Hibernate environments.

Backend DevelopmentDeclarative TransactionsJava
0 likes · 16 min read
Master Spring Transaction Abstraction: Platform & Reactive Managers
Top Architect
Top Architect
Feb 27, 2023 · Backend Development

Understanding Spring Transaction Management: @EnableTransactionManagement, Transaction Propagation, and Synchronization

This article explains how Spring enables transaction management through @EnableTransactionManagement, details the underlying proxy mechanism, outlines the basic and detailed execution flow, describes transaction propagation types and their classifications, and shows how to force rollback and use TransactionSynchronization for custom callbacks.

Backend DevelopmentJavaSynchronization
0 likes · 13 min read
Understanding Spring Transaction Management: @EnableTransactionManagement, Transaction Propagation, and Synchronization
ITPUB
ITPUB
Feb 10, 2023 · Backend Development

Designing Clean Application Services in DDD: Principles & Best Practices

This article explains how application services act as a façade for domain models, outlines key design principles, shows practical Go/Java implementation patterns, discusses transaction propagation and security handling, and provides concrete best‑practice recommendations for building thin, framework‑agnostic backend services.

Backend ArchitectureDDDGo
0 likes · 17 min read
Designing Clean Application Services in DDD: Principles & Best Practices
Code Ape Tech Column
Code Ape Tech Column
Feb 8, 2023 · Backend Development

Enhancing MVC Architecture with a Manager Layer in Java

The article explains the classic three‑layer MVC pattern, its shortcomings in complex Java projects, and proposes adding a Manager layer to separate generic business processing, reduce transaction scope, and improve code organization, illustrated with Spring‑based code examples.

JavaMVCService
0 likes · 9 min read
Enhancing MVC Architecture with a Manager Layer in Java
NetEase Yanxuan Technology Product Team
NetEase Yanxuan Technology Product Team
Feb 6, 2023 · Databases

Database Independence Migration for Yanxuan Trading System: Architecture Evolution and Implementation

Yanxuan migrated its monolithic trading system from a shared DDB cluster to an independent database by using Netease Data Canal for real‑time sync, a write‑stop switch with Pandora middleware, account and permission isolation, and extensive testing across three phases to ensure data consistency and minimal business impact.

Big Data IntegrationData ConsistencyEnterprise Database
0 likes · 15 min read
Database Independence Migration for Yanxuan Trading System: Architecture Evolution and Implementation
Top Architect
Top Architect
Dec 9, 2022 · Backend Development

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

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

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

Understanding Spring Transaction Management: @EnableTransactionManagement, Transaction Propagation, and Synchronization

This article provides a comprehensive guide to Spring transaction management, explaining the inner workings of @EnableTransactionManagement, the basic and detailed execution processes, various propagation mechanisms, forced rollback techniques, and TransactionSynchronization, supplemented with practical code examples and case analyses.

JavaSpring FrameworkTransaction Propagation
0 likes · 13 min read
Understanding Spring Transaction Management: @EnableTransactionManagement, Transaction Propagation, and Synchronization
Code Ape Tech Column
Code Ape Tech Column
Nov 28, 2022 · Backend Development

Resolving Long Transactions and Connection‑Closed Issues in Spring with Druid

This article analyzes why a Spring service encounters "connection closed" errors during long‑running transactions, explains how MyBatis and Druid manage connections, and provides a programmatic‑transaction solution that splits large operations into smaller units to prevent connection leaks and timeouts.

Backend DevelopmentDatabase ConnectionDruid
0 likes · 11 min read
Resolving Long Transactions and Connection‑Closed Issues in Spring with Druid
Su San Talks Tech
Su San Talks Tech
Nov 22, 2022 · Backend Development

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

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

Backend DevelopmentJavaaop
0 likes · 12 min read
Deep Dive into Spring Transaction: Source Code Walkthrough and Execution Flow
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
IT Architects Alliance
IT Architects Alliance
Aug 19, 2022 · Backend Development

Comprehensive Guide to Microservices Architecture, Spring Cloud, Dubbo, and Distributed System Practices

This article provides an in‑depth overview of microservice concepts, RPC frameworks, serialization methods, distributed transaction models, CAP and BASE theories, monitoring solutions, high‑availability strategies, load‑balancing techniques, configuration management, service registration/discovery, and Dubbo fault‑tolerance clusters, offering practical examples and code snippets for Java‑based cloud native systems.

Distributed SystemsDubboMicroservices
0 likes · 37 min read
Comprehensive Guide to Microservices Architecture, Spring Cloud, Dubbo, and Distributed System Practices
Programmer DD
Programmer DD
Jul 2, 2022 · Backend Development

How to Achieve Distributed Transaction Consistency with MQs

This article explains the challenges of distributed transactions in multi‑node systems, reviews common solutions such as 2PC, TCC, Saga, and focuses on implementing eventual consistency using message queues, detailing local message tables, MQ‑based transactions, and loss‑prevention techniques across RocketMQ, Kafka, and RabbitMQ.

ConsistencyDistributed TransactionsMQ
0 likes · 19 min read
How to Achieve Distributed Transaction Consistency with MQs
Baidu Geek Talk
Baidu Geek Talk
Jun 22, 2022 · Databases

Analyzing Go SQL Connection Pool Resource Release and Transaction Management

The article explains how Go's database/sql pool retains connections until Rows, Stmt, or Tx objects are explicitly closed or a timeout context is cancelled, demonstrates experiments showing blocked goroutines when resources aren't released, and offers practical guidelines—using QueryContext with timeouts, deferring Close/Cancel, and always committing or rolling back transactions—to prevent pool exhaustion and improve MySQL reliability.

Connection PoolGoSQL
0 likes · 19 min read
Analyzing Go SQL Connection Pool Resource Release and Transaction Management
Selected Java Interview Questions
Selected Java Interview Questions
May 14, 2022 · Backend Development

Optimizing Large‑Scale MySQL Updates with Manual Transactions and Multithreading in Spring Boot

This article demonstrates how to accelerate massive MySQL data updates in a Spring Boot application by replacing naïve loops with manual transaction control, multithreaded processing, CountDownLatch synchronization, and UNION‑based SQL batching, achieving up to a five‑fold speed increase.

Batch UpdateMyBatisSpringBoot
0 likes · 14 min read
Optimizing Large‑Scale MySQL Updates with Manual Transactions and Multithreading in Spring Boot
Sohu Tech Products
Sohu Tech Products
May 11, 2022 · Backend Development

Optimizing Large-Scale Database Updates with Manual Transactions and Multithreading in Spring Boot MyBatis

This article demonstrates how to efficiently update up to 50,000 MySQL records in a Spring Boot‑MyBatis application by comparing simple loops, manual transaction control, multithreaded execution with CountDownLatch coordination, and union‑based batch updates, while analyzing performance and connection‑pool considerations.

MyBatisPerformance OptimizationSpring Boot
0 likes · 14 min read
Optimizing Large-Scale Database Updates with Manual Transactions and Multithreading in Spring Boot MyBatis
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
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Feb 14, 2022 · Backend Development

How MyBatis Parses and Applies Transaction Managers: A Deep Dive

This article walks through how MyBatis parses the transaction manager factory from XML configuration, builds the Environment, and applies the transaction manager during SqlSession creation, including detailed code examples of XMLConfigBuilder, transaction factories, and the JdbcTransaction implementation.

Backend DevelopmentJavaMyBatis
0 likes · 8 min read
How MyBatis Parses and Applies Transaction Managers: A Deep Dive
IT Architects Alliance
IT Architects Alliance
Dec 6, 2021 · Backend Development

Mastering Distributed Transactions: From XA to TCC and Beyond

This article explains the fundamentals of database transactions, defines distributed transactions, and provides a comprehensive comparison of classic solutions such as XA, SAGA, TCC, local message tables, transaction messages, maximum‑effort notifications, and AT mode, while also covering exception handling and the sub‑transaction barrier technique.

BackendDistributed TransactionsMicroservices
0 likes · 19 min read
Mastering Distributed Transactions: From XA to TCC and Beyond
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 1, 2021 · Backend Development

Master Programmatic Transactions in Spring Boot 2.3.9 with Templates & Managers

This guide explains how to use Spring Boot's programmatic transaction APIs—including TransactionTemplate, TransactionManager, and transactional event listeners—through detailed code examples, configuration tips, rollback handling, and best‑practice recommendations for backend Java development.

Backend DevelopmentJavaProgrammatic Transactions
0 likes · 9 min read
Master Programmatic Transactions in Spring Boot 2.3.9 with Templates & Managers
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
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
Wukong Talks Architecture
Wukong Talks Architecture
Oct 17, 2021 · Backend Development

Common Scenarios Where Spring Transactions Fail and How to Fix Them

This article explains why Spring @Transactional may become ineffective in various situations—such as wrong method visibility, final or static modifiers, internal method calls, missing bean registration, multithreading, unsupported table engines, misconfigured propagation, swallowed exceptions, and improper rollback settings—and provides practical solutions for each case.

Backendtransactiontransaction-management
0 likes · 19 min read
Common Scenarios Where Spring Transactions Fail and How to Fix Them
Top Architect
Top Architect
Jul 21, 2021 · Backend Development

Understanding Spring's @Transactional Annotation: Implementation and AOP Mechanics

This article explains the purpose and inner workings of Spring's @Transactional annotation, detailing how AOP and dynamic proxies create transactional proxies, the role of BeanPostProcessor, advisors, TransactionInterceptor, and the transaction lifecycle, accompanied by code examples and diagrams for deeper insight.

Backend DevelopmentJavaaop
0 likes · 10 min read
Understanding Spring's @Transactional Annotation: Implementation and AOP Mechanics
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 10, 2021 · Backend Development

Mastering Programmatic Transaction Management in Spring Boot 2.3.9

This guide explains Spring Boot's two programmatic transaction approaches—TransactionTemplate/TransactionalOperator and direct TransactionManager—provides detailed code examples for using TransactionTemplate with return values, rollbacks, property configuration, demonstrates PlatformTransactionManager usage, and shows how to listen to transaction events with @TransactionalEventListener.

Backend DevelopmentJavaProgrammatic Transactions
0 likes · 8 min read
Mastering Programmatic Transaction Management in Spring Boot 2.3.9
Programmer DD
Programmer DD
Jul 9, 2021 · Backend Development

Why Catching an Exception Doesn't Prevent Spring Transaction Rollback

This article explains why a caught javax.validation.ConstraintViolationException in a Spring @Transactional method does not stop the transaction from rolling back, and shows how to debug the flow with logs and breakpoints to understand the underlying commit process.

DebuggingException HandlingJava
0 likes · 4 min read
Why Catching an Exception Doesn't Prevent Spring Transaction Rollback