BestHub
Sign in
Tagged articles

Transaction

423 articles · Page 2 of 5
Top Architect
Top Architect
Dec 12, 2024 · Backend Development

Using Spring Transaction Hooks to Send Kafka Messages After Transaction Commit

This article explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions, register synchronization callbacks, and asynchronously send Kafka messages only after a transaction successfully commits, illustrated with a payment‑system example and complete Java code snippets, while also noting thread‑local considerations and promotional offers.

KafkaSpringSpringBoot
0 likes · 12 min read
Using Spring Transaction Hooks to Send Kafka Messages After Transaction Commit
Top Architect
Top Architect
Nov 25, 2024 · Backend Development

Using Spring Transaction Hooks to Send Kafka Messages After Transaction Commit

This article explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks so that Kafka messages are sent asynchronously only after a transaction successfully commits, ensuring data consistency without impacting the main business flow.

KafkaSpringTransaction
0 likes · 12 min read
Using Spring Transaction Hooks to Send Kafka Messages After Transaction Commit
Top Architect
Top Architect
Nov 1, 2024 · Backend Development

Using Spring Transaction Hooks with TransactionSynchronizationManager for Asynchronous Kafka Messaging

The article explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks that asynchronously send Kafka messages after a transaction commits, ensuring reliable fund‑flow archiving in payment systems while avoiding thread‑switch issues.

KafkaSpringTransaction
0 likes · 11 min read
Using Spring Transaction Hooks with TransactionSynchronizationManager for Asynchronous Kafka Messaging
Programmer XiaoFu
Programmer XiaoFu
Oct 22, 2024 · Databases

What Batch Size Gives MySQL the Best Insert Performance?

This article explains how MySQL writes data to cache before flushing to disk, compares single‑row versus batch inserts, discusses how hardware limits, transaction size, and lock contention affect performance, and shows how to estimate an optimal batch size with concrete calculations and MyBatis examples.

Batch InsertDisk I/OMemory
0 likes · 14 min read
What Batch Size Gives MySQL the Best Insert Performance?
Top Architect
Top Architect
Oct 18, 2024 · Backend Development

Using Spring Transaction Hooks to Send Kafka Messages After Commit

This article explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions, register synchronization callbacks, and asynchronously send Kafka messages only after a transaction successfully commits, providing a practical example and detailed code snippets for building a reusable Spring Boot starter library.

KafkaSpringSpringBoot
0 likes · 12 min read
Using Spring Transaction Hooks to Send Kafka Messages After Commit
Architect
Architect
Oct 16, 2024 · Backend Development

Mastering Spring Transaction Hooks for Safe Kafka Publishing

This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions, register synchronization callbacks, and asynchronously publish payment‑log messages to Kafka without affecting the main business flow, complete with practical code snippets and pitfalls to avoid.

KafkaSpringTransaction
0 likes · 11 min read
Mastering Spring Transaction Hooks for Safe Kafka Publishing
macrozheng
macrozheng
Oct 11, 2024 · Backend Development

Does Spring Commit Before Unlock? Unraveling Transaction Timing in High‑Concurrency

This article dissects the exact moment a Spring @Transactional method commits relative to a surrounding lock, explains why committing after unlock can cause overselling, and provides source‑level debugging techniques to verify transaction start, commit, and rollback behavior in MySQL under high concurrency.

DatabaseLockSpring
0 likes · 21 min read
Does Spring Commit Before Unlock? Unraveling Transaction Timing in High‑Concurrency
IT Services Circle
IT Services Circle
Sep 14, 2024 · Backend Development

Spring Transaction Pitfalls: Common Scenarios Where Transactions Fail and How to Fix Them

This article explains the most common reasons why Spring @Transactional annotations may become ineffective or fail to roll back, covering access‑modifier issues, final methods, internal calls, self‑injection, multithreading, unsupported table engines, mis‑configured propagation, exception handling, nested transactions, large‑transaction problems, and the advantages of programmatic transaction management.

AOPDatabaseExceptionHandling
0 likes · 20 min read
Spring Transaction Pitfalls: Common Scenarios Where Transactions Fail and How to Fix Them
Su San Talks Tech
Su San Talks Tech
Sep 9, 2024 · Backend Development

Why Your Spring @Transactional Might Fail: 7 Common Pitfalls and How to Fix Them

This article explains why Spring transactions can become ineffective or fail to roll back, covering issues such as wrong method visibility, final methods, internal calls, missing Spring bean registration, multithreading, unsupported table engines, misconfigured propagation, exception handling, and offers practical solutions for each case.

