트랜잭션

트랜잭션 커넥션 맺는 과정

One Session for Each Connection 각각의 커넥션마다 세션이 만들어진 모습

Two Sessions in One Connection

1. 사용자는 데이터베이스에 접근할 수 있다. 이때 사용자는 데이터베이스 서버에 연결을 요청하고 커넥션을 맺게 된다.
2. 데이터베이스 서버는 내부적으로 세션을 만든다.
3. 그리고 커넥션을 통한 모든 요청은 이 세션을 통해 실행하게 된다.
4. 세션은 트랜잭션을 시작하고, 커밋 또는 롤백을 통해 트랜잭션을 종료한다.
5. 사용자가 커넥션을 닫거나 DBA가 세션을 강제로 종료하면 세션이 종료된다.

 

참고

• DataSource의 getConnection을 통해 가져온 커넥션은 기본적으로 autoCommit 모드로 동작한다.
• 하지만 autoCommit 모드로 동작하면 쿼리를 하나 실행할때마다 바로 바로 커밋이 되어 버려 트랜잭션이 사실상 없는 것과 마찬가지이다.
• 그래서 자바에서는 자동 커밋 모드에서 수동 커밋 모드로 전환 하는 것을 트랜잭션을 시작한다고 표현한다
• 중요 : 같은 DB 세션을 사용하기 위해선 자바에서 트랜잭션을 사용하는 동안 같은 커넥션을 유지해야한다.

 

커넥션과 세션 차이
Connections and Sessions A connection is a physical communication pathway between a client process and a database instance. A communication pathway is established using available interprocess communication mechanisms or network software. Typically, a connection occurs between a client process and a server process or dispatcher, but it can also occur between a client process and Oracle Connection Manager (CMAN). A session is a logical entity in the database instance memory that represents the state of a current user login to a database. For example, when a user is authenticated by the database with a password, a session is established for this user. A session lasts from the time the user is authenticated by the database until the time the user disconnects or exits the database application. A single connection can have 0, 1, or more sessions established on it. The sessions are independent: a commit in one session does not affect transactions in other sessions. Note: If Oracle Net connection pooling is configured, then it is possible for a connection to drop but leave the sessions intact. Multiple sessions can exist concurrently for a single database user. As shown in Figure 15-2, user hr can have multiple connections to a database. In dedicated server connections, the database creates a server process on behalf of each connection. Only the client process that causes the dedicated server to be created uses it. In a shared server connection, many client processes access a single shared server


Connection은 클라이언트 프로세스와 데이터베이스 인스턴스 간의 물리적 통신 경로입니다. 통신 경로는 사용 가능한 프로세스 간 통신 메커니즘 또는 네트워크 소프트웨어를 사용하여 설정됩니다.
일반적으로 Connection은 클라이언트 프로세스와 서버 프로세스 또는 디스패처 간에 발생하지만 클라이언트 프로세스와 Oracle Connection Manager (CMAN) 간에도 발생할 수 있습니다.

세션은 데이터베이스 인스턴스 메모리에서 현재 사용자 로그인의 상태를 나타내는 논리적 엔터티입니다. 예를 들어, 데이터베이스에서 사용자가 비밀번호로 인증되면 이 사용자에 대해 세션이 설정됩니다.
세션은 사용자가 데이터베이스에서 로그인한 시간부터 사용자가 연결을 종료하거나 데이터베이스 응용 프로그램을 종료할 때까지 지속됩니다.
하나의 연결에는 0, 1개 이상의 세션이 설정될 수 있습니다. 세션은 독립적입니다. 한 세션에서의 커밋은 다른 세션의 트랜잭션에 영향을 미치지 않습니다.

