使用 NIO 模式简单模拟一个 Tomcat 运行原理

已于 2022-08-10 10:12:04 修改
阅读量223 收藏
点赞数
分类专栏： Netty Java基础 文章标签： java servlet nio
于 2022-08-09 16:06:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35971258/article/details/126249820
版权

问题：一直对 Tomcat 的运行原理充满着好奇，今天终于自己通过 NIO 模拟了一个简约版 Tomcat ，直接看下面代码：

package main.tomcat;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * 定义同一规范的接口用来处理客户端请求
 */
interface Servlet {
    void service(HttpServletRequest request, HttpServletResponse response) throws Exception;
}

/**
 * 处理客户单请求登录的 Servlet
 * request 接受客户端发送的请求参数
 * response 把处理结果发送给客户端
 */
class LoginServlet implements Servlet {

    @Override
    public void service(HttpServletRequest request, HttpServletResponse response) throws Exception {
        String userName = request.getParameterValue("userName");
        String password = request.getParameterValue("password");
        String uri = request.getParameterValue("uri");

        String allParameterValue = request.getAllParameterValue();

        System.out.println(LocalDateTime.now() + " 【" + Thread.currentThread().getName() + "】线程===>正在处理客户端请求,需耗时3s...");
        System.out.println("开始倒计时:");
        TimeUnit.SECONDS.sleep(1);
        System.out.println("3");
        TimeUnit.SECONDS.sleep(1);
        System.out.println("2");
        TimeUnit.SECONDS.sleep(1);
        System.out.println("1");
        TimeUnit.SECONDS.sleep(1);

        SocketChannel printWriter = response.getPrintWriter();
        StringBuffer result = ResponsePage.build(request.getParameterValue("uri"));
        result.append("<h1><font color='green'>接受到你的请求参数是:" + allParameterValue + "</font></h1>");
        // 处理完成，开始会写给客户端数据
        System.out.println(LocalDateTime.now() + " 【" + Thread.currentThread().getName() + "】线程===>处理成功");
        printWriter.write(ByteBuffer.wrap(result.toString().getBytes(StandardCharsets.UTF_8)));
        System.out.println("\n\n\n\n");
    }
}

/**
 * 定义一些返回结果页面，用于展示、方便浏览器查看
 */
class ResponsePage {

    public static StringBuffer build(String pageIndex) {
        StringBuffer buffer = new StringBuffer();
        buffer.append("HTTP/1.1 200 ok\n");
        buffer.append("Content-Type: text/html; Charset=utf-8\n\n");
        try {
            FileInputStream fileInputStream = null;
            if (pageIndex.contains("login")) {
                fileInputStream = new FileInputStream("/Users/gongweiming/IdeaProjects/NettyProDemo/src/main/tomcat/login.html");
            } else {
                fileInputStream = new FileInputStream("/Users/gongweiming/IdeaProjects/NettyProDemo/src/main/tomcat/404.html");
            }

            FileChannel channel = fileInputStream.getChannel();
            ByteBuffer byteBuf = ByteBuffer.allocate(1024);
            int len = 0;
            while ((len = channel.read(byteBuf)) != -1) {

            }
            String content = new String(byteBuf.array(), 0, 1024 - byteBuf.remaining());
            // System.out.println(">>>>>>>>>"+content);
            buffer.append(content);

           /* BufferedReader reader = new BufferedReader(new InputStreamReader(fileInputStream));
            String line = "";

            while ((line = reader.readLine()) != null) {
                buffer.append(line);
            }*/
        } catch (Exception e) {
            e.printStackTrace();
        }
        return buffer;
    }
}

/**
 * =============================启动 Tomcat 服务器=============================
 * 1、首先加载并解析 web.xml 内容，每一个客户端访问都会有一个对应的 Servlet 进行相应处理
 * 2、真正开始处理客户端请求，也就是调用 Servlet 接口中定义的 service(request,response) 方法
 * 3、service(request,response) 可以从 request 中获取客户端发送的数据，可以使用 response 进行响应客户端请求
 */
