精华内容
下载资源
问答
  • Tomcat底层原理实现
    2020-01-31 22:17:51

    一、Tomcat原理总结

    1. Tomcat需要main方法启动。
    2. Tomcat需要监听本机上的某个端口。
    3. Tomcat需要抓取此端口上来自客户端的链接并获得请求调用的方法与参数。
    4. Tomcat需要根据请求调用的方法,动态地加载方法所在的类,完成累的实例化并通过该实例获得需要的方法最终将请求传入方法执行。
    5. 将结果返回给客户端(jsp/html页面、json/xml字符串)

    二、Tomcat运行原理分析

    1. Tomcat是运行在JVM中的一个进程。它定义为【中间件】,顾名思义,是一个在Java项目与JVM之间的中间容器。
    2. Web项目的本质,是一大堆的资源文件和方法。Web项目没有入口方法(main方法),,意味着Web项目中的方法不会自动运行起来。
    3. Web项目部署进Tomcat的webapp中的目的是很明确的,那就是希望Tomcat去调用 写好的方法去为客户端返回需要的资源和数据。
    1. Tomcat可以运行起来,并调用写好的方法。那么,Tomcat一定有一个main方法。
    2. 对于Tomcat而言,它并不知道我们会有什么样的方法,这些都只是在项目被部署进webapp下后才确定的,由此分析,必然用到了Java的反射来实现类的动态加载、实例化、获取方法、调用方法。但是我们部署到Tomcat的中的Web项目必须是按照规定好的接口来进行编写,以便进行调用
      6.Tomcat如何确定调用什么方法呢。这取决于客户端的请求,http://127.0.0.1:8080/Test.Tomcat.Study/index.java?show这样的一个请求,通过http协议,在浏览器发往本机的8080端口,携带的参数show方法,包含此方法的路径为Test.Tomcat.Study,文件名为:index.java。

    tomcat
      |—bin:存放启动和关闭tomcat脚本
      |—conf:存放不同的配置文件(server.xml和web.xml);
      |—doc:存放Tomcat文档;
      |—lib/japser/common:存放Tomcat运行需要的库文件(JARS);
      |—logs:存放Tomcat执行时的LOG文件;
      |—src:存放Tomcat的源代码;
      |—webapps:Tomcat的主要Web发布目录(包括应用程序示例);
      |—work:存放jsp编译后产生的class文件;

    服务器端(tomcat):
    1、使用SocketServer创建一个套接字连接服务。
    2、监听端口号,例如这里的8080端口。
    3、通过套接字服务,获取inputStream输入流,可以理解为request。
    4、通过输入流(request)获取请求的信息。
    5、处理获取出来的输入流信息,使用反射生成访问的处理类对象,用来调用访问的方法。
    6、通过套接字得到outputStream输出流,可以理解成response,通过输出流给出响应信息。

    客户端(浏览器访问):
    1、使用Socket创建一个连接,访问一个路径和一个端口号,也就是用户在浏览器中输入网址的过程。
    2、使用socket获取输出流,这里的输出流可以理解成request对象。
    3、如果要获取发服务器响应的内容则通过,socket获取inputStream输入流,读取管道中的数据就可以。

    更多相关内容
  • 主要介绍了Tomcat 热部署的实现原理详解的相关资料,需要的朋友可以参考下
  • Tomcat实现原理

    千次阅读 2019-03-10 12:08:05
    今天我们来介绍一下,tomcat和web项目之间的关系? 我们先来介绍一下Tomcat,先提出一个问题,为什么需要tomcat? 在开发java应用程序的时候,我们都要写一个main方法,用于运行开发人员所编写的java代码,这个main...

    今天我们来介绍一下,tomcat和web项目之间的关系?

     
    我们先来介绍一下Tomcat,先提出一个问题,为什么需要tomcat
        在开发java应用程序的时候,我们都要写一个main方法,用于运行开发人员所编写的java代码,这个main方法也称为应用程序的主入口。

        在开发web项目的时候呢,我们并没有类似于main方法的入口,也就是说我们所写的web项目没有办法运行。这时候服务器(tomcat)出现了,开发人员可以将web项目发布在tomcat中,借助tomcat运行。

        这时候又有一个问题,由于web项目和tomcat两者是互相独立的,那么tomcat怎么知道你要访问那些资源?
    答案:反射

    举个例子:
         tomcat启动的时候,会去扫描WebContent下的所有的资源,当然也包括web.xml文件,开发人员在web.xml文件中配置的servletfilterlistener等一系列组件,都会"告知"Context,包括web项目中整个项目的文件信息,Context都事先"知晓"它们的存在。
         这时候项目已经发布在tomcat中了,一切的准备工作也做好了。当用户在浏览器中输入一个网址。例如:
    127.0.0.1:8080/Test/indexServlet?method=add&userName=admin

    下面解释一下这个请求:

    127.0.0.1:表示我们要访问的主机地址。
    8080:我们要访问的端口服务。
    Test:访问的项目名。
    indexServlet:接受处理的角色。
    method=add:要做什么事情。
    userName=admin:做这件事情所需要参数,或者说 做事情所需要的"东西"。
    

        tomcat根据request可以获取到所有和请求有关的信息,根据这个路径就去访问到了这个项目,然后通过你访问处理角色也就是indexServlet,这时候强大的反射就派上用场了,tomcat通过反射工厂模式 根据indexServlet这个名字,去创建servlet处理类这里tomcat是如何找到indexServlet这个类的呢? 前面有提到ContextContext知晓所有的文件是否存在,这时候就可以创建出来indexSerlvet所对应的对象了。既然这个对象有了,该对象中的方法也都可以使用反射的方式去调用了。

        当我们请求完之后,tomcat肯定会给我们一个答复。response将处理的结果返回给用户。整个请求和响应之间的过程,称之为一个会话(session),整个tomcat的运行流程及用户访请求,服务器响应就讲完了。



    上面一直有提到tomcat,request,response等。

    下面来讲一下这几个组件的实现。
    tomcat的实现,这里模拟一下实现原理

    服务器端(tomcat):
    1、使用SocketServer创建一个套接字连接服务。
    2、监听端口号,例如这里的8080端口。
    3、通过套接字服务,获取inputStream输入流,可以理解为request。
    4、通过输入流(request)获取请求的信息。
    5、处理获取出来的输入流信息,使用反射生成访问的处理类对象,用来调用访问的方法。
    6、通过套接字得到outputStream输出流,可以理解成response,通过输出流给出响应信息。

    以上就是模拟实现获取请求和给出响应的实现原理。


    客户端(浏览器访问):
    1、使用Socket创建一个连接,访问一个路径和一个端口号,也就是用户在浏览器中输入网址的过程。
    2、使用socket获取输出流,这里的输出流可以理解成request对象。
    3、如果要获取发服务器响应的内容则通过,socket获取inputStream输入流,读取管道中的数据就可以。


    以上就是模拟浏览器发出请求并接受响应的过程。
        实际上在tomcat中,request和response的实现方式也是与上面模拟的十分类似;只是tomcat对其进行了封装,让开发人员可以更友好的使用。







    希望以上的内容对你有所帮助

    展开全文
  • tomcat服务器工作原理

    2018-12-28 11:38:12
    更深入的了解tomcat服务器的运行机制 更好的了解底层技术实现
  • SpringBoot内嵌Tomcat实现原理解析

    万次阅读 2020-10-06 21:04:49
    从源码角度出发,剖析SpringBoot中内嵌Tomcat原理,讨论Tomcat何时创建、何时启动以及怎么启动。

    一、序言

    使用SpringBoot经常会使用内嵌的tomcat做为项目的启动容器,本文将从源码的角度出发,剖析SpringBoot内嵌Tomcat的实现原理,讨论Tomcat何时创建、何时启动以及怎么启动。

    二、引入Tomcat组件

    导入依赖:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    

    项目启动:

    @SpringBootApplication
    public class Application {
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }
    

    以上是一段常见的SpringBoot项目依赖和启动的代码。引入spring-boot-starter-web同时会默认引入spring-boot-starter-tomcat,即Tomcat启动的相关环境。而对于项目启动代码,@SpringBootApplication主要实现Spring组件扫描和自动配置。该注解是复合注解,其中@EnableAutoConfiguration本身也是一个复合注解,包含以下内容:

    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration {
    }
    

    这两个注解比较关键。@AutoConfigurationPackage主要实现自动配置包,会扫描@SpringbootApplication标注的类所在包名及其子包,将创建的组件添加到容器中;而@Import则是导入了AutoConfigurationImportSelector.class,实现查找classpath上所有jar包中的META-INF/spring.factories,找出其中的自动配置类并导入到容器中,其中Web容器所对应的自动配置类为ServletWebServerFactoryAutoConfiguration。

    在这里插入图片描述
    ServletWebServerFactoryAutoConfiguration中支持好几种web容器,比如Tomcat、Jetty和Undertow。

    在这里插入图片描述
    而EmbeddedTomcat则是Tomcat组件相关的类,本身是一个FactoryBean,用来实例化TomcatServletWebServerFactory。此时TomcatServletWebServerFactory中就包含了创建和启动Tomcat的方法getWebServer()。

    在这里插入图片描述

    三、Tomcat组件启动

    SpringBoot是在项目启动的时候才同时启动Tomcat的,很显然getWebServer()是在项目启动的过程中调用的。跟踪SpringApplication的run(),其中存在refreshContext(context),此时主要完成容器的刷新。

    在这里插入图片描述
    容器刷新跟踪到最后是AbstractApplicationContext中的onRefresh(),显然这是一个钩子函数,应用了模板方法,查看所有的实现方法,其中有一个ServletWebServerApplicationContext,则是当前Web容器的实现。

    在这里插入图片描述

    而ServletWebServerApplicationContext中主要是去获得ServletWebServerFactory对象,同时调用getWebServer创建WebServer对象。

    在这里插入图片描述
    此时,主要处理的是Tomcat容器对象的创建、环境配置和启动。

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

    四、总结

    到这里,基本就走完了内嵌Tomcat创建启动的整个流程。其实核心主要还是依赖于SpringBoot的自动配置。项目启动的过程中,扫描classpath下的META-INF/spring.factories,实例化工厂对象TomcatServletWebServerFactory,在调用run()方法的时候完成Tomcat对象的创建,环境设置和启动,从而实现Tomcat容器的自动化处理。

    展开全文
  • 在本地eclipse上创建一个tomcat server即tomcat服务器时, 会复制一份tomca安装目录中的conf文件下的配置文件到这个tomcatserver目录下 这个tomcatserver目录在workspaces路径,跟其他project同路径 文件如下,这些...
  • 深入理解 Tomcat(三)Tomcat 底层实现原理

    万次阅读 多人点赞 2017-11-29 00:18:09
    又是一个周末,这篇文章将从一个简单的例子来理解tomcat的底层设计;本文将介绍 Java Web 服务器是如何运行的, Web 服务器也称为超文本传输协议( HyperText Transfer Protocol, HTTP)服务器, 因为它使用 Http 与其...

    又是一个周末,这篇文章将从一个简单的例子来理解tomcat的底层设计;

    本文将介绍 Java Web 服务器是如何运行的, Web 服务器也称为超文本传输协议( HyperText Transfer Protocol, HTTP)服务器, 因为它使用 Http 与其客户端(通常是 Web 浏览器)进行通信, 基于 Java 的 Web 服务器会使用两个重要的类: java.net.Socket 类和 java.net.ServerSocket 类, 并通过发送 Http 消息进行通信. 我们先花一些篇幅介绍 Http 协议(如果同学们熟悉HTTP协议可直接跳过)和这两个类, 然后写一个简单的 Web 服务器.

    HTTP

    Http : Http 允许 Web 服务器和浏览器通过 Internet 发送并接受数据, 是一种基于”请求—响应”的协议, 客户端请求一个文件, 服务器端对该请求进行响应. Http 使用可靠的 tcp 连接, tcp 协议默认使用 tcp 80端口, http协议的第一个版本是 http/0.9, 后来被 http/1.0取代, 随后 http/1.0又被http/1.1取代, http/1.1 定义域 RFC(Request for Comment, 请求注解)2616中.

    如果各位对 Http1.1 有更多兴趣, 请阅读 RFC 2616.

    在 Http 中, 总是由客户端通过建立连接并发送 http 请求来初始化一个事务的. Web 服务器端并不负责联系客户端或建立一个到客户端的回调连接.客户端或服务器端可提前关闭连接, 例如, 当使用 Web 浏览器浏览网页时, 可以单击浏览器上的 stop 按钮来停止下载文件, 这样就有效的关闭了一个 Web 服务器的 http 连接.

    HTTP 请求

    一个 HTTP 请求包含以下三部分:
    * 请求方法—-统一资源标识符(Uniform Resource Identifier, URI)——协议/版本
    * 请求头
    * 实体

    下面是一个 HTTP 请求的例子:

    POST /examples/default.jsp HTTP/1.1 
    Accept: text/plain; text/html 
    Accept-Language: en-gb 
    Connection: Keep-Alive 
    Host: localhost 
    User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)
    Content-Length: 33 Content-Type: application/x-www-form-urlencoded Accept-Encoding: gzip, deflate 
    
    lastName=Franks&firstName=Michael  
    

    方法—统一资源标识符(URI)—协议/版本出现在请求的第一行。
    POST /examples/default.jsp HTTP/1.1

    这里 POST 是请求方法,/examples/default.jsp 是 URI,而 HTTP/1.1 是协议/版本部分。 每个 HTTP 请求可以使用 HTTP 标准里边提到的多种方法之一。HTTP 1.1 支持 7 种类型的请 求:GET, POST, HEAD, OPTIONS, PUT, DELETE 和 TRACE。GET 和 POST 在互联网应用里边最普遍使用的。

    URI 完全指明了一个互联网资源。URI 通常是相对服务器的根目录解释的。因此,始终一斜 线/开头。统一资源定位器(URL)其实是一种 URI(查看 http://www.ietf.org/rfc/rfc2396.txt)
    来的。该协议版本代表了正在使用的 HTTP 协议的版本。

    请求的头部包含了关于客户端环境和请求的主体内容的有用信息。例如它可能包括浏览器设 置的语言,主体内容的长度等等。每个头部通过一个回车换行符(CRLF)来分隔的。

    对于 HTTP 请求格式来说,头部和主体内容之间有一个回车换行符(CRLF)是相当重要的。CRLF 告诉HTTP服务器主体内容是在什么地方开始的。在一些互联网编程书籍中,CRLF还被认为是HTTP 请求的第四部分。

    在前面一个 HTTP 请求中,主体内容只不过是下面一行:

    lastName=Franks&firstName=Michael

    实体内容在一个典型的 HTTP 请求中可以很容易的变得更长。

    HTTP 响应

    类似于 HTTP 请求,一个 HTTP 响应也包括三个组成部分:
    * 方法—统一资源标识符(URI)—协议/版本
    * 响应的头部
    * 主体内容

    下面是一个 HTTP 响应的例子:

    HTTP/1.1 200 OK 
    Server: Microsoft-IIS/4.0 
    Date: Mon, 5 Jan 2004 13:13:33 GMT 
    Content-Type: text/html 
    Last-Modified: Mon, 5 Jan 2004 13:13:12 GMT 
    Content-Length: 112 
    
    <html> 
        <head> 
            <title>HTTP Response Example</title> 
        </head> 
        <body> 
            Welcome to Brainy Software 
        </body> 
    </html> 

    响应头部的第一行类似于请求头部的第一行。第一行告诉你该协议使用 HTTP 1.1,请求成 功(200=成功),表示一切都运行良好。

    响应头部和请求头部类似,也包括很多有用的信息。响应的主体内容是响应本身的 HTML 内 容。头部和主体内容通过 CRLF 分隔开来。

    Socket 类

    套接字是网络连接的一个端点。套接字使得一个应用可以从网络中读取和写入数据。放在两 个不同计算机上的两个应用可以通过连接发送和接受字节流。为了从你的应用发送一条信息到另 一个应用,你需要知道另一个应用的 IP 地址和套接字端口。在 Java 里边,套接字指的是java.net.Socket类。

    要创建一个套接字,你可以使用 Socket 类众多构造方法中的一个。其中一个接收主机名称 和端口号:

    public Socket (java.lang.String host, int port)

    在这里主机是指远程机器名称或者 IP 地址,端口是指远程应用的端口号。例如,要连接 yahoo.com 的 80 端口,你需要构造以下的 Socket 对象:

    new Socket ("yahoo.com", 80);

    一旦你成功创建了一个 Socket 类的实例,你可以使用它来发送和接受字节流。要发送字节 流,你首先必须调用Socket类的getOutputStream方法来获取一个java.io.OutputStream对象。 要 发 送 文 本 到 一 个 远 程 应 用 , 你 经 常 要 从 返 回 的 OutputStream 对 象 中 构 造 一 个 java.io.PrintWriter 对象。要从连接的另一端接受字节流,你可以调用 Socket 类的 getInputStream 方法用来返回一个 java.io.InputStream 对象。

    ServerSocket 类

    Socket 类代表一个客户端套接字,即任何时候你想连接到一个远程服务器应用的时候你构 造的套接字,现在,假如你想实施一个服务器应用,例如一个 HTTP 服务器或者 FTP 服务器,你 需要一种不同的做法。这是因为你的服务器必须随时待命,因为它不知道一个客户端应用什么时 候会尝试去连接它。为了让你的应用能随时待命,你需要使用 java.net.ServerSocket 类。这是 服务器套接字的实现。

    ServerSocket 和 Socket 不同,服务器套接字的角色是等待来自客户端的连接请求。一旦服 务器套接字获得一个连接请求,它创建一个 Socket 实例来与客户端进行通信。

    要创建一个服务器套接字,你需要使用 ServerSocket 类提供的四个构造方法中的一个。你 需要指定 IP 地址和服务器套接字将要进行监听的端口号。通常,IP 地址将会是 127.0.0.1,也 就是说,服务器套接字将会监听本地机器。服务器套接字正在监听的 IP 地址被称为是绑定地址。 服务器套接字的另一个重要的属性是 backlog,这是服务器套接字开始拒绝传入的请求之前,传 入的连接请求的最大队列长度。

    其中一个 ServerSocket 类的构造方法如下所示:

    java
    public ServerSocket(int port, int backLog, InetAddress bindingAddress);

    应用程序

    如果同学们下载过我们在第一篇文章提供的源码(How Tomcat Works)的话, 我们可以看一看我们的目录:

    我们的 web 服务器应用程序放在 cxs01.pyrmont(编译的时候因为错误改名字了,也就懒得改回来了) 包里边,由三个类组成:
    * HttpServer
    * Request
    * Response

    这个应用程序的入口点(静态 main 方法)可以在 HttpServer 类里边找到。main 方法创建了 一个 HttpServer 的实例并调用了它的 await 方法。await 方法,顾名思义就是在一个指定的端 口上等待 HTTP 请求,处理它们并发送响应返回客户端。它一直等待直至接收到 shutdown 命令。

    应用程序不能做什么,除了发送静态资源,例如放在一个特定目录的 HTML 文件和图像文件。 它也在控制台上显示传入的 HTTP 请求的字节流。不过,它不给浏览器发送任何的头部例如日期 或者 cookies。

    下面我们来看看我们今天的重点,这三个类,也就是tomcat的雏形代码
    HttpServer 类

    HttpServer 类代表一个 web 服务器,也就是程序的入口,看代码:

    public class HttpServer {
      public static final String WEB_ROOT =
        System.getProperty("user.dir") + File.separator  + "webroot";
    
      // 关闭命令
      private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
    
      // 是否关闭
      private boolean shutdown = false;
    
      public static void main(String[] args) {
        HttpServer server = new HttpServer();
        server.await();
      }

    main 方法中创建了一个HttpServer对象,并调用了该对象的await方法。看名字,该方法应该是等待http请求之类的东东。我们来看看方法内部:

    public void await() {
        ServerSocket serverSocket = null;
        int port = 8080;
        try {
          // 创建一个socket服务器
          serverSocket =  new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
        }
        catch (IOException e) {
          e.printStackTrace();
          System.exit(1);
        }
    
        // 循环等待http请求
        while (!shutdown) {
          Socket socket = null;
          InputStream input = null;
          OutputStream output = null;
          try {
            // 阻塞等待http请求
            socket = serverSocket.accept();
            input = socket.getInputStream();
            output = socket.getOutputStream();
    
            // 创建一个Request对象用于解析http请求内容
            Request request = new Request(input);
            request.parse();
    
            // 创建一个Response 对象,用于发送静态文本
            Response response = new Response(output);
            response.setRequest(request);
            response.sendStaticResource();
    
            // 关闭流
            socket.close();
    
            //检查URI中是否有关闭命令
            shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
          }
          catch (Exception e) {
            e.printStackTrace();
            continue;
          }
        }
      }

    我们看到,该方法创建了一个Socket服务器,并循环阻塞监听http请求,当有http请求到来时, 该方法便创建一个Request对象,构造参数是socket获取的输入流对象, 用于读取客户端请求的数据并解析。 然后再创建一个Response对象,构造参数是socket的输出流对象, 并含有一个Request对象的成员变量。Response对象用于将静态页面发送给浏览器或者是其他的客户端。最后, 该方法校验请求中是否含有关闭命令的字符串,如果有,就停止服务器的运行。

    这就是一个简单的服务器, 当我第一次看到的时候,心想: 真TMD简单啊。原来没那么复杂嘛。我想同学们心里想的跟我也一样吧。so, 不论多么庞大的代码,底层原理都是很简单的,只要我们学好了基础,学习起来就会轻松很多。

    废话不多说,我们继续看看Request 是如何解析Http请求的吧。

    Request 类

    类结构图如下:
    image

    Request 类代表一个 HTTP 请求。从负责与客户端通信的 Socket 中传递过来 InputStream 对象来构造这个类的一个实例。你调用 InputStream 对象其中一个 read 方法来获 取 HTTP 请求的原始数据。其中最主要的方法就是parse 和 parseUri ,他们用于逐个解析每个从客户端传递过来的字节,我们先看parse方法:

      public void parse() {
        // Read a set of characters from the socket
        StringBuffer request = new StringBuffer(2048);
        int i;
        byte[] buffer = new byte[2048];
        try {
          // 读取流中内容
          i = input.read(buffer);
        }
        catch (IOException e) {
          e.printStackTrace();
          i = -1;
        }
        for (int j=0; j<i; j++) {
         // 将每个字节转换为字符
          request.append((char) buffer[j]);
        }
        // 打印字符串
        System.out.print(request.toString());
        // 根据转换出来的字符解析URI
        uri = parseUri(request.toString());
      }

    我们也看到该方法是十分的简单, 创建一个StringBuffer 对象,然后从流中读取字节,然后循环将字节转成字符写入到Stringbuffer对象中。最后传入到parseUri方法中进行解析。

    我们再看看parseUri方法, 这个方法中,我们前面学习的关于HTTP的知识会起作用:

      private String parseUri(String requestString) {
        int index1, index2;
        // 找到第一个空格
        index1 = requestString.indexOf(' ');
        if (index1 != -1) {
          // 找到第二个空格
          index2 = requestString.indexOf(' ', index1 + 1);
          if (index2 > index1)
            // 截取第一个空格到第二个空格之间的内容
            return requestString.substring(index1 + 1, index2);
        }
        return null;
      }
    

    该方法从请求行里边获得 URI。parseUri 方法搜索请求里边的第一个和第二个空格并从中获取 URI。
    为什么是第一个空格和第二个空格之间的内容呢?我们看看前面的Http请求的例子:

    POST /examples/default.jsp HTTP/1.1 
    Accept: text/plain; text/html 
    Accept-Language: en-gb 
    Connection: Keep-Alive 
    Host: localhost 
    User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)
    Content-Length: 33 Content-Type: application/x-www-form-urlencoded Accept-Encoding: gzip, deflate 
    
    lastName=Franks&firstName=Michael  

    我们看第一行:

    POST 和 HTTP/1.1之间的就是我们需要的URI。so, 我们只需要将中间那段字符串截取就OK了。

    我们总结一下Request类,这个类其实就是解析HTTP 消息头内容的,先将流中数据转成字节,然后将转成字符,最后将字符解析,得到自己感兴趣的内容。奏是这么简单。好了,我们再看看Response类。看看他是怎么实现的。

    Response类

    我们先看看这个类的结构图:

    Response 代表了Http请求中的一个响应。我们关注其中的 sendStaticResource 方法,看名字,该方法应该是发送静态资源给客户端。我们看看代码:

      public void sendStaticResource() throws IOException {
        byte[] bytes = new byte[BUFFER_SIZE];
        FileInputStream fis = null;
        try {
          File file = new File(HttpServer.WEB_ROOT, request.getUri());
          if (file.exists()) {
            // 文件存在则从输出流中输出
            fis = new FileInputStream(file);
            int ch = fis.read(bytes, 0, BUFFER_SIZE);
            while (ch!=-1) {
              output.write(bytes, 0, ch);
              ch = fis.read(bytes, 0, BUFFER_SIZE);
            }
          }
          else {
            // 没有文件返回404
            String errorMessage = "HTTP/1.1 404 File Not Found\r\n" +
              "Content-Type: text/html\r\n" +
              "Content-Length: 23\r\n" +
              "\r\n" +
              "<h1>File Not Found</h1>";
            output.write(errorMessage.getBytes());
          }
        }
        catch (Exception e) {
          // thrown if cannot instantiate a File object
          System.out.println(e.toString() );
        }
        finally {
          if (fis!=null)
            fis.close();
        }
      }

    可以看到,该方法也非常的简单, sendStaticResource 方法是用来发送一个静态资源,例如一个 HTML 文件。它首先通过传递 上一级目录的路径和子路径给 File 累的构造方法来实例化 java.io.File 类。

    然后它检查该文件是否存在。假如存在的话,通过传递 File 对象让 sendStaticResource 构造一个 java.io.FileInputStream 对象。然后,它调用 FileInputStream 的 read 方法并把字 节数组写入 OutputStream 对象。请注意,这种情况下,静态资源是作为原始数据发送给浏览器 的。

    假如文件并不存在,sendStaticResource 方法发送一个错误信息到浏览器

    运行程序,启动HttpServer mian方法,使用Edge浏览器在地址栏敲入:http://localhost:8080/index.html
    返回:

    表示文件存在, 再看看我们的后台控制台:

    如期打印了http请求头中的内容。并且下面还请求了一张图片。

    总结

    至此,我们已经知道了一个简单的Web服务器是如何工作的。破除了我们之前的疑惑,实际上tomcat底层就是这么实现的,可能关于阻塞IO和非阻塞NIO会有区别,但总体上还是这个思路,然后其余的组件都是针对优化性能,提高扩展性来设计新的架构。所以,我们明白了底层设计,再去学习他的设计,就不会那么迷茫。从而感到泄气。毕竟每个夜晚,我们孤独的学习,不想徒劳无功。

    好了,本文结束!!! good luck !!!

    展开全文
  • tomcat工作原理(基本过程)

    千次阅读 2020-01-26 21:52:09
    tomcat工作原理铺垫知识tomcat工作原理tomcat工作流程图 今天嘞,我们来粗略的谈一下tomcat的工作原理,希望有错误的地方请大家积极指出! 铺垫知识 emmm,在说之前我先说一下基本的铺垫知识吧。 tomcat是使用java...
  • tomcat原理解析(一):一个简单的实现

    万次阅读 多人点赞 2017-03-07 09:54:27
     前段时间去面试,被人问到了tomcat实现原理。由于平时没怎么关注容器的实现细节,这个问题基本没回答上来。所以最近花了很多时间一直在网上找资料和看tomcat的源码来研究里面处理一个HTTP请求的流程。 二 一个简单...
  • Springboot内置tomcat原理

    2020-08-16 01:11:32
    内置tomcatspringmvc注解版结合tomcat springmvc注解版 时下非常火的Springboot,有个非常好用的内置tomcat,其实并不是什么非常新的技术,而是对Spring的一层包装。完成一个springmvc注解版,打开官网关于springmvc...
  • Tomcat原理及架构

    万次阅读 多人点赞 2018-05-18 19:43:25
    转自:https://zhuanlan.zhihu.com/p/35398064俗话说,站在巨人的肩膀上看世界,...找到了 Tomcat最核心的模块,问题才可以游刃而解,了解了Tomcat的整体架构对以后深入了解Tomcat来说至关重要!一、Tomcat顶层架...
  • Tomcat工作原理

    2020-06-09 23:01:40
    Tomcat是什么 Tomcat 服务器是一个免费的开放源代码的Web 应用服务器,属于轻量级应用服务器,在中小型系统和并发访问用户不是很多的场合下被普遍使用,是开发和调试JSP 程序的首选。 web服务器按功能分类可分为:...
  • Tomcat 的线程池实现原理

    千次阅读 2021-02-02 12:55:38
    一个激进创建线程的弹性线程池更符合我们的需求,你能给出相关的实现吗?实现后再测试一下,是否所有的任务都可以正常处理完成呢? 既然选择先扩容线程池再加入队列,那为什么不干脆把核心线程数设置大一些,然后...
  • Tomcat底层原理

    千次阅读 2019-11-06 11:02:21
    一、Tomcat启动时到底对我们的应用程序做了什么? 当我们把一个应用程序的war包放到Tomcat的webapps目录后,启动Tomcat,然后就可以通过浏览器发送Http请求访问该war包内的Servlet了。 这个过程包括: 1、启动...
  • 要在运行的过程中升级Web应用,如果你不想重启系统,实现的方式有两种:热加载和热部署。 如何实现热部署、热加载? ...Tomcat实现热加载、热部署 Tomcat通过开启后台线程,使得各个层次的容器组件
  • tomcat实现热部署

    2019-05-26 01:07:15
    NULL 博文链接:https://lhgyy00.iteye.com/blog/494086
  • Tomcat运行原理

    千次阅读 2019-07-15 22:52:20
    Tomcat服务器本质 Tomcat是运行在JVM中的一个进程。通过处理scoket通信 (Socket) 来运行。 Web项目的本质,是一大堆的资源文件和方法。Web项目没有入口方法(main方法),意味着Web项目中的方法不会自动运行起来。...
  • Tomcat集群Cluster实现原理剖析.doc
  • 一、初识Tomcat; 二、Tomcat与jdk的关系; 三、Tomcat内部工作原理; 四、Tomcat配置文件详解; 五、案例:搭建Tomcat案例;
  • 一、 Tomcat JNDI JNDI(java nameing and drectory interface),是一组在Java应用中访问命名和服务的API,所谓命名服务,即将对象和名称联系起来,使得可以通过名称访问并获取对象。 简单原理介绍:点击访问 ...
  • tomcat的工作原理

    2021-05-20 21:05:51
    本文源自转载:你还记得 Tomcat 的工作原理么 一、Tomcat 整体架构 Tomcat 是一个免费的、开源的、轻量级的 Web 应用服务器。适合在并发量不是很高的中小企业项目中使用。 二、文件目录结构 以下是 Tomcat 8 ...
  • tomcat + spring mvc原理(五):tomcat Filter组件实现原理前言:Wrapper中Pipeline的收尾Filter的基本实现FilterChain的实现 前言:     原理(四)中假装结束了tomcat消息处理的流程分析,其实...
  • 迷你版的Tomcat,利用socket的输入输出流,封装解析request,response对象
  • Tomcat原理

    千次阅读 多人点赞 2019-04-19 10:19:13
    Tomcat顶层架构 Tomcat的顶层结构图: 1、Tomcat中最顶层的容器是Server,代表着整个服务器,一个Server可以包含至少一个Service,用于具体提供服务。 2、Service主要包含两个部分:Connector和Container。 ...
  • tomcat的工作原理以及简介

    千次阅读 2020-07-13 21:11:02
    它的结构比较复杂,但是又比较模块化,所以只要我们找到了最核心的模块,对于tomcat的整体架构和工作原理就很好理解了。Connector(连接器)组件负责生成请求对象和响应对象的,Tomcat默认为HttpConnector,负责根据...
  • tomcat 工作原理

    2012-06-22 21:22:20
    够基础、够循序渐进,加上作者本身对tomcat的深入理解,所以行文中处处向读者传递着tomcat的设计思想,我想这才是大部分人研究tomcat所希望学到的

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,525
精华内容 45,010
关键字:

tomcat实现原理