참고:
만약 Oracle Net 연결 풀링이 구성되어 있다면, 연결은 끊어질 수 있지만 세션은 그대로 유지될 수 있습니다. 단일 데이터베이스 사용자에 대해 여러 세션이 동시에 존재할 수 있습니다. 그림 15-2에서 나타난 것처럼, 사용자 hr은 데이터베이스에 대해 여러 연결을 가질 수 있습니다. 전용 서버 연결에서는 데이터베이스가 각 연결을 위해 서버 프로세스를 생성합니다. 서버를 생성한 클라이언트 프로세스만 해당 서버를 사용합니다. 공유 서버 연결에서는 여러 클라이언트 프로세스가 단일 공유 서버 프로세스에 액세스합니다.

---

같은 커넥션을 유지하는 방법

• 가장 간단한 방법 : 파라미터로 들고 다닌다.
• 커넥션을 변수에 넣고 공유한다.

TransactionManager를 상속하고 있다,

트랜잭션 추상화

• 트랜잭션 동기화 문제 해결
• 예외 누수 (JDBC 구현 기술 예외가 서비스 계층으로 전파)
• 트랜잭션 적용 반복 문제 (try, catch, finally의 무한반복)
• 이런 문제들을 추상화를 통해 해결했다.
• 스프링 : PlatformTransactionManager (TransactionManager)
  • 메서드
    • getTransaction
    • commit
    • rollback
  • 트랜잭션 매니저는 내부적으로 트랜잭션 동기화 매니저를 사용한다.
  • 트랜잭션 동기화 매니저는 쓰레드 로컬을 사용해서 커넥션을 동기화해준다. (매번 비즈니스 로직마다 들고다니지 않아도 된다)

// TransactionManager
if (txObject.isNewConnectionHolder()) {
    TransactionSynchronizationManager.bindResource(this.obtainDataSource(), txObject.getConnectionHolder());
}

// 추상 클래스로 객체 생성 불가능
public abstract class TransactionSynchronizationManager {
	// 내부적으로 ThreadLocal로 multi thread safe하게 저장하고 있다,
    private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal("Transactional resources");
    private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations = new NamedThreadLocal("Transaction synchronizations");
    private static final ThreadLocal<String> currentTransactionName = new NamedThreadLocal("Current transaction name");
    private static final ThreadLocal<Boolean> currentTransactionReadOnly = new NamedThreadLocal("Current transaction read-only status");
    private static final ThreadLocal<Integer> currentTransactionIsolationLevel = new NamedThreadLocal("Current transaction isolation level");
    private static final ThreadLocal<Boolean> actualTransactionActive = new NamedThreadLocal("Actual transaction active");

   
    @Nullable
    private static Object doGetResource(Object actualKey) {
        Map<Object, Object> map = (Map)resources.get();
        if (map == null) {
            return null;
        } else {
            Object value = map.get(actualKey);
            if (value instanceof ResourceHolder) {
                ResourceHolder resourceHolder = (ResourceHolder)value;
                if (resourceHolder.isVoid()) {
                    map.remove(actualKey);
                    if (map.isEmpty()) {
                        resources.remove();
                    }

                    value = null;
                }
            }

            return value;
        }
    }

    public static void bindResource(Object key, Object value) throws IllegalStateException {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Assert.notNull(value, "Value must not be null");
        Map<Object, Object> map = (Map)resources.get();
        if (map == null) {
            map = new HashMap();
            resources.set(map);
        }

        Object oldValue = ((Map)map).put(actualKey, value);
        if (oldValue instanceof ResourceHolder resourceHolder) {
            if (resourceHolder.isVoid()) {
                oldValue = null;
            }
        }

        if (oldValue != null) {
            throw new IllegalStateException("Already value [" + oldValue + "] for key [" + actualKey + "] bound to thread");
        }
    }

}

명시적으로 트랜잭션 구현 방법

1. transactionManager.getTransaction()을 호출해 트랜잭션을 시작한다.
   1. 트랜잭션을 시작하려면 데이터베이스 커넥션이 필요하다. 내부적으로 DataSource를 이용해 커넥션을 생성한다.
   2. 커넥션을 수동 커밋 모드로 변경한다.
   3. 커넥션을 트랜잭션 동기화 매니저에 보관한다.
   4. 트랜잭션 동기화 매니저는 쓰레드 로컬에 커넥션을 보관한다.
