BestHub
Sign in
Tagged articles
400 articles
Page 3 of 4
Java Backend Technology
Java Backend Technology
Oct 10, 2022 · Backend Development

8 Hidden Spring Transaction Pitfalls That Can Break Your Java Apps

This article reveals ten common Spring transaction pitfalls—including private methods, final modifiers, self‑invocation, missing @Service, wrong propagation, non‑transactional databases, swallowed or wrong exceptions, multi‑threaded calls, and nested transaction rollbacks—that can silently disable transaction management in Java backend projects.

AOPJavaPitfalls
0 likes · 9 min read
8 Hidden Spring Transaction Pitfalls That Can Break Your Java Apps
DaTaobao Tech
DaTaobao Tech
Sep 16, 2022 · Databases

Investigation of Hanging Transactions and Lock Wait Timeout in MySQL InnoDB

The article investigates MySQL InnoDB lock‑wait timeouts caused by hanging transactions that lack proper commit or rollback, explains ACID and lock mechanisms, shows how stale ThreadLocal bindings let pooled threads reuse unfinished transactions, and recommends using @Transactional with robust try‑catch handling to prevent such deadlocks.

DebuggingHangingTransactionInnoDB
0 likes · 14 min read
Investigation of Hanging Transactions and Lock Wait Timeout in MySQL InnoDB
Su San Talks Tech
Su San Talks Tech
Aug 25, 2022 · Backend Development

Mastering Spring Transactions: From Basics to Advanced Propagation Types

This article explains the origins and purpose of Spring transactions, demonstrates how to quickly set them up with code examples, explores key features and common pitfalls, and provides an in‑depth comparison of the REQUIRED, REQUIRES_NEW, and NESTED propagation types for robust backend development.

AOPJavaMyBatis
0 likes · 21 min read
Mastering Spring Transactions: From Basics to Advanced Propagation Types
Su San Talks Tech
Su San Talks Tech
Aug 14, 2022 · Backend Development

9 Hidden Pitfalls When Converting Synchronous Code to Multithreaded Execution

Switching from single‑threaded synchronous calls to multithreaded asynchronous execution can boost performance, but it also introduces nine common problems—including missing return values, data loss, ordering issues, thread‑safety bugs, ThreadLocal anomalies, OOM, high CPU usage, transaction failures, and service crashes—that developers must understand and mitigate.

ConcurrencyJavaThreadLocal
0 likes · 19 min read
9 Hidden Pitfalls When Converting Synchronous Code to Multithreaded Execution
Xianyu Technology
Xianyu Technology
Jul 27, 2022 · Operations

Automated Regression Testing for Xianyu Transaction Chain

The Xianyu transaction chain now employs automated regression testing that records and replays interface traffic, verifies scenarios, and integrates a strong checkpoint in the release pipeline, cutting manual validation from thirty minutes to one minute, enhancing quality assurance, release safety, and paving the way for broader test coverage.

Automationci/cdquality assurance
0 likes · 7 min read
Automated Regression Testing for Xianyu Transaction Chain
DaTaobao Tech
DaTaobao Tech
Jul 22, 2022 · Databases

Using GDB with TinkerPop: Transaction Management and DAO Implementation

The article explains how to integrate Alibaba's Graph Database (GDB) with TinkerPop, compares it to other graph databases, details challenges such as string‑based script construction and missing transaction APIs, and demonstrates two DAO implementations and explicit transaction handling using GdbClient.

Graph DatabaseJavaTinkerPop
0 likes · 14 min read
Using GDB with TinkerPop: Transaction Management and DAO Implementation
dbaplus Community
dbaplus Community
Jul 20, 2022 · Databases

From Middleware to Distributed Database: The Evolution of PolarDB‑X

PolarDB‑X evolved from Alibaba’s internal sharding middleware TDDL to the DRDS cloud service and finally to a fully distributed MySQL‑compatible database, introducing a full SQL optimizer, MPP engine, global secondary indexes, strong‑consistent distributed transactions via TSO + 2PC, and full binlog compatibility.

MySQL compatibilityPolarDB-Xglobal index
0 likes · 26 min read
From Middleware to Distributed Database: The Evolution of PolarDB‑X
Architects' Tech Alliance
Architects' Tech Alliance
Jul 17, 2022 · Databases

Comprehensive Overview of Database Evolution, Architecture, and Core Technologies

