Servlet详解

详解Servlet

转载自：https://www.cnblogs.com/whgk/p/6399262.html
原文阅读体验不是很友好，因此转载到自己博客

1、什么是Servlet

处理请求和发送响应的过程是由一种叫做Servlet的程序来完成的，并且Servlet是为了解决实现动态页面而衍生的东西。理解这个的前提是了解一些http协议的东西，并且知道B/S模式(浏览器/服务器)。

B/S:浏览器/服务器。 浏览器通过网址来访问服务器，比如访问百度，在浏览器中输入www.baidu.com，这个时候浏览器就会显示百度的首页，那么这个具体的过程，步骤是怎样的呢？这个就了解一下http请求和响应了
img

2、tomcat和servlet的关系

Tomcat 是Web应用服务器,是一个Servlet/JSP容器. Tomcat 作为Servlet容器,负责处理客户请求,把请求传送给Servlet,并将Servlet的响应传送回给客户.而Servlet是一种运行在支持Java语言的服务器上的组件. Servlet最常见的用途是扩展Java Web服务器功能,提供非常安全的,可移植的,易于使用的CGI替代品.

从http协议中的请求和响应可以得知，浏览器发出的请求是一个请求文本，而浏览器接收到的也应该是一个响应文本。但是在上面这个图中，并不知道是如何转变的，只知道浏览器发送过来的请求也就是request，我们响应回去的就用response。忽略了其中的细节，现在就来探究一下。

img

①：Tomcat将http请求文本接收并解析，然后封装成HttpServletRequest类型的request对象，所有的HTTP头数据读可以通过request对象调用对应的方法查询到。

②：Tomcat同时会要响应的信息封装为HttpServletResponse类型的response对象，通过设置response属性就可以控制要输出到浏览器的内容，然后将response交给tomcat，tomcat就会将其变成响应文本的格式发送给浏览器

Java Servlet API 是Servlet容器(tomcat)和servlet之间的接口，它定义了serlvet的各种方法，还定义了Servlet容器传送给Servlet的对象类，其中最重要的就是ServletRequest和ServletResponse。所以说我们在编写servlet时，需要实现Servlet接口，按照其规范进行操作。

3、编写Servlet

手动编写servlet

  • 创建一个MyServlet继承HttpServlet，重写doGet和doPost方法，也就是看请求的方式是get还是post，然后用不同的处理方式来处理请求

    public class Myservlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
				 System.out.println("get");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("post");
    }
}

  • 在web.xml中配置MyServlet，为什么需要配置？让浏览器发出的请求知道到达哪个servlet，也就是让tomcat将封装好的request找到对应的servlet让其使用。

    <servlet>
  <servlet-name>MyServlet</servlet-name>
  <servlet-class>com.liuermeng.javaWeb.Myservlet</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>MyServlet</servlet-name>
  <url-pattern>/MyServlet</url-pattern>
</servlet-mapping>

我这里是采用的IDEA，这里的tomcat配置如图

image-20211208152020056

我将ApplicationContext配置成了/test01.这也就导致项目的路径为http://localhost:8080/test01/

按照步骤，首先浏览器通过http://localhost:8080/test01/MyServlet来找到web.xml中的url-pattern，这就是第一步，匹配到了url-pattern后，就会找到第二步servlet的名字MyServlet，知道了名字，就可以通过servlet-name找到第三步，到了第三步，也就能够知道servlet的位置了。然后到其中找到对应的处理方式进行处理。

浏览器访问，控制台输出get

4、servlet 的生命周期是什么？

  • 服务器启动时 (web.xml 中配置 load-on-startup=1，默认为 0) 或者第一次请求该 servlet 时，就会初始化一个 Servlet 对象，也就是会执行初始化方法 init(ServletConfig conf)

  • 该 servlet 对象去处理所有客户端请求，在 service(ServletRequest req，ServletResponse res) 方法中执行

  • 最后服务器关闭时，才会销毁这个 servlet 对象，执行 destroy() 方法。

    image-20211207192026292