2. SQL 수행 시 DataSourceUtils.getConnection을 사용해서 트랜잭션 동기화 매니저에 보관된 커넥션을 꺼내 사용한다.
3. 비즈니스 로직이 끝나면 트랜잭션 동기화 매니저로부터 커넥션을 얻어 트랜잭션을 종료한다. (커밋 or 롤백)
   1. 리소스를 정리한다
   2. 트랜잭션 동기화 매니저를 정리한다.
   3. 오토 커밋 모드로 변경한다 (커넥션 풀 고려)
   4. 커넥션을 반환한다.

 

관련 코드

상세 로직을 전부 보지 못해서 정확한 위치가 아닐 수 있습니다. 참고만 부탁 드립니다.

// 1. 서비스 계층에서 getTransaction을 호출해 트랜잭션을 시작한다.

// AbstractPlatformTransactionManager
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
    TransactionDefinition def = definition != null ? definition : TransactionDefinition.withDefaults();
    
    // 2. 커넥션을 시작한다. (내부적으로 doBegin에서 획득)
    Object transaction = this.doGetTransaction();
    boolean debugEnabled = this.logger.isDebugEnabled();
    if (this.isExistingTransaction(transaction)) {
        return this.handleExistingTransaction(def, transaction, debugEnabled);
    } else if (def.getTimeout() < -1) {
        throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
    } else if (def.getPropagationBehavior() == 2) {
        throw new IllegalTransactionStateException("No existing transaction found for transaction marked with propagation 'mandatory'");
    } else if (def.getPropagationBehavior() != 0 && def.getPropagationBehavior() != 3 && def.getPropagationBehavior() != 6) {
        if (def.getIsolationLevel() != -1 && this.logger.isWarnEnabled()) {
            this.logger.warn("Custom isolation level specified but no actual transaction initiated; isolation level will effectively be ignored: " + def);
        }

        boolean newSynchronization = this.getTransactionSynchronization() == 0;
        return this.prepareTransactionStatus(def, (Object)null, true, newSynchronization, debugEnabled, (Object)null);
    } else {
        SuspendedResourcesHolder suspendedResources = this.suspend((Object)null);
        if (debugEnabled) {
            Log var10000 = this.logger;
            String var10001 = def.getName();
            var10000.debug("Creating new transaction with name [" + var10001 + "]: " + def);
        }

        try {
            return this.startTransaction(def, transaction, false, debugEnabled, suspendedResources);
        } catch (Error | RuntimeException var7) {
            this.resume((Object)null, suspendedResources);
            throw var7;
        }
    }
}


// 2. 커넥션을 시작한다. (내부적으로 doBegin에서 획득)
protected void doBegin(Object transaction, TransactionDefinition definition) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject)transaction;
    Connection con = null;

    try {
        if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
            Connection newCon = this.obtainDataSource().getConnection();
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
            }

            txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
        }

        txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
        con = txObject.getConnectionHolder().getConnection();
        Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
        txObject.setPreviousIsolationLevel(previousIsolationLevel);
        txObject.setReadOnly(definition.isReadOnly());
        if (con.getAutoCommit()) {
            txObject.setMustRestoreAutoCommit(true);
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
            }
			// 3. 커넥션을 수동 커밋 모드로 변경한다.
            con.setAutoCommit(false);
        }

        this.prepareTransactionalConnection(con, definition);
        txObject.getConnectionHolder().setTransactionActive(true);
        int timeout = this.determineTimeout(definition);
        if (timeout != -1) {
            txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
        }

        if (txObject.isNewConnectionHolder()) {
        	// 4.커넥션을 트랜잭션 동기화 매니저에 보관한다.
            TransactionSynchronizationManager.bindResource(this.obtainDataSource(), txObject.getConnectionHolder());
        }

    } catch (Throwable var7) {
        if (txObject.isNewConnectionHolder()) {
            DataSourceUtils.releaseConnection(con, this.obtainDataSource());
            txObject.setConnectionHolder((ConnectionHolder)null, false);
        }

        throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", var7);
    }
}

