[스프링 DB 1편] #6. 스프링과 문제 해결 - 예외 처리, 반복

[YuDeokRin]

스프링과 문제 해결 - 예외 처리, 반복

1️⃣ 체크 예외와 인터페이스

• 서비스 계층은 가급적 특정 구현 기술에 의존하지 않고, 순수하게 유지하는 것이 좋다.
• 위와 같이 하려면 예외에 대한 의존도 함께 해결해야한다.
• 예시) 서비스가 처리할 수 없는 SQLException에 대한 경우
  • 서비스가 처리할 수 없으므로 리포지토리가 던지는 SQLException 체크 예외를 런타임 예외로 전환해서 서비스 계층에 던지면 된다.
  • 서비스 게층이 해당 예외를 무시할 수 있기 때문에, 특정 구현 기술에 의존하는 부분을 제거하고 서비스 계층을 순수하게 유지할 수 있다.

✅ 인터페이스 도입

• 인터페이스 도입 그림

• 이렇게 인터페이스를 도입하면 MemberService는 MemberRepository 인터페이스만 의존하면 된다.

• 구현 기술을 변경하고 싶으면 DI를 사용해서 MemberService코드의 변경 없이 구현 기술을 변경할 수 있다.

• MemberRepository 인터페이스

  • 특정 기술에 종속되지 않는 순수한 인터페이스

package hello.jdbc.repository;

import hello.jdbc.domain.Member;

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

• 체크 예외 코드에 인터페이스 도입시 문제점 - 인터페이스
  • 인터페이스 메서드에 throws SQLException을 붙여줘야한다.

package hello.jdbc.repository;

import hello.jdbc.domain.Member;

import java.sql.SQLException;

public interface MemberRepositoryEx {
    Member save(Member member) throws SQLException;
    Member findById(String memberId) throws SQLException;
    void update(String memberId, int money) throws SQLException;
    void delete(String memberId)throws SQLException;
}

• 체크 예외 코드에 인터페이스 도입시 문제점 - 구현 클래스
  • 인터페이스의 구현체가 체크 예외를 던질려면, 인터페이스 메서드에도 체크 예외를 던지는 부분이 선언 되어 있어야 한다.
    • MemberRepositoryV3가 throws SQLException를 하려면 MemberRepositoryEx 인터페이스에도 throws SQLException이 필요하다.
  • 참고로 구현 클래스의 메서드에 선언할 수 있는 예외는 부모 타입에서 던진 예외와 같거나 하위 타입이어야 한다.
    • 예) 인터페이스 메서드에 throws Exception를 선언하면, 구현 클래스 메서드에 throws SQLException는 가능하다.

@Slf4j
public class MemberRepositoryV3 implements MemberRepositoryEx {
     
     public Member save(Member member) throws SQLException {
         String sql = "insert into member(member_id, money) values(?, ?)";
     } 
}

✅ 특정 기술에 종속되는 인터페이스

• 구현 기술을 쉽게 변경하기 위해서 인터페이스를 도입하더라도 SQLException과 같은 특정 구현 기술에 종속적인 체크 예외를 사용하게 되면 인터페이스에도 해당 예외를 포함해야 한다. → 순수한 인터페이스가 아니다
• JDBC 기술에 종속적인 인터페이스일 뿐이다.
• 인터페이스를 만든 목적은 구현체를 쉽게 변경하기 위함인데 그 장점을 살리지 못함

2️⃣ 런타임 예외 적용

• MemberRepositroy 인터페이스

package hello.jdbc.repository;

import hello.jdbc.domain.Member;

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

• MyDbException 런타임 예외
  • RuntimeException 을 상속 → MyDbException은 런타임(언체크) 예외가 된다.

package hello.jdbc.repository.ex;

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);
    }

}

• MemberRepositoryV4_1
  • implements MemberRepositroy 인터페이스를 구현한다.
  • SQLException이라는 체크 예외를 MyDbException이라는 런타임 예외로 변환해서 던지는 부분이다.
  • @OverRide 를 붙이는 게 좋다 → 하게되면 컴파일러가 오류를 주어서 에러를 찾기가 쉬워짐

