手写一个迷你版本的Tomcat

最新推荐文章于 2023-09-22 21:44:58 发布
最新推荐文章于 2023-09-22 21:44:58 发布
阅读量216 收藏
点赞数
分类专栏： 训练 Tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ko0491/article/details/107329981
版权
训练 同时被 2 个专栏收录
139 篇文章 3 订阅
订阅专栏
Tomcat
17 篇文章 0 订阅
订阅专栏

迷你版本的Tomcat1.0

  • 达成目标 向浏览器输出字符
工具类
public class HttpProtocolUtil {

    /**
     * 200的响应头
     * @param length
     * @return
     */
    public static  String getHttpHeader200(long length){

        return "HTTP/1.1 200 OK"+"\n"+
                "Content-Type: text/html;charset=utf-8"+"\n"+
                "Content-Length: "+length+ "\n"+
                "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36"+"\n"
                +"\r\n";
    }

    /**
     * 404的响应头
     * @return
     */
    public static  String getHttpHeader404(){
            String str404 = "<h1>404 Not Found</h1>";
        return "HTTP/1.1 200 OK"+"\n"+
                "Content-Type: text/html;charset=utf-8"+"\n"+
                "Content-Length: "+str404.getBytes().length+ "\n"+
                "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36"+"\n"
                +"\r\n"+str404;
    }
}
启动类
public class BootStrap {

    private int port = 8080;


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

