JavaWeb笔记

一、Mybatis

1.Mybatis在Maven下使用步骤（快速入门）

• 创建模块，导入坐标 ：在创建好的模块中的 pom.xml 配置文件中添加依赖的坐标
• 1.  
     <dependencies>
  2.  
     <!--mybatis 依赖-->
  3.  
     <dependency>
  4.  
     <groupId>org.mybatis</groupId>
  5.  
     <artifactId>mybatis</artifactId>
  6.  
     <version>3.5.5</version>
  7.  
     </dependency>
  8.  
      
  9.  
     <!--mysql 驱动-->
  10.  
      <dependency>
  11.  
      <groupId>mysql</groupId>
  12.  
      <artifactId>mysql-connector-java</artifactId>
  13.  
      <version>5.1.46</version>
  14.  
      </dependency>
  15.  
       
  16.  
      <!--junit 单元测试-->
  17.  
      <dependency>
  18.  
      <groupId>junit</groupId>
  19.  
      <artifactId>junit</artifactId>
  20.  
      <version>4.13</version>
  21.  
      <scope>test</scope>
  22.  
      </dependency>
  23.  
      <!-- 添加slf4j日志api -->
  24.  
      <dependency>
  25.  
      <groupId>org.slf4j</groupId>
  26.  
      <artifactId>slf4j-api</artifactId>
  27.  
      <version>1.7.20</version>
  28.  
      </dependency>
  29.  
      <!-- 添加logback-classic依赖 -->
  30.  
      <dependency>
  31.  
      <groupId>ch.qos.logback</groupId>
  32.  
      <artifactId>logback-classic</artifactId>
  33.  
      <version>1.2.3</version>
  34.  
      </dependency>
  35.  
       
  36.  
      <!-- 添加logback-core依赖 -->
  37.  
      <dependency>
  38.  
      <groupId>ch.qos.logback</groupId>
  39.  
      <artifactId>logback-core</artifactId>
  40.  
      <version>1.2.3</version>
  41.  
      </dependency>
  42.  
       
  43.  
      </dependencies>
  

  注意：需要在项目的 resources 目录下创建logback.xml的配置文件

  1.  
     <?xml version="1.0" encoding="UTF-8"?>
  2.  
     <configuration>
  3.  
     <!--
  4.  
     CONSOLE ：表示当前的日志信息是可以输出到控制台的。
  5.  
     -->
  6.  
     <appender name="Console" class="ch.qos.logback.core.ConsoleAppender">
  7.  
     <encoder>
  8.  
     <pattern>[%level] %cyan([%thread]) %boldGreen(%logger{15}) - %msg %n</pattern>
  9.  
     </encoder>
  10.  
      </appender>
  11.  
       
  12.  
      <logger name="com.stu" level="DEBUG" additivity="false">
  13.  
      <appender-ref ref="Console"/>
  14.  
      </logger>
  15.  
       
  16.  
       
  17.  
      <!--
  18.  
       
  19.  
      level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF
  20.  
      ， 默认debug
  21.  
      <root>可以包含零个或多个<appender-ref>元素，标识这个输出位置将会被本日志级别控制。
  22.  
      -->
  23.  
      <root level="DEBUG">
  24.  
      <appender-ref ref="Console"/>
  25.  
      </root>
  26.  
      </configuration>

  
• 编写 MyBatis 核心配置文件 -- > 替换连接信息 解决硬编码问题

  在模块下的 resources 目录下创建 mybatis 的配置文件 mybatis - config.xml ，内容如下：

  1.  
     <?xml version="1.0" encoding="UTF-8" ?>
  2.  
     <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
  3.  
     <configuration>
  4.  
      
  5.  
     <typeAliases>
  6.  
     <package name="com.stu.domain"/>
  7.  
     </typeAliases>
  8.  
      
  9.  
     <!-- environments：配置数据库连接环境信息。可以配置多个environment，通过default属性切换不同的 environment -->
  10.  
       
  11.  
      <environments default="development">
  12.  
      <environment id="development">
  13.  
      <transactionManager type="JDBC"/>
  14.  
      <dataSource type="POOLED">
  15.  
      <!--数据库连接信息-->
  16.  
      <property name="driver" value="com.mysql.jdbc.Driver"/>
  17.  
      <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
  18.  
      <property name="username" value="root"/>
  19.  
      <property name="password" value="1234"/>
  20.  
      </dataSource>
  21.  
       
  22.  
      </environment>
  23.  
      <environment id="test">
  24.  
      <transactionManager type="JDBC"/>
  25.  
      <dataSource type="POOLED">
  26.  
      <!--数据库连接信息-->
  27.  
      <property name="driver" value="com.mysql.jdbc.Driver"/>
  28.  
      <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
  29.  
      <property name="username" value="root"/>
  30.  
      <property name="password" value="1234"/>
  31.  
      </dataSource>
  32.  
       
  33.  
      </environment>
  34.  
      </environments>
  35.  
      <mappers>
  36.  
      <!--加载sql映射文件-->
  37.  
      <mapper resource="UserMapper.xml"/>
  38.  
      </mappers>
  39.  
       
  40.  
      </configuration>

  