This article provides a detailed survey of database fundamentals, historical evolution from early relational systems to modern distributed and cloud‑native solutions, explains various architectural components and core technologies such as query processing, indexing, transaction management, and discusses business‑driven classifications, distributed designs, SMP versus MPP, and resource‑access models.

DatabaseHTAPNoSQL
0 likes · 34 min read
Comprehensive Overview of Database Evolution, Architecture, and Core Technologies
Liangxu Linux
Liangxu Linux
Jul 3, 2022 · Databases

What’s the Optimal Batch Size for MySQL Inserts? A Deep Performance Test

This article investigates how many rows should be inserted per batch in MySQL by measuring the impact of packet size limits, buffer pool usage, insert buffers, transaction handling and index structures, and it provides practical recommendations based on tests with millions of rows.

Batch InsertMySQLbuffer pool
0 likes · 16 min read
What’s the Optimal Batch Size for MySQL Inserts? A Deep Performance Test
dbaplus Community
dbaplus Community
Jun 23, 2022 · Databases

How to Detect and Resolve Blocked DDL Operations in MySQL

Learn how to identify when a MySQL DDL statement is blocked, use SHOW PROCESSLIST and the sys.schema_table_lock_waits view to pinpoint the blocking session, and apply targeted KILL commands or transaction queries to safely unblock operations in both MySQL 5.7 and 8.0.

DDLMySQLkill
0 likes · 9 min read
How to Detect and Resolve Blocked DDL Operations in MySQL
Programmer DD
Programmer DD
Jun 22, 2022 · Databases

Why Did My Spring @Transactional Rollback Fail? Uncovering a MySQL Connector Bug

An in‑depth investigation reveals that Spring’s @Transactional rollback can silently fail due to a bug in mysql‑connector‑java 8.0.28 when useLocalSessionState=true, causing auto‑commit to stay enabled; the article explains the root cause, debugging steps, and how upgrading to 8.0.29 resolves the issue.

Connector/JMySQLautocommit
0 likes · 14 min read
Why Did My Spring @Transactional Rollback Fail? Uncovering a MySQL Connector Bug
Ops Development Stories
Ops Development Stories
Jun 21, 2022 · Databases

Inside MySQL UPDATE: How Undo, Redo, and Binlog Work

This article explains in detail what happens inside MySQL when an UPDATE statement is executed, covering the execution flow, the roles of undo log, redo log, and binlog, buffer pool mechanics, two‑phase commit, group commit, and practical optimization tips.

MySQLbinlogbuffer pool
0 likes · 40 min read
Inside MySQL UPDATE: How Undo, Redo, and Binlog Work
TAL Education Technology
TAL Education Technology
Jun 9, 2022 · Backend Development

Understanding Idempotency: Definitions, Scenarios, and Implementation Strategies

This article explains the concept of idempotency, outlines common business scenarios such as duplicate orders and payments, describes natural and required idempotent operations, and provides practical techniques—including unique keys, database constraints, and message‑queue handling—to ensure idempotent behavior in backend systems.

Idempotencybackenddistributed-systems
0 likes · 6 min read
Understanding Idempotency: Definitions, Scenarios, and Implementation Strategies
Code Ape Tech Column
Code Ape Tech Column
May 24, 2022 · Databases

Understanding MVCC (Multi-Version Concurrency Control) in MySQL InnoDB

This article provides a comprehensive, step‑by‑step explanation of MySQL InnoDB's MVCC mechanism, covering its fundamentals, the role of Undo Log and Read View, and how it enables repeatable‑read and read‑committed isolation levels while preventing dirty reads and other concurrency anomalies.

ConcurrencyDatabaseMVCC
0 likes · 12 min read
Understanding MVCC (Multi-Version Concurrency Control) in MySQL InnoDB
Sanyou's Java Diary
Sanyou's Java Diary
May 19, 2022 · Backend Development

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

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

AOPIoCMVC
0 likes · 54 min read
Mastering Spring: Core Concepts, Modules, Annotations & Advanced Features
Java Backend Technology
Java Backend Technology
May 14, 2022 · Backend Development

Boosting Massive Data Updates in Spring Boot: Manual Transactions, Multithreading, and UNION Batch Tricks

