Spring DB 정리 2) 트랜잭션 처리 및 예외 처리

이 글은 김영한님의 스프링 DB 1편 강의중 제목과 관련된 부분을 블로그장의 취향대로 요약한 것이며 강의 자료 및 출처는 가장 아래에서 확인할 수 있습니다.

트랜잭션이란?

트랜잭션은 데이터베이스의 상태를 변화시키기 위해 수행하는 작업의 단위를 의미한다.

 

데이터를 저장할 때 단순히 파일에 저장해도 되지만, 데이터베이스에 저장하는 이유는 트랜잭션 개념을 지원하기 때문이며, 데이터베이스에서 트랜잭션은 "하나의 거래를 안전하게 처리하도록 보장해주는 것"을 뜻한다.

트랜잭션을 사용하지 않으면?

만약 A가 B에게 계좌이체를 하는 예시를 생각해보자.
A의 잔고가 5000원 감소하고, B의 잔고가 5000원 증가할것이다.

그런데 만약, A의 잔고가 5000원 감소하고 갑자기 장애가 발생한다면 B의 잔고는 증가되지않고 A의 잔고만 감소될것이다.
따라서 이럴때 트랜잭션 기능을 사용하여 거래 전의 상태로 돌아갈 수 있도록 하는것이다.

Spring 트랜잭션 처리

그렇다면 Spring에서 트랜잭션은 어떤식으로 처리되어왔는지 살펴보자.

1.파라미터로 커넥션 전달

간단하게 파라미터로 커넥션을 전달하여 커넥션이 유지되게 하여 트랜잭션을 유지하는 방법이다.

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);
        }
    }
    
 // 같은 트랜잭션을 유지하기 위해 파라미터에 커넥션을 넘겨야함
    private void bizLogic(Connection con, String fromId, String toId, int money) throws SQLException {
        Member fromMember = memberRepository.findById(con, fromId);
        Member toMember = memberRepository.findById(con, toId);
        memberRepository.update(con, fromId, fromMember.getMoney() - money);
        validation(toMember);
        memberRepository.update(con, toId, toMember.getMoney() + money);
    }
    
    ....

위는 간단하게 계좌이체를 실행하는 메서드 accountTransfer()가 있는 서비스 계층이다.

트랜잭션을 시작한 후, 비즈니스 로직에 connection 객체를 넘겨준후, 마지막에 commint하는 모습을 확인할 수 있다.

한계점

javax.sql.DataSource, java.sql.Connection, java.sql.SQLException과 같은 JDBC 기술에 의존하고 있음을 확인할 수 있으며, 비즈니스 로직과 JDBC를 사용하여 트랜잭션을 처리하는 코드가 더 많다.

 

즉, 로직과 기술이 섞여 유지보수가 어려우며 향후 JDBC에서 JPA같은 기술로 변경되면 서비스 코드를 모두 변경해야한다.( JPA는 트랜잭션을 사용하는 코드가 JDBC와 다르다 .)

 

따라서 위 문제를 해결하기 위해 스프링은 트랜잭션을 추상화한 인터페이스를 제공한다.

단순하게 생각해서 begin(), commit(), rollback() 3개의 메서드를 가진 interface를 제공한다고 생각하면 된다.

따라서 Spring이 제공하는 위 트랜잭션 매니져를 사용한다면 향후 어떤 기술이 오던지, 위 트랜잭션 매니져만 가져다 사용하면 된다.

2. 트랜잭션 매니저 사용

transantionalManager를 사용하여 트랜잭션을 처리하는 코드를 살펴보자.

...
private final PlatformTransactionManager transactionManager;
...

public void accountTransfer(String fromId, String toId, int money){
        // 트랜잭션 시작
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
        try{
            //비즈니스 로직
            bizLogic(fromId, toId, money);
            transactionManager.commit(status); //성공시 커밋
        } catch (Exception e) {
            transactionManager.rollback(status); //실패시 롤백
            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);
    }

트랜잭션 매니져는 .getTransactional()로 트랜잭션을 시작하고, commit()으로 커밋, rollback()으로 롤백하는 기능을 제공한다. 동작방식을 간략히 설명하면 아래와 같다.

 

