Netty搭建http server

最新推荐文章于 2024-03-07 12:53:49 发布
最新推荐文章于 2024-03-07 12:53:49 发布
阅读量2.5k 收藏 4
点赞数 1
分类专栏： NIO & Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26222859/article/details/80900125
版权

概述

  • HttpRequestDecoder 即把 ByteBuf 解码到 HttpRequest 和 HttpContent。
  • HttpResponseEncoder 即把 HttpResponse 或 HttpContent 编码到 ByteBuf。
  • HttpServerCodec 即 HttpRequestDecoder 和 HttpResponseEncoder 的结合。

本文想要回答的问题是：

在netty搭建http server时

  1. HttpRequest和HttpContent是如何透传给用户自定义的ChannelInBoundHandler
  2. ByteBuf是怎么解析成HttpRequest和多个HttpContent（最后一个为LastHttpContent）

例子 


public class HttpServer {

    public static void main(String[] args) throws InterruptedException {
        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
                        public void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast(new HttpServerCodec());
//pipeline.addLast(new HttpServerCodec());相当于
//pipeline.addLast(new HttpReuqestDecoder());
//pipeline.addLast(new HttpResponseEncoder());
                            pipeline.addLast(new HttpServerHandler());
                        }
                    });
            ChannelFuture f = b.bind(8080).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

HttpServerHandler类

class HttpServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws UnsupportedEncodingException {

        if (msg instanceof HttpRequest) {

            // 请求，解码器将请求转换成HttpRequest对象
            HttpRequest request = (HttpRequest) msg;
            
            // 获取请求参数
            QueryStringDecoder queryStringDecoder = new QueryStringDecoder(request.uri());
            String name = "netty";
            if(queryStringDecoder.parameters().get("name") != null) {
                    name = queryStringDecoder.parameters().get("name").get(0);
            }

            // 响应HTML
            String responseHtml = "<html><body>Hello, " + name + "</body></html>";
            byte[] responseBytes = responseHtml.getBytes("UTF-8");
            int contentLength = responseBytes.length;

            // 构造FullHttpResponse对象，FullHttpResponse包含message body
            FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, Unpooled.wrappedBuffer(responseBytes));
            response.headers().set("Content-Type", "text/html; charset=utf-8");
            response.headers().set("Content-Length", Integer.toString(contentLength));

            ctx.writeAndFlush(response);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

原始的ByteBuf解析

io.netty.handler.codec.ByteToMessageDecoder#channelRead

 @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof ByteBuf) {
            CodecOutputList out = CodecOutputList.newInstance();
            try {
                ByteBuf data = (ByteBuf) msg;
                first = cumulation == null;
                if (first) {
                    cumulation = data;
                } else {
                    cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
                }
                callDecode(ctx, cumulation, out);
            } catch (DecoderException e) {
                throw e;
            } catch (Exception e) {
                throw new DecoderException(e);
            } finally {
                if (cumulation != null && !cumulation.isReadable()) {
                    numReads = 0;
                    cumulation.release();
                    cumulation = null;
                } else if (++ numReads >= discardAfterReads) {
                    // We did enough reads already try to discard some bytes so we not risk to see a OOME.
                    // See https://github.com/netty/netty/issues/4275
                    numReads = 0;
                    discardSomeReadBytes();
                }

                int size = out.size();
                decodeWasNull = !out.insertSinceRecycled();
                fireChannelRead(ctx, out, size);
                out.recycle();
            }
        } else {
            ctx.fireChannelRead(msg);
        }
    }

解析

    protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
        try {
//此处通过while循环将ByteBuf分成多次解析
//才有了后面的解析成一个HttpRequest和多个HttpContent
            while (in.isReadable()) {
                int outSize = out.size();

                if (outSize > 0) {
                    fireChannelRead(ctx, out, outSize);
                    out.clear();

                    // Check if this handler was removed before continuing with decoding.
                    // If it was removed, it is not safe to continue to operate on the buffer.
                    //
                    // See:
                    // - https://github.com/netty/netty/issues/4635
                    if (ctx.isRemoved()) {
                        break;
                    }
                    outSize = 0;
                }

                int oldInputLength = in.readableBytes();
                decodeRemovalReentryProtection(ctx, in, out);

                // Check if this handler was removed before continuing the loop.
                // If it was removed, it is not safe to continue to operate on the buffer.
                //
                // See https://github.com/netty/netty/issues/1664
                if (ctx.isRemoved()) {
                    break;
                }

                if (outSize == out.size()) {
                    if (oldInputLength == in.readableBytes()) {
                        break;
                    } else {
                        continue;
                    }
                }

                if (oldInputLength == in.readableBytes()) {
                    throw new DecoderException(
                            StringUtil.simpleClassName(getClass()) +
                                    ".decode() did not read anything but decoded a message.");
                }

                if (isSingleDecode()) {
                    break;
                }
            }
        } catch (DecoderException e) {
            throw e;
        } catch (Exception cause) {
            throw new DecoderException(cause);
        }
    }

