Request

目标：

• 掌握Request对象的概念与使用
• 掌握Response对象的概念与使用
• 能够完成用户登录注册案例的实现
• 能够完成SQLSessionFactory工具类的抽取

Request和Response概述

Request是请求对象，Response是响应对象。这两个对象在我们使用Servlet的时候看到：

@WebServlet("/demo")
public class ServletDemo implements Servlet {

  @Override
  public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
    System.out.println("say hello ~");
  }

  @Override
  public void init(ServletConfig config) throws ServletException {

  }

}

此时，我们就需要思考一个问题request和response这两个参数的作用是什么？

• request：获取请求数据
  • 浏览器会发送HTTP请求到后台服务器Tomcat
  • HTTP的请求中会包含很多请求数据请求行 + 请求头 + 请求体
  • 后台服务器Tomcat会对HTTP请求中的数据进行解析并把解析结果存入到一个对象中
  • 所存入的对象即为Request对象，所以我们可以从Request对象中获取请求的相关参数
  • 获取到数据后就可以继续后续的业务，比如获取用户名和密码就可以实现登录操作的相关业务
• Response：设置响应数据
  • 业务处理完后，后台就需要给前端返回业务处理的结果即响应数据
  • 把响应数据封装到Response对象中
  • 后台服务器Tomcat会解析Response对象，按照响应行 + 响应头 + 响应体格式拼接结果
  • 浏览器最终解析结果，把内容展示在浏览器给用户浏览

对于上述所讲的内容，我们通过一个案例来初步体验下request和response对象的使用。

实现步骤：

• 使用骨架创建JavaWeb项目
  • 创建Maven项目
  • 选择使用Web项目骨架
  • 输入Maven项目坐标创建项目
  • 确认Maven相关的配置信息后，完成项目创建
  • 删除pom.xml文件中多余的内容
  • 补齐JavaWeb项目缺失的目录结构
• 开发Servlet代码
  • 编写ServletDemo3类

1. 使用骨架创建JavaWeb项目

   1. 创建Maven项目

   

   2. 选择使用Web项目骨架

   

   3. 输入Maven项目坐标创建项目

   

   4. 确认Maven相关配置信息

   

   5. 完成项目创建

   

   6. 删除pom.xml文件中多余的内容，只留下下面的内容，注意打包方式为war

   <?xml version="1.0" encoding="UTF-8"?>
   
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
   
     <groupId>com.itheima</groupId>
     <artifactId>Day09</artifactId>
     <version>1.0-SNAPSHOT</version>
     <packaging>war</packaging>
   
     <properties>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <maven.compiler.source>8</maven.compiler.source>
       <maven.compiler.target>8</maven.compiler.target>
     </properties>
   
   </project>
   

   7. 补齐Web项目缺失的目录结构，默认没有java和resources目录，需要手动完成创建，最终的目录结构如下：

   

   

2. 编写Servlet代码

   1. 在pom.xml文件中添加servlet依赖坐标

   <?xml version="1.0" encoding="UTF-8"?>
   
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
   
       <groupId>com.itheima</groupId>
       <artifactId>Day09</artifactId>
       <version>1.0-SNAPSHOT</version>
       <packaging>war</packaging>
   
       <properties>
           <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
           <maven.compiler.source>8</maven.compiler.source>
           <maven.compiler.target>8</maven.compiler.target>
       </properties>
   
       <dependencies>
           <dependency>
               <groupId>javax.servlet</groupId>
               <artifactId>javax.servlet-api</artifactId>
               <version>3.1.0</version>
               <scope>provided</scope>
           </dependency>
       </dependencies>
   
   </project>
   

   2. 创建包

   

   3. 创建ServletDemo3类

   

3. 实现ServletDemo3类中的方法

   1. 继承HttpServlet接口

   package com.itheima.request;
   
   import javax.servlet.http.HttpServlet;
   
   public class ServletDemo3 extends HttpServlet {
   
   }
   

   2. 重写doGet和doPost方法

   

   package com.itheima.request;
   
   import javax.servlet.ServletException;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import java.io.IOException;
   
   public class ServletDemo3 extends HttpServlet {
   
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           // 使用request对象，获取请求数据
           // url?name=张三
           String name = req.getParameter("name");
   
           //使用response对象，设置响应数据
           resp.setHeader("content-type", "text/html;charset=utf-8");
           resp.getWriter().write("<h1>" + name + ", 欢迎您！</h1>");
       }
   
       @Override
       protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           System.out.println("Post ...");
       }
   }
   

4. 配置Tomcat并启动服务

   1. 配置本地Tomcat

   

   2. 部署我们的Day09模块

   

   3. 将Tomcat服务添加到启动列表中

   

5. 通过浏览器访问http://localhost/Day09/demo3?name=%E5%AD%99%E9%98%B3

   

小结

在这一小节中，我们主要认识了下request对象和response对象：

• request对象是用来封装请求数据的对象
• response对象是用来封装响应数据的对象

目前我们只知道这两个对象是用来干什么的，那么它们具体是如何实现的，接下来就需要我们继续深入的学习，我们先从Request对象来开始，主要学习下面这些内容：

• Request继承体系
• Request获取请求参数
• Request请求转发

Request对象

在学习这节内容之前，我们先看一个问题，前面在介绍Request和Response对象的时候，比较细心的同学可能已经发现：

• 当我们的Servlet类实现的是Servlet接口的时候，service方法中的参数是ServletRequest和ServletResponse
• 当我们的Servlet类继承的是HttpServlet类的时候，doGet和doPost方法中的参数就变成了HttpServletRequest和HttpServletResponse

那么，我们就要提出以下几个问题：

• ServletRequest和HttpServletRequest的关系是什么？
• Request对象是由谁来创建的？
• Request对象提供了哪些API，这些API从哪里可以查到如何使用？

Request继承体系

首先，我们先来看下Request的继承体系：

从上图可以看出，ServletRequest和HttpServletRequest都是Java提供的，所以我们可以打开JavaEE提供的API文档，打开后可以看到：

所以ServletRequest和HttpServletRequest是继承关系，并且两个都是接口，接口是无法创建对象的，这个时候就引发了下面的问题：