// DataSourceUtils.getConnection()
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
    Assert.notNull(dataSource, "No DataSource specified");\
    
    // TransactionSynchronizationManager 트랜잭션동기화 매니저에서 커넥션을 가져온다
    ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(dataSource);
    if (conHolder == null || !conHolder.hasConnection() && !conHolder.isSynchronizedWithTransaction()) {
        logger.debug("Fetching JDBC Connection from DataSource");
        Connection con = fetchConnection(dataSource);
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            try {
                ConnectionHolder holderToUse = conHolder;
                if (conHolder == null) {
                    holderToUse = new ConnectionHolder(con);
                } else {
                    conHolder.setConnection(con);
                }

                holderToUse.requested();
                TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(holderToUse, dataSource));
                holderToUse.setSynchronizedWithTransaction(true);
                if (holderToUse != conHolder) {
                    TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
                }
            } catch (RuntimeException var4) {
                releaseConnection(con, dataSource);
                throw var4;
            }
        }

        return con;
    } else {
        conHolder.requested();
        if (!conHolder.hasConnection()) {
            logger.debug("Fetching resumed JDBC Connection from DataSource");
            conHolder.setConnection(fetchConnection(dataSource));
        }

        return conHolder.getConnection();
    }
}

 

TransactionalTemplate

public <T> T execute(TransactionCallback<T> action) throws TransactionException {
    if (this.transactionManager instanceof CallbackPreferringPlatformTransactionManager) {
        return ((CallbackPreferringPlatformTransactionManager)this.transactionManager).execute(this, action);
    } else {
        TransactionStatus status = this.transactionManager.getTransaction(this);

        Object result;
        try {
            result = action.doInTransaction(status);
        } catch (RuntimeException var5) {
            this.rollbackOnException(status, var5);
            throw var5;
        } catch (Error var6) {
            this.rollbackOnException(status, var6);
            throw var6;
        } catch (Exception var7) {
            this.rollbackOnException(status, var7);
            throw new UndeclaredThrowableException(var7, "TransactionCallback threw undeclared checked exception");
        }

        this.transactionManager.commit(status);
        return result;
    }
}

 

PlatformTransactionManager을 통해 명시적으로(프로그래밍 방식) 트랜잭션 처리를 해도 되지만, 좀 더 편리한 방법이 존재한다.

• 프록시 객체를 사용해 비즈니스 로직과 분리할 수 있는 방법
• 스프링이 템플릿 콜백 패턴을 이용해 만든 트랜잭션 프록시 객체
• UnChecked Exception이 발생하면 롤백하고, 그 이외에는 커밋한다.
• 선언적  방법 : @Transactional 어노테이션이 붙은 메서드를 기반으로 프록시 로직을 붙인다.
  • 어드바이저: BeanFactoryTransactionAttributeSourceAdvisor
  • 포인트컷: TransactionAttributeSourcePointcut
  • 어드바이스: TransactionInterceptor

 

SQL 에러 변환기

• SQLExceptionTranslator
• DB별로 에러코드를 미리 지정해놓고, 각 에러코드 유형마다 String[]로 저장해놓는다.
• 내부에서 BinarySearch 알고리즘으로 조회한다.

if (Arrays.binarySearch(sqlErrorCodes.getBadSqlGrammarCodes(), errorCode) >= 0) {
    this.logTranslation(task, sql, sqlEx, false);
    return new BadSqlGrammarException(task, sql != null ? sql : "", sqlEx);
}

if (Arrays.binarySearch(sqlErrorCodes.getInvalidResultSetAccessCodes(), errorCode) >= 0) {
    this.logTranslation(task, sql, sqlEx, false);
    return new InvalidResultSetAccessException(task, sql != null ? sql : "", sqlEx);
}

if (Arrays.binarySearch(sqlErrorCodes.getDuplicateKeyCodes(), errorCode) >= 0) {
    this.logTranslation(task, sql, sqlEx, false);
    return new DuplicateKeyException(this.buildMessage(task, sql, sqlEx), sqlEx);
}

