認識Http請求

在動手寫Netty框架之前，我們先要了解http請求的組成，如下圖：

1. HttpContent 裡面包含的是資料，可以後續有多個 HttpContent 部分
2. LastHttpContent 標記是 HTTP request 的結束，同時可能包含頭的尾部資訊
3. 完整的 HTTP request，由1，2，3組成

1. HTTP response 第一部分是包含的頭資訊
2. HttpContent 裡面包含的是資料，可以後續有多個 HttpContent 部分
3. LastHttpContent 標記是 HTTP response 的結束，同時可能包含頭的尾部資訊
4. 完整的 HTTP response，由1，2，3組成

從request的介紹我們可以看出來，一次http請求並不是通過一次對話完成的，他中間可能有很次的連線。通過上一章我們隊netty的瞭解，每一次對話都會建立一個channel，並且一個ChannelInboundHandler一般是不會同時去處理多個Channel的。
如何在一個Channel裡面處理一次完整的Http請求？這就要用到我們上圖提到的FullHttpRequest，我們只需要在使用netty處理channel的時候，只處理訊息是FullHttpRequest的Channel，這樣我們就能在一個ChannelHandler中處理一個完整的Http請求了。

開始動手

搭建一個Netty伺服器，我們只需要兩個類——一個是啟動類，負責啟動（BootStrap）和main方法，一個是ChannelHandler，負責具體的業務邏輯，我們先從啟動類說起。

package com.dz.netty.http;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import
 
 io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpRequestDecoder;
import io.netty.handler.codec.http.HttpResponseEncoder;

/**
 * Created by RoyDeng on 17/7/20.
 */
public class HttpServer {

    private final int port;

    public HttpServer(int port) {
        this.port = port;
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.err.println(
                    "Usage: " + HttpServer.class.getSimpleName() +
                            " <port>");
            return;
        }
        int port = Integer.parseInt(args[0]);
        new HttpServer(port).start();
    }

    public void start() throws Exception {
        ServerBootstrap b = new ServerBootstrap();
        NioEventLoopGroup group = new NioEventLoopGroup();
        b.group(group)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    public void initChannel(SocketChannel ch)
                            throws Exception {
                        System.out.println("initChannel ch:" + ch);
                        ch.pipeline()
                                .addLast("decoder", new HttpRequestDecoder())   // 1
                                .addLast("encoder", new HttpResponseEncoder())  // 2
                                .addLast("aggregator", new HttpObjectAggregator(512 * 1024))    // 3
                                .addLast("handler", new HttpHandler());        // 4
                    }
                })
                .option(ChannelOption.SO_BACKLOG, 128) // determining the number of connections queued
                .childOption(ChannelOption.SO_KEEPALIVE, Boolean.TRUE);

        b.bind(port).sync();
    }
}

這個類同上一章中出現的Netty簡易封裝伺服器程式碼類似，不一樣的是這裡使用了多個ChannelHandler，在這裡一一介紹：

1. HttpRequestDecoder，用於解碼request
2. HttpResponseEncoder，用於編碼response
3. aggregator，訊息聚合器（重要）。為什麼能有FullHttpRequest這個東西，就是因為有他，HttpObjectAggregator，如果沒有他，就不會有那個訊息是FullHttpRequest的那段Channel，同樣也不會有FullHttpResponse。
   如果我們將z'h
   HttpObjectAggregator(512 * 1024)的引數含義是訊息合併的資料大小，如此代表聚合的訊息內容長度不超過512kb。
4. 新增我們自己的處理介面

完成啟動類之後，接下來就是我們的業務處理類HttpHandler了，先上程式碼：

package com.dz.netty.http;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.util.AsciiString;

/**
 * Created by RoyDeng on 17/7/20.
 */
public class HttpHandler extends SimpleChannelInboundHandler<FullHttpRequest> { // 1

