Spring系列之不同資料庫異常如何抽象的？

程式設計師阿牛發表於2021-09-06

前言

使用Spring-Jdbc的情況下，在有些場景中，我們需要根據資料庫報的異常型別的不同，來編寫我們的業務程式碼。比如說，我們有這樣一段邏輯，如果我們新插入的記錄，存在唯一約束衝突，就會返回給客戶端描述：記錄已存在，請勿重複操作
程式碼一般是這麼寫的:

@Resource
private JdbcTemplate jdbcTemplate;
public String testAdd(){
    try {
        jdbcTemplate.execute("INSERT INTO user_info (user_id, user_name, email, nick_name, status, address) VALUES (80002, '張三丰', 'xxx@126.com', '張真人', 1, '武當山');");
        return "OK";
    }catch (DuplicateKeyException e){
        return "記錄已存在，請勿重複操作";
    }
}

測試一下：
file
如上圖提示，並且無論什麼更換什麼資料庫（Spring-Jdbc支援的），程式碼都不用改動

那麼Spring-Jdbc是在使用不同資料庫時，Spring如何幫我們實現對異常的抽象的呢?

程式碼實現

我們來正向看下程式碼:
首先入口JdbcTemplate.execute方法：

public void execute(final String sql) throws DataAccessException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Executing SQL statement [" + sql + "]");
    }
    ...
    //實際執行入口,呼叫內部方法
    this.execute(new ExecuteStatementCallback(), true);
}

內部方法execute

@Nullable
private <T> T execute(StatementCallback<T> action, boolean closeResources) throws DataAccessException {
    Assert.notNull(action, "Callback object must not be null");
    Connection con = DataSourceUtils.getConnection(this.obtainDataSource());
    Statement stmt = null;

    Object var12;
    try {
	...
    } catch (SQLException var10) {
        ....
	//SQL出現異常後，所有的異常在這裡進行異常轉換
        throw this.translateException("StatementCallback", sql, var10);
    } finally {
        if (closeResources) {
            JdbcUtils.closeStatement(stmt);
            DataSourceUtils.releaseConnection(con, this.getDataSource());
        }

    }

    return var12;
}

異常轉換方法translateException

protected DataAccessException translateException(String task, @Nullable String sql, SQLException ex) {
	//獲取異常轉換器，然後根據資料庫返回碼相關資訊執行轉換操作
	//轉換不成功，也有兜底異常UncategorizedSQLException
    DataAccessException dae = this.getExceptionTranslator().translate(task, sql, ex);
    return (DataAccessException)(dae != null ? dae : new UncategorizedSQLException(task, sql, ex));
}

獲取轉換器方法getExceptionTranslator

public SQLExceptionTranslator getExceptionTranslator() {
    //獲取轉換器屬性，如果為空，則生成一個
    SQLExceptionTranslator exceptionTranslator = this.exceptionTranslator;
    if (exceptionTranslator != null) {
        return exceptionTranslator;
    } else {
        synchronized(this) {
            SQLExceptionTranslator exceptionTranslator = this.exceptionTranslator;
		if (exceptionTranslator == null) {
                DataSource dataSource = this.getDataSource();
                //shouldIgnoreXml是一個標記，就是不通過xml載入bean，預設false
		if (shouldIgnoreXml) {
                    exceptionTranslator = new SQLExceptionSubclassTranslator();
                } else if (dataSource != null) {
		//如果DataSource不為空，則生成轉換器SQLErrorCodeSQLExceptionTranslator，一般情況下首先獲取到該轉換器
                    exceptionTranslator = new SQLErrorCodeSQLExceptionTranslator(dataSource);
                } else {
		// 其他情況，生成SQLStateSQLExceptionTranslator轉換器
                    exceptionTranslator = new SQLStateSQLExceptionTranslator();
                }

                this.exceptionTranslator = (SQLExceptionTranslator)exceptionTranslator;
            }
            return (SQLExceptionTranslator)exceptionTranslator;
        }
    }
}

轉換方法：
因為預設的轉換器是SQLErrorCodeSQLExceptionTranslator，所以這裡呼叫SQLErrorCodeSQLExceptionTranslator的doTranslate方法
file
類圖呼叫關係如上，實際先呼叫的是AbstractFallbackSQLExceptionTranslator.translate的方法

