Netty(四)——HTTP服务端之例

不念不忘少年蓝@ 2022-05-14 17:04 305阅读 0赞

HTTP（HyperText Transfer Protocol，超文本传输协议）是因特网上应用最为广泛的一种网络传输协议，所有的WWW文件都必须遵守这个标准。我们用的tomcat、jetty、jobss等各种服务器，其实就是一个服务端容器，方便我们直接部署我们应用，让用户通过使用客户端（WEB浏览器、手机H5、app等）借住HTTP协议，来完成信息的提交和获取。这篇文章简单总结一下HTTP协议，然后用Netty来实现一个HTTP服务端实例。

一，HTTP协议，是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统，是基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果等）。下边我们分几个方面来看下。

1，网络层次模型：HTTP协议是在网络层次模型中的应用层，这里来看下[OSI七层模型详解][OSI]（[https://blog.csdn.net/yaopeng\_2005/article/details/7064869][OSI] ），[TCP、IP详解学习笔记][TCP_IP]（[https://www.cnblogs.com/fengzanfeng/articles/1339347.html][TCP_IP] ）通过这两篇文章来了解一下各层协议。

2，HTTP协议的主要特点：a，支持Client/Server模式；b，简单，客户端向服务器请求服务时，只需指定服务URL，携带必要的请求参数或者消息体；c，灵活，HTTP允许传输任意类型的数据对象，传输内容类型有HTTP消息头中的Content-Type加以标识；d，无状态，表示HTTP协议对于事物处理没有记忆能力。

3，HTTP协议的URL格式：http://host\[":"port\]\[abs\_path\]。

4，HTTP请求消息（HttpRequest）组成：a，HTTP请求行，格式为Method（请求方法）  Request-URL（统一资源标识符）  HTTP-Version（协议版本）  CRLF（回车和换行）。其中Method请求方法有：GET、POST、HEAD、PUT、DELETE、TRACE、CONNECT、OPTIONS等；   b，HTTP消息头 ；    c，HTTP请求正文。我们看下这个格式图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWppYWhhbjYyOTYyOQ_size_27_color_FFFFFF_t_70][]

5，HTTP响应消息（HttpResponse）:也是又三个部分组成：状态行、消息报头、响应正文。其中状态行格式为：HTTP-Version Status-Code Reason-Phrase CRLF。这里说下状态码：其中1\*\*：指示信息，表示请求已接受，继续处理；2\*\*：成功，表示请求已被成功接收、理解、处理；3\*\*：重定向，要完成请求必须进行更进一步的操作；4\*\*：客户端错误，请求有语法错误或者无法实现；5\*\*：服务端错误，服务器在处理请求过程中发生了错误。