AOPDatabaseSpring
0 likes · 21 min read
Why Your Spring @Transactional Might Fail: 7 Common Pitfalls and How to Fix Them
Top Architect
Top Architect
Sep 3, 2024 · Backend Development

Design and Implementation of a General Asynchronous Processing SDK for Java Backend

This article introduces a reusable asynchronous processing SDK for Java backend systems, explaining its purpose, advantages, underlying principles, component choices, design patterns, database schema, configuration options, usage instructions, and best‑practice notes, while providing complete code snippets and deployment details.

Design PatternKafkaTransaction
0 likes · 13 min read
Design and Implementation of a General Asynchronous Processing SDK for Java Backend
JavaEdge
JavaEdge
Sep 1, 2024 · Backend Development

How Kafka Implements Transactions and Achieves Exactly‑Once Guarantees

This article explains how Kafka implements transactions using a two‑phase commit protocol, compares its approach with RocketMQ, details the exactly‑once semantics for streaming workloads, and walks through the coordinator roles, message flow, and practical use‑case scenarios.

KafkaTransactiontwo-phase commit
0 likes · 10 min read
How Kafka Implements Transactions and Achieves Exactly‑Once Guarantees
Java High-Performance Architecture
Java High-Performance Architecture
Aug 28, 2024 · Databases

NewSQL vs Sharding: Which Database Architecture Truly Wins?

This article objectively compares NewSQL distributed databases with traditional middleware‑based sharding solutions, examining their architectural differences, transaction support, scalability, HA, storage engines, and ecosystem maturity, to help readers decide which approach best fits their performance, consistency, and operational needs.

HANewSQLSharding
0 likes · 18 min read
NewSQL vs Sharding: Which Database Architecture Truly Wins?
Top Architect
Top Architect
Aug 8, 2024 · Backend Development

Design and Implementation of Payment Business Architecture

This article outlines the business background, detailed payment workflow, associated product and coupon management, and practical implementation tips for designing a robust payment system, covering process decomposition, sequence diagrams, data structures, transaction handling, and key technical considerations such as transaction management, locking, and settlement accuracy.

Transactionarchitecturebackend
0 likes · 12 min read
Design and Implementation of Payment Business Architecture
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 1, 2024 · Backend Development

Backend API Design Best Practices

This article outlines comprehensive backend API design guidelines, covering parameter validation, extensibility, idempotency, logging, thread‑pool isolation, third‑party error handling, asynchronous processing, parallel queries, rate limiting, security, lock granularity, and strategies to avoid long‑running transactions.

API DesignAsynchronousIdempotency
0 likes · 11 min read
Backend API Design Best Practices
Top Architect
Top Architect
Jul 30, 2024 · Backend Development

Payment System Architecture: Business Background, Process Decomposition, Sequence Design, and Structural Design

This article analyzes the complexities of payment system design, covering business background, modular process breakdown, sequence diagrams for pre‑payment, payment integration, post‑payment stages, and detailed structural design, while also highlighting related business components and practical implementation tips.

System DesignTransactionarchitecture
0 likes · 12 min read
Payment System Architecture: Business Background, Process Decomposition, Sequence Design, and Structural Design
Architect
Architect
Jul 29, 2024 · Databases

NewSQL vs Middleware Sharding: Which Architecture Truly Wins?

This article objectively compares NewSQL distributed databases with traditional middleware‑based sharding solutions, examining their architectures, transaction models, scalability, high‑availability mechanisms, storage engines, maturity, and offering a decision framework to help engineers choose the most suitable approach for their workloads.

CAP theoremDatabase ArchitectureDistributed Databases
0 likes · 20 min read
NewSQL vs Middleware Sharding: Which Architecture Truly Wins?
Top Architect
Top Architect
Jul 14, 2024 · Backend Development

Designing Complex Payment Systems: Architecture, Process Decomposition, and Best Practices

The article outlines the challenges of payment systems, detailing business background, process decomposition, flow sequencing, structural design, related product and coupon management, and summarizes key technical considerations such as transaction management, locking, retry mechanisms, and fund settlement for robust backend development.

Transactionarchitecturebackend
0 likes · 12 min read
Designing Complex Payment Systems: Architecture, Process Decomposition, and Best Practices
Architect's Guide
Architect's Guide
Jul 11, 2024 · Backend Development

Using Spring Transaction Hooks to Send Kafka Messages After Commit

