JavaWeb：Servlet的应用及接口介绍

客官°小女子只卖身不卖艺 2023-09-23 15:32 127阅读 0赞

> 广义的 Servlet 泛指在服务器上运行的 Java 程序，但是这个 Java 程序，并不能独立运行（因为 Servlet 没有 main 方法），需要部署在相应的 Servlet 容器中，比如 Tomcat 和 Jetty。Servlet 主要功能在于交互式地浏览和修改数据，生成动态 Web 内容。  
> ～  
> 本篇内容包括：Serlvet 相关概念、Servlet 的应用、*javax.servlet* 包下主要的类和接口 以及 *javax.servlet.http* 包下主要的类和接口

--------------------

*  上一篇内容：[JavaWeb：JavaWeb技术架构演进][JavaWeb_JavaWeb]
 *  更多知识学习：[全网最全的 Java 技术栈内容梳理（持续更新中）][Java]

--------------------

### 文章目录 ###

*   *  一、Serlvet 相关概念
     *   *   *  1、Servlet
             *  2、Servlet 容器
             *  3、Apache / Tomcat
     *  二、Servlet 的应用
     *   *   *  1、Servlet Api
             *  2、Servlet 软件包
     *  三、javax.servlet 包下主要的类和接口
     *   *   *  1、javax.servlet 包定义的类和接口
             *  2、RequestDispatcher
             *  3、Servlet
             *  4、ServletRequest
             *  5、ServletResponse
             *  6、ServletConfig
             *  7、ServletContext
     *  四、javax.servlet.http 包下主要的类和接口
     *   *   *  1、javax.servlet.http 包定义的类和接口
             *  2、HttpServlet
             *  3、HttpServletRequest
             *  4、HttpServletResponse

--------------------

## 一、Serlvet 相关概念 ##

#### 1、Servlet ####

Servlet，即 Java Servlet 的简称，其中 Servlet 的含义为 Server Applet（服务端程序），并且 Servlet 的名字由来也是这两个单词的拼接。

狭义的 Servlet 是指 Java 语言实现的一个接口。

广义的 Servlet 泛指在服务器上运行的 Java 程序，但是这个 Java 程序，并不能独立运行（因为 Servlet 没有 main 方法），需要部署在相应的 Servlet 容器中，比如 Tomcat 和 Jetty。Servlet 主要功能在于交互式地浏览和修改数据，生成动态 Web 内容。

#### 2、Servlet 容器 ####

Servlet 容器也被称为 Servlet 引擎，是 Web 服务器或应用程序服务器的一部分，用于在发送的请求和响应之上提供网络服务。

Servlet 没有 main 方法，不能独立运行，它必须被部署到 Servlet 容器中，由容器来实例化和调用 Servlet 的方法（如 doGet() 和 doPost() ），Servlet 容器在 Servlet 的生命周期内包容和管理 Servlet。在 JSP 技术推出后，管理和运行 Servlet/JSP 的容器也称为 Web 容器。

#### 3、Apache / Tomcat ####

Apache 是 Web 服务器，Tomcat 是应用（java）服务器，它只是一个 servlet 容器，是 Apache 的扩展。 Apache 和 Tomcat 都可以做为独立的 Web 服务器来运行，但是 Apache 不能解释 Java 程序（JSP、Servlet）。

两者都是一种容器，只不过发布的东西不同：

*  Apache 是 Html 容器，功能像 IIS（Internet Information Services）一样；
 *  Tomcat 是 JSP/Servlet 容器，用于发布 JSP 及 Java 应用。

--------------------

## 二、Servlet 的应用 ##

#### 1、Servlet Api ####

Java Servlet 是运行在带有支持 Java Servlet 规范的解释器的 web 服务器上的 Java 类。

针对 Servlet 实现技术，SUN 公司提供了一套标准的 Java Servlet Api 以便于更快速、规范地开发 Servlet 程序。

<dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.1.0</version>
                <scope>provided</scope>
            </dependency>

#### 2、Servlet 软件包 ####

在这套 Servlet API 中，最重要的两个软件包是：javax.servlet、javax.servlet.http

1.  `javax.servlet`：包含定义 servlet 和 servlet 容器之间契约的类和接口，主要有 RequestDispatcher、Servlet、GenericServlet、ServletConfig、ServletContext、ServletRequest、ServletResponse、Filter；
2.  `javax.servlet.http`：包含定义 HTTP Servlet 和 Servlet 容器之间关系的类和接口，主要有 HttpServlet、HttpServletRequest、HttpServletResponse、HttpSession、Cookie；

总的来说：`javax.servlet` 是一个与通信协议无关的通用软件包；`javax.servlet.http` 是一个支持 HTTP 访问协议的软件包，这两个软件包的同时存在，使得 Servlet API 能支持任何协议的请求/响应。

此外，Servlet API 中还有另外两个包，也有一定作用：

1.  `javax.servlet.annotation`，其中包含标注 servlet，Filter，Listener 的标注。它还为被标注元件定义元数据。
2.  `javax.servlet.descriptor`，其中包含提供程序化登录 Web 应用程序的配置信息的类型。

--------------------

## 三、javax.servlet 包下主要的类和接口 ##

