Spring DB 기술 파헤치기 #1

 

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

Java의 데이터 접근기술은 1997년 JDBC (JDK 1.1)에 시작되어 20년의 역사를 거치며 발전해왔습니다.

Oracle, MySql, PostgreSql 같은 벤더를 제외하고 Java의 DB 접근기술만 공부한다해도 그 규모가 너무 커져 왜 이렇게 사용하는지, 내부에서는 어떻게 동작하는지를 이해하기는 쉽지 않습니다.

게다가 기타 도구들 Hibernate Envers, Hypersistence(vladmihalcea), flyway ... 단순 사용법만 찾아도 끝이 안보이죠

 

 

 

🍀 자바 코드로 DB를 사용하는 방법

try {
    // JDBC 4.0 부터는 META-INF/services/java.sql.Driver를 읽어 DriverManager를 미리 생성해줍니다.
    // 필요하다면 Class.forName("com.my.db.jdbc.Driver") 와 같이 직접 DriverManager에 추가할 수도 있습니다.
    connection = DriverManager.getConnection(jdbcUrl, username, password)
    println("Database connection established.")
 
    // Statement 생성
    statement = connection.createStatement()
 
    // SQL 쿼리 실행
    val sql = "SELECT * FROM your_table"
    resultSet = statement.executeQuery(sql)
 
    // 결과 처리
    while (resultSet.next()) {
        // 첫 번째 컬럼 값을 String으로 읽기
        val firstColumnValue = resultSet.getString(1)
        println(firstColumnValue)
    }
} catch (e: Exception) {
    e.printStackTrace()
} finally {
    // DB 커넥션을 닫아줘야 합니다. Java7 부터는 try-resource 문 (kotlin 에선 use)를 사용하면 편합니다.
    resultSet?.close()
    statement?.close()
    connection?.close()
}

 

 

 

 

🍀 JDBC

자바에서 데이터베이스를 사용하는 방법은 JDBC(Java DataBase Connectivity) API 단 하나 뿐이다. 이는 자바에서 제공해주는 DB 연결 인터페이스이고 실제 구현체는 공식 DB 벤더사 (Oracle, MS..)에서 제공합니다. 만약 나만의 Driver를 구현하고 싶다면 동일하게 JDBC Driver 구현체를 만들어서 등록하면 됩니다.

 

JDBC는 크게 2가지 인터페이스로 이루어져있습니다.

DataAccess는 개발자가 직접 만든 코드를 의미한다 (DAO, Data Access Object, Repository 등으로도 불린다.)

• JDBC Driver: 실제 DB와 네트워크 통신을 담당한다.
• DataSource : 각종 설정 및 커넥션 풀을 관리한다.
  ** 권장하는 방법은 아니지만, 단순히 한번 연결 하는거라면 DriverManger 유틸을 직접 꺼내 간단히 커넥션을 얻는 방법도 있습니다.

실제 구현체는 자바의 공식 DB 벤더사(MS, Oracle...)가 만들어서 제공하며 Java1.4 이후 버전 자바 설치시 META-INF/services/java.sql.Driver 경로에 포함되어있다. 

참고로 그 이전엔 Driver 구현체를 직접 로드해서 사용했는데, 컴파일 시점에 모든 DB Driver 클래스를 읽는건 불필요하므로 Class.forName("oracle.jdbc.driver.OracleDriver") 메서드를 이용해 런타임에 필요한 DB 구현체만 포함 되도록 사용했었다.

DriverManager에 등록된 JDBC Driver는 드라이버 객체 생성시점에 static {..} 으로 클래스를 읽어와서 등록된다.

 

 

 

 

🍀 Java DataSource  와 DB Connection Pool (DBCP)

사용자는 JDBC Connection 객체를 이용해 DB와 통신을 합니다.

DB는 커넥션에 클라이언트용 세션을 따로 만들어 요청을 받고 원하는 응답을 제공합니다.

참고로 자바 어플리케이션이 아닌 데이터베이스에서 사용되는 Connection과 Session의 의미는 아래와 같다.

< 커넥션이 연결되면 세션이 만들어지게 되고, 세션에 작업을 요청하면 프로세스가 실행된다. >
- 커넥션(Connection)은 클라이언트 프로세스와 데이터베이스 인스턴스간의 물리적인 TCP/IP 통신 경로를 의미한다.
- 세션(Sessions)은 논리적인 개념으로 한 유저의 로그인 상태를 의미한다. 보통 커넥션과 1:1 으로 대응된다.
- 프로세스(Process)는 실제 서버에 생성되는 운영체제 프로세스를 의미한다.

