[Spring] 트랜잭션 템플릿 (p.s 템플릿 콜백 패턴)

트랜잭션을 사용하는 코드를 보면 반복되는 패턴들이 있다.
 

 // 트랜잭션 시작
TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());

try {
    // 비즈니스 로직
    bizLogic(fromId, toId, money);
    transactionManager.commit(status); // 성공시 커밋
} catch (Exception e) {
    transactionManager.rollback(status); // 실패시 롤백
    throw new IllegalStateException(e);
}

 
트랜잭션 시작 → 비즈니스 로직 실행 → 성공 시 커밋 / 예외 발생, 실패 시 롤백
다른 서비스에서 트랜잭션을 시작하려면 try, catch, finally 를 포함하여 성공시, 실패시 코드들이 반복될 것이다
 
이런 형태는 만들게 되는 서비스에 다 반복될 것이다. 달라지는 부분은 비즈니스 로직부분만 달라진다.
이럴  때 탬플릿 콜백 패턴을 활용하면 이런 문제를 해결할 수 있다.
 

※ 여기서 템플릿 콜백 패턴이란?

템플릿 콜백 패턴 (Template Callback Pattern) 은 템플릿 메서드 패턴과 콜백 패턴을 조합한 디자인 패턴으로, 변하지 않는 흐름(템플릿)을 유지하면서, 중간에 변경 가능한 동작(콜백)을 외부에서 주입받는 방식이다.
 
------------------------------------------------ 템플릿 콜백 패턴 정리 시작 ---------------------------------------------------

✅ 개념 요약

📌 템플릿 콜백 패턴이란?

• 고정된 실행 흐름(템플릿) 안에서
• 가변적인 로직(콜백) 을 외부에서 전달받아 실행하는 패턴

탬플릿 콜백 패턴

보통 "코드의 중복을 제거하고", "공통된 처리 로직을 분리"할 때 자주 사용된다.
 

💡 예시: JDBC 작업 처리

🎯 상황

JDBC로 DB를 다룰 때, 매번 커넥션/PreparedStatement/ResultSet 을 여닫는 작업이 반복됨 → 이 반복적인 행위를 템플릿화
 
1. 전통적인 코드 (중복 많음)

public void getUser() {
    try (Connection conn = DriverManager.getConnection(...);
         PreparedStatement stmt = conn.prepareStatement("SELECT * FROM user WHERE id=?")) {

        stmt.setInt(1, 1);
        ResultSet rs = stmt.executeQuery();

        while (rs.next()) {
            System.out.println(rs.getString("name"));
        }

    } catch (SQLException e) {
        e.printStackTrace();
    }
}

 
Connection, PreparedStatement, ResultSet 처리 흐름은 항상 같고, SQL만 바뀐다.
 

2. 템플릿 콜백 패턴 적용

🔧 공통 흐름 (템플릿 클래스)