@Nullable
public DataAccessException translate(String task, @Nullable String sql, SQLException ex) {
    Assert.notNull(ex, "Cannot translate a null SQLException");
		//這裡才真正呼叫SQLErrorCodeSQLExceptionTranslator.doTranslate方法
    DataAccessException dae = this.doTranslate(task, sql, ex);
    if (dae != null) {
        return dae;
    } else {
		    //如果沒有找到響應的異常，則呼叫其他轉換器，輸入遞迴呼叫，這裡後面說
        SQLExceptionTranslator fallback = this.getFallbackTranslator();
        return fallback != null ? fallback.translate(task, sql, ex) : null;
    }
}

實際轉換類SQLErrorCodeSQLExceptionTranslator的方法：

//這裡省略了一些無關程式碼，只保留了核心程式碼
//先獲取SQLErrorCodes集合，在根據返回的SQLException中獲取的ErrorCode進行匹配，根據匹配結果進行返回響應的異常
protected DataAccessException doTranslate(String task, @Nullable String sql, SQLException ex) {
	....
	SQLErrorCodes sqlErrorCodes = this.getSqlErrorCodes();
    
	String errorCode = Integer.toString(ex.getErrorCode());
	...
	//這裡用1062唯一性約束衝突，所以走到這裡的邏輯，從而返回DuplicateKeyException
	if (Arrays.binarySearch(sqlErrorCodes.getDuplicateKeyCodes(), errorCode) >= 0) {
		this.logTranslation(task, sql, sqlEx, false);
		return new DuplicateKeyException(this.buildMessage(task, sql, sqlEx), sqlEx);
	}
    ...
    return null;
}

上面的SQLErrorCodes是一個錯誤碼集合，但是不是全部資料庫的所有錯誤碼集合，而是隻取了相應資料庫的錯誤碼集合，怎麼保證獲取的是當前使用的資料庫的錯誤碼，而不是其他資料庫的錯誤碼呢？當然Spring為我們實現了，在SQLErrorCodeSQLExceptionTranslator中：

public class SQLErrorCodeSQLExceptionTranslator extends AbstractFallbackSQLExceptionTranslator {

private SingletonSupplier<SQLErrorCodes> sqlErrorCodes;
//預設構造方法，設定瞭如果轉換失敗，下一個轉換器是SQLExceptionSubclassTranslator
    public SQLErrorCodeSQLExceptionTranslator() {
        this.setFallbackTranslator(new SQLExceptionSubclassTranslator());
}
//前面生成轉換器的時候，exceptionTranslator = new SQLErrorCodeSQLExceptionTranslator(dataSource);
//使用的是本構造方法，傳入了DataSource，其中有資料庫廠商資訊，本文中是MYSQL
public SQLErrorCodeSQLExceptionTranslator(DataSource dataSource) {
	this();
	this.setDataSource(dataSource);
}

//從錯誤碼工廠SQLErrorCodesFactory裡，獲取和資料來源對應的廠商的所有錯誤碼
public void setDataSource(DataSource dataSource) {
	this.sqlErrorCodes = SingletonSupplier.of(() -> {
		return SQLErrorCodesFactory.getInstance().resolveErrorCodes(dataSource);
	});
	this.sqlErrorCodes.get();
}
}

錯誤碼工廠SQLErrorCodesFactory的resolveErrorCodes方法：

//既然是工廠，裡面肯定有各種資料庫的錯誤碼，本文中使用的是MYSQL，我們看一下實現邏輯
@Nullable
public SQLErrorCodes resolveErrorCodes(DataSource dataSource) {
    Assert.notNull(dataSource, "DataSource must not be null");
    if (logger.isDebugEnabled()) {
        logger.debug("Looking up default SQLErrorCodes for DataSource [" + this.identify(dataSource) + "]");
    }
    //從快取中拿MYSQL對應的SQLErrorCodes
    SQLErrorCodes sec = (SQLErrorCodes)this.dataSourceCache.get(dataSource);
    if (sec == null) {
        synchronized(this.dataSourceCache) {
            sec = (SQLErrorCodes)this.dataSourceCache.get(dataSource);
            if (sec == null) {
                try {
                    String name = (String)JdbcUtils.extractDatabaseMetaData(dataSource, DatabaseMetaData::getDatabaseProductName);
                    if (StringUtils.hasLength(name)) {
                        SQLErrorCodes var10000 = this.registerDatabase(dataSource, name);
                        return var10000;
                    }
                } catch (MetaDataAccessException var6) {
                    logger.warn("Error while extracting database name", var6);
                }

                return null;
            }
        }
    }

    if (logger.isDebugEnabled()) {
        logger.debug("SQLErrorCodes found in cache for DataSource [" + this.identify(dataSource) + "]");
    }

    return sec;
}

快取dataSourceCache如何生成的？

