基于传统I/O或Netty简单实现tomcat容器

已于 2022-03-30 14:39:50 修改
阅读量588 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： java tomcat netty io
于 2022-03-30 14:22:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45097637/article/details/123844782
版权

总体思路

以往部署servlet项目都是部署在tomcat上，并且有一个全局的web.xml配置实现的servlet和filter过滤器，在这里我们自定义一个web.properties来代替web.xml；除此之外，我们需要做的呀Request和Response来处理http请求和响应，也要自定义servlet来处理http请求的相应后端业务逻辑，servlet与url的映射关系我们配置在web.properties中。

1、环境准备

自定义Servlet

servlet抽象类

public abstract class AbstractServlet {

    public void service(MyRequest request, MyResponse response) throws Exception {
        if ("GET".equals(request.getMethod())) {
            doGet(request, response);
        } else {
            doPost(request, response);
        }
    }

    public abstract void doGet(MyRequest request, MyResponse response) throws Exception;
    public abstract void doPost(MyRequest request, MyResponse response) throws Exception;
}

servlet实现类MyFirstServlet

public class MyFirstServlet extends AbstractServlet {

    @Override
    public void doGet(MyRequest request, MyResponse response) throws Exception {
        this.doPost(request, response);
    }

    @Override
    public void doPost(MyRequest request, MyResponse response) throws Exception {
        response.write("MyFirstServlet done!");
    }
}

servlet实现类MySecondServlet

public class MySecondServlet extends AbstractServlet {
    @Override
    public void doGet(MyRequest request, MyResponse response) throws Exception {
        this.doPost(request, response);
    }

    @Override
    public void doPost(MyRequest request, MyResponse response) throws Exception {
        response.write("MySecondServlet done!");
    }
}

2、自定义配置文件web.properties

servlet.first.url=/first
servlet.first.className=com.mxd.nettystudy.tomcat.servlet.MyFirstServlet

servlet.second.url=/second
servlet.second.className=com.mxd.nettystudy.tomcat.servlet.MySecondServlet

3、基于传统I/O实现Tomcat

自定义Request=>MyRequest

public class MyRequest {
    private String method;
    private String url;