다만 해당 DB가 자체적인 Connection Pool이나 Shared Server Mode 같은 걸 제공해준다면 한 커넥션에 여러개의 세션이 붙을 수도 있다.

DataSource는 DB 커넥션 풀링과 서버 설정을 담당하고, JDBC Driver는 실제 벤더(Oracle, MySql..) 와 통신을 담당합니다.

 

참고로 자바 어플리케이션이 아닌 데이터베이스에서 사용되는 Connection과 Session의 의미는 아래와 같다.

< 커넥션이 연결되면 세션이 만들어지게 되고, 세션에 작업을 요청하면 프로세스가 실행된다. >
- 커넥션(Connection)은 클라이언트 프로세스와 데이터베이스 인스턴스간의 물리적인 TCP/IP 통신 경로를 의미한다.
- 세션(Sessions)은 논리적인 개념으로 한 유저의 로그인 상태를 의미한다. 보통 커넥션과 1:1 으로 대응된다.
- 프로세스(Process)는 실제 서버에 생성되는 운영체제 프로세스를 의미한다.

다만 해당 DB가 자체적인 Connection Pool이나 Shared Server Mode 같은 걸 제공해준다면 한 커넥션에 여러개의 세션이 붙을 수도 있다.

Server의 Connection 객체 <-> 데이터베이스 Client Connection (TCP)

 

 

위 그림을 사용자 입장에서 다시 그려보면 아래와 같습니다.

참고로 그림처럼 커넥션 풀을 사용하지 않는다면 DataSource 를 사용하지않고 DriverManager 만으로 간단히 연결 가능합니다.

 

다만 어떤 방법을 사용하든 자바를 사용한다면 JDBC Driver 인터페이스를 이용해 데이터베이스에 접근하는건 동일합니다.

• <DataSource 또는 DriverManager 직접 사용> 당연히 쌩 JDBC 를 직접 사용해서 커넥션을 얻어와도 사용 가능
• <Spring JDBC Template> 내부 필드로 DataSource를 가지고 있다.
• <MyBatis (구 iBatis)> SqlSessionFactory (spring mybatis는 SqlSessionFactoryBean) 에 DataSource를 등록해두고 세션인 SqlSessionTemplate 를 이용해 사용한다.
• < JPA > EntityManagerFactory에 DataSource를 등록해두고 세션인 EntityManager를 만들어 사용한다.
• < Spring Data JPA > 구현체(SimpleJpaRepository)를 확인해보면 EntityManager를 스프링 빈으로 주입받아 사용한다. 해당 빈은 Spring AOP 프록시를 거쳐 현재 트랜잭션에 맞춰 적절한 커넥션에 할당된다.

커넥션과 커넥션 풀에 대하여 더 자세하게 알고싶다면 아래 글을 참고해주세요.

JDBC Connection 에 대한 이해, HikariCP 설정 팁

보통 DriverManager를 직접 사용하는 경우는 거의 없습니다. 꼭 필요하다면 스프링의 DriverManagerDataSource 와 같이 사용하면 됩니다.

 

 

 

 

🍀 Transaction

트랜잭션에 관한 기초 내용은 이미 글이 있으므로 생략합니다.

2021.08.10 - [👀기본 지식/CS 기본지식] - 트랜잭션 격리수준(DB Isolation Level)

2022.08.15 - [👀기본 지식/Java 기본지식] - 의식의 흐름대로 써보는 DB 트랜잭션 이야기

 

 

 

 

🍀 Spring Transaction 추상화

JDBC를 이용하면 DB의 상세 스펙을 몰라도 Java 코드로 사용할 수 있습니다만, 직접 사용하기엔 여러 단점이 있습니다.

• JDBC를 사용하기 위해 try-catch-finally 같은 특정 패턴의 코드가 반복됩니다.
• Connection 같은 자원이 누수되지 않도록 직접 관리해야합니다. 
  JDBC 관련 코드를 숨기려고해도, Transaction 설정 및 동기화 때문에 강제로 서비스코드와 섞이게 됩니다.