An in‑depth guide shows how to accelerate updating tens of thousands of MySQL rows in a Spring Boot‑MyBatis project by switching from automatic per‑record commits to manual transactions, applying multithreaded execution with CountDownLatch coordination, and using UNION‑based batch updates when native batch support is unavailable.

MyBatisSpring Boottransaction
0 likes · 14 min read
Boosting Massive Data Updates in Spring Boot: Manual Transactions, Multithreading, and UNION Batch Tricks
Top Architect
Top Architect
May 6, 2022 · Databases

Optimizing MySQL Batch Insert Performance: Determining the Ideal Batch Size

This article analyzes MySQL batch insertion by examining field size, max_allowed_packet limits, transaction overhead, buffer pool usage, and empirical tests with varying batch sizes, ultimately recommending a batch size around half of the max_allowed_packet for optimal throughput.

Batch InsertMySQLbuffer pool
0 likes · 14 min read
Optimizing MySQL Batch Insert Performance: Determining the Ideal Batch Size
Code Ape Tech Column
Code Ape Tech Column
May 5, 2022 · Backend Development

Optimizing Bulk Database Updates with Manual Transactions and Multithreading in Spring/MyBatis

This article demonstrates how to dramatically speed up updating tens of thousands of records in a Spring‑MyBatis application by switching from automatic per‑operation commits to manual transaction control, applying multithreaded processing, tuning the Hikari connection pool, and using SQL UNION‑based batch updates.

DatabaseMyBatismultithreading
0 likes · 13 min read
Optimizing Bulk Database Updates with Manual Transactions and Multithreading in Spring/MyBatis
政采云技术
政采云技术
Apr 26, 2022 · Databases

Analysis of Lock Wait Timeout and Gap Locks in InnoDB

This article analyzes a MySQL InnoDB lock wait timeout error, explains how gap locks cause blocked inserts and phantom reads under repeatable‑read isolation, and offers optimization strategies such as primary‑key deletions, while concluding with a recruitment invitation for the Zero technology team.

DatabaseGap LockInnoDB
0 likes · 7 min read
Analysis of Lock Wait Timeout and Gap Locks in InnoDB
Top Architect
Top Architect
Apr 25, 2022 · Backend Development

Designing Payment Account Systems for E‑commerce Platforms

This article explains the fundamental concepts, design requirements, and modeling approaches for payment account systems in e‑commerce, covering the distinction between payment and login accounts, transaction needs, accounting structures, entity and account models, and the detailed transaction model.

account modelingarchitecturebackend
0 likes · 14 min read
Designing Payment Account Systems for E‑commerce Platforms
dbaplus Community
dbaplus Community
Apr 20, 2022 · Backend Development

How to Build a Robust E‑Commerce Backend: Idempotency, Snapshots, and Sharding

This article explores common e‑commerce backend challenges such as duplicate orders, order snapshots, cart storage, inventory oversell, logistics updates, account balance consistency, read‑write splitting, hot‑cold data separation, and sharding, and provides concrete design patterns and SQL examples to solve them.

IdempotencyShardingbackend
0 likes · 17 min read
How to Build a Robust E‑Commerce Backend: Idempotency, Snapshots, and Sharding
Zhuanzhuan Tech
Zhuanzhuan Tech
Apr 20, 2022 · Backend Development

Transaction Middleware: FSM and Concurrency Model Practices and Exploration

This article examines the challenges faced by a transaction middleware platform, introduces a finite‑state‑machine (FSM) solution for order state flows, and compares traditional serial processing with future‑based staged concurrency and event‑driven concurrency models, highlighting their benefits and trade‑offs.

ConcurrencyEvent-drivenFinite State Machine
0 likes · 11 min read
Transaction Middleware: FSM and Concurrency Model Practices and Exploration
Maoyan Technology Team
Maoyan Technology Team
Apr 13, 2022 · Big Data

Inside Maoyan’s Near‑Real‑Time Transaction Data Center

The article details Maoyan’s transaction data center, explaining its background, the need for a unified real‑time order model, the benefits of reduced coupling and improved data accuracy, and describes the system’s architecture, components, data collection, processing, task scheduling, monitoring, and future plans.

Data Centerbig-datamonitoring
0 likes · 29 min read
Inside Maoyan’s Near‑Real‑Time Transaction Data Center
IT Architects Alliance
IT Architects Alliance
Apr 10, 2022 · Backend Development

