SpringBoot中的事務(wù)處理

作者：xcbeyond
瘋狂源自夢想，技術(shù)成就輝煌！微信公眾號：《程序猿技術(shù)大咖》號主，專注后端開發(fā)多年，擁有豐富的研發(fā)經(jīng)驗，樂于技術(shù)輸出、分享，現(xiàn)階段從事微服務(wù)架構(gòu)項目的研發(fā)工作，涉及架構(gòu)設(shè)計、技術(shù)選型、業(yè)務(wù)研發(fā)等工作。對于Java、微服務(wù)、數(shù)據(jù)庫、Docker有深入了解，并有大量的調(diào)優(yōu)經(jīng)驗。

前兩章節(jié)主要講解了在SpringBoot中關(guān)于對數(shù)據(jù)的操作，本章節(jié)將介紹如何進行事務(wù)處理。所有的數(shù)據(jù)訪問技術(shù)都離不開事務(wù)處理，否則將會造成數(shù)據(jù)不一致。事務(wù)是一系列的動作，一旦其中有一個動作出現(xiàn)錯誤，必須全部回滾，系統(tǒng)將事務(wù)中對數(shù)據(jù)庫的所有已完成的操作全部撤消，滾回到事務(wù)開始的狀態(tài)，避免出現(xiàn)由于數(shù)據(jù)不一致而導(dǎo)致的接下來一系列的錯誤。事務(wù)的出現(xiàn)是為了確保數(shù)據(jù)的完整性和一致性，在目前企業(yè)級應(yīng)用開發(fā)中，事務(wù)管理是必不可少的。

1、SpringBoot事務(wù)機制
       事務(wù)處理機制都會提供API來開啟事務(wù)、提交事務(wù)來完成數(shù)據(jù)操作，或者在發(fā)生錯誤的時候回滾數(shù)據(jù)，避免數(shù)據(jù)的不完整性、不一致性。

       SpringBoot事務(wù)機制實質(zhì)上就是Spring的事務(wù)機制，是采用統(tǒng)一的機制處理來自不同數(shù)據(jù)訪問技術(shù)的事務(wù)處理，提供了一個接口 PlatformTransactionManager，已經(jīng)為不同數(shù)據(jù)訪問技術(shù)可以進行不同的實現(xiàn)，如下表。
 

涉及到接口關(guān)系如下：

接口PlatformTransactionManager源碼如下：






/*
 * Copyright 2002-2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
package org.springframework.transaction;
 
import org.springframework.lang.Nullable;
 
/**
 * This is the central interface in Spring's transaction infrastructure.
 * Applications can use this directly, but it is not primarily meant as API:
 * Typically, applications will work with either TransactionTemplate or
 * declarative transaction demarcation through AOP.
 *
 * <p>For implementors, it is recommended to derive from the provided
 * {@link org.springframework.transaction.support.AbstractPlatformTransactionManager}
 * class, which pre-implements the defined propagation behavior and takes care
 * of transaction synchronization handling. Subclasses have to implement
 * template methods for specific states of the underlying transaction,
 * for example: begin, suspend, resume, commit.
 *
 * <p>The default implementations of this strategy interface are
 * {@link org.springframework.transaction.jta.JtaTransactionManager} and
 * {@link org.springframework.jdbc.datasource.DataSourceTransactionManager},
 * which can serve as an implementation guide for other transaction strategies.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @since 16.05.2003
 * @see org.springframework.transaction.support.TransactionTemplate
 * @see org.springframework.transaction.interceptor.TransactionInterceptor
 * @see org.springframework.transaction.interceptor.TransactionProxyFactoryBean
 */
public interface PlatformTransactionManager {
 
    /**
     * Return a currently active transaction or create a new one, according to
     * the specified propagation behavior.
     * <p>Note that parameters like isolation level or timeout will only be applied
     * to new transactions, and thus be ignored when participating in active ones.
     * <p>Furthermore, not all transaction definition settings will be supported
     * by every transaction manager: A proper transaction manager implementation
     * should throw an exception when unsupported settings are encountered.
     * <p>An exception to the above rule is the read-only flag, which should be
     * ignored if no explicit read-only mode is supported. Essentially, the
     * read-only flag is just a hint for potential optimization.
     * @param definition TransactionDefinition instance (can be {@code null} for defaults),
     * describing propagation behavior, isolation level, timeout etc.
     * @return transaction status object representing the new or current transaction
     * @throws TransactionException in case of lookup, creation, or system errors
     * @throws IllegalTransactionStateException if the given transaction definition
     * cannot be executed (for example, if a currently active transaction is in
     * conflict with the specified propagation behavior)
     * @see TransactionDefinition#getPropagationBehavior
     * @see TransactionDefinition#getIsolationLevel
     * @see TransactionDefinition#getTimeout
     * @see TransactionDefinition#isReadOnly
     */
    TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;
 
