Java NIO: 논블로킹 I/O 프로그래밍의 세계로 풍덩! 🏊‍♂️

안녕, 친구들! 오늘은 정말 흥미진진한 주제로 찾아왔어. 바로 Java NIO, 그러니까 논블로킹 I/O 프로그래밍에 대해 함께 알아볼 거야. 😎 이 주제, 처음 들으면 좀 어렵게 느껴질 수 있지만, 걱정 마! 내가 아주 쉽고 재미있게 설명해줄 테니까.

그런데 말이야, 우리가 이런 고급 Java 기술에 대해 배우려고 하는 걸 보니, 너희들도 프로그래밍에 관심이 많은 것 같아. 혹시 자신의 프로그래밍 실력을 뽐내고 싶다면, 재능넷(https://www.jaenung.net)이라는 사이트를 한번 들러봐. 거기서 너의 Java 실력을 다른 사람들과 나누고, 새로운 프로젝트도 시작할 수 있을 거야. 자, 이제 본격적으로 Java NIO의 세계로 들어가볼까?

자, 이제부터 우리는 Java NIO의 세계로 깊이 들어갈 거야. 준비됐니? 그럼 출발! 🚀

1. Java NIO의 기본 개념 이해하기 🧠

자, 친구들! Java NIO를 이해하기 전에, 우리가 왜 이걸 배워야 하는지부터 알아볼까? 🤔

옛날옛날에 (그러니까 Java NIO가 없던 시절에), 우리는 Java I/O를 사용해서 파일을 읽고 쓰거나 네트워크 통신을 했어. 근데 이 방식이 좀... 느렸지? 마치 편의점에서 라면을 사고 물이 끓기를 기다리는 것처럼 말이야. 물이 끓을 때까지 우리는 아무것도 못하고 그냥 기다려야 했어. 이런 방식을 우리는 '블로킹 I/O'라고 불러.

그런데 Java NIO는 이런 문제를 해결해줘. 어떻게? 바로 '논블로킹' 방식을 도입해서! 이건 마치 라면을 끓이면서 동시에 다른 일을 할 수 있는 것과 같아. 물이 끓는 동안 우리는 휴대폰도 보고, 친구랑 얘기도 하고, 심지어 다른 요리 준비도 할 수 있지. cool하지 않아? 😎

Java NIO의 핵심 개념들을 간단히 살펴볼까?

• 채널(Channel): 데이터의 입출력이 일어나는 통로야. 파일이나 네트워크 연결과 같은 I/O 소스와 프로그램 사이의 연결 다리라고 생각하면 돼.
• 버퍼(Buffer): 데이터를 임시로 저장하는 메모리 영역이야. 채널을 통해 데이터를 읽거나 쓸 때 이 버퍼를 사용해.
• 셀렉터(Selector): 여러 채널의 이벤트를 모니터링하고 관리하는 특별한 컴포넌트야. 이게 바로 논블로킹 I/O의 핵심이지!

이 세 가지가 Java NIO의 삼총사라고 할 수 있어. 이들이 어떻게 협력하는지 그림으로 한번 볼까?

와! 이 그림을 보니 Java NIO가 어떻게 동작하는지 좀 감이 오지 않아? Selector가 여러 Channel을 동시에 모니터링하고 있고, 각 Channel은 Buffer를 통해 데이터를 주고받고 있어. 이런 구조 덕분에 우리는 여러 I/O 작업을 효율적으로 처리할 수 있는 거야.

그런데 말이야, 이렇게 멋진 기술을 배우다 보면 "와, 이거 실제로 어디에 쓰이는 거지?"라는 의문이 들 수 있어. 실제로 Java NIO는 많은 곳에서 사용되고 있어. 예를 들면:

• 대규모 웹 서버
• 실시간 채팅 애플리케이션
• 게임 서버
• 금융 거래 시스템

이런 시스템들은 동시에 수많은 연결을 처리해야 하기 때문에, Java NIO의 논블로킹 특성이 아주 유용하게 사용돼. 그리고 말이야, 만약 네가 이런 시스템을 개발하는 실력을 갖추게 된다면, 재능넷같은 플랫폼에서 네 실력을 뽐내고 다른 개발자들과 협업할 수 있는 기회도 생길 거야. 멋지지 않아?

자, 이제 우리는 Java NIO의 기본 개념에 대해 알아봤어. 다음 섹션에서는 이 개념들을 좀 더 자세히 파헤쳐볼 거야. 준비됐니? 그럼 계속 가보자고! 🚀

2. Channel: Java NIO의 데이터 고속도로 🛣️

안녕, 친구들! 이번에는 Java NIO의 첫 번째 주인공, Channel에 대해 자세히 알아볼 거야. Channel이 뭐냐고? 음... 상상해봐. 네가 아주 긴 워터슬라이드를 타고 있다고 말이야. 그 슬라이드가 바로 Channel이야! 🌊

자, 이제 Channel의 특징들을 하나씩 살펴볼까?

1. 양방향 통신 👥

Channel의 가장 큰 특징 중 하나는 양방향 통신이 가능하다는 거야. 기존의 Java I/O에서는 InputStream과 OutputStream을 따로 사용해야 했지만, Channel은 하나로 읽기와 쓰기를 모두 할 수 있어. 마치 양방향 도로같은 거지!

2. 비동기 I/O 지원 ⚡

Channel은 비동기 I/O를 지원해. 이게 무슨 말이냐면, 데이터를 읽거나 쓰는 동안 다른 작업을 할 수 있다는 거야. 마치 라면을 끓이면서 동시에 핸드폰을 보는 것처럼 말이야. 효율적이지 않아?

3. 버퍼를 통한 데이터 전송 📦

Channel은 항상 Buffer를 통해 데이터를 주고받아. 직접 바이트 단위로 데이터를 다루는 대신, Buffer라는 컨테이너에 데이터를 담아서 전송하는 거지. 이렇게 하면 데이터 처리가 더 효율적이고 빨라져.

4. 다양한 Channel 구현체 🌈

Java NIO는 다양한 종류의 Channel을 제공해. 각각의 Channel은 특정 I/O 작업에 최적화되어 있어. 주요 Channel 구현체들을 살펴볼까?

• FileChannel: 파일 읽기/쓰기용 Channel이야. 대용량 파일을 효율적으로 처리할 수 있어.
• SocketChannel: TCP 네트워크 통신을 위한 Channel이야. 클라이언트 측에서 사용돼.
• ServerSocketChannel: TCP 서버를 구현할 때 사용하는 Channel이야.
• DatagramChannel: UDP 통신을 위한 Channel이야. 빠른 속도가 필요한 경우에 사용해.

와! 이렇게 다양한 Channel이 있다니 놀랍지 않아? 각각의 Channel은 특정 상황에 맞게 최적화되어 있어서, 우리는 상황에 따라 적절한 Channel을 선택해서 사용할 수 있어.

그런데 말이야, 이런 Channel들을 어떻게 사용하는지 궁금하지 않아? 간단한 예제를 통해 FileChannel을 사용하는 방법을 한번 볼까?

import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class FileChannelExample {
    public static void main(String[] args) {
        try {
            // FileChannel 생성
            FileChannel channel = FileChannel.open(Paths.get("example.txt"), StandardOpenOption.CREATE, StandardOpenOption.WRITE);

            // 버퍼 생성 및 데이터 쓰기
            ByteBuffer buffer = ByteBuffer.wrap("Hello, Java NIO!".getBytes());
            channel.write(buffer);

            // 채널 닫기
            channel.close();

            System.out.println("파일에 데이터를 성공적으로 썼습니다!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

이 코드는 "example.txt"라는 파일을 생성하고, 그 안에 "Hello, Java NIO!"라는 문자열을 쓰는 간단한 예제야. FileChannel을 사용해서 파일에 데이터를 쓰는 과정을 보여주고 있지.

여기서 주목할 점은 ByteBuffer를 사용한다는 거야. Channel은 항상 Buffer를 통해 데이터를 주고받는다고 했지? 이 예제에서도 그 원칙을 따르고 있어.

자, 이제 우리는 Channel에 대해 꽤 자세히 알아봤어. Channel은 Java NIO의 핵심 컴포넌트 중 하나로, 효율적인 I/O 처리를 가능하게 해주는 강력한 도구야. 네가 대규모 시스템을 개발하게 된다면, Channel을 잘 활용해서 성능을 크게 향상시킬 수 있을 거야.

그런데 말이야, 이렇게 멋진 기술을 배우고 나면 어떻게 활용할 수 있을까? 음... 예를 들어, 너가 재능넷같은 플랫폼에서 대용량 파일 업로드/다운로드 기능을 구현해야 한다고 생각해봐. FileChannel을 사용하면 대용량 파일도 효율적으로 처리할 수 있을 거야. 멋지지 않아?

다음 섹션에서는 Buffer에 대해 자세히 알아볼 거야. Channel과 Buffer는 찰떡궁합이니까, 이 둘을 함께 이해하면 Java NIO의 진가를 제대로 느낄 수 있을 거야. 준비됐니? 그럼 계속 가보자고! 🚀

3. Buffer: Java NIO의 데이터 컨테이너 📦

안녕, 친구들! 이번에는 Java NIO의 두 번째 주인공, Buffer에 대해 알아볼 거야. Buffer는 뭐냐고? 음... 상상해봐. 네가 아주 큰 택배 상자를 가지고 있다고 말이야. 그 상자에 여러 가지 물건을 담았다가 꺼냈다가 할 수 있지? 그 상자가 바로 Buffer야! 🎁

자, 이제 Buffer의 특징들을 하나씩 살펴볼까?

1. 데이터 타입별 Buffer 👨‍🔬

Java NIO는 다양한 데이터 타입에 대한 Buffer를 제공해. 예를 들면:

• ByteBuffer
• CharBuffer
• ShortBuffer
• IntBuffer
• LongBuffer
• FloatBuffer
• DoubleBuffer

이렇게 다양한 Buffer가 있어서 우리는 상황에 맞는 적절한 Buffer를 선택해서 사용할 수 있어. 예를 들어, 바이트 단위의 데이터를 다룰 때는 ByteBuffer를, 문자 데이터를 다룰 때는 CharBuffer를 사용하면 돼.

2. Buffer의 주요 속성 🏷️

Buffer는 네 가지 중요한 속성을 가지고 있어. 이 속성들을 이해하면 Buffer를 더 효율적으로 사용할 수 있지:

• capacity: Buffer가 담을 수 있는 데이터 요소의 최대 개수야.
• position: 현재 읽거나 쓸 위치를 가리키는 인덱스야.
• limit: 읽거나 쓸 수 있는 마지막 위치야.
• mark: 현재 position을 나중에 다시 불러올 수 있도록 표시해두는 인덱스야.

이 속성들이 어떻게 동작하는지 그림으로 한번 볼까?

이 그림을 보면 Buffer의 구조를 더 쉽게 이해할 수 있지? position은 현재 위치를, limit은 읽거나 쓸 수 있는 마지막 위치를, capacity는 Buffer의 전체 크기를 나타내. 그리고 mark는 나중에 돌아올 수 있는 위치를 표시해두는 거야.

3. Buffer의 주요 메서드 🛠️

Buffer를 효과적으로 사용하기 위해서는 몇 가지 중요한 메서드들을 알아야 해:

• put(): Buffer에 데이터를 넣어.
• get(): Buffer에서 데이터를 꺼내.
• flip(): 쓰기 모드에서 읽기 모드로 전환해. limit를 현재 position으로 설정하고, position을 0으로 리셋해.
• clear(): Buffer를 초기화해. position을 0으로, limit를 capacity로 설정해.
• rewind(): position을 0으로 리셋해. 데이터를 다시 읽을 때 사용해.
• compact(): 읽지 않은 데이터를 Buffer의 앞쪽으로 복사하고, position을 그 다음 위치로 설정해.

이 메서드들을 잘 활용하면 Buffer를 아주 효 율적으로 사용할 수 있어. 자, 이제 간단한 예제를 통해 Buffer를 어떻게 사용하는지 살펴볼까?

import java.nio.ByteBuffer;

public class BufferExample {
    public static void main(String[] args) {
        // 10바이트 크기의 ByteBuffer 생성
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // 데이터 쓰기
        buffer.put((byte) 10);
        buffer.put((byte) 20);
        buffer.put((byte) 30);

        System.out.println("Writing to Buffer:");
        System.out.println("Position: " + buffer.position());
        System.out.println("Limit: " + buffer.limit());
        System.out.println("Capacity: " + buffer.capacity());

        // 읽기 모드로 전환
        buffer.flip();

        System.out.println("\nAfter flip():");
        System.out.println("Position: " + buffer.position());
        System.out.println("Limit: " + buffer.limit());
        System.out.println("Capacity: " + buffer.capacity());

        // 데이터 읽기
        while(buffer.hasRemaining()) {
            System.out.println("Read: " + buffer.get());
        }

        System.out.println("\nAfter reading:");
        System.out.println("Position: " + buffer.position());
        System.out.println("Limit: " + buffer.limit());
        System.out.println("Capacity: " + buffer.capacity());
    }
}

이 예제는 ByteBuffer를 생성하고, 데이터를 쓰고 읽는 과정을 보여줘. 특히 주목할 점은 flip() 메서드를 호출해서 쓰기 모드에서 읽기 모드로 전환하는 부분이야. 이렇게 하면 Buffer의 상태가 어떻게 변하는지 확실히 볼 수 있지.

4. Direct Buffer vs Non-Direct Buffer 🏎️ vs 🚗

Java NIO에서는 두 가지 종류의 Buffer를 제공해: Direct Buffer와 Non-Direct Buffer.

• Direct Buffer: 운영체제의 메모리를 직접 사용해. I/O 작업이 빠르지만, 생성과 해제에 비용이 많이 들어.
• Non-Direct Buffer: JVM의 힙 메모리를 사용해. 생성과 해제가 빠르지만, I/O 작업 시 중간에 복사 과정이 필요해.

어떤 Buffer를 사용할지는 상황에 따라 다르겠지만, 대용량 데이터를 자주 처리해야 하는 경우에는 Direct Buffer를 고려해볼 만해.

자, 이제 우리는 Buffer에 대해 꽤 자세히 알아봤어. Buffer는 Java NIO의 핵심 컴포넌트 중 하나로, Channel과 함께 사용되어 효율적인 I/O 처리를 가능하게 해주는 강력한 도구야.

그런데 말이야, 이런 Buffer를 실제로 어떻게 활용할 수 있을까? 음... 예를 들어, 네가 재능넷같은 플랫폼에서 대용량 이미지 처리 기능을 구현해야 한다고 생각해봐. ByteBuffer를 사용하면 이미지 데이터를 효율적으로 처리할 수 있을 거야. 이미지를 읽어서 Buffer에 저장하고, 필요한 처리를 한 후에 다시 파일이나 네트워크로 전송하는 식으로 말이야.

다음 섹션에서는 Selector에 대해 자세히 알아볼 거야. Selector는 Channel과 함께 사용되어 논블로킹 I/O의 핵심을 이루는 컴포넌트야. Channel, Buffer, 그리고 Selector. 이 세 가지를 모두 이해하면 Java NIO의 진정한 힘을 느낄 수 있을 거야. 준비됐니? 그럼 계속 가보자고! 🚀

4. Selector: Java NIO의 트래픽 관리자 🚦

안녕, 친구들! 이번에는 Java NIO의 마지막 주인공, Selector에 대해 알아볼 거야. Selector는 뭐냐고? 음... 상상해봐. 네가 아주 바쁜 교차로의 교통경찰이라고 말이야. 여러 방향에서 오는 차들을 효율적으로 관리해야 해. 그 교통경찰이 바로 Selector야! 🚗🚙🚕

자, 이제 Selector의 특징들을 하나씩 살펴볼까?

1. 다중 채널 관리 👨‍💼

Selector의 가장 큰 특징은 여러 Channel을 동시에 관리할 수 있다는 거야. 이게 왜 중요하냐고? 음... 상상해봐. 네가 피자 가게 주인이라고 해보자. 주문 전화가 여러 개 있는데, 각 전화마다 직원을 한 명씩 배치하면 비용이 엄청 들겠지? 대신에 한 명의 직원이 여러 전화를 관리하면 어떨까? 그게 바로 Selector가 하는 일이야.

2. 이벤트 기반 처리 🎭

Selector는 Channel에서 발생하는 특정 이벤트를 모니터링해. 주요 이벤트에는 다음과 같은 것들이 있어:

• SelectionKey.OP_READ: 데이터를 읽을 준비가 됐을 때
• SelectionKey.OP_WRITE: 데이터를 쓸 준비가 됐을 때
• SelectionKey.OP_CONNECT: 연결이 완료됐을 때
• SelectionKey.OP_ACCEPT: 새로운 연결을 수락할 준비가 됐을 때

이런 이벤트들이 발생하면 Selector가 알려주기 때문에, 우리는 필요한 때에만 I/O 작업을 수행할 수 있어. 효율적이지?

3. 논블로킹 I/O 구현 ⚡

Selector를 사용하면 논블로킹 I/O를 쉽게 구현할 수 있어. 이게 무슨 말이냐면, I/O 작업을 기다리는 동안 다른 일을 할 수 있다는 거야. 마치 라면을 끓이면서 동시에 방 청소를 하는 것처럼 말이야. 멋지지 않아?

4. Selector 사용하기 🛠️

자, 이제 Selector를 어떻게 사용하는지 간단한 예제를 통해 알아볼까?

import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.SelectionKey;
import java.net.InetSocketAddress;
import java.util.Iterator;
import java.util.Set;

public class SelectorExample {
    public static void main(String[] args) throws Exception {
        // Selector 생성
        Selector selector = Selector.open();

        // ServerSocketChannel 생성 및 설정
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress("localhost", 5000));
        serverSocket.configureBlocking(false);

        // ServerSocketChannel을 Selector에 등록
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            // 이벤트 발생 대기
            int readyChannels = selector.select();

            if (readyChannels == 0) {
                continue;
            }

            // 발생한 이벤트 처리
            Set<selectionkey> selectedKeys = selector.selectedKeys();
            Iterator<selectionkey> keyIterator = selectedKeys.iterator();

            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();

                if (key.isAcceptable()) {
                    // 새로운 클라이언트 연결 수락
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel client = server.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("새로운 클라이언트 연결 수락");
                } else if (key.isReadable()) {
                    // 클라이언트로부터 데이터 읽기
                    SocketChannel client = (SocketChannel) key.channel();
                    // 데이터 읽기 로직 구현
                    System.out.println("클라이언트로부터 데이터 읽기");
                }

                keyIterator.remove();
            }
        }
    }
}
</selectionkey></selectionkey>

이 예제는 Selector를 사용해서 여러 클라이언트의 연결을 관리하는 간단한 서버를 구현한 거야. Selector가 여러 Channel의 이벤트를 어떻게 모니터링하고 처리하는지 볼 수 있지?

5. Selector의 장단점 ⚖️

Selector를 사용하면 좋은 점도 있지만, 주의해야 할 점도 있어. 한번 살펴볼까?

장점:

• 적은 수의 스레드로 많은 연결을 처리할 수 있어 리소스를 효율적으로 사용할 수 있어.
• 논블로킹 I/O를 구현하기 쉬워져.
• 확장성이 뛰어나 대규모 애플리케이션에 적합해.

단점:

• 코드가 복잡해질 수 있어.
• CPU 사용량이 증가할 수 있어.
• 디버깅이 어려울 수 있어.

자, 이제 우리는 Selector에 대해 꽤 자세히 알아봤어. Selector는 Java NIO의 핵심 컴포넌트 중 하나로, Channel과 함께 사용되어 효율적인 논블로킹 I/O를 가능하게 해주는 강력한 도구야.

그런데 말이야, 이런 Selector를 실제로 어떻게 활용할 수 있을까? 음... 예를 들어, 네가 재능넷같은 플랫폼에서 실시간 채팅 기능을 구현해야 한다고 생각해봐. Selector를 사용하면 수많은 사용자의 연결을 효율적으로 관리할 수 있을 거야. 한 명의 관리자(스레드)가 여러 채팅방(Channel)을 동시에 모니터링하고 필요할 때만 메시지를 처리하는 식으로 말이야.

이렇게 해서 우리는 Java NIO의 세 가지 핵심 컴포넌트인 Channel, Buffer, Selector에 대해 모두 알아봤어. 이 세 가지를 잘 이해하고 활용하면, 네가 만드는 애플리케이션의 성능을 크게 향상시킬 수 있을 거야. 특히 대규모 시스템을 개발할 때 이런 지식은 정말 중요하지.

Java NIO는 정말 강력한 도구야. 하지만 동시에 복잡하기도 해. 그래서 처음에는 좀 어렵게 느껴질 수 있어. 하지만 걱정하지 마. 연습하고 경험을 쌓다 보면 점점 익숙해질 거야. 그리고 언젠가는 네가 Java NIO를 마스터해서 아주 멋진 프로젝트를 만들 수 있을 거라고 믿어!

자, 이제 우리의 Java NIO 여행이 끝났어. 어떠니? 재미있었니? 이해가 잘 됐니? 혹시 더 궁금한 점이 있다면 언제든 물어봐. 그리고 이 지식을 활용해서 멋진 프로젝트를 만들어보는 건 어때? 화이팅! 👍

마무리: Java NIO의 세계를 정복하다! 🏆

와우! 정말 긴 여정이었지만, 드디어 Java NIO의 핵심을 모두 살펴봤어. 어떠니? 머리가 좀 아프지 않아? 😅 걱정 마, 이런 고급 기술을 한 번에 완전히 이해하기는 어려워. 하지만 너는 이미 큰 걸음을 내딛었어!

우리가 배운 내용을 간단히 정리해볼까?

1. Channel: 데이터의 입출력이 일어나는 통로. 양방향 통신이 가능하고, 비동기 I/O를 지원해.
2. Buffer: 데이터를 임시로 저장하는 메모리 영역. 다양한 데이터 타입을 지원하고, 효율적인 데이터 처리가 가능해.
3. Selector: 여러 Channel의 I/O 이벤트를 모니터링하고 관리하는 컴포넌트. 하나의 스레드로 여러 Channel을 효율적으로 처리할 수 있게 해줘.

이 세 가지 컴포넌트를 잘 활용하면, 네가 만드는 애플리케이션의 성능을 크게 향상시킬 수 있어. 특히 대규모 시스템, 실시간 애플리케이션, 고성능이 필요한 서버 등을 개발할 때 Java NIO는 정말 강력한 도구가 될 거야.

그런데 말이야, 이렇게 멋진 기술을 배웠으니 어디에 써먹을지 고민되지 않아? 음... 내가 몇 가지 아이디어를 줄게:

• 실시간 채팅 애플리케이션: Selector를 사용해 수많은 사용자의 연결을 효율적으로 관리할 수 있어.
• 대용량 파일 처리 시스템: Channel과 Buffer를 활용해 대용량 파일을 빠르게 읽고 쓸 수 있어.
• 고성능 웹 서버: 논블로킹 I/O를 활용해 많은 동시 연결을 처리할 수 있는 웹 서버를 만들 수 있어.
• 네트워크 게임 서버: 실시간으로 많은 플레이어의 데이터를 처리해야 하는 게임 서버에 적합해.

이런 프로젝트들을 재능넷같은 플랫폼에서 시작해보는 건 어때? 네 실력을 뽐내고, 다른 개발자들과 협업할 수 있는 좋은 기회가 될 거야.

마지막으로, Java NIO를 공부하면서 느꼈겠지만, 프로그래밍의 세계는 정말 넓고 깊어. 오늘 배운 내용은 그 중 일부일 뿐이야. 앞으로도 계속 공부하고, 새로운 것을 배우는 걸 두려워하지 마. 그게 바로 진정한 개발자의 자세야.

자, 이제 정말 끝이야. 긴 여정이었지만, 네가 끝까지 따라와줘서 정말 고마워. 이제 네가 배운 지식을 활용해서 멋진 프로젝트를 만들어볼 차례야. 어떤 아이디어가 떠오르니? 뭘 만들고 싶어? 언제든 시작해봐. 나는 네가 Java NIO를 마스터해서 아주 멋진 개발자가 될 거라고 믿어!

화이팅! 👍 그리고 즐거운 코딩하길 바래! 🚀👨‍💻