JavaWeb知识学习（二）

来源：互联网收集：自由互联发布时间：2023-09-14

04_TomcatServletHTTP 0. JavaWeb技术栈 0.1 B/S 架构 B/S 架构：Browser/Server，浏览器/服务器架构模式，它的特点是，客户端只需要浏览器，应用程序的逻辑和数据都存储在服务器端。浏览器只需要

04_Tomcat&Servlet&HTTP

0. JavaWeb技术栈

0.1 B/S 架构

B/S 架构：Browser/Server，浏览器/服务器架构模式，它的特点是，客户端只需要浏览器，应用程序的逻辑和数据都存储在服务器端。浏览器只需要请求服务器，获取Web资源，服务器把Web资源发送给浏览器即可。

0.2 静态资源

静态资源主要包含HTML、CSS、JavaScript、图片等，主要负责页面的展示。
由于做出来的这些内容都是静态的，这就会导致所有的人看到的内容将是一模一样。

0.3 动态资源

动态资源主要包含Servlet、JSP等，主要用来负责逻辑处理。
动态资源处理完逻辑后会把得到的结果交给静态资源来进行展示，动态资源和静态资源要结合一起使用。

1. Tomcat

Web服务器是一个应用程序，对HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作，让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的官网: https://tomcat.apache.org/ 从官网上可以下载对应的版本进行使用。

注意：Tomcat服务器的安装、配置、部署、Maven创建Web项目、 IDEA集成Tomcat，见 Tomcat.md

2. Servlet

2.1 简介

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

介绍完Servlet是什么以后，接下来我们就按照快速入门->执行流程->生命周期->体系结构->urlPattern配置->XML配置的学习步骤，一步步完成对Servlet的知识学习，首选我们来通过一个入门案例来快速把Servlet用起来。

2.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程序已经成功运行。

2.3 执行流程

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

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

浏览器发出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方法

2.4 生命周期

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

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

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

生命周期: 对象的生命周期指一个对象从被创建到被销毁的整个过程。
Servlet运行在Servlet容器(web服务器)中，其生命周期由容器来管理，分为4个阶段：

加载和实例化：默认情况下，当Servlet第一次被访问时，由容器创建Servlet对象

默认情况，Servlet会在第一次访问被容器创建，但是如果创建Servlet比较耗时的话，那么第一个访问的人等待的时间就比较长，用户的体验就比较差，那么我们能不能把Servlet的创建放到服务器启动的时候来创建，具体如何来配置?
 
 @WebServlet(urlPatterns = "/demo1",loadOnStartup = 1)
 loadOnstartup的取值有两类情况
     （1）负整数:第一次访问时创建Servlet对象
     （2）0或正整数:服务器启动时创建Servlet对象，数字越小优先级越高

初始化：在Servlet实例化之后，容器将调用Servlet的init()方法初始化这个对象，完成一些如加载配置文件、创建连接等初始化的工作。该方法只调用一次
请求处理：每次请求Servlet时，Servlet容器都会调用Servlet的service()方法对请求进行处理
服务终止：当需要释放内存或者容器关闭时，容器就会调用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次

2.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()这两个方法使用的不是很多，大家了解下。

2.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方法

2.7 urlPattern配置

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

一个Servlet,可以配置多个urlPattern

package com.itheima.web;
 
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.annotation.WebServlet;
 
 /**
 * urlPattern: 一个Servlet可以配置多个访问路径
 */
 @WebServlet(urlPatterns = {"/demo7","/demo8"})
 public class ServletDemo7 extends MyHttpServlet {
 
     @Override
     protected void doGet(ServletRequest req, ServletResponse res) {
         
         System.out.println("demo7 get...");
     }
     @Override
     protected void doPost(ServletRequest req, ServletResponse res) {
     }
 }

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

urlPattern配置规则

精确匹配

