[JAVA]자바 네트워크 프로그래밍: 소켓, NIO, HTTP 통신 마스터 가이드 🌐

안녕하세요! 오늘은 인터넷 세상의 근간을 이루는 자바 네트워크 프로그래밍의 매력적인 세계로 여러분을 초대합니다. 💻 현대 애플리케이션은 대부분 네트워크를 통해 데이터를 주고받으며 동작합니다. 웹 개발부터 마이크로서비스 아키텍처(MSA)까지, 네트워크 프로그래밍 능력은 개발자에게 필수적인 핵심 역량이 되었죠.

이번 포스팅에서는 자바를 이용하여 네트워크 프로그래밍을 시작하는 분들을 위해 기초부터 심화 내용까지 차근차근 안내해 드릴 예정입니다. 소켓 통신부터 NIO, HTTP 통신, 웹 서버/클라이언트 개발, 보안까지! 🌐✨ 네트워크 프로그래밍의 모든 것을 마스터하는 여정을 함께 시작해 볼까요?

반응형

1. 네트워크 프로그래밍 개요 (TCP/IP, OSI 7 Layer 모델)

네트워크 프로그래밍을 이해하기 위한 첫걸음은 네트워크 기본 개념을 확립하는 것입니다. 데이터가 어떻게 인터넷을 통해 전달되는지, 어떤 규칙과 약속들이 존재하는지 알아야 효율적인 네트워크 애플리케이션을 개발할 수 있습니다.

1.1 TCP/IP (Transmission Control Protocol/Internet Protocol)

TCP/IP는 인터넷 통신의 핵심 프로토콜입니다. 데이터를 안정적으로, 그리고 효율적으로 전송하기 위한 다양한 규칙들을 정의하고 있습니다. TCP/IP는 4개의 계층으로 구성됩니다.

• 링크 계층 (Link Layer): 물리적인 네트워크 매체를 통해 데이터를 전송하는 역할을 합니다. 이더넷, Wi-Fi 등이 링크 계층 프로토콜입니다.
• 인터넷 계층 (Internet Layer): IP 주소를 이용하여 데이터 패킷을 목적지까지 라우팅하는 역할을 합니다. IP 프로토콜이 대표적입니다.
• 전송 계층 (Transport Layer): 애플리케이션 간의 데이터 전송을 담당합니다. TCP, UDP 프로토콜이 있습니다.
  • TCP (Transmission Control Protocol): 연결형 프로토콜로, 신뢰성 있는 데이터 전송을 보장합니다. 순서 보장, 오류 검출 및 재전송 기능을 제공합니다.
  • UDP (User Datagram Protocol): 비연결형 프로토콜로, 빠른 데이터 전송에 유리합니다. 실시간 스트리밍, 온라인 게임 등에 사용됩니다.
• 응용 계층 (Application Layer): 실제 애플리케이션에서 사용하는 프로토콜입니다. HTTP, FTP, SMTP 등이 있습니다.

1.2 OSI 7 Layer 모델 (Open Systems Interconnection 7 Layer Model)

OSI 7 Layer 모델은 네트워크 통신 과정을 7개의 계층으로 표준화한 모델입니다. 네트워크 시스템을 체계적으로 이해하고 설계하는 데 도움을 줍니다.

1. 물리 계층 (Physical Layer): 전기적, 물리적인 매체를 통해 비트 스트림을 전송합니다.
2. 데이터 링크 계층 (Data Link Layer): 인접 노드 간의 데이터 전송, 오류 제어를 담당합니다.
3. 네트워크 계층 (Network Layer): IP 주소를 기반으로 패킷을 목적지까지 라우팅합니다.
4. 전송 계층 (Transport Layer): 신뢰성 있는 데이터 전송 (TCP), 빠른 데이터 전송 (UDP)을 제공합니다.
5. 세션 계층 (Session Layer): 통신 장치 간의 연결 설정, 유지, 종료를 관리합니다.
6. 표현 계층 (Presentation Layer): 데이터 표현 방식 (암호화, 압축 등)을 정의합니다.
7. 응용 계층 (Application Layer): 사용자에게 네트워크 서비스를 제공하는 애플리케이션 프로토콜 (HTTP, FTP 등)을 정의합니다.

2. Socket 프로그래밍 (TCP Socket, UDP Socket)

