0 views collected around this technical thread.
This article explains a puzzling Spring Boot transaction rollback caused by MyBatis-Plus's saveBatch method, reproduces the error with nested @Transactional calls, analyzes why the rollback flag is set, and offers a practical workaround by replacing the framework batch operation with a custom mapper implementation.
This article explains how to locate and analyze MySQL slow queries, understand index structures and types, apply best practices for index creation, handle large pagination, manage transaction isolation and MVCC, and implement master‑slave replication and sharding strategies for high‑performance databases.
This article explains MySQL InnoDB locking mechanisms—including row, record, gap, next‑key, and intention locks—illustrates each type with SQL statements and performance_schema data, and shows how they interact during concurrent transactions.
This article provides a comprehensive overview of database transactions, explaining ACID properties, transaction states, explicit and implicit transaction control, isolation levels, and how to configure and use them in MySQL with practical SQL examples and code snippets.
This article explains how using a custom @DistributeLock annotation together with @Transactional can cause idempotency issues due to aspect execution order, and demonstrates how to prioritize the lock aspect using @Order to ensure the lock is applied before the transaction, with code examples and best‑practice recommendations.
This article explains the sequential write process of Undo Log, Redo Log, and Binlog during MySQL transaction execution and commit phases, describes the involved caches, two‑phase commit rationale, and outlines key configuration parameters for each log type.
The production failure where a customer‑service event creation stopped each morning was traced to RedisTemplate’s increment returning null because @Transactional combined with enabled Redis transaction support caused the command to be queued in a MULTI/EXEC block, which is fixed by using separate non‑transactional and transactional StringRedisTemplate beans.
This article explains MySQL deadlocks by creating a test table, running two concurrent transactions—one using SLEEP to hold a lock and another attempting the same resource—to reproduce a deadlock error, and discusses how this approach aids debugging and understanding of transaction conflicts.
This tutorial explains how to use Python's sqlite3 module and MySQL connectors to perform essential database operations such as connecting, creating tables, inserting, querying, updating, deleting records, and managing transactions for both SQLite and MySQL.
This article explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks that asynchronously send Kafka messages after transaction commit, illustrated with a practical payment‑system example and complete Java code snippets.
The article explains how Spring AOP can cause object escape leading to concurrency safety problems, describes the impact of asynchronous threads and caching, and provides practical guidance on ordering AOP advices such as distributed lock, @Retryable, and dynamic datasource to avoid business anomalies.
This article explains how to reproduce a MySQL InnoDB lock‑wait scenario, use system tables such as information_schema.processlist, innodb_trx, sys.innodb_lock_waits and performance_schema to locate the blocking transaction, and finally resolve the issue by killing the offending session, while also providing quick‑check queries and parameter tuning advice.
This article describes a generic asynchronous processing SDK built on Spring that leverages transaction events, AOP, and a combination of Kafka, XXL‑Job, and MySQL to provide non‑intrusive, reliable, and idempotent async execution with configurable strategies, security levels, and monitoring dashboards.
This article explains the typical reasons why Spring @Transactional annotations may fail—including AOP proxy limitations, method visibility, self‑invocation, exception handling, propagation settings, async execution, multiple data sources, and database constraints—and provides practical solutions to ensure reliable transaction behavior.
MySQL employs a two‑phase commit to synchronize InnoDB’s redo log with the server’s binlog, ensuring atomicity during transaction commits and preventing data inconsistencies during crash recovery or replication, while also introducing lock contention, extra I/O, and potential blocking.
This article explains how to decouple business logic using Spring Boot transaction event listeners, demonstrates both manual TransactionSynchronization and @TransactionalEventListener implementations with full code examples, and shows a practical user‑registration scenario that avoids common pitfalls.
This article explains how Spring's declarative transaction management works, why the @Transactional annotation can unexpectedly become ineffective, and presents twelve typical scenarios—such as internal method calls, non‑public methods, final/static modifiers, proxy issues, and incorrect propagation settings—along with practical solutions to ensure reliable transaction handling.
This article provides a comprehensive index of a MySQL internals series covering the transaction, lock, and undo modules, detailing each sub‑topic such as transaction initialization, two‑phase commit, various lock types, deadlock handling, and undo log management across numerous linked articles.
This article objectively compares NewSQL distributed databases with traditional middleware‑based sharding solutions, examining their architectures, distributed transaction support, high availability, scaling, SQL capabilities, and maturity to help readers decide which approach best fits their workload and operational constraints.
The article explains how InnoDB handles transaction commit by modifying Insert and Update Undo segment states, generating a transaction commit number, adding rollback segments to the purge queue, and finally cleaning or caching Undo segments based on their usage and state.