• JDBC의 `throws SQLException` 을 어딘가에서 직접 처리해야합니다.

 

해당 문제들을 해결하기위해 스프링에선 트랜잭션을 아래와 같이 추상화 해두었습니다. 

정확히는 PlatformTransactionManager <- AbstractPlatformTransactionManager <- { 구현체 } 로 이루어져있습니다.

public interface PlatformTransactionManager{

    TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
            throws TransactionException;


    void commit(TransactionStatus status) throws TransactionException;


    void rollback(TransactionStatus status) throws TransactionException;

}

public interface AbstractPlatformTransactionManager extends PlatformTransactionManager{
    /**
     * begin, commit, rollback 코드를 보면 실제 동작은 아래 메서드에 위임한다 
     * (EX commit()-> processCommit() -> doCommit())
     */    
    protected void doCommit(DefaultTransactionStatus status) throws TransactionException;

    protected void doRollback(DefaultTransactionStatus status) throws TransactionException;
	
    protected void doBegin(Object transaction, TransactionDefinition definition)
            throws TransactionException;
}

 

 

이제 개발자는 PlatformTransactionManager 를 꺼내서 getTransaction, commit, rollback만 사용하면 됩니다.

보통 try-catch 없이 편리하게 쓰려고 스프링이 제공하는 템플릿 클래스(TransactionTemplate)로 래핑해서 사용합니다.

@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
    // DataSource로 PlatformTransactionManager 생성
    return new DataSourceTransactionManager(dataSource);
}

@Bean
public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) {
    // PlatformTransactionManager 으로 TransactionTemplate 생성 
    return new TransactionTemplate(transactionManager);
}

@Service
@RequiredArgsConstructor
public class MyService {
    private final TransactionTemplate transactionTemplate;
    
    /** ⭐️ Java8 람다로 정의된 메서드를 쓰면 매우 깔끔합니다. */
    void myTransactionalLambda() {
        transactionTemplate.executeWithoutResult(status -> { /*..트랜잭션 로직..*/ });
        
        var result = transactionTemplate.execute(status -> { /*..트랜잭션 로직..*/ return null; });
    }
    
    /** 익명클래스로 사용할 땐 아래와 같습니다 */
    MyResultDto myTransactionalMethod() {
        return transactionTemplate.execute(new TransactionCallback<MyResultDto>() {
            @Override
            public MyResultDto doInTransaction(TransactionStatus status) {
                // 여기에 트랜잭션을 적용할 비즈니스 로직을 작성합니다.
                // 필요한 경우 status.setRollbackOnly(); 호출로 롤백을 지시할 수 있습니다.
                MyResultDto result = new MyResultDto();
                return result;
            }
        });
    }

    void myTransactionalMethod() {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                // 여기에 트랜잭션을 적용할 비즈니스 로직을 작성합니다.
                // 필요한 경우 status.setRollbackOnly(); 호출로 롤백을 지시할 수 있습니다.
            }
        });
    }
}

 

 

실제 내부 구현을 그림으로 그려보면 아래와 같습니다.
참고로 한 스레드가 여러 DB Connection을 물고있을 수는 있지만, 반대는 불가능합니다. 관리도 엄청 복잡해지고 스레드 경합문제도 있기때문입니다. 애초에 커넥션풀로 관리하는데 한 커넥션을 여러 스레드가 사용할 필요도 없구요.

 

복잡해보일수 있는데 역할에 따라 분리해보면 생각보다 간단합니다. 예를 들어 DataSourceTransactionManager.doBegin() 를 까보면 아래와 같습니다.

/**
 * doBegin: 트랜잭션을 시작합니다. 참고로 쌩 JDBC 에서는시작 메서드는 따로 없고 
   setAutoCommit(false) 로 트랜잭션을 시작합니다.
 * 
 * @param transaction 현재 트랜잭션에 관한 설정 정보 및 Connection 을 관리합니다. 
   구현체에 따라 TransactionObject 타입이 달라집니다.
 * (** Connection 자원 할당 및 회수는 TransactionSynchronizationManager 를 사용해서 처리합니다.)
 
 * @param definition 트랜잭션 전파, 격리, 타임아웃, 읽기 전용등의 동작 방식을 관리합니다.
 */
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
    Connection con = null;
    