public class TomcatBootStrap {
    /**
     * 用于存放从 web.xml 中解析到的内容，基本就是 </login,LoginServlet> 一个访问路径对应一个处理器 Servlet
     */
    private static final ConcurrentHashMap<String, Servlet> servletMap = new ConcurrentHashMap<>();

    /**
     * Tomcat 启动入口
     */
    public static void main(String[] args) throws Exception {
        /** 1、解析 web.xml 中的内容，将请求 uri 和 servlet 解析到一个 Map 中存放好 */
        initWebXML();

        /** 2、使用 NIO 中的 Channel 通道进行通信，调用对应的 Servlet 处理业务 */
        startTomcat(8080);
    }

    /**
     * 只是一个做了一个简单的解析，局限性严重，推荐使用 Dom4j 树相关工具类解析
     */
    private static void initWebXML() throws Exception {
        FileInputStream fileInputStream = new FileInputStream("/Users/gongweiming/IdeaProjects/NettyProDemo/src/main/tomcat/web.xml");
        BufferedReader reader = new BufferedReader(new InputStreamReader(fileInputStream));
        String line = "";

        String key = null;
        String value = null;
        while ((line = reader.readLine()) != null) {
            if (line.contains("pattern")) {
                String[] split = line.split("/");
                key = "/" + split[1].substring(0, split[1].length() - 1);
            }
            if (line.contains("class")) {
                value = line.split(">")[1].split("<")[0];
            }
        }
        if (Objects.nonNull(key) && Objects.nonNull(value)) {
            servletMap.put(key, new LoginServlet());
        }
    }

    /**
     * 启动 Tomcat 服务，这里使用的是 NIO 异步非阻塞模式，也可以使用 Selector、Netty(Reactor 模式)
     */
    private static void startTomcat(int port) throws Exception {
        // 开启服务通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        // 监听端口
        serverSocketChannel.bind(new InetSocketAddress(port));

        // 设置成异步非阻塞模式，如果没有事件发生就返回 null
        serverSocketChannel.configureBlocking(false);

        // 开启线程处理业务
        doExecute(serverSocketChannel);

        // 关闭资源
        // 如果将 serverSocketChannel.accept() 方法放到另一个线程中执行的话这里不要关闭，否则拿不到 SocketChannel,
        // 如果使用 Completable 接口调用 serverSocketChannel.accept() 方法，注意它使用的是 ForkJoinPool 是个守护线程
        // 所以启动主线程，如果使用这个 ForkJoinPool 框架开启新线程，可以在主线程上面阻塞住，不要关闭了，因为 ForkJoinPool 是守护线程
        serverSocketChannel.close();
    }


    private static final int BUFFER_SIZE = 1024;