Designing Payment Account Systems for E‑Commerce Platforms

This article explains the fundamental concepts, design requirements, and modeling techniques for payment accounts and transaction flows in e‑commerce systems, covering distinctions between payment and login accounts, internal vs. external accounts, and detailed entity, account, and transaction models.

Financeaccount modelingbackend
0 likes · 13 min read
Designing Payment Account Systems for E‑Commerce Platforms
Java Backend Technology
Java Backend Technology
Apr 7, 2022 · Backend Development

Does @Transactional Commit Before Unlock? Deep Dive into Spring Transaction Timing

This article explores the precise moment a Spring @Transactional transaction is committed relative to a surrounding lock release, revealing that commits occur after the method finishes, and demonstrates how to verify this through source code inspection, debugging techniques, and proper lock‑usage to prevent overselling.

DebuggingLockMySQL
0 likes · 21 min read
Does @Transactional Commit Before Unlock? Deep Dive into Spring Transaction Timing
Top Architect
Top Architect
Mar 28, 2022 · Databases

Key Aspects of Distributed Storage Systems: Replication, Engines, Transactions, Analytics, Multi‑Core, Computation, and Compilation

This article provides a comprehensive overview of distributed storage, covering seven core aspects such as replication, storage engines, transaction processing, analytical query execution, multi‑core scalability, computation models, and compilation techniques, while also highlighting practical challenges and design considerations for modern database systems.

AnalyticsStorage Enginecompilation
0 likes · 13 min read
Key Aspects of Distributed Storage Systems: Replication, Engines, Transactions, Analytics, Multi‑Core, Computation, and Compilation
Architect
Architect
Mar 21, 2022 · Databases

Comprehensive Redis Guide: Introduction, Installation, Data Types, Persistence, Transactions, and Caching Strategies

This article provides a detailed overview of Redis, covering its core concepts, high‑performance features, common use cases, installation steps, memory‑management policies, supported data structures, persistence mechanisms, transaction model, and best practices for cache consistency and failure handling.

CachingData TypesIn-Memory Database
0 likes · 32 min read
Comprehensive Redis Guide: Introduction, Installation, Data Types, Persistence, Transactions, and Caching Strategies
Sohu Tech Products
Sohu Tech Products
Mar 9, 2022 · Backend Development

Understanding the Spring Transaction Rollback Bug and Its Resolution

This article analyzes a Spring transaction rollback issue caused by the use of pattern‑based exception matching, explains why certain custom exceptions trigger unexpected rollbacks, traces the problem through source code and GitHub issues, and describes how the Spring team fixed it with type‑safe rollback rules and documentation updates.

DocumentationJavabackend
0 likes · 22 min read
Understanding the Spring Transaction Rollback Bug and Its Resolution
Sanyou's Java Diary
Sanyou's Java Diary
Mar 5, 2022 · Databases

Unlock MySQL’s Secrets: Redo Log, Undo Log, Binlog & Transaction Mechanics

This article delves into MySQL’s internal logging mechanisms—redo log, undo log, and binlog—explaining their structures, purposes, and interactions, and then explores transaction concepts such as dirty reads/writes, non‑repeatable reads, phantom reads, isolation levels, and the MVCC implementation that ensures data consistency.

Isolation LevelsMVCCMySQL
0 likes · 11 min read
Unlock MySQL’s Secrets: Redo Log, Undo Log, Binlog & Transaction Mechanics
Architecture Digest
Architecture Digest
Mar 2, 2022 · Backend Development

Overview and Core Architecture of a Payment System

This article presents a comprehensive overview of payment system architecture, detailing the transaction and payment cores, their interactions, service governance, data consistency, asynchronous processing, performance testing, and practical production practices for building robust backend payment platforms.

paymentservice governancetransaction
0 likes · 5 min read
Overview and Core Architecture of a Payment System
ByteDance Data Platform
ByteDance Data Platform
Feb 25, 2022 · Big Data

Optimizing SparkSQL: ByteDance EMR’s Data Lake Integration and Multi‑Tenant Server

ByteDance’s EMR team details how they integrated data‑lake engines such as Hudi and Iceberg into SparkSQL, streamlined jar management, built a custom Spark SQL Server with Hive compatibility, multi‑tenant support, engine pre‑warming, and transaction capabilities, dramatically improving performance and resource efficiency for enterprise workloads.