if (Arrays.binarySearch(sqlErrorCodes.getDataIntegrityViolationCodes(), errorCode) >= 0) {
    this.logTranslation(task, sql, sqlEx, false);
    return new DataIntegrityViolationException(this.buildMessage(task, sql, sqlEx), sqlEx);
}

if (Arrays.binarySearch(sqlErrorCodes.getPermissionDeniedCodes(), errorCode) >= 0) {
    this.logTranslation(task, sql, sqlEx, false);
    return new PermissionDeniedDataAccessException(this.buildMessage(task, sql, sqlEx), sqlEx);
}

if (Arrays.binarySearch(sqlErrorCodes.getDataAccessResourceFailureCodes(), errorCode) >= 0) {
    this.logTranslation(task, sql, sqlEx, false);
    return new DataAccessResourceFailureException(this.buildMessage(task, sql, sqlEx), sqlEx);
}

if (Arrays.binarySearch(sqlErrorCodes.getTransientDataAccessResourceCodes(), errorCode) >= 0) {
    this.logTranslation(task, sql, sqlEx, false);
    return new TransientDataAccessResourceException(this.buildMessage(task, sql, sqlEx), sqlEx);
}

if (Arrays.binarySearch(sqlErrorCodes.getCannotAcquireLockCodes(), errorCode) >= 0) {
    this.logTranslation(task, sql, sqlEx, false);
    return new CannotAcquireLockException(this.buildMessage(task, sql, sqlEx), sqlEx);
}

if (Arrays.binarySearch(sqlErrorCodes.getDeadlockLoserCodes(), errorCode) >= 0) {
    this.logTranslation(task, sql, sqlEx, false);
    return new DeadlockLoserDataAccessException(this.buildMessage(task, sql, sqlEx), sqlEx);
}

if (Arrays.binarySearch(sqlErrorCodes.getCannotSerializeTransactionCodes(), errorCode) >= 0) {
    this.logTranslation(task, sql, sqlEx, false);
    return new CannotSerializeTransactionException(this.buildMessage(task, sql, sqlEx), sqlEx);
}

// sql-error-codes.xml
<bean id="DB2" name="Db2" class="org.springframework.jdbc.support.SQLErrorCodes">
    <property name="databaseProductName">
        <value>DB2*</value>
    </property>
    <property name="badSqlGrammarCodes">
        <value>-007,-029,-097,-104,-109,-115,-128,-199,-204,-206,-301,-408,-441,-491</value>
    </property>
    <property name="duplicateKeyCodes">
        <value>-803</value>
    </property>
    <property name="dataIntegrityViolationCodes">
        <value>-407,-530,-531,-532,-543,-544,-545,-603,-667</value>
    </property>
    <property name="dataAccessResourceFailureCodes">
        <value>-904,-971</value>
    </property>
    <property name="transientDataAccessResourceCodes">
        <value>-1035,-1218,-30080,-30081</value>
    </property>
    <property name="deadlockLoserCodes">
        <value>-911,-913</value>
    </property>
</bean>

 

트랜잭션 우선 순위

• 구체적이고 자세한 것이 더 높은 우선순위를 가진다.
• 클래스 < 메서드
• 인터페이스 < 구현 클래스

주의사항

• 프록시 내부 호출은 트랜잭션 적용 안됨.
• public 메서드에만 트랜잭션 적용 가능 (예외 발생하지는 않고 그냥 무시)
  • 참고로 부트 3.0부터는 protected, package-private도 적용됨
• @PostContruct과 동시 사용 불가 (초기화 코드가 먼저 호출 -> 트랜잭션 AOP가 적용됨)

트랜잭션 전파

• 모든 논리 트랜잭션이 커밋 되어야 물리 트랜잭션이 커밋된다.
• 하나의 논리 트랜잭션이라도 롤백되면 물리 트랜잭션은 롤백된다.

 

👍 Reference

https://docs.oracle.com/cd/E11882_01/server.112/e40540/process.htm#CNCPT1247

Process Architecture