这个时候，我们就需要用到Request继承体系中的RequestFacade类：

• 该类实现了HttpServletRequest接口，也间接实现了ServletRequest接口；
• Servlet类中的service方法、doGet方法或者doPost方法最终都是由Web服务器(Tomcat)来调用，所以Tomcat提供了接口方法参数的具体实现类，并完成了对象的创建；
• 要想了解RequestFacade中都提供了哪些方法，我们可以直接查看JavaEE的API文档中关于ServletRequest和HttpServletRequest的接口文档，因为RequestFacade实现了其接口就需要重写接口中的方法

对于上述结论，要想验证，可以编写一个Servlet，在方法中把Request对象打印下，就能看到最终的对象是不是RequestFacade，代码如下：

package com.itheima.request;

import javax.servlet.ServletException;
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("/demo2")
public class ServletDemo2 extends HttpServlet {

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

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

启动服务器，运行访问：http://localhost/Day09/demo2，得到运行结果：

小结

• Request的继承体系为ServletRequest --> HttpServletRequest --> RequestFacade
• Tomcat需要解析请求数据，封装为Request对象，并且创建Request对象传递到service方法
• 使用Request对象，可以查阅JavaEE API文档的HttpServletRequest接口中的方法说明

Request获取请求数据

HTTP请求数据总共分为三部分内容，分别是请求行、请求头、请求体，对于这三部分内容的数据，分别该如何获取呢？

获取请求行数据

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

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

• 获取请求方式：GET

  String getMethod();
  

• 获取虚拟目录(项目访问路径)：/Day09

  String getContextPath();
  

• 获取URL(统一资源定位符)：http://localhost/Day09/demo3

  StringBuffer getRequestURL();
  

• 获取URI(统一资源标识符)：/Day09/demo3

  String getRequestURI();
  

• 获取请求参数(GET方式)：name=zhangsan&password=1234

  String getQueryString();
  

介绍完上述方法后，我们通过代码把上述方法都使用一下：

package com.itheima.request;

import javax.servlet.ServletException;
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("/demo3")
public class ServletDemo3 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 使用request对象，获取请求数据
        // String getMethod(): 获取请求方式 GET
        String method = req.getMethod();
        // String getContextPath(): 获取虚拟目录，项目访问路径 /Day09
        String contextPath = req.getContextPath();
        // StringBuffer getRequestURL(): 获取URL(统一资源定位符)
        StringBuffer url = req.getRequestURL();
        // String getRequestURI(): 获取URI(统一资源标识符) /Day09/demo3
        String uri = req.getRequestURI();
        // String getQueryString(): 获取请求参数(GET方式) name=zhangsan
        String queryString = req.getQueryString();
        // url?name=张三
        String name = req.getParameter("name");

        //使用response对象，设置响应数据
        resp.setHeader("content-type", "text/html;charset=utf-8");
        String html = "<h1>" + name + ", 欢迎您！</h1>"
                + "<h2> 请求方式：" + method + "</h2>"
                + "<h2> 项目访问路径：" + contextPath + "</h2>"
                + "<h2> URL：" + url + "</h2>"
                + "<h2> URI：" + uri + "</h2>"
                + "<h2> 请求参数(GET)：" + queryString + "</h2>";
        resp.getWriter().write(html);
    }

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

启动服务器，访问http://localhost/Day09/demo3?name=sunyangyang&password123456，访问到的网页如下：

URI和URL

URI包括URL和URN两个类别，URL是URI的子集，所以URL一定是URI，而URI不一定是URL

URI = Universal Resource Identifier 统一资源标志符，用来标识抽象或物理资源的一个紧凑字符串。

URL = Universal Resource Locator 统一资源定位符，一种定位资源的主要访问机制的字符串，一个标准的URL必须包括：protocol、host、port、path、parameter、anchor。

URN = Universal Resource Name 统一资源名称，通过特定命名空间中的唯一名称或ID来标识资源。

统一资源标识符URI就是在某一规则下把一个资源独一无二地标识出来。 举个例子： 假设这个世界上所有人的名字都不能重复，那么名字就是URI的一个实例，通过名字就可以标识出唯一的一个人。但现实当中名字当然会重复，所以身份证号才是URI，通过身份证号能让我们能且仅能确定一个人。 那统一资源定位符URL是什么呢？同样是上面的例子，我们知道某个人的身份证号并不一定能找打这个人，但如果我们知道如下信息： 生物住址协议://地球/中国/广东/广州/花都区/X学校/X楼/X宿舍/张三 可以看到，上面的字符串同样标识出了唯一的一个人，起到了URI的作用，所以URL是URI的子集，但URL是以描述人的位置来唯一确定一个人的。

获取请求头数据

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

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

String getHeader(String name);

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

package com.itheima.request;

import javax.servlet.ServletException;
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("/demo3")
public class ServletDemo3 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 使用request对象，获取请求数据
        // 1. 获取请求行数据
        // String getMethod(): 获取请求方式 GET
        String method = req.getMethod();
        // String getContextPath(): 获取虚拟目录，项目访问路径 /Day09
        String contextPath = req.getContextPath();
        // StringBuffer getRequestURL(): 获取URL(统一资源定位符)
        StringBuffer url = req.getRequestURL();
        // String getRequestURI(): 获取URI(统一资源标识符) /Day09/demo3
        String uri = req.getRequestURI();
        // String getQueryString(): 获取请求参数(GET方式) name=zhangsan
        String queryString = req.getQueryString();
        // url?name=张三
        String name = req.getParameter("name");

        // 2. 获取请求头数据
        // user-agent: 浏览器版本信息
        String agent = req.getHeader("user-agent");
        System.out.println(agent);

        //使用response对象，设置响应数据
        resp.setHeader("content-type", "text/html;charset=utf-8");
        String html = "<h1>" + name + ", 欢迎您！</h1>"
                + "<h2> 请求方式：" + method + "</h2>"
                + "<h2> 项目访问路径：" + contextPath + "</h2>"
                + "<h2> URL：" + url + "</h2>"
                + "<h2> URI：" + uri + "</h2>"
                + "<h2> 请求参数(GET)：" + queryString + "</h2>"
                + "<h2> User-Agent浏览器版本信息：" + agent + "</h2>"
                ;
        resp.getWriter().write(html);
    }

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