#### 1、javax.servlet 包定义的类和接口 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">类/接口</th> 
   <th align="center">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>interface RequestDispatcher</code></td> 
   <td align="center">定义一种对象，用于从客户接受请求，并将请求发送到服务器上任何指定的资源，如一个 Servlet 、JSP 或 HTML 文件</td> 
  </tr> 
  <tr> 
   <td align="center"><code>interface Servlet</code></td> 
   <td align="center">定义了所有 Servlet 必须实现的方法。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>interface ServletConfig</code></td> 
   <td align="center">定义 Servlet config 对象，由Servlet 引擎用在 Servlet 初始化时，向 Servlet 传递信息。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>interface ServletContext</code></td> 
   <td align="center">定义了一系列方法，以便 Servlet 与其运行的环境通信。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>interface ServletRequest</code></td> 
   <td align="center">定义了一个对象，用于向 Servlet 传递客户请求信息的对象。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>interface ServletResponse</code></td> 
   <td align="center">定义了一个对象，由 Servlet 用于向客户发送响应的对象。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>interface SingleThreadModel</code></td> 
   <td align="center">用于保证 Servlet 在任一时刻，只处理一个请求。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>class GenericServlet</code></td> 
   <td align="center">继承 Servlet 接口，定义了一个通用的，与协议无关的Servlet。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>class ServletInputStream</code></td> 
   <td align="center">定义了一个输入流，用于由 Servlet 从中读取客户请求的二进制数据。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>class ServletOutputStream</code></td> 
   <td align="center">定义了一个输出流，用于由 Servlet 向客户发送二进制数据。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>class ServletException</code></td> 
   <td align="center">定义了一个当 Servlet 遇到问题时可以抛出的异常。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>class UnavailableException</code></td> 
   <td align="center">定义了一种异常，用于由 Servlet 指明它永远或暂时不可用。</td> 
  </tr> 
 </tbody> 
</table>

#### 2、RequestDispatcher ####

RequestDispatcher 是资源调度器接口，实现的是请求转发。请求转发的意思就是说通知其他 Web 资源处理当前 Servlet 的请求。

RequestDispatcher 对象由 Servlet 容器创建，用于封装并调度由一个特定的 URL 定义的服务器资源。

public interface RequestDispatcher {
        
        //forward方式下，来源URI名称(值在目标request中attribute中获取)
        static final String FORWARD_REQUEST_URI = "javax.servlet.forward.request_uri";
        //forward方式下，来源context路径名称(值在目标request中attribute中获取)
        static final String FORWARD_CONTEXT_PATH = "javax.servlet.forward.context_path";
        //forward方式下，来源路径信息名称(值在目标request中attribute中获取)
        static final String FORWARD_PATH_INFO = "javax.servlet.forward.path_info";
        //forward方式下，来源servlet的servlet路径名称(值在目标request中attribute中获取)
        static final String FORWARD_SERVLET_PATH = "javax.servlet.forward.servlet_path";
        //forward方式下，来源请求查询串名称(值在目标request中attribute中获取)
        static final String FORWARD_QUERY_STRING = "javax.servlet.forward.query_string";
        //include方式下，目标请求的URI名称(值在目标request中attribute中获取)
        static final String INCLUDE_REQUEST_URI = "javax.servlet.include.request_uri";
        //include方式下，目标context路径名称(值在目标request中attribute中获取)
        static final String INCLUDE_CONTEXT_PATH = "javax.servlet.include.context_path";
        //include方式下，目标路径信息名称(值在目标request中attribute中获取)
        static final String INCLUDE_PATH_INFO = "javax.servlet.include.path_info";
        //include方式下，目标servlet路径名称(值在目标request中attribute中获取)
        static final String INCLUDE_SERVLET_PATH = "javax.servlet.include.servlet_path";
        //include方式下，目标查询串名称(值在目标request中attribute中获取)
        static final String INCLUDE_QUERY_STRING = "javax.servlet.include.query_string";
        //error方式下，传递的异常对象名称(值在目标request中attribute中获取)
        public static final String ERROR_EXCEPTION = "javax.servlet.error.exception";
        //error方式下，传递的异常类型名称(值在目标request中attribute中获取)
        public static final String ERROR_EXCEPTION_TYPE = "javax.servlet.error.exception_type";
        //error方式下，传递的异常信息名称(值在目标request中attribute中获取)
        public static final String ERROR_MESSAGE = "javax.servlet.error.message";
        //error方式下，导致传递异常的请求URI名称(值在目标request中attribute中获取)
        public static final String ERROR_REQUEST_URI = "javax.servlet.error.request_uri";
        //error方式下，传递的发生错误的servlet名称(值在目标request中attribute中获取)
        public static final String ERROR_SERVLET_NAME = "javax.servlet.error.servlet_name";
        //error方式下，传递的响应code名称(值在目标request中attribute中获取)
        public static final String ERROR_STATUS_CODE = "javax.servlet.error.status_code";
    
        //在内部(浏览器地址不会改变)将请求从一个serlvet转发到另一个资源(servlet、jsp、html)处理
        public void forward(ServletRequest request, ServletResponse response)
            throws ServletException, IOException;
        //在响应请求中添加指定资源(servlet、jsp、html)
        public void include(ServletRequest request, ServletResponse response)
            throws ServletException, IOException;
    }

#### 3、Servlet ####

Servlet 定义了所有 Servlet 必须实现的方法：

public interface Servlet {
        
      	// Servlet初始化方法，通过init()方法可以获得容器创建的ServletConfig对象
        void init(ServletConfig var1) throws ServletException;
    		// 请求处理方法（第一次请求时，会先调用init( )）
        void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
      	// Servlet实例销毁方法
        void destroy();
    
        // 获取ServletConfig配置对象方法
        ServletConfig getServletConfig();
      	// 获取Servlet相关信息方法
      	String getServletInfo();
    }

其中，`init()`、`service()`、`destroy()` 是Servlet生命周期的方法。代表了 Servlet 从“出生”到“工作”再到“死亡”的过程。

#### 4、ServletRequest ####

Servlet 容器对于接受到的每一个 Http 请求，都会创建一个 ServletRequest 对象，并把这个对象传递给 Servlet 的 `Sevice()` 方法。其中，ServletRequest 对象内封装了关于这个请求的许多详细信息。

public interface ServletRequest {
        
      	// 获取请求中指定属性的值
        Object getAttribute(String var1);           
     		// 获取请求中所有属性name集
        Enumeration<String> getAttributeNames();    
     		// 返回请求中输入内容的字符编码类型
        String getCharacterEncoding();              
     		// 设置字符编码类型
        void setCharacterEncoding(String var1) throws UnsupportedEncodingException;  
     		// 获取请求内容的长度，如果长度位置就返回-1
        int getContentLength();
      	long getContentLengthLong();
     		// 返回请求数据体的MIME类型，如果类型未知就返回空值
        String getContentType();            
      	
