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

This article focuses on "what are the reasons for the failure of Spring transactions". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn "what is the reason for the failure of Spring transactions?"

1. Database engine does not support transactions

Here, take MySQL as an example. Its MyISAM engine does not support transaction operations. InnoDB is the engine that supports transactions. Generally, InnoDB is used to support transactions.

According to the official documents of MySQL:

Https://dev.mysql.com/doc/refman/5.5/en/storage-engine-setting.html

The default storage engine starting from MySQL 5.5.5 is InnoDB, and the previous default is: MyISAM, so it's worth noting that the underlying engine doesn't support transactions for nothing.

2. Not managed by Spring

As shown in the following example:

/ / @ Service public class OrderServiceImpl implements OrderService {@ Transactional public void updateOrder (Order order) {/ / update order}}

If you comment out the @ Service annotation at this time, the class will not be loaded as a Bean, the class will not be managed by Spring, and the transaction will naturally be invalidated.

3. The method is not public.

The following is from the official Spring documentation:

When using proxies, you should apply the @ Transactional annotation only to methods with public visibility. If you do annotate protected, private or package-visible methods with the @ Transactional annotation, no error is raised, but the annotated method does not exhibit the configured transactional settings. Consider the use of AspectJ (see below) if you need to annotate non-public methods.

It roughly means that @ Transactional can only be used on public methods, otherwise the transaction will not expire. If you want to use it on non-public methods, you can turn on AspectJ proxy mode.

4. The problem of self-calling

Let's look at two examples:

Service public class OrderServiceImpl implements OrderService {public void update (Order order) {updateOrder (order);} @ Transactional public void updateOrder (Order order) {/ / update order}}

There is no @ Transactional annotation on the update method. Call the updateOrder method with the @ Transactional annotation. Does the transaction on the updateOrder method work?

Let's look at the following example:

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}}

This time, we added @ Transactional,updateOrder and REQUIRES_NEW to the update method to open a new transaction, so does the new transaction work?

The answer to these two examples is: it doesn't work!

Because they make their own calls, they adjust their own methods of this class without passing through the Spring proxy class. By default, only externally invoked transactions will take effect, which is also a clich é classic problem.

One of the solutions to this is to inject yourself into your class and call another method with the injected object, which is not elegant, and another possible solution can be found in the article "how does Spring start another transaction in another transaction?"

5. The data source does not have a transaction manager configured

@ Bean public PlatformTransactionManager transactionManager (DataSource dataSource) {return new DataSourceTransactionManager (dataSource);}

As shown above, it is useless if the current data source is not configured with a transaction manager!

6. Transactions are not supported

Take a look at the following example:

Service public class OrderServiceImpl implements OrderService {@ Transactional public void update (Order order) {updateOrder (order);} @ Transactional (propagation = Propagation.NOT_SUPPORTED) public void updateOrder (Order order) {/ / update order}}

Propagation.NOT_SUPPORTED: indicates that it does not run as a transaction. Currently, it is suspended if there is a transaction.

All actively do not support running as a transaction, and it is futile for the transaction to take effect!

7. Abnormal has been eaten

This is also a more common scene:

/ @ Service public class OrderServiceImpl implements OrderService {@ Transactional public void updateOrder (Order order) {try {/ / update order} catch {}

Eat the exception, and then do not throw it out, how to roll back the transaction!

8. Error in exception type

The above example throws another exception:

/ / @ Service public class OrderServiceImpl implements OrderService {@ Transactional public void updateOrder (Order order) {try {/ / update order} catch {throw new Exception (update error);}

This transaction also does not take effect, because the default rollback is: RuntimeException. If you want to trigger other abnormal rollbacks, you need to configure them on the comments, such as:

@ Transactional (rollbackFor = Exception.class)

This configuration is limited to the Throwable exception class and its subclasses.

At this point, I believe you have a deeper understanding of "what is the reason for the failure of Spring transactions?" you might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

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.