package hello.jdbc.repository;

import hello.jdbc.domain.Member;
import hello.jdbc.repository.ex.MyDbException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.jdbc.support.JdbcUtils;

import javax.sql.DataSource;
import java.sql.*;
import java.util.NoSuchElementException;

/**
 * 예외 누수 문제 해결
 * 체크 예외를 런타임 예외로 해결
 * MemberRepository 인터페이스 사용
 * throws SQLException 제거
 */
@Slf4j
public class MemberRepositoryV4_1 implements MemberRepositroy{

    private final DataSource dataSource;

    public MemberRepositoryV4_1(DataSource dataSource) {
        this.dataSource = 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());
            pstmt.executeUpdate();
            return member;
        } catch (SQLException e) {
            throw new MyDbException(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 new MyDbException(e);
        } finally {
            close(con, pstmt, rs);
        }
    }

    @Override
    public void update(String memberId, int money) {
        String sql = "update member set money = ? where member_id = ?";

        Connection con = null;
        PreparedStatement pstmt = null;

        try {
            con = getConnection();
            pstmt = con.prepareStatement(sql);
            pstmt.setInt(1, money);
            pstmt.setString(2, memberId);
            int resultSize = pstmt.executeUpdate();
            log.info("resultSize = {}", resultSize);
        } catch (SQLException e) {
            throw new MyDbException(e);
        } finally {
            close(con, pstmt, null);
        }
    }

    @Override
    public void delete(String memberId) {
        String sql = "delete from member where member_id = ?";

        Connection con = null;
        PreparedStatement pstmt = null;

        try {
            con = getConnection();
            pstmt = con.prepareStatement(sql);
            pstmt.setString(1, memberId);

            pstmt.executeUpdate();

        } catch (SQLException e) {
            throw new MyDbException(e);
        } finally {
            close(con, pstmt, null);
        }
    }

    private void close(Connection con, Statement stmt, ResultSet rs) {
        JdbcUtils.closeResultSet(rs);
        JdbcUtils.closeStatement(stmt);

        //트랜잭션 동기화를 사용하려면 DataSourceUtils를 사용해야 한다.
        DataSourceUtils.releaseConnection(con, dataSource);
    }
    private Connection getConnection() throws SQLException {
        //주의 ! 트랜잭션 동기화를 사용하려면 DataSourceUtils를 사용해야한다.
        Connection con = DataSourceUtils.getConnection(dataSource);
        log.info("get connection={}, class={}", con, con.getClass());
        return con;
    }
}

✅ 예외 변환

• 잘 보면 기존 예외를 생성자를 통해서 포함하고 있는 것을 확인할 수 있다.
• 예외는 원인이 되는 예외를 내부에 포함할 수 있는데, 꼭 이렇게 작성해야 한다.
• 그래야지 예외를 출력했을 때, 원인이 되는 기존 예외도 함께 확인할 수 있다.
• MyDbException이 내부에 SQLException을 포함하고 있다고 이해하면 된다.
  • 스택 트레이스를 통해 둘다 확인 가능

catch (SQLException e) {
     throw new MyDbException(e);
}

• MemberServiceV4
  • MemberRepository 인터페이스에 의존하도록 코드 변경
  • MemberServiceV3_3와 비교해서 보면 드디어 메서드에서 throws SQLException 부분이 제거된 것을 확인할 수 있다.

package hello.jdbc.service;

import hello.jdbc.domain.Member;
import hello.jdbc.repository.MemberRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.annotation.Transactional;

import java.sql.SQLException;

/**
 * 예외 누수 문제 해결
 * SQLException 제거
 *
 * MemberRepository 인터페이스 의존
 */
@Slf4j
public class MemberServiceV4 {

    private final MemberRepository memberRepository;

    public MemberServiceV4(MemberRepository memberRepositroy) {
        this.memberRepository = memberRepositroy;
    }

    @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 IllegalArgumentException("이체중 예외 발생");
        }
    }
}

• MemberServiceV4Test
  • MembmerRepository인터페이스를 사용하도록 했다.
  • 테스트가 모두 정상 동작 확인

package hello.jdbc.service;