5、为什么创建的 servlet 是继承自 httpServlet，而不是直接实现 Servlet 接口？

image-20211207192416178

查看源码，httpServlet 的继承结构。

httpServlet 继承 GenericServlet。GenericServlet(通用 Servlet) 的作用是什么？大概的就是将实现 Servlet 接口的方法，简化编写 servlet 的步骤。具体下面详解

GenericServlet 的继承结构，实现了 Servlet 接口和 ServletConfig 接口

Servlet 接口内容

image-20211207192643718

从这里可以看到，Servlet 生命周期的三个关键方法，init、service、destroy。还有另外两个方法，一个 getServletConfig() 方法来获取 ServletConfig 对象，ServletConfig 对象可以获取到 Servlet 的一些信息，ServletName、ServletContext、InitParameter、InitParameterNames、通过查看 ServletConfig 这个接口就可以知道

ServletConfig 接口内容

image-20211207192859141

其中 ServletContext 对象是 servlet 上下文对象，功能有很多，获得了 ServletContext 对象，就能获取大部分我们需要的信息，比如获取 servlet 的路径，等方法。

到此，就知道了 Servlet 接口中的内容和作用，总结起来就是，三个生命周期运行的方法，获取 ServletConfig，而通过 ServletConfig 又可以获取到 ServletContext。而 GenericServlet 实现了 Servlet 接口后，也就说明我们可以直接继承 GenericServlet，就可以使用上面我们所介绍 Servlet 接口中的那几个方法了，能拿到 ServletConfig，也可以拿到 ServletContext，不过那样太麻烦，不能直接获取 ServletContext，所以 GenericServlet 除了实现 Servlet 接口外，还实现了 ServletConfig 接口，那样，就可以直接获取 ServletContext 了。

GenericServlet 类的内容详解

image-20211207194245767

看上图，用红色框框起来的就是实现 Servlet 和 ServletConfig 接口所实现的方法，有 9 个，这很正常，但是我们可以发现，init 方法有两个，一个是带有参数 ServletConfig 的，一个有无参的方法，为什么这样设计？这里需要知道其中做了什么事情，来看看这两个方法分别做了什么事？

init(ServletConfig config)

init()

public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }

public void init() throws ServletException {
    }

一个成员变量 config

private transient ServletConfig config;

getServletConfig()

public ServletConfig getServletConfig() {
        return this.config;
  }

通过这几个方法一起来讲解，首先看 init(ServletConfig config) 方法，因为只有 init(ServletConfig config) 中带有 ServletConfig 对象，为了方便能够在其他地方也能直接使用 ServletConfig 对象，而不仅仅局限在 init(ServletConfig config) 方法中，所以创建一个私有的成员变量 config，在 init(ServletConfig config) 方法中就将其赋值给 config，然后通过 getServletConfig() 方法就能够获取 ServletConfig 对象了，这个可以理解，但是在 init(ServletConfig config) 中，158 行，还调用了一个 init() 方法，并且这个 init() 方法是空的，什么读没有，这是为什么呢？这个原因是为了防止一件事情，当我们需要在 init 方法中做一点别的事情，我们想到的方法就是继承 GenericServlet 并且重写了 init(ServletConfig config) 方法，这样依赖，就破坏了原本在 GenericServlet 类中 init(ServletConfig config) 写的代码了，也就是在 GenericServlet 类中的成员变量 config 会一直是 null，无法得到赋值，因为被重写了，就不会在执行 GenericServlet 中 init(ServletConfig config) 方法中的代码。要想赋值，就必须在重写的 init(ServletConfig config) 方法中调用父类的 init(ServletConfig config) 方法，也就是 super.init(ServletConfig config)，这样一来，就很不方便，怕有时候会忘了写这句代码，所以在 GenericServlet 类中增加一个 init() 方法，以后需要在 init 方法中需要初始化别的数据，只需要重写 init() 这个方法，而不需要去覆盖 init(ServletConfig config) 这个方法，这样设计，就好很多，不用在管 init(ServletConfig config) 这个其中的内容了。也不用出现其他的问题。