/**
  * UrlPattern:
  * * 精确匹配
  */
 @WebServlet(urlPatterns = "/user/select")
 public class ServletDemo8 extends MyHttpServlet {
 
     @Override
     protected void doGet(ServletRequest req, ServletResponse res) {
 
         System.out.println("demo8 get...");
     }
     @Override
     protected void doPost(ServletRequest req, ServletResponse res) {
     }
 }

访问路径http://localhost:8080/web-demo/user/select

package com.itheima.web;
 
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.annotation.WebServlet;
 
 /**
  * UrlPattern:
  * * 目录匹配: /user/*
  */
 @WebServlet(urlPatterns = "/user/*")
 public class ServletDemo9 extends MyHttpServlet {
 
     @Override
     protected void doGet(ServletRequest req, ServletResponse res) {
 
         System.out.println("demo9 get...");
     }
     @Override
     protected void doPost(ServletRequest req, ServletResponse res) {
     }
 }

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

思考:

访问路径http://localhost:8080/web-demo/user是否能访问到demo9的doGet方法?
访问路径http://localhost:8080/web-demo/user/a/b是否能访问到demo9的doGet方法?
访问路径http://localhost:8080/web-demo/user/select是否能访问到demo9还是demo8的doGet方法?

答案是: 能、能、demo8，进而我们可以得到的结论是/user/*中的/*代表的是零或多个层级访问目录同时精确匹配优先级要高于目录匹配。

扩展名匹配

package com.itheima.web;
 
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.annotation.WebServlet;
 
 /**
  * UrlPattern:
  * * 扩展名匹配: *.do
  */
 @WebServlet(urlPatterns = "*.do")
 public class ServletDemo10 extends MyHttpServlet {
 
     @Override
     protected void doGet(ServletRequest req, ServletResponse res) {
 
         System.out.println("demo10 get...");
     }
     @Override
     protected void doPost(ServletRequest req, ServletResponse res) {
     }
 }

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

注意:

如果路径配置的不是扩展名，那么在路径的前面就必须要加/否则会报错

如果路径配置的是*.do,那么在*.do的前面不能加/,否则会报错

任意匹配

package com.itheima.web;
 
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.annotation.WebServlet;
 
 /**
  * UrlPattern:
  * * 任意匹配： /
  */
 @WebServlet(urlPatterns = "/")
 public class ServletDemo11 extends MyHttpServlet {
 
     @Override
     protected void doGet(ServletRequest req, ServletResponse res) {
 
         System.out.println("demo11 get...");
     }
     @Override
     protected void doPost(ServletRequest req, ServletResponse res) {
     }
 }

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

package com.itheima.web;
 
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.annotation.WebServlet;
 
 /**
  * UrlPattern:
  * * 任意匹配： /*
  */
 @WebServlet(urlPatterns = "/*")
 public class ServletDemo12 extends MyHttpServlet {
 
     @Override
     protected void doGet(ServletRequest req, ServletResponse res) {
 
         System.out.println("demo12 get...");
     }
     @Override
     protected void doPost(ServletRequest req, ServletResponse res) {
     }
 }

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

