Tagged articles
propagation
28 articles · Page 1 of 1
This article explains the fundamentals of transaction management in SpringBoot, detailing the ACID properties, the @Transactional annotation’s AOP‑based implementation, core attributes such as propagation, isolation, rollback rules, timeout and read‑only mode, and provides practical code examples for single‑ and multi‑datasource scenarios.
@TransactionalJavaSpring
0 likes · 20 min read

The article examines five scenarios where Spring's @Transactional annotation falls short—stock shortage, MQ messaging, batch processing, logging, and isolation/timeout settings—and demonstrates six practical techniques, including programmatic transactions, parameter tuning, transaction synchronizers, event listeners, manual transaction control, and propagation strategies, all backed by runnable demo code.
JavaSpringSpringBoot
0 likes · 19 min read

Spring Boot simplifies transaction management via PlatformTransactionManager and AOP, offering declarative and programmatic approaches, default rollback on runtime exceptions, customizable rollback rules, propagation behaviors, manual rollback techniques, multithreaded transaction handling, and solutions to common pitfalls such as swallowed exceptions and self-invocation issues.
Declarative TransactionsProgrammatic TransactionsSpring Boot
0 likes · 11 min read

This article explains Spring's transaction management, covering ACID principles, transaction propagation types, isolation levels, timeout settings, read‑only flags, rollback behavior, and the effect of asynchronous execution, supplemented with practical code examples and common pitfalls.
AOPBackendJava
0 likes · 15 min read

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.
@TransactionalAOPExceptionHandling
0 likes · 20 min read

This article analyses thirteen common mistakes that cause Spring's @Transactional annotation to be ineffective or not roll back, covering unnecessary usage, private/final/static methods, self‑invocation, wrong propagation settings, async threads, unmanaged beans, exception handling and more, with concrete code demos and solutions.
@TransactionalAOPException Handling
0 likes · 21 min read

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.
@TransactionalJavaSpring
0 likes · 14 min read

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.
@TransactionalJavaSpring
0 likes · 10 min read

This article explains Spring's seven transaction propagation modes, how they affect nested @Transactional method calls, and the resulting commit or rollback behavior in various scenarios, providing clear examples and diagrams for each propagation type.
BackendJavaSpring
0 likes · 11 min read

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.
@TransactionalJavaSpring
0 likes · 9 min read

This article analyzes frequent scenarios where Spring's @Transactional annotation fails in Spring Boot projects—such as self-invocation, swallowed exceptions, misconfigured rollback rules, non‑public methods, wrong propagation settings, and long‑running transactions—and provides concrete fixes to prevent data inconsistency and performance issues.
@TransactionalCGLIB proxySpring Boot
0 likes · 17 min read

This article explains Spring's transaction propagation options, rollback mechanisms, the limitations of self‑invocation within @Transactional methods, and how to correctly use AOP proxies such as AopContext.currentProxy() and @EnableAspectJAutoProxy to ensure transactional behavior in Java backend applications.
@TransactionalBackendJava
0 likes · 10 min read

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.
JavaSpringSynchronization
0 likes · 13 min read

This article explains how Spring's @EnableTransactionManagement activates transaction support by registering advisors and proxy beans, details the core execution flow of transactional methods, explores various propagation scenarios with code examples, and demonstrates forced rollback and transaction synchronization techniques.
@TransactionalAOPJava
0 likes · 10 min read

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.
AOPJavapropagation
0 likes · 13 min read

This article explains how Spring enables transaction management with @EnableTransactionManagement, details the underlying beans and proxy mechanisms, describes the basic execution flow, explores transaction propagation scenarios, shows how to force rollbacks, and demonstrates using TransactionSynchronization for lifecycle callbacks.
JavaSpringSynchronization
0 likes · 11 min read

This article explains the fundamentals of Spring transactions, demonstrates how to set up a Spring Boot project with MySQL and MyBatis, walks through declarative transaction usage, compares REQUIRED, REQUIRES_NEW, and NESTED propagation behaviors with code examples, and highlights common pitfalls and best‑practice steps.
propagationspring-boot
0 likes · 18 min read

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.
AOPBackendJava
0 likes · 21 min read

This article explains Spring's @Transactional annotation, detailing the various transaction propagation options, the default rollback behavior for unchecked exceptions, common pitfalls such as self‑invocation and non‑public methods, and how to use AOP proxies like AopContext.currentProxy and @EnableAspectJAutoProxy to ensure proper transaction management.
@TransactionalAOPProxy
0 likes · 9 min read

This article explains the fundamentals of database transactions, the ACID properties, Spring's @Transactional support, various propagation behaviors and isolation levels, and provides practical code examples for both declarative and programmatic transaction management in Java backend development.
@TransactionalBackendJava
0 likes · 16 min read

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.
@TransactionalAOPSpring
0 likes · 8 min read

This article explains the core principles of Spring transactions, how they rely on database support, demonstrates JDBC transaction steps, introduces Spring's declarative transaction management, compares JDK and CGLIB proxies, and details propagation attributes, isolation levels, and read‑only transaction usage with practical code examples.
BackendDeclarativeisolation
0 likes · 13 min read

This article explains how to configure Spring transaction isolation levels and propagation behaviors, illustrates the effects of dirty read, non‑repeatable read, and phantom read with examples, and provides practical code solutions for handling rollback of failed sub‑tasks and self‑invocation issues.
BackendIsolation LevelJava
0 likes · 9 min read

This article explains what database transactions are, demonstrates how to use Spring Boot’s @Transactional annotation with unit tests, and dives into transaction isolation levels and propagation behaviors, providing code examples and guidance for effective transaction management in Java backend applications.
Isolation LevelJavaSpring Boot
0 likes · 13 min read

This article explains the core principles of Spring transaction management, including JDBC transaction steps, declarative @Transactional usage, AOP proxy mechanisms, propagation behaviors, isolation levels, nested transactions, and Spring Boot support, while also providing code examples and practical guidance for developers.
AOPSpringisolation
0 likes · 14 min read

This article explains how Spring manages transactions, detailing the three essential elements, annotation configuration, rollback rules, propagation behaviors, isolation levels, and the underlying AOP mechanism that enables declarative transaction handling in Java backend applications.
Backendisolationpropagation
0 likes · 11 min read

This article explains Spring's declarative transaction mechanism, detailing transaction attributes such as propagation behavior, isolation levels, timeout and read‑only flags, and illustrates each propagation type with Java code examples to show how transactions are started, joined, suspended, or nested.
BackendIsolation LevelSpring
0 likes · 11 min read

The article presents a comprehensive analysis of Weibo's social graph, introducing metrics such as propagation power, intimacy, fan and follow similarity, two‑degree relationships, and relationship circles to model and quantify user interactions and information diffusion within the platform.
User RelationshipWeibobig data
0 likes · 13 min read