• 编写 SQL 映射文件 --> 统一管理sql语句，解决硬编码问题 ：在模块的 resources 目录下创建映射配置文件 UserMapper.xml ，内容如下：
•  编码

2.Mybatis配置文件浅解

• 初始化类型别名：domain包下存放的是基础类对象--->JavaBean类，也可以是domian包名也可以是叫作pojo
• 初始化dataSource：<!--数据库连接信息-->
• 初始化映射配置：<!--加载sql映射文件--> 或 <!--要操作的数据层的包-->

3.Mapper代理开发

之前我们写的代码是基本使用方式，它也存在硬编码的问题，如下：

 这里调用 selectList() 方法传递的参数是映射配置文件中的 namespace.id值。这样写也不便于后期的维护。如果使用 Mapper 代理方式（如下图）则不存在硬编码问题。

 通过上面的描述可以看出 Mapper 代理方式的目的：

• 解决原生方式中的硬编码
• 简化后期执行SQL

 Mybatis 官网也是推荐使用 Mapper 代理的方式。下图是截止官网的图片

 4.使用Mapper代理要求

• 定义与SQL映射文件同名的Mapper接口，并且将Mapper接口和SQL映射文件放置在同一目录下。如下图：

•  设置SQL映射文件的namespace属性为Mapper接口全限定名

  

• 在 Mapper 接口中定义方法，方法名就是SQL映射文件中sql语句的id，并保持参数类型和返回值类型一致

             

类型别名

二、HTTP协议下请求数据格式

格式介绍

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

• 请求行: HTTP请求中的第一行数据，请求行包含三块内容，分别是 GET[请求方式] /[请求URL路径] HTTP/1.1[HTTP协议及版本]

  请求方式有七种,最常用的是GET和POST

• 请求头: 第二行开始，格式为key: value形式

       请求头中会包含若干个属性，常见的HTTP请求头有：

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

举例说明:服务端可以根据请求头中的内容来获取客户端的相关信息，有了这些信息服务端就可以处理不同的业务需求，比如:

• 不同浏览器解析HTML和CSS标签的结果会有不一致，所以就会导致相同的代码在不同的浏览器会出现不同的效果
• 服务端根据客户端请求头中的数据获取到客户端的浏览器类型，就可以根据不同的浏览器设置不同的代码来达到一致的效果
• 这就是我们常说的浏览器兼容问题

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

• 如上图红线框的内容就是请求体的内容，请求体和请求头之间是有一个空行隔开。此时浏览器发送的是POST请求，为什么不能使用GET呢?这时就需要回顾GET和POST两个请求之间的区别了:

• GET请求请求参数在请求行中，没有请求体，POST请求请求参数在请求体中
• GET请求请求参数大小有限制，POST没有

三、HTTP协议下响应数据格式

格式介绍

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

• 响应行：响应数据的第一行,响应行包含三块内容，分别是 ：

• HTTP/1.1[HTTP协议及版本]      200[响应状态码]       ok[状态码的描述]

• 响应头：第二行开始，格式为key：value形式

  响应头中会包含若干个属性，常见的HTTP响应头有:

  1.  
     Content-Type：表示该响应内容的类型，例如text/html，image/jpeg；
  2.  
     Content-Length：表示该响应内容的长度（字节数）；
  3.  
     Content-Encoding：表示该响应压缩算法，例如gzip；
  4.  
     Cache-Control：指示客户端应如何缓存，例如max-age=300表示可以最多缓存300秒