    /**
     * 启动MiniCat
     */
    private  void start() {
        ServerSocket serverSocket=null;
        try {
            //建立ServerSocket
             serverSocket = new ServerSocket(port);
            System.out.println("Mini Cat Start...");
             while (true){
                 //一直监听
                 Socket socket = serverSocket.accept();
                 //监听到之后就输出
                 String str="Hello MiniCat!";

                 String responseStr = HttpProtocolUtil.getHttpHeader200(str.getBytes().length)+str;
                 socket.getOutputStream().write(responseStr.getBytes());

                 socket.close();
             }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • 启动后访问 http://localhost:8080/
    在这里插入图片描述
2.0版本输出静态页面 index.html
  • 1.新建静态页面
    在Resources目录下新建index.html
    在这里插入图片描述

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Hello MiniCat Index</title>
</head>
<body>
<h1>Hello MiniCat Index</h1>
</body>
</html>

  • 2 封装Request 与Response

  • 将请求方法 请求路径 InputStream封装为 Request

Request URL: https://www.baidu.com/ Request Method: GET

在这里插入图片描述

public class Request {

    /**
     * 请求路径
     */
    private String url;
    /**
     * 请求方法
     */
    private String method;

    /**
     * 输入流
     */
    private InputStream inputStream;


    public Request(InputStream inputStream) {
        this.inputStream = inputStream;
        //通过InputStream解析出请求url与method
        doParse(inputStream);
    }

    private void doParse(InputStream inputStream) {
        try {
        int count = 0;
        while(count==0){
            //数据可能是空一直在读直到有数据
                count=inputStream.available();

        }
        //缓存区
            int available = inputStream.available();
            byte [] buffer = new byte[available];
            //将数据流读到数组中
            inputStream.read(buffer);
            //转换为字符串 -请求字符串
/*
            GET / HTTP/1.1
Host: www.baidu.com
Connection: keep-alive
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1

GET / HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: keep-alive
Upgrade-Insecure-Requests: 1
*/

            String requestStr = new String(buffer, StandardCharsets.UTF_8);
            //按换行符 分隔
            String[] split = requestStr.split("\n");
            //取第一行的请求url 与 method

            String[] header = split[0].split(" ");

            this.method=header[0];
            this.url=header[1];
            System.out.println(method);
            System.out.println(url);

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

    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }
}
  • 将OutputStream封装为Response

public class Response {

    private OutputStream outputStream;


    public Response(OutputStream outputStream) {
        this.outputStream = outputStream;
    }

    /**
     * 输出字符串内容
     * @param content
     */
    public void outputAny(String content){

        try {
            outputStream.write(content.getBytes("UTF-8"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 输出静态资源
     * @param path
     * @throws IOException
     */
    public void outputStatic(String path) throws IOException {
        //获取资源的对路径

        String absolutePath = StaticResource.getAbsolutePath(path);


        File file = new File(absolutePath);
        if(file.exists()&&file.isFile()){
            //输出静态资源
            StaticResource.outputStaticResource(new FileInputStream(file),outputStream);
        }else {
            //找不到资源
            outputAny(HttpProtocolUtil.getHttpHeader404());
        }
    }
}
  • 3 封装工具类

public class StaticResource {


    /**
     * 获取绝对路径
     * @param path
     * @return
     */
    public static String getAbsolutePath(String path) {

        String classedPath = StaticResource.class.getResource("/").getPath();

        return classedPath.replaceAll("\\\\","/")+path;
    }



    public static void outputStaticResource(FileInputStream inputStream, OutputStream outputStream) throws IOException {
        int count = 0;
        while(count == 0) {
            count = inputStream.available();
        }



        //资源大小
        int resourceSize = count;

        //请求头-先写请求头200，再写请求体

        outputStream.write(HttpProtocolUtil.getHttpHeader200(resourceSize).getBytes());

        //已经写的指针
        int writeCourse = 0;
        int byteSize = 1024;
        byte [] buf = new byte[byteSize];
        //写过的小于总大小就一直写
        while(writeCourse<resourceSize){

            //判断是不是写了
            if(writeCourse+byteSize>resourceSize){
                byteSize=resourceSize-writeCourse;
                buf = new byte[byteSize];
            }
            //开始读文件
            inputStream.read(buf);

            //写出
            outputStream.write(buf);
            //刷新
            outputStream.flush();

            //指针增加
            writeCourse+=byteSize;

        }


    }
}
  • 访问

在这里插入图片描述

在这里插入图片描述

自定义Servlet实现动态

public interface Servlet {

    public void init();

    public void service(Request request, Response response);


    public void destroy();

}
public abstract class HttpServlet  implements Servlet{

    protected abstract void doGet(Request request, Response response);
    protected abstract void doPost(Request request, Response response);

    @Override
    public void service(Request request, Response response) {
        if("GET".equals(request.getMethod())){
            doGet(request, response);
        }else {
            doPost(request, response);
        }
    }
}
  • 实现

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(Request request, Response response) {

        response.outputAny("HelloServlet doGet...");

    }

    @Override
    protected void doPost(Request request, Response response) {
        response.outputAny("HelloServlet doPost....");
    }

    @Override
    public void init() {

    }

    @Override
    public void destroy() {

    }
}
  • 在resources目录下新建web.xml

<web-app>
    <servlet>
        <servlet-name>helloServlet</servlet-name>
        <servlet-class>com.liu.me.servlet.me.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>helloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>
  • 改造启动类

public class BootStrap {

    private int port = 8080;

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

    public static void main(String[] args) {
        BootStrap bootStrap = new BootStrap();
        try {
            bootStrap.start();
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 启动MiniCat
     */
    private void start() throws DocumentException, IllegalAccessException, InstantiationException, ClassNotFoundException {
        //加载web.xml中配置的servlet
        loadServelt();

        ServerSocket serverSocket = null;
        try {
            //建立ServerSocket
            serverSocket = new ServerSocket(port);
            System.out.println("Mini Cat Start...");
            while (true) {
                //一直监听
                Socket socket = serverSocket.accept();
                //监听到之后就输出
//                String str = "Hello MiniCat!";

                 String responseStr = HttpProtocolUtil.getHttpHeader200(str.getBytes().length)+str;
                 socket.getOutputStream().write(responseStr.getBytes());
                Request request = new Request(socket.getInputStream());
                Response response = new Response(socket.getOutputStream());

                if(servletMap.get(request.getUrl())==null) {
                    //输出静态资源
                    response.outputStatic(request.getUrl());
                }else{
                    HttpServlet servlet = servletMap.get(request.getUrl());

                    servlet.service(request, response);
                }
                socket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private synchronized void loadServelt() throws DocumentException, ClassNotFoundException, IllegalAccessException, InstantiationException {

        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("web.xml");

        //使用dom4j解析
        Document document = new SAXReader().read(inputStream);

        //获取根标签
        Element rootElement = document.getRootElement();

        //获取所有Servlet标签
        List<Element> elements = rootElement.selectNodes("//servlet");

        //循环取出servletName,ServletClass 根据servlet-name去servlet-maping标签中找到一样的对象的url-patten

        for (Element element : elements) {
            //一个Servelt节点只会有一个Servlet-name 标签
            Node nameNode = element.selectSingleNode("servlet-name");
            //得到ServletName
            String servletName = nameNode.getStringValue();
            //获取servlet-class节点
            Node classNode = element.selectSingleNode("servlet-class");
            //得到ServletClass
            String servletClass = classNode.getStringValue();

            System.out.println("servletName  " + servletName);
            System.out.println("servletClass  " + servletClass);
            //根据servletName去servlet-mapping标签中servelt-name相等的节点
            // /bookstore/book[price>35.00] xpath语法
            Node MappingNode = rootElement.selectSingleNode("/web-app/servlet-mapping[servlet-name='" + servletName + "']");

            String mappingServeltName = MappingNode.selectSingleNode("servlet-name").getStringValue();
            String mappingUrlPatten = MappingNode.selectSingleNode("url-pattern").getStringValue();
            System.out.println("mappingServeltName " + mappingServeltName);
            System.out.println("mappingUrlPatten " + mappingUrlPatten);

            /**
             * 反射实例化放入容器中
             */

            Class<?> clazz = Class.forName(servletClass);
            HttpServlet servlet =(HttpServlet) clazz.newInstance();

            servletMap.put(mappingUrlPatten, servlet);
        }

    }
}
  • 启动访问

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

4.0版本使用线程与线程池
  • RequestProcessor

public class RequestProcessor extends Thread {

    private Socket socket;

     private Map<String, HttpServlet> servletMap;

    public RequestProcessor(Socket socket, Map<String, HttpServlet> servletMap) {
        this.socket = socket;
        this.servletMap = servletMap;
    }

    @Override
    public void run() {

        Request request = null;
        try {
            request = new Request(socket.getInputStream());
            Response response = new Response(socket.getOutputStream());

            if(servletMap.get(request.getUrl())==null) {
                //输出静态资源
                response.outputStatic(request.getUrl());
            }else{
                HttpServlet servlet = servletMap.get(request.getUrl());

                servlet.service(request, response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(socket.isConnected()){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }



    }
  • 改造启动类
public class BootStrap {

    private int port = 8080;

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

    public static void main(String[] args) {
        BootStrap bootStrap = new BootStrap();
        try {
            bootStrap.start();
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 启动MiniCat
     */
    private void start() throws DocumentException, IllegalAccessException, InstantiationException, ClassNotFoundException {
        //加载web.xml中配置的servlet
        loadServelt();

        BlockingQueue<Runnable> workQueue= new ArrayBlockingQueue<>(50);
        ThreadFactory threadFactory=Executors.defaultThreadFactory();
        RejectedExecutionHandler handle=new ThreadPoolExecutor.AbortPolicy();

        ThreadPoolExecutor threadPoolExecutor=
                new ThreadPoolExecutor(10, 50, 60, TimeUnit.SECONDS,
                        workQueue,threadFactory,handle);


        ServerSocket serverSocket = null;
        try {
            //建立ServerSocket
            serverSocket = new ServerSocket(port);
            System.out.println("Mini Cat Start...");
            while (true) {
                //一直监听
                Socket socket = serverSocket.accept();
                RequestProcessor requestProcessor = new RequestProcessor(socket,servletMap);

                threadPoolExecutor.execute(requestProcessor);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private synchronized void loadServelt() throws DocumentException, ClassNotFoundException, IllegalAccessException, InstantiationException {

        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("web.xml");

        //使用dom4j解析
        Document document = new SAXReader().read(inputStream);

        //获取根标签
        Element rootElement = document.getRootElement();

        //获取所有Servlet标签
        List<Element> elements = rootElement.selectNodes("//servlet");

        //循环取出servletName,ServletClass 根据servlet-name去servlet-maping标签中找到一样的对象的url-patten

        for (Element element : elements) {
            //一个Servelt节点只会有一个Servlet-name 标签
            Node nameNode = element.selectSingleNode("servlet-name");
            //得到ServletName
            String servletName = nameNode.getStringValue();
            //获取servlet-class节点
            Node classNode = element.selectSingleNode("servlet-class");
            //得到ServletClass
            String servletClass = classNode.getStringValue();

            System.out.println("servletName  " + servletName);
            System.out.println("servletClass  " + servletClass);
            //根据servletName去servlet-mapping标签中servelt-name相等的节点
            // /bookstore/book[price>35.00] xpath语法
            Node MappingNode = rootElement.selectSingleNode("/web-app/servlet-mapping[servlet-name='" + servletName + "']");

            String mappingServeltName = MappingNode.selectSingleNode("servlet-name").getStringValue();
            String mappingUrlPatten = MappingNode.selectSingleNode("url-pattern").getStringValue();
            System.out.println("mappingServeltName " + mappingServeltName);
            System.out.println("mappingUrlPatten " + mappingUrlPatten);

            /**
             * 反射实例化放入容器中
             */

            Class<?> clazz = Class.forName(servletClass);
            HttpServlet servlet =(HttpServlet) clazz.newInstance();

            servletMap.put(mappingUrlPatten, servlet);
        }

    }
森林森
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
清华大佬手把手带你完成微型tomcat（附源码）
Java架构师联盟
03-26 395
前言 Tomcat，这只3脚猫，大学的时候就认识了，直到现在工作中，也常会和它打交道。这是一只神奇的猫，今天让我来抽象你，实现你！ Write MyTomcat Tomcat是非常流行的Web Server，它还是一个满足Servlet规范的容器。那么想一想，Tomcat和我们的Web应用是什么关系？ 从感性上来说，我们一般需要把Web应用打成WAR包部署到Tomcat中，在我们的W...
手写一个Tomcat
一点思考
11-09 1万+
(参考了公众号：java架构沉思录中的文章：教你写一个迷你版的toncat 原文：https://www.jianshu.com/p/dcelee01fb90) 作为一个java学习的起步者，对tomcat的认识还是有很多的欠缺，在无意中发现了这篇文章，便在自己的环境下尝试搭建，收获良多： 分以下几个步骤： （1）提供Socket服务 （2）进行请求的转发 （3）把请求和响应封装成request/...
手写实现一个迷你版的Tomcat
weixin_33850015的博客
09-18 251
Tomcat，这只3脚猫，大学的时候就认识了，直到现在工作中，也常会和它打交道。这是一只神奇的猫，今天让我来抽象你，实现你！ Tomcat是非常流行的Web Server，它还是一个满足Servlet规范的容器。那么想一想，Tomcat和我们的Web应用是什么关系？ 从感性上来说，我们一般需要把Web应用打成WAR包部署到Tomcat中，在我们的We...
迷你版Tomcat手写
【欢迎关注公众号：冬瓜白】
10-09 508
分析 一般我们使用Servlet，需要在web.xml文件中配置： 然后写一个TestServlet继承HttpSerevlet，重写doGet()和doPost()方法。 这时难免会有这样的疑问： 总体： Request： package com.dongguabai.tomcat.http; import java.io.IOException; import ...
手写实现迷你版 Tomcat
cyd_0619的博客
11-04 948
  Minicat要做的事情：作为⼀个服务器软件提供服务的，也即我们可以通过浏览器客户端发送http请求，Minicat可以接收到请求进行处理，处理之后的结果可以返回浏览器客户端。 整体思路： （1）提供服务，接收请求（Socket通信） （2）请求信息封装成Request对象（Response对象） （3）客户端请求资源，资源分为静态资源（html）和动态资源（Servlet） （4）资源返回给客户端浏览器 我们递进式完成以上需求，提出V1.0、V2.0、V3.0版本的需求： V1.0需求：浏览器请求h
二.手写迷你版Tomcat-minicat2.0
螃蟹士兵
08-01 594
minicat 1.0我们实现了返回固定的字符串"Hello minicat"。 minicat 2.0需求： 封装Request和Response对象，返回html静态资源文件。 封装Request对象 想要封装Request对象，得要先知道请求信息里面有哪些数据，所以我们先打印请求信息。 /** * minicat启动需要初始化展开的一些操作 */ public void start() throws IOException { // 监听端口
手写一个简单的Tomcat
fenghuoliuxing990124的博客
11-30 770
首先tomcat的原理是什么？ 上面的图可以简化为： 这张图固然缺少了很多东西，但是却是tomcat实现功能的一个基本逻辑 简单的来说，就是用户发出一个请求，后台处理url，通过组合根地址，找到本地的资源地址，然后通过读取这个资源，将它的流输出到页面，这就是tomcat的简单原理 那如何实现呢？ 简单的来说：Tomcat由三个基本类组成 HttpServer Request Response...
手写基于NIO的迷你版tomcat
YipSouL的学习笔记
05-13 573
四月底瞄了几眼NIO，写了个聊天室小demo。今天中午回想了一下果然是忘了七七八八了，所以决定再写个小demo来勾起自己这条咸鱼的记忆。。。 BIO 同步阻塞IO, Block IO,IO操作会阻塞线程，并发处理能力低。 我们熟知的Socket编程就是BIO,一个Socket连接一个处理现线程（这个线程负责这个Socket连接的一系列数据传输操作）。阻塞的原因在于，操作系统允许的线程数量是优先的，...
手写迷你Tomcat升级版（含解题思路及完整代码）
舞鹤白沙编码日志
01-23 183
一. 题目要求 开发Minicat V4.0，在已有Minicat基础上进一步扩展，模拟出webapps部署效果 磁盘上放置一个webapps目录，webapps中可以有多个项目，例如demo1、demo2、demo3... 每个项目中含有servlet，可以根据请求url定位对应servlet进一步处理。具体的项⽬⽐如demo1中有serlvet（也即为：servlet是属于具体某⼀个项⽬的servlet），这样的话在Minicat初始化配置加载，以及根据请求url查找对应serlvet时都需要进⼀步.
从原理到代码一步步教你手写实现自定义迷你版SpringBoot
Harrison
03-09 894
文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 一、需求及实现原理 SpringBoot简而言之就是为了简化Spring应用开发而出现的一种框架（基于Spring4.0开发）。其约定优于配置的思想大大减少了XML配置项。 我们实现自定义的SpringBoot需求很简单，就是完成Tomcat的启动，整合SpringMVC（注册DispatcherServlet前端控制器，自动扫描Bean组件）。 我们抽取出两个问题进行具体分析： ...
Tomcat学习笔记
qq_44504035的博客
10-29 228
1. Tomcat 系统总体架构 Tomcat是⼀个Http服务器（能够接收并且处理http请求，所以tomcat是⼀个http服务器） 我们使用浏览器向某⼀个网站发起请求，发出的是Http请求，那么在远程，Http服务器接收到这个请求 之后，会调用具体的程序（Java类）进行处理，往往不同的请求由不同的Java类完成处理。即浏览器发送http请求到http服务器（Tomcat）调用接口，接口调用具体实现 HTTP 服务器接收到请求之后把请求交给Servlet容器来处理，Servlet 容器通过Se
关于Tomcat的简化打包插件——Small Tomcat
最新发布
From_C的博客
09-22 106
对于tomcat编程时，使用Small tomcat插件和不使用插件有什么区别？
Small Tomcat的配置
weixin_44943389的博客
07-12 94
Context Path : 上下文路径，选择Deployment后会自动识别，一般不用修改。Tomcat Server : Tomcat的路径，刚刚配置过的。VM options : Java虚拟机参数设置（可以不填写）Server Port : 端口号 8080（可以自己修改）Deployment : 当前项目的webapp路径。Name : 配置名称，可自行设置，一般用项目名。
一.手写迷你版Tomcat-初探minicat
螃蟹士兵
08-01 2571
大家都成年人了，大名鼎鼎的Tomcat不需要我过多介绍，直接上手写的思路和代码。 思路分析 名称：minicat minicat要做的事情：作为服务器软件提供服务的，也即我们可以通过浏览器客户端发送http请求，minicat可以接受到请求进行处理，处理之后的结果可以返回浏览器客户端。 提供服务，接收请求（Socket通信） 请求信息封装成Request对象（Response对象） 客户端请求资源，资源分为静态资源（html）和动态资源（Servlet） 资源返回给客户端浏览器 Minicat1.0版本
通过Tomcat / Small Tomcat，如何部署Servlet？（超详细）
CYK_byte的博客
11-19 3742
以下将会通过七个步骤，以打印“hello”为例，对Servlet进行部署；以下将会通过七个步骤，以打印“hello”为例，对Servlet进行部署；使用工具（这是配套使用的方案！）：idea2021或2020，jdk 8，Java Servlet API 3.1.0版本，Tomcat 8.5；
复制文件、文件夹;删除文件
hwh的博客
01-14 452
//复制的文件 public int copy(String fromFile, String toFile)     {         //要复制的文件目录         File[] currentFiles;         File root = new File(fromFile);         //如同判断SD卡是否存在或者文件是
开发Minicat V4.0，在已有Minicat基础上进一步扩展，模拟出webapps部署效果 磁盘上放置一个webapps目录，webapps中可以有多个项目，例如demo1、demo2、demo
weixin_52717390的博客
11-24 825
在minicat的resources目录下，增加server.xml配置文件 <?xml version="1.0" encoding="UTF-8" ?> <Server> <!--可以有多个service--> <Service> <Connector port="8080"/> <Engine> <Host name="localhost" appB
【Web服务器深度应用及调优01】之Tomcat深度剖析及性能调优
yuyangzhi10的博客
11-22 618
1、Tomcat系统架构与原理剖析 1.1 浏览器访问服务器的流程 1.1.1 http请求的处理过程图 1.1.2 http请求的处理过程说明 浏览器访问服务器使用的是Http协议，用于定义数据通信的格式 具体的数据传输使用的是TCP/IP协议 Http协议对应于应用层协议，Tcp/IP协议对应于传输层/网络层 1.1.3 协议分层 1.1.4 TCP的三次握手和四次挥手 三次握手 四次挥手 1.2 Tomcat系统总体架构 1.2.1 Tomcat请求处理大致过程 流程图 说明 Tomc
idea 配置tomcat server（解决没有tomcat server选项）
热门推荐
sinat_28530913的博客
04-28 9万+
1.2.点击+号，选择tomcat server - local3.进行参数的配置，选择安装的tomcat路径，jdk版本，jvm参数（内存参数），端口等。4.可能有的版本点击+号并没有出现tomcat server选项，此时进行如下操作，点击小扳手图标Edit Defaults出现Defaults选项5.展开Defaults列表，找到tomcat server 选项，选择Local，然后进行相关...
java手写tomcat
08-05
另外，手写Tomcat对于Java开发者来说是一个非常有挑战性的任务，需要对Java网络编程、Servlet规范、多线程等有深入的理解。如果只是为了学习和了解Tomcat的工作原理，可以尝试手写一个简化版的Tomcat，但如果是为了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值