    /**
     * Commit the given transaction, with regard to its status. If the transaction
     * has been marked rollback-only programmatically, perform a rollback.
     * <p>If the transaction wasn't a new one, omit the commit for proper
     * participation in the surrounding transaction. If a previous transaction
     * has been suspended to be able to create a new one, resume the previous
     * transaction after committing the new one.
     * <p>Note that when the commit call completes, no matter if normally or
     * throwing an exception, the transaction must be fully completed and
     * cleaned up. No rollback call should be expected in such a case.
     * <p>If this method throws an exception other than a TransactionException,
     * then some before-commit error caused the commit attempt to fail. For
     * example, an O/R Mapping tool might have tried to flush changes to the
     * database right before commit, with the resulting DataAccessException
     * causing the transaction to fail. The original exception will be
     * propagated to the caller of this commit method in such a case.
     * @param status object returned by the {@code getTransaction} method
     * @throws UnexpectedRollbackException in case of an unexpected rollback
     * that the transaction coordinator initiated
     * @throws HeuristicCompletionException in case of a transaction failure
     * caused by a heuristic decision on the side of the transaction coordinator
     * @throws TransactionSystemException in case of commit or system errors
     * (typically caused by fundamental resource failures)
     * @throws IllegalTransactionStateException if the given transaction
     * is already completed (that is, committed or rolled back)
     * @see TransactionStatus#setRollbackOnly
     */
    void commit(TransactionStatus status) throws TransactionException;
 
    /**
     * Perform a rollback of the given transaction.
     * <p>If the transaction wasn't a new one, just set it rollback-only for proper
     * participation in the surrounding transaction. If a previous transaction
     * has been suspended to be able to create a new one, resume the previous
     * transaction after rolling back the new one.
     * <p><b>Do not call rollback on a transaction if commit threw an exception.</b>
     * The transaction will already have been completed and cleaned up when commit
     * returns, even in case of a commit exception. Consequently, a rollback call
     * after commit failure will lead to an IllegalTransactionStateException.
     * @param status object returned by the {@code getTransaction} method
     * @throws TransactionSystemException in case of rollback or system errors
     * (typically caused by fundamental resource failures)
     * @throws IllegalTransactionStateException if the given transaction
     * is already completed (that is, committed or rolled back)
     */
    void rollback(TransactionStatus status) throws TransactionException;
 
}
2、聲明式事務(wù)
         建立在AOP之上的，其本質(zhì)是對方法前后進行攔截，然后在目標(biāo)方法開始之前創(chuàng)建或者加入一個事務(wù)，在執(zhí)行完目標(biāo)方法之后根據(jù)執(zhí)行情況提交或者回滾事務(wù)。聲明式事務(wù)最大的優(yōu)點就是不需要通過編程的方式管理事務(wù)，這樣就不需要在業(yè)務(wù)邏輯代碼中摻雜事務(wù)管理的代碼，只需在配置文件中做相關(guān)的事務(wù)規(guī)則聲明(或通過基于@Transactional注解的方式)，便可以將事務(wù)規(guī)則應(yīng)用到業(yè)務(wù)邏輯中。

      Spring支持聲明式事務(wù)，被注解的方法在被調(diào)用時，Spring開啟一個新的事務(wù)，當(dāng)方法無異常結(jié)束后，Spring會提交這個事務(wù)。

@Transactional
public void insertUser(User user) {
   //數(shù)據(jù)庫表的操作
    ……
}
注：

（1）@Transactional是來自org.springframework.transaction.annotation包的。

（2）@Transactional不僅可以注解在方法上，也可以注解在類上。當(dāng)注解在類上時，意味著此類的所有public方法都是開啟事務(wù)的。如果類級別和方法級別同時使用了@Transactional注解，則使用在類級別的注解會重載方法級別的注解。

以下為注解@Transactional源碼：

(為了縮小所占篇數(shù)，故去掉注釋部分)

package org.springframework.transaction.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
import org.springframework.core.annotation.AliasFor;
import org.springframework.transaction.TransactionDefinition;
 
 
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
 
    @AliasFor("transactionManager")
    String value() default "";
    
    @AliasFor("value")
    String transactionManager() default "";
    
    Propagation propagation() default Propagation.REQUIRED;
 
    Isolation isolation() default Isolation.DEFAULT;
 
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
 
    boolean readOnly() default false;
 
    Class<? extends Throwable>[] rollbackFor() default {};
 
    String[] rollbackForClassName() default {};
    
    Class<? extends Throwable>[] noRollbackFor() default {};
 
    String[] noRollbackForClassName() default {};
}
屬性說明如下表：
 

在SpringBoot中，建議采用注解@Transactional進行事務(wù)的控制。