    public MyRequest(InputStream is) {
        try {
            String content = "";
            byte[] bytes = new byte[1024];
            int len = 0;
            if ((len = is.read(bytes)) > 0) {
                content = new String(bytes, 0 ,len);
            }
            // 这里相当于是 "GET /second HTTP/1.1"
            String line = content.split("\\n")[0];
            String[] split = line.split("\\s");
            this.method = split[0];
            this.url = split[1].split("\\s")[0];
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String getUrl() {
        return url;
    }

    public String getMethod() {
        return method;
    }
}

Http请求内容参考

GET /second HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Cache-Control: max-age=0
sec-ch-ua: " Not A;Brand";v="99", "Chromium";v="99", "Google Chrome";v="99"
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/99.0.4844.83 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

自定义Response=>MyResponse

public class MyResponse {
    private OutputStream os;

    public MyResponse(OutputStream os) {
        this.os = os;
    }

    public void write(String msg) throws IOException {
        StringBuilder sb = new StringBuilder();
        sb.append("HTTP/1.1 200 OK\n")
                .append("Content-Type: text/html;\n")
                .append("\r\n")
                .append(msg);
        os.write(sb.toString().getBytes());
    }
}

自定义Tomcat启动类

public class TomcatApplication {
    private int port = 8080;
    private ServerSocket serverSocket;
    // Map存储url与servlet的映射
    private Map<String, AbstractServlet> servletMapping = new HashMap<>();
    // 存储web.properties配置文件
    private Properties webProperties = new Properties();

    // 容器启动时加载配置文件
    public void init() {
        try {
            String path = this.getClass().getResource("/").getPath();
            FileInputStream fis = new FileInputStream(path + "web.properties");
            webProperties.load(fis);
            for (Object k : webProperties.keySet()) {
                String key = k.toString();
                if (key.endsWith(".url")) {
                    String url = webProperties.getProperty(key);
                    String className = webProperties.getProperty(key.replaceAll("\\.url$", "") + ".className");
                    AbstractServlet servlet = (AbstractServlet) Class.forName(className).newInstance();
                    servletMapping.put(url, servlet);
                }
            }


        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void start(){
        init();
        try {
            serverSocket = new ServerSocket(this.port);
            System.out.println("自定义tomcat启动-----监听端口:" + this.port);
            while (true) {
                // 监听端口
                Socket accept = serverSocket.accept();
                System.out.println(accept.getRemoteSocketAddress());
                // 处理请求
                process(accept);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void process(Socket accept) throws Exception {
        InputStream is = accept.getInputStream();
        OutputStream os = accept.getOutputStream();

        MyRequest request = new MyRequest(is);
        MyResponse response = new MyResponse(os);

        String url = request.getUrl();
        // 处理url
        if (servletMapping.containsKey(url)) {
            servletMapping.get(url).service(request, response);
        } else {
            response.write("404-Not Found");
        }

        os.flush();
        os.close();

        is.close();
        accept.close();
    }

    public static void main(String[] args) {
        // 启动tomcat服务
        new TomcatApplication().start();
    }
}

4、基于Netty实现Tomcat

重构Request=>MyRequest

public class MyRequest {
    private ChannelHandlerContext ctx;
    private HttpRequest request;

    public MyRequest(ChannelHandlerContext ctx, HttpRequest request) {
        this.ctx = ctx;
        this.request = request;
    }

    public String getUrl() {
        return this.request.uri();
    }

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

    // 获取指定参数值
    public String getParameter(String paramName) {
        Map<String, List<String>> parameters = getParameters();
        List<String> paramValues = parameters.get(paramName);
        return Objects.nonNull(paramValues)? paramValues.get(0): null;
    }

    // 解析http的URL请求中所有参数键值对
    public Map<String, List<String>> getParameters() {
        QueryStringDecoder queryStringDecoder = new QueryStringDecoder(this.request.uri());
        return queryStringDecoder.parameters();
    }
}

重构Response=>MyResponse

public class MyResponse {
    private ChannelHandlerContext ctx;
    private HttpRequest request;

    public MyResponse(ChannelHandlerContext ctx, HttpRequest request) {
        this.ctx = ctx;
        this.request = request;
    }

    public void write(String msg) throws IOException {
        if (!StringUtils.hasText(msg)) return;

        try {
            FullHttpResponse response = new DefaultFullHttpResponse(
                    // 设置版本为HTTP 1.1
                    HttpVersion.HTTP_1_1,
                    // 设置状态响应码
                    HttpResponseStatus.OK,
                    // 设置输出内容编码格式
                    Unpooled.wrappedBuffer(msg.getBytes(HttpConstants.DEFAULT_CHARSET))
            );

            response.headers().set("Content-Type", "text/html");
            ctx.write(response);
        } finally {
            ctx.flush();
            ctx.close();
        }
    }
}

重构Tomcat启动类[netty实现]

public class TomcatApplication {
    private int port = 8080;
    private ServerSocket serverSocket;
    private Map<String, AbstractServlet> servletMapping = new HashMap<>();
    private Properties webProperties = new Properties();

    // 容器启动时加载配置文件
    public void init() {
        try {
            String path = this.getClass().getResource("/").getPath();
            FileInputStream fis = new FileInputStream(path + "web.properties");
            webProperties.load(fis);
            for (Object k : webProperties.keySet()) {
                String key = k.toString();
                if (key.endsWith(".url")) {
                    String url = webProperties.getProperty(key);
                    String className = webProperties.getProperty(key.replaceAll("\\.url$", "") + ".className");
                    AbstractServlet servlet = (AbstractServlet) Class.forName(className).newInstance();
                    servletMapping.put(url, servlet);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void start(){
        init();
        // netty封装的Reactor模型
        // boss线程
        NioEventLoopGroup boss = new NioEventLoopGroup();
        // work线程
        NioEventLoopGroup work = new NioEventLoopGroup();
        ServerBootstrap server = new ServerBootstrap();

        try {
            server.group(boss, work)
                    // 主线程处理
                    .channel(NioServerSocketChannel.class)
                    // 子线程处理
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // netty对http的封装，顺序有要求
                            ch.pipeline().addLast(new HttpResponseEncoder());
                            ch.pipeline().addLast(new HttpRequestDecoder());
                            // 业务逻辑处理
                            MyTomcatHandler tomcatHandler = new MyTomcatHandler();
                            tomcatHandler.setServletMapping(servletMapping);
                            ch.pipeline().addLast(tomcatHandler);
                        }
                    })
                    // 主线程配置 最大线程数量128
                    .option(ChannelOption.SO_BACKLOG, 128)
                    // 子线程配置 保持长链接
                    .childOption(ChannelOption.SO_KEEPALIVE, true);

            ChannelFuture channelFuture = server.bind(port).sync();
            System.out.println("自定义tomcat启动-----端口：" + port);
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            boss.shutdownGracefully();
            work.shutdownGracefully();
        }

    }

    public static void main(String[] args) {
        // 启动tomcat服务
        new TomcatApplication().start();
    }
}

实现业务处理的handler

public class MyTomcatHandler extends ChannelInboundHandlerAdapter {

    private Map<String, AbstractServlet> servletMapping;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        HttpRequest request = (HttpRequest) msg;
        MyRequest myRequest = new MyRequest(ctx, request);
        MyResponse myResponse = new MyResponse(ctx, request);
        String url = myRequest.getUrl();
        if (servletMapping.containsKey(url)) {
            servletMapping.get(url).service(myRequest, myResponse);
        } else {
            myResponse.write("404-Not Found");
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

    }

    public Map<String, AbstractServlet> getServletMapping() {
        return servletMapping;
    }

    public void setServletMapping(Map<String, AbstractServlet> servletMapping) {
        this.servletMapping = servletMapping;
    }
}

5、启动Tomcat，运行演示

这里我们启动基于Netty实现的Tomcat，所以直接运行Tomcat的启动类中的main方法new TomcatApplication().start();
控制台效果
在这里插入图片描述
浏览器请求效果
浏览器输入=》http://localhost:8080/first
在这里插入图片描述
浏览器输入=》http://localhost:8080/second
在这里插入图片描述

冬雪是你
关注
专栏目录
netty 实现tomcat
weixin_43931625的博客
06-02 694
netty 实现tomcat
(一) Tomcat 源码系列之网络 I/O 模型
Gp_2512212842的博客
07-16 529
今天开始学习 Tomcat 源码, 本系列采用的是 Tomcat 8.5.57 源码构建, 在学习 Tomcat 源码之前, 先来学习基础知识 : 网络 I/O 模型. I/O 模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能 Java 共支持 3 种网络编程模型 /IO 模型：BIO、NIO、AIO BIO Blocking IO, 同步并阻塞 (传统阻塞型)，一般搭配线程池来使用, 否则只有一条线程在工作! 其中 : ServerSocket::accept
netty实现简易tomcat
01-04
基于netty手写实现简易版tomcat,netty实现http服务器容器的demo
netty实现tomcat（简易版）
mulin_2017的博客
01-28 1378
Hi，本篇主要是介绍如何用Netty来实现Tomcat简易功能（首次发文，不喜勿喷） 一、Netty是什么？ Netty是由JBOSS提供的一个Java开源框架。Netty提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络IO程序,是目前最流行的NIO框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，知名的Elasticsearch、Dubbo框架内部都采用了Netty。 Netty不仅支持TCP、UDP...
Spring Boot 如何使用 Netty 框架及 Netty 与 Tomcat 的区别
最新发布
weixin_73414031的博客
09-04 1003
特性TomcatNettyI/O 模型阻塞 I/O，支持 NIO非阻塞 I/O (NIO)，事件驱动并发处理多线程，每请求一个线程事件循环模型，少量线程处理大量请求协议支持HTTP/HTTPS多协议（HTTP、WebSocket、TCP、UDP）适用场景传统 Web 应用，企业级中小型项目高并发、低延迟应用，如实时系统和物联网开发难度容易上手，配置简单开发灵活，但复杂度较高性能适合中等并发应用，性能良好高性能，适合大规模并发应用。
基于netty实现的迷你版TOMCat
weixin_42022924的博客
11-13 301
1.首先有一个tomcat类用来管理网络请求和servlet映射 package com.tomcatmini; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.s...
使用Netty实现服务端与客户端之间的通信
is_Javaer的博客
08-12 2612
Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients. Netty是 一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。 在Netty官网上是如上定义Netty的。Netty利用了Java的高级网络能力，提供了一个比JDK.
chenfast-simple-tomcat-master.zip
05-30
本文将深入探讨如何从零开始，基于传统模式和NIO（非阻塞I/O）模式手写一个简单的Tomcat服务器，以理解其工作原理。 首先，我们需要了解传统的BIO（阻塞I/O）模式。在BIO模式下，每个连接都需要一个单独的线程来...
netty服务端、客户端代码
07-18
4. **NettyReactiveWebServerFactory**: 这是一个用于创建基于Netty的反应式Web服务器的工厂类，可以替代Tomcat或Jetty等传统Servlet容器。 通过以上介绍，我们可以看到Netty服务端和客户端的创建过程，以及Netty...
Netty 20道面试题和答案.docx
06-15
Netty 是一款基于 NIO（Nonblocking I/O，非阻塞 IO）开发的网络通信框架，对比于 BIO（Blocking I/O，阻塞 IO），他的并发性能得到了很大提高。难能可贵的是，在保证快速和易用性的同时，并没有丧失可维护性和性能...
netty与tomcat功能比较
12-10
总结了netty和tomcat的差异，入门级的比较，希望对读者有点帮助
基于netty实现简易版的tomcat服务器
lyzchengxuyuan的博客
12-12 816
基于netty实现简易版的tomcat服务器
Netty学习——入门篇3 基于传统I/O和Netty 简单实现Tomcat
geminigoth的博客
03-12 857
首先，创建GPServlet抽象类。GPServlet生命周期最常用的方法时doGet()和doPost()方法，而doGet()和doPost()方法是service方法的分支实现，下面为简易版Servlet源码实现。从上面的代码中可以看到，doGet()和doPost方法中有两个参数 GPRequest和GPResponse对象，这两个对象是由Web容器创建的，主要是对底层Socket的输入输出进行封装。其中GPRequest是对Input的封装，GPResponse是对Output的封装。
通信框架之Netty第三话 - Netty的使用以及使用Netty改造Tomcat
生生不息，则源源不断
05-09 587
通信框架之Netty第三话 - Netty的使用以及使用Netty改造Tomcat 当然Netty已经内置了很多常见的协议，能直接用的，我们不用自己重复造轮子。 以上就是本章的全部内容了。 上一篇：通信框架之Netty第二话 - 终极理解HTTP协议以及手写一个Tomcat 下一篇：通信框架之Netty第四话 - Netty深入了解之聊天房的实现 读书之法，在循序而渐进，熟读而精思
Tomcat使用Netty实现
weixin_44971379的博客
11-17 1084
定义配置文件，指定 url,与对应的执行类 servlet.one.url=/firstServlet.do servlet.one.className=com.rt.netty.tomcat.servlet.FirstServlet servlet.two.url=/secondServlet.do servlet.two.className=com.rt.netty.tomcat.servlet.SecondServlet 读取配置文件，初始化 Servlet 容器 private Map&.
Netty 实战：如何编写一个麻小俱全的 web 容器
cmqqka62688的博客
02-01 298
学习 Netty 也有一段时间了，为了更好的掌握 Netty，我手动造了轮子，一个基于 Netty 的 web 容器：redant，中文叫红火蚁。创建这个项目的目的主要是学习使用 Netty，俗话说不要轻易的造轮子，但是通过造轮...
SpringBoot项目中使用Netty替换Tomcat，Undertow等Web容器
weixin_34064653的博客
12-10 2791
2019独角兽企业重金招聘Python工程师标准>>> ...
基于Netty实现Web容器-Netty版Tomcat（一）
weixin_37957321的博客
06-27 1408
BIO、NIO、AIO 初识和进阶
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值