手写Tomcat

最新推荐文章于 2024-08-13 21:59:41 发布
最新推荐文章于 2024-08-13 21:59:41 发布
阅读量239 收藏 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
一点思考
11-09 1万+
(参考了公众号：java架构沉思录中的文章：教你写一个迷你版的toncat 原文：https://www.jianshu.com/p/dcelee01fb90) 作为一个java学习的起步者，对tomcat的认识还是有很多的欠缺，在无意中发现了这篇文章，便在自己的环境下尝试搭建，收获良多： 分以下几个步骤： （1）提供Socket服务 （2）进行请求的转发 （3）把请求和响应封装成request/...
手写tomcat
06-03
手写tomcat服务，模拟tomcat运行。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
手写简单的Tomcat
最新发布
Dwwer的博客
08-13 544
那么由此，就会产生HttpRequest,HttpResponse在设计时，我们先设计Request和ResponseRequest：是一个请求数据，其作用就是将客户端发送的http请求数据进行拆解后，将信息封装到其类本身那么里面会持有一个InputStream，还会有参数类型，比如uri，method，以及还有参数信息，那么参数信息我们需要用一个集合来进行存放，就使用hashMap(key，value)key：参数名字, value:参数对应的值。如何获取到数据呢？
java切换到指定程序_教你动手实现Tomcat，快速从JavaSE切换到javaweb学习！
weixin_31481495的博客
02-16 318
对于JavaEE的初学者来说，大家学完JAVASE之后，马上进入了WEB阶段的学习。大家在JAVASE阶段写代码时,从头到尾都是自己写的，到了WEB阶段，尤其是进入Servlet的学习阶段，有人会感到困惑，怎么我写的代码看不到main函数了，服务端的Servlet是个什么东东呢?tomcat服务器到底底层做了哪些事情呢？为了帮助大家更好的理解tomcat服务器,也为了帮助大家更好的步入WEB的学习...
从零手写Tomcat【源码】【abl-tomcat-001】【准备步骤，基础Socket通信环境搭建】
04-04
从零手写Tomcat【源码】【abl-tomcat-001】【准备步骤，基础Socket通信环境搭建】 文章地址：https://blog.csdn.net/m0_37969197/article/details/123956989 目录地址：...
手写Tomcat全家桶
04-08
【标题】"手写Tomcat全家桶"是一个深入理解并实践Apache Tomcat服务器的项目，旨在帮助开发者通过自己动手编写代码来深入理解Tomcat的工作原理和内部机制。这个项目涵盖了从基础的HTTP服务器到复杂的Servlet容器的...
手写 tomcat nio
01-22
在深入探讨手写Tomcat NIO之前，我们首先需要理解NIO（Non-blocking I/O）的概念。NIO是Java提供的一个用于替代传统I/O模型（即BIO，Blocking I/O）的库。在BIO中，每个连接都需要一个单独的线程进行处理，当并发...
手写 tomcat IDEA工程
11-07
在手写Tomcat时，你需要实现一个Servlet容器，管理Servlet的生命周期，包括加载、初始化、服务和销毁等阶段。 4. **静态资源与动态资源**：静态资源通常是HTML、CSS、JavaScript等文件，它们可以直接发送给客户端；...
手写简易Tomcat
Java新生代
12-27 1270
通过手写tomcat对java中的网络通信有了更进一步的了解
手写简易tomcat
05-15
想学习web服务器的可以来看看，写的很基础，内容很详细，有源码和相关说明
手写实现一个迷你版的Tomcat
weixin_33850015的博客
09-18 255
Tomcat，这只3脚猫，大学的时候就认识了，直到现在工作中，也常会和它打交道。这是一只神奇的猫，今天让我来抽象你，实现你！ Tomcat是非常流行的Web Server，它还是一个满足Servlet规范的容器。那么想一想，Tomcat和我们的Web应用是什么关系？ 从感性上来说，我们一般需要把Web应用打成WAR包部署到Tomcat中，在我们的We...
简单手写Tomcat
weixin_43738352的博客
01-09 140
public class TestServer { //获取项目的绝对路径 private static String web_root = System.getProperty("user.dir") + "\\" + "WebRoot"; //资源名 private static String url = ""; //保存配置信息的map集合 private static M...
手写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、付费专栏及课程。

余额充值