实现

• 使用 ssl_npn,NPN 的开源 SSL 提供者。
• 使用通过 Jetty 的 NPN 扩展库。

Jetty NPN 库

Jetty NPN 库是一个外部的库,而不是 Netty 的本身的一部分。它用于处理 Next Protocol Negotiation, 这是用于检测客户端是否支持 SPDY。

Listing 12.1 Implementation of ServerProvider
public class DefaultServerProvider implements NextProtoNego.ServerProvider {
    private static final List<String> PROTOCOLS =
            Collections.unmodifiableList(Arrays.asList("spdy/2", "spdy/3", "http/1.1"));  //1
    private String protocol;
    @Override
    public void unsupported() {
        protocol = "http/1.1";   //2
    }
    @Override
    public List<String> protocols() {
        return PROTOCOLS;   //3
    }
    @Override
    public void protocolSelected(String protocol) {
        this.protocol = protocol;  //4
    }
    public String getSelectedProtocol() {
        return protocol;  //5
    }
}

1. 定义所有的 ServerProvider 实现的协议
2. 设置如果 SPDY 协议失败了就转到 http/1.1
3. 返回支持的协议的列表
4. 设置选择的协议
5. 返回选择的协议

• SPDY 2
• SPDY 3
• HTTP 1.1

Listing 12.2 Implementation that handles HTTP
@ChannelHandler.Sharable
public class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
    @Override
    public void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception { //1
        if (HttpHeaders.is100ContinueExpected(request)) {
            send100Continue(ctx); //2
        }
        FullHttpResponse response = new DefaultFullHttpResponse(request.getProtocolVersion(), HttpResponseStatus.OK); //3
        response.content().writeBytes(getContent().getBytes(CharsetUtil.UTF_8));  //4
        response.headers().set(HttpHeaders.Names.CONTENT_TYPE, "text/plain; charset=UTF-8");  //5
        boolean keepAlive = HttpHeaders.isKeepAlive(request);
        if (keepAlive) {  //6
            response.headers().set(HttpHeaders.Names.CONTENT_LENGTH, response.content().readableBytes());
            response.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
        }
        ChannelFuture future = ctx.writeAndFlush(response);  //7
        if (!keepAlive) {
            future.addListener (ChannelFutureListener.CLOSE); //8
        }
    }
    protected String getContent() {  //9
        return "This content is transmitted via HTTP\r\n";
    }
    private static void send100Continue(ChannelHandlerContext ctx) {  //10
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE);
        ctx.writeAndFlush(response);
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {  //11
        cause.printStackTrace();
        ctx.close();
    }
}

1. 重写 channelRead0() ,可以被所有的接收到的 FullHttpRequest 调用
2. 检查如果接下来的响应是预期的，就写入
3. 新建 FullHttpResponse,用于对请求的响应
4. 生成响应的内容，将它写入 payload
5. 设置头文件，这样客户端就能知道如何与 响应的 payload 交互
6. 检查请求设置是否启用了 keepalive;如果是这样,将标题设置为符合HTTP RFC
7. 写响应给客户端，并获取到 Future 的引用，用于写完成时，获取到通知
8. 如果响应不是 keepalive，在写完成时关闭连接
9. 返回内容作为响应的 payload
10. Helper 方法生成了100 持续的响应，并写回给客户端
11. 若执行阶段抛出异常，则关闭管道

Listing 12.3 Implementation that handles SPDY
@ChannelHandler.Sharable
public class SpdyRequestHandler extends HttpRequestHandler {   //1
    @Override
    protected String getContent() {
        return "This content is transmitted via SPDY\r\n";  //2
    }
}

1. 继承 HttpRequestHandler 这样就能共享相同的逻辑
2. 生产内容写到 payload。这个重写了 HttpRequestHandler 的 getContent() 的实现

public class DefaultSpdyOrHttpChooser extends SpdyOrHttpChooser {
    public DefaultSpdyOrHttpChooser(int maxSpdyContentLength, int maxHttpContentLength) {
        super(maxSpdyContentLength, maxHttpContentLength);
    }
    @Override
    protected SelectedProtocol getProtocol(SSLEngine engine) {
        DefaultServerProvider provider = (DefaultServerProvider) NextProtoNego.get(engine);  //1
        String protocol = provider.getSelectedProtocol();
        if (protocol == null) {
            return SelectedProtocol.UNKNOWN; //2
        }
        switch (protocol) {
            case "spdy/2":
                return SelectedProtocol.SPDY_2; //3
            case "spdy/3.1":
                return SelectedProtocol.SPDY_3_1; //4
            case "http/1.1":
                return SelectedProtocol.HTTP_1_1; //5
            default:
                return SelectedProtocol.UNKNOWN; //6
        }
    }
    @Override
    protected ChannelInboundHandler createHttpRequestHandlerForHttp() {
        return new HttpRequestHandler(); //7
    }
    @Override
    protected ChannelInboundHandler createHttpRequestHandlerForSpdy() {
        return new SpdyRequestHandler();  //8
    }
}

