手写Tomcat

最新推荐文章于 2024-08-13 21:59:41 发布
最新推荐文章于 2024-08-13 21:59:41 发布
阅读量241 收藏 1
点赞数 1
分类专栏： IO&Netty 文章标签： tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45596022/article/details/114297035
版权

1，分析

1，首先要有一个类似web.xml的文件来注册Servlet

2，要有一个BaseServlet

3，request和response实际上就是输入输出流

4，容器启动需要加载配置文件，保存路径和servlet的映射信息

5，利用死循环，socket接收请求，处理请求

2，BIO版本

1）BaseServlet

public abstract class BaseServlet {



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

    protected abstract void doPost(MyRequest request, MyResponse response)throws Exception;

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

2）MyRequest

public class MyRequest {

    private String method;

    private String url;

    public MyRequest(InputStream in) {
        try {
            String context = "";
            byte[] buffer = new byte[1024];
            int len = 0;

            if ((len = in.read(buffer)) > 0) {
                context=new String(buffer,0,len);
            }
            String line =context.split("\\n")[0];
            String[]arr=line.split("\\s");
            this.method=arr[0];
            this.url=arr[1].split("\\?")[0];

            System.out.println(context);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String getUrl() {
        return url;
    }

    public String getMethod() {

        return method;
    }
}

3）MyResponse

public class MyResponse {

    OutputStream outputStream;

    public MyResponse(OutputStream out) {
        this.outputStream = out;
    }

    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);
        outputStream.write(sb.toString().getBytes());
    }
}

4）web.properties

servlet.one.url=/firstServlet.do
servlet.one.className=com.yhd.servlet.FirstServlet

5）FirstServlet

public class FirstServlet extends BaseServlet {


    @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("This is the First Servlet");
    }
}

6）YhdTomcat

public class YhdTomcat {

    private int port = 8080;

    private ServerSocket server;

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

    private Properties webxml = new Properties();