        // 返回一个输入流用来从请求体读取二进制数据。
        // 如果在此之前已经通过getReader方法获得了要读取的结果，这个方法会抛出一个IllegalStateException。
        ServletInputStream getInputStream() throws IOException;
     		// 通过名称获取参数值
        String getParameter(String var1);           
     		// 获取所有参数名称集
        Enumeration<String> getParameterNames();    
     		// 获取指定参数名的所有参数值
        String[] getParameterValues(String var1);   
     		// 返回参数的键值对，是一个只读的map类型
        Map<String, String[]> getParameterMap();    
     		// 返回这个请求所用的协议，其形式是协议/主版本号.次版本号
        String getProtocol();                       
     		// 返回请求所使用的URL的模式。例如，对于一个HTTP请求，这个模式就是http。
        String getScheme();                         
     		// 返回接收请求的服务器的主机名。
        String getServerName();                     
     		// 返回接收请求的端口号。
        int getServerPort();                        
     
        // 返回一个buffered reader用来读取请求体的实体，其编码方式依照请求数据的编码方式。
        // 如果这个请求的输入流已经被getInputStream调用获得，这个方法会抛出一个IllegalStateException。
        BufferedReader getReader() throws IOException;
     		// 返回发送请求者的IP地址。
        String getRemoteAddr();                     
     
        // 返回发送请求者的主机名称。如果引擎不能或者选择不解析主机名（为了改善性能），这个方法会直接返回IP地址。
        String getRemoteHost();
        // 在请求中添加一个属性，这个属性可以被其他可以访问这个请求对象的对象（例如一个嵌套的Servlet）使用。
        void setAttribute(String var1, Object var2);
        // 根据属性名，删除属性值
        void removeAttribute(String var1);
     		// 获取请求者的国家地区信息
        Locale getLocale();                         
     		// .
        Enumeration<Locale> getLocales();           
     		// 返回安全状态
        boolean isSecure();                         
     
        // 返回一个RequestDispatcher对象，是一个Web资源的包装器，
        // 可以用来把当前request传递到该资源，或者把新的资源包括到当前响应中。
        // RequestDispatcher接口中定义了两个方法：include/forward。
        RequestDispatcher getRequestDispatcher(String var1);
     
        /** @deprecated */
      	// 获取应用的完整绝对路径。
        String getRealPath(String var1);            
     		// 返回发送请求者的端口号
        int getRemotePort();                        
     		// 获取Web服务器的主机名
        String getLocalName();                   	   
     		// 获取Web服务器的IP地址
        String getLocalAddr();                      
     		// 获取Web服务器所使用的网络端口号
        int getLocalPort();                         
     		// 获取上下文对象
        ServletContext getServletContext();         
     		
      	// 返回一个异步上下文对象
        AsyncContext startAsync() throws IllegalStateException;  
        AsyncContext startAsync(ServletRequest var1, ServletResponse var2) throws IllegalStateException;
     		// 是否启动异步
        boolean isAsyncStarted();                   
     		// 是否支持异步
        boolean isAsyncSupported();                 
     		// 获取异步上下文
        AsyncContext getAsyncContext();             
     		// 获取调度器类型
        DispatcherType getDispatcherType();         
    }

#### 5、ServletResponse ####

ServletResponse 接口表示一个 Servlet 响应，在调用 Servlet 的 `Service()` 方法前，Servlet 容器会先创建一个 ServletResponse 对象，并把它作为第二个参数传给`Service()`方法。ServletResponse 隐藏了向浏览器发送响应的复杂过程。

public interface ServletResponse {
        
        // 返回在此响应中发送的正文所使用的字符编码（MIME字符集）的名称
        String getCharacterEncoding();
     
        // 返回用于在此响应中发送的MIME主体的内容类型。
        String getContentType();
     
        // 返回一个适合于在响应中写入二进制数据的服务输出流
        ServletOutputStream getOutputStream() throws IOException;
     
        // 返回一个可以向客户端发送字符文本的打印写入器对象。
        PrintWriter getWriter() throws IOException;
     
        // 设置此响应中发送的正文所使用的字符编码（MIME字符集）的名称
        void setCharacterEncoding(String var1);
     
        // 设置响应中内容主体的长度在HTTPservlet中，此方法设置HTTP内容长度头。
        void setContentLength(int var1);
     
        // 设置此响应中发送的MIME主体的内容类型。
        void setContentType(String var1);
     
        // 设置用于响应的实际缓冲区大小
        void setBufferSize(int var1);
     
        // 返回用于响应的实际缓冲区大小
        int getBufferSize();
     
        // 强制将缓冲区中的任何内容写入客户机
        void flushBuffer() throws IOException;
     
        // 清除响应中底层缓冲区的内容，而无需清除标题或状态代码。
        void resetBuffer();
     
        // 返回一个布尔值，以指示是否已提交了响应。
        boolean isCommitted();
     
        // 清除缓冲区中存在的任何数据以及状态代码、报头。
        void reset();
     
        // 设置此响应指定的区域设置
        void setLocale(Locale var1);
     
        // 返回此响应指定的区域设置
        Locale getLocale();
    }

#### 6、ServletConfig ####

ServletConfig 是一个 Servlet 对象的配置信息对象 ServletConfig 对象中封装了一个 Servlet 对象的配置信息，Servlet 对象的配置信息在 *web.xml* 中

一个 Servlet 对象对应一个 ServletConfig 对象，100 个 Servlet 对象对应 100 个 ServletConfig 对象。

public interface ServletConfig {
        
    		// 获取<servlet>servletName</servlet>
        String getServletName();
    		// 获取 ServletContext【Servlet上下文】对象
        ServletContext getServletContext();
    		// 通过初始化参数的name获取初始化参数的value
        String getInitParameter(String var1);
    		// 获取初始化参数的全部的value
        Enumeration<String> getInitParameterNames();
    }

