이 글은 배민 기술이사 김영한 이사님의 인프런 강의 "스프링 DB 2편 - 데이터 접근 활용 기술" 을 기반으로 작성되었습니다. 문제 시 삭제 조치하겠습니다.
아래와 같은 순서로 공부를 진행합니다.
- 스프링 트랜잭션 소개
- 트랜잭션 적용 확인
- 트랜잭션 적용 위치
앞서 “스프링 문제 해결 - 트랜잭션” 을 통해서 스프링이 제공하는 트랜잭션 기능이 왜 필요하고 어떻게 동작하는지 내부 원리를 알아보았습니다.
https://sh1mj1-log.tistory.com/94
https://sh1mj1-log.tistory.com/95
이번에는 스프링 트랜잭션을 더 깊이있게 학습하고, 또 스프링 트랜잭션이 제공하는 다양한 기능들을 자세히 알아봅시다.
먼저 본격적인 기능 설명 이전에 이전에 학습한 내용을 복습해봅시다.
1. 스프링 트랜잭션 소개
스프링 트랜잭션 추상화
각각의 데이터 접근 기술들은 트랜잭션을 처리하는 방식에 차이가 있습니다. 예를 들어 JDBC 기술과 JPA 기술은 트랜잭션을 사용하는 코드 자체가 다릅니다.
JDBC 트랜잭션 코드 예시
public void accountTransfer(String fromId, String toId, int money) throws SQLException {
Connection con = dataSource.getConnection();
try {
con.setAutoCommit(false); //트랜잭션 시작
//비즈니스 로직
bizLogic(con, fromId, toId, money);
con.commit(); //성공시 커밋
} catch (Exception e) {
con.rollback(); //실패시 롤백
throw new IllegalStateException(e);
} finally {
release(con);
}
}
JPA 트랜잭션 코드 예시
public static void main(String[] args) {
//엔티티 매니저 팩토리 생성
EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpabook");
EntityManager em = emf.createEntityManager(); //엔티티 매니저 생성
EntityTransaction tx = em.getTransaction(); //트랜잭션 기능 획득
try {
tx.begin(); //트랜잭션 시작
logic(em); //비즈니스 로직
tx.commit();//트랜잭션 커밋
} catch (Exception e) {
tx.rollback(); //트랜잭션 롤백
} finally {
em.close(); //엔티티 매니저 종료
}
emf.close(); //엔티티 매니저 팩토리 종료
}따라서 JDBC 기술을 사용하다가 JPA 기술로 변경하게 되면 트랜잭션을 사용하는 코드도 모두 함께 변경해야 합니다.
스프링은 이런 문제를 해결하기 위해 트랜잭션 추상화를 제공합니다. 트랜잭션을 사용하는 입장에서는 스프링 트랜잭션 추상화를 통해 둘을 동일한 방식으로 사용할 수 있습니다.
스프링은 PlatformTransactionManager라는 인터페이스를 통해 트랜잭션을 추상화합니다.
PlatformTransactionManager 인터페이스
package org.springframework.transaction;
public interface PlatformTransactionManager extends TransactionManager {
TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;
void commit(TransactionStatus status) throws TransactionException;
void rollback(TransactionStatus status) throws TransactionException;
}트랜잭션은 트랜잭션 시작(획득), 커밋, 롤백으로 단순하게 추상화 할 수 있습니다.
스프링은 트랜잭션을 추상화해서 제공할 뿐만 아니라, 실무에서 주로 사용하는 데이터 접근 기술에 대한 트랜잭션 매니저의 구현체도 제공합니다. 개발자는 필요한 구현체를 스프링 빈으로 등록하고 주입 받아서 사용하기만 하면 됩니다.
여기에 더해서 스프링 부트는 어떤 데이터 접근 기술을 사용하는지를 자동으로 인식해서 적절한 트랜잭션 매니저를 선택해서 스프링 빈으로 등록해주기 때문에 트랜잭션 매니저를 선택하고 등록하는 과정도 생략할 수 있습니다.
예를 들어서 JdbcTemplate, MyBatis를 사용하면 DataSourceTransactionManager(JdbcTransactionManager)를 스프링 빈으로 등록하고, JPA를 사용하면 JpaTransactionManager를 스프링 빈으로 등록해었습니다.
참고 - 스프링 5.3부터는 JDBC 트랜잭션을 관리할 때 DataSourceTransactionManager를 상속받아서 약간의 기능을 확장한 JdbcTransactionManager를 제공합니다. (둘의 기능 차이는 크지 않으므로 같은 것으로 이해하면 됨)
스프링 트랜잭션 사용 방식
PlatformTransactionManager를 사용하는 방법은 크게 2가지가 있습니다.
선언적 트랜잭션 관리 vs 프로그래밍 방식 트랜잭션 관리
선언적 트랜잭션 관리(Declarative Transaction Management)
@Transactional애노테이션 하나만 선언해서 매우 편리하게 트랜잭션을 적용하는 것을 선언적 트랜잭션 관리라 합니다.- 선언적 트랜잭션 관리는 과거 XML에 설정하기도 했습니다.
- 이름 그대로 해당 로직에 트랜잭션을 적용하겠다 라고 어딘가에 선언하기만 하면 트랜잭션이 적용되는 방식입니다.
프로그래밍 방식의 트랜잭션 관리(programmatic transaction management)
- 트랜잭션 매니저 또는 트랜잭션 템플릿 등을 사용해서 트랜잭션 관련 코드를 직접 작성하는 것을 프로그래밍 방식의 트랜잭션 관리라고 합니다.
프로그래밍 방식의 트랜잭션 관리를 사용하게 되면, 애플리케이션 코드가 트랜잭션이라는 기술 코드와 강하게 결합됩니다.
선언적 트랜잭션 관리가 프로그래밍 방식에 비해서 훨씬 간편하고 실용적이기 때문에 실무에서는 대부분 선언적 트랜잭션 관리를 사용합니다.
선언적 트랜잭션과 AOP
@Transactional을 통한 선언적 트랜잭션 관리 방식을 사용하게 되면 기본적으로 프록시 방식의 AOP가 적용됩니다.
프록시 도입 전
트랜잭션을 처리하기 위한 프록시를 도입하기 전에는 서비스의 로직에서 트랜잭션을 직접 시작했습니다.
프록시 도입 전 서비스 계층의 트랜잭션 사용 코드 예시
//트랜잭션 시작
TransactionStatus status =
transactionManager.getTransaction(new DefaultTransactionDefinition());
try {
//비즈니스 로직
bizLogic(fromId, toId, money);
transactionManager.commit(status); //성공시 커밋
} catch (Exception e) {
transactionManager.rollback(status); //실패시 롤백
throw new IllegalStateException(e);
}
프록시 도입 후
트랜잭션을 처리하기 위한 프록시를 적용하면 트랜잭션을 처리하는 객체와 비즈니스 로직을 처리하는 서비스 객체를 명확하게 분리할 수 있습니다.
트랜잭션 프록시 코드 예시
자동으로 아래와 같은 코드가 생성됩니다.
public class TransactionProxy {
private MemberService target;
public void logic() {
//트랜잭션 시작
TransactionStatus status = transactionManager.getTransaction(..);
try {
//실제 대상 호출
target.logic();
transactionManager.commit(status); //성공시 커밋
} catch (Exception e) {
transactionManager.rollback(status); //실패시 롤백
throw new IllegalStateException(e);
}
}
}
트랜잭션 프록시 적용 후 서비스 코드 예시
@Transaction
public class Service {
public void logic() {
//트랜잭션 관련 코드 제거, 순수 비즈니스 로직만 남음
bizLogic(fromId, toId, money);
}
}- 프록시 도입 전: 서비스에 비즈니스 로직과 트랜잭션 처리 로직이 함께 섞여있는 상태
- 프록시 도입 후: 트랜잭션 프록시가 트랜잭션 처리 로직을 모두 가져갑니다. 그리고 트랜잭션을 시작한 후에 실제 서비스를 대신 호출합니다. 트랜잭션 프록시 덕분에 서비스 계층에는 순수한 비즈니즈 로직만 남길 수 있습니다.
프록시 도입 후 전체 과정
- 트랜잭션은 커넥션에
con.setAutocommit(false)를 지정하면서 시작합니다. - 같은 트랜잭션을 유지하려면 같은 데이터베이스 커넥션을 사용해야 합니다.
- 이것을 위해 스프링 내부에서는 트랜잭션 동기화 매니저가 사용됩니다.
JdbcTemplate을 포함한 대부분의 데이터 접근 기술들은 트랜잭션을 유지하기 위해 내부에서 트랜잭션 동기화 매니저를 통해 리소스(커넥션)를 동기화합니다.
스프링이 제공하는 트랜잭션 AOP
스프링의 트랜잭션은 매우 중요한 기능이고, 전세계 누구나 다 사용하는 기능입니다. 스프링은 트랜잭션 AOP를 처리하기 위한 모든 기능을 제공합니다. 스프링 부트를 사용하면 트랜잭션 AOP를 처리하기 위해 필요한 스프링 빈들도 자동으로 등록됩니다.
그렇다면 개발자는 트랜잭션 처리가 필요한 곳에 @Transactional 애노테이션만 붙여주면 됩니다. 스프링의 트랜잭션 AOP는 이 애노테이션을 인식해서 트랜잭션을 처리하는 프록시를 적용해줍니다.
@Transactional
org.springframework.transaction.annotation.Transactional
2. 트랜잭션 적용 확인
@Transactional을 통해 선언적 트랜잭션 방식을 사용하면 단순히 애노테이션 하나로 트랜잭션을 적용할 수 있습니다. 그런데 이 기능은 트랜잭션 관련 코드가 눈에 보이지 않고, AOP를 기반으로 동작하기 때문에 실제 트랜잭션이 적용되고 있는지 아닌지를 확인하기가 어렵습니다.
스프링 트랜잭션이 실제 적용되고 있는지 확인하는 방법부터 알아봅시다.
TxApplyBasicTest
@Slf4j
@SpringBootTest
public class TxBasicTest {
@Autowired
BasicService basicService;
@Test
void proxyCheck() {
//BasicService$$EnhancerBySpringCGLIB...
log.info("aop class={}", basicService.getClass());
assertThat(AopUtils.isAopProxy(basicService)).isTrue();
}
@Test
void txTest() {
basicService.tx();
basicService.nonTx();
}
@TestConfiguration
static class TxApplyBasicConfig {
@Bean
BasicService basicService() {
return new BasicService();
}
}
@Slf4j
static class BasicService {
@Transactional
public void tx() {
log.info("call tx");
boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
log.info("tx active={}", txActive);
}
public void nonTx() {
log.info("call nonTx");
boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
log.info("tx active={}", txActive);
}
}
}proxyCheck() - 실행
AopUtils.isAopProxy()
선언적 트랜잭션 방식에서 스프링 트랜잭션은 AOP를 기반으로 동작합니다.
@Transactional을 메서드나 클래스에 붙이면 해당 객체는 트랜잭션 AOP 적용의 대상이 되고, 결과적으로 실제 객체 대신에 트랜잭션을 처리해주는 프록시 객체가 스프링 빈에 등록됩니다. 그리고 주입을 받을 때도 실제 객체 대신에 프록시 객체가 주입됩니다.
클래스 이름을 출력해보면 아래처럼 프록시 클래스 이름이 출력되는 것을 확인할 수 있습니다.
aop class=class com.jdbc2.TxBasicTest$BasicService$$EnhancerBySpringCGLIB$$e9df40f2
proxyCheck() - 실행 결과
TxBasicTest : aop class=class ..$BasicService$$EnhancerBySpringCGLIB$$xxxxxx
스프링 컨테이너에 트랜잭션 프록시 등록
@Transactional 애노테이션이 특정 클래스나 메서드에 하나라도 있으면 트랜잭션 AOP는 프록시를 만들어서 스프링 컨테이너에 등록합니다.
그리고 실제 basicService 객체 대신에 프록시인 basicService$$CGLIB를 스프링 빈에 등록합니다. 프록시는 내부의 실제 basicService를 참조하고 있습니다. 여기서 핵심은 실제 객체 대신에 프록시가 스프링 컨테이너에 등록되었다는 점입니다.
클라이언트인 txBasicTest는 스프링 컨테이너에 의존관계 주입을 요청합니다. 아래 코드로 말이죠.
@Autowired
BasicService basicService;스프링 컨테이너에는 실제 객체 대신에 프록시가 스프링 빈으로 등록되어 있기 때문에 프록시를 주입합니다.
프록시는 BasicService를 상속해서 만들어지기 때문에 다형성을 활용할 수 있습니다. 따라서 BasicService 대신에 프록시인 BasicService$$CGLIB 를 주입할 수 있습니다.
트랜잭션 프록시 동작 방식
클라이언트가 주입 받은 basicService$$CGLIB는 트랜잭션을 적용 대상인 프록시입니다.
txTest() 실행
실행하기 전에 먼저 다음 로그를 추가합니다.
application.properties
logging.level.org.springframework.transaction.interceptor=TRACE
이 로그를 추가하면 트랜잭션 프록시가 호출하는 트랜잭션의 시작과 종료를 명확하게 로그로 확인할 수 있습니다.
basicService.tx() 호출
클라이언트가 basicService.tx()를 호출하면, 프록시의 tx()가 호출됩니다. 여기서 프록시는 tx() 메서드가 트랜잭션을 사용할 수 있는지 확인합니다. tx() 메서드에는 @Transactional이 붙어있으므로 트랜잭션 적용 대상이 됩니다.
따라서 트랜잭션을 시작한 다음에 실제 basicService.tx()를 호출합니다.
그리고 실제 basicService.tx()의 호출이 끝나서 프록시로 제어가(리턴) 돌아오면 프록시는 트랜잭션 로직을 커밋하거나 롤백해서 트랜잭션을 종료시킵니다.
basicService.nonTx() 호출
클라이언트가 basicService.nonTx()를 호출하면, 트랜잭션 프록시의 nonTx()가 호출됩니다. 여기서 nonTx() 메서드가 트랜잭션을 사용할 수 있는지 확인합니다. nonTx()에는 @Transactional이 없으므로 적용 대상이 아닙니다.
따라서 트랜잭션을 시작하지 않고 basicService.nonTx()를 호출하고 종료합니다.
현재 스레드에 트랜잭션이 적용되어 있는지 확인하는 기능이 아래 코드입니다.
TransactionSynchronizationManager.isActualTransactionActive()결과가 true면 트랜잭션이 적용되어 있는 것입니다. 트랜잭션의 적용 여부를 가장 확실하게 확인할 수 있습니다.
실행 결과
#tx() 호출
TransactionInterceptor : Getting transaction for [..BasicService.tx]
y.TxBasicTest$BasicService : call tx
y.TxBasicTest$BasicService : tx active=true
TransactionInterceptor : Completing transaction for
[..BasicService.tx]
#nonTx() 호출
y.TxBasicTest$BasicService : call nonTx
y.TxBasicTest$BasicService : tx active=false로그를 통해 tx() 호출시에는 tx active=true를 통해 트랜잭션이 적용된 것을 확인할 수 있습니다.
TransactionInterceptor 로그를 통해 트랜잭션 프록시가 트랜잭션을 시작하고 완료한 내용을 확인할 수 있습니다.
nonTx() 호출시에는 tx active=false를 통해 트랜잭션이 없는 것을 확인할 수 있습니다.
3. 트랜잭션 적용 위치
스프링에서 우선순위는 항상 더 구체적이고 자세한 것이 높은 우선순위를 가집니다.
이것만 기억하면 스프링에서 발생하는 대부분의 우선순위를 쉽게 기억할 수 있습니다. 예를 들어서 메서드와 클래스에 애노테이션을 붙일 수 있다면 더 구체적인 메서드가 더 높은 우선순위를 가집니다.
인터페이스와 해당 인터페이스를 구현한 클래스에 애노테이션을 붙일 수 있다면 더 구체적인 클래스가 더 높은 우선순위를 가집니다.
TxLevelTest
@SpringBootTest
public class TxLevelTest {
@Autowired
LevelService service;
@Test
void orderTest() {
service.write();
service.read();
}
@TestConfiguration
static class TxApplyLevelConfig {
@Bean
LevelService levelService() {
return new LevelService();
}
}
@Slf4j
@Transactional(readOnly = true)
static class LevelService {
@Transactional(readOnly = false)
public void write() {
log.info("call write");
printTxInfo();
}
public void read() {
log.info("call read");
printTxInfo();
}
private void printTxInfo() {
boolean txActive = TransactionSynchronizationManager.isActualTransactionActive();
log.info("tx active={}", txActive);
boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
log.info("tx readOnly={}", readOnly);
}
}
}스프링의 @Transactional 규칙은 크게 두 가지가 있습니다.
- 우선순위 규칙
- 클래스에 적용하면 메서드는 자동 적용
우선순위
트랜잭션을 사용할 때는 다양한 옵션을 사용할 수 있습니다. 그런데 어떤 경우에는 옵션을 주고, 어떤 경우에는 옵션을 주지 않으면 어떤 것이 선택될까요?
예를 들어서 읽기 전용 트랜잭션 옵션을 사용하는 경우와 아닌 경우를 위 코드를 보면서 비교해봅시다.
LevelService의 타입에 @Transactional(readOnly = true) 이 붙어있습니다.
write(): 해당 메서드에 @Transactional(readOnly = false)이 붙어있습니다.
- 이렇게 되면 타입에 있는
@Transactional(readOnly = true)와 해당 메서드에 있는@Transactional(readOnly = false)둘 중 하나를 적용해야 합니다. - 클래스 보다는 메서드가 더 구체적이므로 메서드에 있는
@Transactional(readOnly = false)옵션을 사용한 트랜잭션이 적용됩니다.
클래스에 적용하면 메서드는 자동 적용
read(): 해당 메서드에 @Transactional이 없습니다. 이 경우 더 상위인 클래스를 확인하면 됩니다.
- 클래스에
@Transactional(readOnly = true)이 적용되어 있으므로 트랜잭션이 적용되고readOnly = true옵션을 사용합니다.
참고로 readOnly=false는 기본 옵션이기 때문에 보통 생략합니다.
@Transactional == @Transactional(readOnly=false)
현재 트랜잭션에 적용된 readOnly 옵션의 값을 반환하는 코드는 아래와 같습니다.
TransactionSynchronizationManager.isCurrentTransactionReadOnly
실행 결과
# write() 호출
TransactionInterceptor : Getting transaction for
[..LevelService.write]
y.TxLevelTest$LevelService : call write
y.TxLevelTest$LevelService : tx active=true
y.TxLevelTest$LevelService : tx readOnly=false
TransactionInterceptor : Completing transaction for
[..LevelService.write]
# read() 호출
TransactionInterceptor : Getting transaction for
[..LevelService.read]
y.TxLevelTest$LevelService : call read
y.TxLevelTest$LevelService : tx active=true
y.TxLevelTest$LevelService : tx readOnly=true
TransactionInterceptor : Completing transaction for
[..LevelService.read]write()에서는tx readOnly=false: 읽기 쓰기 트랜잭션이 적용.readOnly가 아님read()에서는tx readOnly=true: 읽기 전용 트랜잭션 옵션인readOnly가 적용
인터페이스에 @Transactional 적용
인터페이스에도 @Transactional을 적용할 수 있습니다. 이 경우 다음 순서로 적용됩니다. 똑같이 구체적인 것이 더 높은 우선순위를 가집니다!
- 클래스의 메서드 (우선순위가 가장 높음)
- 클래스의 타입
- 인터페이스의 메서드
- 인터페이스의 타입 (우선순위가 가장 낮음)
클래스의 메서드를 찾고, 만약 없으면 클래스의 타입을 찾고 만약 없으면 인터페이스의 메서드를 찾고 그래도 없으면 인터페이스의 타입을 찾습니다.
그런데 인터페이스에 @Transactional을 사용하는 것은 스프링 공식 메뉴얼에서 권장하지 않는 방법입니다.
AOP를 적용하는 방식에 따라서 인터페이스에 애노테이션을 두면 AOP가 적용이 되지 않는 경우도 있기 때문입니다. 가급적 구체 클래스에 @Transactional을 사용합시다.
참고 - 스프링은 인터페이스에 @Transactional을 사용하는 방식을 스프링 5.0에서 많은 부분 개선했다. 과거에는 구체 클래스를 기반으로 프록시를 생성하는 CGLIB 방식을 사용하면 인터페이스에 있는 @Transactional을 인식하지 못했다. 스프링 5.0 부터는 이 부분을 개선해서 인터페이스에 있는 @Transactional도 인식한다. 하지만 다른 AOP 방식에서 또 적용되지 않을 수 있으므로 공식 메뉴얼의 가이드대로 가급적 구체 클래스에 @Transactional을 사용하자.
'spring > 스프링 DB 2편' 카테고리의 다른 글
| 8. 스프링 트랜잭션 이해(3) (0) | 2023.02.23 |
|---|---|
| 8. 스프링 트랜잭션 이해(2) 주의사항, 프록시, 초기화 시점 (0) | 2023.02.23 |
| 7. 데이터 접근 기술 - 활용 방안 (JPA, JdbcTemplate, MyBatis 조합) (0) | 2023.02.23 |
| 6. 데이터 접근 기술 - Querydsl (0) | 2023.02.23 |
| 5. 스프링 데이터 JPA(2) - 적용하기 (0) | 2023.02.22 |