1.트랜잭션 매니져는내부에서 데이터 소스를 사용하여 커넥션을 생성하여 트랜잭션을 시작한다.

2.트랜잭션 매니저는 트랜잭션이 시작된 커넥션을 "트랜잭션 동기화 매니저"에 보관한다.

3.리포지토리는 동기화 매니저에 보관된 커넥션을 꺼내어 사용한다. 

4.트랜잭션이 종료되면 매니저에 보관된 커넥션을 통해 트랜잭션을 종료하고, 커넥션을 닫는다.

 

이를 그림으로 표현하자면 아래와 같다.

트랜잭션 동기화 매니저는 쓰레드 로컬(ThreadLocal)을 사용하여 커넥션을 동기화하며, 쓰레드 로컬을 사용하기 때문에 멀티쓰레드 상황에 안전하게 커넥션을 동기화할 수 있다.

한계점

Connection으로부터 전파되는 SQLExpcetion이나 트랜잭션을 처리하는 코드가 줄었지만 commit()이나 rollback()과 같이 아직 트랜잭션을 처리하는 코드가 존재하고, 반복된다.

3.트랜잭션 템플릿 사용

...
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){
                /**
                 * SQLException은 체크 예외이기 때문에 트랜잭션 템플릿에서 롤백하지 않는다.
                 * 따라서 언체크 예외로 바꾸어 던진다.
                 */
                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);
    }

트랜잭션 템플릿은 템플릿 콜백 패턴을 사용한다. 

템플릿을 사용하려면 transactionManager가 필요하기 때문에, 생성자에서 매니저를 주입받으며 Template을 생성했다.

트랜잭션 템플릿은 기본적으로 언체크 예외가 발생하면 롤백하고, 그 외의 경우 커밋하기때문에 코드에서 체크 예외를 처리하기 위해 SQLException 예외를 넘겨준후, 해당 람다에서 체크 예외를 밖으로 던질 수 없기때문에 언체크 예외 (IllegalStateException)으로 변경하여 예외를 전환했다.

한계점

commit() 또는 rollback()과 같은 중복되는 코드를 제거하여 코드가 더욱 깔끔해졌지만 서비스 로직은 가급적 비즈니스 로직만 있어야 한다. 하지만 트랜잭션 기술을 사용하려면 어쩔 수 없이 트랜잭션 코드가 나와야한다. 어떻게 해결해야할까?

4.Spring AOP 사용

스프링은 AOP를 사용하여 트랜잭션을 편리하게 처리해준다.

 

AOP가 정확히 어떤것인지 자세한 정보는 추후에 자세히 살펴보고 아래에선 스프링이 제공하는 트랜잭션 AOP를 사용하면 매우 간편하게 트랜잭션 처리를 할 수있다는 점만 집중하면 된다.

 

스프링 AOP를 적용하려면 어드바이저 , 포인트컷 , 어드바이스가 필요한데 스프링 부트를 사용한다면 해당 빈들을 스프링 컨테이너에 자동으로 등록해준다.

스프링 부트 사용시 자동으로 등록되는 AOP 관련 빈
 
어드바이저: BeanFactoryTransactionAttributeSourceAdvisor
포인트컷: TransactionAttributeSourcePointcut
어드바이스: TransactionInterceptor

트랜잭션 AOP를 통해 프록시를 도입하면 아래 처럼 트랜잭션을 처리하는 객체를 분리할 수 있다.

기존에는 서비스 로직에서 직접 트랜잭션을 시작했다면

프록시를 도입하면, 트랜잭션을 처리하는 비즈니스 로직을 처리하는 서비스 객체를 명확하게 분리 것을 볼 수 있다.

 

이제 코드를 살펴보자.

...
 private final MemberRepositoryV3 memberRepository;
    
 	@Transactional
 	public void accountTransfer(String fromId, String toId, int money) throws
SQLException {
 	bizLogic(fromId, toId, money);
 }
 
 	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("이체중 예외 발생");
 }
 }