\# 获取ServletConfig对象的两种方式

*  定义一个全局变量 `private ServletConfig config;` \- 这个方法是在Servlet对象中自己用的
 *  通过：`getServletConfig()`方法获取 - 这个方法是在Servlet对象的子类中使用的

#### 7、ServletContext ####

ServletContext 官方叫 servlet 上下文。服务器会为每一个工程创建一个对象，这个对象就是 ServletContext 对象。这个对象全局唯一，而且工程内部的所有 servlet 都共享这个对象。所以叫全局应用程序共享对象。所有的 Servlet 对象共享一个 ServletContext 对象。

/**
     * 提供一些方法，供Servlet与Servlet容器进行交互，例如获取文件MIME类型等.
     * 每个Web应用程序都有一个Servlet上下文.
     * 
     */
    public interface ServletContext {
        
    
        /**
         * 方法返回web应用的上下文路径，就是我们部署的应用的根目录名称.
         */
        public String getContextPath();
    
        /**
         * 根据资源定位符，获取其Servlet上下文.
         */
        public ServletContext getContext(String uripath);
    
        /**
         * 返回Servlet容器支持的Servlet API主版本号.
         */
        public int getMajorVersion();
    
        /**
         * 返回Servlet容器支持的Servlet API次版本号.
         */
        public int getMinorVersion();
    
        /**
         * 返回指定文件的MIME类型.
         * @param file 文件.
         * @return MIME类型.
         */
        public String getMimeType(String file);
    
        /**
         * 返回一个类似于目录的列表，其中列出了web应用程序中资源的所有路径，这些资源的最长子路径与提供的路径参数匹配.
         * 例如输入/pages，会以路径的方式返回pages目录下的所有文件.
         * @param path 目录. 
         * @return 指定目录下的文件列表.
         */
        public Set getResourcePaths(String path);
    
        /**
         * 根据指定路径返回资源的URL，路径必须以/开头，代表当前Web应用程序的根目录.
         * @param path 资源路径.
         * @return 代表资源的URL.
         * @throws MalformedURLException .
         */
        public URL getResource(String path) throws MalformedURLException;
    
        /**
         * 使用相对于根目录的路径访问到web目录下的所有文件，而不知道绝对路径.                    
         * @param path 相对路径.
         * @return 资源输入流.
         */
        public InputStream getResourceAsStream(String path);
    
        /**
         * 返回一个RequestDispatcher对象，该对象扮演着一个给定资源包装者的角色.
         * 一个RequestDispatcher对象可以用于传送一个请求到特定资源或者把特定资源包含到一个响应当中.
         * 该特定资源可以是动态的也可以是静态的.
         * @param path 给定资源路径.
         * @return RequestDispatcher对象.
         */
        public RequestDispatcher getRequestDispatcher(String path);
    
        /**
         * 为指定名字的servlet对象返回一个RequestDispatcher对象.
         * 一个Servlet实例的名称可以由ServletConfig.getServletName()获取.
         * @param name Servlet名称.
         * @return RequestDispatcher对象.
         */
        public RequestDispatcher getNamedDispatcher(String name);
    
        /**
         * @deprecated 
         * 根据Servlet名称获取Servlet.
         */
        public Servlet getServlet(String name) throws ServletException;
    
        /**
         * @deprecated 
         * 获取所有Servlet的枚举.
         */
        public Enumeration getServlets();
    
        /**
         * @deprecated 
         * 获取所有Servlet名称的枚举.
         */
        public Enumeration getServletNames();
    
        /**
         * 把指定的信息写进servlet日志文件，通常是事物日志.日志文件的名称和类型与servlet容器有关.
         */
        public void log(String msg);
    
        /**
         * @deprecated 
         * 把指定的信息写进servlet日志文件，通常是事物日志.日志文件的名称和类型与servlet容器有关.
         */
        public void log(Exception exception, String msg);
    
        /**
         * 把指定的信息写进servlet日志文件，通常是事物日志.日志文件的名称和类型与servlet容器有关.
         */
        public void log(String message, Throwable throwable);
    
        /**
         * 根据相对路径获取文件路径.
         * "" -> C:\项目根.
         * "/" -> C:\项目根\.
         * "/pp" -> C:\项目根\pp
         * @param path 相对路径.
         * @return 文件绝对路径.
         */
        public String getRealPath(String path);
    
        /**
         * 获取Servlet容器版本号.
         * @return Servlet容器版本号.
         */
        public String getServerInfo();
    
        /**
         * 根据指定名称获取初始化参数值.
         * @param name 参数名称.
         * @return 参数值.
         */
        public String getInitParameter(String name);
    
        /**
         * 获取初始化参数枚举.
         * @return 参数枚举.
         */
        public Enumeration getInitParameterNames();
    
        /**
         * 根据给定属性名，从ServletContext中获取属性.
         * @param name 属性名.
         * @return 属性值.
         */
        public Object getAttribute(String name);
    
        /**
         * 获取ServletContext属性名枚举.
         * @return 属性名枚举.
         */
        public Enumeration getAttributeNames();
    
        /**
         * 设置ServletContext属性.
         */
        public void setAttribute(String name, Object object);
    
        /**
         * 移除ServletContext属性.移除后，获取此属性返回null.
         * @param name
         */
        public void removeAttribute(String name);
    
        /**
         * 返回ServletContext对应应用的名称.
         * 该名称配置于web.xml的<display-name>标签中.
         * @return 应用名称.
         */
        public String getServletContextName();
    }

--------------------

## 四、javax.servlet.http 包下主要的类和接口 ##

