728x90
반응형
SMALL

참고자료

 

김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션 강의 | 김영한 - 인프런

김영한 | I/O, 네트워크, 리플렉션, 애노테이션을 기초부터 실무 레벨까지 깊이있게 학습합니다. 웹 애플리케이션 서버(WAS)를 자바로 직접 만들어봅니다., 국내 개발 분야 누적 수강생 1위, 제대로

www.inflearn.com

 

네트워크 프로그램4 - 자원 정리1

이전 포스팅에서 배운 자원 정리와 네트워크 프로그램을 활용해서, 깔끔하게 자원을 정리하는 코드로 변경해보자.

먼저 finally를 사용해서 자원을 정리해보고, 이후에 try-with-resources를 도입해보자. 참고로 뒤에서 설명하겠지만, try-with-resources를 항상 사용할 수 있는 것은 아니고, finally에서 직접 자원을 정리해야 하는 경우가 많이 있다. 

 

우선, 소켓과 스트림을 종료하기 위해 간단한 유틸리티 클래스를 하나 만들자.

SocketCloseUtil

package cwchoiit.network.tcp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class SocketCloseUtil {

    public static void closeAll(Socket socket, InputStream input, OutputStream output) {
        closeInput(input);
        closeOutput(output);
        closeSocket(socket);
    }

    public static void closeInput(InputStream input) {
        if (input != null) {
            try {
                input.close();
            } catch (IOException e) {
                log(e.getMessage());
            }
        }
    }

    public static void closeOutput(OutputStream output) {
        if (output != null) {
            try {
                output.close();
            } catch (IOException e) {
                log(e.getMessage());
            }
        }
    }

    public static void closeSocket(Socket socket) {
        if (socket != null) {
            try {
                socket.close();
            } catch (IOException e) {
                log(e.getMessage());
            }
        }
    }
}
  • 기본적인 null 체크와 자원 종료시 예외를 잡아서 처리하는 코드가 들어가 있다. 참고로 자원 정리 과정에서 문제가 발생해도 코드에서 직접 대응할 수 있는 부분은 거의 없다. 이 경우, 간단한 로그를 남겨서 이후에 개발자가 인지할 수 있는 정도면 충분하다.
  • 각각의 예외를 잡아서 처리했기 때문에 Socket, InputStream, OutputStream 중 하나를 닫는 과정에서 예외가 발생해도 다음 자원을 닫을 수 있다.
  • Socket을 먼저 생성하고, Socket을 기반으로 InputStream, OutputStream을 생성하기 때문에 닫을 때는 InputStream → OutputStream → Socket 순서로 닫아야 한다. 아 물론, InputStream, OutputStream 이들은 닫는 순서가 상관 없다.

 

클라이언트 코드를 먼저 수정해보자.

ClientV4

package cwchoiit.network.tcp.v4;

import cwchoiit.network.tcp.SocketCloseUtil;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

import static cwchoiit.network.tcp.SocketCloseUtil.*;
import static cwchoiit.util.MyLogger.log;

public class ClientV4 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("클라이언트 시작");

        Socket socket = null;
        DataInputStream input = null;
        DataOutputStream output = null;
        Scanner scanner = new Scanner(System.in);

        try {
            socket = new Socket("localhost", PORT);
            input = new DataInputStream(socket.getInputStream());
            output = new DataOutputStream(socket.getOutputStream());
            log("소켓 연결: " + socket);

            while (true) {
                System.out.print("서버에게 보낼 문자를 입력하세요:");
                String message = scanner.nextLine();

                output.writeUTF(message);
                log("client -> server: " + message);

                if ("exit".equalsIgnoreCase(message)) {
                    break;
                }

                // 서버로부터 문자 받기
                String received = input.readUTF();
                log("client <- server: " + received);
            }
        } catch (IOException e) {
            log(e);
        } finally {
            closeAll(socket, input, output);
            log("연결 종료: " + socket);
        }
    }
}
  • 자원 정리시 finally 코드 블럭에서 SocketCloseUtil.closeAll()만 호출하면 된다.

 

이번에는 서버 코드를 수정하자.

 

SessionV4

package cwchoiit.network.tcp.v4;

import cwchoiit.network.tcp.SocketCloseUtil;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

import static cwchoiit.network.tcp.SocketCloseUtil.*;
import static cwchoiit.util.MyLogger.log;

public class SessionV4 implements Runnable {

    private final Socket socket;

    public SessionV4(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        DataInputStream input = null;
        DataOutputStream output = null;

        try {
            input = new DataInputStream(socket.getInputStream());
            output = new DataOutputStream(socket.getOutputStream());

            while (true) {
                // 클라이언트로부터 문자 받기
                String received = input.readUTF();
                log("client -> server: " + received);

                if (received.equalsIgnoreCase("exit")) {
                    break;
                }

                String toSend = received + " World!";
                output.writeUTF(toSend);
                log("client <- server: " + toSend);
            }
        } catch (IOException e) {
            log(e);
        } finally {
            closeAll(socket, input, output);
            log("연결 종료 " + socket);
        }
    }
}
  • 자원 정리시 finally 코드 블럭에서 SocketCloseUtil.closeAll()만 호출하면 된다.

 

ServerV4ServerV3와 같은 코드이다. SessionV4만 적용하면 된다.

ServerV4

package cwchoiit.network.tcp.v4;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class ServerV4 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("서버 시작");

        ServerSocket serverSocket = new ServerSocket(PORT);
        log("서버 소켓 시작 - 리스닝 포트: " + PORT);

        while (true) {
            Socket socket = serverSocket.accept();

            SessionV4 session = new SessionV4(socket);
            Thread thread = new Thread(session);
            thread.start();
        }
    }
}

 

실행 결과 - 클라이언트 직접 종료시 서버 로그

16:26:45.153 [     main] 서버 시작
16:26:45.171 [     main] 서버 소켓 시작 - 리스닝 포트: 12345
16:26:58.882 [ Thread-0] client -> server: Hello
16:26:58.887 [ Thread-0] client <- server: Hello World!
16:27:11.037 [ Thread-0] java.io.EOFException
16:27:11.039 [ Thread-0] 연결 종료 Socket[addr=/127.0.0.1,port=52386,localport=12345]
  • 기존 코드의 문제는 클라이언트를 직접 종료하면, 서버의 SessionEOFException이 발생하면서 자원을 제대로 정리하지 못했다.
  • 변경한 코드에서는 서버에 접속한 클라이언트를 직접 종료해도 서버의 Session이 "연결 종료"라는 메시지를 남기면서 자원을 잘 정리하는 것을 확인할 수 있다.

이렇게 finally로 자원을 종료하는 방법을 적용해봤다. 이제는 try-with-resources로 자원을 종료해보도록 코드를 수정해보자.

 

네트워크 프로그램5 - 자원 정리2

이번에는 자원 정리에 try-with-resources를 적용해보자.

 

ClientV5

package cwchoiit.network.tcp.v5;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

import static cwchoiit.util.MyLogger.log;

public class ClientV5 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("클라이언트 시작");
        Scanner scanner = new Scanner(System.in);

        try (Socket socket = new Socket("localhost", PORT);
             DataInputStream input = new DataInputStream(socket.getInputStream());
             DataOutputStream output = new DataOutputStream(socket.getOutputStream())) {

            log("소켓 연결: " + socket);

            while (true) {
                System.out.print("서버에게 보낼 문자를 입력하세요:");
                String message = scanner.nextLine();

                output.writeUTF(message);
                log("client -> server: " + message);

                if ("exit".equalsIgnoreCase(message)) {
                    break;
                }

                // 서버로부터 문자 받기
                String received = input.readUTF();
                log("client <- server: " + received);
            }
        } catch (IOException e) {
            log(e);
        }
    }
}
  • 클라이언트에 try-with-resources를 적용했다.
  • 자원 정리시 try-with-resources에 선언되는 순서의 반대로 자원 정리가 적용되기 때문에 여기서는 output → input → socket 순으로 close()가 호출된다.
  • 참고로 OutputStream, InputStream, Socket 모두 AutoCloseable을 구현하고 있다.

SessionV5

package cwchoiit.network.tcp.v5;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class SessionV5 implements Runnable {

    private final Socket socket;

    public SessionV5(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {

        try (socket;
             DataInputStream input = new DataInputStream(socket.getInputStream());
             DataOutputStream output = new DataOutputStream(socket.getOutputStream())) {

            while (true) {
                // 클라이언트로부터 문자 받기
                String received = input.readUTF();
                log("client -> server: " + received);

                if (received.equalsIgnoreCase("exit")) {
                    break;
                }

                String toSend = received + " World!";
                output.writeUTF(toSend);
                log("client <- server: " + toSend);
            }
        } catch (IOException e) {
            log(e);
        }

        log("연결 종료: " + socket + " isClosed: " + socket.isClosed());
    }
}
  • Socket 객체의 경우 Session에서 직접 생성하는 것이 아니라, 외부에서 받아오는 객체이다. 이 경우 try 선언부에 예제와 같이 객체의 참조를 넣어두면 자원 정리 시점에 AutoCloseable이 호출된다.
  • AutoCloseable이 호출되어서 정말 소켓의 close() 메서드가 호출되었는지 확인하기 위해 마지막에 socket.isClosed()를 호출하는 코드를 넣어두었다.

 

ServerV5

package cwchoiit.network.tcp.v5;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class ServerV5 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("서버 시작");

        ServerSocket serverSocket = new ServerSocket(PORT);
        log("서버 소켓 시작 - 리스닝 포트: " + PORT);

        while (true) {
            Socket socket = serverSocket.accept();

            SessionV5 session = new SessionV5(socket);
            Thread thread = new Thread(session);
            thread.start();
        }
    }
}
  • 기존 코드와 같다. SessionV5를 사용하는 것으로만 바꿔주면 된다.

 

실행 결과 - 클라이언트 직접 종료 시 서버의 로그

16:48:58.824 [     main] 서버 시작
16:48:58.836 [     main] 서버 소켓 시작 - 리스닝 포트: 12345
16:49:08.889 [ Thread-0] client -> server: Hello
16:49:08.891 [ Thread-0] client <- server: Hello World!
16:49:13.845 [ Thread-0] java.io.EOFException
16:49:13.869 [ Thread-0] 연결 종료: Socket[addr=/127.0.0.1,port=52610,localport=12345] isClosed: true

 

네트워크 프로그램6 - 자원 정리3

아직 하나 남은게 있다. 바로 서버 코드에 있는 ServerSocket을 정리하는 것. 그래서 서버를 종료할때 서버 소켓과 연결된 모든 소켓 자원을 다 반납하고 서버를 안정적으로 종료하는 방법을 알아보자. 서버를 종료하려면 서버에 종료라는 신호를 전달해야 한다. 예를 들어, 서버도 콘솔창을 통해서 입력을 받도록 만들고 "종료"라는 메시지를 입력하면 모든 자원을 정리하면서 서버가 종료되도록 하면 된다. 하지만 보통 서버에서 콘솔 입력은 잘 하지 않으므로, 이번에는 서버를 직접 종료하면서 자원도 함께 정리하는 방법을 알아보자.

 

셧다운 훅(Shutdown Hook)

자바는 프로세스가 종료될 때, 자원 정리나 로그 기록과 같은 종료 작업을 마무리 할 수 있는 셧다운 훅이라는 기능을 지원한다. 프로세스 종료는 크게 2가지로 분류할 수 있다. 

  • 정상 종료
    • 모든 non 데몬 스레드의 실행 완료로 자바 프로세스 정상 종료
    • 사용자가 Ctrl + C를 눌러서 프로그램을 중단
    • kill 명령 전달 (kill -9 제외)
    • IntelliJ의 Stop 버튼
  • 강제 종료
    • 운영체제에서 프로세스를 더 이상 유지할 수 없다고 판단할 때 사용
    • 리눅스/유닉스의 kill -9 나 윈도우의 taskkill /F

정상 종료의 경우에는 셧다운 훅이 작동해서 프로세스 종료 전에 필요한 후처리를 할 수 있다. 반면에 강제 종료의 경우에는 셧다운 훅이 작동하지 않는다. 셧다운 훅의 사용법을 코드를 통해서 알아보고, 서버 종료 시 자원도 함께 정리해보자.

 

클라이언트 코드는 기존과 같다. 이름만 ClientV6로 복사해서 만들자.

ClientV6

package cwchoiit.network.tcp.v6;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

import static cwchoiit.util.MyLogger.log;

public class ClientV6 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("클라이언트 시작");
        Scanner scanner = new Scanner(System.in);

        try (Socket socket = new Socket("localhost", PORT);
             DataInputStream input = new DataInputStream(socket.getInputStream());
             DataOutputStream output = new DataOutputStream(socket.getOutputStream())) {

            log("소켓 연결: " + socket);

            while (true) {
                System.out.print("서버에게 보낼 문자를 입력하세요:");
                String message = scanner.nextLine();

                output.writeUTF(message);
                log("client -> server: " + message);

                if ("exit".equalsIgnoreCase(message)) {
                    break;
                }

                // 서버로부터 문자 받기
                String received = input.readUTF();
                log("client <- server: " + received);
            }
        } catch (IOException e) {
            log(e);
        }
    }
}

 

서버가 정상적으로 종료되려면, 서버가 만든 Session 객체와 그 객체 안에서 살고있는 Socket, InputStream, OutputStream을 모두 종료해야한다. 그런데 Session 객체는 클라이언트가 생성될때마다 하나씩 생성되기 때문에 그것을 관리하는 누군가가 필요하다. 그래서 여기서는 SessionManager라는 객체를 하나 새로 만들자.

SessionManagerV6

package cwchoiit.network.tcp.v6;

import java.util.ArrayList;
import java.util.List;

public class SessionManagerV6 {

    private final List<SessionV6> sessions = new ArrayList<>();

    public synchronized void add(SessionV6 session) {
        sessions.add(session);
    }

    public synchronized void remove(SessionV6 session) {
        sessions.remove(session);
    }

    public synchronized void closeAll() {
        for (SessionV6 session : sessions) {
            session.close();
        }
        sessions.clear();
    }
}

 

각 세션은 소켓과 연결 스트림을 가지고 있다. 따라서 서버를 종료할 때 사용하는 세션들도 함께 종료해야 한다. 모든 세션들을 찾아서 종료하려면 생성한 세션을 보관하고 관리할 객체가 필요하다. 

  • add() → 클라이언트의 새로운 연결을 통해, 세션이 새로 만들어지는 경우 add()를 호출해서 세션 매니저에 세션을 추가한다.
  • remove() → 클라이언트의 연결이 끊어지면 세션도 함께 정리된다. 이 경우, remove()를 호출해서 세션 매니저에서 세션을 제거한다.
  • closeAll() → 서버를 종료할 때 사용하는 세션들도 모두 닫고, 정리한다.

참고로, 클라이언트가 동시에 두명이 접속한다고 하면 세션도 동시에 두개가 만들어지고, 그 세션들을 동시에 두개를 세션매니저가 추가할 경우가 있다. 즉, 동기화 코드가 필요하다는 의미이고 그래서 각 메서드마다 synchronized 키워드를 사용했다.

 

SessionV6

package cwchoiit.network.tcp.v6;

import cwchoiit.network.tcp.SocketCloseUtil;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

import static cwchoiit.network.tcp.SocketCloseUtil.*;
import static cwchoiit.util.MyLogger.log;

public class SessionV6 implements Runnable {

    private final Socket socket;
    private final DataInputStream input;
    private final DataOutputStream output;
    private final SessionManagerV6 sessionManager;
    private boolean closed = false;

    public SessionV6(Socket socket, SessionManagerV6 sessionManager) throws IOException {
        this.socket = socket;
        this.input = new DataInputStream(socket.getInputStream());
        this.output = new DataOutputStream(socket.getOutputStream());
        this.sessionManager = sessionManager;
        this.sessionManager.add(this);
    }

    @Override
    public void run() {

        try {
            while (true) {
                // 클라이언트로부터 문자 받기
                String received = input.readUTF();
                log("client -> server: " + received);

                if (received.equalsIgnoreCase("exit")) {
                    break;
                }

                String toSend = received + " World!";
                output.writeUTF(toSend);
                log("client <- server: " + toSend);
            }
        } catch (IOException e) {
            log(e);
        } finally {
            sessionManager.remove(this);
            close();
        }
    }


    public synchronized void close() {
        if (closed) {
            return;
        }

        closeAll(socket, input, output);
        log("연결 종료: " + socket);
        closed = true;
    }
}

아쉽지만 Session은 이제 try-with-resources를 사용할 수 없다. 왜냐하면 서버를 종료하는 시점에도 Session의 자원을 정리해야 하기 때문이다. try-with-resources는 사용과 해제를 함께 묶어서 처리할 때 사용한다. 다시 말해, try 선언부에서 사용한 자원을 try가 끝나는 시점에 정리한다. 따라서 try에서 자원의 선언과 자원 정리를 묶어서 처리할 때 사용할 수 있다. 하지만 지금은 서버를 종료하는 시점에도 Session이 사용하는 자원을 정리해야 한다. 서버를 종료하는 시점에 자원을 정리하는 것은 Session안에 있는 try-with-resources를 통해 처리할 수 없다. try구문이랑 상관없이 서버를 꺼버릴 수 있기 때문이다.

 

동시성 문제

public synchronized void close() {...}
  • Session 객체에서도 close() 메서드에는 synchronized 라는 키워드가 붙었다. 왜 그럴까? 동시에 2곳에서 호출될 수 있기 때문이다. 
    • 클라이언트와 연결이 종료되었을 때 (클라이언트가 연결을 종료해서 try 구문안에 readUTF()EOFException을 터뜨리고, finally 구문이 실행되어 자원을 정리하려 들때)
    • 서버를 종료할 때 (서버가 종료되어, SessionManager에서 closeAll()을 호출할 때)
  • 따라서, close()가 다른 스레드에서 동시에 중복 호출될 가능성이 있고 그렇기에 synchronized 키워드를 사용해서 동시성 문제를 해결하자. 이렇게 되면 이제 여러 스레드가 동시에 접근하려고 해도 딱 하나의 스레드만 점유할 수 있다. 그런데 그건 그거고 하나의 스레드가 자기 할 일을 다 하고 나오면 자원이 정리됐는데도 또 이 close()가 호출되는건 막을 수 없다. 동시에 두개의 스레드가 close() 메서드를 실행하려고 하면 하나가 끝나면 다른 하나가 실행할테니. 그래서 이미 자원을 종료했는데 또 자원을 종료하려고 시도하는 것을 방지하기 위해 closed 라는 플래그를 하나 만들어서 이 플래그가 true라면 빠져나오도록 구현했다.

ServerV6

package cwchoiit.network.tcp.v6;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class ServerV6 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("서버 시작");
        SessionManagerV6 sessionManager = new SessionManagerV6();

        ServerSocket serverSocket = new ServerSocket(PORT);
        log("서버 소켓 시작 - 리스닝 포트: " + PORT);

        ShutdownHook shutdownHook = new ShutdownHook(serverSocket, sessionManager);
        // 셧다운 훅 등록 (이렇게 셧다운 훅을 등록하면, 자바가 프로세스를 종료하기 전에 이 셧다운 훅을 실행하고 종료한다)
        Runtime.getRuntime().addShutdownHook(new Thread(shutdownHook, "shutdown"));

        try {
            while (true) {
                Socket socket = serverSocket.accept();

                log("소켓 연결: " + socket);

                SessionV6 session = new SessionV6(socket, sessionManager);
                Thread thread = new Thread(session);
                thread.start();
            }
        } catch (IOException e) {
            // serverSocket.close()를 호출하면, serverSocket.accept()가 예외를 터트린다.
            log("서버 소켓 종료: " + e);
        }
    }

    static class ShutdownHook implements Runnable {

        private final ServerSocket serverSocket;
        private final SessionManagerV6 sessionManager;

        public ShutdownHook(ServerSocket serverSocket, SessionManagerV6 sessionManager) {
            this.serverSocket = serverSocket;
            this.sessionManager = sessionManager;
        }

        @Override
        public void run() {
            log("shutdownHook 실행");
            try {
                sessionManager.closeAll();
                serverSocket.close();

                Thread.sleep(1000); // 자원 정리 대기
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("e = " + e);
            }
        }
    }
}

 

셧다운 훅 등록

ShutdownHook shutdownHook = new ShutdownHook(serverSocket, sessionManager);
// 셧다운 훅 등록 (이렇게 셧다운 훅을 등록하면, 자바가 프로세스를 종료하기 전에 이 셧다운 훅을 실행하고 종료한다)
Runtime.getRuntime().addShutdownHook(new Thread(shutdownHook, "shutdown"));
  • Runtime.getRuntime().addShutdownHook()을 사용하면 자바 종료시 호출되는 셧다운 훅을 등록할 수 있다. 
  • 여기에 셧다운이 발생했을 때 처리할 작업과 스레드를 등록하면 된다.

셧다운 훅 실행 코드

static class ShutdownHook implements Runnable {

        private final ServerSocket serverSocket;
        private final SessionManagerV6 sessionManager;

        public ShutdownHook(ServerSocket serverSocket, SessionManagerV6 sessionManager) {
            this.serverSocket = serverSocket;
            this.sessionManager = sessionManager;
        }

        @Override
        public void run() {
            log("shutdownHook 실행");
            try {
                sessionManager.closeAll();
                serverSocket.close();

                Thread.sleep(1000); // 자원 정리 대기
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("e = " + e);
            }
        }
    }

  • 셧다운 훅이 실행될 때 모든 자원을 정리한다.
  • sessionManager.closeAll() → 모든 세션이 사용하는 자원(Socket, InputStream, OutputStream)을 정리한다.
  • serverSocket.close() → 서버 소켓을 닫는다.

자원 정리 대기 이유

Thread.sleep(1000); // 자원 정리 대기
  • 보통 모든 non 데몬 스레드의 실행이 완료되면 자바 프로세스가 정상 종료된다. 하지만, 다음과 같은 종료도 있다.
    • 사용자가 Ctrl + C를 눌러서 프로그램을 중단
    • kill 명령 전달 (kill -9 제외)
    • IntelliJ의 Stop 버튼

이런 경우에는 non 데몬 스레드의 종료 여부와 관계없이 자바 프로세스가 종료된다. 단, 셧다운 훅의 실행이 끝날 때까지는 기다려준다. 셧다운 훅의 실행이 끝나면 non 데몬 스레드의 실행 여부와 상관없이 자바 프로세스는 종료된다. 따라서, 다른 스레드가 자원을 정리하거나 필요한 로그를 남길 수 있도록 셧다운 훅의 실행을 잠시 대기한다.

 

실행 결과 - 서버 종료 결과

(참고로, 셧다운 훅이 실행되지 않는 경우엔, Build and Run 옵션이 Gradle로 되어 있지는 않은지 확인해보자!, IntelliJ로 자바를 실행해야한다. IntelliJ에서 Stop 버튼을 누를꺼니까.)

18:39:22.337 [     main] 서버 시작
18:39:22.345 [     main] 서버 소켓 시작 - 리스닝 포트: 12345
18:39:38.966 [     main] 소켓 연결: Socket[addr=/127.0.0.1,port=53510,localport=12345]
18:39:50.596 [ shutdown] shutdownHook 실행
18:39:50.599 [ shutdown] 연결 종료: Socket[addr=/127.0.0.1,port=53510,localport=12345]
18:39:50.599 [ Thread-0] java.net.SocketException: Socket closed
18:39:50.599 [     main] 서버 소켓 종료: java.net.SocketException: Socket closed

서버를 종료하면, shutdown 스레드가 shutdownHook을 실행하고, 세션의 Socket의 연결을 close()로 닫는다. 

  • [Thread-0] Socket closed
  • Sessioninput.readUTF()에서 입력을 대기하는 Thread-0 스레드는, SocketException 예외를 받고 종료된다. 참고로 이 예외는 자신의 소켓을 닫았을 때 발생한다.

shutdown 스레드는 서버 소켓을 close()로 닫는다.

  • [main] 서버 소켓 종료
  • serverSocket.accept()에서 대기하고 있던 main 스레드는 SocketException 예외를 받고 종료된다. 

 

정리

드디어, 자원 정리까지 깔끔하게 해결한 서버 프로그램이 완성됐다.

 

네트워크 예외1 - 연결 예외

네트워크 연결시 발생할 수 있는 예외들을 정리해보자.

ConnectMain

package cwchoiit.network.exception.connect;

import java.io.IOException;
import java.net.ConnectException;
import java.net.Socket;
import java.net.UnknownHostException;

public class ConnectMain {
    public static void main(String[] args) throws IOException {
        unknownHostEx1();
        unknownHostEx2();
        connectRefused();
    }

    private static void unknownHostEx1() throws IOException {
        try {
            Socket socket = new Socket("999.999.999.999", 80);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }

    private static void unknownHostEx2() throws IOException {
        try {
            Socket socket = new Socket("google.gogo", 80);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }

    private static void connectRefused() throws IOException {
        try {
            Socket socket = new Socket("localhost", 45678);
        } catch (ConnectException e) {
            e.printStackTrace();
        }
    }
}

실행 결과

  java.net.UnknownHostException: 999.999.999.999
  ...
  java.net.UnknownHostException: google.gogo
  ...
  java.net.ConnectException: Connection refused
  ...

 

java.net.UnknownHostException

  • 호스트를 알 수 없음
  • 999.999.999.999 → 이런 IP는 존재하지 않는다.
  • google.gogo → 이런 도메인은 존재하지 않는다.

 

java.net.ConnectException

  • Connection refused 메시지는 연결이 거절됐다는 뜻이다.
  • 연결이 거절됐다는 뜻은, 우선은 네트워크를 통해 해당 IP의 서버 컴퓨터에 접속은 했다는 뜻이다.
  • 그런데 해당 서버 컴퓨터가 45678 포트를 사용하지 않기 때문에 TCP 연결을 거절한다.
  • IP에 해당하는 서버는 켜져있지만, 사용하는 PORT가 없을 때 주로 발생한다.
  • 네트워크 방화벽 등에서 무단 연결로 인지하고 연결을 막을 때도 발생한다.
  • 서버 컴퓨터의 OS는 이때 TCP RST(Reset)라는 패킷을 보내서 연결을 거절한다.
  • 클라이언트가 연결 시도 중에 RST 패킷을 받으면 이 예외가 발생한다.

TCP RST(Reset) 패킷

TCP 연결에 문제가 있다는 뜻이다. 이 패킷을 받으면 받은 대상은 바로 연결을 해제해야 한다.

 

네트워크 예외2 - 타임아웃

네트워크 연결을 시도해서 서버 IP에 연결 패킷을 전달했지만, 응답이 없는 경우 어떻게 될까?

 

TCP 연결 타임아웃 - OS 기본

package cwchoiit.network.exception.connect;

import java.io.IOException;
import java.net.ConnectException;
import java.net.Socket;

public class ConnectTimeoutMain1 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();

        try {
            Socket socket = new Socket("192.168.1.250", 45678);
        } catch (ConnectException e) {
            e.printStackTrace();
        }

        long endTime = System.currentTimeMillis();
        System.out.println("end = " + (endTime - startTime) + " ms");
    }
}
  • 사설 IP 대역(주로 공유기에서 사용하는 IP 대역)의 192.168.1.250을 사용했다. 혹시 해당 IP로 무언가 연결되어 있다면 다른 결과가 나올 수 있다. 이 경우 마지막 3자리를 변경해보자.
  • 해당 IP로 연결 패킷을 보내지만, IP를 사용하는 서버가 없으므로 TCP 응답이 오지 않는다.
  • 또는 해당 IP로 연결 패킷을 보내지만 해당 서버가 너무 바쁘거나 문제가 있어서 연결 응답 패킷을 보내지 못하는 경우도 있다. 그렇다면 무한정 기다려야 할까?