This article demonstrates how to leverage Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks that asynchronously push payment‑ledger messages to Kafka only after the transaction successfully commits, ensuring data consistency and minimal impact on the main business flow.

KafkaSpringTransaction
0 likes · 9 min read
Using Spring Transaction Hooks to Send Kafka Messages After Commit
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 2, 2024 · Backend Development

When Should You Send Messages in a Transaction? Real‑World Order Processing Insights

This article examines the trade‑offs of sending messages before, during, or after database persistence in order‑creation workflows, explores transaction‑message patterns, half‑message checks, and message‑table strategies, and offers practical guidance for building reliable backend messaging systems.

Message QueueTransactionbackend
0 likes · 10 min read
When Should You Send Messages in a Transaction? Real‑World Order Processing Insights
Architect
Architect
Jun 25, 2024 · Backend Development

Mastering Spring Transaction Hooks: Send Kafka Messages Only After Commit

This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register callbacks that asynchronously send Kafka messages after a transaction successfully commits, ensuring data consistency in payment‑system archiving scenarios.

KafkaSpringSpringBoot
0 likes · 10 min read
Mastering Spring Transaction Hooks: Send Kafka Messages Only After Commit
Top Architect
Top Architect
Jun 12, 2024 · Backend Development

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

The article explains how to analyze, decompose, and design a complex payment workflow by breaking it into modules, defining pre‑payment, payment‑gateway, and post‑payment sequences, and outlining the essential data structures such as account management, transaction records, and order handling, while also highlighting practical implementation considerations.

Transactionarchitecturebackend
0 likes · 10 min read
Payment Business Architecture: Process Decomposition, Sequence Design, and Structural Design
Java High-Performance Architecture
Java High-Performance Architecture
May 12, 2024 · Databases

NewSQL vs Sharding: Which Database Architecture Truly Wins?

This article objectively compares NewSQL databases with middleware‑based sharding solutions, examining their architectural differences, transaction handling, scalability, high‑availability mechanisms, storage engines, and maturity to help readers decide which approach best fits their specific workload and business requirements.

CAP theoremNewSQLSharding
0 likes · 18 min read
NewSQL vs Sharding: Which Database Architecture Truly Wins?
macrozheng
macrozheng
May 11, 2024 · Backend Development

When Does @Transactional Commit? Before or After Unlock?

This article explains the timing of Spring's @Transactional commit relative to lock release, analyzes why committing after unlock can cause overselling, shows how to trace the transaction lifecycle in the source code, and offers practical solutions to ensure atomicity in high‑concurrency scenarios.

DatabaseLockSpring
0 likes · 19 min read
When Does @Transactional Commit? Before or After Unlock?
Java Tech Enthusiast
Java Tech Enthusiast
May 3, 2024 · Databases

MySQL Data Recovery: Strategies for Handling Accidental Deletion

The article explains how to respond to accidental MySQL data deletion by analyzing loss causes, choosing recovery methods such as mysqldump backups, binary‑log point‑in‑time restores, or Percona’s InnoDB tool, provides step‑by‑step commands, and recommends preventive practices like regular backups, transactions, and strict permissions.

Data RecoveryDatabase SecurityMySQL
0 likes · 3 min read
MySQL Data Recovery: Strategies for Handling Accidental Deletion
Architecture Digest
Architecture Digest
Apr 19, 2024 · Databases

Comparing NewSQL Distributed Databases with Middleware‑Based Sharding: Advantages, Trade‑offs, and Use Cases

The article objectively compares NewSQL distributed databases with traditional middleware‑based sharding solutions, examining their architectural differences, distributed transaction support, performance, scalability, high‑availability mechanisms, storage engines, and practical suitability for various application scenarios.

CAP theoremDistributed DatabasesHigh Availability
0 likes · 18 min read
Comparing NewSQL Distributed Databases with Middleware‑Based Sharding: Advantages, Trade‑offs, and Use Cases
Code Ape Tech Column
Code Ape Tech Column
Apr 18, 2024 · Backend Development

Applying Spring Transaction Hooks for Asynchronous Kafka Message Publishing

This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks so that Kafka messages are sent asynchronously after transaction commit, illustrated with a payment‑system logging scenario and complete Java code examples.

AsynchronousKafkaSpring
0 likes · 10 min read
Applying Spring Transaction Hooks for Asynchronous Kafka Message Publishing
MaGe Linux Operations
MaGe Linux Operations
Apr 9, 2024 · Databases

How to Simulate and Prevent SQL Server Deadlocks: A Step-by-Step Guide