소켓 (Socket) 은 네트워크를 통해 데이터를 주고받기 위한 프로그래밍 인터페이스입니다. 두 개의 프로그램이 네트워크를 통해 통신하려면 각각 소켓을 생성하고 연결해야 합니다. 자바는 java.net.Socket 클래스를 통해 소켓 프로그래밍을 지원합니다.

2.1 TCP Socket 프로그래밍

TCP 소켓은 신뢰성 있는 연결 기반 통신을 제공합니다. 데이터 손실이나 순서 변경 없이 정확하게 데이터를 주고받을 수 있습니다. 웹 브라우저와 웹 서버 간의 통신, 파일 전송 등에 사용됩니다.

TCP 서버 소켓 예제 (간단 버전)

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

public class TCPServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8080)) { // 8080 포트로 서버 소켓 생성
            System.out.println("TCP 서버 시작 - 포트: 8080");
            Socket clientSocket = serverSocket.accept(); // 클라이언트 연결 대기
            System.out.println("클라이언트 연결됨: " + clientSocket.getInetAddress());

            try (
                PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); // 클라이언트에게 데이터 전송 스트림
                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); // 클라이언트로부터 데이터 수신 스트림
            ) {
                String inputLine;
                while ((inputLine = in.readLine()) != null) { // 클라이언트로부터 데이터 수신
                    System.out.println("클라이언트 메시지: " + inputLine);
                    out.println("서버 응답: " + inputLine.toUpperCase()); // 클라이언트에게 응답 전송
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

TCP 클라이언트 소켓 예제 (간단 버전)

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

public class TCPClient {
    public static void main(String[] args) {
        String serverHostname = "localhost"; // 서버 주소
        int serverPort = 8080; // 서버 포트

        try (
            Socket socket = new Socket(serverHostname, serverPort); // 서버에 연결
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true); // 서버에게 데이터 전송 스트림
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); // 서버로부터 데이터 수신 스트림
            BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in)) // 사용자 입력 스트림
        ) {
            String userInput;
            while ((userInput = stdIn.readLine()) != null) { // 사용자 입력
                out.println(userInput); // 서버에게 데이터 전송
                System.out.println("서버 응답: " + in.readLine()); // 서버 응답 수신
            }
        } catch (UnknownHostException e) {
            System.err.println("호스트를 찾을 수 없습니다: " + serverHostname);
            System.exit(1);
        } catch (IOException e) {
            System.err.println("I/O 오류 발생: " + serverHostname);
            System.exit(1);
        }
    }
}

 

2.2 UDP Socket 프로그래밍  

UDP 소켓은 비연결 기반 통신을 제공합니다. TCP보다 속도가 빠르지만, 데이터 손실이나 순서 변경이 발생할 수 있습니다. 실시간 스트리밍, DNS 쿼리 등에 사용됩니다.

UDP 서버 소켓 예제 (간단 버전)

import java.net.*;

public class UDPServer {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket(8080)) { // 8080 포트로 DatagramSocket 생성
            byte[] buffer = new byte[256];

            while (true) {
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length); // 데이터 수신 패킷 생성
                socket.receive(packet); // 데이터 수신

                InetAddress address = packet.getAddress(); // 클라이언트 주소
                int port = packet.getPort(); // 클라이언트 포트
                String received = new String(packet.getData(), 0, packet.getLength()); // 수신 데이터

                System.out.println("클라이언트 메시지: " + received + " - 주소: " + address + ", 포트: " + port);

