基于netty构建http服务器-蒲公英云

基于netty构建http服务器

基于Netty构建Http服务的流程如下：

Client向Server发送http请求。
Server端对http请求进行解析。
Server端向Client发送http响应。
Client对http响应进行解析。

流程图如下：

在这里插入图片描述

服务器端实现

package com.morris.netty.protocol.http;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;
import static io.netty.handler.codec.http.HttpHeaders.Names.CONTENT_TYPE;
import static io.netty.handler.codec.http.HttpResponseStatus.OK;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
@Slf4j
public class Server { 
    private static final int port = 8899;
    public static void main(String[] args) throws Exception { 
        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 { 
                            ch.pipeline().addLast(new HttpRequestDecoder()); // 请求消息解码器
                            ch.pipeline().addLast(new HttpObjectAggregator(65536));// 目的是将多个消息转换为单一的request或者response对象
                            ch.pipeline().addLast(new HttpResponseEncoder());//响应编码器
                            ch.pipeline().addLast(new ChannelInboundHandlerAdapter() { 
                                @Override
                                public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 
                                    FullHttpRequest request = (FullHttpRequest) msg;
                                    log.info("method：{}", request.method().name());
                                    log.info("uri：{}", request.uri());
                                    log.info("content：{}", request.content().toString(CharsetUtil.UTF_8));
                                    FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, OK);
                                    response.headers().set(CONTENT_TYPE, "text/html; charset=UTF-8");
                                    ByteBuf buffer = Unpooled.copiedBuffer("<h3>hello world</h3>", CharsetUtil.UTF_8);
                                    response.content().writeBytes(buffer);
                                    buffer.release();
                                    request.release();
                                    ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
                                }
                            });// 业务逻辑
                        }
                    });
            ChannelFuture future = b.bind("127.0.0.1", port).sync();
            log.info("HTTP服务器启动，网址是 : " + "http://127.0.0.1:" + port);
            future.channel().closeFuture().sync();
        } finally { 
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

在浏览器输入http://127.0.0.1:8899就可以看到页面显示hello world。

客户端实现

package com.morris.netty.protocol.http;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Client { 
    public static void main(String[] args) throws InterruptedException { 
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try { 
            Bootstrap b = new Bootstrap();
            b.group(workerGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer() { 
                        @Override
                        protected void initChannel(Channel ch) throws Exception { 
                            ch.pipeline().addLast(new HttpResponseDecoder()); // 响应解码器
                            ch.pipeline().addLast(new HttpObjectAggregator(65536));
                            ch.pipeline().addLast(new HttpRequestEncoder()); // 请求编码器
                            ch.pipeline().addLast(new ChannelInboundHandlerAdapter() { 
                                @Override
                                public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 
                                    FullHttpResponse httpResponse = (FullHttpResponse)msg;
                                    log.info("status:{}", httpResponse.status());
                                    log.info("headers:{}", httpResponse.headers());
                                    log.info("body:{}", httpResponse.content().toString(CharsetUtil.UTF_8));
                                    httpResponse.release();
                                }
                                @Override
                                public void channelActive(ChannelHandlerContext ctx) throws Exception { 
                                    DefaultFullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/");
                                    // 构建http请求
                                    request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
                                    request.headers().set(HttpHeaderNames.CONTENT_LENGTH, request.content().readableBytes());
                                    // 发送http请求
                                    ctx.writeAndFlush(request);
                                }
                            });
                        }
                    });
            // 启动 server.
            ChannelFuture f = b.connect("127.0.0.1", 8899).sync();
            // 等待socket关闭
            f.channel().closeFuture().sync();
        } finally { 
            workerGroup.shutdownGracefully();
        }
    }
}