高性能 Netty 之结合 Http 协议应用

经过了这么多篇文章,其实大家也肯定知道, Netty
主要是在 OSI
七层网络层的应用层进行数据处理的( 因为 Socket 是出于传输层以上的东西,是应用层与传输层的一个抽象层
)。所以肯定明白 Netty
协议这方面肯定是能够掌控的。

HTTP

说到网络协议,相信大家最熟悉的协议也就是 HTTP
协议了。 HTTP
协议是建立在 TCP
传输协议上的应用层协议,属于应用层的面向对象协议。由于简捷,快速的方式,适用于分布式超媒体信息系统。

HTTP 特点

HTTP
协议主要有如下特点:

  1. 支持 CS 模式。
  2. 简洁。客户端向服务端请求只需要指定服务 URL,携带必要的请求参数或者消息体。
  3. 灵活。 HTTP
    允许传输任意类型的数据对象,传输内容类型是 HTTP 消息头的 Content-type
    加以标记。
  4. 高效。客户端和服务端之间是一种一次性连接,它限制了每次连接只处理一个请求。当服务器返回本次请求的应答后便立即关闭连接,等待下一次重新建立连接。这样做是为了顾虑到日后介入千万个用户,及时地释放连接可以大大提高服务器的执行效率。
  5. 无状态。 HTTP
    协议是无状态协议,指的是对于事务处理没有任何记忆能力。缺少记忆能力的后果就是导致后续的处理需要之前的信息,则客户端必须携带重传,这样可能导致每次连接传送的数据亮增大。另一方面,在服务器不需要先前信息时它的应答较快,负载较轻。

知道完特点后,我再简单介绍一下 HTTP
的数据构成,这样有助于我们理解下面的内容。

HTTP 数据构成

使用 Netty 搭建 HTTP 服务器

由于这次搭建的是 Http 服务器,那说明我们可以通过浏览器作为客户端来进行访问服务端了,也就是我们不需要去写客户端代码

服务端

首先编写的是服务端 HttpFileServer.java

public class HttpFileServer {
    //项目访问上下文
    private static final String DEFAULT_URL = "/httpProject";   

    public void run(final int port, final String url) {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //http 解码
                            ch.pipeline().addLast("http-decoder", new HttpRequestDecoder());
                            //http 接收编码
                            ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(65536));
                            //http 编码工具类
                            ch.pipeline().addLast("http-encoder", new HttpResponseEncoder());
                            //chunked 操作
                            ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
                            //文件系统业务逻辑
                            ch.pipeline().addLast("fileServerHandler", new HttpFileServerHander(url));
                        }
                    });
            ChannelFuture f = serverBootstrap.bind("127.0.0.1", port).sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
    public static void main(String[] args) {
        new HttpFileServer().run(8080, DEFAULT_URL);
    }
}
复制代码

注意到这次的服务端代码在 ChannelInitializer
的初始化跟以往有点不同,这次上初始了多个 handler。下面我简单说下它们的用法。

类名 说明
HttpRequestDecoder 负责将 ByteBuf 解码成为 HttpRequest 和 HttpContent 内容
HttpObjectAggregator 负责将 Http 信息和内容封装成为单个 FullHttpRequest
HttpResponseEncoder 对服务端返回的内容进行编码
ChunkedWriteHandler 支持异步大数据量写入避免内存超出

然后我们开始写 HttpFileServerHander.java

