[toc]
本节描述了Spring中事务传播的一些语义。 请注意,本节不适合作为事务传播的介绍; 相反,它详细介绍了Spring中有关事务传播的一些语义。
在Spring管理的事务中,要注意物理和逻辑事务之间的区别,以及传播设置如何应用于这种差异。
## Required
![required](https://box.kancloud.cn/32e6ee200b1e99992bf0cfd8479b407b_800x341.png)
### PROPAGATION_REQUIRED
`PROPAGATION_REQUIRED`强制执行物理事务:如果当前还没有事务存在,则在本地范围内执行,或者参与为更大范围定义的现有“外部”事务。 这是同一线程内公共调用堆栈排列的一个很好的默认值,例如 服务外观委托给几个存储库方法,其中所有底层资源都必须参与服务级事务。
默认情况下,参与事务将使用外部作用域事务的特征,静默忽略本地隔离级别,超时值或只读标志(如果有)。 如果您希望隔离级别声明在参与具有不同隔离级别的现有事务时被拒绝,请考虑在事务管理器上将“validateExistingTransactions”标志切换为“true”。 这种非宽松模式也将拒绝只读不匹配,即内部读写事务试图参与只读外部事务的。
当传播设置为`PROPAGATION_REQUIRED`时,将为应用该设置的每个方法创建逻辑事务范围。 每个这样的逻辑事务范围可以单独确定仅回滚状态,外部事务范围在逻辑上独立于内部事务范围。 当然,在标准`PROPAGATION_REQUIRED`行为的情况下,所有这些范围将映射到同一物理事务。 因此,内部事务范围中的仅回滚标记集确实会影响外部事务实际提交的机会(正如您所期望的那样)。
然而,如果内部事务标记为回滚,而外部事务仍然提交,则外部会收到内部抛出的异常`UnexpectedRollbackException`,并内部事务已回滚.
### RequiresNew
![](https://box.kancloud.cn/5b456aa88851b44d59cfdb54cea24cdb_800x276.png)
与`PROPAGATION_REQUIRED`相反,`PROPAGATION_REQUIRES_NEW`始终对每个受影响的事务范围使用独立的物理事务,从不参与外部范围的现有事务。 在这样的安排中,底层资源事务是不同的,因此可以独立提交或回滚,外部事务不受内部事务的回滚状态影响,并且内部事务的锁在完成后立即释放。 这样一个独立的内部事务也可以声明它自己的隔离级别,超时和只读设置,从不继承外部事务的特性。
### Nested
`PROPAGATION_NESTED`使用具有多个保存点的单个物理事务,它可以回滚到该事务。 这种部分回滚允许内部事务作用域触发其作用域的回滚,外部事务能够继续物理事务,尽管已经回滚了一些操作。 此设置通常映射到JDBC保存点,因此仅适用于JDBC资源事务。 请参阅Spring的`DataSourceTransactionManager`。
- 正确打开本书的姿势
- 第一部分 Core
- 1. Ioc container
- 1.1. Introduction to the Spring IoC container and beans
- 1.2. Container overview
- 1.2.1. Configuration metadata
- 1.2.2. Instantiating a container
- 1.2.3. Using the container
- 1.3. Bean overview
- 1.3.1. Naming beans
- 1.3.2. Instantiating beans
- 1.4. Dependencies
- 1.4.1. Dependency Injection
- 1.4.2. Dependencies and configuration in detail
- 1.4.3. Using depends-on
- 1.4.4. Lazy-initialized beans
- 1.4.5. Autowiring collaborators
- 1.4.6. Method injection
- 1.5 Bean Scopes
- 1.6. Customizing the nature of a bean TODO
- 1.7. Bean definition inheritance TODO
- 1.8. Container Extension Points TODO
- 1.9. Annotation-based container configuration
- 1.9.1. @Required
- 1.9.2. @Autowired
- 1.9.3. Fine-tuning annotation-based autowiring with @Primary
- 1.9.4. Fine-tuning annotation-based autowiring with qualifiers TODO
- 1.9.5. Using generics as autowiring qualifiers TODO
- 1.9.6. CustomAutowireConfigurer TODO
- 1.10. Classpath scanning and managed components
- 1.10.1. @Component and further stereotype annotations
- 1.11. Using JSR 330 Standard Annotations TODO
- 1.12. Java-based container configuration
- 1.12.1. Basic concepts: @Bean and @Configuration
- 1.12.2. Instantiating the Spring container using AnnotationConfigApplicationContext
- 2. Resources
- 2.1. Introduction
- 2.2. The Resource interface
- 2.3. Built-in Resource implementations
- 2.3.1. UrlResource
- 2.3.2. ClassPathResource
- 2.3.3. FileSystemResource
- 2.3.4. ServletContextResource
- 2.3.5. InputStreamResource
- 2.3.6. ByteArrayResource
- 2.4. The ResourceLoader
- 2.5. The ResourceLoaderAware interface
- 2.6. Resources as dependencies
- 2.7. Application contexts and Resource paths
- 2.7.1. Constructing application contexts
- 2.7.2. Wildcards in application context constructor resource paths
- 2.7.3. FileSystemResource caveats
- 3. Validation, Data Binding, and Type Conversion
- 4. Spring Expression Language (SpEL)
- 5. Aspect Oriented Programming with Spring
- 5.1. Introduction
- 5.1.1. AOP concepts
- 5.1.2. Spring AOP capabilities and goals
- 5.1.3. AOP Proxies
- 5.2. @AspectJ support
- 5.2.1. Enabling @AspectJ Support
- 5.2.2. Declaring an aspect
- 5.2.3. Declaring a pointcut
- 5.2.4. Declaring advice
- 5.2.5. Introductions TODO
- 5.2.6. Aspect instantiation models TODO
- 5.2.7. Example
- 5.3. Schema-based AOP support TODO
- 5.4. Choosing which AOP declaration style to use TODO
- 5.5. Mixing aspect types TODO
- 5.6. Proxying mechanisms
- 5.6.1. Understanding AOP proxies
- 5.7. Programmatic creation of @AspectJ Proxies
- 5.8. Using AspectJ with Spring applications
- 5.8.1. Using AspectJ to dependency inject domain objects with Spring
- 5.8.2. Other Spring aspects for AspectJ
- 第二部分 Testing
- 第三部分 Data Access
- 1. Transaction Management
- 1.1. Introduction to Spring Framework transaction management
- 1.2 Advantages of the Spring Framework’s transaction support model
- 1.2.1. Global transactions
- 1.2.2. Local transactions
- 1.2.3. Spring Framework’s consistent programming model
- 1.3. Understanding the Spring Framework transaction abstraction
- 1.4. Synchronizing resources with transactions
- 1.4.1. High-level synchronization approach
- 1.4.2. Low-level synchronization approach
- 1.4.3. TransactionAwareDataSourceProxy
- 1.5. Declarative transaction management
- 1.5.1. Understanding the Spring Framework’s declarative transaction implementation
- 1.5.2. Example of declarative transaction implementation
- 1.5.3. Rolling back a declarative transaction
- 1.5.4. Configuring different transactional semantics for different beans
- 1.5.5. tx:advice元素的 settings
- 1.5.6. Using @Transactional
- 1.5.7. Transaction propagation
- 1.5.8. Advising transactional operations
- 1.5.9. Using @Transactional with AspectJ TODO
- 第四部分 web servlet
- 第五部分 Web Reactive
- 第六部分 Integration
- 第七部分 Languages