OS 기본 대기 시간

TCP 연결을 시도했는데 연결 응답이 없다면, OS에는 연결 대기 타임아웃이 설정되어 있다.

  • Windows: 약 21초
  • Linux: 약 75초에서 180초 사이
  • Mac: 75초

해당 시간이 지나면 java.net.ConnectException: Operation timed out이 발생한다.

실행 결과

  java.net.ConnectException: Operation timed out
      at java.base/sun.nio.ch.Net.connect0(Native Method)
      at java.base/sun.nio.ch.Net.connect(Net.java:589)
      at java.base/sun.nio.ch.Net.connect(Net.java:578)
      at java.base/sun.nio.ch.NioSocketImpl.connect(NioSocketImpl.java:583)
      at java.base/java.net.SocksSocketImpl.connect(SocksSocketImpl.java:327)
      at java.base/java.net.Socket.connect(Socket.java:752)
      at java.base/java.net.Socket.connect(Socket.java:687)
      at java.base/java.net.Socket.<init>(Socket.java:556)
      at java.base/java.net.Socket.<init>(Socket.java:325)
      at
  network.exception.connect.ConnectTimeoutMain.connectionWait1(ConnectTimeoutMai
  n.java:22)
      at
  network.exception.connect.ConnectTimeoutMain.main(ConnectTimeoutMain.java:12)
  end = 75008

TCP 연결을 클라이언트가 이렇게 오래 대기하는 것은 좋은 방법이 아니다.

연결이 안되면, 고객에게 빠르게 현재 연결에 문제가 있다고 알려주는 것이 더 나은 방법이다.

 

 

TCP 연결 타임아웃 - 직접 설정

TCP 연결 타임아웃 시간을 직접 설정해보자.

package cwchoiit.network.exception.connect;

import java.io.IOException;
import java.net.ConnectException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;

public class ConnectTimeoutMain2 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();

        try {
            Socket socket = new Socket(); // 객체만 생성하고 연결은 아직 안한 상태
            socket.connect(new InetSocketAddress("192.168.1.250", 45678), 1000);
        } catch (SocketTimeoutException e) {
            e.printStackTrace();
        }

        long endTime = System.currentTimeMillis();
        System.out.println("end = " + (endTime - startTime) + " ms");
    }
}
  • new Socket()
    • Socket 객체를 생성할 때 인자로 IP, PORT를 모두 전달하면, 생성자에서 바로 TCP 연결을 시도한다. 하지만, IP, PORT를 모두 빼고 객체를 생성하면 객체만 생성되고 아직 연결은 시도하지 않는다. 추가적으로 필요한 설정을 더 한 다음에 socket.connect()를 호출하면 그때 TCP 연결을 시도한다. 이 방식을 사용하면 추가적인 설정을 더 할 수 있는데, 대표적으로 타임아웃을 설정할 수 있다. 
  public void connect(SocketAddress endpoint, int timeout) throws IOException {...}
  • InetSocketAddress: SocketAddress의 자식이다. IP, PORT 기반의 주소를 객체로 제공한다.
  • timeout: 밀리초 단위로 연결 타임아웃을 지정할 수 있다.

타임아웃 시간이 지나도 연결이 되지 않으면 다음 예외가 발생한다. 

java.net.SocketTimeoutException: Connect timed out

 

실행 결과

  java.net.SocketTimeoutException: Connect timed out
      at java.base/
  sun.nio.ch.NioSocketImpl.timedFinishConnect(NioSocketImpl.java:546)
      at java.base/sun.nio.ch.NioSocketImpl.connect(NioSocketImpl.java:592)
      at java.base/java.net.SocksSocketImpl.connect(SocksSocketImpl.java:327)
      at java.base/java.net.Socket.connect(Socket.java:752)
      at
  network.exception.connect.ConnectTimeoutMain2.main(ConnectTimeoutMain2.java:13
  )

실행해보면 설정한 시간인 1초가 지난 후 타임아웃 예외가 발생하는 것을 볼 수 있다.

 

TCP 소켓 타임아웃 - read 타임아웃

타임아웃 중에 또 하나 중요한 타임아웃이 있다. 바로 소켓 타임아웃 또는 read 타임 아웃이라고 부르는 타임아웃이다.

앞에서 설명한 연결 타임아웃은 TCP 연결과 관련이 있다. 연결이 잘 된 이후에 클라이언트가 서버에 어떤 요청을 했다고 가정하자. 그런데 서버가 계속 응답을 주지 않는다면, 무한정 기다려야 하는 것일까? 서버에 사용자가 폭주하고 매우 느려져서 응답을 계속 주지 못하는 상황이라면 어떻게 해야할까? 이런 경우에 사용하는 것이 바로 소켓 타임아웃(read 타임아웃)이다.

 

SoTimeoutServer

package cwchoiit.network.exception.connect;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class SoTimeoutServer {
    public static void main(String[] args) throws InterruptedException, IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        Socket socket = serverSocket.accept();

        Thread.sleep(100000000);
    }
}
  • 서버는 소켓을 연결은 하지만, 아무런 응답을 주지 않는다.

SoTimeoutClient

package cwchoiit.network.exception.connect;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

public class SoTimeoutClient {
    public static void main(String[] args) throws IOException {

        Socket socket = new Socket("localhost", 12345);
        InputStream inputStream = socket.getInputStream();

        try {
            socket.setSoTimeout(3000);
            int read = inputStream.read();
            System.out.println("read: " + read);
        } catch (Exception e) {
            e.printStackTrace();
        }
        socket.close();
    }
}
  • socket.setSoTimeout()을 사용하면 밀리초 단위로 타임아웃 시간을 설정할 수 있다. 여기서는 3초를 설정했다.

3초가 지나면 다음 예외가 발생한다.

java.net.SocketTimeoutException: Read timed out

 

타임아웃 시간을 설정하지 않으면 read()는 응답이 올 때까지 무한정 대기한다.

 

클라이언트 실행 결과

  java.net.SocketTimeoutException: Read timed out
      at java.base/sun.nio.ch.NioSocketImpl.timedRead(NioSocketImpl.java:278)
      at java.base/sun.nio.ch.NioSocketImpl.implRead(NioSocketImpl.java:304)
      at java.base/sun.nio.ch.NioSocketImpl.read(NioSocketImpl.java:346)
      at java.base/sun.nio.ch.NioSocketImpl$1.read(NioSocketImpl.java:796)
      at java.base/java.net.Socket$SocketInputStream.implRead(Socket.java:1108)
      at java.base/java.net.Socket$SocketInputStream.read(Socket.java:1095)
      at java.base/java.net.Socket$SocketInputStream.read(Socket.java:1089)
      at network.exception.connect.SoTimeoutClient.main(SoTimeoutClient.java:15)

 

 

왜 이 타임아웃이 중요할까? 정말 정말 중요하다. 근데 왜 그럴까?

 

실무 이야기

실무에서 자주 발생하는 장애 원인 중 하나가 바로 연결 타임아웃, 소켓 타임아웃(read 타임아웃)을 누락하기 때문에 발생한다. 서버도 외부에 존재하는 데이터를 네트워크를 통해 불러와야 하는 경우가 있다. 예를 들어서 주문을 처리하는 서버가 있는데, 주문 서버는 외부에 있는 서버를 통해 고객의 신용카드 결제를 처리해야 한다고 가정해보자. 

 

신용카드를 처리하는 회사가 3개가 있다고 가정하자.

  • 고객 → 주문 서버 → 신용카드A 회사 서버(정상)
  • 고객 → 주문 서버 → 신용카드B 회사 서버(정상)
  • 고객 → 주문 서버 → 신용카드C 회사 서버(문제)

신용카드 A, 신용카드 B, 서버는 문제가 없고, 신용카드 C 회사 서버에 문제가 발생해서 응답을 주지 못하는 상황이라고 가정해보자. 주문 서버는 계속 신용카드 C 회사 서버의 응답을 기다리게 된다. 여기서 문제는 신용카드 C의 결제에 대해서 주문 서버도 고객에게 응답을 주지 못하고 계속 대기하게 된다. 신용카드 C로 주문하는 고객이 누적될수록 주문 서버의 요청은 계속 쌓이게 되고, 신용카드 C 회사 서버의 응답을 기다리는 스레드도 점점 늘어난다. 결국 주문 서버에 너무 많은 사용자가 접속하게 되면서 주문 서버에 장애가 발생하게 된다. 결과적으로 신용카드 C 때문에 신용카드A, B를 사용하는 고객까지 모두 주문을 할 수 없는 사태가 벌어진다. 

 

이런 장애는 신용카드 C 회사의 문제일까? 아니면 주문 서버 개발자의 문제일까?

만약, 주문 서버에 연결, 소켓 타임아웃을 적절히 설정했다면, 신용카드 C 회사 서버가 연결이 오래 걸리거나 응답을 주지 않을 때 타임아웃으로 처리할 수 있다. 이렇게 되면 요청이 쌓이지 않기 때문에, 주문 서버에 장애가 발생하지 않는다. 타임아웃이 발생하는 신용카드 C 사용자에게는 현재 문제가 있다는 안내를 하면 된다. 나머지 신용카드 A, B는 정상적으로 작동한다.

 

결론은 외부 서버와 통신을 하는 경우, 반드시 연결 타임아웃과 소켓 타임아웃을 지정하자.

 

네트워크 예외3 - 정상 종료

TCP에는 2가지 종류의 종료가 있다.

  • 정상 종료
  • 강제 종료

정상 종료

TCP에서 A, B가 서로 통신한다고 가정해보자. TCP 연결을 종료하려면 서로 FIN 메시지를 보내야 한다.

  • A → (FIN) → B: A가 B로 FIN 메시지를 보낸다.
  • A ← (FIN) ← B: FIN 메시지를 받은 B도 A에게 FIN 메시지를 보낸다.

socket.close()를 호출하면, TCP에서 종료의 의미인 FIN 패킷을 상대방에게 전달한다. FIN 패킷을 받으면 상대방도 socket.close()를 호출해서 FIN 패킷을 상대방에게 전달해야 한다.

 

  • 클라이언트와 서버가 연결되어 있다.
  • 서버가 연결 종료를 위해 socket.close()를 호출한다. 서버는 클라이언트에 FIN 패킷을 전달한다.
  • 클라이언트는 FIN 패킷을 받는다. 
    • 클라이언트의 OS에서 FIN에 대한 ACK 패킷을 전달한다.
  • 클라이언트도 종료를 위해 socket.close()를 호출한다.
    • 클라이언트는 서버에 FIN 패킷을 전달한다.
    • 서버의 OS는 FIN 패킷에 대한 ACK 패킷을 전달한다.

 

예제를 통해 서버와 클라이언트 간 정상 종료에 대해 알아보자.

Server

package cwchoiit.network.exception.close;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class NormalCloseServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        ServerSocket serverSocket = new ServerSocket(12345);
        Socket socket = serverSocket.accept();
        log("소켓 연결:" + socket);

        Thread.sleep(1000);
        socket.close();
        log("소켓 종료");
    }
}
  • 서버는 소켓이 연결되면 1초 뒤에 연결을 종료한다.
  • 서버에서 socket.close()를 호출하면 클라이언트에 FIN 패킷을 보낸다.

Client

package cwchoiit.network.exception.close;

import java.io.*;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class NormalCloseClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 12345);
        log("소켓 연결: " + socket);

        InputStream input = socket.getInputStream();

        readByInputStream(input, socket);
        readByBufferedReader(input, socket);
        readByDataInputStream(input, socket);

        log("연결 종료" + socket.isClosed());
    }

    private static void readByDataInputStream(InputStream input, Socket socket) throws IOException {
        DataInputStream dis = new DataInputStream(input);

        try {
            dis.readUTF();
        } catch (EOFException e) {
            log("EOFException: " + e.getMessage());
        } finally {
            dis.close();
            socket.close();
        }
    }

    private static void readByBufferedReader(InputStream input, Socket socket) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(input));
        String readString = br.readLine();
        log("readString: " + readString);
        if (readString == null) {
            br.close();
            socket.close();
        }
    }

    private static void readByInputStream(InputStream input, Socket socket) throws IOException {
        int read = input.read();
        log("read = " + read);
        if (read == -1) {
            input.close();
            socket.close();
        }
    }
}
  • 클라이언트는 서버의 메시지를 3가지 방법으로 읽는다.
    • read(): 1byte 단위로 읽음
    • readLine(): 라인 단위로 String으로 읽음
    • readUTF(): DataInputStream을 통해 String 단위로 읽음

실행 결과

15:10:29.677 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=60642]
15:10:30.716 [     main] read = -1
15:10:30.718 [     main] readString: null
15:10:30.718 [     main] EOFException: null
15:10:30.718 [     main] 연결 종료true

 

전체 과정

  • 클라이언트가 서버에 접속한다.
  • 클라이언트는 input.read()로 서버의 데이터를 읽기 위해 대기한다.
  • 그런데 1초 뒤에 서버에서 연결을 종료한다.
    • 서버에서 socket.close()를 호출하면 클라이언트에 FIN 패킷을 보낸다.
  • 클라이언트는 FIN 패킷을 받는다.
  • 서버가 소켓을 종료했다는 의미이므로 클라이언트는 더는 읽을 데이터가 없다.
  • FIN 패킷을 받은 클라이언트의 소켓은 더는 서버를 통해 읽을 데이터가 없다는 의미로 -1(EOF)를 반환한다.

여기서 각각의 상황에 따라 EOF를 해석하는 방법이 다르다.

  • read() → -1
  • BufferedReader().readLine()null
    • BufferedReader()는 문자 String을 반환한다. 따라서 -1을 표현할 수 없다. 대신에 null을 반환
  • DataInputStream.readUTF()EOFException
    • DataInputStream은 이 경우 EOFException을 던진다. 

여기서 중요한 점은 EOF가 발생하면 상대방이 FIN 메시지를 보내면서 소켓 연결을 끊었다는 뜻이다. 이 경우 소켓에 다른 작업을 하면 안되고, FIN 메시지를 받은 클라이언트도 close()를 호출해서 상대방에 FIN 메시지를 보내고 소켓 연결을 끊어야 한다. 이렇게 하면 서로 FIN 메시지를 주고 받으면서 TCP 연결이 정상 종료된다.

 

 

네트워크 예외4 - 강제 종료

강제 종료

TCP 연결 중에 문제가 발생하면 RST 라는 패킷이 발생한다. 이 경우 연결을 즉시 종료해야 한다.

예제를 통해 알아보자.

 

Server

package cwchoiit.network.exception.close.reset;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class ResetCloseServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        Socket socket = serverSocket.accept();
        log("소켓 연결: " + socket);

        socket.close();
        serverSocket.close();
        log("소켓 종료");
    }
}
  • 서버는 소켓이 연결되면 단순히 연결을 종료한다.

Client

package cwchoiit.network.exception.close.reset;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketException;

import static cwchoiit.util.MyLogger.log;

public class ResetCloseClient {
    public static void main(String[] args) throws IOException, InterruptedException {
        Socket socket = new Socket("localhost", 12345);
        log("소켓 연결: " + socket);

        InputStream input = socket.getInputStream();
        OutputStream output = socket.getOutputStream();

        // client <- server: FIN
        Thread.sleep(1000); // 서버가 close() 호출할때까지 잠시 대기

        // client -> server: PUSH[1]
        output.write(1);

        // client <- server: RST
        Thread.sleep(1000); // RST 메시지 대기
        try {
            int read = input.read();
            System.out.println("read = " + read);
        } catch (SocketException e) {
            e.printStackTrace();
        }

        try {
            output.write(1);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
}

 

실행 결과

17:01:12.870 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=61714]
java.net.SocketException: Connection reset
	...
java.net.SocketException: Broken pipe
	...

  • 클라이언트와 서버가 연결되어 있다.
  • 서버는 종료를 위해 socket.close()를 호출한다.
    • 서버는 클라이언트에 FIN 패킷을 전달한다.
  • 클라이언트는 FIN 패킷을 받는다.
    • 클라이언트의 OS에서 FIN에 대한 ACK 패킷을 전달한다.
  • 클라이언트는 output.write(1)을 통해, 서버에 메시지를 전달한다.
    • 데이터를 전송하는 PUSH 패킷이 서버에 전달된다.
  • 서버는 이미 FIN으로 종료를 요청했는데, PUSH 패킷으로 데이터가 전송되었다.
    • 서버가 기대하는 값은 FIN 패킷이다.
  • 서버는 TCP 연결에 문제가 있다고 판단하고 즉각 연결을 종료하는 RST 패킷을 클라이언트에 전송한다.

RST 패킷이 도착했다는 것은 현재 TCP 연결에 심각한 문제가 있으므로 해당 연결을 더는 사용하면 안된다는 의미이다.

 

RST 패킷이 도착하면 자바는 read()로 메시지를 읽을 때 다음 예외를 던진다.

java.net.SocketException: Connection reset

 

RST 패킷이 도착하면 자바는 write()로 메시지를 전송할 때 다음 예외를 던진다.

java.net.SocketException: Broken pipe

 

참고 - RST(Reset)

  • TCP에서 RST 패킷은 연결 상태를 초기화(리셋)해서 더 이상 현재의 연결을 유지하지 않겠다는 의미를 전달한다.
  • 여기서 Reset은 현재의 세션을 강제로 종료하고, 연결을 무효화하라는 뜻이다.
  • RST 패킷은 TCP 연결에 문제가 있는 다양한 상황에 발생한다. 예를 들어, 다음과 같은 경우들이 있다.
    • TCP 스펙에 맞지 않는 순서로 메시지가 전달될 때
    • TCP 버퍼에 있는 데이터를 아직 다 읽지 않았는데, 연결을 종료할 때
    • 방화벽 같은 곳에서 연결을 강제로 종료할 때도 발생한다.

참고 - java.net.SocketException: Socket is closed

  • 자기 자신의 소켓을 닫은 이후에 read(), write()를 호출할 때 발생한다.

 

정리

  • 상대방이 연결을 종료한 경우, 데이터를 읽으면 EOF가 발생한다.
    • -1, null, EOFException등이 발생한다.
    • 이 경우 연결을 끊어야 한다.
  • java.net.SocketException: Connection reset
    • RST 패킷을 받은 이후에 read() 호출
  • java.net.SocketException: Broken pipe
    • RST 패킷을 받은 이후에 write() 호출
  • java.net.SocketException: Socket is closed
    • 자신이 소켓을 닫은 이후에 read(), write() 호출

 

네트워크 종료와 예외 정리

네트워크에서 이런 예외들을 다 따로따로 이해하고 다루어야 할까? 사실 어떤 문제가 언제 발생할지 자세하게 다 구분해서 처리하기는 어렵다. 따라서, 기본적으로 정상 종료, 강제 종료 모두 자원을 정리하고 닫도록 설계하면 된다. 예를 들어서, SocketException, EOFException 모두 IOException의 자식이다. 따라서 IOException이 발생하면 자원을 정리하면 된다. 만약, 더 자세히 분류해야 하는 경우가 발생하면 그때 예외를 구분해서 처리하면 된다.

728x90
반응형
LIST

'JAVA의 가장 기본이 되는 내용' 카테고리의 다른 글

네트워크 1 (Socket)  (2) 2024.10.15
File, Files  (0) 2024.10.14
IO 활용  (2) 2024.10.13
IO 기본 2  (0) 2024.10.11
IO 기본 1  (0) 2024.10.11
728x90
반응형
SMALL

참고자료

 

김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션 강의 | 김영한 - 인프런

김영한 | I/O, 네트워크, 리플렉션, 애노테이션을 기초부터 실무 레벨까지 깊이있게 학습합니다. 웹 애플리케이션 서버(WAS)를 자바로 직접 만들어봅니다., 국내 개발 분야 누적 수강생 1위, 제대로

www.inflearn.com

 

자바 네트워크 프로그램에 대해 공부해보자. 여기서는 TCP/IP로 개발할 예정이다.

프로그램을 작성하기 전에 스레드 정보와 현재 시간을 출력하는 간단한 로깅 유틸리티를 만들자.

package cwchoiit.util;

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class MyLogger {

    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss.SSS");

    public static void log(Object object) {
        String time = LocalTime.now().format(formatter);
        System.out.printf("%s [%9s] %s\n", time, Thread.currentThread().getName(), object);
    }
}
  • 앞으로 대부분의 출력은 이 로깅 클래스를 사용하겠다.

이번에 만들 프로그램은 아주 간단한 네트워크 클라이언트, 서버 프로그램이다. 클라이언트가 "Hello"라는 문자를 서버에 전달하면 서버는 클라이언트의 요청에 " World!"라는 단어를 더해서 "Hello World!"라는 문장을 클라이언트에 응답한다.

  • 클라이언트 → 서버: "Hello"
  • 클라이언트 ← 서버: "Hello World!"

네트워크 프로그램 1

ClientV1

package cwchoiit.network.tcp.v1;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class ClientV1 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("클라이언트 시작");

        Socket socket = new Socket("localhost", PORT);

        DataInputStream input = new DataInputStream(socket.getInputStream());
        DataOutputStream output = new DataOutputStream(socket.getOutputStream());
        log("소켓 연결: " + socket);

        // 서버에게 문자 보내기
        String toSend = "Hello";
        output.writeUTF(toSend);
        log("client -> server: " + toSend);

        // 서버로부터 문자 받기
        String received = input.readUTF();
        log("client <- server: " + received);

        // 자원 정리
        log("연결 종료: " + socket);
        input.close();
        output.close();
        socket.close();
    }
}
  • 클라이언트 소스이다.

ServerV1

package cwchoiit.network.tcp.v1;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class ServerV1 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("서버 시작");

        ServerSocket serverSocket = new ServerSocket(PORT);
        log("서버 소켓 시작 - 리스닝 포트: " + PORT);

        Socket socket = serverSocket.accept();
        log("소켓 연결: " + socket);

        DataInputStream input = new DataInputStream(socket.getInputStream());
        DataOutputStream output = new DataOutputStream(socket.getOutputStream());

        // 클라이언트로부터 문자 받기
        String received = input.readUTF();
        log("client -> server: " + received);

        // 클라이언트에게 문자 보내기
        String toSend = received + " World!";
        output.writeUTF(toSend);
        log("client <- server: " + toSend);

        // 자원 정리
        log("연결 종료: " + socket);
        input.close();
        output.close();
        socket.close();
        serverSocket.close();
    }
}
  • 서버 소스이다.

서버를 먼저 실행하고, 그 다음에 클라이언트를 실행해야 한다.

 

실행 결과 - 클라이언트

13:48:52.354 [     main] 클라이언트 시작
13:48:52.373 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=51146]
13:48:52.373 [     main] client -> server: Hello
13:48:52.376 [     main] client <- server: Hello World!
13:48:52.376 [     main] 연결 종료: Socket[addr=localhost/127.0.0.1,port=12345,localport=51146]

참고로, 클라이언트의 localport는 랜덤으로 생성되므로, 다른 숫자가 나올 수 있다. 이 부분은 뒤에서 설명한다.

 

실행 결과 - 서버

13:48:37.708 [     main] 서버 시작
13:48:37.720 [     main] 서버 소켓 시작 - 리스닝 포트: 12345
13:48:52.373 [     main] 소켓 연결: Socket[addr=/127.0.0.1,port=51146,localport=12345]
13:48:52.375 [     main] client -> server: Hello
13:48:52.376 [     main] client <- server: Hello World!
13:48:52.376 [     main] 연결 종료: Socket[addr=/127.0.0.1,port=51146,localport=12345]

 

  • localhost (127.0.0.1)
    • localhost는 현재 사용중인 컴퓨터 자체를 가리키는 특별한 호스트 이름이다. google.com, naver.com과 같은 호스트 이름이지만, 자기 자신의 컴퓨터를 뜻하는 이름이다.
    • localhost는 127.0.0.1이라는 IP로 매핑된다.
    • 127.0.0.1은 IP 주소 체계에서 루프백 주소(loopback address)로 지정된 특별한 IP 주소이다. 이 주소는 컴퓨터가 스스로를 가리킬 때 사용되며, localhost와 동일하게 취급된다.
    • 127.0.0.1은 컴퓨터가 네트워크 인터페이스를 통해 외부로 나가지 않고, 자신에게 직접 네트워크 패킷을 보낼 수 있도록 한다.

주의! - 서버 연결 불가

java.net.ConnectException: Connection refused
  • 서버를 시작하지 않고, 클라이언트만 실행하면 해당 예외가 발생한다.
  • 커넥션 및 소켓과 관련된 다양한 예외들이 있는데, 이런 예외들은 뒤에서 한번에 정리하겠다.

주의 - BindException

Exception in thread "main" java.net.BindException: Address already in use
  • 만약, 이런 예외가 발생했다면 이미 12345라는 포트를 다른 프로세스가 사용하고 있다는 뜻이다. 포트를 다른 숫자로 변경해서 사용하자. 
  • 우리가 작성한 서버 프로그램을 아직 종료하지 않은 상태로 다시 실행하는 경우에도 12345 포트를 이미 점유하고 있으므로 같은 예외가 발생할 수 있다.

위 코드 분석하기

TCP/IP 통신에서는 통신할 대상 서버를 찾을 때 호스트 이름이 아니라, IP 주소가 필요하다. 네트워크 프로그램을 분석하기 전에 먼저 호스트 이름으로 IP를 어떻게 찾는지 확인해보자.

 

DNS 탐색