解析

    final void decodeRemovalReentryProtection(ChannelHandlerContext ctx, ByteBuf in, List<Object> out)
            throws Exception {
        decodeState = STATE_CALLING_CHILD_DECODE;
        try {
            decode(ctx, in, out);
        } finally {
            boolean removePending = decodeState == STATE_HANDLER_REMOVED_PENDING;
            decodeState = STATE_INIT;
            if (removePending) {
                handlerRemoved(ctx);
            }
        }
    }

io.netty.handler.codec.http.HttpObjectDecoder#decode

将ByteBuf解析成HttpRequest和HttpContent

  protected void decode(ChannelHandlerContext ctx, ByteBuf buffer, List<Object> out) throws Exception {
        if (this.resetRequested) {
            this.resetNow();
        }

        int toRead;
        int toRead;
        AppendableCharSequence line;
        switch(this.currentState) {
        case SKIP_CONTROL_CHARS:
            if (!skipControlCharacters(buffer)) {
                return;
            }

            this.currentState = HttpObjectDecoder.State.READ_INITIAL;
        case READ_INITIAL:
            try {
//解析http的initialLine
//initialLine example:GET /favicon.ico HTTP/1.1\r\n
                line = this.lineParser.parse(buffer);
                if (line == null) {
                    return;
                }
//example: ["GET", "/favicon.ico", "/favicon.ico"]
                String[] initialLine = splitInitialLine(line);
                if (initialLine.length < 3) {
                    this.currentState = HttpObjectDecoder.State.SKIP_CONTROL_CHARS;
                    return;
                }
//createMessage是抽象方法，此处用了模板方法模式，整体流程由父类实现，细节由子类实现
//如果由子类HttpRequestDecoder实现，则创建的是DefaultHttpRequest
//后面这个HttpRequest才可以透传给用户自定义的ChannelInboundHandler
                this.message = this.createMessage(initialLine);
                this.currentState = HttpObjectDecoder.State.READ_HEADER;
            } catch (Exception var9) {
                out.add(this.invalidMessage(buffer, var9));
                return;
            }
        case READ_HEADER:
            try {
//此处解析http的头部参数
                HttpObjectDecoder.State nextState = this.readHeaders(buffer);
                if (nextState == null) {
                    return;
                }

                this.currentState = nextState;
                switch(nextState) {
                case SKIP_CONTROL_CHARS:
                    out.add(this.message);
                    out.add(LastHttpContent.EMPTY_LAST_CONTENT);
                    this.resetNow();
                    return;
                case READ_CHUNK_SIZE:
                    if (!this.chunkedSupported) {
                        throw new IllegalArgumentException("Chunked messages not supported");
                    }

                    out.add(this.message);
                    return;
                default:
                    long contentLength = this.contentLength();
                    if (contentLength != 0L && (contentLength != -1L || !this.isDecodingRequest())) {
                        assert nextState == HttpObjectDecoder.State.READ_FIXED_LENGTH_CONTENT || nextState == HttpObjectDecoder.State.READ_VARIABLE_LENGTH_CONTENT;

                        out.add(this.message);
                        if (nextState == HttpObjectDecoder.State.READ_FIXED_LENGTH_CONTENT) {
                            this.chunkSize = contentLength;
                        }

                        return;
                    }

                    out.add(this.message);
                    out.add(LastHttpContent.EMPTY_LAST_CONTENT);
                    this.resetNow();
                    return;
                }
            } catch (Exception var10) {
                out.add(this.invalidMessage(buffer, var10));
                return;
            }
        case READ_CHUNK_SIZE:
            try {
                line = this.lineParser.parse(buffer);
                if (line == null) {
                    return;
                }

                toRead = getChunkSize(line.toString());
                this.chunkSize = (long)toRead;
                if (toRead == 0) {
                    this.currentState = HttpObjectDecoder.State.READ_CHUNK_FOOTER;
                    return;
                }

                this.currentState = HttpObjectDecoder.State.READ_CHUNKED_CONTENT;
            } catch (Exception var8) {
                out.add(this.invalidChunk(buffer, var8));
                return;
            }
        case READ_CHUNKED_CONTENT:
            assert this.chunkSize <= 2147483647L;

            toRead = Math.min((int)this.chunkSize, this.maxChunkSize);
            toRead = Math.min(toRead, buffer.readableBytes());
            if (toRead == 0) {
                return;
            }

            HttpContent chunk = new DefaultHttpContent(buffer.readRetainedSlice(toRead));
            this.chunkSize -= (long)toRead;
            out.add(chunk);
            if (this.chunkSize != 0L) {
                return;
            }

            this.currentState = HttpObjectDecoder.State.READ_CHUNK_DELIMITER;
        case READ_CHUNK_DELIMITER:
            toRead = buffer.writerIndex();
            toRead = buffer.readerIndex();

            while(toRead > toRead) {
                byte next = buffer.getByte(toRead++);
                if (next == 10) {
                    this.currentState = HttpObjectDecoder.State.READ_CHUNK_SIZE;
                    break;
                }
            }

            buffer.readerIndex(toRead);
            return;
        case READ_VARIABLE_LENGTH_CONTENT:
            toRead = Math.min(buffer.readableBytes(), this.maxChunkSize);
            if (toRead > 0) {
                ByteBuf content = buffer.readRetainedSlice(toRead);
                out.add(new DefaultHttpContent(content));
            }

            return;
        case READ_FIXED_LENGTH_CONTENT:
//此处解析http的body
            toRead = buffer.readableBytes();
            if (toRead == 0) {
                return;
            }

            toRead = Math.min(toRead, this.maxChunkSize);
            if ((long)toRead > this.chunkSize) {
                toRead = (int)this.chunkSize;
            }

            ByteBuf content = buffer.readRetainedSlice(toRead);
            this.chunkSize -= (long)toRead;
            if (this.chunkSize == 0L) {
//创建HttpContent
                out.add(new DefaultLastHttpContent(content, this.validateHeaders));
                this.resetNow();
            } else {
                out.add(new DefaultHttpContent(content));
            }

            return;
        case READ_CHUNK_FOOTER:
            try {
                LastHttpContent trailer = this.readTrailingHeaders(buffer);
                if (trailer == null) {
                    return;
                }

                out.add(trailer);
                this.resetNow();
                return;
            } catch (Exception var7) {
                out.add(this.invalidChunk(buffer, var7));
                return;
            }
        case BAD_MESSAGE:
            buffer.skipBytes(buffer.readableBytes());
            break;
        case UPGRADED:
            toRead = buffer.readableBytes();
            if (toRead > 0) {
                out.add(buffer.readBytes(toRead));
            }
        }

    }

 

