[스프링 DB 1편] #5. 자바 예외 이해 (1)

[6om1n]

#️⃣ 목차

• 예외 계층
• 예외 기본 규칙
• 체크 예외 기본 이해
• 언체크 예외 기본 이해

---

1️⃣ 예외 계층

• Object : 예외도 객체이다. 모든 객체의 최상위 부모는 Object 이므로 예외의 최상위 부모도 Object 이다.
• Throwable : 최상위 예외이다. 하위에 Exception 과 Error 가 있다.
• Error : 메모리 부족이나 심각한 시스템 오류와 같이 애플리케이션에서 복구 불가능한 시스템 예외이다. 애플리케이션 개발자는 이 예외를 잡으려고 해서는 안된다.
  • 상위 예외를 catch 로 잡으면 그 하위 예외까지 함께 잡는다. 따라서 애플리케이션 로직에서는 Throwable 예외도 잡으면 안된다. Error 예외도 함께 잡을 수 있기 때문이다. 따라서 애플리케이션 로직은 Exception 부터 필요한 예외로 생각하고 잡으면 된다.
  • Error 도 언체크 예외이다.
• Exception : 체크 예외
  • 애플리케이션 로직에서 사용할 수 있는 실질적인 최상위 예외이다.
  • Exception 과 그 하위 예외는 모두 컴파일러가 체크하는 체크 예외이다. 단 RuntimeException 은 예외로 한다.
• RuntimeException : 언체크 예외, 런타임 예외
  • 컴파일러가 체크 하지 않는 언체크 예외이다.
  • RuntimeException 과 그 자식 예외는 모두 언체크 예외이다.
  • RuntimeException 의 이름을 따라서 RuntimeException 과 그 하위 언체크 예외를 런타임 예외 라고 많이 부른다.

---

2️⃣ 예외 기본 규칙

예외는 잡아서 처리하거나, 처리할 수 없으면 밖으로 던져야한다.

예외 처리

• 5번에서 예외를 처리하면 이후에는 애플리케이션 로직이 정상 흐름으로 동작한다.

예외 던짐

• 예외를 처리하지 못하면 호출한 곳으로 예외를 계속 던지게 된다.

예외에 대한 2가지 기본 규칙

• 1️⃣ 예외는 잡아서 처리하거나 던져야 한다.
• 2️⃣ 예외를 잡거나 던질 때 지정한 예외뿐만 아니라 그 예외의 자식들도 함께 처리된다.
  • Exception 을 catch 로 잡으면 그 하위 예외들도 모두 잡을 수 있다.
  • Exception 을 throws 로 던지면 그 하위 예외들도 모두 던질 수 있다.

예외를 처리하지 못하고 계속 던지면 어떻게 될까 ?

• 자바 main() 쓰레드의 경우 예외 로그를 출력하면서 시스템이 종료된다.
• 웹 애플리케이션의 경우 여러 사용자의 요청을 처리하기 때문에 하나의 예외 때문에 시스템이 종료되면 안된다. 따라서 WAS가 해당 예외를 받아서 처리하는데, 주로 사용자에게 개발자가 지정한, 오류 페이지를 보여준다.

---

3️⃣ 체크 예외 기본 이해

• Exception 과 그 하위 예외는 모두 컴파일러가 체크하는 체크 예외이다. 단 RuntimeException 은 예외로 한다.
• 체크 예외는 잡아서 처리하거나, 또는 밖으로 던지도록 선언해야한다. 그렇지 않으면 컴파일 오류 가 발생한다.

체크 예외 전체 코드

package hello.jdbc.exception.basic;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.*;

@Slf4j
public class CheckedTest  {

    @Test
    void checked_catch() {
        Service service = new Service();
        service.callCatch();
    }

    @Test
    void checked_throw() {
        Service service = new Service();
        assertThatThrownBy(() -> service.callThrow())
                .isInstanceOf(MyCheckedException.class);
    }

    /**
     * Exception을 상속받은 예외는 체크 예외가 된다.
     */
    static class MyCheckedException extends Exception {
        public MyCheckedException(String message) {
            super(message);
        }
    }