package cwchoiit.network.tcp.v1;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class InetAddressMain {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress localhost = InetAddress.getByName("localhost");
        System.out.println(localhost);

        InetAddress google = InetAddress.getByName("google.com");
        System.out.println(google);
    }
}

실행 결과

localhost/127.0.0.1
google.com/142.250.199.110

 

자바의 InetAddress 클래스를 사용하면, 호스트 이름으로 대상 IP를 찾을 수 있다. 찾는 과정은 다음과 같다.

  • 자바는 InetAddress.getByName("호스트명") 메서드를 사용해서 해당하는 IP 주소를 조회한다.
  • 이 과정에서 시스템의 호스트 파일을 먼저 확인한다.
    • /etc/hosts (Linux, Mac)
    • C:\Windows\System32\drivers\etc\hosts (Windows)
  • 호스트 파일에 정의되어 있지 않다면, DNS 서버에 요청해서 IP 주소를 얻는다.

호스트 파일 예시

127.0.0.1 localhost
255.255.255.255 broadcasthost
::1 localhost

 

만약, 호스트 파일에 localhost가 없다면, 127.0.0.1 localhost를 추가하거나, 127.0.0.1과 같은 IP를 직접 사용하면 된다.

 

클라이언트 코드 분석

클라이언트와 서버의 연결은 Socket을 사용한다.

Socket socket = new Socket("localhost", PORT)
  • (지금은 서버도 클라이언트도 동일한 PC이므로) localhost를 통해, 자신의 컴퓨터에 있는 12345 포트에 TCP 접속을 시도한다. 
    • localhost는 IP가 아니므로 해당하는 IP를 먼저 찾는다. 내부에서 InetAddress를 사용한다.
    • localhost는 127.0.0.1 이라는 IP에 매핑되어 있다.
    • 127.0.0.1:12345에 TCP 접속을 시도한다.
  • 연결이 성공적으로 완료되면, Socket 객체를 반환한다.
  • Socket은 서버와 연결되어 있는 연결점이라고 생각하면 된다.
  • Socket 객체를 통해서 서버와 통신할 수 있다.

클라이언트와 서버간의 데이터 통신은 Socket이 제공하는 스트림을 사용한다.

DataInputStream input = new DataInputStream(socket.getInputStream());
DataOutputStream output = new DataOutputStream(socket.getOutputStream());
  • Socket은 서버와 데이터를 주고 받기 위한 스트림을 제공한다.
  • 클라이언트 입장에서는,
    • InputStream: 서버에서 전달한 데이터를 클라이언트가 받을 때 사용한다.
    • OutputStream: 클라이언트에서 서버에 데이터를 전달할 때 사용한다.
    • InputStream, OutputStream을 그대로 사용하면 모든 데이터를 byte로 변환해서 전달해야 하기 때문에 번거롭다. 여기서는 DataInputStream, DataOutputStream이라는 보조 스트림을 사용해서, 자바 타입의 메시지를 편리하게 주고 받을 수 있도록 했다.
// 서버에게 문자 보내기 
String toSend = "Hello";
output.writeUTF(toSend);
  • OutputStream을 통해 서버에 "Hello" 메시지를 전송한다.
// 서버로부터 문자 받기
String received = input.readUTF();
  • InputStream을 통해 서버가 전달한 메시지를 받을 수 있다.
  • 클라이언트가 "Hello"를 전송하면 서버는 " World!"라는 문자를 붙여서 반환하므로 "Hello World!"라는 문자를 반환받는다.

사용한 자원은 반드시 정리해야 한다.

// 자원 정리
log("연결 종료: " + socket);
input.close(); 
output.close(); 
socket.close();

사용이 끝나면 사용한 자원은 반드시 반납해야 한다. 지금은 간단하고 허술하게 자원 정리를 했지만, 뒤에서 자원 정리를 매우 자세히 다루겠다.

 

서버 코드 분석

서버 소켓

서버는 특정 포트를 열어두어야 한다. 그래야 클라이언트가 해당 포트를 지정해서 접속할 수 있다.

ServerSocket serverSocket = new ServerSocket(PORT);
  • 서버는 서버 소켓(ServerSocket)이라는 특별한 소켓을 사용한다.
  • 지정한 포트를 사용해서 서버 소켓을 생성하면, 클라이언트는 해당 포트로 서버에 연결할 수 있다.

 

클라이언트와 서버의 연결 과정을 그림으로 자세히 알아보자.

  • 서버가 12345 포트로 서버 소켓을 열어둔다. 클라이언트는 이제 12345 포트로 서버에 접속할 수 있다.
  • 클라이언트가 12345 포트에 연결을 시도한다.
  • 이때 OS 계층에서 TCP 3 way handshake가 발생하고, TCP 연결이 완료된다.
  • TCP 연결이 완료되면 서버는 OS backlog queue라는 곳에 클라이언트와 서버의 TCP 연결 정보를 보관한다.
    • 이 연결 정보를 보면 클라이언트의 IP, PORT 서버의 IP, PORT 정보가 모두 들어있다.

클라이언트와 랜덤 포트

TCP 연결시에는 클라이언트, 서버 모두 IP와 PORT 정보가 필요하다. 예제에서 사용된 IP 포트는 다음과 같다.

  • 클라이언트 → localhost(127.0.0.1), 50000(랜덤 생성)
  • 서버 → localhost(127.0.0.1), 12345

그런데 생각해보면, 클라이언트는 자신의 포트를 지정한 적이 없다. 서버의 경우 포트가 명확하게 지정되어 있어야 한다. 그래야 클라이언트에서 서버에 어떤 포트에 접속할지 알 수 있다. 반면에 서버에 접속하는 클라이언트의 경우에는 자신의 포트가 명확하게 지정되어 있지 않아도 된다. 클라이언트는 보통 포트를 생략하는데, 생략할 경우 클라이언트 PC에 남아있는 포트 중 하나가 랜덤으로 할당된다. 참고로 클라이언트의 포트도 명시적으로 할당할 수 있지만, 잘 사용하지 않는다.

 

accept() 

Socket socket = serverSocket.accept();
  • 서버 소켓은 단지 클라이언트와 서버의 TCP 연결만 지원하는 특별한 소켓이다.
  • 실제 클라이언트와 서버가 정보를 주고 받으려면 Socket 객체가 필요하다. (서버 소켓이 아니다! 소켓이다!)
  • serverSocket.accept() 메서드를 호출하면 TCP 연결 정보를 기반으로, Socket 객체를 만들어서 반환한다.

accept() 호출 과정을 그림으로 자세히 알아보자.

  • accept()를 호출하면 backlog queue에서 TCP 연결 정보를 조회한다.
    • 만약, TCP 연결 정보가 없다면, 연결 정보가 생성될 때까지 대기한다. (블로킹)
  • 해당 정보를 기반으로 Socket 객체를 생성한다.
  • 사용한 TCP 연결 정보는 backlog queue에서 제거된다.

Socket 생성 후 그림

  • 클라이언트와 서버의 Socket은 TCP로 연결되어 있고, 스트림을 통해 메시지를 주고 받을 수 있다.
DataInputStream input = new DataInputStream(socket.getInputStream());
DataOutputStream output = new DataOutputStream(socket.getOutputStream());
  • Socket은 클라이언트와 서버가 데이터를 주고 받기 위한 스트림을 제공한다.
  • InputStream: 서버 입장에서 보면 클라이언트가 전달한 데이터를 서버가 받을 때 사용한다.
  • OutputStream: 서버에서 클라이언트에 데이터를 전달할 때 사용된다.
// 클라이언트로부터 문자 받기
String received = input.readUTF();
  • 클라이언트가 전달한 "Hello" 메시지를 전달 받는다.
// 클라이언트에게 문자 보내기
String toSend = received + " World!";
output.writeUTF(toSend);
  • 클라이언트의 메시지에 " World!" 메시지를 붙여서 반환한다.
  • OutputStream을 통해 서버에서 클라이언트로 메시지를 전송한다.
// 자원 정리
log("연결 종료: " + socket);
input.close(); 
output.close();
socket.close();
serverSocket.close();
  • 필요한 자원을 사용하고 나면, 꼭! 정리해야 한다.

 

문제

이 프로그램은 메시지를 하나만 주고 받으면 클라이언트와 서버가 모두 종료된다. 메시지를 계속 주고 받고, 원할 때 종료할 수 있도록 변경해보자.

 

네트워크 프로그램 2

이번엔 클라이언트와 서버가 메시지를 계속 주고 받다가, "exit" 라고 입력하면 클라이언트와 서버를 종료해보자.

 

ClientV2

package cwchoiit.network.tcp.v2;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

import static cwchoiit.util.MyLogger.log;

public class ClientV2 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        log("클라이언트 시작");

        Socket socket = new Socket("localhost", PORT);

        DataInputStream input = new DataInputStream(socket.getInputStream());
        DataOutputStream output = new DataOutputStream(socket.getOutputStream());
        log("소켓 연결: " + socket);

        while (true) {
            System.out.print("서버에게 보낼 문자를 입력하세요:");
            String message = scanner.nextLine();

            output.writeUTF(message);
            log("client -> server: " + message);

            if ("exit".equalsIgnoreCase(message)) {
                break;
            }

            // 서버로부터 문자 받기
            String received = input.readUTF();
            log("client <- server: " + received);
        }

        // 자원 정리
        log("연결 종료: " + socket);
        input.close();
        output.close();
        socket.close();
    }
}
  • 클라이언트와 서버가 메시지를 주고 받는 부분만 while로 반복하면 된다.
  • exit를 입력하면 클라이언트는 exit 메시지를 서버에 전송하고, 클라이언트는 while 문을 빠져나가면서 연결을 종료한다.

ServerV2

package cwchoiit.network.tcp.v2;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
import java.util.Scanner;

import static cwchoiit.util.MyLogger.log;

public class ServerV2 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("서버 시작");

        ServerSocket serverSocket = new ServerSocket(PORT);
        log("서버 소켓 시작 - 리스닝 포트: " + PORT);

        Socket socket = serverSocket.accept();
        log("소켓 연결: " + socket);

        DataInputStream input = new DataInputStream(socket.getInputStream());
        DataOutputStream output = new DataOutputStream(socket.getOutputStream());

        while (true) {
            // 클라이언트로부터 문자 받기
            String received = input.readUTF();
            log("client -> server: " + received);

            if (received.equalsIgnoreCase("exit")) {
                break;
            }

            String toSend = received + " World!";
            output.writeUTF(toSend);
            log("client <- server: " + toSend);
        }

        // 자원 정리
        log("연결 종료: " + socket);
        input.close();
        output.close();
        socket.close();
        serverSocket.close();
    }
}
  • 클라이언트와 서버가 메시지를 주고 받는 부분만 while로 반복하면 된다.
  • 클라이언트로부터 exit 메시지가 전송되면, 서버는 while문을 빠져나가면서 연결을 종료한다.

실행 결과 - 클라이언트

16:03:41.259 [     main] 클라이언트 시작
16:03:41.275 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=60687]
서버에게 보낼 문자를 입력하세요:hello
16:03:49.077 [     main] client -> server: hello
16:03:49.081 [     main] client <- server: hello World!
서버에게 보낼 문자를 입력하세요:hi
16:03:53.077 [     main] client -> server: hi
16:03:53.078 [     main] client <- server: hi World!
서버에게 보낼 문자를 입력하세요:exit
16:04:03.087 [     main] client -> server: exit
16:04:03.089 [     main] 연결 종료: Socket[addr=localhost/127.0.0.1,port=12345,localport=60687]

 

실행 결과 - 서버

16:03:34.700 [     main] 서버 시작
16:03:34.712 [     main] 서버 소켓 시작 - 리스닝 포트: 12345
16:03:41.275 [     main] 소켓 연결: Socket[addr=/127.0.0.1,port=60687,localport=12345]
16:03:49.077 [     main] client -> server: hello
16:03:49.080 [     main] client <- server: hello World!
16:03:53.077 [     main] client -> server: hi
16:03:53.078 [     main] client <- server: hi World!
16:04:03.088 [     main] client -> server: exit
16:04:03.089 [     main] 연결 종료: Socket[addr=/127.0.0.1,port=60687,localport=12345]

 

덕분에 클라이언트와 서버가 필요할 때까지 계속 매시지를 주고 받을 수 있다.

 

문제

서버는 하나의 클라이언트가 아니라, 여러 클라이언트의 연결을 처리할 수 있어야 한다. 여러 클라이언트가 하나의 서버에 접속하도록 해보자.

 

참고로, IntelliJ에서 같은 클라이언트를 동시에 실행하려면 다음과 같이 하면 된다.

  • Edit Configurations... 선택

  • Copy Configuration 클릭

  • 새로 만든 ClientV2Configuration을 저장한다.

  • 새로 만든 Configuration을 실행한다.

 

그렇게 실행하면 여러 클라이언트를 실행할 수 있다. 그런데 다음과 같이 정상적으로 수행되지 않는다.

16:12:03.789 [     main] 클라이언트 시작
16:12:03.804 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=61271]
서버에게 보낼 문자를 입력하세요:hello
16:13:20.652 [     main] client -> server: hello

 

  • 처음 접속한 클라이언트는 문제 없이 작동하는데, 두번째부터 새로 연결한 클라이언트는 소켓 연결과 보내는 것만 될 뿐, 돌아오지 않고 있다. 왜 이런 문제가 발생할까?

 

네트워크 프로그램 2 - 문제 분석

서버 소켓과 연결을 더 자세히 알아보자. 이번에는 여러 클라이언트가 서버에 접속한다고 가정해보자.

  • 서버는 12345 서버 소켓을 열어둔다.
  • 50000번 랜덤 포트를 사용하는 클라이언트가 먼저 12345 포트의 서버에 접속을 시도한다.
  • 이때, OS 계층에서 TCP 3 handshake가 발생하고, TCP 연결이 완료된다.
  • TCP 연결이 완료되면, 서버는 OS backlog queue라는 곳에 클라이언트와 서버의 TCP 연결 정보를 보관한다.

여기서 중요한 점이 있는데, 이 시점에 TCP 3 handshake가 완료되었기 때문에, 클라이언트와 서버의 TCP 연결은 이미 완료되고, 클라이언트의 소켓 객체도 정상 생성된다. 참고로 이 시점에 아직 서버의 소켓 객체(서버 소켓 아님)는 생성되지 않았다.

 

  • 이번에는 60000번 랜덤 포트를 사용하는 클라이언트가 12345 포트의 서버에 접속을 시도하고 연결을 완료한다.
  • 50000번 클라이언트와 60000번 클라이언트 모두 서버와 연결이 완료되었고, 클라이언트의 소켓도 정상 생성된다.

  • 서버가 클라이언트와 데이터를 주고 받으려면 소켓을 획득해야 한다.
  • ServerSocket.accept() 메서드를 호출하면 backlog 큐의 정보를 기반으로 소켓 객체를 하나 생성한다.
  • 큐이므로 순서대로 데이터를 꺼낸다. 처음 50000번 클라이언트의 접속 정보를 기반으로 서버에 소켓이 하나 생성된다.
  • 50000번 클라이언트와 서버는 소켓의 스트림을 통해 서로 데이터를 주고 받을 수 있다.

  • 그림에서 60000번 클라이언트도 이미 서버와 TCP 연결은 되어 있다. OS 계층에서 TCP 3 handshake가 발생하고, TCP 연결이 완료되었다.
  • 60000번 클라이언트도 서버와 TCP 연결이 되었기 때문에 서버로 메시지를 보낼 수 있다. 아직 서버에 Socket 객체가 없더라도, 메시지는 보낼 수 있다. 클라이언트는 Socket이 만들어진 상태고 TCP 연결은 이미 완료가 된 상태이니까.

그림을 보자. 소켓을 통해 스트림으로 메시지를 주고 받는다는 것은 이러한 과정을 거친다. 자바 애플리케이션은 소켓 객체의 스트림을 통해 서버와 데이터를 주고 받는다. 데이터를 주고 받는 과정은 다음과 같다.

클라이언트가 "Hello"라는 메시지를 서버에 전송할 때

  • 클라이언트: 애플리케이션 → OS TCP 송신 버퍼 → 클라이언트 네트워크 카드

클라이언트가 보낸 메시지가 서버에 도착했을 때

  • 서버: 서버 네트워크 카드 → OS TCP 수신 버퍼 → 애플리케이션

여기서, 60000번 클라이언트가 보낸 메시지는 서버 애플리케이션에서 아직 읽지 않았기 때문에, 서버 OS의 TCP 수신 버퍼에서 대기하게 된다. 여기서 핵심적인 내용이 있는데, 소켓 객체 없이 서버 소켓만으로도 TCP 연결은 완료된다는 점이다. (서버 소켓은 연결만 담당한다) 하지만 연결 이후에 서로 메시지를 주고 받으려면 소켓 객체가 필요하다.

 

accept()는 이미 연결된 TCP 연결 정보를 기반으로 서버 측에 소켓 객체를 생성한다. 그리고 이 소켓 객체가 있어야 스트림을 사용해서 메시지를 주고 받을 수 있다.

  • 이렇게 소켓을 연결하면 소켓의 스트림을 통해 OS TCP 수신 버퍼에 있는 메시지를 읽을 수 있고, 또 전송할 수도 있다.

  • 정상적으로 여러 클라이언트를 처리할 수 있는 서버라면, 이렇게 50000번, 60000번 클라이언트와 통신할 소켓 객체를 각각 만들어 통신할 수 있는 환경이 되면 다시 accept() 메서드가 블로킹 상태로 계속 대기해야 한다. 그래야 다음 클라이언트가 접속 시도를 할 때 정상적으로 소켓 객체를 만들 수 있으니까. 

그럼 지금 겪고 있는 문제의 원인은 이렇다.

  • 새로운 클라이언트가 접속하면?
    • 새로운 클라이언트가 접속했을 때, 서버의 main 스레드는 aceept() 메서드를 절대로 호출할 수 없다! 왜냐하면 while 문으로 기존 클라이언트와 메시지를 주고 받는 부분만 반복하기 때문이다.
    • accept()를 호출해야 소켓 객체를 생성하고 새로운 클라이언트와 메시지를 주고 받을 수 있다.
  • 2개의 블로킹 작업 - 핵심은 별도의 스레드가 필요하다!
    • accept() → 클라이언트와 서버의 연결을 처리하기 위해 대기
    • readUTF() 등 readXxx() → 클라이언트의 메시지를 받아서 처리하기 위해 대기
  • 각각의 블로킹 작업은 별도의 스레드에서 처리해야 한다. 그렇지 않으면 다른 블로킹 메서드 때문에 계속 대기할 수 있다.

즉, 지금 서버의 코드는 다음과 같이 두 부분이 블로킹 메서드이다.

ServerSocket serverSocket = new ServerSocket(PORT);
Socket socket = serverSocket.accept(); // 블로킹

while(true) {
    ...
    String received = input.readUTF(); // 블로킹
    output.writeUTF(toSend);
}

 

네트워크 프로그램 3

이번엔 위 문제를 해결하고자, 클라이언트가 동시에 접속할 수 있는 서버 프로그램을 작성해보자.

  • 서버의 main 스레드는 서버 소켓을 생성하고, 서버 소켓의 accept()를 반복해서 호출해야 한다.

  • 클라이언트가 서버에 접속하면 서버 소켓의 accept() 메서드가 Socket을 반환한다.
  • main 스레드는 이 정보를 기반으로 Runnable을 구현한 Session이라는 별도의 객체를 만들고, 새로운 스레드에서 이 객체를 실행한다. 여기서는 Thread-0Session을 실행한다.
  • Session 객체와 Thread-0은 연결된 클라이언트와 메시지를 주고 받는다.

  • 새로운 TCP 연결이 발생하면 main 스레드는 새로운 Session 객체를 별도의 스레드에서 실행한다. 그리고 이 과정을 반복한다. 
  • Session 객체와 Thread-1은 연결된 클라이언트와 메시지를 주고 받는다.

역할의 분리

  • main 스레드
    • main 스레드는 새로운 연결이 있을때마다 Session 객체와 별도의 스레드를 생성하고, 별도의 스레드가 Session 객체를 실행하도록 한다.
  • Session 담당 스레드
    • Session을 담당하는 스레드는 자신의 소켓이 연결된 클라이언트와 메시지를 반복해서 주고 받는 역할을 담당한다.

 

ClientV3

package cwchoiit.network.tcp.v3;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

import static cwchoiit.util.MyLogger.log;

public class ClientV3 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        log("클라이언트 시작");

        Socket socket = new Socket("localhost", PORT);

        DataInputStream input = new DataInputStream(socket.getInputStream());
        DataOutputStream output = new DataOutputStream(socket.getOutputStream());
        log("소켓 연결: " + socket);

        while (true) {
            System.out.print("서버에게 보낼 문자를 입력하세요:");
            String message = scanner.nextLine();

            output.writeUTF(message);
            log("client -> server: " + message);

            if ("exit".equalsIgnoreCase(message)) {
                break;
            }

            // 서버로부터 문자 받기
            String received = input.readUTF();
            log("client <- server: " + received);
        }

        // 자원 정리
        log("연결 종료: " + socket);
        input.close();
        output.close();
        socket.close();
    }
}
  • 클라이언트 코드는 기존 코드와 완전히 같다. 클래스 이름만 ClientV2 → ClientV3로 변경했다.

SessionV3