zhifeng687
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【使用Netty实现Http服务器一】
ThinkLess404的专栏
06-03 1043
这里MyHttpServerHandler 继承类时传入的泛型是FullHttpRequest，这里的类型与你上一个处理的handler有关，我们示例中上一个handler是HttpObjectAggregator，聚合后的数据我们读取就是FullHttpRequest类型了。到这里我们已经完成了一个简单的HTTP服务，如果我们要实现一个静态的web服务器，指定一个路径为基地址，通过path访问路径下的html，要如何做呢。实现在运行目录的app目录下作为网站基地址，实现静态网页的访问。
java netty服务器搭建_用Netty搭建一个简单的Http服务器
weixin_33344147的博客
02-16 536
用Netty搭建一个简单的Http服务器，实现客户端发起http请求时，服务端作出响应返回一串数据。准备工作搭建maven项目，引入netty的依赖。我这里用的是4.0.20版本。io.nettynetty-all4.0.20.Final代码编写1、启动服务端public class HttpServer {public static void main(String[] args) {Even...
【Netty系列】使用Netty搭建HttpServer
秋装什么的博客
12-17 237
【Netty系列】使用Netty搭建HttpServer
HTTP2: netty http2 server demo
Mr_rain的专栏
02-07 968
与netty 的http1.1类似，http2也需要相应的编解码器，另外还需要一个处理http2连接通道复用的Handler。在构建Http2FrameCodec时，可以通过Http2Settings类对流和数据帧进行设置，覆盖默认其默认值。运行上面的代码，8080端口将支持http2协议。运行下面的curl脚本，即可访问。
【Netty系列】使用Netty搭建TcpServer
秋装什么的博客
12-17 1240
【Netty系列】使用Netty搭建TcpServer
几十行代码基于Netty搭建一个 HTTP Server
这个博客没用了
10-08 1097
目前正在写的一个叫做 jsoncat 的轻量级 HTTP 框架内置的 HTTP 服务器是我自己基于 Netty 写的，所有的核心代码加起来不过就几十行。这得益于 Netty 提供的各种开箱即用的组件，为我们节省了太多事情。 这篇文章我会手把手带着小伙伴们实现一个简易的 HTTP Server。 如果文章有任何需要改善和完善的地方，欢迎在评论区指出，共同进步！ 开始之前为了避免有小伙伴不了解 Netty ，还是先来简单介绍它！ 什么是 Netty？ 简单用 3 点来概括一下 Netty 吧！ Netty 是一
Netty之——搭建HttpServer
fulong0406的博客
06-14 712
认识Http请求 在动手写Netty框架之前，我们先要了解http请求的组成，如下图：
【二】基于Netty搭建简单的http服务
echohuangshihuxue的博客
01-03 743
netty 的性能比较高，我们从简单的例子，实现简单的http服务。从中慢慢学习netty
Netty 搭建Http服务端
robinson_911的专栏
04-13 262
1. 通过浏览器请求接口，http://localhost:8000/ Netty的Http服务器返回 Netty Http Server 2. 服务端打印的日志 Netty的Http服务器源码如下： package server; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapt
Netty搭建WebSocket服务器
最新发布
qq_40107343的博客
03-07 601
【代码】Netty搭建WebSocket服务器。
netty搭建TCP、UDP服务
09-23
例如，你可以使用Netty搭建一个物联网设备管理平台，接收设备上报的数据，同时向设备发送控制指令。 在具体实现过程中，首先需要定义ChannelInitializer，它会在新建立的Channel中添加所需的ChannelHandler。然后，...
mqttserver:基于netty实现mqtt协议 服务器端开发
05-19
mqttserver，基于netty 4.1.1，可解码http、mqtt协议请求。 项目包括： 1.基于netty绑定端口监听，对于mqtt消息和http请求消息分别绑定不同的监听端口； 2.在MQTTServerInitializer中，分别添加mqtt编码解码器和http...
使用netty使用http协议开发文件服务器
10-06
在`HttpFileServer`的`main`函数中，我们会设置Netty的服务器端配置，包括绑定监听的端口、创建EventLoopGroup（线程组）以及定义服务器的ChannelInitializer。EventLoopGroup是Netty用来管理线程的组件，它负责调度...
netty_server
02-15
总的来说，Netty_Server是一个使用Java的Netty框架搭建的服务器，具备与MySQL数据库的高效连接管理，邮件功能且支持JSON和AES加密的数据安全传输，客户端使用Unity进行交互。这样的服务器可以用于实现各种网络服务，...
server-ssm:一个ssm的服务器框架，并使用Netty搭建TCP服务
04-30
main fuction集成 Spring + SpringMvc + Mybatis 服务器框架使用 Netty 搭建 TCP 服务器使用 Protobuf 进行数据交互使用 Mybatis 自动生成插件Othermaven mirror 设置<mirror> <id>alimaven</id> <name>aliyun maven...
java NIO实现(二) ——  EPollArrayWrapper源码分析
lzf的博客
03-30 1884
EPollArrayWrapper有几个native方法 1、poll方法： 调用了epollWait()方法，返回ready desccriptor的数量。将c++层的struct epoll_event events数组的指针地址，转为私有成员变量pollArrayAddress。 2、updateRegistrations方法： 调用epollCtl方法， 3、remove(int fd)方法： 调用epollCtl方法，从epfd指向的epoll实例删除注册其中的fd。 4、EpollA
java NIO实现(一) ——ServerSocketChannel和Selector源码分析
lzf的博客
01-01 1155
概述 java NIO属于epoll水平触发 Selector.open()在linux内核调用epoll_create; ServerSocketChannel#register()在linux内核调用epoll_ctl ,并设置为水平触发; Selector#select()在linux内核调用epoll_wait
Netty模型架构和思维导图
lzf的博客
04-01 866
Reactor多线程模型--连接与I/O操作分离 若请求连接的并发量是数以百万计的，且 IO 操作还比较耗时，此时的 Server 即使采用的是 Reactor 线程池模型，系统性能也会急剧下降。此时，可以将连接操作与 IO 操作分开处理，形成 Reactor 的多线程模型。 当客户端通过处理连接请求的 Channel 连接上 Server 后，系统会为该客户端再生成一个子 Channel 专门用于处理该客户端的 IO 请求。这两类不同的 Channel 连接着两类不同的线程池。而线程池中的线程..
netty httpserver
01-27
System.out.println("Netty HTTP Server started on port 8080."); // 等待服务器关闭 future.channel().closeFuture().sync(); } finally { // 关闭EventLoopGroup bossGroup.shutdownGracefully(); ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值