    /**
     * Checked 예외는
     * 예외를 잡아서 처리하거나, 던지거나 둘 중 하나를 필수로 선택해야 한다.
     */
    static class Service {
        Repository repository = new Repository();
        /**
         * 예외를 잡아서 처리하는 코드
         */
        public void callCatch() {
            try {
                repository.call();
            } catch (MyCheckedException e) {
                //예외 처리 로직
                log.info("예외 처리, message={}", e.getMessage(), e);
            }
        }

        /**
         * 체크 예외를 밖으로 던지는 코드
         * 체크 예외는 예외를 잡지 않고 밖으로 던지려면 throws 예외를 메서드에 필수로 선언해야한다.
         * @throws MyCheckedException
         */
        public void callThrow() throws MyCheckedException {
            repository.call();
        }
    }

    static class Repository {
        public void call() throws MyCheckedException {
            throw new MyCheckedException("ex");
        }
    }
}

Exception을 상속받은 예외는 체크 예외가 된다.

static class MyCheckedException extends Exception {
        public MyCheckedException(String message) {
            super(message);
        }
    }

• MyCheckedException 은 Exception 을 상속받았기에 체크 예외가 된다.
• RuntimeException 을 상속받으면 언체크 예외가 된다. 자바 언어에서 문법으로 정한 것이다.
• 예외가 제공하는 여러가지 기본 기능 중에 오류 메시지를 보관하는 기능도 있다. (생성자를 통해서 해당 기능 사용)

✅ 예외를 잡아서 처리하는 코드

@Test
    void checked_catch() {
        Service service = new Service();
        service.callCatch();
    }

• service.callCatch() 에서 예외를 처리했기 때문에 test 메서드까지 예외가 올라오지 않는다.

실행 순서

• 1️⃣ test ➡️ service.callCatch() ➡️ repository.call() [예외 발생, 던짐]
• 2️⃣ test ➡️ service.callCatch() [예외 처리] ➡️ repository.call()
• 3️⃣ test [정상 흐름] ➡️ service.callCatch() ➡️ repository.call()

repository.call() 에서 MyUncheckedException 예외가 발생하고, 그 예외를 Service.callCatch() 에서 잡는 것을 확인할 수 있다.

실행 결과

• 실행 결과 로직을 보면 첫 줄은 남긴 로그가 그대로 남는 것을 확인할 수 있다.
• 두 번째 줄부터는 예외에 대한 스택 트레이스가 추가로 출력된다. 로그를 남길 때 로그의 마지막 인수에 예외 객체를 전달해주면 로그가 해당 예외의 스택 트레이스를 추가로 출력해주는 것이다.

catch 는 해당 타입과 그 하위 타입을 모두 잡을 수 있다.

• catch 에 MyCheckedException 의 상위 타입인 Exception 을 적어주어도 MyCheckedException 을 잡을 수 있다.
• catch 에 예외를 지정하면 해당 예외와 그 하위 타입 예외를 모두 잡아준다.
• 정확하게 MyCheckedException 만 잡고 싶다면 catch 에 MyCheckedException 을 적어주어야 한다.

✅ 예외를 처리하지 않고, 밖으로 던지는 코드 - 실행 순서

• 1️⃣ test ➡️ service.callThrow() ➡️ repository.call() [예외 발생, 던짐]
• 2️⃣ test ➡️ service.callThrow() [예외 던짐] ➡️ repository.call()
• 3️⃣ test [예외 도착] ➡️ service.callThrow() ➡️ repository.call()

체크 예외를 밖으로 던지지 않으면 컴파일 오류 발생한다.

체크 예외를 밖으로 던지는 경우에도 해당 타입과 그 하위 타입을 모두 던질 수 있다.

체크 예외의 장단점

체크 예외는 예외를 잡아서 처리할 수 없을 때, 예외를 밖으로 던지는 throws 예외를 필수로 선언해야 한다. 그렇지 않으면 컴파일 오류가 발생한다.

