Isolation level of things in spring

One, propagation (the propagation property of a transaction)

propagation:key property determines which method the agent should add the transaction behavior to. The most important part of such a property is the propagation behavior. The following options are available: propagation_required--supports the current transaction and creates a new transaction if no transaction is currently in use. This is the most common choice. The
propagation_supports--supports the current transaction and is executed in a non-transactional manner if no transactions are currently in use. The
propagation_mandatory--supports the current transaction and throws an exception if there is no current transaction.
propagation_requires_new--a new transaction and suspends the current transaction if a transaction is currently present. The
propagation_not_supported--executes the operation in a non-transactional manner, suspending the current transaction if a transaction is currently present. The
propagation_never--is executed in a non-transactional manner and throws an exception if a transaction is currently present.

1:propagation_required
Join the transaction that is currently being executed is not in another transaction, then a new transaction
For example, Serviceb.methodb's transaction level is defined as propagation_required , then because of the execution of Servicea.methoda, the
Servicea.methoda has already started a transaction, and when the call Serviceb.methodb,serviceb.methodb sees that he is already running within the transaction of the Servicea.methoda
, it will no longer start a new transaction. And if Servicea.methoda is running and finds himself not in a transaction, he assigns himself a transaction.
This allows the transaction to be rolled back if an exception occurs in the Servicea.methoda or anywhere within the SERVICEB.METHODB. Even if the SERVICEB.METHODB transaction has been
committed, but Servicea.methoda will be rolled back in the next fail, SERVICEB.METHODB will also be rolled back

2:propagation_supports
If you are currently running in a transaction, that is, as a transaction, if you are not currently in a transaction, run as a non-transactional

3:propagation_mandatory
Must run in a transaction. In other words, he can only be called by a parent transaction. Otherwise, he's going to throw an exception.

4:propagation_requires_new
This is a comparison of the mouth. For example, we design Servicea.methoda transaction level of Propagation_required,serviceb.methodb for Propagation_requires_new,
Then when the execution to the SERVICEB.METHODB, Servicea.methoda the transaction will be suspended, Serviceb.methodb will start a new transaction, waiting for Serviceb.methodb to complete the transaction,
He just went on with the execution. The difference between his affairs and Propagation_required is the degree of rollback of the transaction. Because Serviceb.methodb is a new transaction, there is a
two different transactions. If the SERVICEB.METHODB has been committed, then Servicea.methoda fails to rollback, SERVICEB.METHODB is not rolled back. If Serviceb.methodb fails to roll back, the Servicea.methoda transaction may still be committed if the exception he throws is Servicea.methoda captured.

5:propagation_not_supported
Transactions are not currently supported. For example, Servicea.methoda's transaction level is propagation_required, and Serviceb.methodb's transaction level is propagation_not_supported,
Then when execution to Serviceb.methodb, Servicea.methoda's transaction hangs, and he runs out of non-transactional state, and then continues the Servicea.methoda transaction.

6:propagation_never
Cannot run in a transaction. Suppose the transaction level of Servicea.methoda is propagation_required, and Serviceb.methodb's transaction level is Propagation_never,
Then Serviceb.methodb will throw an exception.

7:propagation_nested
The key to understanding nested is savepoint. The difference between him and propagation_requires_new is that propagation_requires_new another transaction, which will be independent of his father's affairs,
and nested's affairs are dependent on his father's affairs, and his submission is to be submitted as a piece of his father's business. In other words, if the parent transaction is finally rolled back, he will also be rolled back.
The advantage of nested affairs is that he has a savepoint.

ServiceA {/*** Transaction property is configured to Propagation_required*/void MethodA () {try {//savepointserviceb.methodb ();//propagation_nested Level} catch (Someexception) {//execute other business, such as SERVICEC.METHODC ();}}}

SERVICEC.METHODC, go ahead and try to do your own business.
But this transaction is not defined in the EJB standard.

spring the isolation level of the transaction
 1. Isolation_default: This is a platfromtransactionmanager default isolation level that uses the default transaction isolation level of the database.
      Four additional isolation levels corresponding to JDBC
 2. Isolation_read_uncommitted: This is the lowest isolation level of a transaction, which allows a foreign transaction to see the uncommitted data for this transaction.
      This isolation level produces dirty reads, non-repeatable reads, and Phantom reads.
 3. Isolation_read_committed: Ensures that a transaction modified data is committed before it can be read by another transaction. Another transaction cannot read the uncommitted data of the transaction
 4. Isolation_repeatable_read: This transaction isolation level prevents dirty reads and cannot be read repeatedly. However, Phantom reads may occur.
      It ensures that one transaction cannot read the uncommitted data of another transaction, and that the following conditions are avoided (non-repeatable read).
 5. Isolation_serializable This is the most cost-effective, but most reliable, transaction isolation level. Transactions are processed for sequential execution. In addition to preventing dirty reads, the
      also avoids the illusion of reading, not repeating.

What is dirty data, dirty reading, non-repeatable reading, hallucination reading?
Dirty read: refers to when a transaction is accessing the data, and the data is modified, and this modification has not yet been committed to the database, then another transaction also accesses the data, and then used this data. Because this data is data that has not yet been submitted, the data that is read by another transaction is dirty, and the operation based on dirty data may not be correct.

non-repeatable read: refers to reading the same data multiple times within a transaction. When this transaction is not finished, another transaction accesses the same data. Then, between the two read data in the first transaction, the data that the first transaction two reads may be different because of the modification of the second transaction. This occurs when the data that is read two times within a transaction is not the same and is therefore called non-repeatable read.

illusion reading: a phenomenon that occurs when a transaction is not executed independently, such as when the first transaction modifies data in a table, which involves all rows of data in the table. At the same time, the second transaction modifies the data in the table by inserting a new row of data into the table. Then the user who will be working on the first transaction in the future finds that there are no modified rows of data in the table, as if the illusion had occurred.

Isolation level of things in spring