import hello.jdbc.domain.Member;
import hello.jdbc.repository.MemberRepository;
import hello.jdbc.repository.MemberRepositoryV4_1;
import lombok.extern.slf4j.Slf4j;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
import static hello.jdbc.connection.ConnectionConst.*;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

@Slf4j
@SpringBootTest
public class MemberServiceV4Test {
    public static final String MEMBER_A = "memberA";
    public static final String MEMBER_B = "memberB";
    public static final String MEMBER_EX = "ex";

    @Autowired
    MemberRepository memberRepository;

    @Autowired
    MemberServiceV4 memberService;

    @AfterEach
    void after() throws SQLException {
        memberRepository.delete(MEMBER_A);
        memberRepository.delete(MEMBER_B);
        memberRepository.delete(MEMBER_EX);
    }

    @TestConfiguration
    static class TestConfig {

        private final DataSource dataSource;

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

        @Bean
        MemberRepository memberRepository() {
            return new MemberRepositoryV4_1(dataSource); //단순 예외 변환
        }

        @Bean
        MemberServiceV4 memberServiceV4() {
            return new MemberServiceV4(memberRepository());
        }
    }

    @Test
    void AopCheck() {
        log.info("memberService class={}", memberService.getClass());
        log.info("memberRepository class={}", memberRepository.getClass());
        Assertions.assertThat(AopUtils.isAopProxy(memberService)).isTrue();
        Assertions.assertThat(AopUtils.isAopProxy(memberRepository)).isFalse();
    }

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

        //when
        memberService.accountTransfer(memberA.getMemberId(), memberB.getMemberId(), 2000);

        //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() {
        //given
        Member memberA = new Member(MEMBER_A, 10000);
        Member memberEx = new Member(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);
    }
}

✅ 남은 문제

• 리포지토리에서 넘어오는 특정한 예외의 경우 복구를 시도할 수도 있다. 그런데 지금 방식은 항상 MyDbException이라는 예외만 넘어오기 때문에 예외를 구분할 수 없는 단점이 있다.
• 특정 상황에서 예외를 잡아서 복구하고 싶으면 어떻게해야할까?

3️⃣ 데이터 접근 예외 직접 만들기

• 데이터베이스 오류에 따라서 특정 예외는 복구하고 싶을 수 있음
  • 예) 회원 가입시 DB에 이미 같은 ID가 있으면 ID 뒤에 숫자를 붙여서 새로운 ID를 만들어야 한다고 가정
  • ID를 Hello라고 가입 시도, 이미 같은 아이디가 있으면 Hello21345와 같이 뒤에 임의의 숫자를 붙여서 가입하는 것이다.

✅ H2 데이터베이스의 키 중복 오류 코드

e.getErrorCode() == 23505

• SQLException 내부에 들어있는 errorCode를 활용하면 데이터베이스에 어떤 문제가 발생했는지 확인할 수 있음

✅ H2 데이터베이스 예시

• 23505 : 키 중복 오류

• 42000: SQL 문법 오류

• MyDuplicateKeyException

  • 기존에 사용했던 MyDbException을 상속받아서 의미있는 계층을 형성
  • 이럴경우 데이터베이스 관련 예외라는 계층을 만들 수 있다.
  • 이름처럼 MyDuplicateKeyException는 데이터 중복의 경우에만 던져야 한다.

package hello.jdbc.repository.ex;

public class MyDuplicateKeyException extends MyDbException {
    
    public MyDuplicateKeyException() {
    }

    public MyDuplicateKeyException(String message) {
        super(message);
    }

    public MyDuplicateKeyException(String message, Throwable cause) {
        super(message, cause);
    }

    public MyDuplicateKeyException(Throwable cause) {
        super(cause);
    }
}

• ExTranslatorV1Test

package hello.jdbc.exception.translator;

import hello.jdbc.domain.Member;
import hello.jdbc.repository.ex.MyDbException;
import hello.jdbc.repository.ex.MyDuplicateKeyException;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Random;

import static org.springframework.jdbc.support.JdbcUtils.closeConnection;
import static org.springframework.jdbc.support.JdbcUtils.closeStatement;