重新启动服务器后，http://localhost/Day09/demo3?name=sunyangyang&password=123456，获取的结果如下

获取请求体数据

在讲获取请求体数据之前，我们来回顾一下GET和POST请求方式的区别：

1. 都可以携带额外的参数：
   1. GET提交的数据会放在URL之后，以?分隔URL和参数，参数之间以&相连
   2. POST方法是把提交的数据放在HTTP包的请求体(Body)中
2. 提交数据的大小限制：浏览器对URL长度有限制，所以GET提交的数据大小有限制，而POST方法则没有
3. 数据的安全性：GET方式提交数据，会带来安全问题，比如一个登录页面，通过GET方式提交数据时，用户名和密码将出现在URL上，如果页面可以被缓存或者其他人可以访问这台机器，就可以从历史记录中获得该用户的账号和密码。

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

username=zhangsan&password123

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

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

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

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

  BufferedReader getReader();
  

接下来，大家想一下，获取请求体的内容该如何实现：

实现步骤：

• 准备一个登录页面，用来发送POST请求
• 在Servlet的doPost方法中获取请求体数据
• 在doPost方法中使用Request的getReader()或者getInputStream()来获取请求体数据
• 访问测试

1. 在项目的webapp目录下添加一个HTML页面，名称为：login.html

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
    <link rel="stylesheet" href="static/css/reset.css" />
    <link rel="stylesheet" href="static/css/style.css" media="screen" type="text/css" />
</head>
<body>
    <div id="window" style="display:none;">
        <div class="page page-front">
            <div class="page-content">
                <div class="input-row">
                    <label class="label fadeIn">用户名</label>
                    <input id="username" type="text" class="input fadeIn delay1" />
                </div>
                <div class="input-row">
                    <label class="label fadeIn delay2">密码</label>
                    <input id="password" type="password" class="input fadeIn delay3" />
                </div>
                <div class="input-row perspective">
                    <button id="submit" class="button load-btn fadeIn delay4">
                        <span class="default"><i class="ion-arrow-right-b"></i>登录</span>
                        <div class="load-state">
                            <div class="ball"></div>
                            <div class="ball"></div>
                            <div class="ball"></div>
                        </div>
                    </button>
                </div>
            </div>
        </div>
        <div class="page page-back">
            <div class="page-content">
                <img src="static/img/avatar.jpg" class="avatar" />
                <p class="welcome">欢迎您</p>
                <div class="perspective">
                    <button class="button inline trigger-anim-replay"><i class="ion-refresh"></i>重播</button>
                </div>
            </div>
        </div>
    </div>
    <script type="text/javascript" src="static/js/jquery.js"></script>
    <script type="text/javascript" src="static/js/index.js"></script>
</body>
</html>

提示

HTML页面中引入的css、js等文件可以在我们随堂代码中找到，源码就不一一在讲义里面体现了。

2. 在Servlet的doPost方法中获取数据

package com.itheima.request;

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

@WebServlet("/demo3")
public class ServletDemo3 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 使用request对象，获取请求数据
        // 1. 获取请求行数据
        // String getMethod(): 获取请求方式 GET
        String method = req.getMethod();
        // String getContextPath(): 获取虚拟目录，项目访问路径 /Day09
        String contextPath = req.getContextPath();
        // StringBuffer getRequestURL(): 获取URL(统一资源定位符)
        StringBuffer url = req.getRequestURL();
        // String getRequestURI(): 获取URI(统一资源标识符) /Day09/demo3
        String uri = req.getRequestURI();
        // String getQueryString(): 获取请求参数(GET方式) name=zhangsan
        String queryString = req.getQueryString();
        // url?name=张三
        String name = req.getParameter("name");

        // 2. 获取请求头数据
        // user-agent: 浏览器版本信息
        String agent = req.getHeader("user-agent");
        System.out.println(agent);

        //使用response对象，设置响应数据
        resp.setHeader("content-type", "text/html;charset=utf-8");
        String html = "<h1>" + name + ", 欢迎您！</h1>"
                + "<h2> 请求方式：" + method + "</h2>"
                + "<h2> 项目访问路径：" + contextPath + "</h2>"
                + "<h2> URL：" + url + "</h2>"
                + "<h2> URI：" + uri + "</h2>"
                + "<h2> 请求参数(GET)：" + queryString + "</h2>"
                + "<h2> User-Agent浏览器版本信息：" + agent + "</h2>"
                ;
        resp.getWriter().write(html);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        System.out.println("收到Post请求... ...");
        BufferedReader br = req.getReader();
        String line = br.readLine();
        System.out.println("请求体内容：" + line);
        resp.setCharacterEncoding("UTF-8");
        resp.getWriter().write("请求已收到!");
    }
}

3. 调用getReader()或者getInputStream()方法，因为目前前端传递的是纯文本数据，所以我们采用getReader()方法来获取，代码参考第二步中的源码

4. 点击登录按钮后，就可以在控制台看到前端发送的请求数据

   

小结

HTTP请求数据中包含了请求行、请求头、和请求体，针对这三部分内容，Request对象都提供了对应的API方法来获取对应的值。

• 请求行
  • getMethod()获取请求方式
  • getContextPath()获取项目访问路径
  • getRequestURL()获取请求URL
  • getRequestURI()获取请求URI
  • getQueryString()获取GET请求方式的请求参数
• 请求头
  • getHeader(String name)根据请求头名称获取其对应的值
• 请求体
  • 注意：浏览器发送的POST请求才有请求体
  • 如果是纯文本数据：getReader()
  • 如果是字节数据如文件数据：getInputStream()

获取请求参数的通用方式

问题：

• 什么是请求参数？
• 请求参数和请求数据的关系是什么？

1. 什么是请求参数？

   为了能更好的回答上述两个问题，我们拿用户登录的例子来说明

   

   1. 想要登录网站，需要进入登录页面
   2. 在登录页面输入用户名和密码
   3. 将用户名和密码提交到后台
   4. 后台校验用户名和密码是否正确
   5. 如果正确，则正常登录，如果不正确，则提示用户名和密码错误

   上面的用户名和密码其实就是我们所说的请求参数。

