10-Servlet

标签：10 调用 servlet void req Servlet public

1. 简介

Servlet 是 JavaWeb 最为核心的内容，它是 Java 提供的一门动态web 资源开发技术。
使用 Servlet 就可以实现，根据不同的登录用户在页面上动态显示不同内容。
Servlet 是 JavaEE 规范之一，其实就是一个接口，将来我们需要定义 Servlet 类实现 Servlet 接口，并由 web 服务器运行 Servlet

2. 快速入门

需求分析: 编写一个 Servlet 类，并使用 IDEA 中 Tomcat 插件进行部署，最终通过浏览器访问所编写的 Servlet 程序。

具体的实现步骤为:

创建 Web 项目web-demo，导入 Servlet 依赖坐标

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <!--
      此处为什么需要添加该标签?
      provided指的是在编译和测试过程中有效,最后生成的war包时不会加入
       因为Tomcat的lib目录中已经有servlet-api这个jar包，如果在生成war包的时候生效就会和Tomcat中的jar包冲突，导致报错
    -->
    <scope>provided</scope>
</dependency>

创建:定义一个类，实现 Servlet 接口，并重写接口中所有方法，并在 service 方法中输入一句话

package com.itheima.web;

import javax.servlet.*;
import java.io.IOException;

public class ServletDemo1 implements Servlet {

    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("servlet hello world~");
    }
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    public ServletConfig getServletConfig() {
        return null;
    }

    public String getServletInfo() {
        return null;
    }

    public void destroy() {

    }
}

配置:在类上使用@WebServlet 注解，配置该 Servlet 的访问路径

@WebServlet("/demo1")

访问:启动 Tomcat,浏览器中输入 URL 地址访问该 Servlet

http://localhost:8080/web-demo/demo1

器访问后，在控制台会打印servlet hello world~ 说明 servlet 程序已经成功运行。

至此，Servlet 的入门案例就已经完成。

3. 执行流程

Servlet 程序已经能正常运行，但是我们需要思考个问题: 我们并没有创建 ServletDemo1 类的对象，也没有调用对象中的 service 方法，为什么在控制台就打印了servlet hello world~这句话呢?

浏览器发出http://localhost:8080/web-demo/demo1请求，从请求中可以解析出三部分内容，分别是localhost:8080、web-demo、demo1
- 根据localhost:8080可以找到要访问的 Tomcat Web 服务器
- 根据web-demo可以找到部署在 Tomcat 服务器上的 web-demo 项目
- 根据demo1可以找到要访问的是项目中的哪个 Servlet 类，根据@WebServlet 后面的值进行匹配
找到 ServletDemo1 这个类后，Tomcat Web 服务器就会为 ServletDemo1 这个类创建一个对象，然后调用对象中的 service 方法
- ServletDemo1 实现了 Servlet 接口，所以类中必然会重写 service 方法供 Tomcat Web 服务器进行调用
- service 方法中有 ServletRequest 和 ServletResponse 两个参数，ServletRequest 封装的是请求数据，ServletResponse 封装的是响应数据，后期我们可以通过这两个参数实现前后端的数据交互

小结

介绍完 Servlet 的执行流程，需要大家掌握两个问题：

Servlet 由谁创建?Servlet 方法由谁调用?

Servlet 由 web 服务器创建，Servlet 方法由 web 服务器调用

服务器怎么知道 Servlet 中一定有 service 方法?

因为我们自定义的 Servlet,必须实现 Servlet 接口并复写其方法，而 Servlet 接口中有 service 方法

4. 生命周期

生命周期: 对象的生命周期指一个对象从被创建到被销毁的整个过程。

Servlet 运行在 Servlet 容器(web 服务器)中，其生命周期由容器来管理，分为 4 个阶段：

1. 加载和实例化：默认情况下，当 Servlet 第一次被访问时，由容器创建 Servlet 对象
```
默认情况，Servlet会在第一次访问被容器创建，但是如果创建Servlet比较耗时的话，那么第一个访问的人等待的时间就比较长，用户的体验就比较差，那么我们能不能把Servlet的创建放到服务器启动的时候来创建，具体如何来配置?

@WebServlet(urlPatterns = "/demo1",loadOnStartup = 1)
loadOnstartup的取值有两类情况
	（1）负整数:第一次访问时创建Servlet对象
	（2）0或正整数:服务器启动时创建Servlet对象，数字越小优先级越高
```
1. 初始化：在 Servlet 实例化之后，容器将调用 Servlet 的init()方法初始化这个对象，完成一些如加载配置文件、创建连接等初始化的工作。该方法只调用一次
2. 请求处理：每次请求 Servlet 时，Servlet 容器都会调用 Servlet 的service()方法对请求进行处理
3. 服务终止：当需要释放内存或者容器关闭时，容器就会调用 Servlet 实例的destroy()方法完成资源的释放。在 destroy()方法调用之后，容器会释放这个 Servlet 实例，该实例随后会被 Java 的垃圾收集器所回收