service(ServletRequest req, ServletResponse res)

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

一个抽象方法，说明在 GenericServlet 类中并没有实现该内容，那么我们想到的是，在它上面肯定还有一层，也就是还有一个子类继承它，实现该方法，要是让我们自己写的 Servlet 继承 GenericServlet，需要自己写 service 方法，那岂不是累死，并且我们可以看到，service 方法中的参数还是 ServletRequest，ServletResponse。并没有跟 http 相关对象挂钩，所以我们接着往下面看。

HttpServlet 类详解

继承了 GenericServlet 类，通过我们上面的推测，这个类主要的功能肯定是实现 service 方法的各种细节和设计。并且通过类名可以知道，该类就跟 http 挂钩了。

img

service(HttpServletRequest req, HttpServletResponse resp) &&service(ServletRequest req, ServletResponse res)

service(ServletRequest req, ServletResponse res) 方法

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(lStrings.getString("http.non_http"));
        }

        this.service(request, response);
    }

该方法中就做一件事情，就是将 ServletRequest 和 ServletResponse 这两个对象强转为 HttpServletRequest 和 HttpServletResponse 对象。为什么能这样转？

首先要知道 req、res 是什么类型，通过打印 System.out.println(req)，可以知道，req 实际上的类型是 org.apache.catalina.connector.RequestFacade　

image-20211207200759944

image-20211207202525646

通过图可以得知，req 的继承结构：RequestFacade、httpServletRequest、ServletRequest，我们知道本身 req 是 ServletRequest，那么从继承结构上看，它也可以看成 HttpServletRequest，也可以看成 ServletRequest，所以强转为 HttpServletRequest 是可以的。

转换为 httpServletRequest 和 HttpServletResponse 对象之后，在调用 service(HttpServletRequest req, HttpServletResponse resp) 方法。

service(HttpServletRequest req, HttpServletResponse resp)

protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        long lastModified;
        if (method.equals("GET")) {
            lastModified = this.getLastModified(req);
            if (lastModified == -1L) {
                this.doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader("If-Modified-Since");
                } catch (IllegalArgumentException var9) {
                    ifModifiedSince = -1L;
                }

                if (ifModifiedSince < lastModified / 1000L * 1000L) {
                    this.maybeSetLastModified(resp, lastModified);
                    this.doGet(req, resp);
                } else {
                    resp.setStatus(304);
                }
            }
        } else if (method.equals("HEAD")) {
            lastModified = this.getLastModified(req);
            this.maybeSetLastModified(resp, lastModified);
            this.doHead(req, resp);
        } else if (method.equals("POST")) {
            this.doPost(req, resp);
        } else if (method.equals("PUT")) {
            this.doPut(req, resp);
        } else if (method.equals("DELETE")) {
            this.doDelete(req, resp);
        } else if (method.equals("OPTIONS")) {
            this.doOptions(req, resp);
        } else if (method.equals("TRACE")) {
            this.doTrace(req, resp);
        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[]{method};
            errMsg = MessageFormat.format(errMsg, errArgs);
            resp.sendError(501, errMsg);
        }
    }

这个方法就是判断浏览器过来的请求方式是哪种，每种的处理方式不一样，我们常用的就是 get，post，并且，我们处理的方式可能有很多的内容，所以，在该方法内会将 get，post 等其他 5 种请求方式提取出来，变成单个的方法，然后我们需要编写 servlet 时，就可以直接重写 doGet 或者 doPost 方法就行了，而不是重写 service 方法，更加有针对性。6、的答案也就出来了。

6、servlet 的生命周期中，可以看出，执行的是 service 方法，为什么我们就只需要写 doGet 和 doPost 方法呢？

7、几个重点的对象

讲解四大类，ServletConfig 对象，ServletContext 对象、request 对象，response 对象

ServletConfig 对象

获取途径：getServletConfig();

功能：上面大概提及了一下，能得到四个东西，