2. 什么是请求数据？

   请求数据包含请求行、请求头和请求体的所有数据

3. 请求参数和请求数据的关系是什么？

   1. 请求参数是请求数据中的部分内容
   2. 如果是GET请求，请求参数在请求行中
   3. 如果是POST请求，请求参数一般在请求体中

对于请求参数的获取，常用的有以下两种：

• GET方式：

  String getQueryString();
  

• POST方式：

  BufferedReader getReader();
  

了解完上面的知识，我们再来回顾一下咱们的用户登录ServletDemo3案例

在上述代码中，doGet和doPost方法都需要解析、处理请求参数，那么有没有一种处理请求参数的通用方式，使用该方式我们可以将doGet和doPost方法中的请求参数处理代码抽取到一个公共方法里面，类似下面的代码结构：

@WebServlet("/demo3")
public class ServletDemo3 extends HttpServlet {

    private Map<String, String> parseRequestParam(HttpServletRequest req) {
        // TODO 处理请求参数
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // TODO 调用处理请求参数方法，获取请求参数
        Map<String, String> param = parseRequestParam(req);

        // TODO 使用请求参数，处理GET请求业务

        // TODO 响应GET请求
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        // TODO 调用处理请求参数方法，获取请求参数
        Map<String, String> param = parseRequestParam(req);

        // TODO 使用请求参数，处理POST请求业务

        // TODO 响应POST请求
    }

}

要实现上面的方式，以我们现在的知识储备是不太容易实现的，因为我们在获取GET和POST请求参数上使用的是不同的处理方式，以上面所学到的知识实现：

private Map<String, String> parseRequestParam(HttpServletRequest req) {
    // 处理请求参数
    // 1. 获取请求方式
    String method = req.getMethod();
    // 2. 根据请求方式不同，采用不同的方式获取请求参数
    if ("GET".equals(method)) {
      // 以GET获取方式获取请求参数
    }
    if ("POST".equals(method)) {
      // 以POST获取方式获取请求参数
    }
}

上面使用Request的getMethod()来获取请求方式，根据请求方式的不同分别获取请求参数值，这样就可以解决上述问题，但是以后每个Servlet都需要这样写代码，实现起来比较麻烦，这种方案我们弃用。

有没有更方便快捷的方法，获取请求参数？

Request对象已经将上述获取请求参数的方法进行了封装，并且Request提供的方法实现的功能更强大，以后只需要调用Request提供的方法即可，在Request的方法中都实现了哪些操作呢？

1. 根据不同的请求方式获取请求参数，请求参数内容如下：

   username=zhangsan&hobby=1&hobby=2
   

2. 把获取到的内容进行分割，内容如下

   

3. 把分割后的数据，存入到一个Map集合中：Map<String, String[]>

   

注意

因为参数的值可能是一个，也可能是多个，所以Map的值的类型为String数组

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

• 获取所有参数Map集合

  Map<String, String[]> getParameterMap();
  

• 根据名称获取参数值数组

  String[] getParameterValues(String name)
  

• 根据名称获取参数值单个值

  String getParameter(String name);
  

接下来，我们通过案例来把上述的三个方法进行实例演示：

1. 新增注册页面regist.html，添加用户名、密码、爱好等输入信息

   <!DOCTYPE html>
   <html lang="zh">
   <head>
       <meta charset="UTF-8">
       <title>注册</title>
   </head>
   <body>
       <form action="demo1" method="GET">
           用户名：<input type="text" name="username" /> <br>
           密码：<input type="password" name="password" /> <br>
           爱好：<input type="checkbox" name="hobby" value="1" /> 游泳
           <input type="checkbox" name="hobby" value="2" /> 爬山 <br>
           <input type="submit" value="提交">
       </form>
   </body>
   </html>
   

   

2. 在Servlet代码中获取页面传递的GET请求的参数值

   1. 获取GET方式的所有请求参数
   2. 获取GET请求参数中的爱好，结果是数组值
   3. 获取GET请求参数中的用户名和密码，结果是单个值

   package com.itheima.request;
   
   import javax.servlet.ServletException;
   import javax.servlet.annotation.WebServlet;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import java.io.IOException;
   import java.util.Map;
   
   @WebServlet("/demo1")
   public class ServletDemo1 extends HttpServlet {
   
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           // 获取GET请求参数逻辑
           System.out.println("收到 GET 请求 ...");
           // 1. 获取所有参数的Map集合
           Map<String, String[]> map = req.getParameterMap();
           for (String key : map.keySet()) {
               // username: zhangsan
               System.out.print(key + " : ");
   
               // 获取值
               String[] values = map.get(key);
               for (String value : values) {
                   System.out.print(value + " ");
               }
   
               System.out.println();
           }
   
           // 2. 获取GET请求参数中的爱好，结果是数组
           System.out.println("--------------------------------------------");
           String[] hobbies = req.getParameterValues("hobby");
           for (String hobby : hobbies) {
               System.out.println("爱好：" + hobby);
           }
   
           // 3. 获取GET请求参数中的用户名和密码，结果是单个值
           String username = req.getParameter("username");
           String password = req.getParameter("password");
           System.out.println("用户名：" + username);
           System.out.println("密码：" +password);
       }
   
       @Override
       protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
   
       }
   
   }
   

   运行结果：

   