public SQLErrorCodes registerDatabase(DataSource dataSource, String databaseName) {
   //根據資料庫型別名稱（這裡是MySQL），獲取錯誤碼列表
    SQLErrorCodes sec = this.getErrorCodes(databaseName);
    if (logger.isDebugEnabled()) {
        logger.debug("Caching SQL error codes for DataSource [" + this.identify(dataSource) + "]: database product name is '" + databaseName + "'");
    }

    this.dataSourceCache.put(dataSource, sec);
    return sec;
}

public SQLErrorCodes getErrorCodes(String databaseName) {
        Assert.notNull(databaseName, "Database product name must not be null");
	//從errorCodesMap根據key=MYSQL獲取SQLErrorCodes
        SQLErrorCodes sec = (SQLErrorCodes)this.errorCodesMap.get(databaseName);
        if (sec == null) {
            Iterator var3 = this.errorCodesMap.values().iterator();

            while(var3.hasNext()) {
                SQLErrorCodes candidate = (SQLErrorCodes)var3.next();
                if (PatternMatchUtils.simpleMatch(candidate.getDatabaseProductNames(), databaseName)) {
                    sec = candidate;
                    break;
                }
            }
        }

        if (sec != null) {
            this.checkCustomTranslatorRegistry(databaseName, sec);
            if (logger.isDebugEnabled()) {
                logger.debug("SQL error codes for '" + databaseName + "' found");
            }

            return sec;
        } else {
            if (logger.isDebugEnabled()) {
                logger.debug("SQL error codes for '" + databaseName + "' not found");
            }

            return new SQLErrorCodes();
        }
    }
		
		
//SQLErrorCodesFactory構造方法中，生成的errorCodesMap，map的內容來自org/springframework/jdbc/support/sql-error-codes.xml檔案		
protected SQLErrorCodesFactory() {
        Map errorCodes;
        try {
            DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
            lbf.setBeanClassLoader(this.getClass().getClassLoader());
            XmlBeanDefinitionReader bdr = new XmlBeanDefinitionReader(lbf);
            Resource resource = this.loadResource("org/springframework/jdbc/support/sql-error-codes.xml");
            if (resource != null && resource.exists()) {
                bdr.loadBeanDefinitions(resource);
            } else {
                logger.info("Default sql-error-codes.xml not found (should be included in spring-jdbc jar)");
            }

            resource = this.loadResource("sql-error-codes.xml");
            if (resource != null && resource.exists()) {
                bdr.loadBeanDefinitions(resource);
                logger.debug("Found custom sql-error-codes.xml file at the root of the classpath");
            }

            errorCodes = lbf.getBeansOfType(SQLErrorCodes.class, true, false);
            if (logger.isTraceEnabled()) {
                logger.trace("SQLErrorCodes loaded: " + errorCodes.keySet());
            }
        } catch (BeansException var5) {
            logger.warn("Error loading SQL error codes from config file", var5);
            errorCodes = Collections.emptyMap();
        }

        this.errorCodesMap = errorCodes;
}

sql-error-codes.xml檔案中配置了各個資料庫的主要的錯誤碼
這裡列舉了MYSQL部分，當然還有其他部分，我們可以看到唯一性約束錯誤碼是1062，就可以翻譯成DuplicateKeyException異常了

<bean id="MySQL" class="org.springframework.jdbc.support.SQLErrorCodes">
		<property name="databaseProductNames">
			<list>
				<value>MySQL</value>
				<value>MariaDB</value>
			</list>
		</property>
		<property name="badSqlGrammarCodes">
			<value>1054,1064,1146</value>
		</property>
		<property name="duplicateKeyCodes">
			<value>1062</value>
		</property>
		<property name="dataIntegrityViolationCodes">
			<value>630,839,840,893,1169,1215,1216,1217,1364,1451,1452,1557</value>
		</property>
		<property name="dataAccessResourceFailureCodes">
			<value>1</value>
		</property>
		<property name="cannotAcquireLockCodes">
			<value>1205,3572</value>
		</property>
		<property name="deadlockLoserCodes">
			<value>1213</value>
		</property>
	</bean>

你已經看到，比如上面的錯誤碼值列舉了一部分，如果出現了一個不在其中的錯誤碼肯定是匹配不到，Spring當然能想到這種情況了

   /**
	 *@公-眾-號：程式設計師阿牛
	 *在AbstractFallbackSQLExceptionTranslator中，看到如果查詢失敗會獲取下一個後續轉換器
	 */
    @Nullable
    public DataAccessException translate(String task, @Nullable String sql, SQLException ex) {
        Assert.notNull(ex, "Cannot translate a null SQLException");
        DataAccessException dae = this.doTranslate(task, sql, ex);
        if (dae != null) {
            return dae;
        } else {
            SQLExceptionTranslator fallback = this.getFallbackTranslator();
            return fallback != null ? fallback.translate(task, sql, ex) : null;
        }
    }