    private void init() {
        try {
            String WEB_INT = this.getClass().getResource("/").getPath();
            FileInputStream fis = new FileInputStream(WEB_INT + "web.properties");
            webxml.load(fis);
            for (Object key : webxml.keySet()) {
                String k = key.toString();
                if (k.endsWith(".url")) {
                    String servletName = k.replaceAll("\\.url$", "");
                    String url = webxml.getProperty(k);
                    String className = webxml.getProperty(servletName + ".className");

                    BaseServlet obj = (BaseServlet) Class.forName(className).newInstance();
                    servletMap.put(url, obj);

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

    private void process(Socket client) throws Exception {
        InputStream inputStream = client.getInputStream();
        OutputStream outputStream = client.getOutputStream();
        MyRequest request = new MyRequest(inputStream);
        MyResponse response = new MyResponse(outputStream);
        String url = request.getUrl();
        if (servletMap.containsKey(url))
            servletMap.get(url).service(request, response);
        else
            response.write("404 Not Found");
        outputStream.flush();
        outputStream.close();
        inputStream.close();


    }

    public void start() {
        init();
        try {
            server = new ServerSocket(this.port);
            System.out.println("tomcat is start , listening port is " + port);
            for (; ; ) {
                Socket client = server.accept();

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

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

3，Netty版

1）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.getUri();
    }

    public String getMethod() {
        return req.getMethod().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);

    }

}

2）MyResponse

public class MyResponse {

    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(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, Unpooled.wrappedBuffer(out.getBytes("UTF-8")));
            response.headers().set("Content-Type", "text/html;");
            ctx.write(response);
        } finally {
            ctx.flush();
            ctx.close();
        }
    }
}

3）MyTomcat

public class MyTomcat {

    private int port = 8080;

    private ServerSocket server;

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

    private Properties webxml = new Properties();

    private void init() {
        try {
            String WEB_INT = this.getClass().getResource("/").getPath();
            FileInputStream fis = new FileInputStream(WEB_INT + "web.properties");
            webxml.load(fis);
            for (Object key : webxml.keySet()) {
                String k = key.toString();
                if (k.endsWith(".url")) {
                    String servletName = k.replaceAll("\\.url$", "");
                    String url = webxml.getProperty(k);
                    String className = webxml.getProperty(servletName + ".className");

                    BaseServlet obj = (BaseServlet) Class.forName(className).newInstance();
                    servletMap.put(url, obj);

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

    public void start() {
        init();
        worker();
    }

    private void worker() {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        // Worker线程
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap server = new ServerBootstrap();
            // 链路式编程
            server.group(bossGroup, workerGroup)
                    // 主线程处理类,看到这样的写法，底层就是用反射
                    .channel(NioServerSocketChannel.class)
                    // 子线程处理类 , Handler
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        // 客户端初始化处理
                        @Override
                        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 TomcatHandler());
                        }

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

            // 启动服务器
            ChannelFuture f = server.bind(port).sync();
            System.out.println("Tomcat is start ,listening port is ：" + port);
            f.channel().closeFuture().sync();
        }catch (Exception e){

        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

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


    private class TomcatHandler 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(servletMap.containsKey(url)){
                    servletMap.get(url).service(request, response);
                }else{
                    response.write("404 - Not Found");
                }

            }
        }
    }
}

码云地址

学nm个锤子
关注
专栏目录
手写简易tomcat
05-15
想学习web服务器的可以来看看，写的很基础，内容很详细，有源码和相关说明
【Tomcat】——纯手写实现一个简单的Tomcat
我爱吃土豆
07-26 7459
前言 心血来潮，记得上大学时老师曾经简单讲过Tomcat底层的实现原理，并给我们演示过简单的实现，趁着刚毕业还没有全部忘记，回温一下记录在这里，在这里纯底层实现一个简单可以访问静态文件以及动态请求的Tomcat服务器。 实现功能： 1：静态资源请求 2：动态请求处理 3：session及cookie信息存储，为方便下文的理解不了解的同学可以先自行了解一下session和cookie ...
手写简单的Tomcat
最新发布
Dwwer的博客
08-13 552
那么由此，就会产生HttpRequest,HttpResponse在设计时，我们先设计Request和ResponseRequest：是一个请求数据，其作用就是将客户端发送的http请求数据进行拆解后，将信息封装到其类本身那么里面会持有一个InputStream，还会有参数类型，比如uri，method，以及还有参数信息，那么参数信息我们需要用一个集合来进行存放，就使用hashMap(key，value)key：参数名字, value:参数对应的值。如何获取到数据呢？
Tomcat手动部署动态Web项目(详细步骤)
weixin_45256307的博客
06-07 1699
dqw
手写一个简单的tomcat(从零到一，简单易懂)
比时代快才是快，趁风使柁
01-16 1325
教你从零到一构建一个简易的tomcat，获取请求，解析请求，响应资源，刚接触tomcat，本文章是非常适合的，欢迎小伙伴们学习留言交流哦！！！
手写tomcat
06-03
【手写Tomcat】是一个深度理解Java Web服务器工作原理的过程，它涵盖了Tomcat的核心组件、工作流程以及如何通过代码实现这些功能。在这个过程中，我们主要会接触到以下几个关键知识点： 1. **Servlet容器**：Tomcat...
手写 tomcat nio
01-22
在深入探讨手写Tomcat NIO之前，我们首先需要理解NIO（Non-blocking I/O）的概念。NIO是Java提供的一个用于替代传统I/O模型（即BIO，Blocking I/O）的库。在BIO中，每个连接都需要一个单独的线程进行处理，当并发...
手写Tomcat全家桶
04-08
【标题】"手写Tomcat全家桶"是一个深入理解并实践Apache Tomcat服务器的项目，旨在帮助开发者通过自己动手编写代码来深入理解Tomcat的工作原理和内部机制。这个项目涵盖了从基础的HTTP服务器到复杂的Servlet容器的...
手写 tomcat IDEA工程
11-07
在手写Tomcat时，你需要实现一个Servlet容器，管理Servlet的生命周期，包括加载、初始化、服务和销毁等阶段。 4. **静态资源与动态资源**：静态资源通常是HTML、CSS、JavaScript等文件，它们可以直接发送给客户端；...
从零手写Tomcat【源码】【abl-tomcat-001】【准备步骤，基础Socket通信环境搭建】
04-04
从零手写Tomcat【源码】【abl-tomcat-001】【准备步骤，基础Socket通信环境搭建】 文章地址：https://blog.csdn.net/m0_37969197/article/details/123956989 目录地址：...
手把手系列—手写tomcat
qq_60969145的博客
09-29 834
今天一起徒手创建了一个精简版的tomcat，相信大家对tomcat运行原理会有更加深入的理解java注解、反射java网络编程servlet基础。Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache 服务器，可利用它响应（下的一个应用）页面的访问请求。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你
java切换到指定程序_教你动手实现Tomcat，快速从JavaSE切换到javaweb学习！
weixin_31481495的博客
02-16 321
对于JavaEE的初学者来说，大家学完JAVASE之后，马上进入了WEB阶段的学习。大家在JAVASE阶段写代码时,从头到尾都是自己写的，到了WEB阶段，尤其是进入Servlet的学习阶段，有人会感到困惑，怎么我写的代码看不到main函数了，服务端的Servlet是个什么东东呢?tomcat服务器到底底层做了哪些事情呢？为了帮助大家更好的理解tomcat服务器,也为了帮助大家更好的步入WEB的学习...
手写简单的Tomcat（代码源于韩顺平老师的javaweb章节）
weixin_74484843的博客
12-04 1294
在 默 认 的 路 径 下 拷 贝 一份setting.xml 到C:\Users\Administrator.m2\settings.xml。** (3) 修改 C:\Users\Administrator.m2\settings.xml , 增加红色的部分**会下载到哪里到你指定的目录 C:\Users\Administrator.m2\repository。version 表示你引入到我们项目的 jar 包的版本是 3.1.0。scope: 表示作用域，也就是你引入的 jar 包的作用范围。
【JavaWeb学习笔记】10 - 手写Tomcat底层，Maven的初步使用
qq_41891655的博客
12-16 1199
浏览器请求http:/ /localhost:8080,服务端返回hi , hspedu,后台hsptomcat使用BIO线程模型,支持多线程=>对前面的开发模式进行改造一个持有线程的对象。
Tomcat学习笔记002-手写Tomcat小demo
qq_40393739的博客
07-12 395
概要 时间：2021-07-10 学习内容: 视频-动手实现Tomcat 提取码：jpdu 内容输出： 学习笔记 代码demo 1.学习笔记 1）
手写Tomcat源码简易篇
qq_43649937的博客
04-02 1028
java
手写tomcat代码
07-28
手写Tomcat代码通常是指直接操作Tomcat服务器的底层组件，比如Servlet、JSP等，以及管理服务器的一些核心功能，如连接池、部署应用等。这需要对Java SE API、网络编程和Tomcat架构有深入理解。 以下是一个简单的示例，假设我们要创建一个基本的Servlet： ```java import javax.servlet.*; import java.io.*; public class HelloWorldServlet extends GenericServlet { @Override public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.println("<h1>Hello, World!</h1>"); } } ``` 在这个例子中，我们继承了`GenericServlet`并覆盖了`service()`方法，这是Servlet生命周期中的关键部分，当接收到请求时会被调用。 然而，实际的手写Tomcat代码会更复杂，包括但不限于注册Servlet，处理HTTP请求和响应，配置上下文路径，以及维护服务器的运行环境。这些都是通过`Server`, `Connector`, `WebappContext`等Tomcat的核心类来完成的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值