3. 在Servlet代码中获取页面传递POST请求的参数值

   1. 将regist.html页面的form表单的提交方式改为post

   <!DOCTYPE html>
   <html lang="zh">
   <head>
       <meta charset="UTF-8">
       <title>注册</title>
   </head>
   <body>
       <form action="demo1" method="POST">
           用户名：<input type="text" name="username" /> <br>
           密码：<input type="password" name="password" /> <br>
           爱好：<input type="checkbox" name="hobby" value="1" /> 游泳
           <input type="checkbox" name="hobby" value="2" /> 爬山 <br>
           <input type="submit" value="提交">
       </form>
   </body>
   </html>
   

   2. 将doGet方法中的内容复制到doPost方法中即可

   package com.itheima.request;
   
   import javax.servlet.ServletException;
   import javax.servlet.annotation.WebServlet;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import java.io.IOException;
   import java.util.Map;
   
   @WebServlet("/demo1")
   public class ServletDemo1 extends HttpServlet {
   
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           // 获取GET请求参数逻辑
           System.out.println("收到 GET 请求 ...");
           // 1. 获取所有参数的Map集合
           System.out.println("-----获取GET方式请求的所有参数-----");
           Map<String, String[]> map = req.getParameterMap();
           for (String key : map.keySet()) {
               // username: zhangsan
               System.out.print(key + " : ");
   
               // 获取值
               String[] values = map.get(key);
               for (String value : values) {
                   System.out.print(value + " ");
               }
   
               System.out.println();
           }
   
           // 2. 获取GET请求参数中的爱好，结果是数组
           System.out.println("-----获取GET请求参数中的爱好，结果是数组-----");
           String[] hobbies = req.getParameterValues("hobby");
           for (String hobby : hobbies) {
               System.out.println("爱好：" + hobby);
           }
   
           // 3. 获取GET请求参数中的用户名和密码，结果是单个值
           System.out.println("-----获取GET请求参数中的用户名和密码，结果是单个值-----");
           String username = req.getParameter("username");
           String password = req.getParameter("password");
           System.out.println("用户名：" + username);
           System.out.println("密码：" +password);
       }
   
       @Override
       protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           // 获取POST请求参数逻辑
           System.out.println("收到 POST 请求 ...");
           // 1. 获取所有参数的Map集合
           System.out.println("-----获取POST方式请求的所有参数-----");
           Map<String, String[]> map = req.getParameterMap();
           for (String key : map.keySet()) {
               // username: zhangsan
               System.out.print(key + " : ");
   
               // 获取值
               String[] values = map.get(key);
               for (String value : values) {
                   System.out.print(value + " ");
               }
   
               System.out.println();
           }
   
           // 2. 获取GET请求参数中的爱好，结果是数组
           System.out.println("-----获取POST请求参数中的爱好，结果是数组-----");
           String[] hobbies = req.getParameterValues("hobby");
           for (String hobby : hobbies) {
               System.out.println("爱好：" + hobby);
           }
   
           // 3. 获取GET请求参数中的用户名和密码，结果是单个值
           System.out.println("-----获取POST请求参数中的用户名和密码，结果是单个值-----");
           String username = req.getParameter("username");
           String password = req.getParameter("password");
           System.out.println("用户名：" + username);
           System.out.println("密码：" +password);
       }
   
   }
   

   运行结果：

小结

• req.getParameter()方法使用的频率会比较高
• 以后我们在写代码的时候，就只需要按照如下格式来编写：

public class RequestDemo extends HttpServlet {

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 采用request提供的获取请求参数的通用方式来获取请求参数
    // 编写其他的业务代码
  }

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    this.doGet(req, resp);
  }

}

IDEA快速创建Servlet

使用通用方式获取请求参数后，屏蔽了GET和POST的请求方式代码的不同，则代码可以定义如下格式：

@WebServlet("/demo")
public class RequestDemo extends HttpServlet {

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) {

  }

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
    this.doGet(req, resp);
  }

}

由于格式固定，所以我们可以使用IDEA提供的模板来制作一个Servlet模板，这样我们后期在创建Servlet的时候就会更高效，具体实现步骤：

1. 按照自己的需求，修改Servlet创建的模板内容；
2. 使用Servlet模板创建Servlet类

1. 按照自己的需求，修改Servlet创建的模板内容

2. 使用Servlet模板创建Servlet类

Request请求转发

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

1. 浏览器发送请求给服务器，服务器中对应的资源A接收到请求
2. 资源A处理完请求后将请求发给资源B
3. 资源B处理完后将结果响应给浏览器
4. 请求从资源A到资源B的过程就叫请求转发

请求转发的实现方式：

request.getRequestDispatcher("资源B的路径").forward(request, response);

如上图，针对这个需求，具体的实现步骤为：

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

1. 创建ServletDemo5类

package com.itheima.request;

import javax.servlet.ServletException;
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 extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {

    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo5");
    }
}

2. 创建ServletDemo6类

package com.itheima.request;

import javax.servlet.ServletException;
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("/demo6")
public class ServletDemo6 extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {

    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo6");
    }
}

3. 在ServletDemo5的doGet方法中进行请求转发

package com.itheima.request;

import javax.servlet.ServletException;
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 extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {

    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo5");
        request.getRequestDispatcher("/demo6").forward(request, response);
    }
}

4. 启动测试，为验证效果，我们在ServletDemo5和ServletDemo6中添加了响应输出代码，该代码是为了更直观的验证请求转发的效果，最终代码为。

package com.itheima.request;

import javax.servlet.ServletException;
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 extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {

    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo5");
        request.getRequestDispatcher("/demo6").forward(request, response);
        response.setHeader("content-type", "text/html;charset=utf-8");
        response.getWriter().write("由ServletDemo5进行响应！");
    }
}

package com.itheima.request;

import javax.servlet.ServletException;
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("/demo6")
public class ServletDemo6 extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {

    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo6");
        response.setHeader("content-type", "text/html;charset=utf-8");
        response.getWriter().write("由ServletDemo6进行响应！");
    }
}

访问http://localhost/Day09/demo5，就可以在控制台和浏览器中看到如下内容，说明请i去已经转发到了/demo6：

执行结果：

请求转发Servlet之间共享数据：使用request对象，此处主要解决的问题是把请求从 /demo5转发到/demo6的时候，如何将数据传递给/demo6。

这个时候就需要使用request对象提供的三个方法：

• 存储数据到request域 范围，数据是存储在request对象 中的

  void setAttribute(String name, Object o);
  

• 根据key获取值

  Object getAttribute(String name);
  

• 根据key删除该键值对

  void removeAttribute(String name);
  

  接着上面对需求：

1. 在ServletDemo5的doGet方法中转发请求之前，将数据存储request对象的域中
2. 在ServletDemo6的doGet方法中从request域名对象中获取数据，并将数据打印到控制台
3. 启动访问测试

1. 修改ServletDemo5中的方法