getServletName(); // 获取 servlet 的名称，也就是我们在 web.xml 中配置的 servlet-name

getServletContext(); // 获取 ServletContext 对象，该对象的作用看下面讲解

getInitParameter(String); // 获取在 servlet 中初始化参数的值。这里注意与全局初始化参数的区分。这个获取的只是在该 servlet 下的初始化参数

img

getInitParameterNames(); // 获取在 Servlet 中所有初始化参数的名字，也就是 key 值，可以通过 key 值，来找到各个初始化参数的 value 值。注意返回的是枚举类型

img

img

img

注意：在上面我们所分析的源码过程中，我们就知道，其实可以不用先获得 ServletConfig，然后在获取其各种参数，可以直接使用其方法，比如上面我们用的 ServletConfig().getServletName(); 可以直接写成 getServletName(); 而不用在先获取 ServletConfig(); 了，原因就是在 GenericServlet 中，已经帮我们获取了这些数据，我们只需要直接拿就行。

ServletContext 对象

获取途径：getServletContext(); 、getServletConfig().getServletContext();　　// 这两种获取方式的区别就跟上面的解释一样，第一种是直接拿，在 GenericServlet 中已经帮我们用 getServletConfig().getServletContext(); 拿到了 ServletContext。我们只需要直接获取就行了，第二种就相当于我们自己在获取一遍，两种读是一样的。

功能：tomcat 为每个 web 项目都创建一个 ServletContext 实例，tomcat 在启动时创建，服务器关闭时销毁，在一个 web 项目中共享数据，管理 web 项目资源，为整个 web 配置公共信息等，通俗点讲，就是一个 web 项目，就存在一个 ServletContext 实例，每个 Servlet 读可以访问到它。

web 项目中共享数据

setAttribute(String name, Object obj) 在 web 项目范围内存放内容，以便让在 web 项目中所有的 servlet 读能访问到

getAttribute(String name) 通过指定名称获得内容

removeAttribute(String name) 通过指定名称移除内容 　

img

img

img

整个 web 项目初始化参数

// 这个就是全局初始化参数，每个 Servlet 中都能获取到该初始化值

getInitPatameter(String name)　　// 通过指定名称获取初始化值

getInitParameterNames()　　// 获得枚举类型

web.xml 配置 整个 web 项目的初始化

img

img

img

获取 web 项目资源

1 获取 web 项目下指定资源的路径：

getServletContext().getRealPath("/WEB-INF/web.xml")

img

image-20211207211941146

2 获取 web 项目下指定资源的内容

返回的是字节输入流。InputStream getResourceAsStream(java.lang.String path)

img

输出内容截图一部分

img

getResourcePaths(java.lang.String path) 指定路径下的所有内容。

img

结果

image-20211207212307596

还有很多别的方法，暂时用到的就这几个了，以后需要在用的，就查看源码，看 API。

request 对象

我们知道，request 就是将请求文本封装而成的对象，所以通过 request 能获得请求文本中的所有内容，请求头、请求体、请求行 。

img

1、请求行内容的获取。

request.getRequestURI();//获取统一资源标记符
request.getRequestURL();//获取统一资源定位符
request.getProtocol();//协议和版本
request.getScheme();//协议
request.getServerName();//主机（域名），如果使用ip地址就显示ip
request.getServerPort();//端口号
request.getContextPath();//发布到tomcat下的项目名称
request.getServletPath();//servlet路径
request.getQueryString();//所有请求参数，即?后面所有的
request.getRemotAddr();//远程主机的IP地址

2 请求头的获取

随便百度一个东西，然后查看的请求头，包括以下这些内容，稍作了解。

img

String getHeader(java.lang.String name) 获得指定头内容 String

img

img

long getDateHeader(java.lang.String name) 获得指定头内容 Date

int getIntHeader(java.lang.String name) 获得指定头内容 int

Enumeration getHeaders(java.lang.String name) 获得指定名称所有内容

3 请求体的获取 -- 请求参数的获取

分两种，一种 get 请求，一种 post 请求