1. 使用 NextProtoNego 用于获取 DefaultServerProvider 的引用, 用于 SSLEngine
2. 协议不能被检测到。一旦字节已经准备好读,检测过程将重新开始。
3. SPDY 2 被检测到
4. SPDY 3 被检测到
5. HTTP 1.1 被检测到
6. 未知协议被检测到
7. 将会被调用给 FullHttpRequest 消息添加处理器。该方法只会在不支持 SPDY 时调用，那么将会使用 HTTPS
8. 将会被调用给 FullHttpRequest 消息添加处理器。该方法在支持 SPDY 时调用

• SslHandler,用于检测 SPDY 是否通过 TLS 扩展
• DefaultSpdyOrHttpChooser,用于当协议被检测到时，添加正确的 ChannelHandler 到 ChannelPipeline

Listing 12.5 Implementation that handles SPDY
public class SpdyChannelInitializer extends ChannelInitializer<SocketChannel> {  //1
    private final SslContext context;
    public SpdyChannelInitializer(SslContext context) //2 {
        this.context = context;
    }
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        SSLEngine engine = context.newEngine(ch.alloc());  //3
        engine.setUseClientMode(false);  //4
        NextProtoNego.put(engine, new DefaultServerProvider());  //5
        NextProtoNego.debug = true;
        pipeline.addLast("sslHandler", new SslHandler(engine));  //6
        pipeline.addLast("chooser", new DefaultSpdyOrHttpChooser(1024 * 1024, 1024 * 1024));
    }
}

1. 继承 ChannelInitializer 是一个简单的开始
2. 传递 SSLContext 用于创建 SSLEngine
3. 新建 SSLEngine,用于新的管道和连接
4. 配置 SSLEngine 用于非客户端使用
5. 通过 NextProtoNego helper 类绑定 DefaultServerProvider 到 SSLEngine
6. 添加 SslHandler 到 ChannelPipeline 这将会在协议检测到时保存在 ChannelPipeline
7. 添加 DefaultSpyOrHttpChooser 到 ChannelPipeline 。这个实现将会监测协议。添加正确的 ChannelHandler 到 ChannelPipeline,并且移除自身

Listing 12.6 SpdyServer implementation
public class SpdyServer {
    private final NioEventLoopGroup group = new NioEventLoopGroup();  //1
    private final SslContext context;
    private Channel channel;
    public SpdyServer(SslContext context) { //2
        this.context = context;
    }
    public ChannelFuture start(InetSocketAddress address) {
        ServerBootstrap bootstrap  = new ServerBootstrap(); //3
        bootstrap.group(group)
                .channel(NioServerSocketChannel.class)
                .childHandler(new SpdyChannelInitializer(context)); //4
        ChannelFuture future = bootstrap.bind(address); //5
        future.syncUninterruptibly();
        channel = future.channel();
        return future;
    }
    public void destroy() { //6
        if (channel != null) {
            channel.close();
        }
        group.shutdownGracefully();
    }
    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.err.println("Please give port as argument");
            System.exit(1);
        }
        int port = Integer.parseInt(args[0]);
        SelfSignedCertificate cert = new SelfSignedCertificate();
        SslContext context = SslContext.newServerContext(cert.certificate(), cert.privateKey());  //7
        final SpdyServer endpoint = new SpdyServer(context);
        ChannelFuture future = endpoint.start(new InetSocketAddress(port));
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                endpoint.destroy();
            }
        });
        future.channel().closeFuture().syncUninterruptibly();
    }
}

1. 构建新的 NioEventLoopGroup 用于处理 I/O
2. 传递 SSLContext 用于加密
3. 新建 ServerBootstrap 用于配置服务器
4. 配置 ServerBootstrap
5. 绑定服务器用于接收指定地址的连接
6. 销毁服务器，用于关闭管道和 NioEventLoopGroup
7. 从 BogusSslContextFactory 获取 SSLContext 。这是一个虚拟实现进行测试。真正的实现将为 SslContext 配置适当的密钥存储库。