好，这里再推荐两篇文章，写的比较详细，看参考一起学习：[简单教程][Link 1]（[http://www.runoob.com/http/http-tutorial.html）][http_www.runoob.com_http_http-tutorial.html] 、[图解传说中的HTTP协议][HTTP]（[https://blog.csdn.net/agzhchren/article/details/79173491）][https_blog.csdn.net_agzhchren_article_details_79173491]

二，简单小结了Http协议后，我们来看下如何通过Netty来实现HTTP服务端的开发，这样我们就可以直接通过WEB浏览器或其它客户端，直接调用我们的程序了。由于Netty天生是异步事件驱动的架构，因此基于NIO TCP协议栈开发的HTTP协议栈也是异步非阻塞的。下边来看个读取服务器用户目录下的清单的例子。里边写了相关注释：

/**
     * @author liujiahan
     * @Title: HttpFileServer
     * @Copyright: Copyright (c) 2018
     * @Description: 基于Netty开发的HTTP Server端
     * @Created on 2018/10/27
     * @ModifiedBy:
     */
    public class HttpFileServer {
    
    
        private static final String DEFAULT_URL = "/src/main/java/com/ljh/netty/";
    
        /**
         * 入口方法，Netty编写服务端的基本流程
         * @param port 端口号
         * @param url 访问地址
         */
        public void run(final int port, final String url) {
            EventLoopGroup bossGroup = new NioEventLoopGroup();
            EventLoopGroup workerGroup = new NioEventLoopGroup();
    
            try {
                ServerBootstrap b = new ServerBootstrap();
                b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        //1,http请求消息解码器
                        ch.pipeline().addLast("http-decoder", new HttpRequestDecoder());
                        //2，HttpObjectAggregator将多个消息转换为单一的FullHttpRequest或者FullHttpResponse
                        ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(65536));
                        //3,http响应编码器
                        ch.pipeline().addLast("http-encoder", new HttpResponseEncoder());
                        //4,ChunkedWriteHandler 支持异步发送大的码流
                        ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
                        //5,业务处理
                        ch.pipeline().addLast("fileServerHandler", new HttpFileServerHandler(url));
                    }
                });
                ChannelFuture future = b.bind("localhost", port).sync();
                System.out.println("http文件目录服务器启动，网址是：" + "http://localhost:" + port + url);
                future.channel().closeFuture().sync();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                bossGroup.shutdownGracefully();
                workerGroup.shutdownGracefully();
            }
        }
    
    
        public static void main(String[] args) {
            int port = 8091;
            if (args != null && args.length > 0) {
                try {
                    port = Integer.valueOf(args[0]);
                } catch (NumberFormatException e) {
    
                }
            }
    
            String url = DEFAULT_URL;
            if (args.length > 1) {
                url = args[1];
            }
            new HttpFileServer().run(port, url);
    
        }
    
    }
    
    
    
    
    /**
     * @author liujiahan
     * @Title: HttpFileServerHandler
     * @Copyright: Copyright (c) 2018
     * @Description: 具体的业务处理流程
     * @Created on 2018/10/27
     * @ModifiedBy:
     */
    public class HttpFileServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
    
        private String url;
    
        public HttpFileServerHandler(String url) {
            this.url = url;
        }
    
        /**
         * 1，接受到消息后的处理过程
         * @param ctx
         * @param request
         * @throws Exception
         */
        @Override
        protected void messageReceived(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
            //验证解码
            if (!request.decoderResult().isSuccess()) {
                sendError(ctx, HttpResponseStatus.BAD_REQUEST);
                return;
            }
            //验证请求方法
            if (request.method() != HttpMethod.GET) {
                sendError(ctx, HttpResponseStatus.METHOD_NOT_ALLOWED);
                return;
            }
            //uri地址合法的验证
            final String uri = request.uri();
            final String path = sanitizeUri(uri);
            if (path == null) {
                sendError(ctx, HttpResponseStatus.FORBIDDEN);
                return;
            }
    
            //file地址的验证
            File file = new File(path);
            if (file.isHidden() || !file.exists()) {
                sendError(ctx, HttpResponseStatus.NOT_FOUND);
                return;
            }
            //如果是个文件夹的处理内容，sendlist下文件夹下的内容
            if (file.isDirectory()) {
                if (uri.endsWith("/")) {
                    sendListing(ctx, file);
                } else {
                    sendRedirect(ctx, uri + "/");
                }
                return;
            }
    
            //如果不是文件类型请求，返回错误
            if (!file.isFile()) {
                sendError(ctx, HttpResponseStatus.FORBIDDEN);
                return;
            }
    
            //使用欧冠随机文件读写类以只读的方式打开文件
            RandomAccessFile randomAccessFile = null;
            try {
                randomAccessFile = new RandomAccessFile(file, "r");
            } catch (FileNotFoundException fnfd) {
                sendError(ctx, HttpResponseStatus.NOT_FOUND);
                return;
            }
            //如果直接打开或者下载文件，获取文件的长度，构造HTTP消息
            long fileLength = randomAccessFile.length();
            HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
            HttpHeaderUtil.setContentLength(response, fileLength);
            setContentTypeHeader(response, file);
            //将应答header设置为keep-alive
            if (HttpHeaderUtil.isKeepAlive(request)) {
                response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
            }
    
            ctx.write(response);
            ChannelFuture sendFileFuture = null;
            //将文件写到发送缓存区
            sendFileFuture = ctx.write(new ChunkedFile(randomAccessFile, 0, fileLength, 8192), ctx.newProgressivePromise());
            //添加ChannelProgressiveFutureListener 监听，operationProgressed、operationComplete两个方法
            sendFileFuture.addListener(new ChannelProgressiveFutureListener() {
                @Override
                public void operationProgressed(ChannelProgressiveFuture future, long progress, long total) throws Exception {
                    if (total < 0) {
                        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");
                }
            });
    
            //如果使用chunked编码，最后需要发送一个编码结束的空消息体，表示结束
            ChannelFuture lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
            if (!HttpHeaderUtil.isKeepAlive(request)) {
                lastContentFuture.addListener(ChannelFutureListener.CLOSE);
            }
    
        }
    
    
        /**
         * 2，异常处理
         * @param ctx
         * @param cause
         * @throws Exception
         */
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            cause.printStackTrace();
            if (ctx.channel().isActive()) {
                sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR);
            }
        }
    
        /*************************************下边为封装的工具方法**************************************/
    
    
        /**
         * 不安全URI的正则限制
         */
        private static final Pattern INSECURE_URI = Pattern.compile(".*[<>&\"].*");
    
        /**
         * 审核Uri
         *
         * @param uri
         * @return
         */
        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\\.]*");
    
        /**
         * 发送相应的信息
         *
         * @param ctx
         * @param dir
         */
        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");
    
            String dirPath = dir.getPath();
            //拼装响应体的信息
            StringBuilder builder = new StringBuilder();
    
            builder.append("<!DOCTYPE html>\r\n");
            builder.append("<html><head><title>");
            builder.append(dirPath);
            builder.append("目录:");
            builder.append("</title></head><body>\r\n");
    
            builder.append("<h3>");
            builder.append(dirPath).append(" 目录：");
            builder.append("</h3>\r\n");
            builder.append("<ul>");
            builder.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;
                }
    
                builder.append("<li>链接：<a href=\"");
                builder.append(name);
                builder.append("\">");
                builder.append(name);
                builder.append("</a></li>\r\n");
            }
            builder.append("</ul></body></html>\r\n");
    
            ByteBuf buffer = Unpooled.copiedBuffer(builder, CharsetUtil.UTF_8);
            response.content().writeBytes(buffer);
            buffer.release();
            ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    
        }
    
        /**
         * 重定向
         *
         * @param ctx
         * @param newUri
         */
        private static void sendRedirect(ChannelHandlerContext ctx, String newUri) {
            FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.FOUND);
            response.headers().set(HttpHeaderNames.LOCATION, newUri);
            ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
        }
    
        /**
         * 返回错误信息
         * @param ctx
         * @param status
         */
        private static void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) {
            FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, Unpooled.copiedBuffer("Failure:" + status.toString() + "\r\n", CharsetUtil.UTF_8));
            response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html;charset=UTF-8");
            ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    
        }
    
        /**
         * 设置ContentType
         * @param response
         * @param file
         */
        private static void setContentTypeHeader(HttpResponse response, File file) {
            MimetypesFileTypeMap mimetypesFileTypeMap = new MimetypesFileTypeMap();
            response.headers().set(HttpHeaderNames.CONTENT_TYPE, mimetypesFileTypeMap.getContentType(file.getPath()));
        }
    
    }

好，一个简单的Netty开发的HTTP协议的服务端就这样了。只有不断的使用的，不断的学习，不断的理解，不断的反复，很多东西才会有恍然大悟的感觉，继续学习。。。

[OSI]: https://blog.csdn.net/yaopeng_2005/article/details/7064869
[TCP_IP]: https://www.cnblogs.com/fengzanfeng/articles/1339347.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWppYWhhbjYyOTYyOQ_size_27_color_FFFFFF_t_70]: /images/20220503/c32a770787084706823e22a5d9d219d3.png
[Link 1]: http://www.runoob.com/http/http-tutorial.html
[http_www.runoob.com_http_http-tutorial.html]: http://www.runoob.com/http/http-tutorial.html%EF%BC%89
[HTTP]: https://blog.csdn.net/agzhchren/article/details/79173491
[https_blog.csdn.net_agzhchren_article_details_79173491]: https://blog.csdn.net/agzhchren/article/details/79173491%EF%BC%89