• 响应体： 最后一部分。存放响应数据

  上图中...这部分内容就是响应体，它和响应头之间有一个空行隔开。

 响应状态码

• 200 ok 客户端请求成功
• 404 Not Found 请求资源不存在
• 500 Internal Server Error 服务端发生不可预期的错误

四、Servlet

基本介绍

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

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

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

 web项目中使用servlet步骤

①在web-demo项目的pom.xml中导入servlet坐标

 ②创建:定义一个类，实现Servlet接口，并重写接口中所有方法，写入业务逻辑

  （这里演示输出一句话）

1.  
   public class ServletDemo1 implements Servlet {
2.  
    
3.  
   public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
4.  
   System.out.println("servlet hello world~");
5.  
   }
6.  
   public void init(ServletConfig servletConfig) throws ServletException {
7.  
    
8.  
   }
9.  
    
10.  
    public ServletConfig getServletConfig() {
11.  
    return null;
12.  
    }
13.  
     
14.  
    public String getServletInfo() {
15.  
    return null;
16.  
    }
17.  
     
18.  
    public void destroy() {
19.  
     
20.  
    }
21.  
    }

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

@WebServlet("/demo1")

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

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

⑤浏览器访问后，在控制台会打印servlet hello world~ 说明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后面的值进行匹配
• 找到ServletDemo1这个类后，Tomcat Web服务器就会为ServletDemo1这个类创建一个对象，然后调用对象中的service方法
  • ServletDemo1实现了Servlet接口，所以类中必然会重写service方法供Tomcat Web服务器进行调用
  • service方法中有ServletRequest和ServletResponse两个参数，ServletRequest封装的是请求数据，ServletResponse封装的是响应数据，后期我们可以通过这两个参数实现前后端的数据交互

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

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

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

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

Tomcat什么时候创建的Servlet对象?------->了解Servlet的生命周期

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

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

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

  1.  
     默认情况，Servlet会在第一次访问被容器创建，但是如果创建Servlet比较耗时的话，
  2.  
     那么第一个访问的人等待的时间就比较长，用户的体验就比较差，
  3.  
     那么我们能不能把Servlet的创建放到服务器启动的时候来创建，具体如何来配置?
  4.  
      
  5.  
     @WebServlet(urlPatterns = "/demo1",loadOnStartup = 1)
  6.  
     loadOnstartup的取值有两类情况
  7.  
     （1）负整数:第一次访问时创建Servlet对象
  8.  
     （2）0或正整数:服务器启动时创建Servlet对象，数字越小优先级越高
• ② 初始化：在Servlet实例化之后，容器将调用Servlet的init()方法初始化这个对象，完成一些如加载配置文件、创建连接等初始化的工作。该方法只调用一次
• ③ 请求处理：每次请求Servlet时，Servlet容器都会调用Servlet的service()方法对请求进行处理
• ④ 服务终止：当需要释放内存或者容器关闭时，容器就会调用Servlet实例的destroy()方法完成资源的释放。在destroy()方法调用之后，容器会释放这个Servlet实例，该实例随后会被Java的垃圾收集器所回收

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

  1.  
     /**
  2.  
     * Servlet生命周期方法
  3.  
     */
  4.  
     @WebServlet(urlPatterns = "/demo2",loadOnStartup = 1)
  5.  
     public class ServletDemo2 implements Servlet {
  6.  
      
  7.  
     /**
  8.  
     * 初始化方法
  9.  
     * 1.调用时机：默认情况下，Servlet被第一次访问时，调用
  10.  
      * * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用
  11.  
      * 2.调用次数: 1次
  12.  
      * @param config
  13.  
      * @throws ServletException
  14.  
      */
  15.  
      public void init(ServletConfig config) throws ServletException {
  16.  
      System.out.println("init...");
  17.  
      }
  18.  
       
  19.  
      /**
  20.  
      * 提供服务
  21.  
      * 1.调用时机:每一次Servlet被访问时，调用
  22.  
      * 2.调用次数: 多次
  23.  
      * @param req
  24.  
      * @param res
  25.  
      * @throws ServletException
  26.  
      * @throws IOException
  27.  
      */
  28.  
      public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
  29.  
      System.out.println("servlet hello world~");
  30.  
      }
  31.  
       
  32.  
      /**
  33.  
      * 销毁方法
  34.  
      * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用
  35.  
      * 2.调用次数: 1次
  36.  
      */
  37.  
      public void destroy() {
  38.  
      System.out.println("destroy...");
  39.  
      }
  40.  
      public ServletConfig getServletConfig() {
  41.  
      return null;
  42.  
      }
  43.  
       
  44.  
      public String getServletInfo() {
  45.  
      return null;
  46.  
      }
  