This article explains what SQL Server deadlocks are, why they occur, demonstrates a reproducible deadlock scenario with T‑SQL code, and provides practical strategies such as proper schema design, indexing, query optimization, shorter transactions, appropriate isolation levels, and monitoring to minimize deadlock occurrences.

DeadlockSQL ServerTransaction
0 likes · 9 min read
How to Simulate and Prevent SQL Server Deadlocks: A Step-by-Step Guide
Selected Java Interview Questions
Selected Java Interview Questions
Mar 29, 2024 · 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 a master and several application databases in Spring by extending AbstractRoutingDataSource, using configuration‑file and database‑table solutions, and implementing a custom multi‑database transaction manager.

DataSourceDynamicRoutingSpring
0 likes · 15 min read
Dynamic Multi-DataSource Management and Transaction Handling in Spring
Chen Tian Universe
Chen Tian Universe
Mar 26, 2024 · Fundamentals

What’s the Core Architecture Behind Modern Payment Systems?

This article breaks down the essential "kernels" of payment, transaction, settlement, accounting, and related financial processes, illustrating each layer with diagrams and explanations that reveal how businesses, platforms, and institutions collaborate to move money securely and efficiently.

Core ConceptsSettlementTransaction
0 likes · 15 min read
What’s the Core Architecture Behind Modern Payment Systems?
Selected Java Interview Questions
Selected Java Interview Questions
Mar 11, 2024 · Databases

Key MySQL Interview Questions and Answers: Joins, Indexes, Transactions, and Optimization

This article provides a comprehensive overview of essential MySQL interview topics, covering join types, differences among DROP, DELETE, TRUNCATE, UNION vs UNION ALL, CHAR vs VARCHAR, transaction properties and isolation levels, database normalization, index types and usage, query execution flow, storage engine differences, and practical SQL optimization techniques.

IndexOptimizationSQL
0 likes · 20 min read
Key MySQL Interview Questions and Answers: Joins, Indexes, Transactions, and Optimization
Architect's Guide
Architect's Guide
Mar 1, 2024 · Backend Development

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

The article explains how to execute parallel tasks with CompletableFuture, why @Async cannot guarantee transactional integrity in a multi‑threaded Spring environment, and presents a programmatic transaction approach—including copying transaction resources between threads—to achieve consistent commit or rollback across concurrent operations.

CompletableFutureProgrammaticTransactionSpring
0 likes · 19 min read
Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions
Architect
Architect
Feb 23, 2024 · Backend Development

Mastering Spring Transaction Propagation: When and How Transactions Merge, Suspend, or Nest

This article explains the seven Spring transaction propagation levels, shows how nested @Transactional methods interact under each level, and provides concrete code‑level examples that illustrate when transactions are merged, suspended, started anew, or rolled back, helping developers choose the right strategy for reliable enterprise applications.

SpringTransactionTransactional
0 likes · 14 min read
Mastering Spring Transaction Propagation: When and How Transactions Merge, Suspend, or Nest
High Availability Architecture
High Availability Architecture
Feb 19, 2024 · Backend Development

Understanding Spring Transaction Propagation Mechanisms

This article explains Spring's seven transaction propagation behaviors—REQUIRED, SUPPORTS, MANDATORY, REQUIRES_NEW, NOT_SUPPORTED, NEVER, and NESTED—detailing how nested transactional methods interact, when new transactions are created or suspended, and how exceptions influence commit and rollback across different propagation settings.

SpringTransactionTransactional
0 likes · 10 min read
Understanding Spring Transaction Propagation Mechanisms
Su San Talks Tech
Su San Talks Tech
Feb 15, 2024 · Backend Development

How to Ensure Transaction Rollback in Spring Multithreaded Operations

This article explains why the @Transactional annotation fails in Spring when using multithreading, demonstrates a failing example, and provides a solution using manual SqlSession management to guarantee that all database changes are rolled back if any thread encounters an exception.

MyBatisRollbackSpring
0 likes · 10 min read
How to Ensure Transaction Rollback in Spring Multithreaded Operations
Su San Talks Tech
Su San Talks Tech
Feb 13, 2024 · Backend Development

How to Ensure Transaction Consistency When Async Threads Fail in Spring

This article explains how to guarantee transactional integrity when importing a 100,000‑row Excel file with asynchronous threads in Spring, covering double‑async optimization, Future and CompletableFuture handling, @Transactional pitfalls, manual transaction control, and a complete solution for cross‑thread transaction management.

