HTTP·2 — 멀티플렉싱

HTTP/1.1 (텍스트)                    HTTP/2 (바이너리)
+-----------------------+            +--------+--------+
| GET /index.html       |            | Length | Type   |
| Host: example.com     |   →       | Flags  | Stream |
| Accept: text/html     |            | ID     | Payload|
+-----------------------+            +--------+--------+

HTTP/1.1 — 요청이 순서대로 기다림 (HOL Blocking)

연결 1: [요청A] ────→ [응답A] ────→ [요청B] ────→ [응답B]
연결 2: [요청C] ────→ [응답C] ────→ [요청D] ────→ [응답D]

HTTP/2 — 하나의 연결에서 동시에 처리 (멀티플렉싱)

연결 1: [A 헤더][C 데이터][B 헤더][A 데이터][B 데이터][C 헤더]
         ← 프레임 단위로 섞여서 전송 →

첫 번째 요청: content-type: application/json → 전체 전송 + 동적 테이블에 저장
두 번째 요청: content-type: application/json → 인덱스 번호 하나만 전송

클라이언트: GET /index.html
서버:       PUSH_PROMISE (style.css를 보내겠다)
            HEADERS + DATA (index.html 응답)
            HEADERS + DATA (style.css 응답)  ← 클라이언트가 요청하기 전에 도착

                        +--------+
                 send   |        | recv
                HEADERS |  idle  | HEADERS
                        |        |
                        +--------+
                           / \
                          /   \
                         v     v
                  +--------+ +--------+
           send   |  open  | |  open  |   recv
           DATA   | (half  | | (half  |   DATA
                  | closed)| | closed)|
                  +--------+ +--------+
                         \     /
                          \   /
                           v v
                        +--------+
                        | closed |
                        +--------+

[SslHandler]              ← TLS + ALPN 프로토콜 협상
     ↓
[Http2FrameCodec]         ← HTTP/2 프레임 인코딩/디코딩
     ↓
[Http2MultiplexHandler]   ← 스트림별 자식 Channel 생성
     ↓
[Http2StreamChannel]      ← 스트림 #1, #3, #5, ...
     └── 각각 독립된 ChannelPipeline

// Http2FrameCodec 빌더로 생성 — 서버용
Http2FrameCodec frameCodec = Http2FrameCodecBuilder.forServer()
    .initialSettings(Http2Settings.defaultSettings()
        .maxConcurrentStreams(100)      // 동시 스트림 최대 100개
        .initialWindowSize(65535))     // 초기 흐름 제어 윈도우 크기
    .build();

// 각 스트림이 생성될 때 실행되는 초기화 핸들러
Http2MultiplexHandler multiplexHandler = new Http2MultiplexHandler(
    new ChannelInitializer<Channel>() {
        @Override
        protected void initChannel(Channel ch) {
            ChannelPipeline pipeline = ch.pipeline();
            // 각 스트림에 독립된 핸들러를 구성할 수 있다
            pipeline.addLast(new Http2StreamHandler());
        }
    }
);

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http2.*;
import io.netty.util.CharsetUtil;

// 각 HTTP/2 스트림에서 요청을 처리하는 핸들러
public class Http2StreamHandler extends SimpleChannelInboundHandler<Http2Frame> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Http2Frame frame) {
        if (frame instanceof Http2HeadersFrame) {
            Http2HeadersFrame headersFrame = (Http2HeadersFrame) frame;
            handleHeaders(ctx, headersFrame);
        } else if (frame instanceof Http2DataFrame) {
            Http2DataFrame dataFrame = (Http2DataFrame) frame;
            handleData(ctx, dataFrame);
        }
    }

    private void handleHeaders(ChannelHandlerContext ctx,
                               Http2HeadersFrame headersFrame) {
        Http2Headers headers = headersFrame.headers();
        String method = headers.method() != null ? headers.method().toString() : "";
        String path = headers.path() != null ? headers.path().toString() : "";

        System.out.println("요청 수신: " + method + " " + path);

        // GET 요청이면서 END_STREAM이면 바로 응답
        if (headersFrame.isEndStream()) {
            sendResponse(ctx, "Hello, HTTP/2!");
        }
    }

    private void handleData(ChannelHandlerContext ctx,
                            Http2DataFrame dataFrame) {
        // POST 바디 등 데이터 프레임 처리
        ByteBuf content = dataFrame.content();
        System.out.println("데이터 수신: " + content.toString(CharsetUtil.UTF_8));

        if (dataFrame.isEndStream()) {
            sendResponse(ctx, "데이터를 받았습니다");
        }
    }

    private void sendResponse(ChannelHandlerContext ctx, String body) {
        // 1. 응답 헤더 전송
        Http2Headers responseHeaders = new DefaultHttp2Headers()
            .status("200")
            .add("content-type", "text/plain; charset=utf-8");

        ctx.write(new DefaultHttp2HeadersFrame(responseHeaders));

        // 2. 응답 바디 전송 (END_STREAM 플래그로 스트림 종료)
        ByteBuf responseBody = Unpooled.copiedBuffer(body, CharsetUtil.UTF_8);
        ctx.writeAndFlush(new DefaultHttp2DataFrame(responseBody, true));
    }
}

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http2.*;
import io.netty.handler.ssl.*;
import io.netty.handler.ssl.util.SelfSignedCertificate;

public class Http2Server {

    private static final int PORT = 8443;