public class JdbcTemplate {
    public void execute(String sql, JdbcCallback callback) {
        try (Connection conn = DriverManager.getConnection(...);
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            callback.doInStatement(stmt);

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

 

🧩 콜백 인터페이스

@FunctionalInterface
public interface JdbcCallback {
    void doInStatement(PreparedStatement stmt) throws SQLException;
}

 

💻 사용 코드 (고객 코드)

JdbcTemplate jdbcTemplate = new JdbcTemplate();

jdbcTemplate.execute("SELECT * FROM user WHERE id=?", stmt -> {
    stmt.setInt(1, 1);
    ResultSet rs = stmt.executeQuery();
    while (rs.next()) {
        System.out.println(rs.getString("name"));
    }
});

 
이 구조 덕분에 공통된 자원 처리 흐름은 JdbcTemplate에서 담당하고,
비즈니스 로직(SQL과 파라미터 등) 은 콜백으로 분리된다.
 

✅ 템플릿 콜백 패턴의 장점

💡 중복 제거	공통 처리 흐름을 템플릿으로 빼내 코드 반복 제거
🔄 유연성	콜백으로 다양한 처리 로직을 동적으로 주입 가능
📦 재사용성	템플릿 클래스는 다양한 상황에서 재사용 가능

 

---

🎯 실제 적용 예

• Spring Framework의 JdbcTemplate, RestTemplate
• 트랜잭션 처리 패턴
• 파일 읽기/쓰기 작업에서 공통 I/O 처리

------------------------------------------------ 템플릿 콜백 패턴 정리 끝 ---------------------------------------------------
 
 

트랜잭션 템플릿

템플릿 콜백 패턴을 적용하려면 템플릿을 제공하는 클래스를 작성해야 하는데,
스프링은 TransactionTemplate 라는 템플릿 클래스를 제공한다.
 
✅ TransactionTemplate 클래스의 기본 구조
 
TransactionTemplate

public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations {
    private PlatformTransactionManager transactionManager;

    // 생성자
    public TransactionTemplate(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    // 주요 메서드
    @Override
    public <T> T execute(TransactionCallback<T> action) {
        // 트랜잭션 시작 → 콜백 실행 → 커밋 or 롤백
    }
    
    void executeWithoutResult(Consumer<TransactionStatus> action){..}
}

execute() : 응답 값이 있을 때 사용한다.
executeWithoutResult() : 응답 값이 없을 때 사용한다
 
 
🧩 주요 필드와 메서드
🔹 필드

private PlatformTransactionManager transactionManager;

실제 트랜잭션을 처리할 트랜잭션 관리자 (JDBC, JPA, Hibernate 등 구현체에 따라 다름)
 
 
🔹 생성자

public TransactionTemplate(PlatformTransactionManager transactionManager) {
    this.transactionManager = transactionManager;
}

트랜잭션 매니저를 주입받아 TransactionTemplate 객체를 생성
 
🔹 핵심 메서드: execute

@Override
public <T> T execute(TransactionCallback<T> action) throws TransactionException {
    if (this.transactionManager == null) {
        throw new IllegalStateException("No PlatformTransactionManager set");
    }

    TransactionStatus status = this.transactionManager.getTransaction(this);

    T result;
    try {
        result = action.doInTransaction(status);
    } catch (RuntimeException | Error ex) {
        this.transactionManager.rollback(status);
        throw ex;
    } catch (Throwable ex) {
        this.transactionManager.rollback(status);
        throw new UndeclaredThrowableException(ex);
    }

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

 

💡 동작 흐름 설명:

1. transactionManager.getTransaction(...) → 트랜잭션 시작
2. action.doInTransaction(...) → 트랜잭션 내에서 콜백 실행
3. 예외가 발생하면 rollback(status)
4. 정상 수행되면 commit(status)

💡 콜백 인터페이스: TransactionCallback

@FunctionalInterface
public interface TransactionCallback<T> {
    T doInTransaction(TransactionStatus status);
}

 
사용자는 이 콜백에 트랜잭션 내에서 실행할 코드를 작성한다
 

🧾 요약

TransactionTemplate	템플릿 역할을 하며, 트랜잭션 흐름을 정의
PlatformTransactionManager	실제 트랜잭션을 시작/커밋/롤백 처리
TransactionCallback	트랜잭션 내에서 실행할 사용자 정의 코드

 
트랜잭션 템플릿을 사용해서 반복하는 부분을 제거해보자.
 
MemberServiceV3_2

package hello.jdbc.service;

import hello.jdbc.domain.Member;
import hello.jdbc.repository.MemberRepositoryV3;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.transaction.support.TransactionTemplate;

import java.sql.SQLException;

/**
 * 트랜잭션 - 트랜잭션 탬플릿
 * **/

@Slf4j
@RequiredArgsConstructor
public class MemberServiceV3_2 {

    // private final PlatformTransactionManager transactionManager;
    private final TransactionTemplate txTemplate;
    private final MemberRepositoryV3 memberRepository;

    public MemberServiceV3_2(PlatformTransactionManager transactionManager, MemberRepositoryV3 memberRepository) {
        this.txTemplate = new TransactionTemplate(transactionManager);
        this.memberRepository = memberRepository;
    }

    public void accountTransfer(String fromId, String toId, int money) throws SQLException {
        txTemplate.executeWithoutResult((status) -> {
            // 비즈니스 로직
            try {
                bizLogic(fromId, toId, money);
            } catch (SQLException e) {
                throw new IllegalStateException(e);
            }
        });
    }

    private void bizLogic(String fromId, String toId, int money) throws SQLException {
        Member fromMember = memberRepository.findById(fromId);
        Member toMember = memberRepository.findById(toId);

        memberRepository.update(fromId, fromMember.getMoney() - money);
        validation(toMember);
        memberRepository.update(toId, toMember.getMoney() + money);
    }

    private void validation(Member toMember) {
        if(toMember.getMemberId().equals("ex")) {
            throw new IllegalStateException("이체중 예외 발생");
        }
    }
}

 
TransactionTemplate 을 사용하려면 transactionManager 가 필요하다.
생성자에서 transactionManager 를 주입 받으면서 TransactionTemplate 을 생성했다
 

★ 트랜잭션 템플릿 사용 로직

txTemplate.executeWithoutResult((status) -> {
    try {
        //비즈니스 로직
        bizLogic(fromId, toId, money);
    } catch (SQLException e) {
        throw new IllegalStateException(e);
    }
});

 
트랜잭션 템플릿 덕분에 트랜잭션을 시작하고, 커밋하거나 롤백하는 코드가 모두 제거되었다.
트랜잭션 템플릿의 기본 동작은 다음과 같다. 비즈니스 로직이 정상 수행되면 커밋한다.
언체크 예외가 발생하면 롤백한다.
그 외의 경우 커밋한다.
 
코드에서 예외를 처리하기 위해 try~catch 가 들어갔는데,
bizLogic() 메서드를 호출하면 SQLException 체크 예외를 넘겨준다.
해당 람다에서 체크 예외를 밖으로 던질 수 없기 때문에 언체크 예외로 바꾸어 던지도록 예외를 전환했다
 
MemberServiceV3_2Test

package hello.jdbc.service;

import hello.jdbc.domain.Member;
import hello.jdbc.repository.MemberRepositoryV3;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.PlatformTransactionManager;

import java.sql.SQLException;

import static hello.jdbc.connection.ConnectionConst.*;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

/**
 *  트랜잭션 - 트랜잭션 탬플릿
 * */
@Slf4j
class MemberServiceV3_2Test {

    public static final String Member_A = "memberA";
    public static final String Member_B = "memberB";
    public static final String Member_EX = "ex";

    private MemberRepositoryV3 memberRepository;
    private MemberServiceV3_2 memberService;

    @BeforeEach
    void before() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource(URL, USERNAME, PASSWORD);
        memberRepository = new MemberRepositoryV3(dataSource);
        PlatformTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);
        memberService = new MemberServiceV3_2(transactionManager, memberRepository);
    }

    @AfterEach
    void after() throws SQLException {
        memberRepository.delete("memberA");
        memberRepository.delete("memberB");
        memberRepository.delete("ex");
    }

    @Test
    @DisplayName("정상 이체")
    void accountTransfer() throws SQLException {
        // given
        Member memberA = new Member("memberA", 10000);
        Member memberB = new Member("memberB", 10000);
        memberRepository.save(memberA);
        memberRepository.save(memberB);

        // when
        log.info("TX START");
        memberService.accountTransfer(memberA.getMemberId(), memberB.getMemberId(), 2000);
        log.info("TX END");

        // then
        Member findMemberA = memberRepository.findById(memberA.getMemberId());
        Member findMemberB = memberRepository.findById(memberB.getMemberId());
        assertThat(findMemberA.getMoney()).isEqualTo(8000);
        assertThat(findMemberB.getMoney()).isEqualTo(12000);
    }

    @Test
    @DisplayName("이체중 예외 발생")
    void accountTransferEx() throws SQLException {
        // given
        Member memberA = new Member("memberA", 10000);
        Member memberEx = new Member("ex", 10000);
        memberRepository.save(memberA);
        memberRepository.save(memberEx);

        // when
        assertThatThrownBy(
			() -> memberService.accountTransfer(
					memberA.getMemberId(), memberEx.getMemberId(), 2000
            	  )
        ).isInstanceOf(IllegalStateException.class);

        // then
        Member findMemberA = memberRepository.findById(memberA.getMemberId());
        Member findMemberEx = memberRepository.findById(memberEx.getMemberId());

        // memberA의 돈이 롤백되어야 함
        assertThat(findMemberA.getMoney()).isEqualTo(10000);
        assertThat(findMemberEx.getMoney()).isEqualTo(10000);

    }
}

 
테스트 내용은 기존과 같다. 테스트를 실행해보면 정상 동작하고, 실패시 롤백도 잘 수행되는 것을 확인할 수 있다.
 
트랜잭션 템플릿 덕분에, 트랜잭션을 사용할 때 반복하는 코드를 제거할 수 있었다.
하지만 이곳은 서비스 로직인데 비즈니스 로직 뿐만 아니라 트랜잭션을 처리하는 기술 로직이 함께 포함되어 있다.
애플리케이션을 구성하는 로직을 핵심 기능과 부가 기능으로 구분하자면 서비스 입장에서 비즈니스 로직은 핵심 기능이고,
트랜잭션은 부가 기능이다.
이렇게 비즈니스 로직과 트랜잭션을 처리하는 기술 로직이 한 곳에 있으면 두 관심사를 하나의 클래스에서 처리하게 된다.
결과적으로 코드를 유지보수하기 어려워진다.
서비스 로직은 가급적 핵심 비즈니스 로직만 있어야 한다.
하지만 트랜잭션 기술을 사용하려면 어쩔 수 없이 트랜잭션 코드가 나와야 한다
이럴 때, 스프링 AOP를 통해 프록시를 도입하면 문제를 깔끔하게 해결할 수 있다