注意:/和/*的区别?

当我们的项目中的Servlet配置了 "/",会覆盖掉tomcat中的DefaultServlet,当其他的url-pattern都匹配不上时都会走这个Servlet
当我们的项目中配置了"/*",意味着匹配任意访问路径
DefaultServlet是用来处理静态资源，如果配置了"/"会把默认的覆盖掉，就会引发请求静态资源的时候没有走默认的而是走了自定义的Servlet类，最终导致静态资源不能被访问

小结

urlPattern总共有四种配置方式，分别是精确匹配、目录匹配、扩展名匹配、任意匹配
五种配置的优先级为精确匹配 > 目录匹配> 扩展名匹配 > /* > / ,无需记，以最终运行结果为准。

2.8 XML配置

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

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

编写Servlet类

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

在web.xml中配置该Servlet

<?xml versinotallow="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>

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

3. HTTP

3.1 简介

Hyper Text Transfer Protocol，超文本传输协议，规定了浏览器和服务器之间数据传输的规则。

数据传输的规则指的是请求数据和响应数据需要按照指定的格式进行传输。
打开浏览器，点击F12，点击Network来查看某一次请求的请求数据和响应数据具体的格式内容.

HTTP协议特点

基于TCP协议: 面向连接，安全
TCP是一种面向连接的(建立连接之前是需要经过三次握手)、可靠的、基于字节流的传输层通信协议，在数据传输方面更安全。
基于请求-响应模型的:一次请求对应一次响应
请求和响应是一一对应关系
HTTP协议是无状态协议:对于事物处理没有记忆能力。每次请求-响应都是独立的
无状态指的是客户端发送HTTP请求给服务端之后，服务端根据请求响应数据，响应完后，不会记录任何信息。这种特性有优点也有缺点，

缺点:多次请求间不能共享数据
优点:速度快

请求之间无法共享数据会引发的问题，如:

京东购物，加入购物车和去购物车结算是两次请求，
HTTP协议的无状态特性，加入购物车请求响应结束后，并未记录加入购物车任何商品
发起去购物车结算的请求后，因为无法获取哪些商品加入了购物车，会导致此次请求无法正确展示数据

具体使用的时候，我们发现京东是可以正常展示数据的，原因是Java早已考虑到这个问题，

3.2 请求数据格式

请求数据总共分为三部分内容，分别是请求行、请求头、请求体

请求行: HTTP请求中的第一行数据，请求行包含三块内容，分别是 GET[请求方式] /[请求URL路径] HTTP/1.1[HTTP协议及版本]
请求方式有七种,最常用的是GET和POST
请求头: 第二行开始，格式为key: value形式
请求头中会包含若干个属性，常见的HTTP请求头有:

Host: 表示请求的主机名
 User-Agent: 浏览器版本,例如Chrome浏览器的标识类似Mozilla/5.0 ...Chrome/79，IE浏览器的标识类似Mozilla/5.0 (Windows NT ...)like Gecko； 解决浏览器的兼容性问题
 Accept：表示浏览器能接收的资源类型，如text/*，image/*或者*/*表示所有；
 Accept-Language：表示浏览器偏好的语言，服务器可以据此返回不同语言的网页；
 Accept-Encoding：表示浏览器可以支持的压缩类型，例如gzip, deflate等

请求体: POST请求的最后一部分，存储请求参数

3.3 响应数据格式

响应数据总共分为三部分内容，分别是响应行、响应头、响应体

响应行：响应数据的第一行,响应行包含三块内容，分别是 HTTP/1.1[HTTP协议及版本] 200[响应状态码] ok[状态码的描述]

响应状态码

状态码都是3位数字
1XX：服务器接受客户端消息，但没有接受完成，等待一段时间后，发送1xx多状态码
2XX:成功。代表200
3XX:重定向。代表：302（重定向），304（访问缓存）
4XX:客户端错误。代表：404（请求路径没有对应的资源） 405 （请求方式没有对应的doXXX方法）
5XX：服务器端错误；代表：500（服务器内部出现异常）

响应头：第二行开始，格式为key：value形式
响应头中会包含若干个属性，常见的HTTP响应头有:

Content-Type：表示该响应内容的类型，例如text/html，image/jpeg；
 Content-Length：表示该响应内容的长度（字节数）；
 Content-Encoding：表示该响应压缩算法，例如gzip；
 Cache-Control：指示客户端应如何缓存，例如max-age=300表示可以最多缓存300秒
 content-disposition:服务器告诉客户端以什么格式打开响应体数据,in-line:默认值,在当前页面内打开
 attachment;filename=xxx：以附件形式打开响应体。文件下载

响应体：最后一部分。存放响应数据
上图中<html>...</html>这部分内容就是响应体，它和响应头之间有一个空行隔开。

4. Reuqest&Response

4.1 Request和Response的概述

Request是用来封装请求数据的对象，Response是用来封装响应数据对象，是由服务器创建的。

