【Tomcat】第九篇：使用 Netty 重构之前手写的 Tomcat

在上一篇【Tomcat】第八篇：150代码手写Tomcat（基于BIO，超详细注释） 我们一步一步的分析了自己手写一个 Tomcat 的思路，Tomcat 是一个 web 容器，但说到底它底层就是做的网络 IO 的工作：

• MYRequest：读取 web 端发来的请求
• MYTomcat：调用 Servlet 对象中的方法去处理请求
• MYResponse：对处理结果编码编码并写回给 web 端

PS：Servlet 可以理解成一种规范，它定义了我们如何写处理请求的方法，然后 Tomcat 在初始化时会实例化 Servlet 对象（单例）。

在上一篇底层 IO 我们采用的 BIO，它一次只能处理一个请求，不能支持并发，所以我们这篇就来对 Tomcat 进行升级 --使用 Netty 重构！

PS：本篇只贴出跟 IO 相关的 MYRequest、MYResponse、MYTomcat，具体思路请参考上一篇，完整代码在我的 GitHub 上，点击这里跳转…

MYRequest

public class MYRequest {

    private ChannelHandlerContext ctx;

    private HttpRequest req;

    public MYRequest(ChannelHandlerContext ctx, HttpRequest req) {
        this.ctx = ctx;
        this.req = req;
    }

    public String getUrl() {
        return req.uri();
    }

    public String getMethod() {
        return req.method().name();
    }

    public Map<String, List<String>> getParameters() {
        QueryStringDecoder decoder = new QueryStringDecoder(req.uri());
        return decoder.parameters();
    }

    public String getParameter(String name) {
        Map<String, List<String>> params = getParameters();
        List<String> param = params.get(name);
        if (null == param) {
            return null;
        } else {
            return param.get(0);
        }
    }
}

MYResponse

public class MYResponse {

    // SocketChannel的封装
    private ChannelHandlerContext ctx;

    private HttpRequest req;

    public MYResponse(ChannelHandlerContext ctx, HttpRequest req) {
        this.ctx = ctx;
        this.req = req;
    }

    public void write(String out) throws Exception {
        try {
            if (out == null || out.length() == 0) {
                return;
            }
            // 设置 http协议及请求头信息
            FullHttpResponse response = new DefaultFullHttpResponse(
                    // 设置http版本为1.1
                    HttpVersion.HTTP_1_1,
                    // 设置响应状态码
                    HttpResponseStatus.OK,
                    // 将输出值写出 编码为UTF-8
                    Unpooled.wrappedBuffer(out.getBytes("UTF-8")));

            response.headers().set("Content-Type", "text/html;");
            // 当前是否支持长连接
//            if (HttpUtil.isKeepAlive(r)) {
//                // 设置连接内容为长连接
//                response.headers().set(CONNECTION, HttpHeaderValues.KEEP_ALIVE);
//            }
            ctx.write(response);
        } finally {
            ctx.flush();
            ctx.close();
        }
    }
}

MYTomcat

public class MYTomcat {

    private int port = 8080;
    private ServerSocket server;
    // 用来保存路径与Servlet的映射关系（servlet单例模式）
    private Map<String, MYServlet> servletMapping = new HashMap<>();
    // web.xml
    private Properties webxml = new Properties();


    // 加载web.xml文件,同时初始化 ServletMapping对象
    private void init(){

        try{
            String WEB_INF = this.getClass().getResource("/").getPath();
            FileInputStream fis = new FileInputStream(WEB_INF + "web.properties");

            webxml.load(fis);

            for (Object k : webxml.keySet()) {

                String key = k.toString();
                // 以url结尾的key就是要映射的路径
                if(key.endsWith(".url")){
                    String servletName = key.replaceAll("\\.url$", "");
                    String url = webxml.getProperty(key);

                    // 拿到对应servlet全类名后，通过反进行实例化，之后放入map中（单例模式）
                    // 注：这里是将所有Servlet都强转为MyServlet，所以一定要继承MyServlet
                    String className = webxml.getProperty(servletName + ".className");
                    MYServlet obj = (MYServlet)Class.forName(className).newInstance();
                    servletMapping.put(url, obj);
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 启动tomcat
     * 1. 调用init方法，加载web.xml
     * 2.等待用户请求，并对每个请求进行处理
     */
    public void start() {
        init();

        // netty封装了nio，Reactor模型，Boss，worker
        // Boss线程
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        // Worket线程
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // Netty服务
            ServerBootstrap server = new ServerBootstrap();
            // 链路式编程
            server.group(bossGroup, workerGroup)
                    // 主线程处理类,看到这样的写法，底层就是用反射
                    .channel(NioServerSocketChannel.class)
                    // 子线程处理类 , Handler
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        // 客户端初始化处理
                        protected void initChannel(SocketChannel client) throws Exception {
                            // 无锁化串行编程
                            // Netty对HTTP协议的封装，顺序有要求
                            // HttpResponseEncoder 编码器
                            client.pipeline().addLast(new HttpResponseEncoder());
                            // HttpRequestDecoder 解码器
                            client.pipeline().addLast(new HttpRequestDecoder());
                            // 业务逻辑处理
                            client.pipeline().addLast(new MYTomcatHandler());
                        }

                    })
                    // 针对主线程的配置 分配线程最大数量 128
                    .option(ChannelOption.SO_BACKLOG, 128)
                    // 针对子线程的配置 保持长连接
                    .childOption(ChannelOption.SO_KEEPALIVE, true);

            // 启动服务器
            ChannelFuture f = server.bind(port).sync();
            System.out.println("MYTomcat 已启动，监听的端口是：" + port);
            f.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public class MYTomcatHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            if (msg instanceof HttpRequest) {
                HttpRequest req = (HttpRequest) msg;

                // 转交给我们自己的request实现
                MYRequest request = new MYRequest(ctx, req);
                // 转交给我们自己的response实现
                MYResponse response = new MYResponse(ctx, req);
                // 实际业务处理
                String url = request.getUrl();

                if (servletMapping.containsKey(url)) {
                    servletMapping.get(url).service(request, response);
                } else {
                    response.write("404 - Not Found");
                }

            }
        }
    }

    public static void main(String[] args) {
        new MYTomcat().start();
    }
}

然后启动 Tomcat，并在浏览器访问我们写好的 FirstServlet