try {
    /**
     * 1. 사용중인 Connection이 없으면 새로 생성합니다.
     * 2. 사용중인 Connection이 다른 트랜잭션에 사용(동기화)중이라면 새로 생성합니다.
     *
     * 즉 이미 존재하는 Connection이 사용중이 아니라면 해당 커넥션을 사용합니다.
     */
    if (!txObject.hasConnectionHolder() ||
            txObject.getConnectionHolder().isSynchronizedWithTransaction()) {

        Connection newCon = obtainDataSource().getConnection();

        // 새롭게 생성된 Connection을 ConnectionHolder를 이용해 저장합니다.
        // ConnectionHolder 는 참조 카운트를 이용한 커넥션 생명주기 관리, rollback 지원, DB 트랜잭션 상태 저장등을 담당합니다.
        txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
    }


    // 다른 트랜잭션이 해당 Connection 을 사용하지 못하게 {동기화=true} 로 설정한 뒤 커넥션을 꺼내옵니다.
    txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
    con = txObject.getConnectionHolder().getConnection();

    // 트랜잭션 정의에 따라 격리 수준을 설정합니다. prepareConnectionForTransaction 까보면 그냥 JDBC 코드입니다.
    Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
    txObject.setPreviousIsolationLevel(previousIsolationLevel);
    txObject.setReadOnly(definition.isReadOnly());

    // 트랜잭션을 직접 관리하기때문에, autoCommit=true 으로 설정 된 경우 임시로 false 변경합니다.
    // 이는 setMustRestoreAutoCommit 에 기록해뒀다가 트랜잭션이 끝나는 시점에 기존 autoCommit 설정으로 원상 복귀됩니다.
    if (con.getAutoCommit()) {
        txObject.setMustRestoreAutoCommit(true);
        con.setAutoCommit(false);
    }

    // 커넥션 연결을 준비합니다. 까보면 그냥 JDBC로 "SET TRANSACTION READ ONLY" 같은 걸 설정하는 간단한 코드입니다.
    prepareTransactionalConnection(con, definition);
    txObject.getConnectionHolder().setTransactionActive(true);

    // 트랜잭션 정의에 따라 타임아웃을 설정합니다.
    int timeout = determineTimeout(definition);
    if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
        txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
    }

    // ConnectionHolder가 여기에서 첫 생성되었다면 TransactionSyncManager 에 등록해 자원을 관리합니다.
    // Map (key=Datasource, value=ConnectionHolder)
    if (txObject.isNewConnectionHolder()) {
        TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
    }
}

catch (Throwable ex) {
    // 예외 발생 시 연결을 해제하고 TransactionSyncManager 에 자원 해제를 요청합니다.
    if (txObject.isNewConnectionHolder()) {
        DataSourceUtils.releaseConnection(con, obtainDataSource());
        txObject.setConnectionHolder(null, false);
    }
    throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
}
}

 

 

 

🤔 @Transactional은 어떻게 동작하는거에요?

이는 스프링 AOP 를 트랜잭션에 적용한 도구입니다. 동작과정은 아래와 같습니다.

2022.03.09 - [🌱 Spring Framework/Spring Core] - 자바 AOP의 모든 것(Spring AOP & AspectJ)

• 1️⃣ @EnableTransactionManagement 로 스프링 트랜잭션 AOP를 활성화합니다.
  * @SpringBootApplication -> @EnableAutoConfiuration에 의해 EnableTransactionManagement 자동 활성화 됨
  
  
  
• 2️⃣ 활성화되면 @Import(TransactionManagementConfigurationSelector.class) 에 의해 빈으로 등록됩니다.
  우리는 스프링 프록시를 사용하므로 아래 코드에 따라 ProxyTransactionManagementConfiguration 가 빈으로 등록됩니다.

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {

	/** {스프링 프록시 객체} or {AspectJ 프록시 객체} 중 하나를 스프링 빈으로 등록합니다. */
	@Override
	protected String[] selectImports(AdviceMode adviceMode) {
		switch (adviceMode) {
			case PROXY:
				return new String[] {AutoProxyRegistrar.class.getName(),
						ProxyTransactionManagementConfiguration.class.getName()};
			case ASPECTJ:
				return new String[] {determineTransactionAspectClass()};
			default:
				return null;
		}
	}

}

 

• 3️⃣ ProxyTransactionManagementConfiguration 으로 트랜잭션 AOP에 필요한 구현 클래스들이 빈으로 등록됩니다.