    private AsciiString contentType = HttpHeaderValues.TEXT_PLAIN;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest msg) throws Exception {
        System.out.println("class:" + msg.getClass().getName());
        DefaultFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
                HttpResponseStatus.OK,
                Unpooled.wrappedBuffer("test".getBytes())); // 2

        HttpHeaders heads = response.headers();
        heads.add(HttpHeaderNames.CONTENT_TYPE, contentType + "; charset=UTF-8");
        heads.add(HttpHeaderNames.CONTENT_LENGTH, response.content().readableBytes()); // 3
        heads.add(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);

        ctx.write(response);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelReadComplete");
        super.channelReadComplete(ctx);
        ctx.flush(); // 4
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("exceptionCaught");
        if(null != cause) cause.printStackTrace();
        if(null != ctx) ctx.close();
    }
}

該段程式碼需要注意的地方如註釋所示，有以下四點：

1. Handler需要宣告泛型為<FullHttpRequest>，宣告之後，只有msg為FullHttpRequest的訊息才能進來。
   由於泛型的過濾比較簡單，我們就不改程式碼來驗證了，但是在這裡我們可以利用泛型的特性另外做個小測試，將泛型去掉，並且將HttpServer中.addLast("aggregator", new HttpObjectAggregator(512 * 1024)) // 3這一行程式碼註釋掉，然後觀察註釋前後的log。
   註釋前：

initChannel ch:[id: 0xcb9d8e9e, L:/0:0:0:0:0:0:0:1:8888 - R:/0:0:0:0:0:0:0:1:58855]
class:io.netty.handler.codec.http.HttpObjectAggregator$AggregatedFullHttpRequest
channelReadComplete

註釋後：

initChannel ch:[id: 0xc5415409, L:/0:0:0:0:0:0:0:1:8888 - R:/0:0:0:0:0:0:0:1:58567]
class:io.netty.handler.codec.http.DefaultHttpRequest
class:io.netty.handler.codec.http.LastHttpContent$1
channelReadComplete
channelReadComplete

從中可以看出，如果沒有aggregator，那麼一個http請求就會通過多個Channel被處理，這對我們的業務開發是不方便的，而aggregator的作用就在於此。

2. 生成response，這裡使用的FullHttpResponse，同FullHttpRequest類似，通過這個我們就不用將response拆分成多個channel返回給請求端了。
3. 新增header描述length。這一步是很重要的一步，如果沒有這一步，你會發現用postman發出請求之後就一直在重新整理，因為http請求方不知道返回的資料到底有多長。
4. channel讀取完成之後需要輸出緩衝流。如果沒有這一步，你會發現postman同樣會一直在重新整理。

構建HTTPS服務

​ 首先，構建HTTPS服務需要證書，那麼什麼是SSL證書呢？

​ SSL 證書就是遵守 SSL協議，由受信任的數字證書頒發機構CA，在驗證伺服器身份後頒發，具有伺服器身份驗證和資料傳輸加密功能。

​ 也就是說，HTTPS相比於HTTP服務，能夠防止網路劫持，同時具備一定的安全加密作用。

​ 一般來說，證書可以在阿里雲、騰訊雲這種雲服務上申請。申請下來之後，證書只能用於指定的域名和伺服器上。

​ netty有提供SSL加密的工具包，只需要通過新增SslHandler，就能快速搭建。基於上面的程式碼，我們重新定義一個ChannelInitializer。

public class SSLChannelInitializer extends ChannelInitializer<SocketChannel> {

    private final SslContext sslContext;

    public SSLChannelInitializer() {
        String keyStoreFilePath = "/root/.ssl/test.pkcs12";
        String keyStorePassword = "[email protected]";

        try {
            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            keyStore.load(new FileInputStream(keyStoreFilePath), keyStorePassword.toCharArray());

            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(keyStore, keyStorePassword.toCharArray());

            sslContext = SslContextBuilder.forServer(keyManagerFactory).build();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    protected void initChannel(SocketChannel ch) {
        ChannelPipeline pipeline = ch.pipeline();
        SSLEngine sslEngine = sslContext.newEngine(ch.alloc());
        pipeline
                .addLast(new SslHandler(sslEngine))
                  .addLast("decoder", new HttpRequestDecoder())
                  .addLast("encoder", new HttpResponseEncoder())
                  .addLast("aggregator", new HttpObjectAggregator(512 * 1024))
                  .addLast("handler", new HttpHandler());
        ;
    }
}