Shulou(Shulou.com)06/02 Report--

This article mainly introduces "how to understand Spring transactions". In daily operation, I believe many people have doubts about how to understand Spring transactions. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the doubts about "how to understand Spring transactions"! Next, please follow the editor to study!

1. Is the transaction of Spring and the transaction isolation of database a concept?

Let's start with the first question, is the transaction isolation level of Spring the same as the transaction isolation level of data?

In fact, databases generally have only four isolation mechanisms, and Spring abstracts a kind of default, which varies according to data settings.

Read uncommitted (read not submitted)

Read committed (committed, non-repeatable)

Repeatable read (repeatable)

Serializable (serializable)

Default (PlatformTransactionManager default isolation level, which uses the database default)

This is because Spring only provides a unified transaction management interface, and the implementation is implemented by each database itself (such as MySQL). Spring adjusts the database isolation level at the beginning of the transaction according to the isolation level set in the current environment, thus maintaining consistency.

In the DataSourceUtils file, the code outputs this process in detail.

/ / Apply specific isolation level, if any. Integer previousIsolationLevel = null; if (definition! = null & & definition.getIsolationLevel ()! = TransactionDefinition.ISOLATION_DEFAULT) {if (logger.isDebugEnabled ()) {logger.debug ("Changing isolation level of JDBC Connection [" + con + "] to" + definition.getIsolationLevel ());} int currentIsolation = con.getTransactionIsolation (); if (currentIsolation! = definition.getIsolationLevel ()) {previousIsolationLevel = currentIsolation Con.setTransactionIsolation (definition.getIsolationLevel ());}}

Conclusion: in three cases, if Spring does not specify a transaction isolation level, it will use the default transaction isolation level of the database; when Spring specifies a transaction isolation level, it will change the transaction isolation level to the specified value in the code; when the database does not support this isolation level, the effect will be based on the database (for example, using the MyISAM engine).

We will make the declaration in the following way. If you don't have performance and demand problems, don't fix it. If the transaction is not handled properly, the table will be locked, and the locked table can be dead in the case of large concurrency.

@ Transactional (isolation = Isolation.READ_UNCOMMITTED)

2. Seven propagation mechanisms of Spring transactions.

As long as you write code, there will always be nesting or loops in the code, resulting in the nesting or looping of transactions. Then the transaction will react differently according to the configuration in these cases.

REQUIRED, this is the default. Indicates that the current method must run in the context of a transaction, and if a client has a transaction, the callee will run in that transaction, otherwise a transaction will be reopened. (if an exception occurs on the callee, both the caller and the callee transaction will be rolled back.)

REQUIRE_NEW indicates that the current method must run in its own transaction. If there is a current transaction, the current transaction is suspended during the execution of the method

NESTED if the current method has a transaction running, the method should run in a nested transaction that can be committed or rolled back independently of the encapsulated transaction. If the encapsulated transaction exists and the outer transaction throws an exception rollback, the inner transaction must be rolled back, whereas the inner transaction does not affect the outer transaction. If the encapsulated transaction does not exist, it is the same as the required

SUPPORTS indicates that the current method does not need to have a transaction context, but if there is a transaction, it can also run in that transaction

NOT_SUPPORTED indicates that the method should not be run in a transaction. If a transaction is running, it will be suspended at runtime and will not resume execution until the transaction is committed or rolled back

MANDATORY indicates that the current method must run in a transaction. If there is no transaction, an exception will be thrown.

NEVER means that when a method should not be running in a transaction, an exception is thrown if there is a transaction

Generally use more REQUIRED, REQUIRES_NEW, use other, you have to be careful, understand before using.

Most afraid that if these two words, it will make things very complicated, especially when there is a large amount of code, you never know who your service will be used. This is awkward.

We will make the statement in the following way. In view of the fact that the transaction propagation of Spring is very roundabout, if the function meets the requirements, then use the default, otherwise it will cause unnecessary trouble.

@ Transactional (propagation=Propagation.REQUIRED)

3. How is the transaction propagation mechanism realized?

The transaction propagation mechanism seems magical, but it is actually implemented using a simple ThreadLocal mechanism. Therefore, if the method called is called on a new thread, transaction propagation is actually invalidated. This is different from the transparent transmission we talked about before, Spring does not do this kind of treatment.

Therefore, the transaction propagation mechanism can only be impressed by going through the source code. Relying solely on words to spread, many things will become indescribable.

As shown in the figure, PlatformTransactionManager has only three simple abstract interfaces that define all transaction operations of Spring, including JDBC.

What we usually call JDBC is only part of it.

The way of implementation is still implemented using AOP, and the specific implementation class is implemented by TransactionAspectSupport. As you can see, the code defines a ThreadLocal variable called transactionInfoHolder, and when used, it ensures that the variables obtained are consistent under the same thread.