/** Advice (프록시로 적용할 실동작 코드) 를 담당하는 Advisor 클래스, 스프링 컨테이너 AOP(BeanFactory)에서 적용됨*/
BeanFactoryTransactionAttributeSourceAdvisor;

/** 사용자 트랜잭션 설정(TransactionAttributeSource)를 읽어들이는 클래스, 어노테이션을 읽는 구현체 사용 */
AnnotationTransactionAttributeSource;

/** PointCut(적용 조건), 즉 invoke() 메서드를 구현해서 AOP을 적용할 조건을 지정하는 클래스 */
TransactionInterceptor;

 

transactionInterceptor 코드를 보시면 `setTransactionManager(this.txManager)` 를 등록하는 부분이 있는데, 여기에 PlatformTransactionManager 가 설정됩니다. 이제 @Transactional 을 사용하면 AOP를 통해 트랜잭션이 걸리게 됩니다.

설정부분이 복잡하지만 동작은 생각보다 간단합니다.

1. 내가 원하는 메서드에 @Transactional 명시
2. 클래스가 빈으로 등록되는 시점에 Spring BeanPostProcessor 에 의한 AOP 프록시 생성 
3. PlatformTransactionManager 으로 메서드 시작전, 후에 트랜잭션 코드 집어넣기

 

 

 

🤔 트랜잭션 전파옵션..? 이런게 JDBC에 있었던가요?

트랜잭션 격리레벨(Transaction Isolation)은 JDBC에서도 손쉽게 설정가능합니다.

// isolation=TransactionDefinition.ISOLATION_READ_UNCOMMITTED
connection.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);

그런데 전파옵션 (Transaction Propagation)은 설정에 따라 기존 트랜잭션을 연장하거나, 새로운 트랜잭션을 만드는 등의 기능인데 

이는 당연히 JDBC 자체적으로 제공해주는 기능은 아닙니다. TransactionDefinition 설정값에 따라 스프링이 구현한 내용입니다.

@Transactional 이나 TxTemplate에 명시한걸 읽어서 전파 옵션을 TransactionDefinition 객체로 전달합니다.

 

구현 내용은 까봐야겠지만, JDBC의 savePoint 등을 적절하게 활용하면 불가능한건 아닙니다. 

출처&nbsp;https://jeong-pro.tistory.com/228

 

참고로 JDBC savePoint 는 아래와 같이 사용하는 기능입니다.

// try-with-resources 문을 사용하여 자동으로 리소스 해제
try (Connection conn = DriverManager.getConnection(url, user, password)) {
    conn.setAutoCommit(false);

    // 첫 번째 업데이트
    try (PreparedStatement pstmt1 = conn.prepareStatement(sql1)) { pstmt1.executeUpdate(); }

    // Savepoint 설정
    Savepoint savepoint1 = conn.setSavepoint("Savepoint1");

    // 두 번째 업데이트
    try (PreparedStatement pstmt2 = conn.prepareStatement(sql2)) { pstmt2.executeUpdate(); }

    conn.commit();
} catch (SQLException e) {
    try {
        if (savepoint1 != null) {
            // Savepoint가 있다면, 거기로 롤백 ( savePoint 이후 작업만 롤백됨 )
            conn.rollback(savepoint1);
            
            conn.commit(); // 다시 커밋
        }
    } catch (SQLException se) {
       /* .. */
    }
}

 

 

같이보면 좋은 글
2021.08.18 - [🌱 Spring Framework/Spring Core] - @Transactional 의 동작원리, 트랜잭션 매니저

2021.08.18 - [🌱 Spring Framework/Spring Core] - DB와 @Transactional을 사용할때 자주 나오는 실수

 

 

 

 

🍀 자바의 Exception 처리

• Throwable: throw를 사용할 수 있는 인터페이스
• Throwable->Error: 개발자가 처리할 수 없는 JVM 자체 에러 (메모리부족, 시스템 OS 오류)
• Throwable->Exception: 개발자가 처리할 수 있는 에러
• Throwable->Exception -> RuntimeException: 언체크드 예외, 즉 런타임에서 처리해야하는 예외

 

자바에서 예외가 발생하면 기본적으로 상위 메서드로 던져진다.

