Web---Tomcat & Servlet

Tomcat

简介

什么是Web服务器？
Web服务器是一个应用程序（软件），对HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作，让Web开发更加便捷。主要功能是”提供网上信息浏览服务”。

我们可以把自己写的Web项目部署到Web Tomcat服务器软件中，当Web服务器软件启动后，部署在Web服务器软件中的页面就可以直接通过浏览器来访问了。

Web服务器软件使用步骤

• 准备静态资源
• 下载安装Web服务器软件
• 将静态资源部署到Web服务器上
• 启动Web服务器使用浏览器访问对应的资源

Tomcat的相关概念:

• Tomcat是Apache软件基金会一个核心项目，是一个开源免费的轻量级Web服务器，支持Servlet/JSP少量JavaEE规范。

• 概念中提到了JavaEE规范，那什么又是JavaEE规范呢?

  JavaEE: Java Enterprise Edition,Java企业版。指Java企业级开发的技术规范总和。包含13项技术规范:JDBC、JNDI、EJB、RMI、JSP、Servlet、XML、JMS、Java IDL、JTS、JTA、JavaMail、JAF。

• 因为Tomcat支持Servlet/JSP规范，所以Tomcat也被称为Web容器、Servlet容器。Servlet需要依赖Tomcat才能运行。

• Tomcat的官网: Apache Tomcat® - Welcome! 从官网上可以下载对应的版本进行使用。

关于IDEA创建Maven Web项目和在Tomcat的使用这里就不过多介绍了。

Servlet

简介

• Servlet是JavaWeb最为核心的内容，它是Java提供的一门动态web资源开发技术。

• 使用Servlet就可以实现，根据不同的登录用户在页面上动态显示不同内容。

• Servlet是JavaEE规范之一，其实就是一个接口，将来我们需要定义Servlet类实现Servlet接口，并由web服务器运行Servlet

快速入门

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

具体的实现步骤为:

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

   XML

   1 2 3 4 5 6 7 8 9 10 11

   <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>

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

   JAVA

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

   import javax.servlet.*; import javax.servlet.annotation.WebServlet; import java.io.IOException; public class ServletDemo implements Servlet { @Override public void init(ServletConfig servletConfig) throws ServletException { } @Override public ServletConfig getServletConfig() { return null; } @Override public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException { System.out.println("hello servlet"); } @Override public String getServletInfo() { return null; } @Override public void destroy() { } }

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

   JAVA

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

   import javax.servlet.*; import javax.servlet.annotation.WebServlet; import java.io.IOException; @WebServlet("/demo1") //加上这个东东 public class ServletDemo implements Servlet { @Override public void init(ServletConfig servletConfig) throws ServletException { } @Override public ServletConfig getServletConfig() { return null; } @Override public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException { System.out.println("hello servlet"); } @Override public String getServletInfo() { return null; } @Override public void destroy() { } }

4. 访问:启动Tomcat,浏览器中输入URL地址访问该Servlet
   http://localhost:8080/web-demo/demo1

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

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

执行流程

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

要解答上述问题，我们就需要对Servlet的执行流程进行一个学习。

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

小结

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

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

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

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

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

生命周期

介绍完Servlet的执行流程后，我们知道Servlet是由Tomcat Web服务器帮我们创建的。

接下来咱们再来思考一个问题:Tomcat什么时候创建的Servlet对象?

要想回答上述问题，我们就需要对Servlet的生命周期进行一个学习。

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

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

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

     JAVA

     1	@WebServlet(urlPatterns = "/demo1",loadOnStartup = 1)

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

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

  JAVA

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

  import javax.servlet.*; import javax.servlet.annotation.WebServlet; import java.io.IOException; //设置为1之后，在我们访问http://localhost:8080/web-demo/demo之前，就会进行初始化操作了，第一个人访问的时候就不会等那么久了 @WebServlet(urlPatterns = "/demo",loadOnStartup = 1) public class ServletDemo implements Servlet { /** * 初始化方法 * 1.调用时机：默认情况下，Servlet被第一次访问时，调用 * * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用 * 2.调用次数: 1次 * * @param servletConfig * @throws ServletException */ @Override public void init(ServletConfig servletConfig) throws ServletException { System.out.println("init.."); } /** * 提供服务 * 1.调用时机:每一次Servlet被访问时，调用 * 2.调用次数: 多次 * * @param servletRequest * @param servletResponse * @throws ServletException * @throws IOException */ @Override public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException { System.out.println("hello servlet"); } /** * 销毁方法 * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用 * 2.调用次数: 1次 */ @Override public void destroy() { System.out.println("destroy..."); } @Override public String getServletInfo() { return null; } @Override public ServletConfig getServletConfig() { return null; } }

小结

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

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

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

   涉及到三个方法，分别是 init()、service()、destroy()
   init方法在Servlet对象被创建的时候执行，只执行1次
   service方法在Servlet被访问的时候调用，每访问1次就调用1次(每刷新一次界面，控制台就会输出一次)
   destroy方法在Servlet对象被销毁的时候调用，只执行1次

方法介绍

Servlet中总共有5个方法，我们已经介绍过其中的三个，剩下的两个方法是:

• 获取Servlet信息

  JAVA

  1 2 3 4 5

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

• 获取ServletConfig对象

  JAVA

  1	ServletConfig getServletConfig()

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