AsyncCompletableFutureExcel import
0 likes · 18 min read
How to Ensure Transaction Consistency When Async Threads Fail in Spring
Nullbody Notes
Nullbody Notes
Jan 23, 2024 · Databases

Implementing Redis Transactions in Go: A Complete Walkthrough

This article walks through building a functional Redis server in Go, focusing on transaction support (MULTI, EXEC, WATCH, UNWATCH, DISCARD), using locks for atomicity, version tracking for watch, and an undo‑log mechanism for rollback, with code examples and demo screenshots.

DatabaseGoLock
0 likes · 11 min read
Implementing Redis Transactions in Go: A Complete Walkthrough
php Courses
php Courses
Jan 9, 2024 · Databases

Efficiently Inserting 10 Million Records into MySQL with PHP

This tutorial explains how to use PHP and PDO to quickly insert ten million rows into a remote MySQL database by preparing the connection, employing batch inserts, managing transactions, tuning MySQL settings, and optionally using the LOAD DATA statement for optimal performance.

Bulk InsertMySQLPDO
0 likes · 6 min read
Efficiently Inserting 10 Million Records into MySQL with PHP
vivo Internet Technology
vivo Internet Technology
Jan 3, 2024 · Backend Development

Understanding Spring Transaction Propagation Mechanisms

Spring’s transaction propagation defines seven behaviors—REQUIRED, SUPPORTS, MANDATORY, REQUIRES_NEW, NOT_SUPPORTED, NEVER, and NESTED—detailing how methods join, create, suspend, or nest transactions, and the article explains each type, practical scenarios, and how proper selection ensures atomicity, consistency, and correct rollback handling.

SpringTransactionTransactional
0 likes · 9 min read
Understanding Spring Transaction Propagation Mechanisms
IT Xianyu
IT Xianyu
Jan 2, 2024 · Backend Development

Ensuring Transaction Consistency in Multithreaded Spring Applications Using Programmatic Transactions

This article explains how to execute two dependent tasks in parallel, guarantee their successful completion before a final step, and maintain transaction consistency across multiple threads in Spring by using CompletableFuture, programmatic transaction management, and a custom transaction‑resource copying mechanism.

CompletableFutureProgrammaticTransactionSpring
0 likes · 18 min read
Ensuring Transaction Consistency in Multithreaded Spring Applications Using Programmatic Transactions
Sanyou's Java Diary
Sanyou's Java Diary
Dec 21, 2023 · Databases

What Happens Inside MySQL When You Run an UPDATE? A Deep Dive

This article explains the complete execution process of a MySQL UPDATE statement, covering InnoDB page structures, tablespaces, buffer pool caching, redo/undo logs, binlog, and the two‑phase commit mechanism, helping readers understand how MySQL ensures data consistency and durability.

InnoDBMySQLRedo Log
0 likes · 21 min read
What Happens Inside MySQL When You Run an UPDATE? A Deep Dive
Su San Talks Tech
Su San Talks Tech
Dec 18, 2023 · Databases

Master MySQL Transactions: ACID, Isolation Levels, and MVCC Explained

This comprehensive guide explores MySQL transaction fundamentals, the ACID properties, various isolation levels, concurrency issues like dirty, non‑repeatable, and phantom reads, and dives deep into MVCC implementation, hidden fields, undo logs, and read views to help developers write reliable, consistent database code.

ACIDDatabaseIsolation Level
0 likes · 24 min read
Master MySQL Transactions: ACID, Isolation Levels, and MVCC Explained
DataFunTalk
DataFunTalk
Dec 17, 2023 · Databases

Evolution of MatrixOne: From NewSQL/MPP Roots to a Modern HTAP Architecture

This article introduces the open‑source distributed database MatrixOne, tracing its early NewSQL/MPP architecture, the challenges that prompted a major redesign, and the resulting HTAP‑oriented three‑layer architecture with decoupled compute, transaction, and storage layers, highlighting performance, cost, and scalability improvements.

HTAPMatrixOneStorage Engine
0 likes · 22 min read
Evolution of MatrixOne: From NewSQL/MPP Roots to a Modern HTAP Architecture
Nullbody Notes
Nullbody Notes
Dec 17, 2023 · Backend Development

Build Your Own Go ORM: Logger, Struct Mapping, CRUD, Transactions & Hooks

This tutorial walks through creating a lightweight Go ORM—covering a custom logger, converting structs to table metadata, implementing basic CRUD operations, handling transactions, and adding hook callbacks—while exposing the core Session data structure and providing a GitHub reference.

