La primavera no puede deshacer las transacciones confirmadas cuando un origen de datos error en la transacción

Estoy trabajando en una microservice, que involucra a varios orígenes de datos. En aras de simplificar, estoy usando dos fuentes de datos aquí, MySql y Oracle. Este es el pseudo-código.

    domain.withNewTransaction {
      mySql.executeUpdate("update mySqlTable")
      oracle.executeUpdate("update oracleTable")
    }

Un día hubo una excepción que se produce cuando tratando de cometer actualización de oracle, sin embargo, me encontré con mysql update es confirmado correctamente y no se deshace. Me encontré con el marco de trabajo es el uso de ChainedTransactionManager.java para la gestión de múltiples orígenes de datos que se cometen. Este es el código para el método commit.

public void commit(TransactionStatus status) throws TransactionException {

        MultiTransactionStatus multiTransactionStatus = (MultiTransactionStatus) status;

        boolean commit = true;
        Exception commitException = null;
        PlatformTransactionManager commitExceptionTransactionManager = null;

        for (PlatformTransactionManager transactionManager : reverse(transactionManagers)) {

            if (commit) {

                try {
                    multiTransactionStatus.commit(transactionManager);
                } catch (Exception ex) {
                    commit = false;
                    commitException = ex;
                    commitExceptionTransactionManager = transactionManager;
                }

            } else {

                // after unsucessfull commit we must try to rollback remaining transaction managers

                try {
                    multiTransactionStatus.rollback(transactionManager);
                } catch (Exception ex) {
                    LOGGER.warn("Rollback exception (after commit) (" + transactionManager + ") " + ex.getMessage(), ex);
                }
            }
        }

        if (multiTransactionStatus.isNewSynchonization()) {
            synchronizationManager.clearSynchronization();
        }

        if (commitException != null) {
            boolean firstTransactionManagerFailed = commitExceptionTransactionManager == getLastTransactionManager();
            int transactionState = firstTransactionManagerFailed ? HeuristicCompletionException.STATE_ROLLED_BACK
                    : HeuristicCompletionException.STATE_MIXED;
            throw new HeuristicCompletionException(transactionState, commitException);
        }
    }

Resulta que cuando uno datasource cometer error, ChainedTransactionManager sólo revertir el resto de los no comprometidos queridos, nada que ver con las transacciones comprometidas.

Entiendo que es complicado y riesgoso para revertir la transacción confirmada. Me gustaría saber para el desarrollador de la aplicación si alguna mejor idea para manejar este de múltiples orígenes de datos de confirmación de la transacción falla. Gracias de antemano!

0
2019-09-18 21:55:41
fuente
0 respuestas

Vea otras preguntas sobre etiquetas