package com.itheima.request;

import javax.servlet.ServletException;
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 extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {

    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo5");
        request.setAttribute("msg", "Hello World!");
        request.getRequestDispatcher("/demo6").forward(request, response);
        response.setHeader("content-type", "text/html;charset=utf-8");
        response.getWriter().write("由ServletDemo5进行响应！");
    }
}

2. 修改ServletDemo6中的方法

package com.itheima.request;

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

@WebServlet("/demo6")
public class ServletDemo6 extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {

    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo6");
        Object data = request.getAttribute("msg");
        String msg = (String) data;
        System.out.println(msg);
        response.setHeader("content-type", "text/html;charset=utf-8");
        response.getWriter().write("由ServletDemo6进行响应！ServletDemo5 转发给 ServletDemo6 的消息为：" + msg);
    }
}

3. 启动测试

访问http://localhost/Day09/demo5，就可以在控制台和浏览器看到如下内容：

请求转发的特点

• 浏览器地址栏路径不发生变化，虽然后台从/demo5转发到/demo6，但是浏览器的地址一直是/demo5，未发生变化，一直是http://localhost/Day09/demo5
• 只能转发到当前服务器的内部资源，不能从一个服务器通过转发访问另外一台服务器
• 浏览器只发送了一次请求，可以在转发资源间使用request对象共享数据，虽然后台从/demo5转发到/demo6，但是浏览器只发送了一次请求。

Response对象

前面讲解完Request对象，接下来我们回到刚开始的那张图：

• Request: 使用request对象来获取请求数据
• Response: 使用response对象来设置响应数据

Response的继承体系和Request的继承体系类似：

介绍完Response的相关体系结构后，接下来对于Response我们需要学习如下内容：

• Response设置响应数据的功能介绍
• Response完成重定向
• Response响应字符数据
• Response响应字节数据

Response设置响应数据功能介绍

HTTP响应数据总共分为三部分内容，分别是响应行、响应头、响应体，对于这三部分内容的数据，我们来看下response都提供了哪些方法来进行设置？

1. 响应行

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

void setStatus(int sc);

2. 响应头

设置响应头键值对:

void setHeader(String name, String value);

3. 响应体

<html>
  <head>

  </head>
  <body>

  </body>
</html>

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

获取字符输出流：

PrintWriter getWriter();

获取字节输出流：

ServletOutputStream getOutputStream();

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

Response请求重定向

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

1. 浏览器发送请求给服务器，服务器中对应的*资源A(Servlet)*接收到请求
2. 资源A现在无法处理该请求，就会给浏览器响应一个302的状态码+location的一个访问资源B的路径
3. 浏览器接收到响应状态码为302就会重新发送请求到location对应的访问地址去访问资源B(Servlet)
4. 资源B接收到请i去后进行处理并最终给浏览器响应结果，这整个过程就叫重定向

重定向的实现方式：

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

具体如何来使用，我们先来看一个案例需求：

针对上述需求及过程分析，具体的实现步骤为：

1. 创建一个ServletDemo7类，接收/demo7的请求，在doGet方法中打印demo7...
2. 创建一个ServletDemo8类，接收/demo8的请求，在doGet方法中打印demo8...
3. 在ServletDemo7的方法中使用重定向的实现代码
4. 启动测试

1. 创建ServletDemo7类

package com.itheima.request;

import javax.servlet.ServletException;
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("/demo7")
public class ServletDemo7 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo7...");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {
        this.doGet(request, response);
    }

}

2. 创建ServletDemo8类

package com.itheima.request;

import javax.servlet.ServletException;
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("/demo8")
public class ServletDemo8 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo8...");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {
        this.doGet(request, response);
    }

}

3. 在ServletDemo7的doGet方法中给前端响应数据

package com.itheima.request;

import javax.servlet.ServletException;
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("/demo7")
public class ServletDemo7 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo7...");
        // 重定向
        // 1. 设置响应状态码 302
        response.setStatus(302);
        // 2. 设置响应头 Location
        response.setHeader("Location", "/Day09/demo8");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {
        this.doGet(request, response);
    }

}

4. 启动测试

访问http://localhost/Day09/demo7，就可以在控制台看到如下内容：

说明/demo7和/demo8都被访问到了，到这里重定向就已经完成了。

虽然功能已经实现，但是从设置重定向的两行代码来看，会发现除了重定向的地址不一样，其他的内容都是一样的，所以response对象给我们提供了更简化的编写方式：

response.sendRedirect("/Day09/demo8");

所以第3步的代码可以简化为：

package com.itheima.request;

import javax.servlet.ServletException;
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("/demo7")
public class ServletDemo7 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo7...");
        // 重定向
        // 1. 设置响应状态码 302
        // response.setStatus(302);
        // 2. 设置响应头 Location
        // response.setHeader("Location", "/Day09/demo8");
        // 重定向简化代码
        response.sendRedirect("/Day09/demo8");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {
        this.doGet(request, response);
    }

}

重定向的特点

• 浏览器地址栏路径发生变化，当进行重定向访问时，由于时由浏览器发送的两次请求，所以地址会发生变化

• 可以重定向到任何位置的资源(服务器内部、外部均可)，因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径可以是互联网上任意位置资源

• 两次请求，不能再多个资源使用request对象来共享数据，因为浏览器发送了两次请求，是两个不同的request对象，所以无法通过request对象来共享数据

重定向、请求转发的特点

请求转发的特点	重定向的特点
浏览器地址栏路径不发生变化	浏览器地址栏发生变化
只能转发到当前服务器的内部资源	可以重定向到互联网任意位置的资源(服务器内部、外部均可)
一次请求，可以在转发的资源间使用request共享数据	两次请求，不能再多个资源间使用request共享数据

路径问题

问题：转发的时候路径上没有添加/Day09而重定向加了，那么到底什么时候需要加，什么时候不加呢？

请求转发：request.getRequestDispatcher("/demo6").forward(request, response);

重定向：response.sendRedirect("/Day09/demo8");

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

• 浏览器使用：需要加虚拟访问目录，也即是项目访问路径
• 服务器端使用：不需要加虚拟目录

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

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