DatabaseGORMGo
0 likes · 7 min read
Build Your Own Go ORM: Logger, Struct Mapping, CRUD, Transactions & Hooks
政采云技术
政采云技术
Dec 14, 2023 · Databases

Understanding MySQL Locks: Types, Mechanisms, and Deadlock Resolution

This article explains the various lock types in MySQL—including global, table, row, metadata, and intent locks—how they work under InnoDB, demonstrates lock acquisition with SQL examples, and provides practical guidance for detecting and resolving deadlocks in production environments.

DatabaseDeadlockInnoDB
0 likes · 17 min read
Understanding MySQL Locks: Types, Mechanisms, and Deadlock Resolution
Top Architect
Top Architect
Dec 11, 2023 · Backend Development

Optimizing Large Transactions in Backend Development

The article explains why large database transactions degrade backend API performance, outlines issues such as data inconsistency, lock contention, and log overhead, and presents practical optimization techniques including avoiding RPC inside transactions, using programmatic transactions, batch processing, splitting into smaller transactions, and asynchronous parallel execution with CompletableFuture.

Transactionbackend
0 likes · 10 min read
Optimizing Large Transactions in Backend Development
Efficient Ops
Efficient Ops
Dec 6, 2023 · Databases

When and How to Use MySQL Locks: A Deep Dive into Explicit and Implicit Locking

This article explains MySQL's explicit and implicit locking mechanisms, illustrates how transaction isolation levels affect lock scope, provides practical SQL examples for various scenarios, and offers guidelines on when to apply pessimistic locks versus optimistic approaches to maintain database performance.

DatabaseMySQLSQL
0 likes · 13 min read
When and How to Use MySQL Locks: A Deep Dive into Explicit and Implicit Locking
Architect
Architect
Dec 2, 2023 · Backend Development

7 Common Message‑Queue Scenarios and How to Choose the Right Type

This article examines seven typical messaging scenarios—ordinary, ordered, delayed, transactional, trace, dead‑letter, and priority messages—explaining the problem each solves, the trade‑offs, and concrete implementations in RocketMQ, Pulsar, RabbitMQ and Kafka with code samples.

Message QueueOrderingTransaction
0 likes · 14 min read
7 Common Message‑Queue Scenarios and How to Choose the Right Type
Architect
Architect
Nov 21, 2023 · Backend Development

Why Large Database Transactions Slow Your API and How to Fix Them

The article explains how bundling many business‑logic steps into a single large transaction harms API performance, outlines the resulting concurrency, locking, undo‑log, and DB‑pressure issues, and then presents practical techniques—programmatic transactions, batch processing, transaction splitting, and asynchronous parallelism—to optimize and speed up backend services.

AsynchronousTransactionbatch-processing
0 likes · 10 min read
Why Large Database Transactions Slow Your API and How to Fix Them
MaGe Linux Operations
MaGe Linux Operations
Nov 18, 2023 · Databases

Understanding SQL Server Deadlocks: Causes, Detection, and Prevention

This article explains the principle of deadlocks, the four necessary conditions, how they manifest in SQL Server resources, methods for investigating deadlocks with system procedures and Profiler, and practical techniques—including isolation level changes, lock timeouts, and bound sessions—to avoid and resolve them.

DeadlockSQL ServerTransaction
0 likes · 17 min read
Understanding SQL Server Deadlocks: Causes, Detection, and Prevention
IT Architects Alliance
IT Architects Alliance
Nov 17, 2023 · Backend Development

Design and Implementation of a Generic Asynchronous Processing SDK

This article introduces a generic asynchronous processing SDK for Java Spring applications, covering its purpose, advantages, underlying principles, component choices such as Kafka, XXL‑Job, MySQL, design patterns, database schema, configuration via Apollo, usage instructions, safety considerations, and provides code examples and a GitHub repository link.

AOPKafkaMySQL
0 likes · 9 min read
Design and Implementation of a Generic Asynchronous Processing SDK
Java High-Performance Architecture
Java High-Performance Architecture
Nov 17, 2023 · Backend Development

How to Ensure Transaction Rollback in Multithreaded Spring Applications

This article demonstrates why @Transactional fails in multithreaded Spring services, presents a thread‑pool based solution using manual SqlSession control to achieve full rollback across child threads, and provides complete code examples and test results illustrating both failure and successful transaction handling.

DatabaseMyBatisSpring
0 likes · 10 min read
How to Ensure Transaction Rollback in Multithreaded Spring Applications
JD Tech
JD Tech
Nov 13, 2023 · Databases