1.  
   注意:如何才能让Servlet中的destroy方法被执行？
2.  
   在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次

• Servlet中总共有5个方法

1.  
   在Servlet被创建时执行，只执行一次
2.  
   void init(ServletConfig config) 

1.  
   提供服务方法， 每次Servlet被访问，都会调用该方法
2.  
   void service(ServletRequest req, ServletResponse res)

1.  
   销毁方法，当Servlet被销毁时，调用该方法。在内存释放或服务器关闭时销毁Servlet
2.  
   void destroy()

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

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

1.  
   获取ServletConfig对象
2.  
   ServletConfig getServletConfig()

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

1.  
   @WebServlet(urlPatterns = "/demo3",loadOnStartup = 1)
2.  
   public class ServletDemo3 implements Servlet {
3.  
    
4.  
   private ServletConfig servletConfig;
5.  
   /**
6.  
   * 初始化方法
7.  
   * 1.调用时机：默认情况下，Servlet被第一次访问时，调用
8.  
   * * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用
9.  
   * 2.调用次数: 1次
10.  
    * @param config
11.  
    * @throws ServletException
12.  
    */
13.  
    public void init(ServletConfig config) throws ServletException {
14.  
    this.servletConfig = config;
15.  
    System.out.println("init...");
16.  
    }
17.  
    public ServletConfig getServletConfig() {
18.  
    return servletConfig;
19.  
    }
20.  
     
21.  
    /**
22.  
    * 提供服务
23.  
    * 1.调用时机:每一次Servlet被访问时，调用
24.  
    * 2.调用次数: 多次
25.  
    * @param req
26.  
    * @param res
27.  
    * @throws ServletException
28.  
    * @throws IOException
29.  
    */
30.  
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
31.  
    System.out.println("servlet hello world~");
32.  
    }
33.  
     
34.  
    /**
35.  
    * 销毁方法
36.  
    * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用
37.  
    * 2.调用次数: 1次
38.  
    */
39.  
    public void destroy() {
40.  
    System.out.println("destroy...");
41.  
    }
42.  
     
43.  
    public String getServletInfo() {
44.  
    return "";
45.  
    }
46.  
    }

Servlet的体系结构

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

HttpServlet简化Servlet开发

 具体的编写格式如下:

1.  
   @WebServlet("/demo4")
2.  
   public class ServletDemo4 extends HttpServlet {
3.  
   @Override
4.  
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
5.  
   //TODO GET 请求方式处理逻辑
6.  
   System.out.println("get...");
7.  
   }
8.  
   @Override
9.  
   protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
10.  
    //TODO Post 请求方式处理逻辑
11.  
    System.out.println("post...");
12.  
    }
13.  
    }

• 要想发送一个GET请求，请求该Servlet，只需要通过浏览器发送http://localhost:8080/web-demo/demo4, 就能看到doGet方法被执行了
• 要想发送一个POST请求，请求该Servlet，单单通过浏览器是无法实现的，这个时候就需要编写一个form表单来发送请求，在webapp下创建一个a.html页面，内容如下:
  1.  
     <!DOCTYPE html>
  2.  
     <html lang="en">
  3.  
     <head>
  4.  
     <meta charset="UTF-8">
  5.  
     <title>Title</title>
  6.  
     </head>
  7.  
     <body>
  8.  
     <form action="/web-demo/demo4" method="post">
  9.  
     <input name="username"/><input type="submit"/>
  10.  
      </form>
  11.  
      </body>
  12.  
      </html>

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

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

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

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

有，获取请求方式，判断请求方式，根据不同的请求方式进行不同的业务处理。通过HttpServlet，翻开源码，service()方法里面不仅可以处理GET和POST还可以处理其他五种请求方式。