accountTransfer()메서드위에 @Transactionl 어노테이션이 추가된 것을 확인할 수 있다.

 

@Transasctional을 추가하면 스프링이 제공하는 트랜잭션 AOP를 사용할 수 있으며, @Transactional은 메서드에 붙여도 되고, 클래스에 붙여도 된다. 다만 클래스에 붙이면 외부에서 호출 가능한 public 메서드가 AOP 적용 대상이 된다. 

스프링 부트의 트랜잭션 매니저 자동 등록

트랜잭션 AOP는 스프링 빈에 등록된 트랜잭션 매니저를 찾아서 사용하기 때문에 매니저가 빈으로 등록되어 있어야한다.
스프링 부트를 사용한다면 현재 등록된 라이브러리를 보고 판단하여, JDBC를 사용하면 DataSourceTransactionManager를 빈으로 등록하고, JPA를 사용하면 JpaTransactionManager를 빈으로 등록한다.

만약 둘다 사용하는경우, JpaTransactionManager를 등록하는데 JpaTransactionManager는
DataSourceTransactionManager가 제공하는 기능을 대부분 지원하기 때문이다.

트랜잭션 AOP가 사용된 전체 흐름을 그림으로 정리하면 아래와 같다.

이제 비즈니스 로직과 데이터 접근 로직을 완벽하게 분리하였다. 마지막 한가지 문제점인 예외 처리가 남았다.

한계점

AOP 프록시를 적용하여 비즈니스 로직을 완벽하게 분리하였지만, throw SQLException과 같이 JDBC 기술에 종송적인 인터페이스가 남아있다. SQLException은 체크 예외이기 때문에, 계속해서 예외를 던져줘야 한다.

5. 체크 예외를 RuntimeException 예외(언체크 예외)로 변경

먼저 Java의 예외 구조는 아래와 같다.

SQLException과 같은 체크 예외는 예외를 잡아서 항상 throws에 던지는 예외를 선언해야하는 것과 달리, RuntimeException 예외는 언체크 예외로, 예외를 잡아서 처리하지 않아도 throws를 생략할 수 있다.

참고로 자바는 Exception을 상속하면 체크 예외로, RuntimeException을 상속하면 언체크 예외로 설정된다.

 

따라서 체크 예외를 언체크 예외로 변환한뒤, 서비스 계층으로 던지면 서비스 계층은 해당 예외를 무시할 수 있기때문에, 의존되는 부분을 제거할 수 있다.

 

예외 변환전에, 순수한 Repository 인터페이스를 도입하여 추후에 구현 기술을 쉽게 변경할 수 있도록 한다.

public interface MemberRepository {
    Member save(Member save);
    Member findById(String memberId);
    void update(String memberId, int money);
    void delete(String memberId);
}

위 인터페이스를 도입하면 어떻게 될까?

위와 같이 추후 구현 기술을 변경하고 싶을때, DI를 사용하여 코드의 변경 없이 기술을 변경할 수 있다.

 

이제 체크 예외를 언체크 예외로 변경해본다.

먼저, RuntimeException을 상속받는 언체크 예외클래스를 생성한다.

public class MyDbException extends RuntimeException {
 public MyDbException() {
 }
 public MyDbException(String message) {
 super(message);
 }
 public MyDbException(String message, Throwable cause) {
 super(message, cause);
 }
 public MyDbException(Throwable cause) {
 super(cause);
 }
}

이제 위 Exception을 Repository에 적용해준다.

public class MemberRepositoryV4_1 implements MemberRepository{

    private final DataSource dataSource;

    public MemberRepositoryV4_1(DataSource dataSource){
        this.dataSource = dataSource;
    }

	...

    @Override
    public Member findById(String memberId) {
        String sql = "select * from member where member_id = ?";
        Connection con = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            pstmt = con.prepareStatement(sql);
            pstmt.setString(1, memberId);
            rs = pstmt.executeQuery();
            if (rs.next()) {
                Member member = new Member();
                member.setMemberId(rs.getString("member_id"));
                member.setMoney(rs.getInt("money"));
                return member;
            } else {
                throw new NoSuchElementException("member not found memberId=" +
                        memberId);
            }
        } catch (SQLException e) {
            throw new MyDbException(e);
        } finally {
            close(con, pstmt, rs);
        }
    }
    ...