                String response = "서버 응답: " + received.toUpperCase(); // 응답 메시지 생성
                buffer = response.getBytes();
                packet = new DatagramPacket(buffer, buffer.length, address, port); // 응답 패킷 생성
                socket.send(packet); // 응답 전송
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

UDP 클라이언트 소켓 예제 (간단 버전)

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

public class UDPClient {
    public static void main(String[] args) {
        String serverHostname = "localhost";
        int serverPort = 8080;

        try (DatagramSocket socket = new DatagramSocket()) { // DatagramSocket 생성
            InetAddress address = InetAddress.getByName(serverHostname);

            String message = "UDP 메시지!";
            byte[] buffer = message.getBytes();
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, address, serverPort); // 데이터 전송 패킷 생성
            socket.send(packet); // 데이터 전송

            buffer = new byte[256];
            packet = new DatagramPacket(buffer, buffer.length); // 데이터 수신 패킷 생성
            socket.receive(packet); // 데이터 수신

            String received = new String(packet.getData(), 0, packet.getLength()); // 수신 데이터
            System.out.println("서버 응답: " + received);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. NIO (Non-blocking I/O) 와 Channel, Buffer, Selector

NIO (Non-blocking I/O) 는 기존의 Blocking I/O 방식의 성능 한계를 극복하기 위해 등장했습니다. 단일 쓰레드로 여러 개의 채널을 효율적으로 관리하여 높은 처리량과 확장성을 제공합니다. 주로 고성능 서버 개발에 사용됩니다.

NIO의 핵심 구성 요소는 채널 (Channel), 버퍼 (Buffer), 셀렉터 (Selector) 입니다.

• Channel (채널): 데이터를 읽고 쓰기 위한 통로입니다. FileChannel, SocketChannel, ServerSocketChannel, DatagramChannel 등이 있습니다.
• Buffer (버퍼): 데이터를 임시로 저장하는 공간입니다. ByteBuffer, CharBuffer, IntBuffer 등이 있습니다.
• Selector (셀렉터): 단일 쓰레드로 여러 채널의 I/O 이벤트를 감지하고 처리합니다. Non-blocking I/O의 핵심 역할을 합니다.

NIO 서버 소켓 예제 (간단 버전)

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

public class NIOServer {
    public static void main(String[] args) throws Exception {
        Selector selector = Selector.open(); // 셀렉터 생성
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); // 서버 소켓 채널 생성
        serverSocketChannel.bind(new InetSocketAddress("localhost", 8080)); // 포트 바인딩
        serverSocketChannel.configureBlocking(false); // Non-blocking 모드로 설정
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); // 셀렉터에 등록 (ACCEPT 이벤트 감시)

        ByteBuffer buffer = ByteBuffer.allocate(256);

        while (true) {
            selector.select(); // 이벤트 발생 대기
            Set<SelectionKey> keys = selector.selectedKeys(); // 발생한 이벤트 키 Set 가져오기
            Iterator<SelectionKey> keyIterator = keys.iterator();

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

                if (key.isAcceptable()) { // ACCEPT 이벤트 발생
                    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = serverChannel.accept(); // 클라이언트 연결 수락
                    clientChannel.configureBlocking(false); // Non-blocking 모드로 설정
                    clientChannel.register(selector, SelectionKey.OP_READ); // 셀렉터에 등록 (READ 이벤트 감시)
                    System.out.println("클라이언트 연결됨: " + clientChannel.getRemoteAddress());
                } else if (key.isReadable()) { // READ 이벤트 발생
                    SocketChannel clientChannel = (SocketChannel) key.channel();
                    int bytesRead = clientChannel.read(buffer); // 데이터 읽기
                    if (bytesRead > 0) {
                        buffer.flip(); // 버퍼 flip (읽기 모드로 전환)
                        byte[] data = new byte[buffer.remaining()];
                        buffer.get(data); // 버퍼에서 데이터 가져오기
                        String received = new String(data, "UTF-8");
                        System.out.println("클라이언트 메시지: " + received);
                        buffer.clear(); // 버퍼 clear
                    } else if (bytesRead < 0) {
                        key.cancel(); // 채널 연결 종료
                        clientChannel.close();
                        System.out.println("클라이언트 연결 종료");
                    }
                }
            }
        }
    }
}

 

NIO 클라이언트 소켓 예제 (간단 버전)

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class NIOClient {
    public static void main(String[] args) throws Exception {
        SocketChannel clientChannel = SocketChannel.open(); // 소켓 채널 생성
        clientChannel.connect(new InetSocketAddress("localhost", 8080)); // 서버에 연결

        ByteBuffer buffer = ByteBuffer.wrap("NIO 메시지!".getBytes()); // 버퍼 생성
        clientChannel.write(buffer); // 데이터 전송

        buffer.clear();
        clientChannel.read(buffer); // 서버 응답 수신
        buffer.flip();
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        String received = new String(data, "UTF-8");
        System.out.println("서버 응답: " + received);

        clientChannel.close();
    }
}

4. HTTP 통신 (HttpURLConnection, HttpClient)

HTTP (Hypertext Transfer Protocol) 는 웹에서 데이터를 주고받기 위한 응용 계층 프로토콜입니다. 웹 브라우저와 웹 서버 간의 통신, REST API 호출 등에 사용됩니다.

자바는 HTTP 통신을 위해 HttpURLConnection 클래스를 기본적으로 제공하며, 좀 더 강력하고 다양한 기능을 제공하는 HttpClient (Java 11부터 표준)도 사용할 수 있습니다.