创建一个私有的ServletConfig对象，当我们调用init方法的时候，将传入的ServletConfig对象赋给私有的ServletConfig对象，代码如下

JAVA

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

import javax.servlet.*; import javax.servlet.annotation.WebServlet; import java.io.IOException; @WebServlet(urlPatterns = "/demo", loadOnStartup = 1) public class ServletDemo implements Servlet { //创建ServletConfig对象 private ServletConfig servletConfig; @Override public void init(ServletConfig servletConfig) throws ServletException { //将init方法传入的ServletConfig对象赋给我们创建的ServletConfig this.servletConfig = servletConfig; System.out.println("init.."); } @Override public ServletConfig getServletConfig() { //返回ServletConfig对象 return servletConfig; } @Override public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException { System.out.println("hello servlet"); } @Override public void destroy() { System.out.println("destroy..."); } @Override public String getServletInfo() { return null; } }

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

体系结构

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

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

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

JAVA

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

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(urlPatterns = "/demo", loadOnStartup = 1) public class ServletDemo extends HttpServlet { @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System.out.println("post..."); } @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System.out.println("get..."); } }

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

  HTML

  1 2 3 4 5 6 7 8 9 10 11 12 13

  <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <form action="/web_demo_war_exploded/demo" method="post"> 用户名：<input type="text" name="username"> <input type="submit" value="提交"> </form> </body> </html>

  启动测试，在控制台可看到doPost方法被执行了。

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

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

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

可以把这些相似的代码写入一个类当中，HttpServlet已经帮我们解决了，下面来看看HttpServlet中的service方法，首先先获取请求方法，随后根据不同的请求方法来进行不同的操作。
前面说过一共有7种请求方法，HttpServlet类中已经包含了这7种，不仅可以处理GET和POST还可以处理其他五种请求方式。

JAVA

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

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 = req.getDateHeader("If-Modified-Since"); if (ifModifiedSince < lastModified) { 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); } }

小结

1. HttpServlet的使用步骤

   继承HttpServlet
   重写doGet和doPost方法

2. HttpServlet原理

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

urlPattern配置

Servlet类编写好后，要想被访问到，就需要配置其访问路径（==urlPattern==）

• 一个Servlet,可以配置多个urlPattern，例如

  JAVA

  1	@WebServlet(urlPatterns = {"/demo1","/demo2"})

  在浏览器上输入http://localhost:8080/web-demo/demo1,http://localhost:8080/web-demo/demo2这两个地址都能访问到ServletDemo的doGet方法。

• urlPattern配置规则

  • 精确匹配

    JAVA

    1	@WebServlet(urlPatterns = "/user/select")

    访问路径http://localhost:8080/web-demo/user/select
  • 目录匹配

    JAVA

    1	@WebServlet(urlPatterns = "/user/*")

    访问路径http://localhost:8080/web-demo/user/任意
  • 扩展名匹配

    JAVA

    1	@WebServlet(urlPatterns = "*.do") //注意这里没加斜杠

    访问路径http://localhost:8080/web-demo/任意.do
  • 任意匹配

    JAVA

    1 2 3

    @WebServlet(urlPatterns = "/") //或 @WebServlet(urlPatterns = "/*")

    访问路径http://localhost:8080/demo-web/任意

注意:/和/*的区别?

1. 当我们的项目中的Servlet配置了 “/“,会覆盖掉tomcat中的DefaultServlet,当其他的url-pattern都匹配不上时都会走这个Servlet

2. 当我们的项目中配置了”/*”,意味着匹配任意访问路径

3. DefaultServlet是用来处理静态资源，如果配置了”/“会把默认的覆盖掉，就会引发请求静态资源的时候没有走默认的而是走了自定义的Servlet类，最终导致静态资源不能被访问（不必太过担心这种问题，因为我们几乎不会配置这种匹配方式）

小结

1. urlPattern总共有四种配置方式，分别是精确匹配、目录匹配、扩展名匹配、任意匹配

2. 五种配置的优先级为 精确匹配 > 目录匹配> 扩展名匹配 > /* > / ,无需记，以最终运行结果为准。

XML配置

前面对应Servlet的配置，我们都使用的是@WebServlet,这个是Servlet从3.0版本后开始支持注解配置，3.0版本前只支持XML配置文件的配置方法。

对于XML的配置步骤有两步:

• 编写Servlet类

  JAVA

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  package com.itheima.web; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.annotation.WebServlet; public class ServletDemo extends MyHttpServlet { @Override protected void doGet(ServletRequest req, ServletResponse res) { System.out.println("demo get..."); } @Override protected void doPost(ServletRequest req, ServletResponse res) { } }

• 在web.xml中配置该Servlet

  XML

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

  <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <!-- Servlet 全类名 --> <servlet> <!-- servlet的名称，名字任意--> <servlet-name>demo13</servlet-name> <!--servlet的类全名--> <servlet-class>com.itheima.web.ServletDemo13</servlet-class> </servlet> <!-- Servlet 访问路径 --> <servlet-mapping> <!-- servlet的名称，要和上面的名称一致--> <servlet-name>demo13</servlet-name> <!-- servlet的访问路径--> <url-pattern>/demo13</url-pattern> </servlet-mapping> </web-app>

这种配置方式和注解比起来，确认麻烦很多，所以建议使用注解来开发。但是还是要认识上面这种配置方式，因为并不是所有的项目都是基于注解开发的。