@Slf4j
public class ExTranslatorV1Test {

    Repository repository;
    Service service;

    @BeforeEach
    void init() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource(URL, USERNAME, PASSWORD);
        repository = new Repository(dataSource);
        service = new Service(repository);
    }

    @Test
    void duplicateKeySave() {
        service.create("myId");
        service.create("myId");//같은 ID 저장 시도
    }

    @Slf4j
    @RequiredArgsConstructor
    static class Service {
        private final Repository repository;

        public void create(String memberId) {
            try {
                repository.save(new Member(memberId, 0));
                log.info("saveId={}", memberId);
            } catch (MyDuplicateKeyException e) {
                log.info("키 중복, 복구 시도");
                String retryId = generateNewId(memberId);
                log.info("retryId={}", retryId);
                repository.save(new Member(retryId, 0));
            } catch (MyDbException e) {
                log.info("데이터 접근 계층 예외", e);
                throw e;
            }
        }
    }

    private String generateNewId(String memberId) {
        return memberId + new Random().nextInt(10000);
    }

    @RequiredArgsConstructor
    static class Repository {
        private final DataSource dataSource;
        public Member save(Member member) {
            String sql = "insert into member(member_id, money) values(?, ?)";
            Connection con = null;
            PreparedStatement pstmt = null;
            try {
                con = dataSource.getConnection();
                pstmt = con.prepareStatement(sql);
                pstmt.setString(1, member.getMemberId());
                pstmt.setInt(2, member.getMoney());
                pstmt.executeUpdate();
                return member;
            } catch (SQLException e) {
                //h2 db
                if (e.getErrorCode() == 23505) {
                    throw new MyDuplicateKeyException(e);
                }
                throw new MyDbException(e);
            } finally {
                closeStatement(pstmt);
                closeConnection(con);
            }
        } 
    }
}

• 실행해보면 다음과 같은 로그를 확인할 수 있다.

Service - saveId=myId
Service - 키 중복, 복구 시도
Service - retryId=myId492

• 같은 ID를 저장했지만, 중간에 예외를 잡아서 복구한 것을 확인할 수 있다.

• 리포지토리 중요한 부분

} catch (SQLException e) {
     //h2 db
     if (e.getErrorCode() == 23505) {
         throw new MyDuplicateKeyException(e);
}
     throw new MyDbException(e);
}

• e.getErrorCode() == 23505 :오류코드가 키 중복 오류(23505)인경우

• MyDuplicateKeyException을 새로 만들어서 서비스 계층에 던진다.

• 나머지 경우 기존에 만들었던 MyDbException 을 던진다.

• 서비스에 중요한 부분

try {
   repository.save(new Member(memberId, 0));
   log.info("saveId={}", memberId);
} catch (MyDuplicateKeyException e) { 
	 log.info("키 중복, 복구 시도");
	 String retryId = generateNewId(memberId); 
	 log.info("retryId={}", retryId); 
	 repository.save(new Member(retryId, 0));
} catch (MyDbException e) { 
	 log.info("데이터 접근 계층 예외", e); 
	 throw e;
}

• 처음에 저장을 시도한다. 만약 리포지토리에서 MyDuplicateKeyException 예외가 올라오면 이 예외를 잡는다.
• 예외를 잡아서 generateNewId(memberId) 로 새로운 ID 생성을 시도한다. 그리고 다시 저장한다. 여기가 예외를 복구하는 부분이다.

✅남은 문제

• SQL ErrorCode는 각각의 데이터베이스 마다 다르다. 결과적으로 데이터베이스가 변경될 때 마다 ErrorCode도 모두 변경해야 한다.
• 예) 키 중복 오류 코드
  • H2: 23505
  • MySQL: 1062

데이터베이스가 전달하는 오류는 키 중복 뿐만 아니라 락이 걸린 경우, SQL 문법에 오류 있는 경우 등등 수십 수
백가지 오류 코드가 있다. 이 모든 상황에 맞는 예외를 지금처럼 다 만들어야 할까? 추가로 앞서 이야기한 것 처럼
데이터베이스마다 이 오류 코드는 모두 다르다.