通过案例演示下上述的生命周期

package com.itheima.web;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;
/**
* Servlet生命周期方法
*/
@WebServlet(urlPatterns = "/demo2",loadOnStartup = 1)
public class ServletDemo2 implements Servlet {

    /**
     *  初始化方法
     *  1.调用时机：默认情况下，Servlet被第一次访问时，调用
     *      * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用
     *  2.调用次数: 1次
     * @param config
     * @throws ServletException
     */
    public void init(ServletConfig config) throws ServletException {
        System.out.println("init...");
    }

    /**
     * 提供服务
     * 1.调用时机:每一次Servlet被访问时，调用
     * 2.调用次数: 多次
     * @param req
     * @param res
     * @throws ServletException
     * @throws IOException
     */
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        System.out.println("servlet hello world~");
    }

    /**
     * 销毁方法
     * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用
     * 2.调用次数: 1次
     */
    public void destroy() {
        System.out.println("destroy...");
    }
    public ServletConfig getServletConfig() {
        return null;
    }

    public String getServletInfo() {
        return null;
    }


}

注意:如何才能让 Servlet 中的 destroy 方法被执行？

在 Terminal 命令行中，先使用mvn tomcat7:run启动，然后再使用ctrl+c关闭 tomcat

小结

这节中需要掌握的内容是:

Servlet 对象在什么时候被创建的?

默认是第一次访问的时候被创建，可以使用@WebServlet(urlPatterns = "/demo2",loadOnStartup = 1)的 loadOnStartup 修改成在服务器启动的时候创建。

Servlet 生命周期中涉及到的三个方法，这三个方法是什么?什么时候被调用?调用几次?

涉及到三个方法，分别是 init()、service()、destroy()

init 方法在 Servlet 对象被创建的时候执行，只执行 1 次

service 方法在 Servlet 被访问的时候调用，每访问 1 次就调用 1 次

destroy 方法在 Servlet 对象被销毁的时候调用，只执行 1 次

5. 方法介绍

Servlet 中总共有 5 个方法前面介绍过其中的三个，剩下的两个方法作用分别是什么？

我们先来回顾下前面讲的三个方法，分别是:

初始化方法，在 Servlet 被创建时执行，只执行一次

void init(ServletConfig config)

提供服务方法，每次 Servlet 被访问，都会调用该方法

void service(ServletRequest req, ServletResponse res)

销毁方法，当 Servlet 被销毁时，调用该方法。在内存释放或服务器关闭时销毁 Servlet

void destroy()

剩下的两个方法是:

获取 Servlet 信息

String getServletInfo()
//该方法用来返回Servlet的相关信息，没有什么太大的用处，一般我们返回一个空字符串即可
public String getServletInfo() {
    return "";
}

获取 ServletConfig 对象

ServletConfig getServletConfig()

ServletConfig 对象，在 init 方法的参数中有，而 Tomcat Web 服务器在创建 Servlet 对象的时候会调用 init 方法，必定会传入一个 ServletConfig 对象，我们只需要将服务器传过来的 ServletConfig 进行返回即可。具体如何操作?

package com.itheima.web;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;

/**
 * Servlet方法介绍
 */
@WebServlet(urlPatterns = "/demo3",loadOnStartup = 1)
public class ServletDemo3 implements Servlet {

    private ServletConfig servletConfig;
    /**
     *  初始化方法
     *  1.调用时机：默认情况下，Servlet被第一次访问时，调用
     *      * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用
     *  2.调用次数: 1次
     * @param config
     * @throws ServletException
     */
    public void init(ServletConfig config) throws ServletException {
        this.servletConfig = config;
        System.out.println("init...");
    }
    public ServletConfig getServletConfig() {
        return servletConfig;
    }

    /**
     * 提供服务
     * 1.调用时机:每一次Servlet被访问时，调用
     * 2.调用次数: 多次
     * @param req
     * @param res
     * @throws ServletException
     * @throws IOException
     */
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        System.out.println("servlet hello world~");
    }

    /**
     * 销毁方法
     * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用
     * 2.调用次数: 1次
     */
    public void destroy() {
        System.out.println("destroy...");
    }

    public String getServletInfo() {
        return "";
    }
}

getServletInfo()和 getServletConfig()这两个方法使用的不是很多，了解下。

6. 体系结构

通过上面的学习，我们知道要想编写一个 Servlet 就必须要实现 Servlet 接口，重写接口中的 5 个方法，虽然已经能完成要求，但是编写起来还是比较麻烦的，因为我们更关注的其实只有 service 方法，那有没有更简单方式来创建 Servlet 呢?