끝까지 처리하지않으면 main() 스레드까지 예외가 전달되고 이는 시스템이 종료된다. 웹 서버라 tomcat 등을 사용할 경우 main 까지 가지않고 WAS가 받아서 기본값으로 처리한다.

 

단순히 설명만 들으면 RuntimeException을 사용하지않고, 전부 체크 예외 (throws 로 명시하고 try-catch가 강제되는 예외)를 사용하면 편할 것 같지만, 특정 Exception 객체에 의존성이 생기게되고 코드 자체가 더러워진다.

그래서 보통 웹 서버의 경우 RuntimeException을 많이 활용한다.

실제로 체크 익셉션으로 예외처리를 강제해봐야 코드상으로 할 수 있는게 없어서 예외를 try{..} catch 로 아무 처리도 하지않고 무시하는 개발자도 많았었다. 개발자가 예상하지 못한 에러는 최상위에서 ControllerAdvice (또는 main 코드) 에서만 예외를 처리해주는게 맞다.

보통 RuntimeException을 상속한 MyCommonException 등을 만들어서 많이 사용한다.

 

2021.07.07 - [🌱Backend/Java] - #7 Exception (예외처리)

#7 Exception (예외처리)

 

 

 

🍀 스프링의 DB Exception 처리

스프링도 이와 비슷하게 DB에서 발생하는 에러를 추상화해두었다. ( org.springframework.dao.DataAccessException )
여담으로 DB 뿐만 아니라 스프링의 다양한 기능이 예외를 이런식으로 처리한다.

Transient는 일시적이라는 의미이다. 즉 DB 나 SQL 자체 문제가 아닌 {타임아웃, 락}과 같은 예외가 여기에 속한다.

 

예외가 정의 되어있다한들, 내가 모든 DB의 익셉션을 DataAccessException 으로 변환해주어야하는 번거로움은 그대로이다. 그래서 스프링에선 SQLExceptionTranslator 객체를 따로 만들어서 사용한다.

SQLExceptionTranslator exTranslator = new SQLErrorCodeSQLExceptionTranslator(dataSource);

// exTranslator.translate(String task, String sql, Exception e)
// 참고로 String task 는 일종의 주석이다. 예를 들어 하이버네이트의 경우 "Hibernate operation: " 으로 전달한다.
DataAccessException resultEx = exTranslator.translate("select", sql, e);

// 변환한 예외를 그대로 던질 수도 있다.
throw resultEx;

실제 JDBCTemplate 등을 까보면, 예외가 터졌을 때 등록된 ExceptionTranslator로 예외를 변환한다.

 

스프링으로 DB를 사용해봤다면 생각보다 에러 종류가 상세하게 구분되어있는걸 알 수 있는데, 이는 스프링이 각 DB 가 반환하는 에러별로 class SqlErrorCodes 객체를 정의해두었기 때문이다. 이는 org.springframework.jdbc.support.sql-error-codes.xml 파일을 통해 빈이 생성된다.

내부 코드를 까보면 SQLErrorCodeSQLExceptionTranslator 가 등록된 예외를 읽어서 switch 분기를 쳐준다.

 

참고로 여러 과정을 거쳤음에도 정의된 에러를 찾지 못했다면, 에러  로그를 남기고 DataAccessException을 상속한 UncategorizedSQLException 을 던진다. 물론 이는 구현체에 따라 다를 수 있다.

 

어찌보면 당연한거지만, 해당 기능을 편하게 쓰려면 Spring에서 제공해주는 도구를 사용해야한다.

Spring의 의존성까지 제거하고 싶다면 이를 참조해서 직접 자바코드로 구현해도 되지만, 대부분의 서비스는 DB 를 추상화한 부분을 도메인 로직처럼 순수한 Java (POJO)로 가져갈 필요는 없다. Spring Framework를 사용하기로 결정했다면 대부분 크게 신경쓰지않아도 되는 부분이다.

 

 

🍀 여담

근데 스프링이 이 모든걸 다해준 JdbcTemplte 을 사용하더라도 사실상 실제 프로덕션 코드로 사용하다보면 그렇게 엄청 편리하지는 않다.

@Repository
class EmployeeRepository(private val jdbcTemplate: JdbcTemplate) {

