네트워크 2 (Socket)

cwchoiit 2024. 10. 16. 16:36

2024. 10. 16. 16:36

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()만 호출하면 된다.

ServerV4는 ServerV3와 같은 코드이다. 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]

기존 코드의 문제는 클라이언트를 직접 종료하면, 서버의 Session에 EOFException이 발생하면서 자원을 제대로 정리하지 못했다.
변경한 코드에서는 서버에 접속한 클라이언트를 직접 종료해도 서버의 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
Session의 input.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

programmer.cwchoiit