Analysis of MySQL Lock Mechanisms and Deadlock Scenarios

This article examines MySQL's various lock types—including shared, exclusive, gap, next‑key, and insert‑intention locks—illustrates how they interact during concurrent transactions, analyzes a real‑world deadlock incident, and provides recommendations for preventing similar concurrency issues in high‑traffic systems.

LocksMySQLTransaction
0 likes · 19 min read
Analysis of MySQL Lock Mechanisms and Deadlock Scenarios
Architecture Digest
Architecture Digest
Nov 10, 2023 · Backend Development

Understanding Spring Boot @Async: Usage, Pitfalls, and Best Practices

This article explains how to enable and configure Spring Boot's @Async annotation, demonstrates proper thread‑pool setup, highlights common mistakes such as calling async methods within the same class or mixing with @Transactional, and provides guidance on handling blocking tasks and exceptions for robust asynchronous execution.

AsynchronousException HandlingSpring Boot
0 likes · 10 min read
Understanding Spring Boot @Async: Usage, Pitfalls, and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Oct 30, 2023 · Databases

Understanding SELECT ... FOR UPDATE Locks in MySQL

This article explains how MySQL's SELECT ... FOR UPDATE statement applies different lock types—row, table, or none—depending on whether the WHERE clause uses primary keys, unique indexes, regular indexes, range queries, non‑indexed fields, or returns no rows, illustrated with practical transaction examples.

Row LockSELECT FOR UPDATESQL
0 likes · 9 min read
Understanding SELECT ... FOR UPDATE Locks in MySQL
Selected Java Interview Questions
Selected Java Interview Questions
Oct 11, 2023 · Databases

Understanding and Handling MySQL Deadlocks

This article explains MySQL deadlocks, describing common scenarios such as multi‑table updates, nested transactions, inconsistent index order, and concurrent index updates, provides a concrete banking transfer example, and outlines practical steps for monitoring, terminating, retrying, analyzing, and preventing deadlocks in production.

SQLTransaction
0 likes · 9 min read
Understanding and Handling MySQL Deadlocks
Su San Talks Tech
Su San Talks Tech
Oct 6, 2023 · Databases

How MySQL Executes SQL: From Connection Pools to Log Files Explained

This article walks through how a Java application interacts with MySQL, covering the driver, connection pooling, thread handling, query parsing, the optimizer, storage engine, buffer pool, undo/redo logs, binlog, and transaction commit, providing a complete end‑to‑end view of MySQL’s internal processing.

DatabaseInnoDBMySQL
0 likes · 22 min read
How MySQL Executes SQL: From Connection Pools to Log Files Explained
政采云技术
政采云技术
Sep 28, 2023 · Backend Development

Common Scenarios Where Spring @Transactional Fails and How to Avoid Them

This article explains the fundamentals of database transactions, introduces Spring's @Transactional annotation, and enumerates nine typical situations—such as incorrect method visibility, final methods, self‑invocation, unmanaged beans, multithreading, wrong propagation, swallowed exceptions, unsupported exception types, and non‑transactional storage engines—where transactions may not work as expected, offering guidance to prevent these pitfalls.

AOPSpringTransaction
0 likes · 13 min read
Common Scenarios Where Spring @Transactional Fails and How to Avoid Them
dbaplus Community
dbaplus Community
Sep 27, 2023 · Databases

Understanding MySQL Locks: Which Queries Actually Acquire Locks?

This article breaks down MySQL's complex locking mechanisms—global, table, and row locks—explaining how different SELECT statements, transaction isolation levels, and index types affect lock acquisition, and provides practical test scripts and visual examples to help developers master lock behavior.

InnoDBIsolationLevelLocks
0 likes · 14 min read
Understanding MySQL Locks: Which Queries Actually Acquire Locks?
Top Architect
Top Architect
Sep 25, 2023 · Backend Development

Idempotency in Backend Development: Concepts, Importance, and Implementation Strategies

The article explains the concept of idempotency, its significance in preventing duplicate operations such as double payments, and outlines various backend techniques—including MVCC, deduplication tables, token mechanisms, and distributed locks—to ensure consistent system behavior across retries and network failures.

APIIdempotencyTransaction
0 likes · 13 min read
Idempotency in Backend Development: Concepts, Importance, and Implementation Strategies
ITPUB
ITPUB
Sep 23, 2023 · Databases

Is PostgreSQL Really the Most Popular Database? A Deep Dive into Rankings, Architecture, and Performance