    fun findEmployeesWithJoin(minSalary: Double, maxSalary: Double, departmentName: String, positionTitle: String): List<Employee> {
        val sql = """
            SELECT 
                e.*, 
                d.id as department_id, d.name as department_name, 
                p.id as position_id, p.title as position_title
            FROM employees e
            INNER JOIN departments d ON e.department_id = d.id
            INNER JOIN positions p ON e.position_id = p.id
            WHERE e.salary BETWEEN ? AND ?
              AND d.name = ?
              AND p.title = ?
            ORDER BY e.lastName, e.firstName
        """

        return jdbcTemplate.query(
            sql,
            arrayOf(minSalary, maxSalary, departmentName, positionTitle),
            EmployeeRowMapper()
        )
    }
}

class EmployeeRowMapper : RowMapper<Employee> {
    override fun mapRow(rs: ResultSet, rowNum: Int): Employee {
        return Employee(
            id = rs.getLong("id"),
            firstName = rs.getString("firstName"),
            lastName = rs.getString("lastName"),
            // 기타 Employee 필드
            department = Department(
                id = rs.getLong("department_id"),
                name = rs.getString("department_name")
                // 기타 Department 필드
            ),
            position = Position(
                id = rs.getLong("position_id"),
                title = rs.getString("position_title")
                // 기타 Position 필드
            )
            // 기타 필드
        )
    }
}

 

물론 ORM (ex JPA + QueryDsl 조합)으로 대부분 해결되지만, 특정 DB에 종속된 고급 쿼리나 통계 쿼리의 경우 그게 불가능 한 경우도 많다. 그런 쿼리엔 JPA 가 똑바로 생성하는지 믿기 힘든 것도 있고

이런 류의 기술로 여러가지를 찾아봤었는데, 전부 장단점이 있어 애매했었다.

물론 DB로 해결하지않고 검색이면 Elasticsearch, 대용량 처리는 Hadoop에 밀어넣고 Google BigQuery로 사용하는 방법도 있는데 그건 기업이 큰 경우에만 가능한 방법이니 잠깐 밀어두고, 가능한 방법들을 정리하면 아래와 같다. 

• Spring JDBC Template (위 예제코드)
• Jooq ( native sql을 마치 JPA처럼 사용하는 라이브러리 )
• MyBatis ( 선호하지는 않지만 Java8 이하를 사용한다면 유일한 선택지 🥲 )
• JPA + 복잡한 쿼리만 EntityManager.createNativeQuery 사용

 

 

이런 고민을 나만 한게 아닌지 SpringBoot 3.0 에 JDBC Client 라는게 추가되었더라. 생각보다 쓸만해보여서 나중에 써보고 글로 후기를 써볼 예정이다.

@Repository
class EmployeeRepository(private val jdbcAggregateOperations: JdbcAggregateOperations) {

    fun findEmployeeById(employeeId: Long): Employee? {
        return jdbcAggregateOperations.findById(employeeId, Employee::class.java)
    }

    fun findAllEmployees(): List<Employee> {
        return jdbcAggregateOperations.findAll(Employee::class.java)
    }
}

 

 

참고로 Jpa에서 사용하던 기능들중, Spring Data에만 의존하고 있는 기능들도 많다. 아래와 같이 Spring Data의 Criteria를 활용하는 방법도 있다

출처-&nbsp;www.youtube.com/watch?v=RKxQWQJftAg

/** Spring Data의 Criteria 활용 */
@Repository
class EmployeeRepository(private val jdbcAggregateTemplate: JdbcAggregateTemplate) {

    fun findEmployeesWithJoin(minSalary: Double, maxSalary: Double, departmentName: String, positionTitle: String): List<Employee> {
        val query = Query.query(
            Criteria.where("e.salary").between(minSalary, maxSalary)
                .and("d.name").`is`(departmentName)
                .and("p.title").`is`(positionTitle)
        ).sort(Sort.by("e.lastName").and(Sort.by("e.firstName")))

        return jdbcAggregateTemplate.find(query, Employee::class.java, "employees e")
            .innerJoin("departments d", "e.department_id = d.id")
            .innerJoin("positions p", "e.position_id = p.id")
            .all()
    }
}

 

궁금하다면 아래 링크를 한번쯤 꼭 보는걸 추천한다.

설명 - https://www.baeldung.com/spring-6-jdbcclient-api

유튜브 - 하찮은오후님 JdbcClient와 record를 결합하면 시너지가 커집니다.