SQLErrorCodeSQLExceptionTranslator的後置轉換器是什麼？

//構造方法中已經指定，SQLExceptionSubclassTranslator
public SQLErrorCodeSQLExceptionTranslator() {
   this.setFallbackTranslator(new SQLExceptionSubclassTranslator());
}

SQLExceptionSubclassTranslator的轉換方法邏輯如下：

/**
*@公-眾-號：程式設計師阿牛
*可以看出實際按照子類型別來判斷，返回相應的錯誤類，如果匹配不到，則找到下一個處理器，這裡的處理其我們可以根據構造方法青松找到*SQLStateSQLExceptionTranslator
*/
@Nullable
protected DataAccessException doTranslate(String task, @Nullable String sql, SQLException ex) {
    if (ex instanceof SQLTransientException) {
        if (ex instanceof SQLTransientConnectionException) {
            return new TransientDataAccessResourceException(this.buildMessage(task, sql, ex), ex);
        }

        if (ex instanceof SQLTransactionRollbackException) {
            return new ConcurrencyFailureException(this.buildMessage(task, sql, ex), ex);
        }

        if (ex instanceof SQLTimeoutException) {
            return new QueryTimeoutException(this.buildMessage(task, sql, ex), ex);
        }
    } else if (ex instanceof SQLNonTransientException) {
        if (ex instanceof SQLNonTransientConnectionException) {
            return new DataAccessResourceFailureException(this.buildMessage(task, sql, ex), ex);
        }

        if (ex instanceof SQLDataException) {
            return new DataIntegrityViolationException(this.buildMessage(task, sql, ex), ex);
        }

        if (ex instanceof SQLIntegrityConstraintViolationException) {
            return new DataIntegrityViolationException(this.buildMessage(task, sql, ex), ex);
        }

        if (ex instanceof SQLInvalidAuthorizationSpecException) {
            return new PermissionDeniedDataAccessException(this.buildMessage(task, sql, ex), ex);
        }

        if (ex instanceof SQLSyntaxErrorException) {
            return new BadSqlGrammarException(task, sql != null ? sql : "", ex);
        }

        if (ex instanceof SQLFeatureNotSupportedException) {
            return new InvalidDataAccessApiUsageException(this.buildMessage(task, sql, ex), ex);
        }
    } else if (ex instanceof SQLRecoverableException) {
        return new RecoverableDataAccessException(this.buildMessage(task, sql, ex), ex);
    }

    return null;
}

SQLStateSQLExceptionTranslator的轉換方法：

/**
*@公-眾-號：程式設計師阿牛
*可以看出根據SQLState的前兩位來判斷異常，根據匹配結果返回相應的異常資訊  
*/
@Nullable
protected DataAccessException doTranslate(String task, @Nullable String sql, SQLException ex) {
    String sqlState = this.getSqlState(ex);
    if (sqlState != null && sqlState.length() >= 2) {
        String classCode = sqlState.substring(0, 2);
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Extracted SQL state class '" + classCode + "' from value '" + sqlState + "'");
        }

        if (BAD_SQL_GRAMMAR_CODES.contains(classCode)) {
            return new BadSqlGrammarException(task, sql != null ? sql : "", ex);
        }

        if (DATA_INTEGRITY_VIOLATION_CODES.contains(classCode)) {
            return new DataIntegrityViolationException(this.buildMessage(task, sql, ex), ex);
        }

        if (DATA_ACCESS_RESOURCE_FAILURE_CODES.contains(classCode)) {
            return new DataAccessResourceFailureException(this.buildMessage(task, sql, ex), ex);
        }

        if (TRANSIENT_DATA_ACCESS_RESOURCE_CODES.contains(classCode)) {
            return new TransientDataAccessResourceException(this.buildMessage(task, sql, ex), ex);
        }

        if (CONCURRENCY_FAILURE_CODES.contains(classCode)) {
            return new ConcurrencyFailureException(this.buildMessage(task, sql, ex), ex);
        }
    }

    return ex.getClass().getName().contains("Timeout") ? new QueryTimeoutException(this.buildMessage(task, sql, ex), ex) : null;
}

為什麼SQLState可以得出錯誤型別？