掌握了这个规则，接下来就通过一些练习来强化下知识的理解：

• <a href='路径'></a>
• <form action='路径'></form>
• request.getRequestDispatcher("路径")
• response.sendRedirect("路径")

答案：

1. 超链接，从浏览器发送，需要加
2. 表单，从浏览器发送，需要加
3. 转发，是从服务器内部跳转，不需要加
4. 重定向，是由浏览器进行跳转，需要加

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

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

package com.itheima.request;

import javax.servlet.ServletException;
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("/demo7")
public class ServletDemo7 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("demo7...");
        // 重定向
        // 1. 设置响应状态码 302
        // response.setStatus(302);
        // 2. 设置响应头 Location
        // response.setHeader("Location", "/Day09/demo8");
        // 重定向简化代码
        // response.sendRedirect("/Day09/demo8");
        // 简化方式完成重定向，动态获取虚拟目录
        String contextPath = request.getContextPath();
        response.sendRedirect(contextPath + "/demo8");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {
        this.doGet(request, response);
    }

}

重新启动访问测试，重定向功能依然能够实现，此时就可以动态获取项目访问的虚拟路径，从而降低代码的耦合度。

Response响应字符数据

如果希望将字符数据写到浏览器，我们就需要两个步骤：

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

接下来，我们实现通过案例把响应字符数据给实际应用下：

需求：返回一个简单的字符串Hello World!

package com.itheima.day09;

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

@WebServlet("/resp3")
public class ResponseDemo3 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        // 1. 获取字符输出流
        PrintWriter writer = response.getWriter();
        // 2. 通过字符输出流写数据
        writer.write("Hello World!");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {
        this.doGet(request, response);
    }

}

需求：返回一串HTML字符串，并且能够被浏览器解析

PrintWriter writer = response.getWriter();
// content-type: 告诉浏览器返回的数据类型是HTML类型数据，这样浏览器才会解析HTML标签
response.setContentType("text/html;charset=utf-8");
writer.write("<h1>Hello World!</h1>");

注意

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

Response响应字节数据

如果想将字节数据响应给浏览器，我们需要两个步骤：

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

接下来，我们通过一个案例将响应字节数据给实际应用下：

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

package com.itheima.day09;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileInputStream;
import java.io.IOException;

@WebServlet("/resp4")
public class ResponseDemo4 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 1. 读取文件
        FileInputStream fis = new FileInputStream("C:\\Users\\sunyy\\Pictures\\itcast.png");
        // 2. 获取response字节输出流
        ServletOutputStream sos = response.getOutputStream();
        // 3. 完成流的copy
        byte[] buff = new byte[1024];
        int len = 0;
        while ((len = fis.read(buff)) != -1) {
            sos.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中添加依赖坐标
2. 调用工具类方法

1. 在pom.xml文件中添加依赖

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

2. 调用工具类方法

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

package com.itheima.day09;

import org.apache.commons.io.IOUtils;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileInputStream;
import java.io.IOException;

@WebServlet("/resp4")
public class ResponseDemo4 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 1. 读取文件
        FileInputStream fis = new FileInputStream("C:\\Users\\sunyy\\Pictures\\itcast.png");
        // 2. 获取response字节输出流
        ServletOutputStream sos = response.getOutputStream();
        // 3. 完成流的copy
        byte[] buff = new byte[1024];
        int len = 0;
        // while ((len = fis.read(buff)) != -1) {
            // sos.write(buff, 0, len);
        // }
        IOUtils.copy(fis, sos);
        fis.close();
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {
        this.doGet(request, response);
    }

}

用户注册登录案例

接下来我们通过两个比较常见的案例，注册、登录来对今天学习的内容进行实战演练：

用户登录

用户登录-需求分析

1. 用户在登录页面输入用户名和密码，提交请求给LoginServlet
2. 在LoginServlet中接收请求和数据用户名和密码
3. 在LoginServlet中通过MyBatis调用UserMapper来根据用户名和密码查询数据库用户表
4. 将查询到的结果封装到User对象中进行返回
5. 在LoginServlet中判断返回的User对象是否为null
6. 如果为null，说明根据用户名和密码没有查询到用户，则登录失败，返回登录失败数据给前端页面
7. 如果不为null，则说明用户存在并且密码正确，则登录成功，返回登录成功数据给前端

用户登录-环境准备

1. 复制课程资料中的静态页面到项目的webapp目录下，拷贝完项目目录结构如下：

2. 在db1数据库下，创建tb_user表

-- 创建用户表
CREATE TABLE tb_user(   
  id int primary key auto_increment,
  username varchar(20) unique,
  password varchar(32)
);

-- 添加数据
INSERT INTO tb_user(username,password) values('zhangsan','123'),('lisi','234');

SELECT * FROM tb_user;

在模块中创建pojo包，并在包下创建User实体类，代码如下：

package com.itheima.day09.pojo;

public class User {

    private Integer id;
    private String username;
    private String password;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

3. 在项目的pom.xml中引入MyBatis和MySQL驱动的依赖坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>Course</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

4. 创建mybatis-config.xml核心配置文件，UserMapper.xml映射文件，UserMapper.java接口

mybatis-config.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--
    environments：develop配置数据库连接环境信息。
    -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--数据库连接信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///db1?useSSL=false&amp;useServerPrepStmts=true"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--加载sql映射文件-->
        <!--Mapper代理方式-->
        <package name="com.itheima.day09.mapper"/>
    </mappers>
</configuration>

在com.itheima.day09下创建mapper包，并在该包下创建UserMapper接口

package com.itheima.day09.mapper;

public interface UserMapper {

}

在模块目录的resources目录下创建com/itheima/day09/mapper目录结构，注意路径之间不能用.进行分割，要使用/：

将课程资料里面的UserMapper.xml拷贝到resources/com/itheima/day09/mapper目录下

至此我们所需要的环境就都已经准备好了，下面我们就来逐步实现注册、登录。

用户登录-代码实现

1. 在UserMapper接口中提供一个根据用户名和密码查询用户对象的方法

package com.itheima.day09.mapper;

import com.itheima.day09.pojo.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface UserMapper {

    /**
     * 根据用户名和密码查询用户对象
     * @param username
     * @param password
     * @return
     */
    @Select("select * from tb_user where username = #{username} and password = #{password}")
    User select(@Param("username") String username, @Param("password") String password);

}

说明

@Param注解的作用：用于传递参数，方法的参数可以与SQL中的字段名相对应

2. 修改login.html

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>login</title>
    <link href="css/login.css" rel="stylesheet">
</head>

<body>
<div id="loginDiv">
    <form action="login" id="form">
        <h1 id="loginMsg">LOGIN IN</h1>
        <p>Username:<input id="username" name="username" type="text"></p>

