공통 예외 처리와 자원 정리

public final class TryWithResourcesPrimaryFailure {
    public static void main(String[] args) {
        try (BoardChannel channel = new BoardChannel()) {
            channel.send();
        }
    }

    private static final class BoardChannel implements AutoCloseable {
        void send() {
            throw new IllegalStateException("primary send failure");
        }

        @Override
        public void close() {
            throw new IllegalArgumentException("secondary close failure");
        }
    }
}

java.lang.IllegalStateException: primary send failure
Suppressed: java.lang.IllegalArgumentException: secondary close failure

public final class AutoCloseableBoardClient {
    public static void main(String[] args) {
        send("publish-post");
    }

    private static void send(String data) {
        try (BoardClient client = new BoardClient("board.local")) {
            client.connect();
            client.send(data);
        } catch (BoardGatewayException error) {
            System.out.println("handled=" + error.getMessage());
        }
    }

    private static final class BoardClient implements AutoCloseable {
        private final String address;
        private boolean connected;

        BoardClient(String address) { this.address = address; }

        void connect() {
            connected = true;
            System.out.println("connect=" + address);
        }

        void send(String data) {
            if (!connected) throw new BoardGatewayException("not connected");
            System.out.println("send=" + data);
        }

        @Override
        public void close() {
            if (connected) {
                connected = false;
                System.out.println("close=" + address);
            }
        }
    }

    private static final class BoardGatewayException extends RuntimeException {
        BoardGatewayException(String message) { super(message); }
    }
}

connect=board.local
send=publish-post
close=board.local

public final class MultiResourceCloseOrder {
    public static void main(String[] args) {
        try (Resource connection = new Resource("connection");
             Resource channel = new Resource("channel")) {
            System.out.println("work");
        }
    }

    private static final class Resource implements AutoCloseable {
        private final String name;

        Resource(String name) {
            this.name = name;
            System.out.println("open=" + name);
        }

        @Override
        public void close() { System.out.println("close=" + name); }
    }
}

open=connection
open=channel
work
close=channel
close=connection

public final class ResourceFailurePriority {
    public static void main(String[] args) {
        run("body", true, false);
        run("close", false, false);
        run("init", false, true);
    }

    private static void run(String scenario, boolean failBody, boolean failSecondInit) {
        System.out.println("case=" + scenario);
        try (Resource first = new Resource("first", false);
             Resource second = new Resource("second", failSecondInit)) {
            if (failBody) throw new IllegalStateException("work");
            System.out.println("work=done");
        } catch (RuntimeException primary) {
            System.out.println("primary=" + primary.getClass().getSimpleName()
                    + ":" + primary.getMessage());
            for (Throwable suppressed : primary.getSuppressed()) {
                System.out.println("suppressed=" + suppressed.getMessage());
            }
        }
    }

    private static final class Resource implements AutoCloseable {
        private final String name;
        Resource(String name, boolean failInit) {
            this.name = name;
            if (failInit) throw new IllegalStateException("init-" + name);
            System.out.println("open=" + name);
        }
        public void close() {
            System.out.println("close=" + name);
            throw new IllegalArgumentException("close-" + name);
        }
    }
}

case=body
open=first
open=second
close=second
close=first
primary=IllegalStateException:work
suppressed=close-second
suppressed=close-first
case=close
open=first
open=second
work=done
close=second
close=first
primary=IllegalArgumentException:close-second
suppressed=close-first
case=init
open=first
close=first
primary=IllegalStateException:init-second
suppressed=close-first

public final class CommonExceptionBoundary {
    public static void main(String[] args) {
        handle("REQ-42", () -> new BoardService().publish("예외 처리 질문"));
    }

    private static void handle(String requestId, Command command) {
        try {
            command.run();
            System.out.println("status=ok");
        } catch (BoardValidationException error) {
            System.out.println("status=bad-request,field=" + error.field());
        } catch (Exception error) {
            System.out.println("status=system-error,request=" + requestId);
            logForOperator(requestId, error);
        }
    }

    private static void logForOperator(String requestId, Exception error) {
        System.out.println("board=" + requestId + ":"
                + error.getClass().getSimpleName() + ":" + error.getMessage());
    }

    private interface Command { void run(); }

    private static final class BoardService {
        void publish(String title) {
            throw new BoardSystemException("database offline for " + title);
        }
    }

    private static final class BoardValidationException extends RuntimeException {
        private final String field;
        BoardValidationException(String field) { this.field = field; }
        String field() { return field; }
    }

    private static final class BoardSystemException extends RuntimeException {
        BoardSystemException(String message) { super(message); }
    }
}

status=system-error,request=REQ-42
board=REQ-42:BoardSystemException:database offline for 예외 처리 질문