因為資料庫是根據 X/Open 和 SQL Access Group SQL CAE 規範 (1992) 所進行的定義，SQLERROR 返回 SQLSTATE 值。SQLSTATE 值是包含五個字元的字串。五個字元包含數值或者大寫字母，代表各種錯誤或者警告條件的程式碼。SQLSTATE 有個層次化的模式：頭兩個字元標識條件的通常表示錯誤條件的類別，後三個字元表示在該通用類中的子類。成功的狀態是由 00000 標識的。SQLSTATE 程式碼在大多數地方都是定義在 SQL 標準裡

處理流程圖

file

用到了哪些設計模式？

組合模式

file

通過上圖大家有沒有發現三個實現類之間的關係—組合關係，組合關係在父類AbstractFallbackSQLExceptionTranslator中變成了遞迴呼叫，這裡充滿了智慧(Composite設計模式)。

單例模式

在SQLErrorCodesFactory（單例模式）

策略模式

根據資料庫的不同，獲取不同的errorcodes集合

總結：

在學習的過程中，我們不但要關注其實現的方式，還要關注我們能從裡面學到什麼？比如說從這個異常抽象中，能學到幾種設計模式，以及使用的場景，這些都是可以運用到以後的工作中。
下一篇，我們繼續。
也歡迎加我，一起交流和成長。

Spring系列之JDBC對不同資料庫異常如何抽象的？
2021-09-06
SpringJDBC資料庫抽象
從原始碼解析 Spring 資料庫異常抽理
2019-05-25
原始碼Spring資料庫
PHP系列（十二）資料庫抽象層pdo
2017-11-12
PHP資料庫抽象
資料庫差異備份與增量備份的不同之處
2009-01-19
資料庫
不同資料庫SQL語法差異
2024-07-29
資料庫SQL
不同Oracle資料庫之間的資料同步
2017-04-19
Oracle資料庫
Spring系列(七) Spring MVC 異常處理
2018-10-05
SpringMVC
MapReduce之----往hbase資料庫寫入資料時, 出現資料異常
2018-06-23
資料庫
JavaSE基礎系列之異常
2020-10-12
Java
Spring Boot應用中如何動態指定資料庫，實現不同使用者不同資料庫的場景
2024-04-26
Spring Boot資料庫
dart系列之:dart語言中的異常
2021-11-13
Dart
DataIntegrityViolationException異常：java利用mymatis連線資料庫異常
2018-08-22
AIExceptionJava資料庫
資料庫異常hang住解決
2014-05-16
資料庫
資料庫異常崩潰的元凶--OOM killer
2010-03-19
資料庫OOM
SCN異常增長導致資料庫異常關閉風險的防範
2012-12-03
資料庫
資料庫連線系列一：laravel框架如何連線兩個資料庫（不同伺服器）
2020-11-25
資料庫Laravel框架伺服器
資料庫異常智慧分析與診斷
2022-05-10
資料庫
資料庫連線異常故障報告
2021-05-06
資料庫
資料庫連線異常處理思路
2022-10-11
資料庫
今晚遷移資料庫異常順利
2004-12-27
資料庫
Spring Boot實戰系列(2)資料儲存之NoSQL資料庫MongoDB
2018-11-06
Spring BootSQL資料庫MongoDB
Spring系列之資料來源的配置資料庫資料來源連線池的區別
2020-09-20
Spring資料庫
異構資料庫之間資料作業
2012-11-08
資料庫
執行jivejdon報資料庫URL “NULL”異常
2014-04-25
資料庫Null
一次資料庫異常的處理過程
2011-08-23
資料庫
不同字符集資料庫之間的資料同步問題:
2008-04-08
資料庫
異常資料表Exceptions的使用
2012-07-15
Exception
搭建前端監控，如何採集異常資料？
2022-06-10
前端
不同字符集資料庫之間的資料同步問題-補
2008-07-09
資料庫
MySQL資料庫mysqldump命令備份異常的一個案例
2012-03-19
MySql資料庫
SQLServer 異構資料庫之間資料的匯入匯出
2009-12-18
SQLServer資料庫
MySQLNonTransientConnectionException資料庫連線異常
2020-10-12
MySqlException資料庫
【YashanDB知識庫】資料庫審計shutdown immediate操作導致資料庫異常退出
2024-07-16
資料庫
高效Java：丟擲適合抽象的異常 - Kyle Carter
2021-08-25
Java抽象
Spring Boot實戰系列(4)統一異常處理
2019-03-04
Spring Boot
【Spring Cloud】Feign呼叫異常觸發降級後如何捕獲異常
2023-01-31
SpringCloud
前端如何防止資料被異常篡改並且復原資料
2023-11-08
前端
SpringMVC學習系列（10）之異常處理
2020-11-27
SpringMVC