【Netty】五、Netty实现Http服务器

小咪咪 2023-10-09 15:03 11阅读 0赞

#### Netty实现http服务器 ####

*  一、Netty实现hhttp服务器
 *  代码演示
 *   *  HttpServer
     *  HttpServerHandler
     *  HttpServerInitializer （http请求解码和编码）

## 一、Netty实现hhttp服务器 ##

Netty除了支持 TCP 协议以外，内部还支持多种协议，比如telnet、UDP、http、http2、websocket等；  
要支持这些协议，主要就是支持这些协议的报文解析，能把这些协议的报文进行编码和解码，就可以了；  
比如http协议的报文格式是这样的：  
![在这里插入图片描述][777c96742a294a59aebe9ba6201b7458.png]  
![在这里插入图片描述][3b256a4ed42540bcae19c85b3857588e.png]  
那么netty内部已经支持这种http报文格式的解析，所以我们能使用netty开发http服务器；

Netty支持websocket  
我们知道Netty除了支持 TCP 协议以外，内部还支持多种协议，比如telnet、UDP、http、http2、websocket等；  
要支持这些协议，主要就是支持这些协议的报文解析，能把这些协议的报文进行编码和解码，就可以了；  
比如websocket协议的报文格式是这样的：

Netty内置了对websocket协议的编码和解码，从而可以使用netty开发基于websocket连接的应用；

## 代码演示 ##

### HttpServer ###

import com.mytest.http.handler.HttpServerInitializer;
    import io.netty.bootstrap.ServerBootstrap;
    import io.netty.channel.Channel;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.nio.NioServerSocketChannel;
    
    public final class HttpServer {
        
    
        static final int PORT = Integer.parseInt(System.getProperty("port", "8080"));
    
        public static void main(String[] args) throws Exception {
        
            // Configure the server.
            EventLoopGroup bossGroup = new NioEventLoopGroup(1);
            EventLoopGroup workerGroup = new NioEventLoopGroup();
            try {
        
                ServerBootstrap b = new ServerBootstrap();
                b.group(bossGroup, workerGroup)
                 .channel(NioServerSocketChannel.class)
                 //.handler(new LoggingHandler(LogLevel.INFO))
                 .childHandler(HttpServerInitializer.INSTANCE);
    
                Channel ch = b.bind(PORT).sync().channel();
                System.err.println("请在浏览器打开 http://127.0.0.1:" + PORT + '/');
                ch.closeFuture().sync();
            } finally {
        
                bossGroup.shutdownGracefully();
                workerGroup.shutdownGracefully();
            }
        }
    }

### HttpServerHandler ###

import io.netty.channel.*;
    import io.netty.handler.codec.http.*;
    
    @ChannelHandler.Sharable
    public class HttpServerHandler extends SimpleChannelInboundHandler<HttpObject> {
        
    
        public static final HttpServerHandler INSTANCE = new HttpServerHandler();
    
        private static final byte[] CONTENT = {
         'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd' };
    
        @Override
        public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        
            System.out.println("channelRegistered......");
        }
    
        @Override
        public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        
            System.out.println("channelUnregistered......");
        }
    
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
        
            System.out.println("channelActive......");
        }
    
        @Override
        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        
            System.out.println("channelInactive......");
        }
    
        @Override
        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        
            System.out.println("userEventTriggered......");
        }
    
        @Override
        public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
        
            System.out.println("channelWritabilityChanged......");
        }
    
        @Override
        protected void ensureNotSharable() {
        
            System.out.println("ensureNotSharable......");
        }
    
        @Override
        public boolean isSharable() {
        
            System.out.println("isSharable......");
            return super.isSharable();
        }
    
        @Override
        public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        
            System.out.println("handlerAdded......");
        }
    
        @Override
        public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        
            System.out.println("handlerRemoved......");
        }
    
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
        
    
            //给浏览器响应
            DefaultFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
            response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html;charset=utf-8");
    
            //要响应的内容
            String src = "<!DOCTYPE html>\n" +
                    "<html lang=\"en\">\n" +
                    "<head>\n" +
                    "    <meta charset=\"UTF-8\">\n" +
                    "    <title>Hello Netty.</title>\n" +
                    "</head>\n" +
                    "<body>\n" +
                    "Hello Netty.\n" +
                    "</body>\n" +
                    "</html>";
            response.content().writeBytes(src.getBytes("UTF-8"));
    
            ChannelFuture f = ctx.writeAndFlush(response);
            f.addListener(ChannelFutureListener.CLOSE);
        }
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) {
        
            System.out.println("channelReadComplete......");
            ctx.flush();
        }

### HttpServerInitializer （http请求解码和编码） ###

http请求解码和编码

import io.netty.channel.ChannelHandler;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelPipeline;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.handler.codec.http.HttpServerCodec;
    
    @ChannelHandler.Sharable
    public class HttpServerInitializer extends ChannelInitializer<SocketChannel> {
        
    
        public static final HttpServerInitializer INSTANCE = new HttpServerInitializer();
    
        @Override
        public void initChannel(SocketChannel ch) {
        
            ChannelPipeline pipeline = ch.pipeline();
            //对http请求的编码和解码
            pipeline.addLast(new HttpServerCodec());
    
            //支持http请求的编码
            //pipeline.addLast(new HttpResponseEncoder());
            //支持http请求的解码
            //pipeline.addLast(new HttpRequestDecoder());
    
            pipeline.addLast(HttpServerHandler.INSTANCE);
        }
    }

[777c96742a294a59aebe9ba6201b7458.png]: https://img-blog.csdnimg.cn/777c96742a294a59aebe9ba6201b7458.png
[3b256a4ed42540bcae19c85b3857588e.png]: https://img-blog.csdnimg.cn/3b256a4ed42540bcae19c85b3857588e.png