package cwchoiit.network.tcp.v3;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class SessionV3 implements Runnable {

    private final Socket socket;

    public SessionV3(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            DataInputStream input = new DataInputStream(socket.getInputStream());
            DataOutputStream output = new DataOutputStream(socket.getOutputStream());

            while (true) {
                // 클라이언트로부터 문자 받기
                String received = input.readUTF();
                log("client -> server: " + received);

                if (received.equalsIgnoreCase("exit")) {
                    break;
                }

                String toSend = received + " World!";
                output.writeUTF(toSend);
                log("client <- server: " + toSend);
            }

            input.close();
            output.close();
            socket.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
  • Session의 목적은 소켓이 연결된 클라이언트와 메시지를 반복해서 주고받는 것이다.
  • 생성자를 통해 Socket 객체를 입력 받는다.
  • Runnable을 구현해서 별도의 스레드에서 실행한다.

ServerV3

package cwchoiit.network.tcp.v3;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import static cwchoiit.util.MyLogger.log;

public class ServerV3 {

    private static final int PORT = 12345;

    public static void main(String[] args) throws IOException {
        log("서버 시작");

        ServerSocket serverSocket = new ServerSocket(PORT);
        log("서버 소켓 시작 - 리스닝 포트: " + PORT);

        while (true) {
            Socket socket = serverSocket.accept();

            SessionV3 session = new SessionV3(socket);
            Thread thread = new Thread(session);
            thread.start();
        }
    }
}
  • main 코드는 main 스레드가 작동하는 부분이다.
  • main 스레드는 서버 소켓을 생성하고, serverSocket.accept()를 호출해서 연결을 대기한다.
  • 새로운 연결이 추가될 때마다 Session 객체를 생성하고 별도의 스레드에서 Session 객체를 실행한다.
  • 이 과정을 반복한다.

실행결과 - ClientV3

17:59:18.232 [     main] 클라이언트 시작
17:59:18.248 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=65101]
서버에게 보낼 문자를 입력하세요:17:59:25.057 [     main] client -> server: hello
17:59:25.067 [     main] client <- server: hello World!
서버에게 보낼 문자를 입력하세요:

 

실행 결과 - ClientV3-2

17:59:34.482 [     main] 클라이언트 시작
17:59:34.498 [     main] 소켓 연결: Socket[addr=localhost/127.0.0.1,port=12345,localport=65103]
서버에게 보낼 문자를 입력하세요:17:59:39.294 [     main] client -> server: hoho
17:59:39.295 [     main] client <- server: hoho World!
서버에게 보낼 문자를 입력하세요:

 

실행 결과 - ServerV3

17:59:14.130 [     main] 서버 시작
17:59:14.143 [     main] 서버 소켓 시작 - 리스닝 포트: 12345
17:59:25.063 [ Thread-0] client -> server: hello
17:59:25.067 [ Thread-0] client <- server: hello World!
17:59:39.294 [ Thread-1] client -> server: hoho
17:59:39.294 [ Thread-1] client <- server: hoho World!

 

이제 여러 서버가 접속해도 문제없이 작동하는 것을 볼 수 있다. 그리고 각각의 연결이 별도의 스레드에서 처리되는 것도 확인할 수 있다. 

서버 소켓을 통해 소켓을 연결하는 부분과 각 클라이언트와 메시지를 주고 받는 부분이 별도의 스레드로 나뉘어 있다. 블로킹 되는 부분은 이렇게 별도의 스레드로 나누어 실행해야 한다.

 

문제

여기서 실행 중인 클라이언트를 IntelliJ의 빨간색 Stop 버튼을 눌러서 직접 종료해보자.

 

 

클라이언트를 직접 종료한 경우 서버 로그

Exception in thread "Thread-0" java.lang.RuntimeException: java.io.EOFException
	at cwchoiit.network.tcp.v3.SessionV3.run(SessionV3.java:42)
	at java.base/java.lang.Thread.run(Thread.java:857)
Caused by: java.io.EOFException
	at java.base/java.io.DataInputStream.readUnsignedShort(DataInputStream.java:337)
	at java.base/java.io.DataInputStream.readUTF(DataInputStream.java:583)
Caused by: java.io.EOFException

	at java.base/java.io.DataInputStream.readUTF(DataInputStream.java:558)
	at cwchoiit.network.tcp.v3.SessionV3.run(SessionV3.java:26)
	... 1 more

다음과 같이 에러가 발생했다. 에러가 어디서 발생했을까? 항상 에러 로그는 가장 아래서부터 봐야한다.

 

클라이언트의 연결을 직접 종료하면, 클라이언트 프로세스가 종료되면서, 클라이언트와 서버의 TCP 연결도 함께 종료된다. 이때 서버에서 readUTF()로 클라이언트가 보낸 메시지를 읽으려고 하면 EOFException이 발생한다. 소켓의 TCP 연결이 종료되었기 때문에 더는 읽을 수 있는 메시지가 없다는 뜻이다. EOF(파일의 끝)가 여기서는 전송의 끝이라는 뜻이다. 그런데 여기서 심각한 문제가 하나 있다. 이렇게 예외가 발생해버리면, 서버에서 자원 정리 코드를 호출하지 못한다는 점이다. 서버 로그를 보면 연결 종료 로그가 없는 것을 확인할 수 있다. 

 

// 자원 정리
input.close();
output.close();
socket.close();

자바 객체는 GC가 되지만, 자바 외부의 자원은 자동으로 GC가 되는게 아니다. 따라서, 꼭! 정리를 해주어야 한다. (TCP 연결의 경우 운영체제가 어느정도 연결을 정리해주지만, 직접 연결을 종료할 때보다 더 많은 시간이 걸릴 수 있다) 결론은, 이 자원 정리 코드가 예외가 발생하면서 catch 구문으로 빠져버리니 자원 정리 코드를 호출하지 못하게 된다는 점이다.

 

자원 정리는 정말 반드시 중요하게 짚고 넘어가야 하는 부분이다. 서버는 한번 키고 끄는 일회성이 아니라, 항시 켜져있어야 한다. 따라서 사용하지 않는 자원은 반드시 정리해야 한다. 그래서 이제부터 자원 정리에 대해 알아보는 시간을 가져보자.

 

 

자원 정리1

자원 정리를 이해하기 위해 간단한 예제 코드를 만들어보자.

 

CallException

package cwchoiit.network.tcp.autocloseable;

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

 

CloseException

package cwchoiit.network.tcp.autocloseable;

public class CloseException extends Exception {

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

 

ResourceV1

package cwchoiit.network.tcp.autocloseable;

public class ResourceV1 {
    private String name;

    public ResourceV1(String name) {
        this.name = name;
    }

    public void call() {
        System.out.println(name + " call");
    }

    public void callEx() throws CallException {
        System.out.println(name + " callEx");
        throw new CallException(name + " ex");
    }

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

    public void closeEx() throws CloseException {
        System.out.println(name + " closeEx");
        throw new CloseException(name + " ex");
    }
}
  • call(): 정상 로직 호출
  • callEx(): 비정상 로직 호출 CallException을 던진다.
  • close(): 정상 종료
  • closeEx(): 비정상 종료, CloseException을 던진다.

 

ResourceCloseMainV1

package cwchoiit.network.tcp.autocloseable;

public class ResourceCloseMainV1 {
    public static void main(String[] args) {
        try {
            logic();
        } catch (CallException e) {
            System.out.println("Call Exception 예외 처리");
            throw new RuntimeException(e);
        } catch (CloseException e) {
            System.out.println("Close Exception 예외 처리");
            throw new RuntimeException(e);
        }
    }

    private static void logic() throws CallException, CloseException {
        ResourceV1 resource1 = new ResourceV1("resource1");
        ResourceV1 resource2 = new ResourceV1("resource2");

        resource1.call();
        resource2.callEx();

        System.out.println("자원 정리");
        resource2.closeEx();
        resource1.close();
    }
}
  • 서로 관련된 자원은 나중에 생성한 자원을 먼저 정리해야 한다.
  • 예를 들어서, resource1을 생성하고, resource1의 정보를 활용해서 resource2를 생성한다면, 닫을 때는 그 반대인 resource2를 먼저 닫고, 그 다음에 resource1을 닫아야 한다. 왜냐하면 resource2의 입장에서 resource1의 정보를 아직 참고하고 있기 때문이다.
  • 이 예제에서는 두 자원이 서로 연관이 없기 때문에 생성과 종료 순서가 크게 상관이 없지만, resource1의 정보를 기반으로, resource2를 생성한다고 가정하겠다.

실행 결과

resource1 call
resource2 callEx
Call Exception 예외 처리
Exception in thread "main" java.lang.RuntimeException: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV1.main(ResourceCloseMainV1.java:9)
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceV1.callEx(ResourceV1.java:16)
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV1.logic(ResourceCloseMainV1.java:21)
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex

	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV1.main(ResourceCloseMainV1.java:6)
  • callEx()를 호출하면서 예외가 발생했다. 예외 때문에 자원 정리 코드가 정상 호출되지 않았다. 이 코드는 예외가 발생하면 자원이 정리되지 않는다는 문제가 있다.

 

자원 정리2

이번에는 예외가 발생해도 자원을 정리하도록 해보자.

 

ResourceCloseMainV2

package cwchoiit.network.tcp.autocloseable;

public class ResourceCloseMainV2 {
    public static void main(String[] args) {
        try {
            logic();
        } catch (CallException e) {
            System.out.println("Call Exception 예외 처리");
            throw new RuntimeException(e);
        } catch (CloseException e) {
            System.out.println("Close Exception 예외 처리");
            throw new RuntimeException(e);
        }
    }

    private static void logic() throws CallException, CloseException {

        ResourceV1 resource1 = null;
        ResourceV1 resource2 = null;
        try {
            resource1 = new ResourceV1("resource1");
            resource2 = new ResourceV1("resource2");

            resource1.call();
            resource2.callEx();
        } catch (CallException e) {
            System.out.println("ex " + e);
            throw e;
        } finally {
            System.out.println("자원 정리");
            if (resource2 != null) {
                resource2.closeEx();
            }
            if (resource1 != null) {
                resource1.close();
            }
        }
    }
}

 

실행 결과

resource1 call
resource2 callEx
ex cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
자원 정리
resource2 closeEx
Close Exception 예외 처리
Exception in thread "main" java.lang.RuntimeException: cwchoiit.network.tcp.autocloseable.CloseException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV2.main(ResourceCloseMainV2.java:12)
Caused by: cwchoiit.network.tcp.autocloseable.CloseException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceV1.closeEx(ResourceV1.java:25)
Caused by: cwchoiit.network.tcp.autocloseable.CloseException: resource2 ex

	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV2.logic(ResourceCloseMainV2.java:32)
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV2.main(ResourceCloseMainV2.java:6)

 

이 코드는 비즈니스 로직에서 예외가 발생했을 때도 자원을 잘 정리하는 것 같지만(그렇지도 않지만) 다음과 같은 문제들이 있다.

  • null 체크
    • 이번에는 finally 코드 블록을 사용해서 자원을 닫는 코드가 항상 호출되도록 했다. 만약, resource2 객체를 생성하기 전에 예외가 발생하면 resource2null이 된다. 따라서 null 체크를 해야한다. resource1의 경우에도 resource1을 생성하는 중에 예외가 발생한다면 null 체크가 필요하다.
  • 자원 정리 중에 예외가 발생하는 문제
    • finally 코드 블록은 항상 호출되기 때문에 자원이 잘 정리되는 것 같지만, 이번에는 자원을 정리하는 중에 finally 코드 블록 안에서 resource2.closeEx()를 호출하면서 예외가 발생한다. 결과적으로 resource1.close()는 호출되지 않는다.
  • 핵심 예외가 바뀌는 문제
    • 이 코드에서 발생한 핵심적인 예외는 CallException이다. 이 예외 때문에 문제가 된 것이다. 그런데 finally 코드 블록에서 자원을 정리하면서 CloseException 예외가 추가로 발생했다. 예외 때문에 자원을 정리하고 있는데, 자원 정리중에 또 예외가 발생한 것이다. 이 경우 logic()을 호출하는 쪽에서는 핵심 예외인 CallException이 아니라 finally 블록에서 새로 생성된 CloseException을 받게 된다. 핵심 예외가 사라진 것이다! 개발자가 원하는 예외는 당연히 핵심 예외다. 이 핵심 예외를 확인해야 제대로 된 문제를 찾을 수 있다. 자원을 닫는 중에 발생한 예외는 부가 예외일 뿐이다. 

정리하면 이 코드는 다음과 같은 문제가 있다.

  • close() 시점에서 실수로 예외를 던지면, 이후 다른 자원을 닫을 수 없는 문제 발생
  • finally 블럭 안에서 자원을 닫을 때 예외가 발생하면, 핵심 예외가 finally에서 발생한 부가 예외로 바뀌어 버린다. 그리고 핵심 예외가 사라진다.

 

자원 정리3

이번에는 자원 정리의 코드에서 try-catch를 사용해서 자원 정리 중에 발생하는 예외를 잡아서 처리해보자.

package cwchoiit.network.tcp.autocloseable;

public class ResourceCloseMainV3 {
    public static void main(String[] args) {
        try {
            logic();
        } catch (CallException e) {
            System.out.println("Call Exception 예외 처리");
            throw new RuntimeException(e);
        } catch (CloseException e) {
            System.out.println("Close Exception 예외 처리");
            throw new RuntimeException(e);
        }
    }

    private static void logic() throws CallException, CloseException {

        ResourceV1 resource1 = null;
        ResourceV1 resource2 = null;
        try {
            resource1 = new ResourceV1("resource1");
            resource2 = new ResourceV1("resource2");

            resource1.call();
            resource2.callEx();
        } catch (CallException e) {
            System.out.println("ex " + e);
            throw e;
        } finally {
            System.out.println("자원 정리");
            if (resource2 != null) {
                try {
                    resource2.closeEx();
                } catch (CloseException e) {
                    // close()에서 발생한 예외는 버린다. 필요하면 로깅 정도
                    System.out.println("close ex: " + e);
                }
            }
            if (resource1 != null) {
                try {
                    resource1.closeEx();
                } catch (CloseException e) {
                    System.out.println("close ex2: " + e);
                }
            }
        }
    }
}
  • finally 블럭에서 각각의 자원을 닫을 때도, 예외가 발생하면 예외를 잡아서 처리하도록 했다.
  • 이렇게 하면 자원 정리 시점에 예외가 발생해도, 다음 자원을 닫을 수 있다.
  • 자원 정리 시점에 발생한 예외는 잡아서 처리했기 때문에, 자원 정리 시점에 발생한 부가 예외가 핵심 예외를 가리지 않는다.
  • 자원 정리 시점에 발생한 예외는 당장 더 처리할 수 있는 부분이 없다. 이 경우 로그를 남겨서 개발자가 인지할 수 있게 하는 정도면 충분하다. 

실행 결과

resource1 call
resource2 callEx
ex cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
자원 정리
resource2 closeEx
close ex: cwchoiit.network.tcp.autocloseable.CloseException: resource2 ex
resource1 closeEx
close ex2: cwchoiit.network.tcp.autocloseable.CloseException: resource1 ex
Call Exception 예외 처리
Exception in thread "main" java.lang.RuntimeException: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV3.main(ResourceCloseMainV3.java:9)
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceV1.callEx(ResourceV1.java:16)
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV3.logic(ResourceCloseMainV3.java:25)
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex

	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV3.main(ResourceCloseMainV3.java:6)

이전에 발생했던 2가지 문제를 해결했다.

  • close() 시점에 예외가 발생하면, 이후 다른 자원을 닫을 수 없는 문제 발생
  • finally 블럭 안에서 자원을 닫을 때 예외가 발생하면, 핵심 예외가 finally에서 발생한 부가 예외로 바뀌어 버린다. 그리고 핵심 예외가 사라지는 현상

 

핵심적인 문제들은 해결되었지만, 코드 부분에서 보면 아쉬운 부분이 많다.

  • resource 변수를 선언하면서 동시에 할당할 수 없음(try, finally 코드 블록과 변수 스코프가 다른 문제)
  • catch 이후에 finally 호출, 자원 정리가 조금 늦어진다.
  • 개발자가 실수로 close()를 호출하지 않을 가능성
  • 개발자가 close() 호출 순서를 실수(보통 자원을 생성한 순서와 반대로 닫아야 하는데 순서를 실수할 경우)

지금까지 수많은 자바 개발자들이 자원 정리 때문에 고통을 받아왔다. 이런 문제를 한번에 해결하는 것이 바로 자바 중급1편에서 학습한 try-with-resource 구문이다.

 

자원 정리4

try-with-resource를 사용해서 자원 정리를 효율적으로 해보자.

 

ResourceV2

package cwchoiit.network.tcp.autocloseable;

public class ResourceV2 implements AutoCloseable {
    private final String name;

    public ResourceV2(String name) {
        this.name = name;
    }

    public void call() {
        System.out.println(name + " call");
    }

    public void callEx() throws CallException {
        System.out.println(name + " callEx");
        throw new CallException(name + " ex");
    }

    @Override
    public void close() throws CloseException {
        System.out.println(name + " close");
        throw new CloseException(name + " ex");
    }
}
  • AutoCloseable을 구현했다.
  • close()는 항상 CloseException을 던지도록 구현했다. (AutoCloseable을 구현한 객체가 close()가 호출될 때 예외가 발생하면 어떻게 행동하는지 알아보기 위함)

ResourceCloseMainV4

package cwchoiit.network.tcp.autocloseable;

public class ResourceCloseMainV4 {
    public static void main(String[] args) {
        try {
            logic();
        } catch (CallException e) {
            System.out.println("Call Exception 예외 처리");
            throw new RuntimeException(e);
        } catch (CloseException e) {
            System.out.println("Close Exception 예외 처리");
            throw new RuntimeException(e);
        }
    }

    private static void logic() throws CallException, CloseException {
        try (ResourceV2 resource1 = new ResourceV2("resource1");
             ResourceV2 resource2 = new ResourceV2("resource2")) {

            resource1.call();
            resource2.callEx();
        } catch (CallException e) {
            System.out.println("ex: " + e);
            throw e;
        }
    }
}

 

실행 결과

resource1 call
resource2 callEx
resource2 close
resource1 close
ex: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
Call Exception 예외 처리
Exception in thread "main" java.lang.RuntimeException: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV4.main(ResourceCloseMainV4.java:9)
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex
	at cwchoiit.network.tcp.autocloseable.ResourceV2.callEx(ResourceV2.java:16)
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV4.logic(ResourceCloseMainV4.java:21)
	at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV4.main(ResourceCloseMainV4.java:6)
	Suppressed: cwchoiit.network.tcp.autocloseable.CloseException: resource2 ex
		at cwchoiit.network.tcp.autocloseable.ResourceV2.close(ResourceV2.java:22)
		at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV4.logic(ResourceCloseMainV4.java:17)
		... 1 more
	Suppressed: cwchoiit.network.tcp.autocloseable.CloseException: resource1 ex
Caused by: cwchoiit.network.tcp.autocloseable.CallException: resource2 ex

		at cwchoiit.network.tcp.autocloseable.ResourceV2.close(ResourceV2.java:22)
		at cwchoiit.network.tcp.autocloseable.ResourceCloseMainV4.logic(ResourceCloseMainV4.java:17)
		... 1 more
  • try-with-resource는 단순하게 close()를 자동 호출해준다는 정도의 기능만 제공하는 것이 아니다. 고민한 6가지 문제를 모두 해결하는 장치이다.

2가지 핵심 문제

  • close() 시점에 예외가 던져지면, 이후 다른 자원을 닫을 수 없는 문제 발생
  • finally 블록 안에서 자원을 닫을 때 예외가 발생하면, 핵심 예외가 finally에서 발생한 부가 예외로 바뀌어 버린다. 그리고 핵심 예외가 사라진다.

4가지 부가 문제

  • resource 변수를 선언하면서 동시에 할당할 수 없음 (try, finally 코드 블록과 변수 스코프가 다른 문제)
  • catch 이후에 finally 호출, 자원 정리가 조금 늦어진다.
  • 개발자가 실수로 close()를 호출하지 않을 가능성
  • 개발자가 close() 호출 순서를 실수 (보통 자원을 생성한 순서와 반대로 닫아야 한다)

 

try-with-resource의 장점

  • 리소스 누수 방지: 모든 리소스가 제대로 닫히도록 보장한다. 실수로 finally 블록을 적지 않거나, finally 블록 안에서 자원 해제 코드를 누락하는 문제들을 예방할 수 있다.
  • 코드 간결성 및 가독성 향상: 명시적인 close() 호출이 필요 없어, 코드가 더 간결하고 읽기 쉬워진다.
  • 스코프 범위 한정: 예를 들어, 리소스로 사용되는 resource1, 2 변수의 스코프가 try 블록 안으로 한정된다. 따라서 코드 유지보수가 더 쉬워진다. 
  • 조금 더 빠른 자원 해제: 기존에는 try → catch → finallycatch 이후에 자원을 반납했다. try-with-resource 구문은 try 블럭이 끝나면 즉시 close()를 호출한다.
  • 자원 정리 순서: 먼저 선언한 자원을 나중에 정리한다. 
  • 부가 예외 포함: 이 내용은 무엇이냐면, 아까 ResourceV2 만들때, AutoCloseable을 구현하게 했고, close() 메서드를 오버라이딩했다. 그리고 그 메서드 안에서 예외를 던지도록 코드를 수정했었다. 그럼 try-with-resource 구문에서 자원이 해제될 때, 해당 예외가 발생할테니까 이 try-with-resource도 과연 핵심 예외가 부가 예외로 변경되어 밖으로 던져질지가 궁금했다. 근데 그게 아니라 정확히 핵심 예외가 밖으로 던져졌고, 자원을 해제하는 중에 터진 예외는 Suppressed로 추가된다. 아래 더 자세히 설명했다.

try-with-resources 예외 처리와 부가 예외 포함

try-with-resources를 사용하는 중에 핵심 로직 예외자원을 정리하는 중에 발생하는 부가 예외가 모두 발생하면 어떻게 될까?

  • try-with-resources는 핵심 예외를 반환한다.
  • 부가 예외는 핵심 예외안에 Suppressed로 담아서 반환한다.
  • 개발자는 자원 정리 중에 발생한 부가 예외를 e.getSuppressed()를 통해 활용할 수 있다.
  • try-with-resources를 사용하면 핵심 예외를 반환하면서, 동시에 부가 예외도 필요하면 확인할 수 있다. 

참고로 자바 예외는 e.addSuppressed(ex)라는 메서드가 있어서 예외 안에 참고할 예외를 담아둘 수 있다. 참고로 이 기능도 try-with-resources와 함께 등장했다.

 

 

다음 포스팅에서 계속...

 

728x90
반응형
LIST

'JAVA의 가장 기본이 되는 내용' 카테고리의 다른 글

네트워크 2 (Socket)  (0) 2024.10.16
File, Files  (0) 2024.10.14
IO 활용  (2) 2024.10.13
IO 기본 2  (0) 2024.10.11
IO 기본 1  (0) 2024.10.11
728x90
반응형
SMALL

참고자료

 

김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션 강의 | 김영한 - 인프런

김영한 | I/O, 네트워크, 리플렉션, 애노테이션을 기초부터 실무 레벨까지 깊이있게 학습합니다. 웹 애플리케이션 서버(WAS)를 자바로 직접 만들어봅니다., 국내 개발 분야 누적 수강생 1위, 제대로

www.inflearn.com

 

File

자바에서 파일 또는 디렉토리를 다룰 때는 File 또는 Files, Path 클래스를 사용하면 된다. 이 클래스들을 사용하면 파일이나 폴더를 생성하고, 삭제하고, 또 정보를 확인할 수 있다.

 

먼저 File 클래스를 사용해보자. 이 방식은 오래된 방식으로 이제는 새로운 방식인 Files를 더 많이 사용하긴 하지만, 여전히 알아두어야 한다.

 

OldFileMain

package cwchoiit.io.file;

import java.io.File;
import java.io.IOException;
import java.util.Date;

public class OldFileMain {

    public static void main(String[] args) throws IOException {
        File file = new File("temp/example.txt");
        File directory = new File("temp/exampleDir");

        // 1. 파일이나 디렉토리의 존재 여부를 확인
        System.out.println("file exists: " + file.exists());
        System.out.println("directory exists: " + directory.exists());

        // 2. 파일과 디렉토리를 생성
        boolean created = file.createNewFile();
        boolean dirCreated = directory.mkdir();
        System.out.println("file created: " + created);
        System.out.println("Directory created: " + dirCreated);

        // 3. 파일과 디렉토리 삭제
        boolean deleted = file.delete();
        boolean deletedDir = directory.delete();
        System.out.println("File deleted: " + deleted);
        System.out.println("Directory deleted: " + deletedDir);

        // 4. 파일인지 디렉토리인지 
        System.out.println("is file: " + file.isFile());
        System.out.println("is directory: " + directory.isDirectory());
        
        // 5. 파일 이름, 사이즈
        System.out.println("File Name: " + file.getName());
        System.out.println("File Size: " + file.length());

        // 6. 파일 이름 바꾸기
        File newFile = new File("temp/newExample.txt");
        boolean renamed = file.renameTo(newFile);
        System.out.println("File renamed: " + renamed);

        // 7. 파일의 마지막 변경 시간
        long lastModified = newFile.lastModified();
        System.out.println("last modified: " + new Date(lastModified));
    }
}

실행 결과

file exists: false
directory exists: true
file created: true
Directory created: false
File deleted: true
Directory deleted: true
is file: false
is directory: false
File Name: example.txt
File Size: 0
File renamed: false
last modified: Mon Oct 14 20:50:57 KST 2024

 

File은 파일과 디렉토리를 둘 다 다룬다. 참고로 File 객체를 생성했다고 파일이나 디렉토리가 바로 만들어지는 것은 아니다. 메서드를 통해 생성해야 한다. File과 같은 클래스들은 학습해야 할 중요한 원리가 있는 것이 아니라, 다양한 기능의 모음을 제공한다. 이런 클래스의 기능들은 외우기 보다는 이런 것들이 있다 정도만 간단히 알아두고, 필요할 때 찾아서 사용하면 된다. 

 

Files

File, Files의 역사

자바 1.0에서 File 클래스가 등장했다. 이후에 자바 1.7에서 File 클래스를 대체할 FilesPath가 등장했다.

 

Files의 특징 

  • 성능과 편의성이 모두 개선되었다.
  • File은 과거에 호환을 유지하기 위해 남겨둔 기능이다. 이제는 Files 사용을 먼저 고려하자.
  • 여기에는 수많은 유틸리티 기능이 있다. File 클래스는 물론이고, File과 관련된 스트림(FileInputStream, FileWriter)의 사용을 고민하기 전에 Files에 있는 기능을 먼저 찾아보자. 성능도 좋고, 사용하기도 더 편리하다.
  • 기능이 너무 많기 때문에 주요 기능만 알아보고, 나머지는 필요할 때 검색하자.
  • 이렇게 기능 위주의 클래스는 외우는 것이 아니다. 이런게 있다 정도의 주요 기능만 알아두고, 나머지는 필요할 때 검색하면 된다.

 

앞서 작성한 코드를 Files로 그대로 사용해보자. 참고로 Files를 사용할 때 파일이나, 디렉토리의 경로는 Path 클래스를 사용해야 한다.

package cwchoiit.io.file;

import java.io.IOException;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAttributes;

public class NewFilesMain {
    public static void main(String[] args) throws IOException {
        Path file = Path.of("temp/example.txt");
        Path directory = Path.of("temp/exampleDir");

        // 1. exists(): 파일이나 디렉토리의 존재 여부를 확인
        System.out.println("File exists: " + Files.exists(file));

        // 2. createFile(): 새 파일을 생성
        try {
            Files.createFile(file);
            System.out.println("File created");
        } catch (FileAlreadyExistsException e) {
            System.out.println(file + " already exists");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        // 3. createDirectory(): 새 디렉토리를 생성
        try {
            Files.createDirectory(directory);
            System.out.println("Directory created");
        } catch (FileAlreadyExistsException e) {
            System.out.println(directory + " already exists");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        // 4. delete(): 파일이나 디렉토리를 삭제
        /*try {
            Files.delete(file);
            System.out.println("File deleted");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }*/

        // 5. isRegularFile(): 일반 파일인지 확인
        System.out.println("is regular file: " + Files.isRegularFile(file));
        // 6. isDirectory(): 디렉토리인지 확인
        System.out.println("is directory: " + Files.isDirectory(directory));
        // 7. getFileName(): 파일이나 디렉토리의 이름을 반환
        System.out.println("File name: " + file.getFileName());
        // 8. size(): 파일의 크기를 바이트 단위로 반환
        System.out.println("File size: " + Files.size(file) + " bytes");

        // 9. move(): 파일의 이름을 변경하거나 이동
        Path newFile = Path.of("temp/newExample.txt");
        Files.move(file, newFile, StandardCopyOption.REPLACE_EXISTING);
        System.out.println("File moved");

        // 10. getLastModifiedTime(): 마지막으로 수정된 시간을 반환
        System.out.println("Last modified: " + Files.getLastModifiedTime(newFile));

        // 추가: readAttributes(): 파일의 기본 속성들을 한 번에 읽기
        BasicFileAttributes attrs = Files.readAttributes(newFile, BasicFileAttributes.class);
        System.out.println("========= Attributes ========");
        System.out.println("Creation time: " + attrs.creationTime());
        System.out.println("Is directory: " + attrs.isDirectory());
        System.out.println("Is regular file: " + attrs.isRegularFile());
        System.out.println("Is symbolic link: " + attrs.isSymbolicLink());
        System.out.println("Size: " + attrs.size());
    }
}
  • Files는 직접 생성할 수 없고, static 메서드를 통해 기능을 제공한다.

실행 결과

File exists: false
File created
temp/exampleDir Directory already exists
Is regular file: true
Is directory: true
File name: example.txt
File size: 0 bytes
File moved/renamed
Last modified: 2024-09-03T06:32:09.182412076Z
===== Attributes =====
Creation time: 2024-09-03T06:32:09Z
Is directory: false
Is regular io.file: true
Is symbolic link: false
Size: 0

 

경로 표시

파일이나 디렉토리가 있는 경로는 크게 절대 경로와 정규 경로로 나눌 수 있다.

 

File을 사용한 경로 표시

package cwchoiit.io.file;

import java.io.File;
import java.io.IOException;

public class OldFilePath {
    public static void main(String[] args) throws IOException {
        // 앞에 아무것도 없고 "temp/.." 이렇게 되면 자바가 시작되는 지점부터다. (상대 경로)
        File file = new File("temp/..");
        System.out.println("path: " + file.getPath());

        // 절대 경로
        System.out.println("Absolute path: " + file.getAbsolutePath());

        // 정규 경로 ("temp/.."에서 ..을 다 계산한 결과를 정규 경로라 한다)
        System.out.println("Canonical path: " + file.getCanonicalPath());

        File[] files = file.listFiles();
        for (File f : files) {
            System.out.println((f.isDirectory() ? "D" : "F") + " | " + f.getName());
        }
    }
}

실행 결과

path = temp/..
Absolute path = /Users/yh/study/inflearn/java/java-adv2/temp/..
Canonical path = /Users/yh/study/inflearn/java/java-adv2
D | temp
F | java-adv2-v1.iml
D | out
F | .gitignore
D | .idea
D | src
  • 절대 경로(Absolute Path): 절대 경로는 경로의 처음부터 내가 입력한 모든 경로를 다 표현한다.
  • 정규 경로(Canonical Path): 경로의 계산이 모두 끝난 경로이다. 정규 경로는 하나만 존재한다. 예제에서 `..`은 바로 위의 상위 디렉토리를 뜻한다. 이런 경로의 계산을 모두 처리하면 하나의 경로만 남는다.
  • 그래서 절대 경로는 다음 2가지 경로가 모두 가능하지만,
    • /Users/yh/study/inflearn/java/java-adv2 
    • /Users/yh/study/inflearn/java/java-adv2/temp/..
  • 정규 경로는 다음 하나만 가능하다.
    •  /Users/yh/study/inflearn/java/java-adv2

 

file.listFiles()

  • 현재 경로에 있는 모든 파일 또는 디렉토리를 반환한다.
  • 파일이면 F, 디렉토리면 D로 표현했다.

 

 

FIles를 사용한 경로 표시

package cwchoiit.io.file;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.stream.Stream;

public class NewFilesPath {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("temp/..");
        System.out.println("path: " + path);

        // 절대 경로
        System.out.println("Absolute path: " + path.toAbsolutePath());

        // 정규 경로
        System.out.println("Canonical path: " + path.toRealPath());

        Stream<Path> pathStream = Files.list(path);
        pathStream.forEach(p -> System.out.println((Files.isRegularFile(p) ? "F" : "D") + " | " + p.getFileName()));
        pathStream.close();
    }
}

실행 결과

path = temp/..
Absolute path = /Users/yh/study/inflearn/java/java-adv2/temp/..
Canonical path = /Users/yh/study/inflearn/java/java-adv2
D | temp
F | java-adv2-v1.iml
D | out
F | .gitignore
D | .idea
D | src

 

Files.list(path)

  • 현재 경로에 있는 모든 파일 또는 디렉토리를 반환한다.
  • 파일이면 F, 디렉토리면 D로 표현했다.

 

Files로 문자 파일 읽기

문자로된 파일을 읽고 쓸 때 과거에는 FileReader, FileWriter 같은 복잡한 스트림 클래스를 사용해야 했다. 거기에 모든 문자를 읽으려면 반복문을 사용해서 파일의 끝까지 읽어야 하는 과정을 추가해야 했다. 또 한 줄 단위로 파일을 읽으려면 BufferedReader와 같은 스트림 클래스를 추가해야 했다.

 

Files는 이런 문제를 코드 한 줄로 깔끔하게 해결해준다.

 

Files - 모든 문자 읽기

package cwchoiit.io.file.text;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;

public class ReadTextFileV1 {

    private static final String PATH = "temp/hello2.txt";

    public static void main(String[] args) throws IOException {
        String writeString = "abc\n가나다";
        System.out.println("== Write String ==");
        System.out.println(writeString);

        Path path = Path.of(PATH);

        // 파일에 쓰기
        Files.writeString(path, writeString, StandardCharsets.UTF_8);

        // 파일에서 읽기
        String readString = Files.readString(path, StandardCharsets.UTF_8);

        System.out.println("== Read String ==");
        System.out.println(readString);
    }
}

실행 결과

== Write String == 
abc
가나다
== Read String == 
abc
가나다
  • Files.writeString(): 파일에 쓰기
  • Files.readString(): 파일에서 모든 문자 읽기

Files를 사용하면 아주 쉽게 파일에 문자를 쓰고 읽을 수 있다.

 

Files - 라인 단위로 읽기

package cwchoiit.io.file.text;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Stream;

public class ReadTextFileV2 {

    private static final String PATH = "temp/hello2.txt";

    public static void main(String[] args) throws IOException {
        String writeString = "abc\n가나다";
        System.out.println("== Write String ==");
        System.out.println(writeString);

        Path path = Path.of(PATH);

        // 파일에 쓰기
        Files.writeString(path, writeString, StandardCharsets.UTF_8);

        // 파일에서 읽기 (라인별)
        List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
        System.out.println("== Read String ==");
        for (int i = 0; i < lines.size(); i++) {
            System.out.println((i + 1) + ": " + lines.get(i));
        }
    }
}

실행 결과

== Write String == 
abc
가나다
== Read String == 
1: abc
2: 가나다
  • Files.readAllLines(path) → 파일을 한번에 다 읽고, 라인 단위로 List에 나누어 저장하고 반환한다.

근데 이런 경우, 모든 라인을 일단 다 읽어서 리스트에 저장하기 때문에 파일이 엄청 크면 메모리를 매우 많이 차지하거나, 아예 OOM이 터질수도 있다. 그래서 파일을 한 줄 단위로 나누어 읽고, 메모리 사용량을 줄이고 싶다면 다음 기능을 사용하면 된다. 다만, 이 기능을 제대로 이해하려면, 람다와 스트림을 알아야 한다. 

// 파일에서 읽기 (라인별 - 스트림)
try (Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8)) {
    lines.forEach(System.out::println);
}
  • 파일을 스트림 단위로 나누어 조회한다. (I/O 스트림이 아니라, 람다와 스트림에서 사용하는 스트림이다)
  • 파일이 아주 크다면 한 번에 모든 파일을 다 메모리에 올리는 것보다, 파일을 부분 부분 나누어 메모리에 올리는 것이 더 나은 선택일 수 있다. 
  • 예를 들어, 파일의 크기가 1000MB라면 한번에 1000MB의 파일이 메모리에 불러진다. 앞서, Files.readAllLines의 경우, List에 1000MB의 파일이 모두 올라간다.
  • 이 기능을 사용하면 파일을 한 줄 단위로 메모리에 올릴 수 있다. 한 줄 당 1MB의 용량을 사용한다면 자바는 파일에서 한번에 1MB의 데이터만 메모리에 올려 처리한다. 그리고 처리가 끝나면 다음 줄을 호출하고, 기존에 사용한 1MB의 데이터는 GC한다.
  • 용량이 아주 큰 파일을 처리해야 한다면, 이런 방식으로 나누어 처리하는 것이 효과적이다.
  • 참고로 용량이 너무 커서 자바 메모리에 한번에 불러오는 것이 불가능할 수 있다. 그때는 이런 방식으로 처리해야만 한다.
  • 물론, BufferedReader를 통해서도 한 줄 단위로 이렇게 나누어 처리하는 것이 가능하다. 여기서 핵심은 매우 편리하게 문자를 나누어 처리하는 것이 가능하다는 점이다.

 

파일 복사 최적화

이번에는 파일을 복사하는 효율적인 방법에 대해 알아보자. 예제를 위해서 200MB 임시 파일을 하나 만들어보자.

package cwchoiit.io.file.copy;

import java.io.FileOutputStream;
import java.io.IOException;

public class CreateCopyFile {

    private static final int FILE_SIZE = 200 * 1024 * 1024; // 200MB

    public static void main(String[] args) throws IOException {
        String fileName = "temp/copy.dat";
        long startTime = System.currentTimeMillis();

        FileOutputStream fos = new FileOutputStream(fileName);
        byte[] bytes = new byte[FILE_SIZE];
        fos.write(bytes);
        fos.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File created: " + fileName);
        System.out.println("File size: " + FILE_SIZE / 1024 / 1024 + "MB");
        System.out.println("Time taken: " + (endTime - startTime) + "ms");
    }
}

실행 결과

File created: temp/copy.dat
File size: 200MB
Time taken: 69ms

 

이렇게 만들어진 파일을 다른 파일로 복사하는 여러 가지 방법을 알아보자. 그리고 가장 효율적인 방법을 알아보자.

 

파일 복사 예제1

package cwchoiit.io.file.copy;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyMainV1 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("temp/copy.dat");
        FileOutputStream fos = new FileOutputStream("temp/copy_new.dat");

        byte[] bytes = fis.readAllBytes();
        fos.write(bytes);

        fos.close();
        fis.close();
        long endTime = System.currentTimeMillis();

        System.out.println("Time taken : " + (endTime - startTime) + " ms");
    }
}