SQLException을 MyDbException으로 변경하였다. 이제 언체크예외를 서비스에서 사용하게 되므로, 서비스 계층에서는 Exception을 throw할 필요가 없어졌다.

public class MemberServiceV4 {

    private final MemberRepository memberRepository;

    @Transactional
    public void accountTransfer(String fromId, String toId, int money){
        bizLogic(fromId, toId, money);
    }

    private void bizLogic(String fromId, String toId, int money){
        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("이체중 예외 발생");
        }
    }


}

이제 정말 순수한 서비스 계층을 완성하였다. 이로 인해 추후 JDBC에서 다른 구현 기술로 변경하더라도 서비스 계층의 코드를 변경할 필요가 없어졌다.

추가 - JDBC 반복 문제 해결 (JdbcTemplate 사용)

위에서 트랜잭션 처리와 계층 종속성 제거가 끝났으므로 마지막으로 Repository에서 아래와 같은 코드의 반복을 제거해보도록 한다.

@Slf4j
public class MemberRepositoryV4_2 implements MemberRepository{

    private final DataSource dataSource;
    private final SQLExceptionTranslator exTranslator; // 추가

    public MemberRepositoryV4_2(DataSource dataSource){
        this.dataSource = dataSource;
        this.exTranslator = new SQLErrorCodeSQLExceptionTranslator(dataSource);
    }

    @Override
    public Member save(Member member) {
        String sql = "insert into member(member_id, money) values(?, ?)";

        Connection con = null;
        PreparedStatement pstmt = null;

        try{
            con = getConnection();
            pstmt = con.prepareStatement(sql);
            pstmt.setString(1, member.getMemberId());
            pstmt.setInt(2, member.getMoney());
            return member;
        }catch (SQLException e){
            throw exTranslator.translate("save", sql, e);
        } finally {
            close(con, pstmt, null);
        }
    }

    @Override
    public Member findById(String memberId) {
        String sql = "select * from member where member_id = ?";
        Connection con = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            pstmt = con.prepareStatement(sql);
            pstmt.setString(1, memberId);
            rs = pstmt.executeQuery();
            if (rs.next()) {
                Member member = new Member();
                member.setMemberId(rs.getString("member_id"));
                member.setMoney(rs.getInt("money"));
                return member;
            } else {
                throw new NoSuchElementException("member not found memberId=" + memberId);
            }
        } catch (SQLException e) {
            throw exTranslator.translate("findById", sql, e);
        } finally {
            close(con, pstmt, rs);
        }
    }

save()와 findById()에서 알 수 있듯이, JDBC 반복 코드가 많은 것을 확인할 수 있다.

커넥션 조회 및 동기화 ,PreparedStatement 생성 및 파라미터 바인딩 , 쿼리 실행, 결과 바인딩..등등 상당히 많은 부분이 반복된다. 따라서 이를 효과적으로 처리할 수 있게 템플릿 콜백 패턴을 적용한다.

/**
 * JdbcTemplate 사용
 */
@Slf4j
public class MemberRepositoryV5 implements MemberRepository {
   private final JdbcTemplate template;
   
   public MemberRepositoryV5(DataSource dataSource) {
   template = new JdbcTemplate(dataSource);
 }
   @Override
   public Member save(Member member) {
   String sql = "insert into member(member_id, money) values(?, ?)";
   template.update(sql, member.getMemberId(), member.getMoney());
   return member;
 }
 
   @Override
   public Member findById(String memberId) {
   String sql = "select * from member where member_id = ?";
   return template.queryForObject(sql, memberRowMapper(), memberId);
 }

템플릿 콜백 패턴에 대해서는 추후에 자세히 다룰 예정이며, 스프링이 JdbcTemplate이라는 편리한 기능을 제공하는 정도로 이해하면 된다.

 

* 출처 자료

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-db-1

스프링 DB 1편 - 데이터 접근 핵심 원리 강의 - 인프런