EMRHudiIceberg
0 likes · 11 min read
Optimizing SparkSQL: ByteDance EMR’s Data Lake Integration and Multi‑Tenant Server
Architects Research Society
Architects Research Society
Jan 8, 2022 · Databases

Understanding Database Isolation Levels and Dirty Reads

This article explains database isolation levels, including read committed, repeatable read, serializable, and snapshot isolation, discusses dirty reads, phantom reads, and how various systems such as SQL Server, PostgreSQL, MySQL, Oracle, MongoDB, and others implement or differ in these isolation semantics.

DatabaseIsolation LevelSQL
0 likes · 19 min read
Understanding Database Isolation Levels and Dirty Reads
Su San Talks Tech
Su San Talks Tech
Dec 15, 2021 · Backend Development

Top 18 Spring Interview Questions and Answers You Must Know

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

AOPInterviewIoC
0 likes · 17 min read
Top 18 Spring Interview Questions and Answers You Must Know
Senior Brother's Insights
Senior Brother's Insights
Nov 28, 2021 · Backend Development

Why @Transactional Fails with parallelStream and How to Fix It

An Excel import that partially succeeds reveals a hidden bug where Spring’s @Transactional annotation doesn’t roll back when using Java 8’s parallelStream, and the article explains the underlying thread‑local transaction mechanics, demonstrates the issue with code, and offers practical solutions and best‑practice guidelines.

ConcurrencyJavaParallelStream
0 likes · 8 min read
Why @Transactional Fails with parallelStream and How to Fix It
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 22, 2021 · Big Data

Achieving Exactly-Once Writes from Flink to ClickHouse: Architecture and Performance

This article explains how Flink and ClickHouse can be combined to build a real-time data warehouse with end-to-end Exactly-Once guarantees, detailing the underlying write mechanisms, transaction state machine, connector implementation, and performance test results, while also outlining future enhancements for distributed transactions.

ClickHouseFlinkperformance testing
0 likes · 15 min read
Achieving Exactly-Once Writes from Flink to ClickHouse: Architecture and Performance
IT Architects Alliance
IT Architects Alliance
Nov 17, 2021 · Backend Development

Design and Implementation of a Payment Center Architecture

This article outlines the objectives, call flow, architectural design, and potential challenges of a payment center system that unifies transaction, payment, and finance services, detailing its four main modules, data handling, and integration with third‑party payment channels.

System Designarchitecturebackend
0 likes · 8 min read
Design and Implementation of a Payment Center Architecture
ITPUB
ITPUB
Nov 5, 2021 · Databases

Why Distributed Databases Face Consistency Challenges and How to Address Them

The article explains how distributed database systems appear as a single logical database but operate over a network of nodes, detailing failures, stale reads, consistency models, architecture anomalies, sharding, replication, and various read/write scenarios that illustrate the complexity of achieving strong consistency.

CAP theoremConsistencySharding
0 likes · 16 min read
Why Distributed Databases Face Consistency Challenges and How to Address Them
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 30, 2021 · Backend Development

Spring Transaction Management: Concepts, Configuration, and Best Practices

This article explains the fundamentals of database transactions, the ACID properties, and how Spring provides both declarative and programmatic transaction support through three core interfaces, detailed configuration examples in XML and Java, and a deep dive into transaction attributes such as isolation, propagation, rollback rules, read‑only mode, and timeout.

DeclarativeJavaProgrammatic
0 likes · 31 min read
Spring Transaction Management: Concepts, Configuration, and Best Practices
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
Code Ape Tech Column
Code Ape Tech Column
Oct 9, 2021 · Backend Development

Common Scenarios Where Spring Transactions Fail and How to Fix Them

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

AOPJavabackend
0 likes · 19 min read
Common Scenarios Where Spring Transactions Fail and How to Fix Them
Top Architect
Top Architect
Oct 3, 2021 · Databases

Understanding the INSERT Locking Process in MySQL by Analyzing the Source Code

This article examines MySQL's INSERT locking behavior, explains why phantom reads do not occur under REPEATABLE READ isolation, and walks through compiling the MySQL source, debugging lock acquisition, and the role of insert‑intention and gap locks using detailed code examples and execution traces.

Gap LockInnoDBInsert
0 likes · 18 min read
Understanding the INSERT Locking Process in MySQL by Analyzing the Source Code
Su San Talks Tech
Su San Talks Tech
Sep 4, 2021 · Backend Development

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

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