request:获取请求数据

浏览器会发送HTTP请求到后台服务器[Tomcat]
HTTP的请求中会包含很多请求数据[请求行+请求头+请求体]
后台服务器[Tomcat]会对HTTP请求中的数据进行解析并把解析结果存入到一个对象中
所存入的对象即为request对象，所以我们可以从request对象中获取请求的相关参数
获取到数据后就可以继续后续的业务，比如获取用户名和密码就可以实现登录操作的相关业务

response:设置响应数据

业务处理完后，后台就需要给前端返回业务处理的结果即响应数据
把响应数据封装到response对象中
后台服务器[Tomcat]会解析response对象,按照[响应行+响应头+响应体]格式拼接结果
浏览器最终解析结果，把内容展示在浏览器给用户浏览

4.2 Request对象

4.2.1 Request继承体系

ServletRequest和HttpServletRequest都是Java提供的，二者是继承关系，并且两个都是接口，无法创建对象。

这就需要用到Tomcat服务器的Request继承体系中的RequestFacade：

该类实现了HttpServletRequest接口，也间接实现了ServletRequest接口。
Servlet类中的service方法、doGet方法或者是doPost方法最终都是由Web服务器[Tomcat]来调用的，所以Tomcat提供了方法参数接口的具体实现类，并完成了对象的创建

4.2.2 Request获取请求数据

HTTP请求数据总共分为三部分内容，分别是请求行、请求头、请求体

① 获取请求行数据

请求行包含三块内容，分别是请求方式、请求资源路径、HTTP协议及版本

对于这三部分内容，request对象都提供了对应的API方法来获取，具体如下:

获取请求方式: GET

String getMethod()

获取虚拟目录(项目访问路径): /request-demo

String getContextPath()

获取URL(统一资源定位符): http://localhost:8080/request-demo/req1

StringBuffer getRequestURL()

获取URI(统一资源标识符): /request-demo/req1

String getRequestURI()

获取请求参数(GET方式): username=zhangsan&password=123

String getQueryString()

获取协议及版本：HTTP/1.1

String getProtocol()

获取客户机的IP地址：

String getRemoteAddr()

介绍完上述方法后，咱们通过代码把上述方法都使用下:

② 获取请求头数据

对于请求头的数据，格式为key: value如下:

根据请求头名称获取对应值的方法为:

String getHeader(String name)

获取所有的请求头名称

Enumeration<String> getHeaderNames()

接下来，在代码中如果想要获取客户端浏览器的版本信息，则可以使用

③ 获取请求体数据

浏览器在发送GET请求的时候是没有请求体的，所以需要把请求方式变更为POST，请求体中的数据格式如下:

对于请求体中的数据，Request对象提供了如下两种方式来获取其中的数据，分别是:

获取字节输入流，如果前端发送的是字节数据，比如传递的是文件数据，则使用该方法

ServletInputStream getInputStream()
 该方法可以获取字节

获取字符输入流，如果前端发送的是纯文本数据，则使用该方法

BufferedReader getReader()

④ 获取请求参数的通用方式

基于上述理论，request对象为我们提供了如下方法:

获取所有参数Map集合

Map<String,String[]> getParameterMap()

根据名称获取参数值（数组）

String[] getParameterValues(String name)

根据名称获取参数值(单个值)

String getParameter(String name)

获取所有请求的参数名称

Enumeration<String> getParameterNames()

4.2.3 请求参数中文乱码问题

get方式：tomcat 8 已经将get方式乱码问题解决了

POST请求的中文乱码解决方案为什么不适用GET请求？

GET请求获取请求参数的方式是request.getQueryString()
POST请求获取请求参数的方式是request.getReader()
request.setCharacterEncoding("utf-8")是设置request处理流的编码
getQueryString方法并没有通过流的方式获取数据

首先我们需要先分析下GET请求出现乱码的原因:

浏览器通过HTTP协议发送请求和数据给后台服务器（Tomcat)
浏览器在发送HTTP的过程中会对中文数据进行URL编码
在进行URL编码的时候会采用页面<meta>标签指定的UTF-8的方式进行编码，张三编码后的结果为%E5%BC%A0%E4%B8%89
后台服务器(Tomcat)接收到%E5%BC%A0%E4%B8%89后会默认按照ISO-8859-1进行URL解码
由于前后编码与解码采用的格式不一样，就会导致后台获取到的数据为乱码。

URL编码

将字符串按照编码方式转为二进制
每个字节转为2个16进制数并在前边加上%
张三按照UTF-8的方式转换成二进制的结果为:

1110 0101 1011 1100 1010 0000 1110 0100 1011 1000 1000 1001

在计算的十六进制结果中，每两位前面加一个%,就可以获取到%E5%BC%A0%E4%B8%89。
在Java中已经为我们提供了编码和解码的API工具类可以让我们更快速的进行编码和解码:
编码:

java.net.URLEncoder.encode("需要被编码的内容","字符集(UTF-8)")

解码:

java.net.URLDecoder.decode("需要被解码的内容","字符集(UTF-8)")

通用方式（GET/POST）：需要先解码，再编码

new String(username.getBytes("ISO-8859-1"),"UTF-8");

/**
  * 中文乱码问题解决方案
  */
 @WebServlet("/req4")
 public class RequestDemo4 extends HttpServlet {
     @Override
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         //1. 解决乱码：POST，getReader()
         //request.setCharacterEncoding("UTF-8");//设置字符输入流的编码
 
         //2. 获取username
         String username = request.getParameter("username");
         System.out.println("解决乱码前："+username);
 
         //3. GET,获取参数的方式：getQueryString
         // 乱码原因：tomcat进行URL解码，默认的字符集ISO-8859-1
        /* //3.1 先对乱码数据进行编码：转为字节数组
         byte[] bytes = username.getBytes(StandardCharsets.ISO_8859_1);
         //3.2 字节数组解码
         username = new String(bytes, StandardCharsets.UTF_8);*/
 
         username  = new String(username.getBytes(StandardCharsets.ISO_8859_1),StandardCharsets.UTF_8);
 
         System.out.println("解决乱码后："+username);
 
     }
 
     @Override
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         this.doGet(request, response);
     }
 }

注意：Tomcat8.0之后，已将GET请求乱码问题解决，设置默认的解码方式为UTF-8

post方式：会乱码

分析出现中文乱码的原因：

POST的请求参数是通过request的getReader()来获取流中的数据
TOMCAT在获取流的时候采用的编码是ISO-8859-1
ISO-8859-1编码是不支持中文的，所以会出现乱码

解决方案：

页面设置的编码格式为UTF-8
把TOMCAT在获取流数据之前的编码设置为UTF-8
通过request.setCharacterEncoding("UTF-8")设置编码,UTF-8也可以写成小写
POST请求中文乱码的问题就已经解决，但是这种方案不适用于GET请求

解决：在获取参数前，设置request的编码 request.setCharacterEncoding("utf-8");

4.2.4 Requset 请求转发

请求转发(forward):一种在服务器内部的资源跳转方式。

(1)浏览器发送请求给服务器，服务器中对应的资源A接收到请求

(2)资源A处理完请求后将请求发给资源B

(3)资源B处理完后将结果响应给浏览器

(4)请求从资源A到资源B的过程就叫请求转发

请求转发的实现方式：通过请求转发器对象进行转发

req.getRequestDispatcher("资源B路径").forward(req,resp);

具体如何来使用，我们先来看下需求:

针对上述需求，具体的实现步骤为:

1.创建一个RequestDemo5类，接收/req5的请求，在doGet方法中打印demo5
2.创建一个RequestDemo6类，接收/req6的请求，在doGet方法中打印demo6
3.在RequestDemo5的方法中使用
req.getRequestDispatcher("/req6").forward(req,resp)进行请求转发
4.启动测试