4️⃣ 스프링 예외 추상화 이해

• 스프링은 데이터 접근과 관련된 예외를 추상화해서 제공한다.

• 스프링 데이터 접근 예외 계층

  • 각각의 예외는 특정 기술에 종속적이지 않게 설계되어 있다.
  • 따라서 서비스 계층에서도 스프링이 제공하는 예외를 사용하면된다.
  • JDBC나 JPA를 사용할 때 발생하는 예외를 스프링이 제공하는 예외로 변환해주는 역할도 스프링이 제공한다.
  • 아래의 그림과 같이 예외의 최고 상위는 org.springframework.dao.DataAccessException이다. 런타임 예외를 상속 받았기 때문에 스프링이 제공하는 데이터 접근 계층의 모든 예외는 런타임 예외이다.
  • DataAccessException은 크게 2가지로 구분
    • NonTransient예외 : 일시적이지 않다라는 뜻으로 같은 SQL을 그대로 반복해서 실행하면 실패한다.
      • 예) SQL문법 오류, 데이터베이스 제약조건 위배 등..
    • Transient 예외 : 일시적인 뜻으로 Transient 하위 예외는 동일한 SQL을 다시 시도 했을 때 성공할 가능성이 있다.
      • 예) 쿼리 타임아웃, 락과 관련된 오류들이다. 이런 오류들은 데이터베이스가 상태가 좋아지거나, 락이 풀렸을 때 다시 시도하면 성공할 수도 있기 때문이다.

✅스프링이 제공하는 예외 변환기

• 스프링은 데이터베이스에서 발생하는 오류 코드를 스프링이 정의한 예외로 자동으로 변환해주는 변환기를 제공한다.

• SpringExceptionTranslatorTest - 추가 exceptionTranslator

  • 이전에 살펴봤던 SQL ErrorCode를 직접 확인하는 방법이다.
  • 이렇게 직접 예외를 확인하고 스프링이 만들어준 예외로 변환하는 것은 현실성이 없다.
  • 이렇게 하려면 오류 코드를 확인하고 스프링의 예외 체계에 맞추어 예외를 직접 변환해야한다.
  • 따라서 스프링은 예외 변환기를 제공한다.

package hello.jdbc.exception.translator;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import javax.sql.DataSource;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

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

@Slf4j
public class SpringExceptionTranslatorTest {

    DataSource dataSource;

    @BeforeEach
    void init() {
        dataSource = new DriverManagerDataSource(URL, USERNAME, PASSWORD);
    }

    @Test
    void sqlExceptionErrorCode() {
        String sql = "select bad grammar";
        try {
            Connection con = dataSource.getConnection();
            PreparedStatement stmt = con.prepareStatement(sql);
            
        } catch (SQLException e) {
            assertThat(e.getErrorCode()).isEqualTo(42122);
            int errorCode = e.getErrorCode();
            log.info("errorCode={}", errorCode);
            //org.h2.jdbc.JdbcSQLSyntaxErrorException
            log.info("error", e);

        }
    }

}

• 스프링이 제공하는 SQL 예외 변환기 다음과 같이 사용하면 된다.
  • translate() - 메서드의 첫번째 파라미터는 읽을 수 있는 설명이고 두번째 실행한 sql, 마지막은 발생된 SQLException을 전달하면 된다. 이렇게 하면 적절한 스프링 데이터 접근 계층의 예외로 변환해서 반환해준다.
  • 예제에서는 BadSqlGrammarException을 반환한다.
  • BadSqlGrammarException은 최상위 타입인 DataAccessException를 상속 받아서 만들어진다.

SQLExceptionTranslator exTranslator = new SQLErrorCodeSQLExceptionTranslator(dataSource);
DataAccessException resultEx = exTranslator.translate("select", sql, e);

• 각각의 DB마다 SQL ErrorCode는 다르다. 스프링은 어떻게 각각의 DB가 제공하는 SQL ErrorCode까지 고려해서 예외를 변환할 수 있을까 ?