실행 결과

Time taken: 109ms
  • FileInputStream에서 readAllBytes를 통해, 한번에 모든 데이터를 읽고 write(bytes)를 통해 한번에 모든 데이터를 저장한다.
  • 파일(copy.dat) → 자바(byte) → 파일(copy_new.dat)의 과정을 거친다.
  • 자바가 copy.dat 파일의 데이터를 자바 프로세스가 사용하는 메모리에 불러온다. 그리고 메모리에 있는 데이터를 copy_new.dat에 전달한다.

파일 복사 예제2

package cwchoiit.io.file.copy;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyMainV2 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("temp/copy.dat");
        FileOutputStream fos = new FileOutputStream("temp/copy_new.dat");

        fis.transferTo(fos);

        fos.close();
        fis.close();
        long endTime = System.currentTimeMillis();

        System.out.println("Time taken : " + (endTime - startTime) + " ms");
    }
}

실행 결과

Time taken: 70ms
  • InputStream에는 transferTo()라는 특별한 메서드가 있다 (자바 9부터 제공)
  • 이 메서드는 InputStream에서 읽은 데이터를 바로 OutputStream으로 출력한다.
  • transferTo()는 성능 최적화가 되어 있기 때문에, 앞의 예제와 비슷하거나 조금 더 빠르다.
  • 파일(copy.dat) → 자바(byte) → 파일(copy_new.dat)의 과정을 거친다.
  • transferTo() 덕분에 파일을 읽고 바이트로 변환한 값을 다시 파일에 쓰는 코드를 생략할 수 있다.

파일 복사 예제3

package cwchoiit.io.file.copy;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

public class FileCopyMainV3 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();

        Path source = Path.of("temp/copy.dat");
        Path target = Path.of("temp/copy_new.dat");

        Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);

        long endTime = System.currentTimeMillis();
        System.out.println("Time taken : " + (endTime - startTime) + " ms");
    }
}

실행 결과

Time taken: 37ms
  • Files.copy() → 앞의 예제들은 파일을 복사할 때 다음 과정을 거쳤다.
    • 파일(copy.dat) → 자바(byte) → 파일(copy_new.dat)의 과정을 거친다.
  • 이 과정들은 파일의 데이터를 자바로 불러오고, 또 자바에서 읽은 데이터를 다시 파일에 전달해야 한다.
  • Files.copy()는 자바에서 파일 데이터를 불러오지 않고, 운영체제의 파일 복사 기능을 사용한다. 따라서 자바로 데이터를 불러오는 과정이 필요가 없다. 그러므로 가장 빠르다.

 

정리를 하자면

파일을 다루어야 할 일이 있다면 항상 Files의 기능을 먼저 찾아보자. 파일을 읽거나 쓸 때도 스트림 대신 매우 편리하게 읽고 쓸 수 있고, 생성이나 복사 등 여러 방면에서 좋은 점이 많다. File은 예전 방식이고 이제는 먼저 고려할건 Files다.

728x90
반응형
LIST

'JAVA의 가장 기본이 되는 내용' 카테고리의 다른 글

네트워크 2 (Socket)  (0) 2024.10.16
네트워크 1 (Socket)  (2) 2024.10.15
IO 활용  (2) 2024.10.13
IO 기본 2  (0) 2024.10.11
IO 기본 1  (0) 2024.10.11
728x90
반응형
SMALL

참고자료

 

김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션 강의 | 김영한 - 인프런

김영한 | I/O, 네트워크, 리플렉션, 애노테이션을 기초부터 실무 레벨까지 깊이있게 학습합니다. 웹 애플리케이션 서버(WAS)를 자바로 직접 만들어봅니다., 국내 개발 분야 누적 수강생 1위, 제대로

www.inflearn.com

 

이전 포스팅에서 여러가지 스트림을 배워봤다. 그리고 마지막 즈음에 말했던 DataStream은 파일에 자바 타입 그대로를 저장할 수 있는 꽤나 신기하지만? 어디에 이게 활용이 될까?싶은 스트림이 있었다. 이 포스팅에서는 이 녀석의 활용처를 알아보고자 한다.

 

일단 그러기에 앞서, 예제를 만들고 왜 이걸 사용하면 좋은지를 먼저 알아보자.

 

회원 관리 예제1 - 메모리

I/O를 사용해서 회원 데이터를 관리하는 예제를 만들어보자.

 

요구사항

  • 회원 관리 프로그램을 작성해라.
  • 회원의 속성은 다음과 같다
    • ID
    • Name
    • Age
  • 회원을 등록하고, 등록한 회원의 목록을 조회할 수 있어야 한다.

 

프로그램 작동 예시

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 1
ID 입력: id1
Name 입력: name1
Age 입력: 20
회원이 성공적으로 등록되었습니다.

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 1
ID 입력: id2
Name 입력: name2
Age 입력: 30
회원이 성공적으로 등록되었습니다.

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 2
회원 목록:
[ID: id1, Name: name1, Age: 20] 
[ID: id2, Name: name2, Age: 30]

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 3
프로그램을 종료합니다.

 

Member

package cwchoiit.io.member;

public class Member {
    private String id;
    private String name;
    private Integer age;

    public Member() {
    }

    public Member(String id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Member{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 

MemberRepository

package cwchoiit.io.member;

import java.util.List;

public interface MemberRepository {
    void add(Member member);

    List<Member> findAll();
}
  • add(): 회원 객체를 저장한다.
  • findAll(): 저장한 회원 객체를 List로 모두 조회한다.
  • Repository는 저장소라는 뜻이다.

MemoryMemberRepository

package cwchoiit.io.member.impl;

import cwchoiit.io.member.Member;
import cwchoiit.io.member.MemberRepository;

import java.util.ArrayList;
import java.util.List;

public class MemoryMemberRepository implements MemberRepository {

    private final List<Member> members = new ArrayList<>();

    @Override
    public void add(Member member) {
        members.add(member);
    }

    @Override
    public List<Member> findAll() {
        return members;
    }
}
  • 간단하게 메모리에 회원을 저장하고 관리하자.
  • 회원을 저장하면 내부에 있는 members 리스트에 회원이 저장된다.
  • 회원을 조회하면 members 리스트가 반환된다.

MemberConsoleMain

package cwchoiit.io.member;

import cwchoiit.io.member.impl.FileMemberRepository;
import cwchoiit.io.member.impl.MemoryMemberRepository;

import java.util.List;
import java.util.Scanner;

public class MemberConsoleMain {

    // private static final MemberRepository repository = new MemoryMemberRepository();
    private static final MemberRepository repository = new FileMemberRepository();

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("1. 회원 등록 | 2. 회원 목록 조회 | 3. 종료");
            System.out.print("선택: ");
            int choice = scanner.nextInt();
            scanner.nextLine();

            switch (choice) {
                case 1:
                    // 회원 등록
                    registerMember(scanner);
                    break;
                case 2:
                    // 회원 목록 조회
                    displayMembers();
                    break;
                case 3:
                    System.out.println("프로그램을 종료합니다.");
                    return;
                default:
                    System.out.println("잘못된 선택입니다. 다시 입력하세요.");
            }
        }
    }

    private static void registerMember(Scanner scanner) {
        System.out.print("ID 입력:");
        String id = scanner.nextLine();

        System.out.print("Name 입력:");
        String name = scanner.nextLine();

        System.out.print("Age 입력:");
        int age = scanner.nextInt();
        scanner.nextLine();

        Member member = new Member(id, name, age);
        repository.add(member);
        System.out.println("회원이 성공적으로 등록되었습니다.");
    }

    private static void displayMembers() {
        List<Member> members = repository.findAll();
        System.out.println("회원 목록");
        for (Member member : members) {
            System.out.printf("[ID: %s, Name: %s, Age: %d]\n", member.getId(), member.getName(), member.getAge());
        }
    }
}
  • 콘솔을 통해 회원 등록, 목록 조회 기능을 제공한다.

실행 결과 - 회원 등록

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 1
ID 입력: id1
Name 입력: name1
Age 입력: 20
회원이 성공적으로 등록되었습니다.

 

실행 결과 - 목록 조회

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 2
회원 목록:
[ID: id1, Name: name1, Age: 20]

 

실행 결과 - 종료

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 3
프로그램을 종료합니다.

 

 

문제점

의도대로 잘 구현이 됐다. 그런데 이 프로그램의 문제가 있다. 어떤거냐면, 데이터를 메모리에 보관하기 때문에, 자바를 종료하면 모든 회원 종료가 사라진다. 따라서 프로그램을 다시 실행하면 모든 회원 데이터가 사라진다. 프로그램을 종료하고 다시 실행해도 회원 데이터가 영구 보존되어야 한다.

 

회원 관리 예제2 - 파일에 보관

회원 데이터를 영구 보존하려면 파일에 저장하면 된다. 다음과 같이 한 줄 단위로 회원 데이터를 파일에 저장해보자.

temp/members-txt.dat

id1,member1,20
id2,member2,30
  • 여기서는 문자를 파일에 저장한다. 문자를 다루므로 Reader, Writer를 사용하는 것이 편리하다.
  • 한 줄 단위로 처리할 때는 BufferedReader가 유용하므로, BufferedReader, BufferedWriter를 사용해보자.

FileMemberRepository

package cwchoiit.io.member.impl;

import cwchoiit.io.member.Member;
import cwchoiit.io.member.MemberRepository;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

import static java.nio.charset.StandardCharsets.UTF_8;

public class FileMemberRepository implements MemberRepository {

    private static final String FILE_PATH = "temp/members-txt.dat";
    private static final String DELIMITER = ",";

    @Override
    public void add(Member member) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(FILE_PATH, UTF_8, true))) {
            bw.write(member.getId() + DELIMITER + member.getName() + DELIMITER + member.getAge());
            bw.newLine();
        } catch (IOException e) {
            throw new RuntimeException("Fail to write member data to file.", e);
        }
    }

    @Override
    public List<Member> findAll() {
        List<Member> members = new ArrayList<>();
        try (BufferedReader br = new BufferedReader(new FileReader(FILE_PATH, UTF_8))) {
            String line;
            while ((line = br.readLine()) != null) {
                String[] memberData = line.split(DELIMITER);
                members.add(new Member(memberData[0], memberData[1], Integer.valueOf(memberData[2])));
            }
            return members;
        } catch (FileNotFoundException e) {
            return new ArrayList<>();
        } catch (IOException e) {
            throw new RuntimeException("Fail to read member data from file.", e);
        }
    }
}
  • MemberRepository 인터페이스가 잘 정의되어 있으므로, 인터페이스를 기반으로 파일에 회원 데이터를 보관하는 구현체를 만들면 된다.
  • DELIMITER: 회원 데이터는 id1,member1,20과 같이 ,(쉼표)로 구분한다.

참고: 빈 컬렉션 반환

  • 빈 컬렉션을 반환할 때는 new ArrayList()보다는 List.of()를 사용하는 것이 좋다. 그런데, 뒤에서 사용할 ObjectStream 부분과 내용을 맞추기 위해 빈 컬렉션에 new ArrayList()를 사용했다.

회원 저장

bw.write(member.getId() + DELIMITER + member.getName() + DELIMITER + member.getAge());
bw.newLine();
  • 회원 객체의 데이터를 읽어서, String 문자로 변환한다. 여기서 write()String으로 입력받는다. 그리고 DELIMITER를 구분자로 사용한다.
  • bw.write("id1,member1,20")를 통해 저장할 문자가 전달된다.
  • 회원 데이터를 문자로 변경한 다음에 파일에 보관한 것이다.
  • 각 회원을 구분하기 위해 newLine()을 통해 다음 줄로 이동한다. 

회원 조회

  • line = br.readLine()line = "id1,member1,20"과 같이 하나의 회원 정보가 담긴 한 줄 문자가 입력된다.
  • String[] memberData = line.split(DELIMITER) → 회원 데이터를 DELIMITER 구분자로 구분해서 배열에 담는다.
  • members.add(new Member(memberData[0], memberData[1], Integer.valueOf(memberData[2])) → 파일에 읽은 데이터를 기반으로 회원 객체를 생성한다. id, nameString이기 때문에 타입이 같다. age의 경우 문자 20으로 조회했기 때문에 숫자인 Integer로 변경해야 한다.
  • FileNotFoundException e → 회원 데이터가 하나도 없을 때는 temp/members-txt.dat 파일이 존재하지 않는다. 따라서 해당 예외가 발생하기 때문에 이 경우, 회원 데이터가 하나도 없는 것으로 보고 빈 리스트를 반환한다.

try-with-resources

try-with-resources 구문을 사용해서 자동으로 자원을 정리한다. try 코드 블록이 끝나면 자동으로 close()가 호출되면서 자원을 정리한다.

try (BufferedWriter bw = new BufferedWriter(new FileWriter(FILE_PATH, UTF_8, true))) {...}
try (BufferedReader br = new BufferedReader(new FileReader(FILE_PATH, UTF_8))) {...}

 

MemberConsoleMain - FileMemberRepository 사용

package cwchoiit.io.member;

import cwchoiit.io.member.impl.FileMemberRepository;
import cwchoiit.io.member.impl.MemoryMemberRepository;

import java.util.List;
import java.util.Scanner;

public class MemberConsoleMain {

    // private static final MemberRepository repository = new MemoryMemberRepository();
    private static final MemberRepository repository = new FileMemberRepository();

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("1. 회원 등록 | 2. 회원 목록 조회 | 3. 종료");
            System.out.print("선택: ");
            int choice = scanner.nextInt();
            scanner.nextLine();

            switch (choice) {
                case 1:
                    // 회원 등록
                    registerMember(scanner);
                    break;
                case 2:
                    // 회원 목록 조회
                    displayMembers();
                    break;
                case 3:
                    System.out.println("프로그램을 종료합니다.");
                    return;
                default:
                    System.out.println("잘못된 선택입니다. 다시 입력하세요.");
            }
        }
    }

    private static void registerMember(Scanner scanner) {
        System.out.print("ID 입력:");
        String id = scanner.nextLine();

        System.out.print("Name 입력:");
        String name = scanner.nextLine();

        System.out.print("Age 입력:");
        int age = scanner.nextInt();
        scanner.nextLine();

        Member member = new Member(id, name, age);
        repository.add(member);
        System.out.println("회원이 성공적으로 등록되었습니다.");
    }

    private static void displayMembers() {
        List<Member> members = repository.findAll();
        System.out.println("회원 목록");
        for (Member member : members) {
            System.out.printf("[ID: %s, Name: %s, Age: %d]\n", member.getId(), member.getName(), member.getAge());
        }
    }
}
  • MemoryMemberRepository 대신에 FileMemberRepository를 사용하도록 코드를 수정하자.
  • MemberRepository 인터페이스를 사용한 덕분에 구현체가 변경되더라도 클라이언트의 다른 코드들은 변경하지 않아도 된다.

실행 결과

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 1
ID 입력: id1
Name 입력: name1
Age 입력: 20
회원이 성공적으로 등록되었습니다.

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 1
ID 입력: id2
Name 입력: name2
Age 입력: 30
회원이 성공적으로 등록되었습니다.

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 2
회원 목록:
[ID: id1, Name: name1, Age: 20]
[ID: id2, Name: name2, Age: 30]

1.회원 등록 | 2.회원 목록 조회 | 3.종료 
선택: 3
프로그램을 종료합니다.

 

결과 - temp/members-txt.dat

id1,member1,20
id2,member2,30

 

 

문제점

파일에 회원 데이터를 저장한 덕분에, 자바를 다시 실행해도 저장한 회원이 잘 조회된다. 위 문제를 해결한 것이다. 

그러나 아직도 남은 문제가 있다. 결국 파일에서 읽어오는 값은 문자열이기 때문에 멤버 객체에 나이를 저장할 때 문자를 숫자로 변환해줘야 한다. 예) Integer.valueOf(memberData[2])

 

이런 문제를 해결할 수 있는 좋은 방법은 DataStream을 사용하는 것이다.

 

회원 관리 예제3 - DataStream

앞서 배운 예시 중에 DataOutputStream, DataInputStream을 떠올려보자. 이 스트림들은 자바의 데이터 타입을 그대로 사용할 수 있다. 따라서 자바의 타입을 그대로 사용하면서 파일에 데이터를 저장하고 불러올 수 있고, 구분자도 사용하지 않아도 된다. 

DataMemberRepository

package cwchoiit.io.member.impl;