1.  
   protected void service(HttpServletRequest req, HttpServletResponse resp)
2.  
   throws ServletException, IOException
3.  
   {
4.  
   String method = req.getMethod();
5.  
    
6.  
   if (method.equals(METHOD_GET)) {
7.  
   long lastModified = getLastModified(req);
8.  
   if (lastModified == -1) {
9.  
   // servlet doesn't support if-modified-since, no reason
10.  
    // to go through further expensive logic
11.  
    doGet(req, resp);
12.  
    } else {
13.  
    long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
14.  
    if (ifModifiedSince < lastModified) {
15.  
    // If the servlet mod time is later, call doGet()
16.  
    // Round down to the nearest second for a proper compare
17.  
    // A ifModifiedSince of -1 will always be less
18.  
    maybeSetLastModified(resp, lastModified);
19.  
    doGet(req, resp);
20.  
    } else {
21.  
    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
22.  
    }
23.  
    }
24.  
     
25.  
    } else if (method.equals(METHOD_HEAD)) {
26.  
    long lastModified = getLastModified(req);
27.  
    maybeSetLastModified(resp, lastModified);
28.  
    doHead(req, resp);
29.  
     
30.  
    } else if (method.equals(METHOD_POST)) {
31.  
    doPost(req, resp);
32.  
     
33.  
    } else if (method.equals(METHOD_PUT)) {
34.  
    doPut(req, resp);
35.  
     
36.  
    } else if (method.equals(METHOD_DELETE)) {
37.  
    doDelete(req, resp);
38.  
     
39.  
    } else if (method.equals(METHOD_OPTIONS)) {
40.  
    doOptions(req,resp);
41.  
     
42.  
    } else if (method.equals(METHOD_TRACE)) {
43.  
    doTrace(req,resp);
44.  
     
45.  
    } else {
46.  
    //
47.  
    // Note that this means NO servlet supports whatever
48.  
    // method was requested, anywhere on this server.
49.  
    //
50.  
    String errMsg = lStrings.getString("http.method_not_implemented");
51.  
    Object[] errArgs = new Object[1];
52.  
    errArgs[0] = method;
53.  
    errMsg = MessageFormat.format(errMsg, errArgs);
54.  
     
55.  
    resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
56.  
    }
57.  
    }

• HttpServlet的使用步骤

继承HttpServlet

重写doGet和doPost方法

• HttpServlet原理

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

• urlPattern配置 

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

① 一个Servlet,可以配置多个urlPattern

②源码

1.  
   @WebServlet(urlPatterns = {"/demo1","/demo2"})
2.  
   public class ServletDemo7 extends HttpServlet {
3.  
    
4.  
   @Override
5.  
   protected void doGet(ServletRequest req, ServletResponse res) {
6.  
    
7.  
   System.out.println("demo1 get...");
8.  
   }
9.  
   @Override
10.  
    protected void doPost(ServletRequest req, ServletResponse res) {
11.  
    }
12.  
    }

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

urlPattern配置规则

• 精确匹配

1.  
   @WebServlet(urlPatterns = "/user/select")
2.  
   public class ServletDemo8 extends MyHttpServlet {
3.  
    
4.  
   @Override
5.  
   protected void doGet(ServletRequest req, ServletResponse res) {
6.  
    
7.  
   System.out.println("demo8 get...");
8.  
   }
9.  
   @Override
10.  
    protected void doPost(ServletRequest req, ServletResponse res) {
11.  
    }
12.  
    }

• 目录匹配

        

1.  
   @WebServlet(urlPatterns = "/user/*")
2.  
   public class ServletDemo9 extends MyHttpServlet {
3.  
    
4.  
   @Override
5.  
   protected void doGet(ServletRequest req, ServletResponse res) {
6.  
    
7.  
   System.out.println("demo9 get...");
8.  
   }
9.  
   @Override
10.  
    protected void doPost(ServletRequest req, ServletResponse res) {
11.  
    }
12.  
    }

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

==思考:==