#### 1、javax.servlet.http 包定义的类和接口 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">类/接口</th> 
   <th align="center">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>interface HttpServletRequest</code></td> 
   <td align="center">继承了ServletRequest 接口，为HTTPServlet 提供请求信息</td> 
  </tr> 
  <tr> 
   <td align="center"><code>interface HttpServletResponse</code></td> 
   <td align="center">继承了ServletResponse 接口，为HTTPServlet 输出响应信息提供支持。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>interface HttpSession</code></td> 
   <td align="center">为维护 HTTP 用户的会话状态提供支持。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>interface HttpSessionBindingListener</code></td> 
   <td align="center">使得某对象在加入一个会话或从会话中删除时能够得到通知。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>interface HttpSessionContext</code></td> 
   <td align="center">由Servlet 2.1 定义，该对象在新版本已不被支持。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>class Cookie</code></td> 
   <td align="center">用在Servlet 中使用Cookie 技术</td> 
  </tr> 
  <tr> 
   <td align="center"><code>class HttpServlet</code></td> 
   <td align="center">定义了一个抽象类，继承 GenericServlet 抽象类，应被 HTTPServlet 继承。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>class HttpSessionBindingEvent</code></td> 
   <td align="center">定义了一种对象，当某一个实现了 HttpSessionBindingListener 接口的对象被加入会话或从话中删除时，会收到该类对象的一个句柄</td> 
  </tr> 
  <tr> 
   <td align="center"><code>class HttpUtils</code></td> 
   <td align="center">提供了一系列便于编写HTTPServlet 的方法。</td> 
  </tr> 
 </tbody> 
</table>

#### 2、HttpServlet ####

HttpServlet 抽象类是继承于 GenericServlet 抽象类而来的。使用 HttpServlet 抽象类时，还需要借助分别代表 Servlet 请求和 Servlet 响应的 HttpServletRequest 和 HttpServletResponse 对象。

HttpServlet 抽象类覆盖了 GenericServlet 抽象类中的 `Service()` 方法，并且添加了一个自己独有的 `Service(HttpServletRequest request，HttpServletResponse)` 方法。

GenericServlet 抽象类中是如何定义 service 方法的：

public abstract void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

我们看到是一个抽象方法，也就是 HttpServlet 要自己去实现这个 service 方法，我们在看看 HttpServlet 是怎么覆盖这个 service 方法的：

public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        
        HttpServletRequest request;
        HttpServletResponse response;
        try {
        
            request = (HttpServletRequest)req;
            response = (HttpServletResponse)res;
        } catch (ClassCastException var6) {
        
            throw new ServletException("non-HTTP request or response");
        }
    
    this.service(request, response);
    
    }

我们发现，HttpServlet 中的 service 方法把接收到的 ServletRequsest 类型的对象转换成了 HttpServletRequest 类型的对象，把 ServletResponse 类型的对象转换成了HttpServletResponse 类型的对象。之所以能够这样强制的转换，是因为在调用 Servlet 的 Service 方法时，Servlet 容器总会传入一个 HttpServletRequest 对象和 HttpServletResponse 对象，预备使用 HTTP。因此，转换类型当然不会出错了。

#### 3、HttpServletRequest ####

HttpServletRequest 是在 ServletRequest 基础上做的进一步封装，使得其更适用于基于 HTTP 的服务特性，在原有的 ServletRequest API 基础上增加了处理 HTTP 的操作。Servlet 容器开发厂商会依据 HttpServletRequest API 进行具体实现。

