二、Servlet

二、Servlet
一、Servlet概述

Servlet类由我们来写，但对象由服务器来创建，并且由服务器来调用相应的方法。

1.1、什么是Servlet

Servlet是JavaWeb的三大组件之一（Servlet、Filter、Listener），它属于动态资源。Servlet的作用是处理请求，服务器会把接收到的请求交给Servlet来处理，在Servlet中通常需要：
- - 接收请求数据；
- - 处理请求；
  - 完成响应。
1.2、实现Servlet的方式

实现Servlet有三种方式：
- - 实现javax.servlet.Servlet接口；
  - 继承javax.servlet.GenericServlet类；
  - 继承javax.servlet.http.HttpServlet类；
通常我们会去继承HttpServlet类来完成我们的Servlet，但学习Servlet还要从javax.servlet.Servlet接口开始学习。

二、实现Servlet接口
- 创建maven工程导入依赖
```
<dependencies>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
      </dependency>
</dependencies>
```
- 创建servlet类
```
public class Servlet_01 implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest req, ServletResponse reps) throws Exception{
        System.out.println("hello servlet!");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}
```
　　我们暂时忽略Servlet中其他四个方法，只关心service()方法，因为它是用来处理请求的方法。我们在该方法内给出一条输出语句！
- 配置web.xml
```
<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.jdy.web.servlet.Servlet_01</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/helloworld</url-pattern>
</servlet-mapping>
```
启动服务器，访问helloword

2.1、Servlet的生命周期：

　　所谓生命周期，就是说xxx的出生、服务，以及死亡。与Servlet的生命周期相关的方法有
```
//第一次访问时调用，或者再web.xml中配置成服务器启动调用,只调用一次；
void init(ServletConfig)：

//每次处理请求时都会被调用；
void service(ServletRequest request, ServletResponse response)

//临死之前（1次）；
void destroy()：
```
(1)、Servlet的出生
- 默认情况下：Servlet第一次被访问时创建Servlet
- web.xml配置：服务器启动时创建Servlet
- Servlet是单例
- Servlet出生后马上就会调用init()方法，而且一个Servlet的一生这个方法只会被调用一次（构造方法在init方法之前）
(2)、Servlet服务

　　当服务器每次接收到请求时，都会去调用Servlet的service()方法来处理请求。正因为如此，所以我们才需要把处理请求的代码写到service()方法中！

(3)、Servlet的离去
- 通常都是在服务器关闭时Servlet才会离去！
- 在销毁Servlet之前服务器会先去调用Servlet的destroy()方法，可以把Servlet的临终遗言放到destroy()方法中，例如对某些资源的释放等代码放到destroy()方法中。
测试生命周期
```
public class Servlet_01 implements Servlet {

    public Servlet_01() {
        System.out.println("Constructor..");
    }

    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("init Method");
    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {

        System.out.println("service Method");
    }

    @Override
    public void destroy() {
        System.out.println("destroy Method");

    }
}
```
　　访问：http://localhost:8080/helloworld ，然后关闭服务器。

2.2、Servlet接口相关类型

　　在Servlet接口中还存在三个我们不熟悉的参数类型：
- - ServletRequest：service() 方法的参数，它表示请求对象，它封装了所有与请求相关的数据，它是由服务器创建的；
  - ServletResponse：service()方法的参数，它表示响应对象，在service()方法中完成对客户端的响应需要使用这个对象；
  - ServletConfig：init()方法的参数，它表示Servlet配置对象，它对应Servlet的配置信息，那对应web.xml文件中的<servlet>元素。
(1)、ServletRequest和ServletResponse

　　ServletRequest 和ServletResponse的实例由服务器创建，然后传递给service()方法。如果在service() 方法中希望使用HTTP相关的功能，那么可以把ServletRequest和ServletResponse强转成HttpServletRequest和HttpServletResponse。这也说明我们经常需要在service()方法中对ServletRequest和ServletResponse进行强转，这是很心烦的事情。不过后面会有一个类来帮我们解决这一问题的。
- HttpServletRequest
  - String getParameter(String paramName)：获取指定请求参数的值；
  - String getMethod()：获取请求方法，例如GET或POST；
  - String getHeader(String name)：获取指定请求头的值；
  - void setCharacterEncoding(String encoding)：设置请求体的编码！因为GET请求没有请求体，所以这个方法只只对POST请求有效。当调用request.setCharacterEncoding(“utf-8”)之后，再通过getParameter()方法获取参数值时，那么参数值都已经通过了转码，即转换成了UTF-8编码。所以，这个方法必须在调用getParameter()方法之前调用！
- HttpServletResponse
  - PrintWriter getWriter()：获取字符响应流，使用该流可以向客户端输出响应信息。例如