import cwchoiit.io.member.Member;
import cwchoiit.io.member.MemberRepository;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class DataMemberRepository implements MemberRepository {

    private static final String FILE_PATH = "temp/members-data.dat";

    @Override
    public void add(Member member) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream(FILE_PATH, true))) {
            dos.writeUTF(member.getId());
            dos.writeUTF(member.getName());
            dos.writeInt(member.getAge());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public List<Member> findAll() {
        List<Member> members = new ArrayList<>();
        try (DataInputStream dis = new DataInputStream(new FileInputStream(FILE_PATH))) {
            while (dis.available() > 0) {
                Member member = new Member(dis.readUTF(), dis.readUTF(), dis.readInt());
                members.add(member);
            }
            return members;
        } catch (FileNotFoundException e) {
            return new ArrayList<>();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

 

회원 저장

dos.writeUTF(member.getId());
dos.writeUTF(member.getName());
dos.writeInt(member.getAge());
  • 회원을 저장할 때는 회원 필드의 타입에 맞는 메서드를 호출하면 된다.
  • 이전 예제에서는 각 회원을 한 줄 단위로 구분했는데, 여기서는 그런 구분이 필요없다.

회원 조회

Member member = new Member(dis.readUTF(), dis.readUTF(), dis.readInt());
  • 회원 데이터를 조회할 때는 회원 필드의 각 타입에 맞는 메서드를 사용해서 조회하면 된다.

 

MemberConsoleMain 수정 - DataMemberRepository 사용

public class MemberConsoleMain {

    // private static final MemberRepository repository = new MemoryMemberRepository();
    // private static final MemberRepository repository = new FileMemberRepository();
    private static final MemberRepository repository = new DataMemberRepository();
    ...
}

 

실행 결과는 파일이 잘 보관되고, 파일에는 문자와 byte가 섞여있다. 그래서 파일을 사람이 직접 읽기는 힘들지만, 자바에서 데이터를 타입에 맞게 가져오기엔 아주 최적화되어 있다. 

 

DataStream 원리

근데 궁금하다. 어떤 원리로 구분자나 한 줄 라인 없이 데이터를 저장하고 조회할 수 있을까? 

예를 들어 이렇게 우리가 회원을 저장했다.

dos.writeUTF(member.getId()); // id1
dos.writeUTF(member.getName()); // member1

 

그럼 분명 파일에는 `id1member1` 이렇게 저장이 될텐데, 어떻게 이후에 readUTF()를 호출하면 딱 id1이라는 3글자만 정확히 가져올 수 있을까? 사실은 writeUTF()는 UTF-8 형식으로 문자를 저장하는데, 저장할 때 2byte를 추가로 사용해서 앞에 글자의 길이를 저장해둔다. 그래서 실제로는 이렇게 저장이 된다.

3id1 (2byte(문자 길이) + 3byte(실제 문자 데이터))
  • 따라서, readUTF()로 읽어들일 때 먼저 앞의 2byte로 글자의 길이를 확인하고 해당 길이만큼 글자를 읽어들인다.
  • 이 경우 2byte를 사용해서 3이라는 문자의 길이를 숫자로 보관하고, 나머지 3byte로 실제 문자 데이터를 보관한다. 

기타 타입

dos.writeInt(20);
dis.readInt();
  • 자바의 int(Integer)4byte를 사용하기 때문에, 4byte를 사용해서 파일을 저장하고, 읽을 때도 4byte를 읽어서 복원한다.

 

저장 예시

dos.writeUTF("id1");
dos.writeUTF("name1");
dos.writeInt(20);
dos.writeUTF("id2");
dos.writeUTF("name2");
dos.writeInt(30);

저장된 파일 예시

3id1 (2byte(문자 길이) + 3byte) 
5name1 (2byte(문자 길이) + 5byte) 
20 (4byte)
3id2 (2byte(문자 길이) + 3byte) 
5name2 (2byte(문자 길이) + 5byte)
30 (4byte)
  • 이해를 돕기 위해 각 필드를 엔터로 구분했지만, 실제로는 엔터 없이 한 줄로 연결되어 있다. 
  • 저장된 파일은 실제로는 문자와 byte가 섞여있다.

정리

DataStream덕분에 자바의 타입도 그대로 사용하고, 구분자도 제거할 수 있었다. 추가로 모든 데이터를 문자로 저장할 때보다 저장 용량도 더 최적화할 수 있다. 예를 들어, 숫자 1,000,000,000(10억)을 문자로 저장하게 되면 총 10byte가 사용된다. 왜냐하면 숫자 하나하나를 문자로 저장해야 하기 때문에 ASCII 인코딩을 해도 각각 1byte가 사용된다. 하지만 이것을 자바의 int와 같이 4byte를 사용해서 저장한다면 4byte만 사용하게 된다. 여기서는 writeInt()를 사용하면 4byte를 사용해서 저장한다. 물론 이렇게 byte를 직접 저장하면, 문서 파일을 열어서 확인하고 수정하는 것이 어렵다는 단점도 있지만, 이러한 장점도 있다.

 

문제점

DataStream 덕분에 회원 데이터를 더 편리하게 저장할 수 있는것은 맞지만, 회원의 필드를 하나하나 다 조회해서 각 타입에 맞도록 따로따로 저장해야 한다. 이건 회원 객체를 저장한다기 보다는 회원 데이터 하나하나를 분류해서 따로 저장한 것이다.

dos.writeUTF(member.getId());
dos.writeUTF(member.getName());
dos.writeInt(member.getAge());

 

다시 처음으로 돌아와서 회원 객체를 자바 컬렉션에 저장하는 예를 보자.

MemoryMemberRepository

package cwchoiit.io.member.impl;

import cwchoiit.io.member.Member;
import cwchoiit.io.member.MemberRepository;

import java.util.ArrayList;
import java.util.List;

public class MemoryMemberRepository implements MemberRepository {

    private final List<Member> members = new ArrayList<>();

    @Override
    public void add(Member member) {
        members.add(member);
    }

    @Override
    public List<Member> findAll() {
        return members;
    }
}

자바 컬렉션에 회원 객체를 저장할 때는 복잡하게 회원의 필드를 하나하나 꺼내서 저장할 필요가 없었다. 단순하게 회원 객체를 그대로 자바 컬렉션에 보관하면 된다. 조회할 때도 마찬가지다. 이렇게 편리하게 회원 객체를 저장할 수 있는 방법은 없을까?

 

회원 관리 예제4 - ObjectStream

회원 인스턴스도 생각해보면 메모리 어딘가에 보관되어 있다. 이렇게 메모리에 보관되어 있는 객체를 읽어서 파일에 저장하기만 하면 아주 간단하게 회원 인스턴스를 저장할 수 있을 것 같다. ObjectStream을 사용하면 이렇게 메모리에 보관되어 있는 회원 인스턴스를 파일에 편리하게 저장할 수 있다. 마치 자바 컬렉션에 회원 객체를 보관하듯 말이다.

 

객체 직렬화

자바 객체 직렬화(Serialization)는 메모리에 있는 객체 인스턴스를 바이트 스트림으로 변환하여 파일에 저장하거나 네트워크를 통해 전송할 수 있도록 하는 기능이다. 이 과정에서 객체의 상태를 유지하여 나중에 역직렬화(Deserialization)를 통해 원래의 객체로 복원할 수 있다. 객체 직렬화를 사용하려면 직렬화하려는 클래스는 반드시 Serializable 인터페이스를 구현해야 한다.

package java.io;

public interface Serializable {
}
  • 이 인터페이스는 아무런 기능이 없다. 단지 직렬화 가능한 클래스라는 것을 표시하기 위한 인터페이스일 뿐이다. 
  • 메서드 없이 단지 표시가 목적인 인터페이스를 마커 인터페이스라 한다.

Member - Serializable 추가

public class Member implements Serializable {
    private String id;
    private String name;
    private Integer age;

    public Member() {
    }

    public Member(String id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
	
    ...
}
  • Member 클래스에 Serializable을 구현했다.
  • 이제 이 클래스의 인스턴스는 직렬화될 수 있다.

만약, 해당 인터페이스가 없는 객체를 직렬화하면 다음과 같은 예외가 발생한다.

java.io.NotSerializableException: io.member.Member

 

ObjectMemberRepository

package cwchoiit.io.member.impl;

import cwchoiit.io.member.Member;
import cwchoiit.io.member.MemberRepository;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class ObjectMemberRepository implements MemberRepository {

    private static final String FILE_PATH = "temp/members-obj.dat";

    @Override
    public void add(Member member) {
        List<Member> members = findAll();
        members.add(member);

        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH))) {
            oos.writeObject(members);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

    @Override
    public List<Member> findAll() {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_PATH))) {
            Object findObject = ois.readObject();
            return (List<Member>) findObject;
        } catch (FileNotFoundException e) {
            return new ArrayList<>();
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}
  • ObjectOutputStream을 사용하면, 객체 인스턴스를 직렬화해서 byte로 변경할 수 있다.
  • 우리는 회원 객체 하나가 아니라 회원 목록 전체를 파일에 저장해야 하므로, members 컬렉션을 직렬화해야 한다. 
  • oos.writeObject(members)를 호출하면 members 컬렉션과 그 안에 포함된 Member를 모두 직렬화해서 byte로 변경한다. 그리고 oos와 연결되어 있는 FileOutputStream에 결과를 출력한다. 
  • 참고로, ArrayListjava.io.Serializable을 구현하고 있어서 직렬화할 수 있다.
  • ObjectInputStream을 사용하면, byte를 역직렬화해서 객체 인스턴스로 만들 수 있다. ois.readObject()를 사용하면 역직렬화가 된다. 이때 반환 타입이 Object이므로 캐스팅해서 사용해야 한다. 
  • 그리고, 파일이 없는 경우 FileNotFoundException이 발생하기 때문에 빈 배열을 반환해줘야 하는데 이 경우 List.of()가 더 효율이 좋다. Immutable이기 때문에 ArrayList와 달리 가변 메모리를 사용하지 않기 때문에 메모리 최적화가 가능하기 때문이다. 그러나 여기서는 new ArrayList<>();를 반환했다. 그 이유는 add() 메서드에서 findAll()을 통해 빈 배열을 받은 경우든 아니든 새로운 멤버를 추가해줘야 하는데 Immutable이면 리스트에 요소를 추가할 수 없기 때문이다. 

MemberConsoleMain 수정 - ObjectMemberRepository 사용

public class MemberConsoleMain {

    // private static final MemberRepository repository = new MemoryMemberRepository();
    // private static final MemberRepository repository = new FileMemberRepository();
    // private static final MemberRepository repository = new DataMemberRepository();
    private static final MemberRepository repository = new ObjectMemberRepository();
    
    ...
    
}

 

실행 결과 - temp/members-obj.dat

파일이 정상 보관된다. 문자와 byte가 섞여 있다.

 

 

정리

객체 직렬화 덕분에 객체를 매우 편리하게 저장하고 불러올 수 있었다. 객체 직렬화를 사용하면 객체를 바이트로 변환할 수 있어, 모든 종류의 스트림에 전달할 수 있다. 이는 파일에 저장하는 것은 물론, 네트워크를 통해 객체를 전송하는 것도 가능하게 한다. 이러한 특성 때문에 초기에는 분산 시스템에서 활용되었다. 그러나 객체 직렬화는 1990년대에 등장한 기술로, 초창기에는 인기가 있었지만 시간이 지나면서 여러 단점이 드러났다. 또한 대안 기술이 등장하면서 점점 그 사용이 줄어들게 되었다. 현재는 객체 직렬화를 거의 사용하지 않는다. 

 

그래서, 결국 지금까지의 흐름을 살펴보면, 처음에는 스트림을 사용해서 문자를 바이트로 변환해서 파일에 저장했고, 그 과정에서 파일에 있는 데이터를 문자로 변환했을 때 객체로 변환하려면 타입을 변환해주어야 하고 구분자를 통해 각 필드를 뽑아내야 하는 번거로움이 있었다. 그래서 FileWriter, FileReader의 불편함을 극복하고자, DataStream을 사용하게 됐다. 이 스트림은 자바의 데이터 타입을 그대로 사용해서 파일에 저장할 수 있었다. 그래서 파일의 데이터를 읽어올 때 그 데이터 타입 그대로로 가져오기 때문에 형변환과 같은 작업이나 구분자가 따로 필요하지 않아 더 편리했지만, 객체를 저장하는 느낌이 아니라 객체의 각각 필드를 하나씩 나누어 저장하는 느낌이 강했다. 그래서 이것을 해결하고자 ObjectStream을 사용하게 됐다. 객체 인스턴스 그 자체를 바이트로 변환할 수 있게 직렬화 가능한 객체로 변환하고 그 오브젝트를 그대로 바이트로 변환해서 파일에 집어넣을 수 있었다. 

 

 

 

그런데, 위에서 직렬화는 이제 거의 사용하지 않는다고 했는데 그 이유는 무엇이고 그럼 어떤 방식을 사용할까?

XML, JSON, 데이터베이스

회원 객체와 같은 구조화 된 데이터를 컴퓨터 간에 서로 주고 받을 때 사용하는 데이터 형식이 어떻게 발전해왔는지 알아보자.

객체 직렬화의 한계

  • 버전 관리의 어려움: 클래스 구조가 변경되면 이전에 직렬화된 객체와의 호환성 문제가 발생한다.
  • 플랫폼 종속성: 자바 직렬화는 자바 플랫폼에 종속적이어서, 다른 언어나 시스템과의 상호 운용성이 떨어진다.
  • 성능 이슈: 직렬화/역직렬화 과정이 상대적으로 느리고 리소스를 많이 사용한다. 

 

객체 직렬화 대안1 - XML

<member>
    <id>id1</id>
    <name>name1</name>
    <age>20</age>
</member>

플랫폼 종속성 문제를 해결하기 위해 2000년대 초반에 XML이라는 기술이 인기를 끌었다. 하지만 XML은 매우 유연하고 강력했어도 복잡성무거움이라는 문제가 있었다. 태그를 포함한 XML 문서의 크기가 커서 네트워크 전송 비용도 증가했다.

 

객체 직렬화 대안2 - JSON

{ "member": { "id": "id1", "name": "name1", "age": 20 } }

JSON은 가볍고 간결하며, 자바스크립트와의 자연스러운 호환성 때문에 웹 개발자들 사이에서 빠르게 확산되었다. 2000년대 후반, 웹 API와 Restful 서비스가 대중화되면서 JSON은 표준 데이터 교환 포맷으로 자리잡았다. XML이 특정 영역에서 여전히 사용되고는 있으나, JSON이 현대 소프트웨어 개발의 주류로 자리 잡았다. 지금은 웹 환경에서 데이터를 교환할 때 JSON이 사실상 표준이다.

 

데이터베이스

앞서 설명한 것처럼 회원 객체같은 구조화된 데이터를 주고받을 때는 JSON 형식을 주로 사용한다. 그러나 어떤 형식이든 데이터를 저장할 때, 파일에 데이터를 직접 저장하는 방식은 몇가지 큰 한계가 있다.

  • 첫째, 데이터의 무결성을 보장하기 어렵다. → 여러 사용자가 동시에 파일을 수정하거나 접근하려고 할 때, 데이터의 충돌이나 손상 가능성이 높아진다. 이러한 경우, 데이터의 일관성을 유지하는 것이 매우 어렵다.
  • 둘째, 데이터 검색과 관리의 비효율성이다. → 파일에 저장된 데이터는 특정 형식 없이 단순히 저장될 수 있기 때문에, 필요한 데이터를 빠르게 찾는데 많은 시간이 소요될 수 있다. 특히 데이터의 양이 방대해질수록 검색 속도는 급격히 저하된다.
  • 셋째, 보안 문제이다. → 파일 기반 시스템에서는 민감한 데이터를 안전하게 보호하기 위한 접근 제어와 암호화등이 충분히 구현되어 있지 않을 수 있다. 결과적으로 데이터의 유출이나 무단 접근의 위험이 커질 수 있다.
  • 넷째, 대규모 데이터의 효율적인 백업과 복구가 필요하다.

이러한 문제점들을 하나하나 해결하면서 발전한 서버 프로그램이 바로 데이터베이스이다.

 

728x90
반응형
LIST

'JAVA의 가장 기본이 되는 내용' 카테고리의 다른 글

네트워크 1 (Socket)  (2) 2024.10.15
File, Files  (0) 2024.10.14
IO 기본 2  (0) 2024.10.11
IO 기본 1  (0) 2024.10.11
문자 인코딩  (0) 2024.10.07
728x90
반응형
SMALL

참고자료

 

김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션 강의 | 김영한 - 인프런

김영한 | I/O, 네트워크, 리플렉션, 애노테이션을 기초부터 실무 레벨까지 깊이있게 학습합니다. 웹 애플리케이션 서버(WAS)를 자바로 직접 만들어봅니다., 국내 개발 분야 누적 수강생 1위, 제대로

www.inflearn.com

 

문자 다루기1 - 시작

스트림의 모든 데이터는 byte 단위를 사용한다. 따라서 byte가 아닌 문자를 스트림에 직접 전달할 수는 없다. 예를 들어서, String 문자를 스트림을 통해 파일에 저장하려면 Stringbyte로 변환한 다음에 저장해야 한다.

 

이번 예제에서 공통으로 다룰 상수를 먼저 만들자.

package cwchoiit.io.text;

public interface TextConst {
    String FILE_NAME = "temp/hello.txt";
}

 

이제 예제를 하나씩 보자.

package cwchoiit.io.text;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

import static cwchoiit.io.text.TextConst.FILE_NAME;
import static java.nio.charset.StandardCharsets.UTF_8;

public class ReaderWriterMainV1 {

    public static void main(String[] args) throws IOException {

        String writeString = "ABC";

        byte[] writeBytes = writeString.getBytes(UTF_8);
        System.out.println("Write String: " + writeString);
        System.out.println("Write bytes: " + Arrays.toString(writeBytes));

        // 파일에 쓰기
        FileOutputStream fos = new FileOutputStream(FILE_NAME);
        fos.write(writeBytes);
        fos.close();

        // 파일에서 읽기
        FileInputStream fis = new FileInputStream(FILE_NAME);
        byte[] readBytes = fis.readAllBytes();
        fis.close();

        String readString = new String(readBytes, UTF_8);
        System.out.println("read bytes: " + Arrays.toString(readBytes));
        System.out.println("read String: " + readString);
    }
}

실행 결과

write String: ABC
write bytes: [65, 66, 67]
read bytes: [65, 66, 67]
read String: ABC

 

실행 결과 - hello.txt

ABC

 

byte[] writeBytes = writeString.getBytes(UTF-8)

  • Stringbyte로 변환할때는 String.getBytes(Charset)을 사용하면 된다.
  • 이때 문자를 byte 숫자로 변경해야 하기 때문에 반드시 문자 집합(인코딩 셋)을 지정해야 한다.
  • 여기서는 UTF-8로 인코딩 한다.
  • ABC를 인코딩하면 65, 66, 67이 된다.

이렇게 만든 byte[]FileOutputStreamwrite()로 전달하면 65, 66, 67을 파일에 저장할 수 있다. 결과적으로 우리가 의도한 ABC 문자를 파일에 저장할 수 있다.

 

String readString = new String(readBytes, UTF-8)

  • 반대의 경우도 비슷하다. String 객체를 생성할 때, 읽어들인 byte[]과 디코딩할 문자 집합을 전달하면 된다. 
  • 그러면 byte[]String 문자로 다시 복원할 수 있다.

여기서 핵심은 스트림은 byte만 사용할 수 있으므로, String과 같은 문자는 직접 전달할 수 없다는 점이다. 그래서 개발자가 번거롭게 다음과 같은 변환 과정을 직접 호출해주어야 한다.

  • String + 문자 집합 → byte[]
  • byte[] + 문자 집합 → String

이렇게 번거로운 변환 과정을 누군가 대신 처리해주면 더 편리하지 않을까? 우리가 이전에 배운 BufferedXxx와 같이 누군가가 이러한 변환 기능을 대신 처리해주면 좋지 안을까?

 

문자 다루기2 - 스트림을 문자로

  • OutputStreamWriter → 스트림에 byte 대신에 문자를 저장할 수 있게 지원한다.
  • InputStreamReader → 스트림에 byte 대신에 문자를 읽을 수 있게 지원한다.
package cwchoiit.io.text;

import java.io.*;

import static cwchoiit.io.text.TextConst.FILE_NAME;
import static java.nio.charset.StandardCharsets.UTF_8;

public class ReaderWriterMainV2 {
    public static void main(String[] args) throws IOException {
        String writeString = "ABC";
        System.out.println("writeString = " + writeString);

        // 파일에 쓰기
        FileOutputStream fos = new FileOutputStream(FILE_NAME);
        OutputStreamWriter osw = new OutputStreamWriter(fos, UTF_8);

        osw.write(writeString);
        osw.close();

        // 파일에서 읽기
        FileInputStream fis = new FileInputStream(FILE_NAME);
        InputStreamReader isr = new InputStreamReader(fis, UTF_8);

        StringBuilder sb = new StringBuilder();
        int ch;
        while ((ch = isr.read()) != -1) {
            sb.append((char) ch);
        }
        isr.close();

        System.out.println("sb = " + sb);
    }
}

실행 결과

write String: ABC
read String: ABC

 

OutputStreamWriter

  • OutputStreamWriter는 문자를 입력 받고, 받은 문자를 내부적으로 인코딩해서 byte[]로 변환한다.
  • OutputStreamWriter는 변환한 byte[]을 전달할 OutputStream과 인코딩 문자 집합에 대한 정보가 필요하다. 따라서 두 정보를 생성자를 통해 전달해야 한다. 예) new OutputStreamWriter(fos, UTF_8)
  • osw.write(writeString)를 보면 String 문자를 직접 전달하는 것을 확인할 수 있다.
  • 그림을 보면 OutputStreamWriter가 문자 인코딩을 통해 byte[]로 변환하고, 변환 결과를 FileOutputStream에 전달하는 것을 확인할 수 있다.

InputStreamReader

  • 데이터를 읽을 때는 int ch = read()를 제공하는데, 여기서는 문자 하나인 char 형으로 데이터를 받게 된다. 그런데 실제 반환 타입은 int형이므로 char형으로 캐스팅해서 사용하면 된다.
  • 자바의 char 형은 파일의 끝인 -1을 표현할 수 없으므로, 대신 int를 반환한다.
  • 그림을 보면 데이터를 읽을 때 FileInputStream에서 byte[]을 읽은 것을 확인할 수 있다.
  • InputStreamReader는 이렇게 읽은 byte[]을 문자인 char로 변경해서 반환한다. 물론 byte를 문자로 변경할 때도 문자 집합이 필요하다. 그래서 생성자로 문자를 읽을, InputStream과 디코딩 문자 집합에 대한 정보가 필요하다. 예) new InputStreamReader(fis, UTF_8)

 

OutputStreamWriter, InputStreamReader 덕분에 매우 편리하게 문자를 byte[]로 변경하고, 그 반대도 가능하다. 덕분에 개발자는 쉽게 String 문자를 파일에 저장할 수 있다. 앞서 우리가 스트림을 배울 때 분명 byte 단위로 데이터를 읽고 쓰는 것을 확인했다. write()의 경우에도 byte 단위로 데이터를 읽고 썼다. 최상위 부모인 OutputStream의 경우 분명 write()byte 단위로 입력하도록 되어 있다. 그런데 OutputStreamWriterwrite()byte가 아니라 String이나 char를 사용한다. 어떻게 된 것일까?

 

항상 기억해야 할 대원칙은 결국 문자든, 파일이든, 네트워크든 컴퓨터는 무조건 byte 단위로 데이터를 읽고 쓴다는 것이다. 컴퓨터는 절대 문자 자체를 파일에 바로 쓰고 읽지 못한다. 언제나 컴퓨터가 읽을 수 있는 byte 단위로 변환한 후 파일에 쓰고, 반대도 파일에서 읽으면 그 값을 byte 단위로 변환해야 한다. 그리고 이때 변환을 위한 문자 집합이 필요한 것이다.

 

문자 다루기3 - Reader, Writer

자바는 byte를 다루는 I/O 클래스와 문자를 다루는 I/O 클래스를 둘로 나누어두었다. 이게 바로 위에서 제시한 의문의 해소점이다. OutputStreamWriter, InputStreamReaderbyte 단위를 사용하지 않고, String이나 char를 다루고 있다.

 

byte를 다루는 클래스

 

문자를 다루는 클래스

  • byte를 다루는 클래스는 OutputStream, InputStream의 자식이다.
    • 부모 클래스의 기본 기능도 byte 단위를 다룬다.
    • 클래스 이름 마지막에 보통 OutputSream, InputStream이 붙어있다. 
  • 문자를 다루는 클래스는 Writer, Reader의 자식이다.
    • 부모 클래스의 기본 기능은 String, char 같은 문자를 다룬다.
    • 클래스 이름 마지막에 보통 Writer, Reader가 붙어있다.

우리가 방금 본 OutputStreamWriter는 바로 문자를 다루는 Writer 클래스의 자식이다. 그래서 write(String)이 가능한 것이다. OutputStreamWriter는 문자를 받아서 byte로 변경한 다음에 byte를 다루는 OutputStream으로 데이터를 전달했던 것이다. (당연한 거지만)

 

다시 말하지만, 꼭 기억해야 할 대원칙은, 모든 데이터는 byte 단위(숫자)로 저장된다. 따라서 Writer가 아무리 문자를 다룬다고 해도 문자를 바로 저장할 수는 없다. 이 클래스에 문자를 전달하면 결과적으로 내부에서는 지정된 문자 집합을 사용해서 문자를 byte로 인코딩해서 저장한다.

 

 

 

그리고, 이 OutputStreamWriter, InputStreamReader를 파일 대상으로 하는 편리한 클래스가 있다. 바로 FileWriter, FileReader. 왜 만들어졌냐? 자주 사용하니까.

 

FileWriter, FileReader

Writer, Reader를 사용하는 아주 대표적인 예시다.

package cwchoiit.io.text;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import static cwchoiit.io.text.TextConst.FILE_NAME;
import static java.nio.charset.StandardCharsets.UTF_8;

public class ReaderWriterMainV3 {

    public static void main(String[] args) throws IOException {
        String writeString = "ABC";
        System.out.println("writeString = " + writeString);

        FileWriter fw = new FileWriter(FILE_NAME, UTF_8);
        fw.write(writeString);
        fw.close();

        StringBuilder sb = new StringBuilder();
        FileReader fr = new FileReader(FILE_NAME, UTF_8);
        int ch;
        while ((ch = fr.read()) != -1) {
            sb.append((char) ch);
        }
        fr.close();
        System.out.println("sb = " + sb);
    }
}

실행 결과

writeString = ABC
sb = ABC
  • new FileWriter(FILE_NAME, UTF_8) 
    • FileWriter에 파일명과 문자 집합(인코딩 셋)을 전달한다.
    • FileWriter는 사실 내부에서 스스로 FileOutputStream을 하나 생성해서 사용한다.
    • 모든 데이터는 byte 단위로 저장된다는 사실을 다시 떠올려보자.

  • fw.write(writeString)
    • 이  메서드를 사용하면, 문자를 파일에 직접 쓸 수 있다. (물론 내부적으로는 byte로 변환하는 과정이 당연히 있다)
    • 이렇게 문자를 쓰면 FileWriter 내부에서는 인코딩 셋을 사용해서 문자를 byte로 변경하고, FileOutputStream을 사용해서 파일에 저장한다. 
    • 개발자가 느끼기에는 문자를 직접 파일에 쓰는것처럼 느껴지지만, 실제로는 내부에서 문자를 byte로 변환한다. 사실 이게 포인트다. 사용하는 사람은 편하게 사용하면 된다.
  • new FileReader(FILE_NAME, UTF_8)
    • 앞서 설명한 FileWriter와 같은 방식으로 작동한다.
    • 내부에서 FileInputSream을 생성해서 사용한다. 

  • ch = fr.read()
    • 데이터를 읽을 때도, 내부에서는 FileInputStream을 사용해서 데이터를 byte 단위로 읽어들인다. 그리고 문자 집합을 사용해서 byte[]char로 디코딩한다. 

 

FileWriter와 OutputStreamWriter

FileWriter 코드와 앞서 작성한, OutputStreamWriter를 사용한 코드가 뭔가 비슷하다는 점을 알 수 있다. 딱 하나 차이점이 있다면 이전 코드에서는 FileOutputStream을 직접 생성했는데, FileWriter는 생성자 내부에서 대신 FileOutputStream을 생성해준다. 사실 FileWriterOutputStreamWriter를 상속한다. 그리고 다른 추가 기능도 없다. 딱 하나, 생성자에서 개발자 대신에 FileOutputStream을 생성해주는 일만 대신 처리해준다.  따라서 FileWriterOutputStreamWriter를 조금 더 편리하게 사용하도록 도와줄 뿐이다. 물론 FileReader도 마찬가지다.

 

정리

Writer, Reader 클래스를 사용하면 바이트 변환 없이 문자를 직접 다룰 수 있어서 편리하다. 하지만 실제로는 내부에서 byte로 변환해서 저장한다는 점을 꼭 기억하자. 모든 데이터는 바이트 단위로 다룬다! 문자를 직접 저장할 수는 없다! 그리고 반드시 기억하자. 문자를 byte로 변경하려면 항상 문자 집합(인코딩 셋)이 필요하다. 참고로, 문자 집합을 생략하면 시스템 기본 문자 집합이 사용된다.

 

 

문자 다루기4 - BufferedReader