AOPbackendspring
0 likes · 19 min read
Why Spring Transactions Fail: 7 Common Pitfalls and How to Fix Them
Java Architect Essentials
Java Architect Essentials
Aug 26, 2021 · Backend Development

Design and Call Flow of a Payment Center Architecture

This article outlines the objectives, detailed call process, architectural modules, and potential challenges of a payment center system that unifies order, payment, and finance services while ensuring security, scalability, and data support for downstream applications.

architecturegatewaypayment
0 likes · 7 min read
Design and Call Flow of a Payment Center Architecture
IT Architects Alliance
IT Architects Alliance
Aug 15, 2021 · Databases

Understanding Local Transactions, ACID, CAP/BASE Theories, and Distributed Transaction Solutions (Seata, 2PC, TCC, Saga)

This article explains the fundamentals of local transactions and ACID properties, introduces CAP and BASE theories, discusses compensation jobs and transaction messages, and reviews distributed transaction models such as two‑phase commit, three‑phase commit, XA, TCC, Saga, and the Seata framework.

ACIDCAP theoremDatabase
0 likes · 15 min read
Understanding Local Transactions, ACID, CAP/BASE Theories, and Distributed Transaction Solutions (Seata, 2PC, TCC, Saga)
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 11, 2021 · Databases

How MySQL InnoDB Guarantees ACID: Locks, MVCC, and Log Mechanics

This article explains how MySQL's InnoDB engine implements ACID properties by detailing transaction atomicity, consistency, isolation levels, lock granularity, MVCC version chains, undo/redo logs, buffer pool behavior, and the interplay between redo log and binlog to ensure durability and data integrity.

ACIDInnoDBLock
0 likes · 16 min read
How MySQL InnoDB Guarantees ACID: Locks, MVCC, and Log Mechanics
IT Architects Alliance
IT Architects Alliance
Aug 8, 2021 · Backend Development

Design and Call Flow of a Payment Center Architecture

This article outlines the objectives, detailed invocation process, architectural design, and anticipated challenges of a payment center system, describing its core modules, data handling, and integration with third‑party payment channels to achieve unified, secure, and scalable transaction services.

Payment GatewaySystem Designarchitecture
0 likes · 9 min read
Design and Call Flow of a Payment Center Architecture
Architecture Digest
Architecture Digest
Jul 27, 2021 · Backend Development

Design and Call Flow of a Payment Center Architecture

The article outlines the objectives, detailed call flow, architectural components, and potential issues of a payment center system, describing how unified order, payment, and financial services are built, integrated with third‑party channels, and managed through modules such as backend, messaging, transaction core, and channel gateway.

System Designintegrationpayment
0 likes · 9 min read
Design and Call Flow of a Payment Center Architecture
Programmer DD
Programmer DD
Jul 11, 2021 · Databases

Inside MyBatis Transactions: The Real Story of JDBC Commit, Rollback & Close

This article demystifies MyBatis transaction handling by explaining the true JDBC methods—setAutoCommit, commit, rollback—and clarifying common misconceptions about create, begin, close, and suspend, while exploring MyBatis’s Transaction, TransactionFactory, and practical code examples that illustrate how commits, rollbacks, and connection closing behave in various scenarios.

DatabaseJDBCMyBatis
0 likes · 10 min read
Inside MyBatis Transactions: The Real Story of JDBC Commit, Rollback & Close
Wukong Talks Architecture
Wukong Talks Architecture
Jun 17, 2021 · Databases

Ensuring Data Consistency Without Native Transactions in MongoDB

The article explains how lack of native transactions in MongoDB 3.0 can cause data inconsistency during order processing, compares it with SQL transaction mechanisms, and proposes optimization and compensation strategies such as retry queues, asynchronous tasks, and refund handling to ensure eventual consistency.

Backend DevelopmentCompensationData Consistency
0 likes · 10 min read
Ensuring Data Consistency Without Native Transactions in MongoDB
IT Xianyu
IT Xianyu
Jun 16, 2021 · Databases

Understanding Database Connection Pools vs. ThreadLocal in Java

This article explains the fundamental differences between database connection pools and ThreadLocal‑cached connections in Java, illustrating how connection pools improve performance while ThreadLocal enables sharing a single connection across methods within the same thread for consistent transaction control, and discusses practical usage patterns.