1. 访问路径http://localhost:8080/web-demo/user是否能访问到demo9的doGet方法?能
2. 访问路径http://localhost:8080/web-demo/user/a/b是否能访问到demo9的doGet方法?能
3. 访问路径http://localhost:8080/web-demo/user/select是否能访问到demo9还是demo8的doGet方法?demo8
4. /user/*中的/*代表的是零或多个层级访问目录同时精确匹配优先级要高于目录匹配。

• 扩展名匹配

            

1.  
   @WebServlet(urlPatterns = "*.do")
2.  
   public class ServletDemo10 extends MyHttpServlet {
3.  
    
4.  
   @Override
5.  
   protected void doGet(ServletRequest req, ServletResponse res) {
6.  
    
7.  
   System.out.println("demo10 get...");
8.  
   }
9.  
   @Override
10.  
    protected void doPost(ServletRequest req, ServletResponse res) {
11.  
    }
12.  
    }

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

==注意==:

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

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

•  任意匹配

            

1.  
   /**
2.  
   * UrlPattern:
3.  
   * * 任意匹配： /
4.  
   */
5.  
   @WebServlet(urlPatterns = "/")
6.  
   public class ServletDemo11 extends MyHttpServlet {
7.  
    
8.  
   @Override
9.  
   protected void doGet(ServletRequest req, ServletResponse res) {
10.  
     
11.  
    System.out.println("demo11 get...");
12.  
    }
13.  
    @Override
14.  
    protected void doPost(ServletRequest req, ServletResponse res) {
15.  
    }
16.  
    }

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

1.  
   @WebServlet(urlPatterns = "/*")
2.  
   public class ServletDemo12 extends MyHttpServlet {
3.  
    
4.  
   @Override
5.  
   protected void doGet(ServletRequest req, ServletResponse res) {
6.  
    
7.  
   System.out.println("demo12 get...");
8.  
   }
9.  
   @Override
10.  
    protected void doPost(ServletRequest req, ServletResponse res) {
11.  
    }
12.  
    }