```
response.getWriter().print(“<h1>Hello JavaWeb!</h1>”)；
```
- - ServletOutputStream getOutputStream()：获取字节响应流，当需要向客户端响应字节数据时，需要使用这个流，例如要向客户端响应图片；
  - void setCharacterEncoding(String encoding)：用来设置字符响应流的编码，例如在调用setCharacterEncoding(“utf-8”);之后，再response.getWriter()获取字符响应流对象，这时的响应流的编码为utf-8，使用response.getWriter()输出的中文都会转换成utf-8编码后发送给客户端；
  - void setHeader(String name, String value)：向客户端添加响应头信息，例如setHeader(“Refresh”, “3;url=https://www.baidu.com/”)，表示3秒后自动刷新到 https://www.baidu.com/；
  - void setContentType(String contentType)：该方法是setHeader(“content-type”, “xxx”)的简便方法，即用来添加名为content-type响应头的方法。content-type响应头用来设置响应数据的MIME类型，例如要向客户端响应jpg的图片，那么可以setContentType(“image/jepg”)，如果响应数据为文本类型，那么还要台同时设置编码，例如setContentType(“text/html;chartset=utf-8”)表示响应数据类型为文本类型中的html类型，并且该方法会调用setCharacterEncoding(“utf-8”)方法；
  - void sendError(int code, String errorMsg)：向客户端发送状态码，以及错误消息。例如给客户端发送404：response(404, “您要查找的资源不存在！”)。
(2)、ServletConfig

　　ServletConfig对象对应web.xml文件中的<servlet>元素。例如你想获取当前Servlet在web.xml文件中的配置名，那么可以使用servletConfig.getServletName()方法获取！ServletConfig对象是由服务器创建的，然后传递给Servlet的init()方法，你可以在init()方法中使用它！
- String getServletName()：获取Servlet在web.xml文件中的配置名称，即<servlet-name>指定的名称；
- ServletContext getServletContext()：用来获取ServletContext对象，ServletContext会在后面讲解；
- String getInitParameter(String name)：用来获取在web.xml中配置的初始化参数，通过参数名来获取参数值；
- Enumeration getInitParameterNames()：用来获取在web.xml中配置的所有初始化参数名称；
三、GenericServlet

3.1、GenericServlet概述

　　GenericServlet是Servlet接口的实现类，我们可以通过继承GenericServlet来编写自己的Servlet。

3.2、GenericServlet的init()方法

　　在GenericServlet中，定义了一个ServletConfig config实例变量，并在init(ServletConfig)方法中把参数ServletConfig赋给了实例变量。然后在该类的很多方法中使用了实例变量config。

　　如果子类覆盖了GenericServlet的init(StringConfig)方法，那么this.config=config这一条语句就会被覆盖了，也就是说GenericServlet的实例变量config的值为null，那么所有依赖config的方法都不能使用了。如果真的希望完成一些初始化操作，那么去覆盖GenericServlet提供的init()方法，它是没有参数的init()方法，它会在init(ServletConfig)方法中被调用。

3.3、实现了ServletConfig接口

　　GenericServlet还实现了ServletConfig接口，所以可以直接调用getInitParameter()、getServletContext()等ServletConfig的方法。

四、HttpServlet

4.1、HttpServlet概述

　　HttpServlet类是GenericServlet的子类，它提供了对HTTP请求的特殊支持，所以通常我们都会通过继承HttpServlet来完成自定义的Servlet。

4.2、HttpServlet覆盖了service()方法

　　HttpServlet类中的service(HttpServletRequest,HttpServletResponse)方法，不是从Servlet继承来的

4.3、doGet()和doPost()

　　在HttpServlet的service(HttpServletRequest,HttpServletResponse)方法会去判断当前请求是GET还是POST，如果是GET请求，那么会去调用本类的doGet()方法，如果是POST请求会去调用doPost()方法，这说明我们在子类中去覆盖doGet()或doPost()方法即可。

五、Servlet细节

5.1、Servlet与线程安全

　　“不是线程安全的”。这说明Servlet的工作效率很高，但也存在线程安全问题！

　　所以我们不应该在Servlet中便宜创建成员变量，因为可能会存在一个线程对这个成员变量进行写操作，另一个线程对这个成员变量进行读操作。

5.2、让服务器在启动时就创建Servlet

　　默认情况下，服务器会在某个Servlet第一次收到请求时创建它。也可以在web.xml中对Servlet进行配置<load-on-startup>，使服务器启动时就创建Servlet。<load-on-startup>元素的值必须是大于等于0的整数，值越小启动顺序越靠前

5.3、<url-pattern>

　　<url-pattern>是<servlet-mapping>的子元素，用来指定Servlet的访问路径，即URL。它必须是以“/”开头！
- 可以在<servlet-mapping>中给出多个<url-pattern>，例如：
```
 <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.jdy.web.servlet.Servlet_01</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/helloworld</url-pattern>
        <url-pattern>/AServlet</url-pattern>
        <url-pattern>/BServlet</url-pattern>
    </servlet-mapping>
```
　　那么这说明一个Servlet绑定了两个URL，无论访问/AServlet还是/BServlet，访问的都是helloworld。
- 还可以在<url-pattern>中使用通配符，所谓通配符就是星号“*”，星号可以匹配任何URL前缀或后缀，使用通配符可以命名一个Servlet绑定一组URL，例如：
  - <url-pattern>/servlet/*<url-patter>：/servlet/a、/servlet/b，都匹配/servlet/*；
  - <url-pattern>*.do</url-pattern>：/abc/def/ghi.do、/a.do，都匹配*.do；
  - <url-pattern>/*<url-pattern>：匹配所有URL；
　　请注意，通配符要么为前缀，要么为后缀，不能出现在URL中间位置，也不能只有通配符。例如：/*.do就是错误的，因为星号出现在URL的中间位置上了。.也是不对的，因为一个URL中最多只能出现一个通配符。

5.4、web.xml文件的继承

　　在${CATALINA_HOME}confweb.xml中的内容，相当于写到了每个项目的web.xml中，它是所有web.xml的父文件。每个完整的JavaWeb应用中都需要有web.xml，但我们不知道所有的web.xml文件都有一个共同的父文件，它在Tomcat的conf/web.xml路径。

六、ServletContext
- 一个项目只有一个ServletContext对象！
- 可以在N多个Servlet中来获取这个唯一的对象，使用它可以给多个Servlet传递数据！
- 这个对象在Tomcat启动时就创建，在Tomcat关闭时才会死去！
6.1、ServletContext概述

　　服务器会为每个应用创建一个ServletContext对象：
- - ServletContext对象的创建是在服务器启动时完成的；
  - ServletContext对象的销毁是在服务器关闭时完成的。
ServletContext对象的作用是在整个Web应用的动态资源之间共享数据！

6.2、获取ServletContext
- ServletConfig#getServletContext()；
```
ServletContext servletContext = config.getServletContext();
```
- GenericServlet#getServletContext();
```
ServletContext servletContext = this.getServletContext();
```
- HttpSession#getServletContext()
- ServletContextEvent#getServletContext()
```
public class Servlet_03 extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        ServletContext servletContext = this.getServletContext();
    }
}
```
6.3、域对象的功能

　　ServletContext是JavaWeb四大域对象之一：
- - PageContext；
  - ServletRequest；
  - HttpSession；
  - ServletContext；
所有域对象都有存取数据的功能，因为域对象内部有一个Map，用来存储数据，下面是ServletContext对象用来操作数据的方法：
```
//用来存储一个对象，如果多次调用该方法，并且使用相同的name，那么会覆盖上一次的值，这一特性与Map相同
void setAttribute(String name, Object value)：

//用来获取ServletContext中的数据
Object getAttribute(String name)：

//用来移除ServletContext中的域属性
void removeAttribute(String name)：

//获取所有域属性的名称；
Enumeration getAttributeNames()：
```
6.4、获取应用初始化参数
```
<context-param>
        <param-name>context-param</param-name>
        <param-value>444</param-value>
</context-param>
```
```
ServletContext servletContext = this.getServletContext();
String initParameter3 = servletContext.getInitParameter("context-param");
System.out.println("initParameter3 = " + initParameter3);

Enumeration names = servletContext.getInitParameterNames();
while(names.hasMoreElements()) {
  System.out.println(names.nextElement());
}
```
6.5、获取资源相关方法

(1)、获取真实路径

　　还可以使用ServletContext对象来获取Web应用下的资源
- 获取a.txt的真实路径：
```
String realPath = servletContext.getRealPath("/WEB-INF/a.txt");

//E:suning_workspacejdy-testweb-2020outartifactsweb_2020_war_explodedWEB-INFa.txt
```
- 获取b.txt的真实路径：
```
String realPath = servletContext.getRealPath("/b.txt");
//E:suning_workspacejdy-testweb-2020outartifactsweb_2020_war_exploded.txt
```
(2)、获取资源流

　　不只可以获取资源的路径，还可以通过ServletContext获取资源流，即把资源以输入流的方式获取：
- - 获取a.txt资源流：InputStream in = servletContext.getResourceAsStream(/b.txt”)；
  - 获取b.txt资源流：InputStream in = servletContext.getResourceAsStream(“/WEB-INF/a.txt”)；
(3)、获取指定目录下所有资源路径

　　还可以使用ServletContext获取指定目录下所有资源路径，例如获取/WEB-INF下所有资源的路
```
    Set set = context.getResourcePaths("/WEB-INF");
    System.out.println(set);
```
6.6、访问量统计
- 一个项目中所有的资源被访问都要对访问量进行累加！
- 创建一个int类型的变量，用来保存访问量，然后把它保存到ServletContext的域中，这样可以保存所有的Servlet都可以访问到！
- 最初时，ServletContext中没有保存访问量相关的属性；
- 当本站第一次被访问时，创建一个变量，设置其值为1；保存到ServletContext中；当以后的访问时，就可以从ServletContext中获取这个变量，然后在其基础之上加１。
- 获取ServletContext对象，查看是否存在名为count的属性，如果存在，说明不是第一次访问，如果不存在，说明是第一次访问；
- 第一次访问：调用Servletcontext的setAttribute()传递一个属性，名为count，值为1；第2~N次访问：调用ServletContext的getAttribute()方法获取原来的访问量，给访问量加1，再调用Servletcontext的setAttribute()方法完成设置。
- 相信大家一定见过很多访问量统计的网站，即“本页面被访问过XXX次”。因为无论是哪个用户访问指定页面，都会累计访问量，所以这个访问量统计应该是整个项目共享的！很明显，这需要使用ServletContext来保存访问量。
```
ServletContext application  = this.getServletContext();
Integer count = (Integer)application.getAttribute("count");
if(count == null) {
  count = 1;
} else {
  count++;
}
resp.setContentType("text/html;charset=utf-8");
resp.getWriter().print("<h1>本页面一共被访问" + count + "次！</h1>");
application.setAttribute("count", count);
```
七、获取类路径下资源

　　获取类路径资源，类路径对一个JavaWeb项目而言，就是/WEB-INF/classes和/WEB-INF/lib/每个jar包！
- - Class
  - ClassLoader：
```
InputStream in = this.getClass().getResourceAsStream("/xxx.txt");
InputStream in = this.getClass().getClassLoader().getResourceAsStream("xxx.txt");
```
　　Class类的getResourceAsStream(String path)：
- - 路径以“/”开头，相对classes路径；
  - 路径不以“/”开头，相对当前class文件所有路径，例如在cn.jdy.servlet.MyServlet中执行，那么相对/classes/cn/jdy/servlet/路径；
　　ClassLoader类的getResourceAsStream(String path)：
- - 相对classes路径；
八、response

8.1、response概述

　　response是Servlet.service方法的一个参数，类型为javax.servlet.http.HttpServletResponse。在客户端发出每个请求时，服务器都会创建一个response对象，并传入给Servlet.service()方法。response对象是用来对客户端进行响应的，这说明在service()方法中使用response对象可以完成对客户端的响应工作。

response对象的功能分为以下四种：
- 设置响应头信息；
- 发送状态码；
- 设置响应正文；
- 重定向；
8.2、response响应正文

response是响应对象，向客户端输出响应正文（响应体）可以使用response的响应流，repsonse一共提供了两个响应流对象：
```
//用字符流封装响应体
response.getWriter().print("还是乱码！");

//用字节流封装响应体
String s = "Hello outputStream";
byte[] bytes = s.getBytes();
response.getOutputStream().write(bytes);

// 把一张图片读取到字节数组中
String path = "E:/a.jpg";
FileInputStream in = new FileInputStream(path);

int len = 0;
byte[] by = new byte[1024];
while((len = in.read(by))!=-1){
  response.getOutputStream().write(by,0,len);
}
```
　　当然，如果响应正文内容为字符，那么使用response.getWriter()，如果响应内容是字节，例如下载时，那么可以使用response.getOutputStream()。

　　注意，在一个请求中，不能同时使用这两个流！也就是说，要么你使用repsonse.getWriter()，要么使用response.getOutputStream()，但不能同时使用这两个流。不然会抛出IllegalStateException异常。

(1)、字符响应流
- 字符编码
　　在使用response.getWriter()时需要注意默认字符编码为ISO-8859-1，如果希望设置字符流的字符编码为utf-8，可以使用response.setCharaceterEncoding(“utf-8”)来设置。这样可以保证输出给客户端的字符都是使用UTF-8编码的！但客户端浏览器并不知道响应数据是什么编码的！如果希望通知客户端使用UTF-8来解读响应数据，那么还是使用response.setContentType("text/html;charset=utf-8")方法比较好，因为这个方法不只会调用response.setCharaceterEncoding(“utf-8”)，还会设置content-type响应头，客户端浏览器会使用content-type头来解读响应数据。
- 缓冲区
　　response.getWriter()是PrintWriter类型，所以它有缓冲区，缓冲区的默认大小为8KB。也就是说，在响应数据没有输出8KB之前，数据都是存放在缓冲区中，而不会立刻发送到客户端。当Servlet执行结束后，服务器才会去刷新流，使缓冲区中的数据发送到客户端。

如果希望响应数据马上发送给客户端：
- 向流中写入大于8KB的数据；
- 调用response.flushBuffer()方法来手动刷新缓冲区；
8.3、设置响应头信息

　　可以使用response对象的setHeader()方法来设置响应头！使用该方法设置的响应头最终会发送给客户端浏览器！
- response.setHeader(“content-type”, “text/html;charset=utf-8”)：设置content-type响应头，该头的作用是告诉浏览器响应内容为html类型，编码为utf-8。而且同时会设置response的字符流编码为utf-8，即response.setCharaceterEncoding(“utf-8”)；
- response.setHeader(“Refresh”,“5; URL=http://www.jdy.cn”)：5秒后自动跳转到中国主页。
8.4、设置状态码及其他方法
- response.setContentType("text/html;charset=utf-8")：等同与调用response.setHeader(“content-type”, “text/html;charset=utf-8”)；
- response.setCharacterEncoding(“utf-8”)：设置字符响应流的字符编码为utf-8；
- response.setStatus(200)：设置状态码；
- response.sendError(404, “您要查找的资源不存在”)：当发送错误状态码时，Tomcat会跳转到固定的错误页面去，但可以显示错误信息。
8.5、重定向

(1)、什么是重定向

当你访问http://www.sun.com时，你会发现浏览器地址栏中的URL会变成http://www.oracle.com/us/sun/index.htm，这就是重定向了。

重定向是服务器通知浏览器去访问另一个地址，即再发出另一个请求。

(2)、完成重定向

响应码为200表示响应成功，而响应码为302表示重定向。所以完成重定向的第一步就是设置响应码为302。

因为重定向是通知浏览器再第二个请求，所以浏览器需要知道第二个请求的URL，所以完成重定向的第二步是设置Location头，指定第二个请求的URL地址。
```
public class AServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setStatus(302);
        response.setHeader("Location", "http://www.baidu.com");
    }
}
```
上面代码的作用是：当访问AServlet后，会通知浏览器重定向到百度。客户端浏览器解析到响应码为302后，就知道服务器让它重定向，所以它会马上获取响应头Location，然发出第二个请求。

(3)、便捷的重定向方式

response.sendRedirect()方法会设置响应头为302，以设置Location响应头。如果要重定向的URL是在同一个服务器内，那么可以使用相对路径，例如：
```
public class AServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.sendRedirect("/hello/BServlet");
    }
}
```
重定向的URL地址为：http://localhost:8080/hello/BServlet。

(4)、重定向小结
- 重定向是两次请求；
- 重定向的URL可以是其他应用，不局限于当前应用；
- 重定向的响应头为302，并且必须要有Location响应头；
- 重定向就不要再使用response.getWriter()或response.getOutputStream()输出数据，不然可能会出现异常；
九、request

9.1、request概述

　　request是Servlet.service()方法的一个参数，类型为javax.servlet.http.HttpServletRequest。在客户端发出每个请求时，服务器都会创建一个request对象，并把请求数据封装到request中，然后在调用Servlet.service()方法时传递给service()方法，这说明在service()方法中可以通过request对象来获取请求数据。

request的功能可以分为以下几种：
- 封装了请求头数据；
- 封装了请求正文数据，如果是GET请求，那么就没有正文；
- request是一个域对象，可以把它当成Map来添加获取数据；
- request提供了请求转发和请求包含功能。
9.2、request域方法

　　request是域对象！在JavaWeb中一共四个域对象，其中ServletContext就是域对象，它在整个应用中只创建一个ServletContext对象。request其中一个，request可以在一个请求中共享数据。

一个请求会创建一个request对象，如果在一个请求中经历了多个Servlet，那么多个Servlet就可以使用request来共享数据。现在我们还不知道如何在一个请求中经历之个Servlet，后面在学习请求转发和请求包含后就知道了。

下面是request的域方法：
- void setAttribute(String name, Object value)**：用来存储一个对象**，也可以称之为存储一个域属性，例如：servletContext.setAttribute(“xxx”, “XXX”)，在request中保存了一个域属性，域属性名称为xxx，域属性的值为XXX。请注意，如果多次调用该方法，并且使用相同的name，那么会覆盖上一次的值，这一特性与Map相同；
- Object getAttribute(String name)：用来获取request中的数据，当前在获取之前需要先去存储才行，例如：String value = (String)request.getAttribute(“xxx”);，获取名为xxx的域属性；
- void removeAttribute(String name)：用来移除request中的域属性，如果参数name指定的域属性不存在，那么本方法什么都不做；
- Enumeration getAttributeNames()：获取所有域属性的名称；
9.3、request获取请求头数据

request与请求头相关的方法有：
- String getHeader(String name)：获取指定名称的请求头；
- Enumeration getHeaderNames()：获取所有请求头名称；
- int getIntHeader(String name)：获取值为int类型的请求头。
9.4、request获取请求相关的其它方法

　　request中还提供了与请求相关的其他方法，有些方法是为了我们更加便捷的方法请求头数据而设计，

有些是与请求URL相关的方法。
- int getContentLength()：获取请求体的字节数，GET请求没有请求体，没有请求体返回-1；
- String getContentType()：获取请求类型，如果请求是GET，那么这个方法返回null；如果是POST请求，那么默认为application/x-www-form-urlencoded，表示请求体内容使用了URL编码；
- String getMethod()：返回请求方法，例如：GET
- Locale getLocale()：返回当前客户端浏览器的Locale。java.util.Locale表示国家和言语，这个东西在国际化中很有用；
- String getCharacterEncoding()：获取请求编码，如果没有setCharacterEncoding()，那么返回null，表示使用ISO-8859-1编码；
- void setCharacterEncoding(String code)：设置请求编码，只对请求体有效！注意，对于GET而言，没有请求体！！！所以此方法只能对POST请求中的参数有效！
- String getContextPath()：返回上下文路径，例如：/hello
- String getQueryString()：返回请求URL中的参数，例如：name=zhangSan
- String getRequestURI()：返回请求URI路径，例如：/hello/oneServlet
- StringBuffer getRequestURL()：返回请求URL路径，例如：http://localhost/hello/oneServlet，即返回除了参数以外的路径信息；
- String getServletPath()：返回Servlet路径，例如：/oneServlet
- String getRemoteAddr()：返回当前客户端的IP地址；
- String getRemoteHost()：返回当前客户端的主机名，但这个方法的实现还是获取IP地址；
- String getScheme()：返回请求协议，例如：http；
- String getServerName()：返回主机名，例如：localhost
- int getServerPort()：返回服务器端口号，例如：8080
9.5、request获取请求参数

最为常见的客户端传递参数方式有两种：
- 浏览器地址栏直接输入：一定是GET请求；
- 超链接：一定是GET请求；
- 表单：可以是GET，也可以是POST，这取决与<form>的method属性值；
GET请求和POST请求的区别：
- GET请求：
  - 请求参数会在浏览器的地址栏中显示，所以不安全；
  - 请求参数长度限制长度在1K之内；
  - GET请求没有请求体，无法通过request.setCharacterEncoding()来设置参数的编码；
- POST请求：
  - 请求参数不会显示浏览器的地址栏，相对安全；
  - 请求参数长度没有限制；
```
<a href="/hello/ParamServlet?p1=v1&p2=v2">超链接</a>
    <hr/>
    <form action="/hello/ParamServlet" method="post">
        参数1：<input type="text" name="p1"/><br/>
        参数2：<input type="text" name="p2"/><br/>
        <input type="submit" value="提交"/>
    </form>
```
下面是使用request获取请求参数的API：
- String getParameter(String name)：通过指定名称获取参数值；
```
public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String v1 = request.getParameter("p1");
        String v2 = request.getParameter("p2");
        System.out.println("p1=" + v1);
        System.out.println("p2=" + v2);
    }
    
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String v1 = request.getParameter("p1");
        String v2 = request.getParameter("p2");
        System.out.println("p1=" + v1);
        System.out.println("p2=" + v2);        
    }
```
- String[] getParameterValues(String name)：当多个参数名称相同时，可以使用方法来获取；
```
<a href="/hello/ParamServlet?name=zhangSan&name=liSi ">超链接</a>
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String[] names = request.getParameterValues("name"); 
        System.out.println(Arrays.toString(names)); 
    }
```
- Enumeration getParameterNames()：获取所有参数的名字；
```
public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        Enumeration names = request.getParameterNames();
        while(names.hasMoreElements()) {
            System.out.println(names.nextElement());
        }
    }
```
- Map getParameterMap()：获取所有参数封装到Map中，其中key为参数名，value为参数值，因为一个参数名称可能有多个值，所以参数值是String[]，而不是String。
```
Map<String,String[]> paramMap = request.getParameterMap();
        for(String name : paramMap.keySet()) {
            String[] values = paramMap.get(name);
            System.out.println(name + ": " + Arrays.toString(values));
        }
```
9.6、请求转发和请求包含

无论是请求转发还是请求包含，都表示由多个Servlet共同来处理一个请求。例如Servlet1来处理请求，然后Servlet1又转发给Servlet2来继续处理这个请求。
- 请求转发和请求包含都要使用RequestDispatcher对象：RequestDispatcher rd = request.getRequestDispatcher(“/BServlet”);
- 请求转发执行RequestDispatcher的forward()方法：rd.forward(request,response);
- 请求包含执行RequestDispatcher的include()方法：rd.include(request,response);
- 请求转发和请求包含的路径都是服务器端路径，相对当前应用
(1)、请求转发

在AServlet中，把请求转发到BServlet：
```
public class AServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        System.out.println("AServlet");
        RequestDispatcher rd = request.getRequestDispatcher("/BServlet"); 
        rd.forward(request, response) ;
    }
}
public class BServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        System.out.println("BServlet");
    }
}
Aservlet
BServlet
```
(2)、请求包含

在AServlet中，把请求包含到BServlet：、
```
public class AServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        System.out.println("AServlet");
        RequestDispatcher rd = request.getRequestDispatcher("/BServlet");
        rd.include (request, response);
    }
}
public class BServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        System.out.println("BServlet");
    }
}
Aservlet
BServlet
```
(3)、请求转发与请求包含比较
- 如果在AServlet中请求转发到BServlet，那么在AServlet中就不允许再输出响应体，即不能再使用response.getWriter()和response.getOutputStream()向客户端输出，这一工作应该由BServlet来完成；如果是使用请求包含，那么没有这个限制；
- 请求转发虽然不能输出响应体，但还是可以设置响应头的，例如：response.setContentType(”text/html;charset=utf-8”);
- 请求包含大多是应用在JSP页面中，完成多页面的合并；
- 请求转发大多是应用在Servlet中，转发目标大多是JSP页面；
(4)、请求转发与重定向比较
- 请求转发是一个请求，而重定向是两个请求；
- 请求转发后浏览器地址栏不会有变化，而重定向会有变化，因为重定向是两个请求；
- 请求转发的目标只能是本应用中的资源，重定向的目标可以是其他应用；
- 请求转发对AServlet和BServlet的请求方法是相同的，即要么都是GET，要么都是POST，因为请求转发是一个请求；
- 重定向的第二个请求一定是GET；
十、路径

10.1、与路径相关的操作
- 超链接
- 表单
- 转发
- 包含
- 重定向
- <url-pattern>
- ServletContext获取资源
- Class获取资源
- ClassLoader获取资源
10.2、客户端路径

超链接、表单、重定向都是客户端路径，客户端路径可以分为三种方式：
- 绝对路径；
- 以“/”开头的相对路径；
- 不以“/”开头的相对路径；
例如：http://localhost:8080/hello1/pages/a.html中的超链接和表单如下：
```
绝对路径：
<a href="http://localhost:8080/hello2/index.html">链接1</a>
客户端路径：
<a href="/hello3/pages/index.html">链接2</a>
相对路径：
<a href="index.html">链接3</a>
<hr/>
绝对路径：
<form action="http://localhost:8080/hello2/index.html">
  <input type="submit" value="表单1"/>
</form>
客户端路径：
<form action="/hello2/index.html">
  <input type="submit" value="表单2"/>
</form>
相对路径：
<form action="index.html">
  <input type="submit" value="表单3"/>
</form>
```
- 链接1和表单1：没什么可说的，它使用绝对路径；
- 链接2和表单2：以“/”开头，相对主机，与当前a.html的主机相同，即最终访问的页面为http://localhost:8080/hello2/index.html；
- 链接3和表单3：不以“/”开头，相对当前页面的路径，即a.html所有路径，即最终访问的路径为：http://localhost:8080/hello1/pages/index.html；
重定向1：
```
public class AServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.sendRedirect("/hello/index.html");
    }
}
```
假设访问AServlet的路径为：http://localhost:8080/hello/servlet/AServlet

因为路径以“/”开头，所以相对当前主机，即http://localhost:8080/hello/index.html。

重定向2：
```
public class AServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.sendRedirect("index.html");
    }
}
```
假设访问AServlet的路径为：http://localhost:8080/hello/servlet/AServlet

因为路径不以“/”开头，所以相对当前路径，即http://localhost:8080/hello/servlet/index.html

(1)、建议使用“/”

强烈建议使用“/”开头的路径，这说明在页面中的超链接和表单都要以“/”开头，后面是当前应用的名称，再是访问路径：
```
<form action="/hello/servlet/AServlet">

</form>
<a href="/hello/b.html">链接</a>
```
其中/hello是当前应用名称，这也说明如果将来修改了应用名称，那么页面中的所有路径也要修改，这一点确实是个问题。这一问题的处理方案会在学习了JSP之后讲解！

在Servlet中的重定向也建议使用“/”开头。同理，也要给出应用的名称！例如：
```
response.sendRedirect("/hello/BServlet");
```
其中/hello是当前应用名，如果将来修改了应用名称，那么也要修改所有重定向的路径，这一问题的处理方案是使用request.getContextPath()来获取应用名称。
```
response.sendRedirect(request.getContextPath() + "/BServlet");
```
10.3、服务器端路径

服务器端路径必须是相对路径，不能是绝对路径。但相对路径有两种形式：
- 以“/”开头；
- 不以“/”开头；
其中请求转发、请求包含都是服务器端路径，服务器端路径与客户端路径的区别是：
- 客户端路径以“/”开头：相对当前主机；
- 服务器端路径以“/”开头：相对当前应用；
转发1：
```
public class AServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        request.getRequestDispatcher("/BServlet").forward(request, response);
    }
}
```
假设访问AServlet的路径为：http://localhost:8080/hello/servlet/AServlet

因为路径以“/”开头，所以相对当前应用，即http://localhost:8080/hello/BServlet。

转发2：
```
public class AServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        request.getRequestDispatcher("BServlet").forward(request, response);
    }
}
```
假设访问AServlet的路径为：http://localhost:8080/hello/servlet/AServlet

因为路径不以“/”开头，所以相对当前应用，即http://localhost:8080/hello/servlet/BServlet。

10.4、<url-pattern>路径

　　<url-pattern>必须使用“/”开头，并且相对的是当前应用。

10.5、ServletContext获取资源

必须是相对路径，可以“/”开头，也可以不使用“/”开头，但无论是否使用“/”开头都是相对当前应用路径。

例如在AServlet中获取资源，AServlet的路径路径为：http://localhost:8080/hello/servlet/AServlet：
```
public class AServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String path1 = this.getServletContext().getRealPath("a.txt");
        String path2 = this.getServletContext().getRealPath("/a.txt");
        System.out.println(path1);
        System.out.println(path2);
    }
}
```
path1和path2是相同的结果：http://localhost:8080/hello/a.txt

10.6、Class获取资源

Class获取资源也必须是相对路径，可以“/”开头，也可以不使用“/”开头。
```
public class Demo {
    public void fun1() {
        InputStream in = Demo.class.getResourceAsStream("/a.txt");
    }
    
    public void fun2() {
        InputStream in = Demo.class.getResourceAsStream("a.txt");
    }
}
```
其中fun1()方法获取资源时以“/”开头，那么相对的是当前类路径，即/hello/WEB-INF/classes/a.txt文件；

其中fun2()方法获取资源时没有以“/”开头，那么相对当前Demo.class所在路径，因为Demo类在cn.jdy包下，所以资源路径为：/hello/WEB-INF/classes/cn/jdy/a.txt。

10.7、ClassLoader获取资源

ClassLoader获取资源也必须是相对路径，可以“/”开头，也可以不使用“/”开头。但无论是否以“/”开头，资源都是相对当前类路径。
```
public class Demo {
    public void fun1() {
        InputStream in = Demo.class.getClassLoader().getResourceAsStream("/a.txt");
    }
    
    public void fun2() {
        InputStream in = Demo.class.getClassLoader().getResourceAsStream("a.txt");
    }
}
```
fun1()和fun2()方法的资源都是相对类路径，即classes目录，即/hello/WEB-INF/classes/a.txt

十一、编码

11.1、请求编码

(1)、直接在地址栏中给出中文

　　请求数据是由客户端浏览器发送服务器的，请求数据的编码是由浏览器决定的。例如在浏览器地址栏中给出：http://localhost:8080/hello/AServlet?name=张三，那么其中“张三”是什么编码的呢？不同浏览器使用不同的编码，所以这是不确定的！
- IE：使用GB2312；
- FireFox：使用GB2312；
- Chrome：使用UTF-8；
通常没有哪个应用要求用户在浏览器地址栏中输入请求数据的，所以大家只需了解一下即可。

(2)、在页面中发出请求

　　通常向服务器发送请求数据都需要先请求一个页面，然后用户在页面中输入数据。页面中有超链接和表单，通过超链接和表单就可以向服务器发送数据了。

　　因为页面是服务器发送到客户端浏览器的，所以这个页面本身的编码由服务器决定。而用户在页面中输入的数据也是由页面本身的编码决定的。

index.html
```
<!DOCTYPE html>
<html>
  <head>
    <title>index.html</title>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  </head>
  
  <body>
<form action="/hello/servlet/AServlet">
  名称:<input type="text" name="name"/>
  <input type="submit" value="提交"/>
</form>
<a href="/hello/servlet/AServlet?name=中国">链接</a>
  </body>
</html>
```
　　当用户在index.html页面中输入数据时，都是UTF-8列表的。因为这个页面本身就是UTF-8编码的！

　　页面的编译就是页面中输入数据的编码。

(3)、GET请求解读编码

　　当客户端通过GET请求发送数据给服务器时，使用request.getParameter()获取的数据是被服务器误认为ISO-8859-1编码的，也就是说客户端发送过来的数据无论是UTF-8还是GBK，服务器都认为是ISO-8859-1，这就说明我们需要在使用request.getParameter()获取数据后，再转发成正确的编码。

例如客户端以UTF-8发送的数据，使用如下转码方式：
```
String name = request.getParameter(“name”);
name = new String(name.getBytes(“iso-8859-1”), “utf-8”);
```
(4)、POST请求解读编码

　　当客户端通过POST请求发送数据给服务器时，可以在使用request.getParameter()获取请求参数之前先通过request.setCharacterEncoding()来指定编码，然后再使用reuqest.getParameter()方法来获取请求参数，那么就是用指定的编码来读取了。

　　也就是说，如果是POST请求，服务器可以指定编码！但如果没有指定编码，那么默认还是使用ISO-8859-1来解读。
```
request.setCharacterEncoding(“utf-8”);
String name = request.getParameter(“name”);
```
11.2、响应编码

　　响应：服务器发送给客户端数据！响应是由response对象来完成，如果响应的数据不是字符数据，那么就无需去考虑编码问题。当然，如果响应的数据是字符数据，那么就一定要考虑编码的问题了。
```
response.getWriter().print(“中国”);
```
　　上面代码因为没有设置repsonse.getWriter()字符流的编码，所以服务器使用默认的编码（ISO-8859-1）来处理，因为ISO-8859-1不支持中文，所以一定会出现编码的。

　　所以在使用response.getWriter()发送数据之前，一定要设置response.getWriter()的编码，这需要使用response.setCharacterEncoding()方法：
```
response.setCharacterEncoding(“utf-8”);
response.getWriter().print(“中国”);
```
　　上面代码因为在使用response.getWriter()输出之前已经设置了编码，所以输出的数据为utf-8编码。但是，因为没有告诉浏览器使用什么编码来读取响应数据，所以很可能浏览器会出现错误的解读，那么还是会出现乱码的。当然，通常浏览器都支持来设置当前页面的编码，如果用户在看到编码时，去设置浏览器的编码，如果设置的正确那么乱码就会消失。但是我们不能让用户总去自己设置编码，而且应该直接通知浏览器，服务器发送过来的数据是什么编码，这样浏览器就直接使用服务器告诉他的编码来解读！这需要使用content-type响应头。
```
response.setContentType(“text/html;charset=utf-8”);
response.getWriter().print(“中国”);
```
　　上面代码使用setContentType()方法设置了响应头content-type编码为utf-8，这不只是在响应中添加了响应头，还等于调用了一次response.setCharacterEncoding(“utf-8”)，也就是说，通过我们只需要调用一次response.setContentType(“text/html;charset=utf-8”)即可，而无需再去调用response.setCharacterEncoding(“utf-8”)了。

在静态页面中，使用<meta>来设置content-type响应头，例如：
```
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
```
11.3、URL编码

　　通过页面传输数据给服务器时，如果包含了一些特殊字符是无法发送的。这时就需要先把要发送的数据转换成URL编码格式，再发送给服务器。

　　其实需要我们自己动手给数据转换成URL编码的只有GET超链接，因为表单发送数据会默认使用URL编码，也就是说，不用我们自己来编码。

　　例如：“中国”这两个字通过URL编码后得到的是：“%E4%BC%A0%E6%99%BA”。URL编码是先需要把“中国”转换成字节，例如我们现在使用UTF-8把“中国”转换成字符，得到的结果是：“[-28, -68, -96, -26, -103, -70]”，然后再把所有负数加上256，得到[228, 188, 160, 230, 153, 186]，再把每个int值转换成16进制，得到[E4, BC, A0, E6, 99, BA]，最后再每个16进制的整数前面加上“%”。

　　通过URL编码，把“中国”转换成了“%E4%BC%A0%E6%99%BA”，然后发送给服务器！服务器会自动识别出数据是使用URL编码过的，然后会自动把数据转换回来。

当然，在页面中我们不需要自己去通过上面的过程把“中国”转换成“%E4%BC%A0%E6%99%BA”，而是使用Javascript来完成即可。当后面我们学习了JSP后，就不用再使用Javascript了。
```
<script type="text/javascript">
      function _go() {
          location = "/day05_2/AServlet?name=" + encodeURIComponent("中国");
      }
  </script>
<a href="javascript:_go();">链接</a>
```
　　因为URL默认只支持ISO-8859-1，这说明在URL中出现中文和一些特殊字符可能无法发送到服务器。所以我们需要对包含中文或特殊字符的URL进行URL编码。

　　服务器会自动识别数据是否使用了URL编码，如果使用了服务器会自动把数据解码，无需我们自己动手解码。
相关阅读:
while循环和递归
 ASP.NET Core Swagger 显示接口注释
 ABP依赖注入
 EF Core 笔记
 .NET Core 管道过滤器扩展
 ABP权限认证
 552 you must authentication
C# 多线程写文件，时常写不成功
 .Net 的一些插件
 多线程下HttpContext.Current 的问题
原文地址：https://www.cnblogs.com/jdy1022/p/13810992.html

一、Servlet概述

1.1、什么是Servlet

1.2、实现Servlet的方式

二、实现Servlet接口

2.1、Servlet的生命周期：

(1)、Servlet的出生

(2)、Servlet服务

(3)、Servlet的离去

2.2、Servlet接口相关类型

(1)、ServletRequest和ServletResponse

(2)、ServletConfig

三、GenericServlet

3.1、GenericServlet概述

3.2、GenericServlet的init()方法

3.3、实现了ServletConfig接口

四、HttpServlet

4.1、HttpServlet概述

4.2、HttpServlet覆盖了service()方法

4.3、doGet()和doPost()

五、Servlet细节

5.1、Servlet与线程安全

5.2、让服务器在启动时就创建Servlet

5.3、<url-pattern>

5.4、web.xml文件的继承

六、ServletContext

6.1、ServletContext概述

6.2、获取ServletContext

6.3、域对象的功能

6.4、获取应用初始化参数

6.5、获取资源相关方法

(1)、获取真实路径

(2)、获取资源流

(3)、获取指定目录下所有资源路径

6.6、访问量统计

七、获取类路径下资源

八、response

8.1、response概述

8.2、response响应正文

(1)、字符响应流

8.3、设置响应头信息

8.4、设置状态码及其他方法

8.5、重定向

(1)、什么是重定向

(2)、完成重定向

(3)、便捷的重定向方式

(4)、重定向小结

九、request

9.1、request概述

9.2、request域方法

9.3、request获取请求头数据

9.4、request获取请求相关的其它方法

9.5、request获取请求参数

9.6、请求转发和请求包含

(1)、请求转发

(2)、请求包含

(3)、请求转发与请求包含比较

(4)、请求转发与重定向比较

十、路径

10.1、与路径相关的操作

10.2、客户端路径

(1)、建议使用“/”

10.3、服务器端路径

10.4、<url-pattern>路径

10.5、ServletContext获取资源

10.6、Class获取资源

10.7、ClassLoader获取资源

十一、编码

11.1、请求编码

(1)、直接在地址栏中给出中文

(2)、在页面中发出请求

(3)、GET请求解读编码

(4)、POST请求解读编码

11.2、响应编码

11.3、URL编码