get 请求参数：http://localhost:8080/test01/MyServlet?username=jack&password=1234

post 请求参数: <form method="post"><input type="text" name="username">

String request.getParameter(String) 获得指定名称，一个请求参数值。

String[] request.getParameterValues(String) 获得指定名称，所有请求参数值。例如：checkbox、select 等

Map<String , String[]> request.getParameterMap() 获得所有的请求参数　

4 请求转发

request.getRequestDispatcher(String path).forward(request,response);　　//path: 转发后跳转的页面，这里不管用不用 "/" 开头，都是以 web 项目根开始，因为这是请求转发，请求转发只局限与在同一个 web 项目下使用，所以这里一直都是从 web 项目根下开始的，

web 项目根：

  • 开发：G:\Workspaces\test01\WebRoot..
  • 运行时：D:\java\tomcat\apache-tomcat-7.0.53\webapps\test01..

web 站点根：

  • 运行时：D:\java\tomcat\apache-tomcat-7.0.53\webapps..

从这里可以看出，web 项目根就是从该 web 项目名开始，所以我们请求转发时，只需要接着项目名后面需要访问的路径写就行了

特点：浏览器中 url 不会改变，也就是浏览器不知道服务器做了什么，是服务器帮我们跳转页面的，并且在转发后的页面，能够继续使用原先的 request，因为是原先的 request，所以 request 域中的属性都可以继续获取到。

response 对象

img

常用的一个方法：response.setHeader(java.lang.String name, java.lang.String value) 设置指定的头，一般常用。

例如：设置每隔 3 秒就自动刷新一次，

response.setHeader("Refresh",3);

img

img

img

这样可以看到现在时间的秒数，会发现每隔三秒就会自动刷新一次页面。

这个最重要的一个就是重定向，其他的一些操作都被封装到 response 对象中了，重点讲解重定向

重定向 (页面跳转)

  • 方式一：手动方案

    response.setStatus(302);　　// 状态码 302 就代表重定向

    response.setHeader("location","http://www.baidu.com");

  • 方式二：使用封装好的，通过 response.sendRedirect("http://www.baidu.com");

    特点：服务器告诉浏览器要跳转的页面，是浏览器主动去跳转的页面，浏览器知道，也浏览器的地址栏中 url 会变，是浏览器重新发起一个请求到另外一个页面，所以 request 是重新发起的，跟请求转发不一样。

注意：response.sendRedirect(path);　　//

img

注意：这里是将项目的contextPath设置成了/test01

  • 第一种：response.sendRedirect("/test01/MyServlet01");　　// 使用了 "/" 开头，说明是从 web 站点根开始，所以需要写 test01/MyServlet01

  • 第二种：response.sendRedirect("MyServlet01");　　// 没有使用 "/" 开头，说明是从 web 项目根开始，那么就无需写 test01 了。

重定向没有任何局限，可以重定向 web 项目内的任何路径，也可以访问别的 web 项目中的路径，并且这里就用 "/" 区分开来，如果使用了 "/" 开头，就说明我要重新开始定位了，不访问刚才的 web 项目，自己写项目名，如果没有使用 "/" 开始，那么就知道是访问刚才那个 web 项目下的 servlet，就可以省略项目名了。就是这样来区别。

8、总结

这一章节篇幅较长，不过理清很多知识点

1、什么是 servlet？如果编写 servlet？

2、分析了 servlet 的部分源码，知道了其中的一些设计巧妙的东西，比如，本来编写 servlet 是能看到其生命周期的，但是在其设计下，我们只关注 doGet 和 doPost 方法，为什么能这样呢？就可以通过源码中得知。

3、servlet 的生命周期，web.xml 的配置

4、servlet 中的 ServletConfig 对象，ServletContext 对象，request 对象，response 对象的详细讲解。包括其中的一些常用的方法。

5、下一篇讲解一下 request、response 的中文乱码问题的解决

posted @ 2021-12-08 16:18  liumeng哈哈哈  阅读(469)  评论(0)  编辑  收藏  举报