package javax.servlet.http;
    
    import javax.servlet.ServletRequest;
    import java.util.Enumeration;
    
    /**
     * 继承自javax.servlet.ServletRequest.
     * 专门为HTTP Servlet提供的请求封装类.
     * 由容器创建并传递给Servlet的sevice类.
     */
    public interface HttpServletRequest extends ServletRequest {
        
    
        /**
         * 基于BASIC认证.
         */
        public static final String BASIC_AUTH = "BASIC";
        
        /**
         * 基于FORM认证.
         */
        public static final String FORM_AUTH = "FORM";
        
        /**
         * 基于CLIENT_CERT认证.
         */
        public static final String CLIENT_CERT_AUTH = "CLIENT_CERT";
        
        /**
         * 基于DIGEST认证.
         */
        public static final String DIGEST_AUTH = "DIGEST";
    
        /**
         * 返回认证类型.
         * 所有Servlet容器都支持basic、form、client_cert，digest不一定支持.
         * 若不支持，则返回null.
         */
        public String getAuthType();
        
        /**
         * 获取请求中带有的Cookie信息.
         */
        public Cookie[] getCookies();
        
        /**
         * 以长整数形式返回一个特定的请求头，该长整数代表一个Date对象. 
         * 该方法可以用在包含时间信息的header中，如：If-Modified-Since.
         * @param name 头名称.
         * @return 头值.
         */
        public long getDateHeader(String name);
        
        /**
         * 根据指定的头名称获取头的值.
         * 若存在多个，则返回第一个.
         * @param name 头名称.
         * @return 头值.
         */
        public String getHeader(String name); 
    
        /**
         * 根据指定的头名称获取头值的枚举.
         * 若没有找到，则返回空的枚举.
         * @param name 头名称.
         * @return 头值.
         */
        public Enumeration getHeaders(String name); 
        
        /**
         * 获取所有的头的枚举.
         * @return 头的枚举.
         */
        public Enumeration getHeaderNames();
    
        /**
         * 根据指定头名称获取int类型的值.若未找到则返回-1，如不是int类型，则会抛出NumberFormatException异常.
         * @param name 头名称.
         * @return 头值.
         */
        public int getIntHeader(String name);
        
        /**
         * 获取HTTP方法，如：GET、POST、PUT等.
         * @return 方法名.
         */
        public String getMethod();
        
        /**
         * 官网解释：
         *  返回与客户端发出此请求时发送的URL相关联的任何额外路径信息.
         *  额外的路径信息跟随servlet路径，但位于查询字符串之前，并以"/"字符开头.
         * 例如：url-pattern配置为/demo/*，请求URL为http://localhost/Pro/demo/htm/index.html，则pathInfo为/htm/index.html.
         * @return
         */
        public String getPathInfo();
    
        /**
         * 返回servlet名称之后、
         *      查询字符串之前的任何额外路径信息，并将其转换为实际路径. 
         *      与转换的CGI变量PATH U的值相同
         * @return
         */
        public String getPathTranslated();
    
        /**
         * 返回项目根路径.
         * 例如：url-pattern配置为/demo/*，请求URL为http://localhost/Pro/demo/htm/index.html，则contextPath为/demo.
         * @return 项目根路径.
         */
        public String getContextPath();
    
        /**
         * 获得请求中的查询字符串，例如a=1&b=2这样的格式.
         * @return 查询字符串.
         */
        public String getQueryString();
        
        /**
         * 如果用户已经过验证，则返回发出此请求的用户的登录信息，如果用户未经过验证，则返回 null.
         * 用户名是否随每个后续请求发送取决于浏览器和验证类型,返回的值与 CGI变量REMOTE_USER的值相同.
         * @return 用户信息.
         */
        public String getRemoteUser();
        
        /**
         * 返回一个 boolean值，指示指定的逻辑"角色"中是否包含经过验证的用户.
         * 角色和角色成员关系可使用部署描述符定义.
         * 如果用户没有经过验证，则该方法返回 false.
         * @param role 角色.
         * @return 已验证用户是否属于某种角色.
         */
        public boolean isUserInRole(String role);
        
        /**
         * 返回包含当前已经过验证的用户的名称的 java.security.Principal对象.
         * 如果用户没有经过验证，则该方法返回 null.
         * @return java.security.Principal或null.
         */
        public java.security.Principal getUserPrincipal();
    
        /**
         * 获取请求对应的sessionId.
         * @return sessionId.会话ID.
         */
        public String getRequestedSessionId();
        
        /**
         * 请求URL的相对地址，包括服务器路径，不包括查询参数.
         * @return 请求URL的相对地址.
         */
        public String getRequestURI();
        
        /**
         * 请求的URL地址，包含协议、主机名、端口和服务器路径，但是不包括查询参数.
         * @return 请求URL地址.
         */
        public StringBuffer getRequestURL();
        
        /**
         * 官方解释：
         *  返回此请求的URL中调用servlet的部分.
         *  此路径以"/"字符开头，包含servlet名称或到servlet的路径，但不包含任何额外的路径信息或查询字符串.
         *  与CGI变量SCRIPT_NAME的值相同.
         * 其实真是的意思就是，在配置webx.xml或编程式配置时，配置了url-pattern，请求的URL与url-pattern的有效部分重合部分就是servletPath，
         * 也可以理解为url-pattern的有效部分就是servletPath.
         * 例如：url-pattern配置为/demo/*，请求URL为http://localhost/Pro/demo/htm/index.html，则servletPath为/demo.
         * @return
         */
        public String getServletPath();
    
        /**
         * 获得请求对应的当前sesson.
         * 在没有session的情况下：
         *  若create=true，则新创建一个session.
         *  若create=false，则不创建session，返回null.
         * @param create session失效的情况下，是否创建session.
         * @return HttpSession实例.
         */
        public HttpSession getSession(boolean create);
        
        /**
         * 获得请求对应的当前sesson.
         * 若没有session，则创建一个session.
         * @return HttpSession实例.
         */
        public HttpSession getSession();
    
        /**
         * 返回session是否有效.
         * @return session是否有效.
         */
        public boolean isRequestedSessionIdValid();
    
        /**
         * sessionId是否从Cookie中获得.
         * @return 若是从Cookie中获得，返回true，否则返回false.
         */
        public boolean isRequestedSessionIdFromCookie();
    
        /**
         * sessionId是否从URL中获得.
         * @return 若是从URL中获得，返回true，否则返回false.
         */
        public boolean isRequestedSessionIdFromURL();
        
        /**
         * @deprecated
         * sessionId是否从URL中获得.
         * @return 若是从URL中获得，返回true，否则返回false.
         */
        public boolean isRequestedSessionIdFromUrl();
        
    }

#### 4、HttpServletResponse ####

HttpServletResponse 是在 ServletResponse 基础上做的进一步封装，使得其更适用于基于 HTTP 的服务特性，在原有的 ServletResponse API 基础上增加了处理 HTTP 的操作。 Servlet 容器开发厂商会依据 HttpServletResponse API 进行具体实现。