• sql-error-codes.xml

  • org.springframeword.jdbc.support.sql-error-codes.xml
  • 스프링 SQL 예외 변환기는 SQLErrorCode를 이 파일을 대입해서 어떤 스프링 데이터 접근 예외로 전환해야 할지 찾아낸다.
    • 예) H2 DB에서 42000이 발생하면 badSqlGrammarException 이다 그럼 BadSqlGrammarException을 반환한다.

<bean id="H2" class="org.springframework.jdbc.support.SQLErrorCodes">
     <property name="badSqlGrammarCodes">
         <value>42000,42001,42101,42102,42111,42112,42121,42122,42132</value>
     </property>
     <property name="duplicateKeyCodes">
         <value>23001,23505</value>
     </property>
</bean>
<bean id="MySQL" class="org.springframework.jdbc.support.SQLErrorCodes">
     <property name="badSqlGrammarCodes">
         <value>1054,1064,1146</value>
     </property>
     <property name="duplicateKeyCodes">
         <value>1062</value>
     </property>
</bean>

✅ 정리

• 스프링은 데이터 접근 계층에 대한 일관된 예외 추상화를 제공
• 스프링은 예외 변환기를 통해서 SQLException의 ErrorCode에 맞는 적절한 스프링 데이터 접근 예외로 변환해준다.
• 서비스, 컨트롤러 계층에서 예외 처리가 필요한 경우, 특정 기술에 종속적인 SQLException같은 예외를 적용하는 것이 아니라, 스프링이 제공하는 데이터 접근 예외를 사용하면 된다.
• 스프링 예외 추상화 때문에 특정 기술에 종속적이지 않게 됨. → JDBC에서 JPA로 기술 변환을 할 경우에도 예외로 인한 변경을 최소화 할 수 있다.
• 스프링이 제공하는 예외를 사용하기 때문에 스프링에 대한 기술 종속성은 발생함.
  • 스프링에 대한 기술 종속성까지 완전히 제거하려면 예외를 모두 직접 정의하고 예외 변환도 직접 하면 되지만, 실용적인 방법은 아님.

5️⃣ 스프링 예외 추상화 적용

• MemberRepositoryV4_2

/**
 * SQLExceptionTranslator 추가
 */
@Slf4j
public class MemberRepositoryV4_2 implements MemberRepositroy{

    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());
            pstmt.executeUpdate();
            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);
        }
    }

    @Override
    public void update(String memberId, int money) {
        String sql = "update member set money = ? where member_id = ?";

        Connection con = null;
        PreparedStatement pstmt = null;

        try {
            con = getConnection();
            pstmt = con.prepareStatement(sql);
            pstmt.setInt(1, money);
            pstmt.setString(2, memberId);
            int resultSize = pstmt.executeUpdate();
            log.info("resultSize = {}", resultSize);
        } catch (SQLException e) {
            throw exTranslator.translate("update", sql, e);
        } finally {
            close(con, pstmt, null);
        }
    }

    @Override
    public void delete(String memberId) {
        String sql = "delete from member where member_id = ?";

        Connection con = null;
        PreparedStatement pstmt = null;

        try {
            con = getConnection();
            pstmt = con.prepareStatement(sql);
            pstmt.setString(1, memberId);

            pstmt.executeUpdate();

        } catch (SQLException e) {
            throw exTranslator.translate("delete", sql, e);
        } finally {
            close(con, pstmt, null);
        }
    }

    private void close(Connection con, Statement stmt, ResultSet rs) {
        JdbcUtils.closeResultSet(rs);
        JdbcUtils.closeStatement(stmt);

        //트랜잭션 동기화를 사용하려면 DataSourceUtils를 사용해야 한다.
        DataSourceUtils.releaseConnection(con, dataSource);
    }
    private Connection getConnection() throws SQLException {
        //주의 ! 트랜잭션 동기화를 사용하려면 DataSourceUtils를 사용해야한다.
        Connection con = DataSourceUtils.getConnection(dataSource);
        log.info("get connection={}, class={}", con, con.getClass());
        return con;
    }
}

• 추가된 부분

  } catch (SQLException e) {
  		throw exTranslator.translate("delete", sql, e); // save, findById, delete, update
  }

• MemberRepositoryV4Test - 수정