/ * * Holder to support the {@ code currentTransactionStatus ()} method, * and to support communication between different cooperating advices * (e.g. Before and after advice) if the aspect involves more than a * single method (as will be the case for around advice). * / private static final ThreadLocal transactionInfoHolder = new NamedThreadLocal ("Current aspect-driven transaction")

The specific business logic is implemented in invokeWithinTransaction. If you continue to trace down, you will find the getTransaction method in the AbstractPlatformTransactionManager class.

@ Override public final TransactionStatus getTransaction (@ Nullable TransactionDefinition definition) throws TransactionException {/ / Use defaults if no transaction definition given. TransactionDefinition def = (definition! = null? Definition: TransactionDefinition.withDefaults (); Object transaction = doGetTransaction (); boolean debugEnabled = logger.isDebugEnabled (); if (isExistingTransaction (transaction)) {/ / Existing transaction found-> check propagation behavior to find out how to behave. Return handleExistingTransaction (def, transaction, debugEnabled);} / / Check definition settings for new transaction. If (def.getTimeout ()

< TransactionDefinition.TIMEOUT_DEFAULT) { throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout()); } // No existing transaction found ->

Check propagation behavior to find out how to proceed. If (def.getPropagationBehavior () = = TransactionDefinition.PROPAGATION_MANDATORY) {throw new IllegalTransactionStateException ("No existing transaction found for transaction marked with propagation 'mandatory'");} else if (def.getPropagationBehavior ()) = = TransactionDefinition.PROPAGATION_REQUIRED | | def.getPropagationBehavior () = = TransactionDefinition.PROPAGATION_REQUIRES_NEW | | def.getPropagationBehavior () = = TransactionDefinition.PROPAGATION_NESTED) {SuspendedResourcesHolder suspendedResources = suspend (null) If (debugEnabled) {logger.debug ("Creating new transaction with name [" + def.getName () + "]:" + def);} try {return startTransaction (def, transaction, debugEnabled, suspendedResources);} catch (RuntimeException | Error ex) {resume (null, suspendedResources); throw ex }} else {/ / Create "empty" transaction: no actual transaction, but potentially synchronization. If (def.getIsolationLevel ()! = TransactionDefinition.ISOLATION_DEFAULT & & logger.isWarnEnabled ()) {logger.warn ("Custom isolation level specified but no actual transaction initiated;" + "isolation level will effectively be ignored:" + def);} boolean newSynchronization = (getTransactionSynchronization () = = SYNCHRONIZATION_ALWAYS); return prepareTransactionStatus (def, null, true, newSynchronization, debugEnabled, null);}}

I don't have to explain too much, all the obvious logic is in the code. This is where the transaction was created.

4. Can the query method not open the transaction?

A transaction has a readonly that controls the read-only properties of the transaction and has nothing to do with whether the transaction is open or not.

In a previous article, we talked about controlling the routing of statements by setting the readonly attribute: the "MySQL official driver" mysterious veil of master-slave separation (literacy article), which uses one of the transaction attributes, readonly, which is ultimately reflected at the database connection level.

Connection.setReadOnly (true)

It is used in Spring as follows:

@ Transactional (readOnly=true)

It is worth noting that after this property is set, not every underlying database supports it. The middle-tier ORM or driver may also use this attribute to do some articles, so the readonly is not so much functional as a hint.

In the case of MySQL, there are two submission modes:

SET AUTOCOMMIT=0 forbids automatic submission

SET AUTOCOMMIT=1 enables auto-submission

These are real SQL statements, so if you open a transaction, AUTOCOMMIT should be false. We can see that Spring does the following.

Con.setAutoCommit (false)

If it is a read-only transaction, don't forget to set it manually.

If (isEnforceReadOnly () & & definition.isReadOnly ()) {try (Statement stmt = con.createStatement ()) {stmt.executeUpdate ("SET TRANSACTION READ ONLY");}}

This operation is expensive, and without Transaction annotations, transactions are not enabled by default. There is no need to open a transaction with a single query statement, and the default configuration of the database can meet the requirements.

However, if you execute multiple query statements at a time, such as statistical query and report query, in this scenario, multiple query SQL must ensure the overall read consistency, otherwise, after the previous SQL query and before the latter SQL query, the data will be changed by other users, which will result in inconsistent data.

It is only in this case that the read transaction is started.

5. Is the private method plus transaction annotations useful?

The @ Transaction annotation added to private is of no use.

This is not a feature written by transactional code. Because these functions of the transaction are imposed by AOP, it is controlled by the dynamic agent.

Methods modified by private and final will not be proxied.

However, you can put the private method in the public method with transactional functionality. In this way, it also seems to have some of the functional features of the transaction, but it does not.

At this point, the study on "how to understand Spring affairs" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.