要想解决上面的问题，我们需要先对 Servlet 的体系结构进行下了解:

因为我们将来开发 B/S 架构的 web 项目，都是针对 HTTP 协议，所以我们自定义 Servlet,会通过继承HttpServlet

具体的编写格式如下:

@WebServlet("/demo4")
public class ServletDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //TODO GET 请求方式处理逻辑
        System.out.println("get...");
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //TODO Post 请求方式处理逻辑
        System.out.println("post...");
    }
}

要想发送一个 GET 请求，请求该 Servlet，只需要通过浏览器发送http://localhost:8080/web-demo/demo4,就能看到 doGet 方法被执行了
要想发送一个 POST 请求，请求该 Servlet，单单通过浏览器是无法实现的，这个时候就需要编写一个 form 表单来发送请求，在 webapp 下创建一个a.html页面，内容如下:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Title</title>
  </head>
  <body>
    <form action="/web-demo/demo4" method="post">
      <input name="username" /><input type="submit" />
    </form>
  </body>
</html>

启动测试，即可看到 doPost 方法被执行了。

Servlet 的简化编写就介绍完了，接着需要思考两个问题:

HttpServlet 中为什么要根据请求方式的不同，调用不同的方法?
如何调用?

针对问题一，我们需要回顾之前的知识点前端发送 GET 和 POST 请求的时候，参数的位置不一致，GET 请求参数在请求行中，POST 请求参数在请求体中，为了能处理不同的请求方式，我们得在 service 方法中进行判断，然后写不同的业务处理，这样能实现，但是每个 Servlet 类中都将有相似的代码，针对这个问题，有什么可以优化的策略么?

package com.itheima.web;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


@WebServlet("/demo5")
public class ServletDemo5 implements Servlet {

    public void init(ServletConfig config) throws ServletException {

    }

    public ServletConfig getServletConfig() {
        return null;
    }

    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        //如何调用?
        //获取请求方式，根据不同的请求方式进行不同的业务处理
        HttpServletRequest request = (HttpServletRequest)req;
       //1. 获取请求方式
        String method = request.getMethod();
        //2. 判断
        if("GET".equals(method)){
            // get方式的处理逻辑
        }else if("POST".equals(method)){
            // post方式的处理逻辑
        }
    }

    public String getServletInfo() {
        return null;
    }

    public void destroy() {

    }
}

要解决上述问题，我们可以对 Servlet 接口进行继承封装，来简化代码开发。

package com.itheima.web;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

public class MyHttpServlet implements Servlet {
    public void init(ServletConfig config) throws ServletException {

    }

    public ServletConfig getServletConfig() {
        return null;
    }

    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest)req;
        //1. 获取请求方式
        String method = request.getMethod();
        //2. 判断
        if("GET".equals(method)){
            // get方式的处理逻辑
            doGet(req,res);
        }else if("POST".equals(method)){
            // post方式的处理逻辑
            doPost(req,res);
        }
    }

    protected void doPost(ServletRequest req, ServletResponse res) {
    }

    protected void doGet(ServletRequest req, ServletResponse res) {
    }

    public String getServletInfo() {
        return null;
    }

    public void destroy() {

    }
}

有了 MyHttpServlet 这个类，以后我们再编写 Servlet 类的时候，只需要继承 MyHttpServlet，重写父类中的 doGet 和 doPost 方法，就可以用来处理 GET 和 POST 请求的业务逻辑。接下来，可以把 ServletDemo5 代码进行改造

@WebServlet("/demo5")
public class ServletDemo5 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {
        System.out.println("get...");
    }

    @Override
    protected void doPost(ServletRequest req, ServletResponse res) {
        System.out.println("post...");
    }
}

将来页面发送的是 GET 请求，则会进入到 doGet 方法中进行执行，如果是 POST 请求，则进入到 doPost 方法。这样代码在编写的时候就相对来说更加简单快捷。

类似 MyHttpServlet 这样的类 Servlet 中已经为我们提供好了，就是 HttpServlet,翻开源码，大家可以搜索service()方法，你会发现 HttpServlet 做的事更多，不仅可以处理 GET 和 POST 还可以处理其他五种请求方式。

protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                if (ifModifiedSince < lastModified) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);

        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }

小结

通过这一节的学习，要掌握:

HttpServlet 的使用步骤

继承 HttpServlet

重写 doGet 和 doPost 方法

HttpServlet 原理

获取请求方式，并根据不同的请求方式，调用不同的 doXxx 方法

7. urlPattern 配置

8. XML 配置

标签：10,调用,servlet,void,req,Servlet,public
From： https://www.cnblogs.com/NorthPoet/p/17404323.html