@Bean
MemberRepository memberRepository() {
		//return new MemberRepositoryV4_1(dataSource); // 단순 예외 변환 
		return new MemberRepositoryV4_2(dataSource); // 스프링 예외 변환 
}

✅ 정리

• 스프링이 예외를 추상화에 따라서 서비스 계층은 특정 리포지토리의 구현 기술과 예외에 종속적이지 않게 되었다.
• 결과로 서비스 계층은 특정 구현 기술이 변경(Ex. JDBC → JPA)되어도 그대로 유지할 수 있게 되었다. DI를 제대로 활용할 수 있게 됨

6️⃣ JDBC 반복 문제 해결 - JdbcTemplate

• 이번에는 리포지토리에서 JDBC를 사용하기 때문에 발생하는 반복 문제를 해결해보자.

▶️ JDBC 반복 문제

1. 커넥션 조회, 커넥션 동기화
2. PreparedStatement 생성 및 파라미터 바인딩
3. 쿼리 실행
4. 결과 바인딩
5. 예외 발생시 스프링 예외 변환기 실행
6. 리소스 종료

• 위와 같은 반복 문제를 해결 할 수 있는 방법은 JdbcTemplate를 사용하면 없앨 수 있다.

• MemberRepositoryV5

package hello.jdbc.repository;

import hello.jdbc.domain.Member;
import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.jdbc.support.JdbcUtils;
import org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator;
import org.springframework.jdbc.support.SQLExceptionTranslator;

import javax.sql.DataSource;
import java.sql.*;
import java.util.NoSuchElementException;

/**
 * JdbcTemplate 사용
 */
@Slf4j
public class MemberRepositoryV5 implements MemberRepositroy{

    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);
    }

    @Override
    public void update(String memberId, int money) {
        String sql = "update member set money = ? where member_id = ?";
        template.update(sql, money, memberId);
    }

    @Override
    public void delete(String memberId) {
        String sql = "delete from member where member_id = ?";
        template.update(sql, memberId);
    }

    private RowMapper<Member> memberRowMapper() {
        return (rs, rowNum) -> {
            Member member = new Member();
            member.setMemberId(rs.getString("member_id"));
            member.setMoney(rs.getInt("money"));
            return member;
        };
    }
}

• MembmerServiceV4Test - 수정
  • MemberRepository 인터페이스가 제공되므로 등록하는 빈만 MemberRepositoryV5로 변경해서 등록하면 된다.

@Bean
 MemberRepository memberRepository() {
		//return new MemberRepositoryV4_1(dataSource); //단순 예외 변환 
		//return new MemberRepositoryV4_2(dataSource); //스프링 예외 변환 
		return new MemberRepositoryV5(dataSource); //JdbcTemplate
}

JdbcTemplate은 JDBC로 개발할 때 발생하는 반복을 대부분 해결해준다. 그 뿐만 아니라 지금까지 학습했던, 트랜잭션을 위한 커넥션 동기화는 물론이고, 예외 발생시 스프링 예외 변환기도 자동으로 실행해준다.

✅ 정리

• 서비스 계층의 순수성
  • 트랜잭션 추상화 + 트랜잭션 AOP 덕분에 서비스 계층의 순수성을 최대한 유지하면서 서비스 계층에서 트랜잭션을 사용할 수 있다.
  • 스프링이 제공하는 예외 추상화와 예외 변환기 덕분에, 데이터 접근 기술이 변경되어도 서비스 계층의 순수성을 유지하면서 예외도 사용할 수 있다.
  • 서비스 계층이 리포지토리 인터페이스에 의존한 덕분에 향후 리포지토리가 다른 구현 기술로 변경되어도 서비스 계층을 순수하게 유지할 수 있다.
• 리포지토리에서 JDBC를 사용하는 반복 코드가 JdbcTemplate 으로 대부분 제거되었다.

🔗 출처

• 김영한 - 스프링 DB 1편 - 데이터 접근 핵심 원리

[6om1n]

수고하셨습니다 ~~ 👍

[YuDeokRin]

감사합니다 ㅎㅎ

[seyxxn]

수고하셨습니당 !!

[YuDeokRin]

감사합니다~