Backend DevelopmentConnection PoolDatabase
0 likes · 7 min read
Understanding Database Connection Pools vs. ThreadLocal in Java
Laravel Tech Community
Laravel Tech Community
Jun 15, 2021 · Backend Development

PDO::inTransaction – Checking If Inside a Transaction

The PDO::inTransaction method returns a boolean indicating whether the current database connection is actively inside a transaction, works only with drivers that support transactions, takes no parameters, and returns TRUE on success and FALSE on failure.

DatabasePDOPHP
0 likes · 1 min read
PDO::inTransaction – Checking If Inside a Transaction
Laravel Tech Community
Laravel Tech Community
Jun 14, 2021 · Backend Development

PDO::rollBack – Rolling Back a Transaction in PHP

The article explains how the PHP PDO::rollBack() method aborts the current transaction, restores autocommit mode when needed, outlines its parameter‑less signature, return values, and provides a complete code example demonstrating transaction handling and rollback behavior.

DatabasePDOPHP
0 likes · 2 min read
PDO::rollBack – Rolling Back a Transaction in PHP
Laravel Tech Community
Laravel Tech Community
Jun 9, 2021 · Backend Development

PDO::inTransaction – Check If Inside a Transaction

PDO::inTransaction is a PHP PDO method that returns a boolean indicating whether the current database connection is actively within a transaction, applicable only to drivers that support transactions, and it takes no parameters.

DatabasePDOPHP
0 likes · 1 min read
PDO::inTransaction – Check If Inside a Transaction
Aikesheng Open Source Community
Aikesheng Open Source Community
Jun 8, 2021 · Databases

Understanding Table Locks in MySQL When Using INSERT INTO SELECT and the Impact of Isolation Levels

The article explains why an INSERT INTO SELECT statement can lock an entire InnoDB table in MySQL, demonstrates the lock behavior with transaction examples, and offers two solutions—adding an index on the filtered column and adjusting the transaction isolation level—to avoid table‑wide blocking.

INSERT SELECTInnoDBMySQL
0 likes · 13 min read
Understanding Table Locks in MySQL When Using INSERT INTO SELECT and the Impact of Isolation Levels
Code Ape Tech Column
Code Ape Tech Column
Jun 8, 2021 · Backend Development

Why Spring @Transactional on a Called Method Doesn’t Rollback and How to Fix It

The article analyzes a Spring Boot transaction issue where a @Transactional method called from another non‑transactional method fails to roll back, explains the underlying propagation and proxy mechanisms, and presents two practical solutions—including using the bean’s proxy via AopContext with exposeProxy enabled—to ensure proper rollback.

AOPSpringBootpropagation
0 likes · 8 min read
Why Spring @Transactional on a Called Method Doesn’t Rollback and How to Fix It
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 2, 2021 · Databases

How PolarDB Guarantees Transaction Atomicity: From WAL to Visibility

This article explains how PolarDB ensures transaction atomicity by analyzing ACID principles, detailing the shortcomings of simple Direct‑IO and Buffer‑IO, introducing write‑ahead logging, full‑page backup, checkpointing, visibility mechanisms, and distinguishing durability and atomicity points to achieve reliable crash recovery and consistent data visibility.

PolardbWALatomicity
0 likes · 30 min read
How PolarDB Guarantees Transaction Atomicity: From WAL to Visibility
Top Architect
Top Architect
May 26, 2021 · Databases

How MySQL InnoDB Implements ACID: Locks, MVCC, and Logging

This article explains how MySQL InnoDB guarantees the ACID properties—Atomicity, Consistency, Isolation, and Durability—through its lock mechanisms, multi‑version concurrency control, undo/redo logs, buffer pool management, and the interaction between binlog and redo log.

ACIDInnoDBLock
0 likes · 12 min read
How MySQL InnoDB Implements ACID: Locks, MVCC, and Logging
Top Architect
Top Architect
May 17, 2021 · Backend Development

Common Spring Transaction Failure Scenarios and Their Solutions

This article explains typical situations where Spring @Transactional annotations fail—such as non‑public methods, beans not managed by the container, internal method calls, non‑RuntimeException throws, caught exceptions without rethrow, incorrect propagation settings, and unsupported MyISAM storage—and provides concrete code examples and fixes to ensure proper transaction behavior.

