Transactional ACID characteristic
Atomicity （Atomicity）： A transaction must be regarded as an indivisible minimum unit of work , All operations in the whole transaction are either committed successfully , Or roll back all failed .
uniformity （consistency）： Databases always transition from one consistent state to another . Before and after the start of the transaction , The integrity constraint of the database is not broken . For example, it violates uniqueness , The transaction must be revoked , Return to initial state .
Isolation （isolation）： The object of each read-write transaction can be separated from the operation object of other transactions , Namely ： Transactions are invisible to other transactions before they are committed , It is usually realized by internal locking .
persistence （durability）： Once the transaction is committed , Its changes will be permanently saved to the database .
spring Properties of transactions in
Communication behavior ：
1.PROPAGATION_REQUIRED
Support current transaction ; If it doesn't exist , Create a new . This is usually the default setting for transaction definitions , Transaction synchronization scope is usually defined .
2.PROPAGATION_SUPPORTS
Support current transaction ; If no transaction exists , Is executed in a non transactional manner .
3.PROPAGATION_REQUIRES_NEW
Create a new transaction , If current transaction exists , Suspend the current transaction .
4.PROPAGATION_MANDATORY
Support current transaction ; If the current transaction does not exist , Throw exception .
5.PROPAGATION_NEVER
The current transaction is not supported ; If the current transaction exists , Throw exception .
6：PROPAGATION_NOT_SUPPORTED
The current transaction is not supported , There is a transaction pending the current transaction ; Always execute non transactionally .
7.PROPAGATION_NESTED
If the current transaction exists , Is executed in a nested transaction , If there are currently no transactions , similar PROPAGATION_REQUIRED（ Create a new ）.
Isolation level
1.Read Uncommitted（ Read uncommitted content ）： Uncommitted data of other transactions may be read .---- Dirty reading problem , Non repeatable reading
2：Read Committed（ Read submission ）： A transaction can only see the changes made by the committed transaction .---- Non repeatable reading , Unreal reading
3：Repeatable Read（ Rereadable ）： Multiple consistent unlocked reads in the same transaction , Take the snapshot version established at the first reading (MVCC), It ensures the readability within the same transaction .
4：Serializable（ Serialization ）： This is the highest level of isolation , It adds a shared lock to each read data row （LOCK IN SHARE
MODE）. At this level , It may lead to a large number of timeout phenomena and lock competition .
.
The difference between unreadable and unreadable ：
Non repeatable reading ：（ Comparison of read data itself ） After a period of time after a transaction reads some data , Read the data again , It is found that the read data content has changed , It is not repeatable .
Unreal reading ：（ Comparison of the number of read result sets ） A transaction queries the previously retrieved data according to the same query criteria , It is found that the number of retrieved result sets increases or decreases （ Inserted by another transaction , Deleted ）, Similar to hallucination .
Rollback mechanism （rollbackfor）
Read only （readonly）
Timeout （timeout）
spring Scenario of transaction invalidation in
1： Database level , The database engine itself does not support transactions
2： cover @Transactional The class of the annotated method is not spring Administration
3： cover @Transactional The class of the annotated method is not public of
4： When calling itself , Call the class's own method , Without going through Spring Proxy class for , By default, the transaction will take effect only when it is called externally .
Because by spring When managing spring inside aop The created proxy object will turn off the automatic submission mechanism of the transaction , Then start the transaction .
@Service public class OrderServiceImpl implements OrderService {
@Transactional public void update(Order order) { updateOrder(order); }
@Transactional(propagation = Propagation.REQUIRES_NEW) public void
updateOrder(Order order) { // update order } }
5： The data source does not have a transaction manager configured
6： There is no exception type configured for rollback , Default is RuntimeException, The exception that occurred does not belong to this class .
Technology