BufferedOutputStream, BufferedInputStream과 같이 Reader, Writer에도 버퍼 보조 기능을 제공하는 BufferedReader, BufferedWriter 클래스가 있다.

 

추가로 문자를 다룰 때는 한 줄(라인)단위로 다룰 때가 많다. BufferedReader는 한 줄 단위로 문자를 읽는 기능도 추가로 제공한다.

package cwchoiit.io.text;

import java.io.*;

import static cwchoiit.io.text.TextConst.BUFFER_SIZE;
import static cwchoiit.io.text.TextConst.FILE_NAME;
import static java.nio.charset.StandardCharsets.UTF_8;

public class ReaderWriterMainV4 {

    public static void main(String[] args) throws IOException {
        String writeString = "ABC\n가나다";
        System.out.println("== Write String ==");
        System.out.println(writeString);

        FileWriter fw = new FileWriter(FILE_NAME, UTF_8);
        BufferedWriter bw = new BufferedWriter(fw, BUFFER_SIZE);
        bw.write(writeString);
        bw.close();

        StringBuilder sb = new StringBuilder();
        FileReader fr = new FileReader(FILE_NAME, UTF_8);
        BufferedReader br = new BufferedReader(fr, BUFFER_SIZE);

        String line;
        while ((line = br.readLine()) != null) {
            sb.append(line).append("\n");
        }
        br.close();
        System.out.println("== Read String ==");
        System.out.println(sb);
    }
}

실행 결과

== Write String == 
ABC
가나다
== Read String == 
ABC
가나다
  • br.readLine()
    • 한 줄 단위로 문자를 읽고 String을 반환한다.
    • 파일의 끝(EOF)에 도달하면 반환 타입이 String이기 때문에 -1을 반환할 수 없다. -1이 아니라 null을 반환한다. 

 

기타 스트림

지금까지 설명한 스트림 외에 수 많은 스트림들이 있다. 몇가지 유용한 부가 기능을 제공하는 PrintStream, DataOutputStream 보조 스트림을 알아보자.

 

PrintStream

PrintStream은 우리가 자주 사용해왔던 바로 System.out에서 사용되는 스트림이다. PrintStreamFileOutputStream을 조합하면 마치 콘솔에 출력하듯이 파일에 출력할 수 있다.

package cwchoiit.io.streams;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class PrintStreamEtcMain {
    public static void main(String[] args) throws FileNotFoundException {

        FileOutputStream fos = new FileOutputStream("temp/print.txt");
        PrintStream printStream = new PrintStream(fos);

        printStream.println("Hello World!");
        printStream.println(123);
        printStream.println(true);
        printStream.printf("hello %s", "world!");
        printStream.close();
    }
}

실행 결과 - temp/print.txt

hello java!
10
true
hello world

 

  • PrintStream의 생성자에 FileOutputStream을 전달했다. 이제 이 스트림을 통해서 나가는 출력은 파일에 저장된다. 이 기능을 사용하면 마치 콘솔에 출력하는 것처럼 파일이나 다른 스트림에 문자를 출력할 수 있다.

 

DataOutputStream

DataOutputStream을 사용하면 자바의 String, int, double, boolean과 같은 데이터 형을 편리하게 다룰 수 있다. 이 스트림과 FileOutputStream을 조합하면 파일에 자바 데이터 형을 편리하게 저장할 수 있다.

 

package cwchoiit.io.streams;

import java.io.*;

public class DataStreamEtcMain {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("temp/data.dat");
        DataOutputStream dos = new DataOutputStream(fos);

        dos.writeUTF("회원A");
        dos.writeInt(20);
        dos.writeDouble(30.5);
        dos.writeBoolean(true);
        dos.close();

        FileInputStream fis = new FileInputStream("temp/data.dat");
        DataInputStream dis = new DataInputStream(fis);
        System.out.println(dis.readUTF());
        System.out.println(dis.readInt());
        System.out.println(dis.readDouble());
        System.out.println(dis.readBoolean());
        dis.close();
    }
}

실행 결과

회원A 
20
10.5
true
  • 예제를 보면, 자바 데이터 타입을 사용하면서, 회원 데이터를 편리하게 저장하고 불러오는 것을 확인할 수 있다. 이 스트림을 사용할 때 주의할 점으로는 꼭! 지정한 순서대로 읽어야 한다는 것이다. 그렇지 않으면 잘못된 데이터가 조회될 수 있다. 저장한 data.dat 파일을 직접 열어보면 제대로 보이지 않는다. 왜냐하면 writeUTF()의 경우 UTF-8 형식으로 저장하지만, 나머지의 경우 문자가 아니라 각 타입에 맞는 byte 단위로 저장하기 때문이다. 예를 들어 자바에서는 int4byte를 묶어서 사용한다. 해당 byte가 그대로 저장되는 것이다. 텍스트 편집기는 자신의 문자 집합을 사용해서 byte를 문자로 표현하려고 시도하지만, 문자 집합에 없는 단어이거나 또는 전혀 예상하지 않은 문자로 디코딩 될 것이다.

 

정리를 하자면

스트림은 크게 기본 스트림보조 스트림으로 나눌 수 있다.

  • 기본 스트림
    • File, 메모리, 콘솔등에 직접 접근하는 스트림
    • 단독으로 사용할 수 있다. 
    • 예) FileInputStream, FileOutputStream, FileReader, FileWriter, ByteArrayInputStream, ByteArrayOutputStream
  • 보조 스트림
    • 기본 스트림을 도와주는 스트림
    • 단독으로 사용할 수 없고, 반드시 대상 스트림이 있어야 한다.
    • 예) BufferedInputStream, BufferedOutputStream, InputStreamReader, OutputStreamReader, DataOutputStream, DataInputStream, PrintStream

 

그리고 가장 중요한 건 역시나, 모든 데이터는 byte 단위로 저장되고 읽는다는 점이다. 이게 가장 핵심이다.

728x90
반응형
LIST

'JAVA의 가장 기본이 되는 내용' 카테고리의 다른 글

File, Files  (0) 2024.10.14
IO 활용  (2) 2024.10.13
IO 기본 1  (0) 2024.10.11
문자 인코딩  (0) 2024.10.07
멀티스레드 Part.13 Executor 프레임워크 2  (0) 2024.07.30
728x90
반응형
SMALL

참고자료

 

김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션 강의 | 김영한 - 인프런

김영한 | I/O, 네트워크, 리플렉션, 애노테이션을 기초부터 실무 레벨까지 깊이있게 학습합니다. 웹 애플리케이션 서버(WAS)를 자바로 직접 만들어봅니다., 국내 개발 분야 누적 수강생 1위, 제대로

www.inflearn.com

 

Stream 시작

 

자바가 가진 데이터를 `hello.dat`라는 파일에 저장하려면 어떻게 해야할까?

자바 프로세스가 가지고 있는 데이터를 밖으로 보내려면 출력 스트림을 사용하면 되고, 반대로 외부 데이터를 자바 프로세스 안으로 가져오려면 입력 스트림을 사용하면 된다. 참고로 각 스트림은 단방향으로만 흐른다.

 

예제 코드를 통해 확인해보자.

package cwchoiit.io.start;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class StreamStartMain1 {

    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("temp/hello.dat");

        fos.write(65);
        fos.write(66);
        fos.write(67);
        fos.close();

        FileInputStream fis = new FileInputStream("temp/hello.dat");
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
    }
}
  • 실행전에, 프로젝트 루트 경로에 `temp`라는 폴더 하나를 만들어야 한다!
  • new FileOutputStream("temp/hello.dat") → 파일에 데이터를 출력하는 스트림이다. 파일이 없으면 자동으로 파일을 만들고, 데이터를 해당 파일에 저장한다. 폴더는 만들지 않기 때문에 폴더는 미리 만들어 두어야 한다.
  • write() → byte 단위로 값을 출력한다. 여기서는 65, 66, 67을 출력했다. 참고로 ASCII 코드 집합에서 65는 'A', 66은 'B', 67은 'C"이다. 
  • new FileInputStream("temp/hello.dat") → 파일에서 데이터를 읽어오는 스트림이다.
  • read() → 파일에서 데이터를 byte 단위로 하나씩 읽어온다. 순서대로 65, 66, 67을 읽어온다. 파일의 끝에 도달해서 더는 읽을 내용이 없다면 -1을 반환한다. (파일의 끝, EOF, End of File)
  • close() → 파일에 접근하는 것은 자바 입장에서 외부 자원을 사용하는 것이다. 자바에서 내부 객체는 자동으로 GC가 되지만, 외부 자원은 사용 후 반드시 닫아주어야 한다.

실행 결과

65
66
67
-1
  • 입력한 순서대로 잘 출력되는 것을 확인할 수 있다. 마지막은 파일의 끝에 도달해서 -1이 출력된다.

실행 결과 - temp/hello.dat

ABC
  • `hello.dat`에 분명 byte로 65, 66, 67을 저장했다. 그런데 왜 개발툴이나 텍스트 편집에서 열어보면 ABC라고 보이는 것일까?
  • 앞서 자바에서 read()로 읽어서 출력한 경우에는 65, 66, 67이 정상 출력되었다.
  • 우리가 사용하는 개발툴이나 텍스트 편집기는 UTF-8 또는 MS949 문자 집합을 사용해서 byte 단위의 데이터를 문자로 디코딩해서 보여준다. 따라서 65, 66, 67이라는 byte를 ASCII 문자인 A, B, C로 인식해서 출력한 것이다.

 

참고: 파일 append 옵션

FileOutputStream의 생성자에는 append라는 옵션이 있다.

  • true → 기존 파일의 끝에 이어서 쓴다.
  • false → 기존 파일의 데이터를 지우고 처음부터 다시 쓴다 (기본값)

 

파일의 데이터를 읽을 때, 파일 끝까지 읽어야 한다면 다음과 같이 반복문을 사용하면 된다.

package cwchoiit.io.start;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class StreamStartMain2 {

    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("temp/hello.dat");

        fos.write(65);
        fos.write(66);
        fos.write(67);
        fos.close();

        FileInputStream fis = new FileInputStream("temp/hello.dat");

        int data;
        while ((data = fis.read())!= -1) {
            System.out.println(data);
        }
        fis.close();
    }
}
  • 입력 스트림의 read()메서드는 파일의 끝에 도달하면 -1을 반환한다. 따라서 -1을 반환할 때 까지 반복문을 사용하면 파일의 데이터를 모두 읽을 수 있다.

실행 결과

65
66
67

 

 

한번에 읽어들이기

이번에는 byte를 하나씩 다루는 것이 아니라, byte[]을 사용해서 데이터를 원하는 크기만큼 더 편리하게 저장하고 읽는 방법을 알아보자.

package cwchoiit.io.start;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class StreamStartMain3 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("temp/hello.dat");
        byte[] input = {65, 66, 67};
        fos.write(input);
        fos.close();

        FileInputStream fis = new FileInputStream("temp/hello.dat");
        byte[] buffer = new byte[10];
        int readCount = fis.read(buffer, 0, 10);
        System.out.println("readCount = " + readCount);
        System.out.println(Arrays.toString(buffer));
        fis.close();
    }
}

 

실행 결과

readCount = 3
[65, 66, 67, 0, 0, 0, 0, 0, 0, 0]
  • 출력 스트림
    • write(byte[]): byte[]에 원하는 데이터를 담고, write()에 전달하면 해당 데이터를 한번에 출력할 수 있다.
  • 입력 스트림
    • read(byte[], offset, length): byte[]을 미리 만들어두고, 만들어둔 byte[]에 한번에 데이터를 읽어올 수 있다.
    • byte[]: 데이터가 읽혀지는 버퍼
    • offset: 데이터 기록되는 byte[]의 인덱스 시작 위치
    • length: 읽어올 byte의 최대 길이
    • 반환값: 버퍼에 읽은 총 바이트 수 여기서는 3byte를 읽었으므로 3이 반환된다. 스트림의 끝에 도달하여 더이상 데이터가 없는 경우 -1을 반환
참고로, read(byte[])처럼 offset, length를 생략한 메서드도 있다. 이 메서드는 다음값을 가진다. offset(0), length(byte[].length).

 

모든 byte 한번에 읽기

package cwchoiit.io.start;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class StreamStartMain4 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("temp/hello.dat");
        byte[] input = {65, 66, 67};
        fos.write(input);
        fos.close();

        FileInputStream fis = new FileInputStream("temp/hello.dat");
        byte[] readBytes = fis.readAllBytes();

        System.out.println(Arrays.toString(readBytes));
        fis.close();
    }
}
  • readAllBytes()를 사용하면, 스트림이 끝날때까지(파일의 끝에 도달할 때까지)모든 데이터를 한번에 읽어올 수 있다.

실행 결과

[65, 66, 67]

 

그럼 이 두가지 방법 중 뭐가 더 좋나요?
- read(byte[], offset, length) → 스트림의 내용을 부분적으로 읽거나, 읽은 내용을 처리하면서 스트림을 계속해서 읽어야 할 경우에 적합하다. 또한, 메모리 사용량을 제어할 수 있기 때문에 너무너무 큰 파일같은 경우 이 방식이 더 적합할 수 있다. 예를 들어, 1TB 파일이 있다고 극단적으로 생각해보면, 이걸 한번에 읽어서 자바 메모리에 올리는 순간 OOM이 터질수도 있다. 

- readAllBytes() → 한번의 호출로 모든 데이터를 읽을 수 있어서 편리하다. 작은 파일이나 메모리에 모든 내용을 올려서 처리해야 하는 경우에 적합하다. 대신 메모리 사용량을 제어할 수 없기 때문에 큰 파일의 경우 OOM이 발생할 수도 있다.

결론적으로, 상황에 따라 적절한 것을 사용하면 된다.

 

 

InputStream, OutputStream

 

현대의 컴퓨터는 대부분 byte 단위로 데이터를 주고 받는다. 참고로 bit 단위는 너무 작기 때문에 byte 단위를 기본으로 사용한다. 이렇게 데이터를 주고 받는 것을 Input/Output(I/O)라고 한다. 자바 내부에 있는 데이터를 외부에 있는 파일에 저장하거나, 네트워크를 통해 전송하거나 콘솔에 출력할 때 모두 byte 단위로 데이터를 주고 받는다. 만약, 파일, 네트워크, 콘솔 각각 데이터를 주고 받는 방식이 다르다면 상당히 불편할 것이다. 또한 파일에 저장하던 내용을 네트워크에 전달하거나 콘솔에 출력하도록 변경할 때 너무 많은 코드를 변경해야 할 수 있다. 이런 문제를 해결하기 위해 자바는 InputStream, OutputStream 이라는 기본 추상 클래스를 제공한다.

 

 

  • InputStream과 상속 클래스
  • read(), read(byte[]), readAllBytes() 제공

  • OutputStream과 상속 클래스
  • write(int), write(byte[]) 제공

 

스트림을 사용하면, 파일을 사용하든, 소켓을 통해 네트워크를 사용하든, 모두 일관된 방식으로 데이터를 주고 받을 수 있다. 그리고 수많은 기본 구현 클래스들도 제공한다. 물론 각각의 구현 클래스들은 자신에게 맞는 추가 기능도 함께 제공한다. 파일에 사용하는 FileInputStream, FileOutputStream은 앞서 알아보았다. 네트워크 관련 스트림은 이후에 네트워클르 다룰 때 알아보자. 여기서는 메모리와 콘솔에 사용하는 스트림을 사용해보자.

 

메모리 스트림

package cwchoiit.io.start;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class ByteArrayStreamMain {
    public static void main(String[] args) throws IOException {
        byte[] input = {65, 66, 67};

        // 메모리에 쓰기
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        bos.write(input);

        // 메모리에서 읽기
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bos.toByteArray());
        byte[] bytes = byteArrayInputStream.readAllBytes();
        System.out.println("bytes = " + Arrays.toString(bytes));
    }
}

실행 결과

bytes = [65, 66, 67]

ByteArrayOutputStream, ByteArrayInputStream을 사용하면 메모리에 스트림을 쓰고 읽을 수 있다. 이 클래스들은 OutputStream, InputStream을 상속받았기 때문에 부모의 기능을 모두 사용할 수 있다. 코드를 보면 파일 입출력과 매우 비슷한 것을 확인할 수 있다. 참고로 메모리에 어떤 데이터를 저장하고 읽을 때는 컬렉션이나 배열을 사용하면 되기 때문에, 이 기능은 잘 사용하지 않는다. 주로 스트림을 간단하게 테스트 하거나, 스트림의 데이터를 확인하는 용도로 사용한다.

 

콘솔 스트림

package cwchoiit.io.start;

import java.io.IOException;
import java.io.PrintStream;

import static java.nio.charset.StandardCharsets.UTF_8;

public class PrintStreamMain {
    public static void main(String[] args) throws IOException {
        PrintStream printStream = System.out;

        byte[] bytes = "Hello\n".getBytes(UTF_8);
        printStream.write(bytes);

        printStream.println("Hello, World!");
    }
}

실행 결과

Hello
Hello, World!
  • 우리가 자주 사용했던 System.out이 사실은 PrintStream이다. 이 스트림은 OutputStream을 상속받는다. 이 스트림은 자바가 시작될 때 자동으로 만들어진다. 따라서 우리가 직접 생성하지 않는다. 
  • write(byte[]): OutputStream 부모 클래스가 제공하는 기능이다.
  • println(String): PrintStream이 자체적으로 제공하는 추가 기능이다. 

 

정리

InputStreamOutputStream이 다양한 스트림들을 추상화하고, 기본 기능에 대한 표준을 잡아둔 덕분에 개발자는 편리하게 입출력 작업을 수행할 수 있다. 이러한 추상화의 장점은 다음과 같다.

  • 일관성: 모든 종류의 입출력 작업에 대해 동일한 인터페이스(여기서는 부모의 메서드)를 사용할 수 있어, 코드의 일관성이 유지된다.
  • 유연성: 실제 데이터 소스나 목적지가 무엇인지에 관계없이 동일한 방식으로 코드를 작성할 수 있다. 예를 들어, 파일, 네트워크, 메모리 등 다양한 소스에 대해 동일한 메서드를 사용할 수 있다.
  • 확장성: 새로운 유형의 입출력 스트림을 쉽게 추가할 수 있다.
  • 재사용성: 다양한 스트림 클래스들을 조합하여 복잡한 입출력 작업을 수행할 수 있다. 예를 들어, BufferedInputStream을 사용하여 성능을 향상시키거나, DataInputStream을 사용하여 기본 데이터 타입을 쉽게 읽을 수 있다. 이 부분은 뒤에서 설명한다.
  • 에러처리: 표준화된 예외 매커니즘을 통해 일관된 방식으로 오류를 처리할 수 있다. 
참고로, InputStream, OutputStream은 추상 클래스이다. 자바 1.0부터 제공되고, 일부 작동하는 코드도 들어 있기 때문에 인터페이스가 아니라 추상 클래스로 제공된다.

 

 

파일 입출력과 성능 최적화1 - 하나씩 쓰고 읽기

파일을 효과적으로 더 빨리 읽고 쓰는 방법에 대해 알아보자. 먼저 예제에서 공통으로 사용할 상수들을 정의하자.

package cwchoiit.io.buffered;

public interface BufferedConst {
    String FILE_NAME = "temp/buffered.dat";
    int FILE_SIZE = 10 * 1024 * 1024; // 10MB
    int BUFFER_SIZE = 8 * 1024; // 8KB
}
  • FILE_NAME: temp/buffered.dat 이라는 파일을 만들 예정이다.
  • FILE_SIZE: 파일의 크기는 10MB이다.
  • BUFFER_SIZE: 뒤에서 설명한다.

 

쓰기

먼저 가장 단순한 FileOutputStreamwrite()을 사용해서 1byte씩 파일을 저장해보자.

그리고 10MB 파일을 만드는데 걸리는 시간을 확인해보자.

package cwchoiit.io.buffered;

import java.io.FileOutputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;
import static cwchoiit.io.buffered.BufferedConst.FILE_SIZE;

public class CreateFileV1 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < FILE_SIZE; i++) {
            fos.write(1);
        }
        fos.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File created: " + FILE_NAME);
        System.out.println("File size: " + FILE_SIZE / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}
  • fos.write(1): 파일의 내용은 중요하지 않다. 단순히 1이라는 값을 반복하여 계속 저장한다. 한 번 호출에 1byte가 만들어진다.
  • 이 메서드를 약 1000만번 호출하면 10MB의 파일이 만들어진다.

실행 결과

File created: temp/buffered.dat
File size: 10MB
Time taken: 11092ms
  • 실행 결과를 보면 알겠지만 상당히 오랜 시간이 걸렸다.

 

읽기

package cwchoiit.io.buffered;

import java.io.FileInputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;

public class ReadFileV1 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();

        int data;
        int fileSize = 0;
        while ((data = fis.read()) != -1) {
            fileSize++;
        }
        fis.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File name: " + FILE_NAME);
        System.out.println("File size: " + fileSize / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}
  • fis.read()를 사용해서 앞서 만든 파일에서 1byte씩 데이터를 읽는다.
  • 파일의 크기가 10MB이므로 fis.read() 메서드를 약 1000만번 호출한다. 

실행 결과

File name: temp/buffered.dat
File size: 10MB
Time taken: 5003ms
  • 실행하는데 상당히 오래걸린다.

 

정리

10MB 파일 하나를 쓰는데 11초, 읽는데 5초라는 매우 오랜 시간이 걸렸다. 이렇게 오래 걸린 이유는 자바에서 1byte씩 디스크에 데이터를 전달하기 때문이다. 디스크는 1byte의 데이터를 받아서 1byte의 데이터를 쓴다. 이 과정을 무려 1000만번 반복하는 것이다. 더 자세히 설명하자면 다음 2가지 이유로 느려진다.

 

  • write()read()를 호출할 때마다 OS의 시스템 콜을 통해 파일을 읽거나 쓰는 명령어를 전달한다. 이러한 시스템 콜은 상대적으로 무거운 작업이다.
  • HDD, SDD 같은 장치들도 하나의 데이터를 읽고 쓸 때마다 필요한 시간이 있다. HDD의 경우 더욱 느린데, 물리적으로 디스크의 회전이 필요하다.
  • 이러한 무거운 작업을 무려 1000만번 반복한다.

비유를 하자면 창고에서 마트까지 상품을 전달해야 하는데 화물차에 한번에 하나의 물건만 가지고 이동하는 것이다. 화물차가 무려 1000만번 이동을 반복해야 10MB의 파일이 만들어진다. 물론 반대로 읽어 들일 때도 마찬가지다. 

이 문제를 해결하려면 한번에 화물차에 더 많은 상품을 담아서 보내면 된다.

 

참고로, 이렇게 자바에서 운영 체제를 통해 디스크에 1byte씩 전달하면, 운영 체제나 하드웨어 레벨에서 여러가지 최적화가 발생한다. 따라서 실제로 디스크에 1byte씩 계속 쓰는 것은 아니다. 그렇다면 훨씬 더 느렸을 것이다. 하지만, 자바에서 1bytewrite()read()를 호출할 때마다 운영 체제로의 시스템 콜이 발생하고, 이 시스템 콜 자체가 상당한 오버헤드를 유발한다. 운영 체제와 하드웨어가 어느 정도 최적화를 제공하더라도, 자주 발생하는 시스템 콜로 인한 성능 저하는 피할 수 없다. 결국 자바에서 read(), write() 호출 횟수를 줄여서 시스템 콜 횟수도 줄여야 한다. 그래서 내부적으로 한번에 모아서 몇번씩 호출하기는 하지만 그럼에도 불구하고 그 횟수가 많다보니 이렇게 느리다.

 

 

파일 입출력과 성능 최적화2 - 버퍼 활용

이번에는 1byte씩 데이터를 하나씩 전달하는 것이 아니라 byte[]을 통해 배열에 담아서 한번에 여러 byte를 전달해보자.

 

쓰기

package cwchoiit.io.buffered;

import java.io.FileOutputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.*;

public class CreateFileV2 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();

        byte[] buffer = new byte[BUFFER_SIZE];
        int bufferIndex = 0;

        for (int i = 0; i < FILE_SIZE; i++) {
            buffer[bufferIndex++] = 1;

            if (bufferIndex == BUFFER_SIZE) {
                fos.write(buffer, 0, BUFFER_SIZE);
                bufferIndex = 0;
            }
        }

        if (bufferIndex > 0) {
            fos.write(buffer, 0, bufferIndex);
        }
        fos.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File created: " + FILE_NAME);
        System.out.println("File size: " + FILE_SIZE / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}
  • 데이터를 먼저 buffer라는 byte[]에 담아둔다. 이렇게 데이터를 모아서 전달하거나 모아서 전달받는 용도로 사용하는 것을 버퍼라 한다.
  • 여기서는 BUFFER_SIZE만큼 모아서, write()을 호출한다. 예를 들어, BUFFER_SIZE가 10이라면, 10만큼 모이면 write()를 호출해서 10byte를 한번에 스트림에 전달한다.
  • 파일의 마지막 부분에는 얼마 남지 않았을 때 버퍼 사이즈만큼은 데이터가 없어서 bufferIndex == BUFFER_SIZE가 참을 반환하지 않지만, 어느정도는 데이터가 버퍼에 채워진 경우도 있을 수 있다. 그 경우를 생각해서 순회가 다 끝나고 bufferIndex가 0이 아닌지 체크한다.

실행 결과

File created: temp/buffered.dat
File size: 10MB
Time taken: 14ms
  • 실행 결과를 보면 이전에 걸렸던 시간보다 훨씬 빨라졌다. 거의 1000배 정도 빨라진 셈이다. 

 

그럼 여기서 질문, 지금은 버퍼 사이즈가 8KB라서 14ms 걸리면 더 키우면 키울수록 더 시간도 단축될까?

아쉽게도 그건 아니다. 왜냐하면, 직접 버퍼 사이즈를 더 늘려서 테스트 해보면 알겠지만 어느정도 크기부터는 시간이 단축되지 않고 그대로 유지된다. 그 이유는, 디스크나 파일 시스템에서 데이터를 읽고 쓰는 기본 단위가 보통 4KB 또는 8KB이기 떄문이다. 결국 버퍼에 많은 데이터를 담아서 보내도 디스크나 파일 시스템에서 해당 단위로 나누어 저장하기 때문에 효율에는 한계가 있다. 따라서 버퍼의 크기는 보통 4KB 또는 8KB 정도로 잡는것이 효율적이다.

 

 

읽기

package cwchoiit.io.buffered;

import java.io.FileInputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.BUFFER_SIZE;
import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;