    public static void main(String[] args) throws Exception {
        // 자체 서명 인증서 생성 (개발용)
        SelfSignedCertificate ssc = new SelfSignedCertificate();

        // HTTP/2는 TLS + ALPN이 필요하다
        SslContext sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey())
            .applicationProtocolConfig(new ApplicationProtocolConfig(
                ApplicationProtocolConfig.Protocol.ALPN,
                ApplicationProtocolConfig.SelectorFailureBehavior.NO_ADVERTISE,
                ApplicationProtocolConfig.SelectedListenerFailureBehavior.ACCEPT,
                ApplicationProtocolNames.HTTP_2   // "h2"를 ALPN에 등록
            ))
            .build();

        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) {
                        ChannelPipeline pipeline = ch.pipeline();

                        // 1. TLS 핸들러 — ALPN 프로토콜 협상 포함
                        pipeline.addLast("ssl", sslCtx.newHandler(ch.alloc()));

                        // 2. HTTP/2 프레임 코덱
                        pipeline.addLast("frameCodec",
                            Http2FrameCodecBuilder.forServer().build());

                        // 3. 멀티플렉스 핸들러 — 스트림별 자식 Channel 생성
                        pipeline.addLast("multiplexHandler",
                            new Http2MultiplexHandler(
                                new ChannelInitializer<Channel>() {
                                    @Override
                                    protected void initChannel(Channel ch) {
                                        ch.pipeline().addLast(
                                            new Http2StreamHandler());
                                    }
                                }
                            ));
                    }
                });

            ChannelFuture future = bootstrap.bind(PORT).sync();
            System.out.println("HTTP/2 서버 시작 — 포트: " + PORT);

            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

클라이언트 → 서버: ClientHello + ALPN 확장 ["h2", "http/1.1"]
서버 → 클라이언트: ServerHello + ALPN 확장 ["h2"]
                  ↑ 서버가 h2를 선택

// ALPN을 포함한 SSL 컨텍스트 구성
SslContext sslCtx = SslContextBuilder.forServer(certFile, keyFile)
    .applicationProtocolConfig(new ApplicationProtocolConfig(
        // ALPN 프로토콜 사용
        ApplicationProtocolConfig.Protocol.ALPN,
        // 클라이언트가 지원하지 않으면 광고하지 않음
        ApplicationProtocolConfig.SelectorFailureBehavior.NO_ADVERTISE,
        // 선택된 프로토콜이 없어도 연결 수락
        ApplicationProtocolConfig.SelectedListenerFailureBehavior.ACCEPT,
        // 지원하는 프로토콜 목록 (우선순위 순서)
        ApplicationProtocolNames.HTTP_2,    // "h2"
        ApplicationProtocolNames.HTTP_1_1   // "http/1.1"
    ))
    .build();

import io.netty.channel.*;
import io.netty.handler.codec.http.*;
import io.netty.handler.codec.http2.*;
import io.netty.handler.ssl.ApplicationProtocolNames;
import io.netty.handler.ssl.ApplicationProtocolNegotiationHandler;

// ALPN 협상 결과에 따라 파이프라인을 동적으로 구성하는 핸들러
public class Http2OrHttp1Handler extends ApplicationProtocolNegotiationHandler {

    // ALPN이 지원되지 않을 때 기본 프로토콜
    public Http2OrHttp1Handler() {
        super(ApplicationProtocolNames.HTTP_1_1);
    }

    @Override
    protected void configurePipeline(ChannelHandlerContext ctx,
                                     String protocol) {
        ChannelPipeline pipeline = ctx.pipeline();

        if (ApplicationProtocolNames.HTTP_2.equals(protocol)) {
            // HTTP/2로 협상됨
            configureHttp2(pipeline);
        } else if (ApplicationProtocolNames.HTTP_1_1.equals(protocol)) {
            // HTTP/1.1로 협상됨
            configureHttp1(pipeline);
        } else {
            throw new IllegalStateException("알 수 없는 프로토콜: " + protocol);
        }
    }

    private void configureHttp2(ChannelPipeline pipeline) {
        pipeline.addLast("frameCodec",
            Http2FrameCodecBuilder.forServer().build());
        pipeline.addLast("multiplexHandler",
            new Http2MultiplexHandler(
                new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel ch) {
                        ch.pipeline().addLast(new Http2StreamHandler());
                    }
                }
            ));
    }

    private void configureHttp1(ChannelPipeline pipeline) {
        pipeline.addLast("httpCodec", new HttpServerCodec());
        pipeline.addLast("aggregator",
            new HttpObjectAggregator(1024 * 1024));
        pipeline.addLast("handler", new Http1RequestHandler());
    }
}

// SSL + 프로토콜 분기를 적용한 파이프라인
bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
    @Override
    protected void initChannel(SocketChannel ch) {
        ChannelPipeline pipeline = ch.pipeline();

        // 1. TLS 핸들러
        pipeline.addLast("ssl", sslCtx.newHandler(ch.alloc()));

        // 2. ALPN 결과에 따라 HTTP/2 또는 HTTP/1.1 파이프라인 구성
        pipeline.addLast("protocolNegotiator", new Http2OrHttp1Handler());
    }
});

// 서버가 보내는 초기 설정
Http2Settings settings = new Http2Settings()
    .maxConcurrentStreams(100)     // 동시 스트림 최대 100개
    .initialWindowSize(1048576)   // 흐름 제어 윈도우 1MB
    .maxHeaderListSize(8192);     // 헤더 최대 크기 8KB

Http2FrameCodec frameCodec = Http2FrameCodecBuilder.forServer()
    .initialSettings(settings)
    .build();

TCP 패킷 흐름:

[패킷1: 스트림A] [패킷2: 스트림B] [패킷3: 스트림C] [패킷4: 스트림A]
                       ↑
                  이 패킷이 유실되면?
                  → 패킷3, 패킷4도 기다려야 함
                  → 스트림 B, C, A 모두 영향