请求转发资源间共享数据:使用Request对象

域对象：一个有作用范围的对象，可以在范围内共享数据

request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据

需要使用request对象提供的三个方法:

存储数据到request域[范围,数据是存储在request对象]中

void setAttribute(String name,Object o);

根据key获取值

Object getAttribute(String name);

根据key删除该键值对

void removeAttribute(String name);

请求转发的特点

浏览器地址栏路径不发生变化
能转发到当前服务器的内部资源
不能从一个服务器通过转发访问另一台服务器
转发是一次请求，可以在转发资源间使用request共享数据
虽然后台从/req5转发到/req6，但是这个只有一次请求

4.3 Response 对象

Response:使用response对象来设置响应数据

Reponse的继承体系和Request的继承体系也非常相似:

4.3.1 Response设置响应数据功能介绍

HTTP响应数据总共分为三部分内容，分别是响应行、响应头、响应体

响应行

对于响应头，比较常用的就是设置响应状态码:

void setStatus(int sc);

响应头

设置响应头键值对：

void setHeader(String name,String value);

响应体

对于响应体，是通过字符、字节输出流的方式往浏览器写，

获取字符输出流:

PrintWriter getWriter();

获取字节输出流

ServletOutputStream getOutputStream();

介绍完这些方法后，后面我们会通过案例把这些方法都用一用，首先先来完成下重定向的功能开发。

4.3.2 Respones请求重定向

Response重定向(redirect):一种资源跳转方式。

(1)浏览器发送请求给服务器，服务器中对应的资源A接收到请求

(2)资源A现在无法处理该请求，就会给浏览器响应一个302的状态码+location的一个访问资源B的路径

(3)浏览器接收到响应状态码为302就会重新发送请求到location对应的访问地址去访问资源B

(4)资源B接收到请求后进行处理并最终给浏览器响应结果，这整个过程就叫重定向

重定向的实现方式:

resp.setStatus(302);
 resp.setHeader("location","资源B的访问路径");

request对象提供了简化的编写方式为:

resposne.sendRedirect("/request-demo/resp2")

具体如何来使用，我们先来看下需求:

针对上述需求，具体的实现步骤为:

1.创建一个ResponseDemo1类，接收/resp1的请求，在doGet方法中打印resp1....
2.创建一个ResponseDemo2类，接收/resp2的请求，在doGet方法中打印resp2....
3.在ResponseDemo1的方法中使用
response.setStatus(302);
response.setHeader("Location","/request-demo/resp2") 来给前端响应结果数据
4.启动测试

重定向的特点

浏览器地址栏路径发送变化
可以重定向到任何位置的资源(服务内容、外部均可)
因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。
两次请求，不能在多个资源使用request共享数据
因为浏览器发送了两次请求，是两个不同的request对象，就无法通过request对象进行共享数据

介绍完请求重定向和请求转发以后，接下来需要把这两个放在一块对比下:

以后到底用哪个，还是需要根据具体的业务来决定。

4.3.3 路径问题

问题1：转发的时候路径上没有加/request-demo而重定向加了，那么到底什么时候需要加，什么时候不需要加呢?

其实判断的依据很简单，只需要记住下面的规则即可:

浏览器使用:需要加虚拟目录(项目访问路径)

对于重定向来说，路径最终是由浏览器来发送请求，就需要添加虚拟目录。

resp.sendRedirect("路径")
建议虚拟目录动态获取：request.getContextPath()

<a href='路径'>
<form actinotallow='路径'>

对于转发来说，因为是在服务端进行的，所以不需要加虚拟目录

req.getRequestDispatcher("路径")

问题2：在重定向的代码中，/request-demo是固定编码的，如果后期通过Tomcat插件配置了项目的访问路径，那么所有需要重定向的地方都需要重新修改，该如何优化?

答案也比较简单，我们可以在代码中动态去获取项目访问的虚拟目录，具体如何获取，我们可以借助request对象中的getContextPath()方法，修改后的代码如下:

@WebServlet("/resp1")
 public class ResponseDemo1 extends HttpServlet {
     @Override
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         System.out.println("resp1....");
 
         //简化方式完成重定向
         //动态获取虚拟目录
         String contextPath = request.getContextPath();
         response.sendRedirect(contextPath+"/resp2");
     }
 
     @Override
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         this.doGet(request, response);
     }
 }

4.3.4 Response响应字符数据

要想将字符数据写回到浏览器，我们需要两个步骤:

通过Response对象获取字符输出流： PrintWriter writer = resp.getWriter();
通过字符输出流写数据: writer.write("aaa");

乱码问题：

PrintWriter pw = response.getWriter();获取的流的默认编码是ISO-8859-1
是在获取流之前设置response.setContentType("text/html;charset=utf-8");

注意:一次请求响应结束后，response对象就会被销毁掉，所以不要手动关闭流。

4.3.5 Response响应字节数据

要想将字节数据写回到浏览器，我们需要两个步骤:

通过Response对象获取字节输出流：ServletOutputStream outputStream = resp.getOutputStream();
通过字节输出流写数据: outputStream.write(字节数据);

返回一个图片文件到浏览器

/**
  * 响应字节数据：设置字节数据的响应体
  */
 @WebServlet("/resp4")
 public class ResponseDemo4 extends HttpServlet {
     @Override
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         //1. 读取文件
         FileInputStream fis = new FileInputStream("d://a.jpg");
         //2. 获取response字节输出流
         ServletOutputStream os = response.getOutputStream();
         //3. 完成流的copy
         byte[] buff = new byte[1024];
         int len = 0;
         while ((len = fis.read(buff))!= -1){
             os.write(buff,0,len);
         }
         fis.close();
     }
 
     @Override
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         this.doGet(request, response);
     }
 }

上述代码中，对于流的copy的代码还是比较复杂的，所以我们可以使用别人提供好的方法来简化代码的开发，具体的步骤是:

(1)pom.xml添加依赖

<dependency>
     <groupId>commons-io</groupId>
     <artifactId>commons-io</artifactId>
     <version>2.6</version>
 </dependency>

(2)调用工具类方法

//fis:输入流
 //os:输出流
 IOUtils.copy(fis,os);

优化后的代码:

/**
  * 响应字节数据：设置字节数据的响应体
  */
 @WebServlet("/resp4")
 public class ResponseDemo4 extends HttpServlet {
     @Override
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         //1. 读取文件
         FileInputStream fis = new FileInputStream("d://a.jpg");
         //2. 获取response字节输出流
         ServletOutputStream os = response.getOutputStream();
         //3. 完成流的copy
         IOUtils.copy(fis,os);
         fis.close();
     }
 
     @Override
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         this.doGet(request, response);
     }
 }

5. ServletContext对象

概念：代表整个web应用，可以和程序的容器(服务器)来通信
获取：

通过request对象获取 request.getServletContext();
通过HttpServlet获取 this.getServletContext();

功能：

获取MIME类型：

MIME类型:在互联网通信过程中定义的一种文件数据类型

格式：大类型/小类型 text/html image/jpeg

获取：String getMimeType(String file)

域对象：共享数据

setAttribute(String name,Object value)
getAttribute(String name)
removeAttribute(String name)

ServletContext对象范围：所有用户所有请求的数据

获取文件的真实(服务器)路径

方法：String getRealPath(String path) String b = context.getRealPath("/b.txt");//web目录下资源访问 System.out.println(b);
String c = context.getRealPath("/WEB-INF/c.txt");//WEB-INF目录下的资源访问 System.out.println(c);
String a = context.getRealPath("/WEB-INF/classes/a.txt");//src目录下的资源访问 System.out.println(a);

上一篇：【HMS Core】华为地图服务调用接口403问题
下一篇：没有了

网友评论

相关栏目