• 장점 : 개발자가 실수로 예외를 누락하지 않도록 컴파일러를 통해 문제를 잡아주는 훌륭한 안전 장치이다.
• 단점 : 개발자가 모든 체크 예외를 반드시 잡거나 던지도록 처리해야 하기 때문에, 번거롭다. 크게 신경쓰고 싶지 않은 예외까지 모두 챙겨야 한다. 의존관계에 따른 단점도 존재한다.

---

4️⃣ 언체크 예외 기본 이해

• RuntimeException 과 그 하위 예외는 언체크 예외로 분류된다.
• 언체크 예외는 컴파일러가 예외를 체크하지 않는다는 뜻이다.
• 언체크 예외는 체크 예외와 동일하지만, 차이는 예외를 던지는 throws 를 선언하지 않고 생략할 수 있다. 이 경우 자동으로 예외를 던진다.

체크 예외 vs 언체크 예외

• 체크 예외: 예외를 잡아서 처리하지 않으면 항상 throws 에 던지는 예외를 선언해야 한다.
• 언체크 예외: 예외를 잡아서 처리하지 않아도 throws 를 생략할 수 있다.

언체크 예외 전체 코드

package hello.jdbc.exception.basic;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.*;

@Slf4j
public class UncheckedTest {

    @Test
    void unchecked_catch() {
        Service service = new Service();
        service.callCatch();
    }

    @Test
    void unchecked_throw() {
        Service service = new Service();
        assertThatThrownBy(() -> service.callThrow())
                .isInstanceOf(MyUncheckedException.class);
    }

    /**
     * RuntimeException을 상속받은 예외는 언체크 예외가 된다.
     */
    static class MyUncheckedException extends RuntimeException {
        public MyUncheckedException(String message) {
            super(message);
        }
    }

    /**
     * UnChecked 예외는
     * 예외를 잡거나, 던지지 않아도 된다.
     * 예외를 잡지 않으면 자동으로 밖으로 던진다.
     */
    static class Service {
        Repository repository = new Repository();

        /**
         * 필요한 경우 예외를 잡아서 처리하면 된다.
         */
        public void callCatch() {
            try {
                repository.call();
            } catch (MyUncheckedException e) {
                //예외 처리 로직
                log.info("예외 처리, message={}", e.getMessage(), e);
            }
        }

        /**
         * 예외를 잡지 않아도 된다. 자연스럽게 상위로 넘어간다.
         * 체크 예외와 다르게 throws 예외 선언을 하지 않아도 된다.
         */
        public void callThrow() {
            repository.call();
        }

    }

    static class Repository {
        public void call() {
            throw new MyUncheckedException("ex");
        }
    }
}

언체크 예외를 잡아서 처리하는 코드

 try {
                repository.call();
            } catch (MyUncheckedException e) {
                //예외 처리 로직
                log.info("예외 처리, message={}", e.getMessage(), e);
            }

• 언체크 예외도 필요한 경우 잡아서 처리할 수 있다.

언체크 예외를 밖으로 던지는 코드에서는 throws 를 생략할 수 있다.

• 물론 언체크 예외도 throws 예외를 선언해도 된다. 생략도 가능
• 주로 생략하지만, 중요한 예외의 경우 선언해두면 해당 코드를 호출하는 개발자가 이런 예외가 발생한다는 점을 IDE를 통해 편리하게 인지할 수 있다.

언체크 예외의 장단점

언체크 예외는 예외를 잡아서 처리할 수 없을 때, 예외를 밖으로 던지는 throws 예외를 생략할 수 있다.

• 장점: 신경쓰고 싶지 않은 언체크 예외를 무시할 수 있다. 언체크 예외는 throws 를 생략할 수 있기 때문이다.
• 단점: 언체크 예외는 개발자가 실수로 예외를 누락할 수 있다. 체크 예외는 컴파일러를 통해 예외 누락을 잡아준다.

체크 예외와 언체크 예외의 차이는 예외를 처리할 수 없을 때 예외를 밖으로 던지는 부분에 있다. (필수로 선언해야하냐, 생략할 수 있느냐의 차이)

---

🔗 출처

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

---

[seyxxn]

수고하셨습니당 👏