精华内容
下载资源
问答
  • Servlet 容器

    2019-05-26 11:47:07
    Servlet 容器用来加载和管理业务类。 HTTP 服务器不直接跟业务类打交道,而是把请求交给 Servlet 容器去处理,Servlet 容器会将请求转发到具体的 Servlet,如果这个 Servlet 还没创建,就加载并实例化这个 Servlet...

    Servlet 容器用来加载和管理业务类。

    HTTP 服务器不直接跟业务类打交道,而是把请求交给 Servlet 容器去处理,Servlet 容器会将请求转发到具体的 Servlet,如果这个 Servlet 还没创建,就加载并实例化这个 Servlet,然后调用这个 Servlet 的接口方法。因此 Servlet 接口其实是Servlet 容器跟具体业务类之间的接口。因此 Servlet 接口和 Servlet 容器的出现,达到了 HTTP 服务器与业务类解耦的目的。

     

    Servlet 接口定义了下面五个方法:

    public interface Servlet {

        void init(ServletConfig config) throws ServletException; 

        ServletConfig getServletConfig();    

        void service(ServletRequest req, ServletResponse res)throws ServletException, IOException;   

        String getServletInfo();

        void destroy();

    }

    service

    service 方法是最重要的方法,具体业务类在这个方法里实现处理逻辑。这个方法有两个参数:ServletRequest 和 ServletResponse。ServletRequest 用来封装请求信息,ServletResponse 用来封装响应信息,因此本质上这两个类是对通信协议的封装。

    比如 HTTP 协议中的请求和响应就是对应了 HttpServletRequest 和 HttpServletResponse 这两个类。你可以通过 HttpServletRequest 来获取所有请求相关的信息,包括请求路径、Cookie、HTTP 头、请求参数等。此外,我在专栏上一期提到过,我们还可以通过 HttpServletRequest 来创建和获取 Session。而 HttpServletResponse 是用来封装 HTTP 响应的。

     

    init 和 destroy

    Servlet 容器在加载 Servlet 类的时候会调用 init 方法,在卸载的时候会调用 destroy 方法。我们可能会在 init 方法里初始化一些资源,并在 destroy 方法里释放这些资源,比如 Spring MVC 中的 DispatcherServlet,就是在 init 方法里创建了自己的 Spring 容器。

     

    ServletConfig

    作用就是封装 Servlet 的初始化参数。你可以在tomcat的 web.xml 给 Servlet 配置参数,并在程序里通过 getServletConfig 方法拿到这些参数。

     

    Servlet 规范提供了两种扩展机制:Filter和Listener

    Filter是过滤器,这个接口允许你对请求和响应做一些统一的定制化处理,比如你可以根据请求的频率来限制访问,或者根据国家地区的不同来修改响应内容。过滤器的工作原理是这样的:Web 应用部署完成后,Servlet 容器需要实例化 Filter 并把 Filter 链接成一个 FilterChain。当请求进来时,获取第一个 Filter 并调用 doFilter 方法,doFilter 方法负责调用这个 FilterChain 中的下一个 Filter。

     

    Listener是监听器,这是另一种扩展机制。当 Web 应用在 Servlet 容器中运行时,Servlet 容器内部会不断的发生各种事件,如 Web 应用的启动和停止、用户请求到达等。 Servlet 容器提供了一些默认的监听器来监听这些事件,当事件发生时,Servlet 容器会负责调用监听器的方法。当然,你可以定义自己的监听器去监听你感兴趣的事件,将监听器配置在 web.xml 中。比如 Spring 就实现了自己的监听器,来监听 ServletContext 的启动事件,目的是当 Servlet 容器启动时,创建并初始化全局的 Spring 容器。

     

    Filter 和 Listener 的本质区别:

    Filter 是干预过程的,它是过程的一部分,是基于过程行为的。

     

    参考来源:极客时间

    Listener 是基于状态的,任何行为改变同一个状态,触发的事件是一致的。

    展开全文
  • Servlet容器

    2016-10-25 15:38:16
    容器就是你的程序运行时需要的环境1,Tomcat是Servlet的运行环境,即一个Servlet容器。 2,Servlet容器的作用是负责处理客户请求,当客户请求来到时,Servlet容器获取请求,然后调用某个Servlet,并把Servlet的执行...

    容器就是你的程序运行时需要的环境

    1,Tomcat是Servlet的运行环境,即一个Servlet容器。

    2,Servlet容器的作用是负责处理客户请求,当客户请求来到时,Servlet容器获取请求,然后调用某个Servlet,并把Servlet的执行结果返回给客户。

    3,Servlet容器的工作过程是:当客户请求某个资源时,Servlet容器使用ServletRequest对象把客户的请求信息封装起来,然后调用Java Servlet API中定义的Servlet的一些生命周期方法,完成Servlet的执行,接着把Servlet执行的要返回给客户的结果封装到 ServletResponse对象中,最后Servlet容器把客户的请求发送给客户,完成为客户的一次服务过程。每一个Servlet的类都执行 init()、service()、destory()三个函数的自动调用,在启动时调用一次init()函数用以进行参数的初始化,在服务期间每当接收到对该Servlet的请求时都会调用Service()函数执行该Servlet的服务操作,当容器销毁时调用一次destory()函数。

    4,典型的Servlet应用是监听器、过滤器的实现。

    JSP运行原理:当Web服务器上的JSP页面第一次被请求执行时,JSP引擎先将JSP页面文件转译成一个Java文件,即Servlet,Java Servlet是基于服务器端编程的API,用Java Servlet编写的Java程序称为servlet,servlet通过HTML与客户交互。服务器将前面转译成的Java文件编译成字节码文件,再执行这个字节码文件来响应客户的请求。当这个JSP页面再次被请求时,只要该JSP文件没有被改动,JSP引擎就直接调用已装载的Servlet。
    JSP和servlet的运行原理探讨
    JSP是一个运行在服务器端的程序,而javascrīpt是运行在客户端的程序。两种程序是工作在不同的地方的,这一点不可以混淆。
    Javascrīpt如何执行,服务器是不会知道的。
    对于javascrīpt的代码在jsp页面中和普通的HTML代码意义上是完全一样的。大可不必理会,因为javascrīpt是在标记中的,而jsp是<%%>中的,而<%%>中的东西是不会到客户端去的。所以你可以利用JSP的规则来确定那些javascrīpt的片断输出到客户端。
    <%page language=”java”%>在服务器端执行,< scrīpt language=javascrīpt>客户端执行,由浏览器的Javascrīpt引擎解释执行.
       客户端用户填写 HTML 表单,发送请求。 将请求发送给 服务器端servlet(tomcat是servlet的容器)。 servlet 将该 HTTP 请求转换成一个 MQSeries 消息,并将其放入一个队列。 后端应用程序处理该消息,然后通过消息队列发回一个应答。 servlet 从队列中检索消息,并将其存放在一个 Java Bean 中。 然后 servlet 调用编译过的 Java Server Page(JSP) 并动态生成结果 HTML 页面。 JSP 从 Java Bean 检索出该页面需要的数据,将其合并到 HTML,然后将结果页面发送给客户端。
    JSP中的html代码和javascrīpt代码不会在服务器端执行,servlet 调用编译过的 Java Server Page(JSP) ,也就是运行由JSP编译成的class文件(运行的代码包括actionBean,formBean,一般的bean 和内嵌在JSP的Java代码).
    apache是web服务器(不是客户端,大多数时候就是指代应用服务器,客户端一般都是web浏览器),tomcat是应用(java)服务器,它只是一个运行servlet的容器,可以认为是apache的扩展,但是可以独立于apache运行。一个Web运行程序(网站)可以有多个servlet,一般认为一个action就是一个servlet.
    所谓Servlet是指运行在服务器端的Java小程序。用于响应客户端的请求。在默认情况下,Servlet采用一种无状态的请求-响应处理方式。Servlet代码的主要作用是为了增强Java服务器端的功能,它运行在服务器端,用于接收并且处理浏览器客户端发出的请求,该请求是通过配置文件web.xml的相关配置进行转发。也就是说Servlet是一个标准的Java类,它符合Java类的一般规则。和一般的Java类不同之处只是在于Servlet可以处理Http请求。
    1.servlet是持久的。servlet只需Web服务器加载一次,后续又用到这个servlet,就不需要再加载。(所谓加载是指servlet加载进JVM运行)
    2.servlet是与平台无关的。
    3.servlet是可扩展的。

    ActionServlet继承自javax.servlet.http.HttpServlet类,其在Struts framework中扮演的角色是中心控制器。它提供一个中心位置来处理全部的终端请求。控制器ActionServlet主要负责将HTTP的客户请求信息组装后,根据配置文件的指定描述,转发到适当的处理器Action。

    JSP 工作原理
    所有JSP页面,在执行的时候都会被服务器端的JSP引擎转换为Servelet(.java),然后又由JSP引擎调用Java编译器,将Servelet(.java)编译为Class文件(.class),并由Java虚拟机(JVM)解释执行。

    展开全文
  • servlet容器

    2017-07-17 15:30:27
    常见的servlet容器有:WEB LOGIC TOMCAT JETTYJBOSSResinWebSphere …… Servlet容器有时候也叫做Servlet引擎,是Web服务器或应用程序服务器的一部分, 1. 什么是Web服务器? 想要知道什么是Servlet容器,我们首先...
    常见的servlet容器有:
    Weblogic
    WebSphere
    TOMCAT 

    JETTY
    JBOSS
    Resin

    ……
    Servlet容器有时候也叫做Servlet引擎,是Web服务器或应用程序服务器的一部分,
    

    1. 什么是Web服务器?

        想要知道什么是Servlet容器,我们首先要知道什么是Web服务器。

        Web服务器使用HTTP协议来传输数据。最简单的一种情况是,用户在浏览器(客户端,client)中输入一个URL(如,www.programcreek.com/static.html),然后就能获取网页进行阅览。因此,服务器完成的工作就是发送网页至客户端。传输过程遵循HTTP协议,它指明了请求(request)消息和响应(response)消息的格式。

    2. 什么是Servlet容器?

        在这里,我们发现,用户/客户端只能向服务器请求静态网页。如果用户想要根据自己的输入来读取网页,这种方式就不能满足用户的要求。Servlet容器的基本思想是在服务器端使用Java来动态生成网页。因此,Servlet容器是Web服务器和servlet进行交互的必不可少的组件。

    Servlet容器的工作过程是:当客户请求某个资源时,Servlet容器使用ServletRequest对象把客户的请求信息封装起来,然后调用java Servlet API中定义的Servlet的一些生命周期方法,完成Servlet的执行,接着把Servlet执行的要返回给客户的结果封装到 ServletResponse对象中,最后Servlet容器把客户的请求发送给客户,完成为客户的一次服务过程。每一个Servlet的类都执行 init()、service()、destory()三个函数的自动调用,在启动时调用一次init()函数用以进行参数的初始化,在服务期间每当接收到对该Servlet的请求时都会调用Service()函数执行该Servlet的服务操作,当容器销毁时调用一次destory()函数。 

        Servlet容器就是用来装Servlet的。

    3. 什么是Servlet?

        Servlet是在javax.serlvet包中定义的一个接口。它声明了servlet生命周期中必不可少的三个方法-init()、service()和destroy()。每个servlet(无论是在SDK中定义的,或是自定义的)都必须实现这三个方法,而且由服务器在特定的时刻调用。

        1. init()方法在servlet生命周期的初始化阶段被调用。它传递一个实现了javax.servlet.ServletConfig接口的对象,使得servlet能够从web application中获取初始化参数。

        2. servlet初始化收,每接收一个请求,就会调用service()方法。每个请求的处理都在独立的线程中进行。Web服务器对每个请求都会调用一次service()方法。service()方法判断请求的类型,并把它转发给相应的方法进行处理。

        3. 当需要销毁servlet对象时,就要调用destroy()方法。该方法释放被占用的资源。

        和所有的Java程序一样,servlet运行在JVM中。引入servlet容器是为了处理复杂的HTTP请求。Servlet容器负责servlet的创建、执行和销毁。

    4. Servlet容器和Web服务器如何处理一个请求?

        1. Web服务器接收到HTTP请求

        2. Web服务器将请求转发给servlet容器

        3. 如果容器中不存在所需的servlet,容器就会检索servlet,并将其加载到容器的地址空间中

        4. 容器调用servlet的init()方法对servlet进行初始化(该方法只会在servlet第一次被载入时调用)

        5. 容器调用servlet的service()方法来处理HTTP请求,即,读取请求中的数据,创建一个响应。servlet会被保留在容器的地址空间中,继续处理其他的HTTP请求

        6. Web服务器将动态生成的结果返回到正确的地址。

        下图标出了上述的六个步骤:


    JSP运行原理:当Web服务器上的JSP页面第一次被请求执行时,JSP引擎先将JSP页面文件转译成一个Java文件,即Servlet,Java Servlet是基于服务器端编程的API,用Java Servlet编写的Java程序称为servlet,servlet通过HTML与客户交互。服务器将前面转译成的Java文件编译成字节码文件,再执行这个字节码文件来响应客户的请求。当这个JSP页面再次被请求时,只要该JSP文件没有被改动,JSP引擎就直接调用已装载的Servlet。

    5. JVM扮演的角色

        使用servlet,就要允许JVM为处理每个请求分配独立的Java线程,这也是Servlet容器主要的优势之一。每一个servlet都是一个拥有能响应HTTP请求的特定元素的Java类。Servlet容器的主要作用是将请求转发给相应的servlet进行处理,并在JVM处理完请求后,将动态生成的结果返回至正确的地址。在大多数情况下,servlet容器运行在独立的JVM中,但如果容器需要多个JVM,也有相应的解决方案。


    展开全文
  • 9.1 Servlet容器&实例

    万次阅读 2020-05-10 00:13:12
    前言 4-8章是JVM和编译器等的内容, 比较深入,凭我目前实际开发经验...Servlet容器是如何工作的(Tomcat) Servlet容器是如何解析web.xml的 请求是如何分配给指定的Servlet Servlet容器如何管理Servlet的生命周期 Se

    前言

    4-8章是JVM和编译器等的内容, 比较深入,凭我目前实际开发经验,感觉太深了,故而跳了。

    第9章主要讲的是Servlet的工作原理

    为什么要学啊 = = ,因为我们是面向Debug学习啊!!

    大家都会莫名其妙报错,而学的多可以精准修正,学的差就无能狂怒啦。

    在第9章你将学习到:

    • Servlet容器是如何启动
    • Servlet容器是如何工作的(Tomcat)
    • Servlet容器是如何解析web.xml的
    • 请求是如何分配给指定的Servlet
    • Servlet容器如何管理Servlet的生命周期
      个人感觉第九章的知识点空洞的一比,可能是为了后面几章铺垫吧= =
      造就完了,奥利给!

    Servlet容器

    背景

    Servlet 与 Servlet 容器的关系,就是鱼和鱼塘的关系。

    虽然它们是彼此依存的,但是又相互独立,从技术角度来说是为了解耦。

    前面说了 Servlet 容器作为一个独立发展的标准化产品,目前它的种类很多,但是它们都有自己的市场定位,很难说谁优谁劣,各有特点。例如现在比较流行的 Jetty,在定制化和移动领域有不错的发展,我们这里还是以大家最为熟悉 Tomcat 为例来介绍 Servlet 容器如何管理 Servlet。

    Tomcat 的容器等级中:

    • Servlet 容器是间接管理 Servlet
    • Context 容器是直接管理 Servlet 在容器中的包装类 Wrapper(可以理解为Wrapper≈Servlet,因为一个Wrapper存且仅存一个Servlet,当然还有Servlet的相关信息)

    所以 Context 容器如何运行将直接影响 Servlet 的工作方式。

    Tomcat 的容器分为四个等级,真正管理 Servlet 的容器是 Context 容器,一个 Context 对应一个 Web 工程

    Tomcat
    Container容器
    Engine
    Host
    Servlet容器
    Context1
    Context2
    Wrapper3
    Wrapper4
    Wrapper1
    Wrapper2

    强调一下(Servlet容器\neqServlet,Context容器=Context)

    Tomcat的配置文件中也能看出来:

    <Context path="/projectOne " docBase="D:\projects\projectOne"
    reloadable="true" />
    

    Servlet容器的启动过程

    Tomcat7 增加了一个启动类Tomcat(org.apache.catalina.startup.Tomcat) 。创建一个Tomcat实例对象,并调用 start 方法就可以启动 Tomcat。

    我们还可以通过这个对象来操作 Tomcat 的配置参数,如可以动态增加 Context、Servlet 等。

    下面我们就利用这个 Tomcat 类来管理新增的一个 Context 容器,我们就选择 Tomcat7 自带的 examples Web 工程

    大概的启动过程:

    Tomcat tomcat = getTomcatInstance(); //创建一个Tomcat实例对象
    File appDir = new File(getBuildDirectory(), "webapps/examples"); 
    tomcat.addWebapp(null, "/examples", appDir.getAbsolutePath()); //加入新的WEB应用
    tomcat.start(); //启动
    
    //下面的不用管
    //测试,调用其中的一个 HelloWorldExample Servlet,看有没有正确返回预期的数据
    ByteChunk res = getUrl("http://localhost:" + getPort() + 
                  "/examples/servlets/servlet/HelloWorldExample"); 
    assertTrue(res.toString().indexOf("<h1>Hello World!</h1>") > 0);
    

    再深入看看Tomcat.addWebapp():

    //返回的是Context
    public Context addWebapp(Host host, String url, String path) { 
           silence(url); 
           Context ctx = new StandardContext(); //创建的实际上是StandardContext
    	    //把传进来的参数配置一下
           ctx.setPath( url ); 
           ctx.setDocBase(path); 
        	//把该设置的设置了
           if (defaultRealm == null) { 
               initSimpleAuth(); 
           } 
           ctx.setRealm(defaultRealm); 
           ctx.addLifecycleListener(new DefaultWebXmlListener()); 
        
        	//这个类最重要,将负责整个webapp配置(xml等)的解析
           ContextConfig ctxCfg = new ContextConfig();
    	    //讲ContextConfig给Context容器
           ctx.addLifecycleListener(ctxCfg);     
           ctxCfg.setDefaultWebXml("org/apache/catalin/startup/NO_DEFAULT_XML"); 
    	    //将这个 Context 容器加到父容器 Host 
           if (host == null) { 
               getHost().addChild(ctx); 
           } else { 
               host.addChild(ctx); 
           } 
           return ctx; 
    }
    

    另外说一句,Tomcat 的启动逻辑是基于观察者模式设计的,所有的容器都会继承 Lifecycle 接口,它管理者容器的整个生命周期,所有容器的的修改和状态的改变,都会去通知已经注册的观察者(Listener)。

    Tomcat启动的时序图:(这个要好好看,涉及到后面的理解,多停留一些时间,图还是老图了= =)
    在这里插入图片描述

    emmm…刚刚说到ContextConfig 类会负责整个 Web 应用的配置文件的解析工作,就再了解一下。

    • ContextConfig 的 init 方法将会主要完成以下工作:(必须得看,时序图第13步)
      1. 创建用于解析 xml 配置文件的 contextDigester 对象
      2. 读取默认 context.xml 配置文件,如果存在解析它
      3. 读取默认 Host 配置文件,如果存在解析它
      4. 读取默认 Context 自身的配置文件,如果存在解析它
      5. 设置 Context 的 DocBase

    图解一波:

    创建解析xml的对象
    读+解析配置文件
    设置docbase
    • Context 容器的会执行 startInternal 方法主要包括如下几个部分:(可看可不看,第14步,紧跟13步)
      1. 创建读取资源文件的对象
      2. 创建 ClassLoader 对象
      3. 设置应用的工作目录
      4. 启动相关的辅助类如:logger、realm、resources 等
      5. 修改启动状态,通知感兴趣的观察者(Web 应用的配置)
      6. 子容器的初始化
      7. 获取 ServletContext 并设置必要的参数
      8. 初始化“load on startup”的 Servlet

    Web应用初始化

    前面讲的是啥子,是Servlet容器(Tomcat)启动,也就是建鱼塘的过程

    现在要讲啥子,是Webapp初始化的过程,也就是找&放鱼的过程(后面还有“养鱼”的过程)。

    就一句话:Webapp的初始化主要是要解析 web.xml 文件(这个文件描述了一个 Web 应用的关键信息,也是一个 Web 应用的入口)。

    这个工作是在 ContextConfig.configureStart() 方法中实现的:

    • Tomcat 首先会找 globalWebXml

      ​ 这个文件的搜索路径是在 engine 的工作目录下寻找以下两个文件中的任一个 org/apache/catalin/startup/NO_DEFAULT_XML 或 conf/web.xml。

    • 接着会找 hostWebXml

      ​ 这个文件可能会在 System.getProperty(“catalina.base”)/conf/{EngineName}/​{HostName}/web.xml.default

    • 接着寻找应用的配置文件 examples/WEB-INF/web.xml(就是你自己写的那个,这里用的Tomcat自带的工程给你讲呢)

      ​ web.xml 文件中的各个配置项将会被解析成相应的属性保存在 WebXml 对象中。如果当前应用支持 Servlet3.0,解析还将完成额外 9 项工作,这个额外的 9 项工作主要是为 Servlet3.0 新增的特性,包括 jar 包中的 META-INF/web-fragment.xml 的解析以及对 annotations 的支持。

    • 接下去将会将 WebXml 对象中的属性设置到 Context 容器中

      ​ 这里包括创建 Servlet 对象、filter、listener 等等。这段代码在 WebXml 的 configureContext 方法中。下面是解析 Servlet 的代码片段

    看图理解一下:

    step1:寻找
    step2:寻找
    step3:寻找
    step4:设置
    Tomcat
    globalWebXml
    hostWebXml
    你自己写的web.xml
    web.xml
    Context容器

    从WebXml到Context容器

    刚刚才说了,Webapp初始化会讲web.xml对象中的属性设置到 Context 容器中,因为很重要,所以单独讲一讲。

    先上部分源码:(不要慌着读代码,笑笑就行,先往下看)

    for (ServletDef servlet : servlets.values()) { 
               Wrapper wrapper = context.createWrapper(); 
               String jspFile = servlet.getJspFile(); 
               if (jspFile != null) { 
                   wrapper.setJspFile(jspFile); 
               } 
               if (servlet.getLoadOnStartup() != null) { 
                   wrapper.setLoadOnStartup(servlet.getLoadOnStartup().intValue()); 
               } 
               if (servlet.getEnabled() != null) { 
                   wrapper.setEnabled(servlet.getEnabled().booleanValue()); 
               } 
               wrapper.setName(servlet.getServletName()); 
               Map<String,String> params = servlet.getParameterMap(); 
               for (Entry<String, String> entry : params.entrySet()) { 
                   wrapper.addInitParameter(entry.getKey(), entry.getValue()); 
               } 
               wrapper.setRunAs(servlet.getRunAs()); 
               Set<SecurityRoleRef> roleRefs = servlet.getSecurityRoleRefs(); 
               for (SecurityRoleRef roleRef : roleRefs) { 
                   wrapper.addSecurityReference( 
                           roleRef.getName(), roleRef.getLink()); 
               } 
               wrapper.setServletClass(servlet.getServletClass()); 
               MultipartDef multipartdef = servlet.getMultipartDef(); 
               if (multipartdef != null) { 
                   if (multipartdef.getMaxFileSize() != null && 
                           multipartdef.getMaxRequestSize()!= null && 
                           multipartdef.getFileSizeThreshold() != null) { 
                       wrapper.setMultipartConfigElement(new 
    MultipartConfigElement( 
                               multipartdef.getLocation(), 
                               Long.parseLong(multipartdef.getMaxFileSize()), 
                               Long.parseLong(multipartdef.getMaxRequestSize()), 
                               Integer.parseInt( 
                                       multipartdef.getFileSizeThreshold()))); 
                   } else { 
                       wrapper.setMultipartConfigElement(new 
    MultipartConfigElement( 
                               multipartdef.getLocation())); 
                   } 
               } 
               if (servlet.getAsyncSupported() != null) { 
                   wrapper.setAsyncSupported( 
                           servlet.getAsyncSupported().booleanValue()); 
               } 
               context.addChild(wrapper); 
    }
    

    这段代码清楚的描述了如何将 Servlet 包装成 Context 容器中的 StandardWrapper。

    你问我为什么要将 Servlet 包装成 StandardWrapper 而不直接是 Servlet 对象? 因为要解耦啊!Servlet 是一个web开发标准,而StandardWrapper 容器是 Tomcat 容器中的一部分(不然你让其他非Tomcat服务器的咋办)

    除了这个,其它的所有 web.xml 属性都被解析到 Context 中,所以说 Context 容器才是真正运行 Servlet 的 Servlet 容器。

    小结:一个 Web 应用对应一个 Context 容器,容器的配置属性由应用的 web.xml 指定,这样我们就能理解 web.xml 到底起到什么作用了。

    (好了,现在看代码)

    Servlet实例

    刚刚才讲到, Servlet 被包装成 StandardWrapper 添加在 Context 容器中,但是它仍然不能为我们工作,它还没有被实例化。

    下面我们将介绍

    • Servlet 对象是如何创建的
    • Servlet 对象初始化

    (相当于鱼已经选好了,现在准备买几条真鱼放入鱼塘)

    创建 Servlet 对象

    • 实例化条件:如果 Servlet 的 load-on-startup 配置项大于 0,那么在 Context 容器启动的时候就会被实例化。

      解释一下——前面提到在解析配置文件时会读取默认的 globalWebXml,且在 conf 下的 web.xml 文件中定义了一些默认的配置项,其定义了两个 Servlet,分别是:DefaultServlet(org.apache.catalina.servlets.DefaultServlet) 和 JspServlet (org.apache.jasper.servlet.JspServlet )。

      它们的 load-on-startup 分别是 1 和 3,也就是当 Tomcat 启动时这两个 Servlet 就会被启动。

    • 创建 Servlet 实例是从 Wrapper.loadServlet() 开始。

      说明一下——loadServlet 方法要完成的就是获取 servletClass, 然后,交给 InstanceManager 去创建一个基于 servletClass.class 的对象(因为Servlet有很多种,比如HttpServlet等)。

      如果这个 Servlet 配置了 jsp-file,那么这个 servletClass 就是 conf/web.xml 中定义的JspServlet (org.apache.jasper.servlet.JspServlet)了。

    初始化 Servlet

    • 初始化 Servlet 在 StandardWrapper.initServlet() 方法中

      说明一下——这个方法很简单,就是调用 Servlet.init()方法,同时把包装了 StandardWrapper 对象的 StandardWrapperFacade 作为 ServletConfig 传给 Servlet。

      (Tomcat 容器为何要传 StandardWrapperFacade 给 Servlet 对象将在后面做详细解析。)

    这样 Servlet 对象就初始化完成了。

    (事实上 Servlet 从被 web.xml 中解析到完成初始化,这个过程非常复杂,中间有很多过程,包括各种容器状态的转化引起的监听事件的触发、各种访问权限的控制和一些不可预料的错误发生的判断行为等等。而我们这里只针对Servlet本身。)

    下面是这个过程的一个完整的时序图,其中也省略了一些细节(上的原图):

    在这里插入图片描述

    至此,鱼儿终于进入鱼塘啦!

    下一章将会讲Servlet的体系结构,让我们对Servlet有个更完整的认识,而不是仅仅在使用层面(API程序员)。谢谢Lehr在wrapper处给我指出的错误

    展开全文
  • Servlet、Servlet容器

    2019-10-08 00:58:42
    Servlet、Servlet容器ServletServlet接口Servlet 接口中定义的方法以及Servlet的生命周期Servlet容器Web服务器Servlet容器 Servlet     Servlet是用Java编写的服务器端程序,其主要功能在于交互式地浏览和修改...
  • ServletServlet 容器

    2019-11-01 21:47:31
    Tomcat是Servlet容器的一种,Servlet容器可以对Servlet进行管理,控制其生命周期。使其可以专注于自己应该做的事情,不需要考虑端口啊多线程啊socket之类的东西,也使得Servlet在各种环境下具有适应性 Tomcat 的...
  • 静态网页和动态网页、servlet容器与Web Server关系、Servlet Container工作过程、Servlet生命周期(init、service、destroy)
  • servlet,servlet容器

    2018-04-09 21:15:16
    首先,得先大概知道web服务器是什么,接着,明白servlet的作用,以及为什么要有servlet容器。最后,再深入了解servlet。 1. What is a web server? To know what is a Servlet container, we need to know what...
  • 一、什么是JavaWeb应用? 在Sun的Java Servlet规范...它可以在各种供应商提供的实现Servlet规范的Servlet容器中运行。” Java Web应用中可以包含如下内容: Servlet JSP 实用类 静态文件,如HTML、JS、图片等...
  • servlet容器,web容器,spring容器,springmvc容器的区别

    千次阅读 多人点赞 2019-05-03 21:42:40
    web容器中有servlet容器,spring项目部署后存在spring容器和springmvc容器。其中spring控制service层和dao层的bean对象。springmvc容器控制controller层bean对象。servlet容器控制servlet对象。项目启动是,首先 ...
  • Servlet 容器说起 转载至:https://www.ibm.com/developerworks/cn/java/j-lo-servlet/ 要介绍 Servlet 必须要先把 Servlet 容器说清楚,ServletServlet 容器的关系有点像枪和子弹的关系,枪是为子弹而生,...
  • Servlet 容器概念整理

    2020-04-14 10:07:25
    Servlet容器主要是JavaWeb应用提供运行时环境,所以也可以称之为JavaWeb应用容器,或者Servlet/JSP容器。Servlet容器主要负责管理Servlet、JSP的生命周期以及它们的共享数据。 Servlet容器有哪些: 目前最流行的...
  • Jetty》-03_你应该知道的Servlet规范和Servlet容器 & 04_打造和运行一个Servlet Servlet规范 Servlet容器用来加载和管理业务类。HTTP服务器不直接跟业务类打交道,而是把请求交给Servlet容器去处理,Servlet...
  •  Servlet,Servlet容器,Jsp容器,Web容器  Servlet是一种运行在服务器端的java应用程序,具有独立于平台(java语言具有平台无关性)和独立于协议的特性(Servlet不对具体的协议实现,而是自定义协议,用...
  • Tomcat、Servlet、Servlet容器

    千次阅读 2020-07-02 22:10:24
    简单一句话:Tomcat是一个Servlet容器。这个容器当然就是装Servlet用的。那Servlet是什么,就是一个(按照Servlet规范写的一个)java类。 这个“装”怎么理解:*实现了Servlet、JSP规范,同时提供http服务。*其实,就...
  • Servlet容器和Web容器

    千次阅读 2015-09-01 13:53:54
    Servlet容器,负责管理Servlet生命周期。 Web容器,负责管理和部署Web应用,其本身可能具备Servlet容器组件;如果没有,一般能将第三方Servlet容器作为组件整合进Web容器。 1.Web容器好比电视机,Servlet容器好比VCD...
  • web容器中有servlet容器,spring项目部署后存在spring容器和springmvc容器。 其中spring控制service层和dao层的bean对象。 springmvc容器控制controller层bean对象。 servlet容器控制servlet对象。 启动流程顺序 ...
  • Spring_Boot专栏 ...目录1 嵌入式Servlet容器1.1 修改默认Servlet容器的相关配置1.1.1 在配置文件application.properties中修改1.1.2 通过Servlet容器的定制器来修改1.2 注册Servlet三大组...
  • 文章目录1 各个容器1.1 Web容器1.2 Servlet容器1.3 Servlet容器和ServletContext的关系1.4 Spring容器和SpringMVC容器1.5 spring与springmvc容器区别1.6 dubbo容器与spring,springmvc容器区别2 容器间的关系图 ...
  • 关系图 借鉴网上看到的一张图,来源于: ...web容器中有servlet容器,spring容器,springmvc容器。 servlet容器保存 Servlet对象。 springmvc容器保存 Controller对象。 spring容器保存 Service、Dao对象。 spring容...
  • servlet容器和web容器

    2015-10-16 08:42:56
    没有servlet容器,你也可以用web容器直接访问静态页面,比如安装一个apache等,但是如果要显示jsp/servlet,你就要安装一个 servlet容器了,但是光有servlet容器是不够的,因为它要被解析成html输http://wri
  • servlet容器(这里指tomcat插件)存放servlet对象,而SpringMVC框架整个是一个servlet对象,而IOC容器 在Boot框架中,会存放产生servlet容器的工厂,工厂依据主配置文件以及用户配置的... Embedded Servlet Cont...
  • Servlet容器的作用是负责处理客户请求,当客户请求来到时,Servlet容器获取请求,然后调用某个Servlet,并把Servlet的执行结果返回给客户。 Servlet容器的工作过程是:当客户请求某个资源时,Servlet容器使用...
  • 什么是 Servlet 容器

    千次阅读 多人点赞 2019-04-30 23:10:08
    2、什么是 Servlet 容器? 3、什么是 Servlet? 4、Servlet 容器和 Web 服务器如何处理一个请求的? 5、JVM 的作用 我们简单的谈一谈关于Web服务器,Servlet 容器及其与JVM 的关系。其实Servlet 容器只不过是一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,183
精华内容 12,473
关键字:

servlet容器