package javax.servlet.http;
    
    import java.io.IOException;
    
    import javax.servlet.ServletResponse;
    
    /**
     * 继承自ServletResponse类，HttpServletResponse提供了HTTP专用的功能. 
     * 例如：HTTP Headers和Cookies的设置.
     * Servlet容器创建HttpServletResponse实例，并将它传递给Servlet的service方法.
     */
    public interface HttpServletResponse extends ServletResponse {
        
    
        /**
         * 设置指定Cookie到response中.
         * 可以被多次调用，可以设置多个Cookie.
         * @param Cookie实例.
         */
        public void addCookie(Cookie cookie);
        
        /**
         * 判断response中是否包含某个响应头.
         * @param 响应头名称.
         * @return 存在返回true，否则返回false.
         */
        public boolean containsHeader(String name);
    
        /**
         * 对指定URL进行编码，编码后包含会话ID，若逻辑判断不需要编码，则返回原URL.
         * 此方法的实现需包括：确定会话ID是否需要包含在编码后的URL中，例如，当浏览器支持Cookie时，或者URL重写（会话跟踪）被关闭时，则不需要URL编码，直接返回原URL.
         * 对于健壮的会话跟踪，Servlet发出的所有URL都应该通过这个方法运行.否则，URL重写不能用于不支持Cookie的浏览器.
         * @param 待编码的URL.
         * @return 已编码的URL.
         */
        public String encodeURL(String url);
    
        /**
         * 对指定URL进行编码，编码后包含会话ID，若逻辑判断不需要编码，则返回原URL.
         * HttpServletResponse.sendRedirect调用前，需调用此方法进行URL编码.
         * 此方法包括是否包含会话ID的逻辑.
         * 此方法包含会话ID的逻辑与encodeURL(String url)是不同的，所以进行了分离.
         * 所有发送到HttpServletResponse.sendRedirect方法应通过此方法运行，否则，URL重写不能用于不支持cookies的浏览器.
         * @param 待编码的URL.
         * @return 已编码的URL.
         */
        public String encodeRedirectURL(String url);
    
        /**
         * @deprecated 
         * 已弃用，使用encodeURL(String url).
         */
        public String encodeUrl(String url);
    
        /**
         * @deprecated 
         * 已弃用，使用encodeRedirectURL(String url).
         */
        public String encodeRedirectUrl(String url);
    
        /**
         * 写入指定的状态码和错误描述信息，并清除缓冲区，将错误响应给客户端.
         * 如果响应已经提交，此方法将抛出一个IllegalStateException，使用此方法后，应将响应视为已提交，不应写入.
         * @param 错误状态码.
         * @param 错误描述信息.
         */
        public void sendError(int sc, String msg) throws IOException;
    
        /**
         * 写入指定的状态码，并清除缓冲区，将错误响应给客户端.
         * 如果响应已经提交，此方法将抛出一个IllegalStateException，使用此方法后，应将响应视为已提交，不应写入.
         * @param 错误状态码.
         */
        public void sendError(int sc) throws IOException;
    
        /**
         * 使用指定的重定向位置URL向客户端发送临时重定向响应.
         * 此方法可以接受相对URL，Servlet容器必须在向客户机发送响应之前将相对URL转换为绝对URL.
         * 如果位置是相对的而没有前导"/"，容器会将其解释为相对于当前请求URI.
         * 如果位置与前导"/"相关，则容器会将其解释为相对于servlet容器根.
         * 如果响应已经提交，此方法将抛出一个IllegalStateException，使用此方法后，应将响应视为已提交，不应写入.
         * @param 重定向地址.
         */
        public void sendRedirect(String location) throws IOException;
    
        /**
         * 设置Date类型头信息.若已经存在指定的头，则会覆盖.
         * @param 头名称.
         * @param 头值.
         */
        public void setDateHeader(String name, long date);
    
        /**
         * 新增Date类型头信息.不管是否存在，都会追加，可允许存在多个同名的头.
         * @param 头名称.
         * @param 头值.
         */
        public void addDateHeader(String name, long date);
    
        /**
         * 设置头信息.若已经存在指定的头，则会覆盖.
         * @param 头名称.
         * @param 头值.
         */
        public void setHeader(String name, String value);
    
        /**
         * 新增头信息.不管是否存在，都会追加，可允许存在多个同名的头.
         * @param 头名称.
         * @param 头值.
         */
        public void addHeader(String name, String value);
    
        /**
         * 设置int类型头信息.若已经存在指定的头，则会覆盖.
         * @param 头名称.
         * @param 头值.
         */
        public void setIntHeader(String name, int value);
    
        /**
         * 新增int类型头信息.不管是否存在，都会追加，可允许存在多个同名的头.
         * @param 头名称.
         * @param 头值.
         */
        public void addIntHeader(String name, int value);
    
        /**
         * 设置response的状态码.
         * 此方法被用来设置成功状态码，出现错误设置状态码使用sendError方法.
         * 例如：SC_OK、SC_MOVED_TEMPORARILY.
         * @param 状态码.
         */
        public void setStatus(int sc);
    
        /**
         * @deprecated 
         * 设置response的状态码.
         * 此方法被用来设置成功状态码，出现错误设置状态码使用sendError方法.
         * 例如：SC_OK、SC_MOVED_TEMPORARILY.
         * @param 状态码.
         * @param 状态描述.
         */
        public void setStatus(int sc, String sm);
    
        /*
         * 服务端响应状态码. 参考查看RFC 2068标准.
         */
        /**
         * CONTINUE：继续，客户端应继续其请求.
         */
        public static final int SC_CONTINUE = 100;
    
        /**
         * SWITCHING_PROTOCOLS：切换协议。服务器根据客户端的请求切换协议.只能切换到更高级的协议，例如，切换到HTTP的新版本协议.
         */
        public static final int SC_SWITCHING_PROTOCOLS = 101;
    
        /**
         * OK：请求成功.一般用于GET与POST请求.
         */
        public static final int SC_OK = 200;
    
        /**
         * CREATED：已创建.成功请求并创建了新的资源.
         */
        public static final int SC_CREATED = 201;
    
        /**
         * ACCEPTED：已接受.已经接受请求，但未处理完成.
         */
        public static final int SC_ACCEPTED = 202;
    
        /**
         * NON_AUTHORITATIVE_INFORMATION：非授权信息.请求成功.但返回的meta信息不在原始的服务器，而是一个副本.
         */
        public static final int SC_NON_AUTHORITATIVE_INFORMATION = 203;
    
        /**
         * NO_CONTENT：无内容.服务器成功处理，但未返回内容.在未更新网页的情况下，可确保浏览器继续显示当前文档.
         */
        public static final int SC_NO_CONTENT = 204;
    
        /**
         * RESET_CONTENT：重置内容.服务器处理成功，用户终端（例如：浏览器）应重置文档视图.可通过此返回码清除浏览器的表单域.
         */
        public static final int SC_RESET_CONTENT = 205;
    
        /**
         * PARTIAL_CONTENT：部分内容.服务器成功处理了部分GET请求.
         */
        public static final int SC_PARTIAL_CONTENT = 206;
    
        /**
         * MULTIPLE_CHOICES：多种选择.请求的资源可包括多个位置，相应可返回一个资源特征与地址的列表用于用户终端（例如：浏览器）选择.
         */
        public static final int SC_MULTIPLE_CHOICES = 300;
    
        /**
         * SC_MOVED_PERMANENTLY：永久移动.请求的资源已被永久的移动到新URI，返回信息会包括新的URI，浏览器会自动定向到新URI.今后任何新的请求都应使用新的URI代替.
         */
        public static final int SC_MOVED_PERMANENTLY = 301;
    
        /**
         * MOVED_TEMPORARILY：临时移动.与301类似.但资源只是临时被移动.客户端应继续使用原有URI.
         */
        public static final int SC_MOVED_TEMPORARILY = 302;
    
        /**
         * SC_FOUND：临时移动.与301类似.但资源只是临时被移动.客户端应继续使用原有URI.
         */
        public static final int SC_FOUND = 302;
    
        /**
         * SEE_OTHER：查看其它地址.与301类似.使用GET和POST请求查看.
         */
        public static final int SC_SEE_OTHER = 303;
    
        /**
         * NOT_MODIFIED：未修改.所请求的资源未修改，服务器返回此状态码时，不会返回任何资源.客户端通常会缓存访问过的资源，通过提供一个头信息指出客户端希望只返回在指定日期之后修改的资源.
         */
        public static final int SC_NOT_MODIFIED = 304;
    
        /**
         * USE_PROXY：使用代理.所请求的资源必须通过代理访问.
         */
        public static final int SC_USE_PROXY = 305;
    
        /**
         * TEMPORARY_REDIRECT：临时重定向.与302类似.使用GET请求重定向.
         */
        public static final int SC_TEMPORARY_REDIRECT = 307;
    
        /**
         * BAD_REQUEST：客户端请求的语法错误，服务器无法理解.
         */
        public static final int SC_BAD_REQUEST = 400;
    
        /**
         * UNAUTHORIZED：请求要求用户的身份认证.
         */
        public static final int SC_UNAUTHORIZED = 401;
    
        /**
         * PAYMENT_REQUIRED：保留，将来使用.
         */
        public static final int SC_PAYMENT_REQUIRED = 402;
    
        /**
         * FORBIDDEN：服务器理解请求客户端的请求，但是拒绝执行此请求.
         */
        public static final int SC_FORBIDDEN = 403;
    
        /**
         * NOT_FOUND：服务器无法根据客户端的请求找到资源（网页）.通过此代码，网站设计人员可设置"您所请求的资源无法找到"的个性页面.
         */
        public static final int SC_NOT_FOUND = 404;
    
        /**
         * METHOD_NOT_ALLOWED：客户端请求中的方法被禁止.
         */
        public static final int SC_METHOD_NOT_ALLOWED = 405;
    
        /**
         * NOT_ACCEPTABLE：服务器无法根据客户端请求的内容特性完成请求.
         */
        public static final int SC_NOT_ACCEPTABLE = 406;
    
        /**
         * PROXY_AUTHENTICATION_REQUIRED：请求要求代理的身份认证，与401类似，但请求者应当使用代理进行授权.
         */
        public static final int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
    
        /**
         * REQUEST_TIMEOUT：服务器等待客户端发送的请求时间过长，超时.
         */
        public static final int SC_REQUEST_TIMEOUT = 408;
    
        /**
         * CONFLICT：服务器完成客户端的PUT请求时可能返回此代码，服务器处理请求时发生了冲突.
         */
        public static final int SC_CONFLICT = 409;
    
        /**
         * GONE：客户端请求的资源已经不存在.410不同于404，如果资源以前有现在被永久删除了可使用410代码，网站设计人员可通过301代码指定资源的新位置.
         */
        public static final int SC_GONE = 410;
    
        /**
         * LENGTH_REQUIRED：服务器无法处理客户端发送的不带Content-Length的请求信息.
         */
        public static final int SC_LENGTH_REQUIRED = 411;
    
        /**
         * PRECONDITION_FAILED：客户端请求信息的先决条件错误.
         */
        public static final int SC_PRECONDITION_FAILED = 412;
    
        /**
         * REQUEST_ENTITY_TOO_LARGE：由于请求的实体过大，服务器无法处理，因此拒绝请求.为防止客户端的连续请求，服务器可能会关闭连接.如果只是服务器暂时无法处理，则会包含一个Retry-After的响应信息.
         */
        public static final int SC_REQUEST_ENTITY_TOO_LARGE = 413;
    
        /**
         * SC_REQUEST_URI_TOO_LONG：请求的URI过长（URI通常为网址），服务器无法处理.
         */
        public static final int SC_REQUEST_URI_TOO_LONG = 414;
    
        /**
         * UNSUPPORTED_MEDIA_TYPE：服务器无法处理请求附带的媒体格式.
         */
        public static final int SC_UNSUPPORTED_MEDIA_TYPE = 415;
    
        /**
         * REQUESTED_RANGE_NOT_SATISFIABLE：客户端请求的范围无效.
         */
        public static final int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
    
        /**
         * EXPECTATION_FAILED：服务器无法满足Expect的请求头信息.
         */
        public static final int SC_EXPECTATION_FAILED = 417;
    
        /**
         * INTERNAL_SERVER_ERROR：服务器内部错误，无法完成请求.
         */
        public static final int SC_INTERNAL_SERVER_ERROR = 500;
    
        /**
         * NOT_IMPLEMENTED：服务器不支持请求的功能，无法完成请求.
         */
        public static final int SC_NOT_IMPLEMENTED = 501;
    
        /**
         * BAD_GATEWAY：作为网关或者代理工作的服务器尝试执行请求时，从远程服务器接收到了一个无效的响应.
         */
        public static final int SC_BAD_GATEWAY = 502;
    
        /**
         * SERVICE_UNAVAILABLE：由于超载或系统维护，服务器暂时的无法处理客户端的请求.延时的长度可包含在服务器的Retry-After头信息中.
         */
        public static final int SC_SERVICE_UNAVAILABLE = 503;
    
        /**
         * GATEWAY_TIMEOUT：充当网关或代理的服务器，未及时从远端服务器获取请求.
         */
        public static final int SC_GATEWAY_TIMEOUT = 504;
    
        /**
         * GATEWAY_TIMEOUT：服务器不支持请求的HTTP协议的版本，无法完成处理.
         */
        public static final int SC_HTTP_VERSION_NOT_SUPPORTED = 505;
        
    }

[JavaWeb_JavaWeb]: https://lizhengi.blog.csdn.net/article/details/127917502
[Java]: https://lizhengi.blog.csdn.net/article/details/127475827