This article examines why PostgreSQL appears to outrank MySQL in recent popularity surveys, explains the DB‑Engines ranking methodology, compares architectural choices such as MVCC, multi‑process vs multi‑thread models, transaction rollback behavior, licensing, and real‑world performance benchmarks like TPC‑C, ultimately revealing that MySQL still dominates many high‑throughput OLTP scenarios.

Database ComparisonMVCCMySQL
0 likes · 17 min read
Is PostgreSQL Really the Most Popular Database? A Deep Dive into Rankings, Architecture, and Performance
Tencent Cloud Developer
Tencent Cloud Developer
Sep 18, 2023 · Databases

Who Is the World's Most Successful Database? An In‑Depth Technical Comparison of PostgreSQL and MySQL

The article evaluates database success by comparing PostgreSQL and MySQL across popularity, features, licensing, transaction behavior, MVCC, concurrency models, and use cases, showing PostgreSQL leads in complex queries and feature richness while MySQL remains the most widely used OLTP system, especially in China.

DB-EnginesDatabase ComparisonMVCC
0 likes · 15 min read
Who Is the World's Most Successful Database? An In‑Depth Technical Comparison of PostgreSQL and MySQL
dbaplus Community
dbaplus Community
Sep 14, 2023 · Databases

Master MySQL InnoDB Locks: From Row Locks to Deadlock Prevention

This article explains why MySQL needs locking, details every InnoDB lock type—including shared, exclusive, intention, record, gap, next‑key, insert‑intention and auto‑increment locks—covers lock compatibility, deadlock causes and prevention, compares optimistic and pessimistic locking, and shows how SELECT FOR UPDATE behaves under different isolation levels.

DeadlockInnoDBMySQL
0 likes · 20 min read
Master MySQL InnoDB Locks: From Row Locks to Deadlock Prevention
Architect
Architect
Sep 12, 2023 · Backend Development

Ensuring Transaction Consistency in Multi‑Threaded Spring Applications Using CompletableFuture and Programmatic Transactions

This article explains how to parallelize business steps with CompletableFuture, why Spring's @Async and @Transactional annotations cannot guarantee transaction consistency across threads, and presents a programmatic transaction approach—including copying Spring's transaction resources between threads—to achieve reliable multi‑threaded commits or rollbacks.

CompletableFutureProgrammaticTransactionSpring
0 likes · 19 min read
Ensuring Transaction Consistency in Multi‑Threaded Spring Applications Using CompletableFuture and Programmatic Transactions
Architect's Tech Stack
Architect's Tech Stack
Jun 24, 2023 · Backend Development

Implementing Multi‑threaded Transactions in Spring Boot with Custom Annotations and AOP

This article explains why @Transactional fails in multithreaded Spring Boot scenarios, then demonstrates how to combine @Async, a custom thread‑pool, @MainTransaction and @SonTransaction annotations with AOP logic to achieve reliable multi‑threaded transaction control, complete with code examples and usage guidelines.

AOPCustom AnnotationTransaction
0 likes · 12 min read
Implementing Multi‑threaded Transactions in Spring Boot with Custom Annotations and AOP
Aikesheng Open Source Community
Aikesheng Open Source Community
Jun 6, 2023 · Databases

Why Does Inserting a Record that Triggers a Unique Index Conflict Add a Next‑Key Exclusive Lock on the Primary‑Key Supremum Record?

This article reproduces a MySQL 8.0.32 InnoDB scenario where inserting a row that violates a unique index causes a next‑key exclusive lock on the primary‑key supremum record, explains the underlying implicit‑lock mechanism, walks through the relevant source‑code stack, and details the lock‑conversion and rollback steps under REPEATABLE‑READ isolation.

Database InternalsInnoDBMySQL
0 likes · 25 min read
Why Does Inserting a Record that Triggers a Unique Index Conflict Add a Next‑Key Exclusive Lock on the Primary‑Key Supremum Record?
Cognitive Technology Team
Cognitive Technology Team
May 21, 2023 · Backend Development

Concurrency Safety Issues Caused by AOP Object Escape and Incorrect Advice Order in Spring

This article explains how improper use of AOP in Spring can cause object escape leading to concurrency safety problems, discusses issues such as asynchronous thread modifications, caching, and incorrect advice ordering with @Transaction, @Retryable, and dynamic datasource switching, and provides practical guidance to avoid these pitfalls.

AOPObject EscapeSpring
0 likes · 5 min read
Concurrency Safety Issues Caused by AOP Object Escape and Incorrect Advice Order in Spring