        <p>Password:<input id="password" name="password" type="password"></p>

        <div id="subDiv">
            <input type="submit" class="button" value="login up">
            <input type="reset" class="button" value="reset">&nbsp;&nbsp;&nbsp;
            <a href="register.html">没有账号？点击注册</a>
        </div>
    </form>
</div>

</body>
</html>

4. 启动服务器测试

   1. 如果用户名和密码输入错误，则

   

   2. 如果用户名和密码输入正确，则

   

至此用户的登录功能就完成了

用户注册

用户注册-需求分析

1. 用户在注册页面输入用户名和密码，提交请求给RegisterServlet
2. 在RegisterServlet中接收请求和数据用户名和密码
3. 在RegisterServlet中通过MyBatis调用UserMapper来根据用户名查询数据库表
4. 将查询的结果封装到User对象中进行返回
5. 在RegisterServlet中判断返回的User对象是否为null
6. 如果为null，说明根据用户名可以使用，则调用UserMapper来实现添加用户
7. 如果不为null，则说明用户已经存在不可以使用，返回用户名已存在给前端

用户注册-代码实现

1. 在UserMapper中提供根据用户名查询用户数据方法和添加用户方法

package com.itheima.day09.mapper;

import com.itheima.day09.pojo.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface UserMapper {

    /**
     * 根据用户名和密码查询用户对象
     * @param username
     * @param password
     * @return
     */
    @Select("select * from tb_user where username = #{username} and password = #{password}")
    User select(@Param("username") String username, @Param("password") String password);

    /**
     * 根据用户名查询用户对象
     * @param username
     * @return
     */
    User selectByUsername(String username);

    /**
     * 添加用户
     * @param user
     */
    void add(User user);

}

2. 在UserMapper映射配置xml文件中添加Statement

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.day09.mapper.UserMapper">
    <insert id="add" parameterType="com.itheima.day09.pojo.User">
        insert into tb_user(username, password) values(#{username}, #{password})
    </insert>

    <select id="selectByUsername" resultType="com.itheima.day09.pojo.User" parameterType="string">
        select *
        from tb_user
        where username = #{username};
    </select>
</mapper>

3. 创建RegisterServlet类

package com.itheima.day09;

import com.itheima.day09.mapper.UserMapper;
import com.itheima.day09.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

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

@WebServlet("/register")
public class RegisterServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 1. 接收用户数据
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        // 封装用户对象
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);

        // 2. 调用 mapper 根据用户名查询用户对象
        String resource = "mybatis-config.xml";
        InputStream is = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        // 2.2 获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 2.3 获取 mapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        // 2.4 调用方法
        User u = userMapper.selectByUsername(username);

        // 3. 判断用户对象是否为null
        if (u == null) {
            // 用户名不存在，添加用户
            userMapper.add(user);

            // 提交事务
            sqlSession.commit();
            // 释放资源
            sqlSession.close();
        } else {
            // 用户名已存在，给出提示信息
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write("用户名已存在");
        }
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {
        this.doGet(request, response);
    }

}

4. 完善用户注册页面register.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>欢迎注册</title>
    <link href="css/register.css" rel="stylesheet">
</head>
<body>

<div class="form-div">
    <div class="reg-content">
        <h1>欢迎注册</h1>
        <span>已有帐号？</span> <a href="login.html">登录</a>
    </div>
    <form id="reg-form" action="register" method="get">

        <table>

            <tr>
                <td>用户名</td>
                <td class="inputs">
                    <input name="username" type="text" id="username">
                    <br>
                    <span id="username_err" class="err_msg" style="display: none">用户名不太受欢迎</span>
                </td>

            </tr>

            <tr>
                <td>密码</td>
                <td class="inputs">
                    <input name="password" type="password" id="password">
                    <br>
                    <span id="password_err" class="err_msg" style="display: none">密码格式有误</span>
                </td>
            </tr>


        </table>

        <div class="buttons">
            <input value="注 册" type="submit" id="reg_btn">
        </div>
        <br class="clear">
    </form>

</div>
</body>
</html>

5. 启动服务器进行测试
   1. 如果注册成功，则在数据库中就能查看到新注册的用户数据
   2. 如果用户已经存在，则在页面上展示用户名已存在的提示信息

SqlSessionFactory工具类抽取

上面两个功能已经实现了注册、登录，但是在写Servlet的时候，因为需要使用MyBatis来完成数据库的操作，所以对于MyBatis的基础操作就出现了重复代码，如下：

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

这些重复代码会产生一些问题：

• 重复代码不利于后期维护
• SqlSessionFactory工厂类进行了重复创建：就相当于每次买手机都要重新建一个手机生产工厂来生产手机一样，资源消耗非常大而且性能极低，所以这么做是不被允许的。

那么，该如何来优化呢？

• 代码重复可以抽取为一个工具类
• 对指定代码只需要执行一次可以使用静态代码块

package com.itheima.util;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

/**
 * MyBatis工具类
 */
public class MyBatisUtil {

    private static SqlSessionFactory factory;

    /**
     * 静态代码块会随着类的加载而自动执行，且只执行一次
     */
    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream is = Resources.getResourceAsStream(resource);
            factory = new SqlSessionFactoryBuilder().build(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSessionFactory getSqlSessionFactory() {
        return factory;
    }
}

工具类抽取以后，后面我们在需要获取MyBatis的SqlSessionFactory的时候，就可以直接使用

SqlSessionFactory sqlSessionFactory = MyBatisUtil.getSqlSessionFactory();

这样就可以很好的解决上面的代码重复和重复创建工厂导致性能低的问题了。