AOPException HandlingJava
0 likes · 10 min read
Common Spring Transaction Failure Scenarios and Their Solutions
Top Architect
Top Architect
May 7, 2021 · Backend Development

Common Spring Transaction Failure Scenarios and Their Solutions

This article explains typical reasons why @Transactional may not work in Spring applications—such as non‑public methods, beans not managed by the container, internal method calls, non‑RuntimeException throws, swallowed exceptions, wrong propagation settings, and unsupported MySQL storage engines—and provides concrete code examples and fixes for each case.

AOPException HandlingJava
0 likes · 11 min read
Common Spring Transaction Failure Scenarios and Their Solutions
Architecture Digest
Architecture Digest
Apr 25, 2021 · Databases

MySQL Lock Types and Deadlock Analysis

This article explains MySQL's lock granularity (table, row, page), the different lock modes such as next‑key, gap and record locks, illustrates common deadlock scenarios with detailed SQL examples, and discusses InnoDB's deadlock prevention strategies and best‑practice solutions.

InnoDBLockMySQL
0 likes · 14 min read
MySQL Lock Types and Deadlock Analysis
Java Interview Crash Guide
Java Interview Crash Guide
Apr 19, 2021 · Fundamentals

What You Need to Know About Distributed Systems: Theory, Consistency, Transactions & Redis

This comprehensive guide covers the core concepts of distributed systems—including CAP theory, consistency models, transaction protocols like 2PC/3PC and TCC, Redis features, persistence options, expiration strategies, memory eviction policies, distributed locking with Redis and Zookeeper, as well as an overview of Kafka's architecture and reliability mechanisms.

ConsistencyDistributed SystemsMessage Queue
0 likes · 34 min read
What You Need to Know About Distributed Systems: Theory, Consistency, Transactions & Redis
Selected Java Interview Questions
Selected Java Interview Questions
Apr 8, 2021 · Backend Development

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

This article outlines common situations that cause Spring @Transactional to fail—such as non‑public methods, internal method calls, unmanaged beans, non‑runtime exceptions, silent catches, incorrect propagation settings, and unsupported MySQL storage engines—and provides practical solutions to ensure transaction reliability.

AOPExceptionJava
0 likes · 10 min read
Common Scenarios Where Spring @Transactional Fails and How to Fix Them
Java Backend Technology
Java Backend Technology
Apr 4, 2021 · Databases

Mastering MySQL Lock Types and Deadlock Prevention

This article explains MySQL's three lock levels, the algorithms behind next‑key, gap, and record locks, illustrates common deadlock scenarios with real SQL examples, and outlines InnoDB's lock‑prevention strategies to help developers avoid and resolve deadlocks.

DatabaseInnoDBLock
0 likes · 15 min read
Mastering MySQL Lock Types and Deadlock Prevention
Java Captain
Java Captain
Apr 3, 2021 · Backend Development

Preventing Order Loss and Duplicate Submissions in Payment Systems

This article explains common causes of order loss and duplicate submissions in payment workflows, and provides practical backend strategies such as intermediate payment states, timeout queries, idempotent handling, retry mechanisms, and Redis‑based deduplication to ensure reliable order processing.

IdempotencyOrder ManagementRetry
0 likes · 4 min read
Preventing Order Loss and Duplicate Submissions in Payment Systems
Top Architect
Top Architect
Mar 22, 2021 · Backend Development

Fundamentals of Spring Transaction Management

This article explains the core principles of Spring transaction management, covering basic JDBC transaction steps, declarative @Transactional usage, AOP proxy mechanisms (JDK dynamic proxy and CGLIB), transaction propagation attributes, isolation levels, nested transactions, and Spring Boot support, with practical code examples.

AOPJavabackend
0 likes · 14 min read
Fundamentals of Spring Transaction Management
360 Tech Engineering
360 Tech Engineering
Mar 12, 2021 · Databases

Comprehensive Overview of the InnoDB Lock System in MySQL

This article provides a detailed explanation of MySQL InnoDB's lock system, covering lock granularity, shared and exclusive locks, intention and auto‑increment locks, various row‑lock types, deadlock scenarios with examples, and the internal representation of locks in the engine.

DatabaseInnoDBLocks
0 likes · 22 min read
Comprehensive Overview of the InnoDB Lock System in MySQL