访问路径`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类

1.  
    
2.  
   public class ServletDemo13 extends MyHttpServlet {
3.  
    
4.  
   @Override
5.  
   protected void doGet(ServletRequest req, ServletResponse res) {
6.  
    
7.  
   System.out.println("demo13 get...");
8.  
   }
9.  
   @Override
10.  
    protected void doPost(ServletRequest req, ServletResponse res) {
11.  
    }
12.  
    }

• 在web.xml中配置该Servlet

1.  
   <?xml version="1.0" encoding="UTF-8"?>
2.  
   <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
3.  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.  
   xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
5.  
   version="4.0">
6.  
    
7.  
    
8.  
    
9.  
   <!--
10.  
    Servlet 全类名
11.  
    -->
12.  
    <servlet>
13.  
    <!-- servlet的名称，名字任意-->
14.  
    <servlet-name>demo13</servlet-name>
15.  
    <!--servlet的类全名-->
16.  
    <servlet-class>com.stu.web.ServletDemo13</servlet-class>
17.  
    </servlet>
18.  
     
19.  
    <!--
20.  
    Servlet 访问路径
21.  
    -->
22.  
    <servlet-mapping>
23.  
    <!-- servlet的名称，要和上面的名称一致-->
24.  
    <servlet-name>demo13</servlet-name>
25.  
    <!-- servlet的访问路径-->
26.  
    <url-pattern>/demo13</url-pattern>
27.  
    </servlet-mapping>
28.  
    </web-app>

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

五、Request&Response

Request和Response的概述

 request和response这两个参数的作用是什么?

request:获取请求数据

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

Request获取请求数据 

  重新启动服务器后，http://localhost:8080/request-demo/req1?                          username=zhangsan&passwrod=123，获取的结果如下:

 获取请求体数据

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

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

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

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

BufferedReader getReader()

具体实现的步骤如下 :

1. 准备一个页面，在页面中添加 form 表单 , 用来发送 post 请求

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

3. 在 doPost 方法中使用 request 的 getReader() 或者 getInputStream() 来获取

4. 访问测试

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

1.  
   <!DOCTYPE html> <html lang="en"> <head>
2.  
   <meta charset="UTF-8">
3.  
   <title>Title</title>
4.  
   </head>
5.  
   <body>
6.  
   <!--
7.  
   action:form表单提交的请求地址
8.  
   method:请求方式，指定为post
9.  
   -->
10.  
    <form action="/request-demo/req1" method="post">
11.  
    <input type="text" name="username">
12.  
    <input type="password" name="password">
13.  
    <input type="submit">
14.  
    </form>
15.  
    </body>
16.  
    </html>

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

启动服务器，通过浏览器访问http://localhost:8080/request-demo/req.html  点击提交按钮后，就可以在控制台看到前端所发送的请求数据

小结

1. 中文乱码解决方案

POST请求和GET请求的参数中如果有中文，后台接收数据就会出现中文乱码问题GET请求在Tomcat8.0以后的版本就不会出现了

POST请求解决方案是:设置输入流的编码

1.  
   request.setCharacterEncoding("UTF-8");
2.  
   注意:设置的字符集要和页面保持一致

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

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

2. URL编码实现方式:

编码:

URLEncoder.encode(str,"UTF-8");

解码:

URLDecoder.decode(s,"ISO-8859-1");

 Request请求转发

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

(1)创建RequestDemo5类  

 说明请求已经转发到了/req6

接着按上面的需求：

1. 在 RequestDemo5 的 doGet 方法中转发请求之前，将数据存入 request 域对象中

2. 在 RequestDemo6 的 doGet 方法从 request 域对象中获取数据，并将数据打印到控制台

3. 启动访问测试

 (1)修改RequestDemo5中的方法

1.  
   @WebServlet("/req5")
2.  
    public class RequestDemo5 extends HttpServlet {
3.  
    @Override
4.  
    protected void doGet(HttpServletRequest request, HttpServletResponse
5.  
   response) throws ServletException, IOException {
6.  
    System.out.println("demo5...");
7.  
    //存储数据
8.  
    request.setAttribute("msg","hello");
9.  
    //请求转发
10.  
     request.getRequestDispatcher("/req6").forward(request,response);
11.  
     
12.  
     }
13.  
     
14.  
     @Override
15.  
     protected void doPost(HttpServletRequest request, HttpServletResponse
16.  
    response) throws ServletException, IOException {
17.  
     this.doGet(request, response);
18.  
     }
19.  
     }

Response对象 

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

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

 Response设置响应数据功能介绍 

1. 响应行

                      

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

void setStatus(int sc); 

设置响应头键值对：

void setHeader(String name,String value);

 3. 响应体

           

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

获取字符输出流:

 PrintWriter getWriter();

获取字节输出流：

ServletOutputStream getOutputStream(); 

 Respones请求重定向

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

                       

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

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

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

1. 创建一个 ResponseDemo1 类，接收 /resp1 的请求，在 doGet 方法中打印 resp1....

2. 创建一个 ResponseDemo2 类，接收 /resp2 的请求，在 doGet 方法中打印 resp2....

3. 在 ResponseDemo1 的方法中使用

    response.setStatus(302);

    response.setHeader("Location","/request-demo/resp2") 来给前端响应结果数据

4. 启动测试

 (1)创建ResponseDemo1类

• 浏览器地址栏路径发送变化

•  可以重定向到任何位置的资源(服务内容、外部均可)

因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。

•  两次请求，不能在多个资源使用request共享数据

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

 路径问题

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

• <a href='https://blog.csdn.net/Kcjljx/article/details/路径'>
• <form action='路径'>
• req.getRequestDispatcher("路径")
• resp.sendRedirect("路径") 

     

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

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

1.  
   response.setContentType("text/html;charset=utf-8");
2.  
   //获取字符输出流
3.  
   PrintWriter writer = response.getWriter();
4.  
   1. 返回一个简单的字符串aaa
5.  
   writer.write("aaa");
6.  
   2. 返回一串html字符串，并且能被浏览器解析
7.  
   PrintWriter writer = response.getWriter();
8.  
   //content-type，告诉浏览器返回的数据类型是HTML类型数据，这样浏览器才会解析HTML标签 response.setHeader("content-type","text/html");
9.  
   writer.write("<h1>aaa</h1>");
10.  
    3. 返回一个中文的字符串你好，需要注意设置响应数据的编码为utf-8
11.  
    //设置响应的数据格式及数据的编码
12.  
    response.setContentType("text/html;charset=utf-8");
13.  
    writer.write("你好");

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

Response响应字节数据

• 通过Response对象获取字节输出流：

            ServletOutputStream outputStream = resp.getOutputStream();

• 通过字节输出流写数据:

            outputStream.write(字节数据);

这篇好文章是转载于：学新通技术网