public class ReadFileV2 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();

        byte[] buffer = new byte[BUFFER_SIZE];
        int size;
        int fileSize = 0;
        while ((size = fis.read(buffer)) != -1) {
            fileSize += size;
        }
        fis.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File name: " + FILE_NAME);
        System.out.println("File size: " + fileSize / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

실행 결과

File name: temp/buffered.dat
File size: 10MB
Time taken: 5ms
  • 읽기의 경우에도 버퍼를 사용하면 약 1000배정도 성능 향상을 확인할 수 있따.

 

버퍼를 사용하면 큰 성능 향상이 있다. 그러니까 결론은 버퍼를 쓰는게 맞다. 그런데 이렇게 직접 버퍼를 만들고 관리해야 하는 번거로움이 있다. 항상 이럴땐 나대신 누가 더 좋은 것을 만들어 두었다. 그게 바로 BufferedStream인데 이 녀석을 알아보자.

 

파일 입출력과 성능 최적화3 - BufferedStream 쓰기 

BufferedOutputStream은 버퍼 기능을 내부에서 대신 처리해준다. 따라서 단순한 코드를 유지하면서 버퍼를 사용하는 이점도 함께 누릴 수 있다. BufferedOutputStream을 사용해서 코드를 작성해보자.

 

쓰기

package cwchoiit.io.buffered;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.*;

public class CreateFileV3 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(FILE_NAME);
        BufferedOutputStream bos = new BufferedOutputStream(fos, BUFFER_SIZE);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < FILE_SIZE; i++) {
            bos.write(1);
        }
        bos.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File created: " + FILE_NAME);
        System.out.println("File size: " + FILE_SIZE / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}
  • BufferedOutputStream은 내부에서 단순히 버퍼 기능만 제공한다. 따라서 반드시 대상 OutputStream이 있어야 한다. 여기서는 FileOutputStream 객체를 생성자에 전달했다. 
  • 추가로 사용할 버퍼의 크기도 함께 전달할 수 있다.
  • 코드를 보면 버퍼를 위한 byte[]을 직접 다루지 않고 매우 단순하게 BufferedOutputStream 객체를 만들어서 write()호출만 하고 있다. BufferedOutputStream 내부적으로 byte[]을 만들어주고 다뤄주고 있는 것이다.

실행 결과

File created: temp/buffered.dat
File size: 10MB
Time taken: 102ms
  • 성능이 아주 뛰어나다. 처음에 직접 1byte씩 쓰는것보다 매우 빠르다.

  • BufferedOutputStreamOutputStream을 상속받는다. 따라서 개발자 입장에서 보면 OutputStream과 같은 기능을 그대로 사용할 수 있다. 예제에서는 write()를 사용했다.

 

BufferedOutputStream 실행 순서

  • BufferedOutputStream은 내부에 byte[] buf라는 버퍼를 가지고 있다.
  • 여기서 버퍼의 크기는 3이라고 가정하겠다.
  • BufferedOutputStreamwrite(byte)를 통해, byte 하나를 전달하면 byte[] buf에 보관된다. 참고로 실제로는 write(int)이다. 근데 내부적으로 그 값을 byte로 형변환해서 buf에 보관한다. 그래서 쉽게 설명하기 위해 write(byte)로 그려두었다.

  • write(byte)를 2번 호출했다. 아직 버퍼가 가득차지 않았다.

  • write(byte)를 3번 호출하면 버퍼가 가득찬다.
  • 버퍼가 가득차면 FileOutputStream에 있는 write(byte[]) 메서드를 호출한다. 참고로 BufferedOutputStream의 생성자에서 FileOutputStream을 전달했다.
  • FileOutputStreamwrite(byte[])를 호출하면, 전달된 모든 byte[]을 시스템 콜로 OS에 전달한다.

  • 버퍼의 데이터를 모두 전달했기 때문에 버퍼의 내용을 비운다.
  • 이후에 write(byte)가 호출되면 다시 버퍼를 채우는 식으로 반복한다.

flush()

버퍼가 다 차지 않아도, 버퍼에 남아있는 데이터를 전달하려면 flush()라는 메서드를 호출할 수도 있다. 다음 예를 보자.

  • 버퍼에 2개의 데이터가 남아 있다.

  • flush() 호출
  • 버퍼에 남은 데이터를 전달

  • 데이터를 전달하고 버퍼를 비움

 

close()

만약, 버퍼에 데이터가 남아 있는 상태로 close()를 호출하면 어떻게 될까?

  • BufferedOutputStreamclose()로 닫으면 먼저 내부에서 flush()를 호출한다. 따라서 버퍼에 남아 있는 데이터를 모두 전달하고 비운다.
  • 따라서, close()를 호출해도 남은 데이터를 안전하게 저장할 수 있다.

  • 버퍼가 비워지고 나면 close()BufferedOutputStream의 자원을 정리한다.
  • 그리고 나서 다음 연결된 스트림의 close()를 호출한다. 여기서는 FileOutputStream의 자원이 정리된다.
  • 여기서 핵심은 close()를 호출하면 close()가 연쇄적으로 호출된다는 점이다. 따라서 마지막에 연결한 BufferedOutputStream만 닫아주면 된다.

주의! - 반드시 마지막에 연결한 스트림을 닫아야 한다.

  • 만약, BufferedOutputStream을 닫지 않고, FileOutputStream만 직접 닫으면 어떻게 될까?
  • 이 경우 BufferedOutputStreamflush()도 호출되지 않고, 자원도 정리되지 않는다. 따라서 남은 byte가 버퍼에 남아있게 되고, 파일에 저장되지 않는 심각한 문제가 발생한다.
  • 따라서, 지금과 같이 스트림을 연결해서 사용하는 경우에는 마지막에 연결한 스트림을 반드시 닫아주어야 한다. 마지막에 연결한 스트림만 닫아주면, 연쇄적으로 close()가 호출된다.

 

기본 스트림, 보조 스트림

FileOutputStream과 같이 단독으로 사용할 수 있는 스트림을 기본 스트림이라고 한다.

BufferedOutputStream과 같이 단독으로 사용할 수 없고, 보조 기능을 제공하는 스트림을 보조 스트림이라 한다.

 

BufferedOutputStreamFileOutputStream에 버퍼라는 보조 기능을 제공한다. BufferedOutputStream의 생성자를 보면 알겠지만, 반드시 FileOutputStream 같은 대상 OutputStream이 있어야 한다.

public BufferedOutputStream(OutputStream out) { ... }
public BufferedOutputStream(OutputStream out, int size) { ... }
  • BufferedOutputStream은 버퍼라는 보조 기능을 제공한다. 그렇다면 누구에게 보조 기능을 제공할지 대상을 반드시 전달해야 한다.

정리

  • BufferedOutputStream은 버퍼 기능을 제공하는 보조 스트림이다.
  • BufferedOutputStreamOutputStream의 자식이기 때문에 OutputStream의 기능을 그대로 사용할 수 있다. 물론 대부분의 기능은 재정의된다. write()의 경우 먼저 버퍼에 쌓도록 재정의된다.
  • 버퍼의 크기만큼 데이터를 모아서 전달하기 때문에 빠른 속도로 데이터를 처리할 수 있다.

 

파일 입출력과 성능 최적화4 - BufferedSteram 읽기

읽기

package cwchoiit.io.buffered;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.BUFFER_SIZE;
import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;

public class ReadFileV3 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(FILE_NAME);
        BufferedInputStream bis = new BufferedInputStream(fis, BUFFER_SIZE);

        long startTime = System.currentTimeMillis();

        int data;
        int fileSize = 0;
        while ((data = bis.read()) != -1) {
            fileSize++;
        }
        bis.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File name: " + FILE_NAME);
        System.out.println("File size: " + fileSize / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

실행 결과

File name: temp/buffered.dat
File size: 10MB
Time taken: 94ms
  • 1byte씩 직접 읽어들이는 것보다 훨씬 빠르다. 그런데, 쓰기도 마찬가지고 읽기도 마찬가지다. 직접 byte[]을 다루어 읽고 쓰는것보다는 조금 더 느린데 이유가 뭘까? 이후에 설명한다.

BufferedInputStream 실행순서

  • BufferedInputStreamInputStream을 상속받는다. 따라서 개발자 입장에서 보면, InputStream과 같은 기능을 그대로 사용할 수 있다. 예제에서는 read()를 사용했다.

  • read() 호출 전
  • 버퍼의 크기는 3이라고 가정

  • read()1byte만 조회한다.
  • BufferedInputStream은 먼저 버퍼를 확인한다. 버퍼에 데이터가 없으므로 데이터를 불러온다.
  • BufferedInputStreamFileInputStream에서 read(byte[])을 사용해서 버퍼의 크기가 3byte의 데이터를 불러온다.
  • 불러온 데이터를 버퍼에 보관한다.

  • 버퍼에 있는 데이터 중에 1byte를 반환한다.

  • read()를 또 호출하면 버퍼에 있는 데이터 중에 1byte를 반환한다.

  • read()를 또 호출하면 버퍼에 있는 데이터 중에 1byte를 반환한다.

  • read()를 호출하는데, 이번에는 버퍼가 비어있다.
  • FileInputStream에서 버퍼 크기만큼 조회하고 버퍼에 담아둔다.

  • 버퍼에 있는 데이터를 하나 반환한다.
  • 이런 방식을 반복한다.

정리

BufferedInputStream은 버퍼의 크기만큼 데이터를 미리 읽어서 버퍼에 보관해둔다. 따라서 read()를 통해 1byte씩 데이터를 조회해도, 성능이 최적화된다.

 

버퍼를 직접 다루는 것보다 BufferedXxx의 성능이 떨어지는 이유

  • 예제1 쓰기: 14000ms (14초)
  • 예제2 쓰기: 14ms (버퍼를 직접 다룸)
  • 예제3 쓰기: 102ms (BufferedXxx)

예제2는 버퍼를 직접 다루는 것이고, 예제3은 BufferedXxx라는 클래스가 대신 버퍼를 처리해준다. 버퍼를 사용하는 것은 같기 때문에 결과적으로 예제2와 예제3은 비슷한 성능이 나와야한다. 그런데 왜 예제2가 더 빠를까? 그것도 10배정도나? 이 이유는 바로 동기화 때문이다.

 

BufferedOutputStream.write()

@Override
public synchronized void write(int b) throws IOException {
    if (count >= buf.length) {
        flushBuffer();
    }
    buf[count++] = (byte)b;
}
  • 와우, synchronized가 걸려있다.
  • BufferedOutputStream을 포함한 BufferedXxx 클래스는 모두 동기화 처리가 되어 있다.
  • 이번 예제의 문제는 1byte씩 저장해서 총 10MB를 저장해야 하는데 이렇게 하려면 write()를 약 1000만번 호출해야 한다.
  • 결과적으로 락을 걸고 푸는 것도 1000만번 호출된다는 뜻이다.

 

BufferedXxx 클래스의 특징

BufferedXxx 클래스는 자바 초창기에 만들어진 클래스인데, 처음부터 멀티 스레드를 고려해서 만든 클래스이다. 따라서 멀티 스레드에 안전하지만 락을 걸고 푸는 동기화 코드로 인해 성능이 약간 저하될 수 있다. 하지만, 싱글 스레드 상황에서는 동기화 락이 필요하지 않기 때문에 직접 버퍼를 다룰 때와 비교해서 성능이 떨어진다. 

 

일반적인 상황이라면, 이 정도 성능은 크게 문제가 되지 않기 때문에 싱글 스레드여도 BufferedXxx를 사용하면 충분하다. 물론, 매우 큰 데이터를 다루어야 하고, 성능 최적화가 중요하다면 직접 버퍼를 다루는 방법을 고려하자. 아쉽게도 동기화 락이 없는 BufferedXxx 클래스는 없다. 꼭 필요한 상황이라면 BufferedXxx를 참고해서 동기화 락 코드를 제거한 클래스를 직접 만들어 사용하면 된다. 

 

 

파일 입출력과 성능 최적화5 - 한번에 쓰고 읽기

파일 크기가 크지 않다면, 간단하게 한번에 쓰고 읽는것도 좋은 방법이다. 이 방법은 성능은 이론적으론 가장 빠르지만, 결과적으로 메모리를 한번에 많이 사용하기 때문에 파일의 크기가 작아야 한다. 그리고 사실, 이론적으로 성능이 가장 빠르긴해도 버퍼의 크기를 지정해서 읽고 쓰는거랑 크게 차이가 없다. 위에서 이 이유도 설명했다. 바로 기본적으로 디스크나 파일 시스템이 4KB, 8KB 크기정도를 기본으로 사용하기 때문에. 

 

쓰기

package cwchoiit.io.buffered;

import java.io.FileOutputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;
import static cwchoiit.io.buffered.BufferedConst.FILE_SIZE;

public class CreateFileV4 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();
        byte[] buffer = new byte[FILE_SIZE];

        for (int i = 0; i < FILE_SIZE; i++) {
            buffer[i] = 1;
        }
        fos.write(buffer);
        fos.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File created: " + FILE_NAME);
        System.out.println("File size: " + FILE_SIZE / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

실행 결과

File created: temp/buffered.dat
File size: 10MB
Time taken: 15ms
  • 실행 시간은 8KB의 버퍼를 직접 사용한 예제2와 오차 범위 정도로 비슷하다. 디스크나 파일 시스템에서 데이터를 읽고 쓰는 기본 단위가 보통 4KB 또는 8KB이기 때문에.

 

읽기

package cwchoiit.io.buffered;

import java.io.FileInputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;

public class ReadFileV4 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();

        byte[] bytes = fis.readAllBytes();
        fis.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File name: " + FILE_NAME);
        System.out.println("File size: " + bytes.length / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

실행 결과

File name: temp/buffered.dat
File size: 10MB
Time taken: 3ms
  • 실행 시간은 8KB의 버퍼를 사용한 예제2와 오차 범위 정도로 비슷하다.
  • readAllBytes()를 사용하면 한번에 모든 데이터를 다 읽을 수 있다.

 

정리를 하자면

결국, 파일이나 네트워크나 콘솔 모두 대부분 byte 단위로 데이터를 주고 받는다. 이렇게 데이터를 주고 받는것을 Input/Output(I/O)라고 했다. 자바에서는 InputStream, OutputStream이라는 기본 추상 클래스를 제공해서 파일이든, 메모리든, 네트워크든, 콘솔이든 다 똑같은 방식으로 데이터를 읽고 쓸 수 있다. 그리고 읽고 쓸때 적절한 크기의 버퍼를 사용해서 읽고 쓰면 훨씬 더 효율적이고 성능이 좋아진다. 그리고 이때도 자바가 미리 만들어둔 BufferedXxx 클래스인 보조 스트림을 사용해서 간단하게 사용할 수가 있다. 다만, 이 BufferedXxx는 전부 다 멀티 스레드를 고려해서 만든 클래스이기 때문에 동기화 락을 걸고 풀고 하는 코드가 있다. 따라서, 싱글 스레드 상황에서는 성능이 직접 만든 byte[]을 사용하는것보단 떨어진다. 이 점은 상황에 맞게 적절히 판단하여 사용하면 될 것 같다.

 

 

728x90
반응형
LIST
728x90
반응형
SMALL

블로그 쓰다가 가끔 지 멋대로 . 이 찍혀서 매우 불편했다. 찾아보니 방법이 있더군.

우선, 시스템 세팅으로 들어간다.

 

들어가면, Keyboard 섹션에 위같이 키보드 입력 수정하는 버튼이 있다.

이거 비활성화 하면 된다. 휴우!

728x90
반응형
LIST

'Etc' 카테고리의 다른 글

IntelliJ IDEA Macro를 사용해 단축키로 여러 액션실행하기  (0) 2024.09.27
Zsh Option key  (0) 2024.03.22
728x90
반응형
SMALL

Spring Batch에서는 메인 로직 외에 구간 사이사이에 어떤 일을 처리하고자 할 때 Listener를 사용한다. 예를 들면, Job, Step, Chunk, ItemReader, ItemProcessor, ItemWriter의 실행 직전과 직후에 어떤 행위를 할지 정의할 수 있다.

 

Listener의 종류

  • JobExecutionListener
  • StepExecutionListener
  • ChunkListener
  • ItemReadListener
  • ItemProcessListener
  • ItemWriteListener

 

JobExecutionListener

public interface JobExecutionListener {
    default void beforeJob(JobExecution jobExecution) {
    }

    default void afterJob(JobExecution jobExecution) {
    }
}
  • Job의 실행 전에 실행하는 beforeJob.
  • Job의 실행 후에 실행하는 afterJob.
  • 두 메서드 모두 인자로 JobExecution을 넘겨준다.
  • 구현한 JobExecutionListener는 아래처럼 JobBuilder에서 Job을 만들 때 listener()에 넣어주면 된다.

 

나만의 JobListener

package cwchoiit.springbatchmaster.tasklet;

import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobExecutionListener;
import org.springframework.batch.item.ExecutionContext;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

@Component
public class JobListener implements JobExecutionListener {

    @Override
    public void beforeJob(JobExecution jobExecution) {
        ExecutionContext executionContext = jobExecution.getExecutionContext();
        Map<String, Object> executionContextMap = new HashMap<>();
        executionContextMap.put("name", "홍길동");
        executionContextMap.put("age", 30);
        jobExecution.setExecutionContext(new ExecutionContext(executionContextMap));
    }

    @Override
    public void afterJob(JobExecution jobExecution) {
        System.out.println(jobExecution.getJobId());
    }
}

listener 등록

@Bean
public Job reserveRestaurantJob(JobRepository jobRepository,
                                JobListener jobListener,
                                Step searchAvailableKoreanRestaurantStep,
                                Step reserveRestaurantStep,
                                Step sendDepositStep) {
    return new JobBuilder("reserveRestaurantJob", jobRepository)
            .listener(jobListener)
            .start(searchAvailableKoreanRestaurantStep)
            .next(reserveRestaurantStep)
            .next(sendDepositStep)
            .build();
}

 

StepExecutionListener

public interface StepExecutionListener extends StepListener {
    default void beforeStep(StepExecution stepExecution) {
    }

    @Nullable
    default ExitStatus afterStep(StepExecution stepExecution) {
        return null;
    }
}
  • Step의 실행 전 실행하는 beforeStep
  • Step의 실행 후 실행하는 afterStep
  • 두 메서드 모두 인자로 StepExecution을 넘겨준다.
  • 구현된 StepExecutionListener는 아래처럼 StepBuilder에서 Step을 만들 때 listener()에 넣어주면 된다.

나만의 StepListener

package cwchoiit.springbatchmaster.tasklet;

import org.springframework.batch.core.ExitStatus;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.StepExecutionListener;
import org.springframework.stereotype.Component;

@Component
public class StepListener implements StepExecutionListener {

    @Override
    public void beforeStep(StepExecution stepExecution) {
        StepExecutionListener.super.beforeStep(stepExecution);
    }

    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        return StepExecutionListener.super.afterStep(stepExecution);
    }
}

listener 등록

@Bean
@JobScope
public Step sampleStep(JobRepository jobRepository,
                       StepListener stepListener,
                       PlatformTransactionManager platformTransactionManager) {
    return new StepBuilder("sampleStep", jobRepository)
            .tasklet(sampleTasklet(), platformTransactionManager)
            .listener(stepListener)
            .build();
}

 

 

ChunkListener

public interface ChunkListener extends StepListener {
    String ROLLBACK_EXCEPTION_KEY = "sb_rollback_exception";

    default void beforeChunk(ChunkContext context) {
    }

    default void afterChunk(ChunkContext context) {
    }

    default void afterChunkError(ChunkContext context) {
    }
}
  • 맥락은 위 Listener들과 똑같다. 다만, 여기서는 Chunk를 했을 때 에러가 발생하면 호출되는 메서드도 있다. 

ItemReadListener

public interface ItemReadListener<T> extends StepListener {
    default void beforeRead() {
    }

    default void afterRead(T item) {
    }

    default void onReadError(Exception ex) {
    }
}
  • 마찬가지다.

ItemProcessListener

public interface ItemProcessListener<T, S> extends StepListener {
    default void beforeProcess(T item) {
    }

    default void afterProcess(T item, @Nullable S result) {
    }

    default void onProcessError(T item, Exception e) {
    }
}

ItemWriteListener

public interface ItemWriteListener<S> extends StepListener {
    default void beforeWrite(Chunk<? extends S> items) {
    }

    default void afterWrite(Chunk<? extends S> items) {
    }

    default void onWriteError(Exception exception, Chunk<? extends S> items) {
    }
}

 

 

정리를 하자면

이번 포스팅에서는, 리스너들을 알아보았다. 각 작업 전후로 어떤 행위가 필요할때, 또는 Chunk, Read, Process, Write의 경우 에러가 발생했을 때 어떤 행위가 필요하면 정의하면 좋을듯하다.

728x90
반응형
LIST

'Spring Batch' 카테고리의 다른 글

ItemWriter  (1) 2024.10.09
ItemProcessor  (2) 2024.10.09
ItemReader  (1) 2024.10.09
Chunk Processing  (5) 2024.10.09
Tasklet  (0) 2024.10.09
728x90
반응형
SMALL

Chunk Processing의 마지막 단계로 Item을 쓰는 단계이다. ItemReaderItemProcessor를 거쳐 처리된 Item을 Chunk 단위만큼 처리한 뒤 이를 ItemWriter에 전달한다. ItemWriterItem 1개가 아니라, 데이터의 묶음인 Item List를 처리한다. ItemWriter가 쓰기를 하는 대상은 그 어떤 것도 될 수 있다. 파일이나, RDBMS, NoSQL에 데이터를 쓸 수도 있고, 다른 API를 호출할 수도 있다.

@FunctionalInterface
public interface ItemWriter<T> {
    void write(@NonNull Chunk<? extends T> chunk) throws Exception;
}

 

ItemWriter 또한, Spring Batch에서 개발자들이 많이 사용할 것들을 미리 만들어 줬다. 대표적인 것들은 다음과 같다.

  • JdbcBatchItemWriter
  • JpaItemWriter

 

ItemWriterList로 처리할까?

ItemReaderread()ItemProcessorprocess()는 아래와 같이 데이터 1개를 반환한다.

O process(@NonNull I item) throws Exception;
T read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException;

 

근데 왜 ItemWriterList로 처리할까? ItemWriter는 대부분 쓰기 작업이 일어난다. 이런 쓰기 작업을 건별로 처리하면 효율이 떨어지고 성능에 문제가 되는 경우가 많다. 예를 들어, ItemWriter에서 DatabaseINSERT를 한다고 하면, 1000개의 데이터를 한번에 저장하는 것과 개별 트랜잭션으로 1개씩 저장하는 것은 많은 성능 차이를 만든다. 그렇기 때문에 ItemWriterList로 처리한다고 보면 된다.

 

그럼에도 불구하고, 건별로 처리하고자 할 경우가 있으면 List를 받아서, 요소마다 건별로 처리하도록 구현할 수도 있다.

 

정리를 하자면

이번에는 ItemWriter에 대해 알아보았다. Chunk Processing의 마지막 단계인 ItemWriter. 다음에는 Listener라는 것을 알아보자!

728x90
반응형
LIST

'Spring Batch' 카테고리의 다른 글

Listener  (1) 2024.10.09
ItemProcessor  (2) 2024.10.09
ItemReader  (1) 2024.10.09
Chunk Processing  (5) 2024.10.09
Tasklet  (0) 2024.10.09
728x90
반응형
SMALL

ItemProcessorItemReader에서 read()로 넘겨준 데이터를 개별로 가공한다. ItemProcessor는 언제 사용할까?

  • ItemReader가 넘겨준 데이터를 가공하려고 할 때
  • 데이터를 ItemWriter로 넘길지 말지 결정할 때 (null을 반환하면, ItemWriter에 전달하지 않음)

ItemProcessor는 필수가 아니다. 필요가 없는 경우는 어떤 경우일까?

  • 정말 ItemProcessor가 필요없는 경우. 예를 들면, ItemReader가 데이터베이스에서 데이터를 읽은 뒤 수정없이 그대로 ItemWriter에서 FileWrite하는 경우에는 ItemProcessor가 굳이 필요하지 않다.
  • ItemReaderItemWriter에서 데이터를 직접 가공까지 하는 경우인데, 이 방법은 추천하지는 않지만 상황에 따라 어쩔 수 없이 ItemReader에서 read할 때, 수정한 데이터를 넘겨주는 경우도 있고, ItemWriter에서 쓰기 전 데이터를 수정해서 write하는 경우가 있다.

 

ItemProcessor는 어떻게 구현할까?

ItemProcessorprocess를 구현하면 된다. ItemProcessorInputOutput이 있고, Input을 받아서 Output으로 변환한 뒤 반환해야 한다. 이때, InputOutput의 타입은 같을 수도 있고 다를 수도 있다.

@FunctionalInterface
public interface ItemProcessor<I, O> {
    @Nullable
    O process(@NonNull I item) throws Exception;
}

 

다음은, ItemProcessor를 입맛에 맞게 구현한 코드이다.

@Bean
@StepScope
public ItemProcessor<Order, Price> findExpensivePriceProcessor(PriceRepository priceRepository) {
    return order -> {
        Price price = priceRepository.findByProductId(order.getProductId());
        if (price.amount > 1000000L) {
            return price;
        } else {
            return null;
        }
    };
}

 

 

CompositeItemProcessor

자주 사용하지는 않지만, ItemProcessor 여러개를 체인처럼 연결할 때 사용한다. read를 통해 나온 아이템은 processor1processor2를 연속적으로 통과한다.

@Bean
@StepScope
public CompositeItemProcessor compositeItemProcessor(ItemProcessor<Order, Order> findExpensivePriceProcessor,
                                                     ItemProcessor<Order, Price> priceToPointProcessor) {
    List<ItemProcessor> delegates = List.of(findExpensivePriceProcessor, priceToPointProcessor);
    CompositeItemProcessor processor = new CompositeItemProcessor<>();
    processor.setDelegates(delegates);
    return processor;
}
  • findExpensivePriceProcessor, priceToPointProcessor를 연속적으로 사용하고자 할 때 이렇게 만들 수 있다.

 

정리를 하자면

데이터를 받아 가공할 때 사용하는 ItemProcessor를 알아보았다. 이 녀석은 필수는 아니다. 데이터를 가공할 필요가 있을 때 사용하면 된다. 이제 ItemWriter를 알아보자!

728x90
반응형
LIST

'Spring Batch' 카테고리의 다른 글

Listener  (1) 2024.10.09
ItemWriter  (1) 2024.10.09
ItemReader  (1) 2024.10.09
Chunk Processing  (5) 2024.10.09
Tasklet  (0) 2024.10.09

+ Recent posts