public class HttpFileServerHander extends
        SimpleChannelInboundHandler<FullHttpRequest> {

    private String url;

    public HttpFileServerHander(String url) {
        this.url = url;
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
        //由于我们上面使用 netty 的解码器 FullHttpRequest 来封装信息
        if (!request.getDecoderResult().isSuccess()) {
            sendError(ctx, HttpResponseStatus.BAD_REQUEST);
            return;
        }
        //如果不是 get 方法则抛弃
        if (request.getMethod() != HttpMethod.GET) {
            sendError(ctx, HttpResponseStatus.BAD_REQUEST);
            return;
        }
        //获取访问的路径
        final String uri = request.getUri();
        //解码路径
        final String path = sanitizeUri(uri);
        //如果路径为空,说明错误请求
        if (path == null) {
            sendError(ctx, HttpResponseStatus.BAD_REQUEST);
            return;
        }
        //新建文件对象
        File file = new File(path);
        //如果不在,返回 404
        if (file.isHidden() || !file.exists()) {
            sendError(ctx, HttpResponseStatus.NOT_FOUND);
            return;
        }
        //如果是目录就循环目录内容返回
        if (file.isDirectory()) {
            if (uri.endsWith("/")) {
                sendListing(ctx, file);
            } else {
                sendRedirect(ctx, uri + '/');
            }
            return;
        }
        //如果是文件就
        if (!file.isFile()) {
            sendError(ctx, HttpResponseStatus.BAD_REQUEST);
            return;
        }
        //具备权限访问的文件
        RandomAccessFile randomAccessFile = null;
        try {
            randomAccessFile = new RandomAccessFile(file, "r");
        }catch (FileNotFoundException e) {
            sendError(ctx, HttpResponseStatus.BAD_REQUEST);
            return;
        }
        long fileLength = randomAccessFile.length();
        //新建一个 DefaultFullHttpResponse
        HttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
        //设置文件长度
        HttpHeaders.setContentLength(response, fileLength);
        setContentTypeHeader(response, file);
        if (HttpHeaders.isKeepAlive(request)) {
            response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
        }
        //ctx写入 response
        ctx.write(response);
        //设置写入文件的 listener
        ChannelFuture  sendFileFuture;
        sendFileFuture = ctx.write(new ChunkedFile(randomAccessFile, 0, fileLength, 8192), ctx.newProgressivePromise());
        //设置监听仅需的的 Listener
        sendFileFuture.addListener(new ChannelProgressiveFutureListener() {
            @Override
            public void operationProgressed(ChannelProgressiveFuture future, long progress, long total) throws Exception {
                if (total < 0) { // total unknown
                    System.err.println("Transfer progress: " + progress);
                } else {
                    System.err.println("Transfer progress: " + progress + " / " + total);
                }
            }

            @Override
            public void operationComplete(ChannelProgressiveFuture future) throws Exception {
                System.out.println("Transfer complete.");
            }
        });
        //最后输出空内容
        ChannelFuture lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
        if (HttpHeaders.isKeepAlive(request)) {
            lastContentFuture.addListener(ChannelFutureListener.CLOSE);
        }
    }

    private static final Pattern INSECURE_URI = Pattern.compile(".*[<>&/"].*");

    //解析 url
    private String sanitizeUri(String uri) {
        try {
            uri = URLDecoder.decode(uri, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            try {
                uri = URLDecoder.decode(uri, "ISO-8859-1");
            } catch (UnsupportedEncodingException e1) {
                throw new Error();
            }
        }
        if (!uri.startsWith(url)) {
            return null;
        }
        if (!uri.startsWith("/")) {
            return null;
        }
        uri = uri.replace('/', File.separatorChar);
        if (uri.contains(File.separator + '.')
                || uri.contains('.' + File.separator) || uri.startsWith(".")
                || uri.endsWith(".") || INSECURE_URI.matcher(uri).matches()) {
            return null;
        }
        return System.getProperty("user.dir") + File.separator + uri;
    }

    private static final Pattern ALLOWED_FILE_NAME = Pattern.compile("[A-Za-z0-9][-_A-Za-z0-9//.]*");
    //渲染画面
    private static void sendListing(ChannelHandlerContext ctx, File dir) {
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html; charset=UTF-8");
        StringBuilder buf = new StringBuilder();
        String dirPath = dir.getPath();
        buf.append("<!DOCTYPE html>/r/n");
        buf.append("<html><head><title>");
        buf.append(dirPath);
        buf.append(" 目录:");
        buf.append("</title></head><body>/r/n");
        buf.append("<h3>");
        buf.append(dirPath).append(" 目录:");
        buf.append("</h3>/r/n");
        buf.append("<ul>");
        buf.append("<li>链接:<a href=/"..//">..</a></li>/r/n");
        for (File f : dir.listFiles()) {
            if (f.isHidden() || !f.canRead()) {
                continue;
            }
            String name = f.getName();
            if (!ALLOWED_FILE_NAME.matcher(name).matches()) {
                continue;
            }
            buf.append("<li>链接:<a href=/"");
            buf.append(name);
            buf.append("/">");
            buf.append(name);
            buf.append("</a></li>/r/n");
        }
        buf.append("</ul></body></html>/r/n");
        ByteBuf buffer = Unpooled.copiedBuffer(buf, CharsetUtil.UTF_8);
        response.content().writeBytes(buffer);
        buffer.release();
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }
    
    //重定向
    private static void sendRedirect(ChannelHandlerContext ctx, String newUri) {
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_FOUND);
        response.headers().set(HttpHeaderNames.LOCATION, newUri);
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }
    
    //发送错误信息
    private static void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) {
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status,
                Unpooled.copiedBuffer("failures: " + status.toString() + "/r/n", CharsetUtil.UTF_8));

        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8");
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }
    
    //设置头部内容
    private static void setContentTypeHeader(HttpResponse response, File file) {
        MimetypesFileTypeMap mimeTypesMap = new MimetypesFileTypeMap();
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, mimeTypesMap.getContentType(file.getPath()));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        if (ctx.channel().isActive()) {
            sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR);
        }
    }
}
复制代码

客户端

客户端在这个例子中并不存在。因为我们电脑的浏览器就是一个一个客户端,它们底层也是通过 Socket
来与服务端进行交互的,原理都是一样的。所以我们只需要访问以下地址:

http://localhost:8080/httpProject

原文 

https://juejin.im/post/5f0309925188252e5f37c343

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 高性能 Netty 之结合 Http 协议应用

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址