HttpURLConnection 사용 예제 (GET 요청)

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class HttpURLConnectionExample {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://www.example.com"); // 요청 URL
        HttpURLConnection con = (HttpURLConnection) url.openConnection(); // HttpURLConnection 객체 생성
        con.setRequestMethod("GET"); // 요청 메소드 설정 (GET)

        int responseCode = con.getResponseCode(); // 응답 코드 확인
        System.out.println("응답 코드: " + responseCode);

        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream())); // 응답 내용 읽기
        String inputLine;
        StringBuffer response = new StringBuffer();
        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        System.out.println("응답 내용: " + response.toString());
    }
}

 

HttpClient 사용 예제 (GET 요청, Java 11+)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class HttpClientExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient(); // HttpClient 객체 생성
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://www.example.com")) // 요청 URI 설정
                .build(); // HttpRequest 객체 생성

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString()); // 요청 전송 및 응답 수신

        System.out.println("응답 코드: " + response.statusCode()); // 응답 코드 확인
        System.out.println("응답 내용: " + response.body()); // 응답 내용 확인
    }
}

5. 웹 서버/클라이언트 개발 실습 (간단한 HTTP 서버, REST API 클라이언트)

지금까지 배운 내용을 바탕으로 간단한 웹 서버와 REST API 클라이언트를 직접 만들어보면서 네트워크 프로그래밍 능력을 더욱 향상시킬 수 있습니다.

• 간단한 HTTP 서버: 특정 포트로 HTTP 요청을 받아 간단한 HTML 페이지 또는 JSON 데이터를 응답하는 서버를 개발해 볼 수 있습니다. ServerSocketChannel과 ByteBuffer를 이용하여 NIO 기반의 고성능 서버를 구현해 볼 수도 있습니다.  
   
• REST API 클라이언트: 공공 API 또는 직접 개발한 REST API 서버에 HTTP 요청을 보내 데이터를 가져오고 활용하는 클라이언트를 개발해 볼 수 있습니다. HttpClient를 사용하여 다양한 HTTP 메소드 (GET, POST, PUT, DELETE)를 활용해 볼 수 있습니다.

6. 네트워크 프로그래밍 보안 (SSL/TLS, HTTPS)

네트워크 통신은 보안에 취약할 수 있습니다. 중요한 데이터를 주고받을 때는 보안 프로토콜을 적용하여 데이터의 기밀성, 무결성, 인증을 확보해야 합니다.  

• SSL/TLS (Secure Sockets Layer/Transport Layer Security): 네트워크 연결을 암호화하여 데이터를 안전하게 전송하는 프로토콜입니다. HTTPS 통신에 사용됩니다.
• HTTPS (Hypertext Transfer Protocol Secure): HTTP over SSL/TLS 로, HTTP 통신에 SSL/TLS 보안 프로토콜을 적용한 것입니다. 웹 브라우저와 웹 서버 간의 보안 통신에 필수적입니다.

자바에서는 javax.net.ssl 패키지를 통해 SSL/TLS 프로그래밍을 지원하며, HttpsURLConnection 클래스를 사용하여 HTTPS 통신을 쉽게 구현할 수 있습니다. HttpClient 역시 HTTPS를 기본적으로 지원합니다.

7. Netty 프레임워크

Netty 는 비동기 이벤트 기반의 네트워크 애플리케이션 프레임워크입니다. NIO를 기반으로 개발되었으며, 높은 성능과 확장성을 제공합니다. 복잡한 네트워크 프로토콜을 쉽게 구현할 수 있도록 다양한 기능과 편의성을 제공하여, 대규모 트래픽을 처리하는 서버 개발에 널리 사용됩니다.

Netty는 낮은 수준의 소켓 프로그래밍의 복잡성을 숨기고, 개발자가 비즈니스 로직에 집중할 수 있도록 도와줍니다. HTTP 서버, 게임 서버, 채팅 서버 등 다양한 종류의 네트워크 애플리케이션을 효율적으로 개발할 수 있습니다.

8. 마무리

자바 네트워크 프로그래밍은 현대 IT 환경에서 핵심적인 기술입니다. 소켓 통신부터 NIO, HTTP 통신, 보안까지, 다양한 기술들을 익히고 활용하는 것은 개발자로서 경쟁력을 높이는 중요한 발걸음입니다.

이번 포스팅이 여러분의 자바 네트워크 프로그래밍 학습에 도움이 되기를 바라며, 🌐🚀 네트워크 프로그래밍 전문가로 성장하는 여정을 응원합니다!