    /**
     * accept() 方法是非阻塞的，没有监听到事件返回 null，注意此处会存在空转问题
     * 采用多线程处理客户端请求
     * <p>
     * 分成三部分处理：
     * 1、通过 Socket 获取到客户端发送的数据包，然后解析封装成 HttpServletRequest 对象
     * 2、根据 web.xml 中的配置，找到对应的处理器 handler 或者说是 Servlet
     * 3、开始真正处理业务，处理完之后通过 HttpServletResponse 进行响应客户端
     */
    private static void doExecute(ServerSocketChannel serverSocketChannel) throws Exception {
        System.out.println("Tomcat is started,port is 8080...");
        while (true) {
            // 如果有 accept 事件发生，就不会返回 null
            SocketChannel socketChannel = serverSocketChannel.accept();
            if (socketChannel != null) {
                CompletableFuture.runAsync(() -> {
                    try {
                        HttpServletResponse response = new HttpServletResponse();
                        response.setPrintWriter(socketChannel);
                        /** 1、读取数据,解析客户端发送过来的请求 */
                        HttpServletRequest request = requestResolver(socketChannel);
                        if (Objects.isNull(request)) {
                            return;
                        }

                        /** 2、根据 web.xml 中配置的路由映射中找到对应的处理 handler */
                        Servlet handler = dispatcherServlet(request);

                        if (Objects.isNull(handler)) {
                            // 跳转到 404 页面，终结此次请求
                            response.getPrintWriter().write(ByteBuffer.wrap(ResponsePage.build("404").toString().getBytes(StandardCharsets.UTF_8)));
                            socketChannel.close();
                            return;
                        }

                        /** 3、对应的 handler 开始处理客户端请求 */
                        handler.service(request, response);

                        response.getPrintWriter().close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
            }
        }
    }

    /**
     * 将请求路径分发到对的 Servlet 处理器上
     */
    private static Servlet dispatcherServlet(HttpServletRequest request) throws InterruptedException {
        return servletMap.get(request.getParameterValue("uri"));
    }

    /**
     * 解析客户端发送的数据包，将其封装成 HttpServletRequest
     *
     * @param socketChannel
     * @return
     * @throws Exception
     */
    private static HttpServletRequest requestResolver(SocketChannel socketChannel) throws Exception {
        HttpServletRequest request = new HttpServletRequest();
        ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
        socketChannel.read(buffer);
        byte[] bytes = buffer.array();
        String content = new String(bytes, 0, BUFFER_SIZE - buffer.remaining());
        System.out.println(LocalDateTime.now() + "【" + Thread.currentThread().getName() + "】线程===>接收到客户端请求,解析后，数据如下所示:\n");
        if (content.contains("favicon")) {
            return null;
        }
        System.out.println("=============================================================================================================");
        System.out.println(content);
        System.out.println("=================================================++++++【开始处理客户单请求】++++================================");

        if (!content.contains("favicon")) {
            String firstLine = content.split("\n")[0];
            if (firstLine.contains("HTTP")) {
                request.setParameterValue("uri", "/" + (firstLine.contains("?") ? firstLine.split("/")[1].split("\\?")[0] : firstLine.split("/")[1].split(" ")[0]));
                ;

                if (firstLine.contains("?") && firstLine.contains("=")) {
                    String s1 = firstLine.split("\\?")[1].split(" ")[0];
                    String[] split = s1.split("&");
                    Arrays.stream(split).forEach(e -> {
                        String[] split1 = e.split("=");
                        request.setParameterValue(split1[0], split1[1]);
                    });
                }
            }
        }
        return request;
    }

}

/**
 * 特别注意 Response 类中封装了可以给客户端会写内容的对象 Socket/SocketChannel
 * 这里也可以封装 PrintWriter 类，怎么方便怎么来
 */
class HttpServletResponse {
    private SocketChannel printWriter;

    public static HttpServletResponse SUCCESS() {
        HttpServletResponse response = new HttpServletResponse();
        return response;
    }

    public SocketChannel getPrintWriter() {
        return printWriter;
    }

    public void setPrintWriter(SocketChannel printWriter) {
        this.printWriter = printWriter;
    }
}

/**
 * 定义用于封装客户端请求参数实体 HttpServletRequest
 */
class HttpServletRequest {

    private Map<String, String> parameterValue = new ConcurrentHashMap<>();

    public String getAllParameterValue() {
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("<br/>");
        parameterValue.forEach((k, v) -> {
            stringBuffer.append(k + "=" + v + "<br/>");
        });
        return stringBuffer.toString();
    }

    public String getParameterValue(String key) {
        return parameterValue.get(key);
    }

    public void setParameterValue(String key, String value) {
        parameterValue.put(key, value);
    }
}

然后开启多个浏览器窗口，地址栏输入

http://localhost:8080/login?userName=10&password=1
http://localhost:8080/login
http://localhost:8080/abcxxx?userName=10&password=1
http://localhost:8080/abcxxx

控制台输出日志，如下：

Tomcat is started,port is 8080...
2022-08-09T17:29:39.679【ForkJoinPool.commonPool-worker-9】线程===>接收到客户端请求,解析后，数据如下所示:

=============================================================================================================
GET /login HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Cache-Control: max-age=0
sec-ch-ua: ".Not/A)Brand";v="99", "Google Chrome";v="103", "Chromium";v="103"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "macOS"
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cookie: XXL_JOB_LOGIN_IDENTITY=7b226964223a312c22757365726e616d65223a2261646d696e222c2270617373776f7264223a226531306164633339343962613539616262653536653035376632306638383365222c22726f6c65223a312c227065726d697373696f6e223a6e756c6c7d; Idea-159af402=a56b3ddf-5c52-4ba7-a513-b6bc69bef0f1


=================================================++++++【开始处理客户单请求】++++================================
2022-08-09T17:29:39.681 【ForkJoinPool.commonPool-worker-9】线程===>正在处理客户端请求,需耗时3s...
开始倒计时:
3
2
1
2022-08-09T17:29:43.701 【ForkJoinPool.commonPool-worker-9】线程===>处理成功

页面展示，如下:

在这里插入图片描述

总结

Tomcat 服务就是一个 Server，具备两点核心功能: Start 启动服务器，Stop 停止服务器；底层通过监听 Socket、接受请求、处理请求、响应请求等主要功能。

魔道不误砍柴功
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
NIO模式例子
seaboat——a free boat on the sea.（公众号：远洋号）
12-07 2828
NIO模式主要优势是体现在对多连接的管理，对众多连接各种事件的转发让处理变得更加高效，所以一般是服务器端才会使用NIO模式，而对于客户端为了方便及习惯使用阻塞模式的Socket进行通信。所以NIO模式的例子也仅仅看下服务端的实现即可。public class NioServer { private ByteBuffer readBuffer; private Selector selector;
Tomcat NIO 模型的实现
weixin_30540691的博客
04-18 289
Tomcat 对 BIO 和 NIO 两种模型都进行了实现，其中 BIO 的实现理解起来比较简单，而 NIO 的实现就比较复杂了，并且它跟常用的 Reactor 模型也略有不同，具体设计如下： 可以看出多了一个 BlockPoller 的设计，这是因为在 Servlet 规范中 ServletInputStream 和 ServletOutputStream 是阻塞的，所以请求体和响应体的读取和...
源码时代JAVA干货分享 | 利用NIO模拟实现Tomcat容器！
ITsource
08-16 114
NIO是什么 New IO，始于Java1.4，提供新的非阻塞 JavaIO 操作API. 又称Non-Blocking IO 非阻塞IO 替代旧版本的Blocking IO, 多用于网络相关的API. 为什么要使用NIO 使用NIO后，WEB网络程序性能可以进一步提高 模拟Tomcat7, 阻塞IO处理Http请求： public class...
Tomcat NIO
八行书
04-11 3035
说起Tomcat的NIO，不得不提的就是Connector这个Tomcat组件。Connector是Tomcat的连接器，其主要任务是负责处理收到的请求，并创建一个Request和Response的对象，然后用一个线程用于处理请求，Connector会把Request和Response对象传递给该线程，该线程的具体的处理过程就是Container容器的事了。在tomcat启动过程中，会初始化Con...
tomcat connectors
09-05
Selenium是一个强大的网页自动化工具，可以模拟用户对网页的各种操作，例如点击按钮、填写表单等。通过Python调用Selenium，开发者可以编写脚本来测试基于Web的Java应用程序，这些应用程序通常部署在Tomcat这样的...
Tomcat7共享session
04-09
- **SimpleTcpCluster**：这是一个基于TCP协议的集群实现，主要用于实现节点间的通信和数据同步。 - **DeltaManager**：用于管理会话数据的复制，它可以只复制会话数据的变化部分，从而提高复制效率。 - **Group...
Apache-Tomcat_Src_Code
12-24
它提供了一个抽象层，使得Tomcat可以支持多种协议，如AJP（Apache JServ Protocol）和NIO（Non-blocking Input/Output）。 5. **Juli**：Juli是Tomcat的自定义日志系统，提供了更灵活的日志配置和控制。开发者可以...
tomcatBIO.zip
11-24
【描述】"TomcatBIO.zip包含了一个使用传统阻塞I/O（BIO）模式构建的简单Tomcat服务器模拟。这个项目利用Spring Boot框架来实现静态资源和服务端动态内容的加载与处理。在BIO模式下，每个客户端连接都需要一个单独的...
一线互联网企业面试题.pdf
06-13
4. **HashMap与Redis实现**：直接用HashMap模拟Redis会有并发问题和死锁风险，推荐使用ConcurrentHashMap以保证线程安全。 5. **线程状态**：线程有新建、就绪、运行、阻塞、死亡五种状态。 6. **线程阻塞方式**：...
tomcat:Java使用nio模式实现tomcat
03-09
tomcat:Java使用nio模式实现tomcat
手写 tomcat nio
01-22
手写 tomcat nio http://knight-black-bob.iteye.com/blog/2408450
手写Tomcat：NIO实现方式
chielong's csdn
08-05 1195
  import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector...
NIO模型
攻城狮的博客
12-05 1522
NIO编程 具体组件 NIO 有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器) 2. NIO是 面向缓冲区编的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络 Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也
Tomcat的NIO模式的理解
qq_14868375的博客
08-17 2380
       要理解NIO必须先理解Tomcat的BIO，传统BIO模式主要这样的一个运行模式。当一个HTTP请求过来时，服务器立马调用serverSocket.accept()接受一个socket，然后服务器从线程池中取一个线程并且将这个socket传给这个线程处理。这个线程就会调用读数据流的方法读取socket中携带的数据流，然后将读取的数据流利用http协议解析成httprequest对象，...
基于NIO，手写一个Tomcat
sunny_fengjing的博客
12-15 1239
Java NIO Java NIO主要有三大核心部分： Buffer（缓冲区） Channel（通道） Selector（选择器） Buffer 缓冲区其实是一个容器对象，也就是一个数组。在NIO中所有数据面向缓存区处理的（传统I/O处理数据都是面向流），在读取数据时，他是直接读取的缓冲区的数据。在写入数据的时候，他也是直接写入缓冲区。在缓冲区中有三个重要的属性： posit...
NIO网络模型
一只特立独行的猪
04-25 7302
1. NIO简介 NIO：Non-blocking I/O 或 New I/O 从特性出发：非阻塞IO 从年龄出发：新IO，在原始IO之后出现的 诞生：从 JDK 1.4 引入的全新的输入输出标准库，重新设计的一套IO标准 职务：高并发网络服务器支持岗。作为原始IO的补充，为了应对高性能高并发的应用场景。 2. 编程模型 模型：对事物共性的抽象（个人理解：用一个统一的方法解决一系列相似的问题）...
基础知识深化：NIO优化原理和Tomcat线程模型
qwe123147369的博客
09-22 619
写在前面：2020年面试必备的Java后端进阶面试题总结了一份复习指南在Github上，内容详细，图文并茂，有需要学习的朋友可以Star一下！ GitHub地址：https://github.com/abel-max/Java-Study-Note/tree/master 1、I/O阻塞 书上说BIO、NIO等都属于I/O模型，但是I/O模型这个范围有点含糊，我为此走了不少弯路。我们日常开发过程中涉及到NIO模型应用，如Tomcat、Netty中等线程模型，可以直接将其视为 网络I/O模型 。本文还是在基础
手写tomcat(四):实现NIO模型的tomcat
shenshaoming的博客
04-20 390
在手写tomcat（三）中，我实现了基于BIO模型的多线程tomcat，而这次我实现了Nio的多线程模型，下一步打算是通过netty实现，不过目前还在进行中。。。 以下是基于NIO模型监听请求以及开启线程处理收到的请求。 package com.tomcat.core; import com.tomcat.annotations.Servlet; import com.tomcat.bas...
ConfigurableServletWebServerFactory 配置tomcat的运行模式为nio模式
最新发布
03-29
可以通过以下方式来配置 ConfigurableServletWebServerFactory 来启用 NIO 模式： 1. 首先，需要创建一个 ConfigurableServletWebServerFactory 实例...这样，Spring Boot 应用就会在 NIO 模式下运行 Tomcat 服务器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

魔道不误砍柴功

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值