Servlet规范

Servlet规范

1.Servlet规范介绍

1. servlet规范来自于javaee规范中的一种
2. 作用：
   1. 在servlet规范中，指定了动态资源文件的开发步骤
   2. 在servlet规范中，指定Http服务器调用动态资源文件规则
   3. 在servlet规范中，指定Http服务器管理 动态资源文件实例对象规则

2.Servlet接口实现类

1. Servlet接口来自于Servlet规范下的一个接口，这个接口存在Http服务器提供的jar包中

2. Tomcat服务器下lib文件有一个servlet-api.jar存放Servlet接口（javax.servlet.Servlet接口）

3. Servlet规范中，HTTp服务器能调用的（动态资源文件）必须是一个Servlet接口实现类

   如：class Student{

   ​ // 不是动态资源文件，Tomcat无权调用

   }

   class Teacher implements Servlet{

   ​ // 合法动态资源文件，Tomcat有权利调用

   }

3.Servlet接口 实现类开发步骤

1. 第一步：创建一个Java类继承于HttpServlet父类，使其成为一个Servlet接口实现类

2. 第二步：重写HttpServlet父类两个方法：doGet()或者doPost()

   如果浏览器以get方式发送请求协议包则重写doGet()方法

   如果浏览器以post方式发送请求协议包则重写doPost()方法

3. 将Servlet接口实现类信息，注册到Tomcat服务器。（注册就是通知Tomcat）

   将信息写在web.xml文件下：

   <!--将Servlet接口实现类类路径地址交给Tomcat-->
   <servlet>
   <servlet-name>mm</servlet-name> <!--声明一个变量存储servlet接口实现类类路径-->
   <servlet-class>com.bjpowernode.controller.OneServlet</servlet-class><!--声明servlet接口实现类类路径-->
   </servlet>
   
   <!--为了降低用户访问Servlet接口实现类难度，需要设置简短请求别名-->
   <servlet-mapping> 
   <servlet-name>mm</servlet-name>
   <url-pattern>/one</url-pattern> <!--设置简短请求别名,别名在书写时必须以"/"为开头-->
   </servlet-mapping>
   
   <!--如果现在浏览器向Tomcat索要OneServlet的地址-->
   
   可以写为：http://localhost:8080/myWeb/one
   而不需要写成：http://localhost:8080/myWeb/XXX/XXX/XXX/XXX.class
   

4. 分析Servlet接口实现类的父类，父父类，祖先类：

   Servlet接口实现/继承关系如下：
   其中抽象类GenericServlet实现了，Servlet接口四个不常用的方法
   （得出一个结论：
   	抽象类作用：降低接口实现类对接口实现过程难度
       		  将接口中不需要使用抽象方法教给抽象类进行完成
      			  这样接口实现类只需要对接口需要方法进行重写
    ）
   		  extends                     extends                       implements
   oneServlet------>(abstract)HttpServlet----->(abstract)GenericServlet-----> servlet接口
                                                  		 init
                                                        destory
                                                        getServletInfo
                                                        getServletConfig
   

4.Servlet对象生命周期

1. 网站中所有的Servlet接口实现类的实例对象，只能由Http服务器负责创建

2. 在默认情况下，Http服务器接收到对当前Servlet接口实现类的第一次请求时，自动创建这个Servlet接口实现类的实例对象

3. 在手动配置情况下，要求Http服务器在启动时自动创建某个Servlet接口实现类的实例对象

   在web.xml中写：30

   <servlet>
   <servlet-name>mm</servlet-name> <!--声明一个变量存储servlet接口实现类类路径-->
   <servlet-class>com.bjpowernode.controller.OneServlet</servlet-class>
   <load-on-startup>30<load-on-startup><!--填写一个大于0的整数即可-->
   </servlet>
   

4. 在Http服务器运行期间，一个Servlet接口实现类只能被创建出一个实例对象

5. 在Http服务器关闭时刻，自动将网站中所有的Servle对象进行销毁

5.HttpServletResponse接口

1. 介绍：

   1. HttpServletResponse接口来自于Servlet规范中，在Tomcat中存在servlet-api.jar
   2. HttpServletResponse接口实现类由Http服务器负责提供
   3. HttpServletResponse接口负责将doGet/doPost方法执行结果写入到响应体中
   4. 开发人员习惯将HttpServletResponse接口修饰的对象称为响应对象

2. 主要功能：

   1. 将执行结果以二进制形式写入到响应体中:

      通过响应对象，向Tomcat索要输出流，

      通过输出流，将执行结果以二进制形式写入到响应体

      实际开发过程中，都是通过out.print()将真实数据写入到响应体

      public class OneServlet extends HttpServlet {
          protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      	String result ="Hello World"; //执行结果
               //--------响应对象将结果写入到响应体--------------start
                  //1.通过响应对象，向Tomcat索要输出流
                  PrintWriter out = response.getWriter();
                  //2.通过输出流，将执行结果以二进制形式写入到响应体
                  out.write(result);
             		//实际开发过程中，都是通过out.print()将真实数据写入到响应体
              	out.print(result);
              //--------响应对象将结果写入到响应体--------------start
          }//doGet执行完毕
           //Tomcat将响应包推送给浏览器
      }
      

   2. 设置响应头中的content-type属性值，从而控制浏览器使用对应编译器将响应体二进制数据编译为：文字、图片、视频、命令

      /*
      *  问题描述： Java<br/>Mysql<br/>HTML<br/>
      *           浏览器在接收到响应结果时，将<br/>作为
      *           文字内容在窗口展示出来，没有将<br/>
      *           当做HTML标签命令来执行
      *
      *  问题原因：
      *           浏览器在接收到响应包之后，根据【响应头中content-type】
      *           属性的值，来采用对应【编译器】对【响应体中二进制内容】进行
      *           编译处理
      *
      *           在默认的情况下，content-type属性的值“text” content-type="text"
      *           此时浏览器将会采用【文本编译器】对响应体二进制数据进行解析
      *			采用utf-8解码：charset=utf-8
      *
      *  解决方案：
      *           一定要在得到输出流之前，通过响应对象对响应头中content-type属性进行
      *           一次重新赋值用于指定浏览器采用正确编译器
      */
      public class ThreeServlet extends HttpServlet {
      	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              String result="Java<br/>Mysql<br/>HTML<br/>"; //既有文字信息又有HTML标签命令
              String result2="红烧排骨<br/>梅菜肘子<br/>糖醋里脊";
              //设置响应头content-type
              response.setContentType("text/html;charset=utf-8");
              //向Tomcat索要输出流
              PrintWriter out = response.getWriter();
              //通过输出流将结果写入到响应体
              out.print(result);
              out.print(result2);
          }
      }
      

   3. 设置响应头中location属性，将一个请求地址赋值给location从而控制浏览器向指定服务器发送请求

      public class FourServlet extends HttpServlet {
          protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
               String result ="http://www.baidu.com?userName=mike";
               //通过响应对象，将地址赋值给响应头中location属性
            	 response.sendRedirect(result);//[响应头location="http://www.baidu.com"]
          }
          /*
          *  浏览器在接收到响应包之后，如果
          *  发现响应头中存在location属性
          *  自动通过地址栏向location指定网站发送请求
          *
          *  sendRedirect方法远程控制浏览器请求行为【请求地址，请求方式，请求参数】
          */
      }
      

6.HttpServletRequest接口

1. 介绍：

   1. HttpServletRequest接口来自于Servlet规范中，在Tomcat中存在servlet-api.jar
   2. HttpServletRequest接口实现类由Http服务器负责提供
   3. HttpServletRequest接口负责在doGet/doPost方法运行时读取Http请求协议包信息
   4. 开发人员习惯将HttpServletRequest接口修饰的对象称为请求对象

2. 作用：

   1. 可以读取Http请求协议包请求行信息

      public class OneServlet extends HttpServlet {
          protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              //1.通过请求对象，读取【请求行】中【url】信息
               String url = request.getRequestURL().toString();
              //2.通过请求对象，读取【请求行】中【method】信息
               String method = request.getMethod();
              //3.通过请求对象，读取【请求行】中uri信息
              /*
              * URI：资源文件精准定位地址，在请求行并没有URI这个属性。
              *      实际上URL中截取一个字符串，这个字符串格式"/网站名/资源文件名"
              *      URI用于让Http服务器对被访问的资源文件进行定位
              */
              String uri =  request.getRequestURI();// substring
      
              System.out.println("URL "+url);
              System.out.println("method "+method);
              System.out.println("URI "+uri);
              
              //--------------------------------------------
              
              //1.通过请求对象获得【请求头】中【所有请求参数名】
              Enumeration paramNames =request.getParameterNames(); //将所有请求参数名称保存到一个枚举对象进行返回
              while(paramNames.hasMoreElements()){
                    String paramName = (String)paramNames.nextElement();
                    //2.通过请求对象读取指定的请求参数的值
                    String value = request.getParameter(paramName);
                    System.out.println("请求参数名 "+paramName+" 请求参数值 "+value);
          }
      }
      

   2. 可以读取保存在Http请求协议包中请求头或者请求体中的请求信息

      浏览器以GET方式发送请求,请求参数保存在【请求头】,在Http请求协议包到达Http服务器之后，第一件事就是进行解码

      浏览器以POST方式发送请求，请求参数保存在【请求体】,在Http请求协议包到达Http服务器之后，第一件事就是进行解码

      /*
         *  问题：
         *      以GET方式发送中文参数内容“老杨是正经人”时，得到正常结果
         *      以POST方式发送中文参数内容"老崔是个男人"，得到【乱码】“è?????????????·???”
         *
         *  原因:
         *
         *      浏览器以GET方式发送请求,请求参数保存在【请求头】,在Http请求协议包到达Http服务器之后，第一件事就是进行解码
         *      请求头二进制内容由Tomcat负责解码，Tomcat9.0默认使用【utf-8】字符集，可以解释一切国家文字
         *
         *      浏览器以POST方式发送请求，请求参数保存在【请求体】,在Http请求协议包到达Http服务器之后，第一件事就是进行解码
         *      请求体二进制内容由当前请求对象（request）负责解码。request默认使用[ISO-8859-1]字符集，一个东欧语系字符集
         *      此时如果请求体参数内容是中文，将无法解码只能得到乱码
         *
         *  解决方案:
         *
         *      在Post请求方式下，在读取请求体内容之前，应该通知请求对象使用utf-8字符集对请求体内容进行一次重新解码
         *
         *
         */
      public class ThreeServlet extends HttpServlet {
      	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              //通知请求对象，使用utf-8字符集对请求体二进制内容进行一次重写解码
              request.setCharacterEncoding("utf-8");
              //通过请求对象，读取【请求体】参数信息
              String value = request.getParameter("userName");
              System.out.println("从请求体得到参数值 "+value);
          }
      
          protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
               //通过请求对象，读取【请求头】参数信息
               String userName = request.getParameter("userName");
               System.out.println("从请求头得到参数值 "+userName);
          }
      }
      

   3. 可以代替浏览器向Http服务器申请资源文件调用

      以后学…

7.请求对象和响应对象生命周期

1. 在Http服务器接收到浏览器发送的Http请求协议包之后，自动为当前的Http请求协议包生成一个请求对象和响应对象
2. 在Http服务器调用doGet/doPost方法时，负责将请求对象和响应对象作为实参传递到方法，确保doGet/doPost正确执行
3. 在Http服务器准备推送Http响应协议包之前，负责将本次请求关联的请求对象和响应对象销毁
4. 请求对象和响应对象声明周期贯穿一次请求的处理过程中
5. 请求对象和响应对象相当于用户在服务端的代言人

8.Http状态码

1. 相关概念：

   1. Http状态码由三位数字组成
   2. Http服务器在推送响应包之前，根据本次请求处理情况，将Http状态码写入到响应包中的状态行上
   3. 如果Http服务器针对本次请求，返回了对应的资源文件，通过Http状态码通知浏览器应该如何处理这个结果
   4. 如果Http服务器针对本次请求，无法返回对应的资源文件，通过Http状态码向浏览器解释不能提供服务的原因

2. 分类：

   1. 1XX：

      最有特征：100，

      通知浏览器本次返回的资源文件并不是一个独立的资源文件，需要浏览器在接收响应包之后，继续向Http服务器索要依赖的其他资源文件

   2. 2XX：

      最有特征：200

      通知浏览器本次返回的资源文件是一个完整独立的资源文件，浏览器在接收之后不需要索要其他关联文件

   3. 3XX：

      最有特征：302

      通知浏览器本次返回的不是一个资源文件的内容，而是一个资源文件地址，需要浏览器根据这个地址自动发起请求来索要这个资源文件

      Servlet中：
      response.sendRedirect("资源文件地址")写入到响应头中的location，
      1、Tomcat在推送响应包之前，看到响应体是空的，但是响应头location存放了一个地址，
      2、此时Tomcat将302状态码写入到状态行，
      3、在浏览器接收到响应包之后，因为302状态码，浏览器不会读取响应体内容，自动根据响应头中location的地址发起第二次请求
      

   4. 4XX：

      最有特征：404，405

      404：通知浏览器，由于服务端没有定位到被访问的资源文件，因此无法提供帮助

      405：通知浏览器，在服务端已经定位到被访问的资源文件（Servlet），但这个Servlet对于浏览器采用的请求方式不能处理

      如：浏览器发送的是get请求，但是Servlet中只能处理Post请求

   5. 5XX：

      最有特征：500

      通知浏览器，在服务端已经定位到被访问的资源文件（Servlet），这个Servlet可以接收浏览器采用请求方式，但是Servlet在处理请求期间，由于Java异常导致处理失败（答应帮你干事，但却在半途中死了）

9.多个Servlet之间调用规则：

1. 为何要使用多个Servlet之间调用规则：

   • 某些来自于浏览器发送请求，往往需要服务端中多个Servlet协同处理，但是浏览器一次只能访问一个Servlet，导致用户需要手动通过浏览器发起多次请求才能得到服务，这样增加用户获得服务难度，导致用户放弃访问当前网站

2. 提高用户使用感受规则：

   无论本次请求涉及到多少个Servlet，用户只需手动通过浏览器发起一次请求即可

3. 多个Servlet之间调用规则：

   1. 重定向 解决方案
   2. 请求转发 解决方案

10.重定向 解决方案

1. 工作原理：

   • 用户第一次通过手动方式通知浏览器访问OneServlet，等OneServlet工作完毕后，将TowServlet地址写入到响应头location属性中，使得Tomcat将302状态码写入到状态行。

• 在浏览器接收到响应包之后，读取到302状态码。此时浏览器自动根据响应头中的location属性地址发起第二次请求，访问TwoServlet去完成请求中剩余的任务

工作流程图如下：

2. 实现命令：

   response.sendRedirect("请求地址")
   将地址写入到响应包中的响应头属性 location当中
   

3. 特征：

   1. 请求地址：
      • 既可以把当前网站内部的资源文件地址发送给浏览器（/网站名/资源文件名）
      • 也可以把其他网站资源文件地址发给浏览器（http://ip地址:端口号/网站名/资源文件名）
   2. 请求次数：
      • 浏览器至少发送两次请求，但是只有第一次请求时用户手动发送的，后续请求都是浏览器自动发送的
   3. 请求方式：
      • 重定向解决方案中，通过地址栏通知浏览器发起下一次请求，因此通过重定向解决方案调用的资源文件接收请求方式一定是GET
   4. 缺点：
      • 重定向解决方案需要在浏览器与服务器之间进行多次往返，大量时间消耗在往返次数上，增加用户等待服务时间

11.请求转发 解决方案

1. 原理：

   • 用户第一次通过手动方式要求浏览器访问OneServlet，OneServlet工作完毕后，通过当前的请求对象代替浏览器向Tomcat发送请求，申请调用TowServlet。Tomcat在接收到这个请求之后，自动调用TowServlet来完成剩余任务

   流程图如下：

   

2. 实现命令：

   // 1、通过当前 请求对象 生成资源文件申请报告对象
   RequestDispatcher report = request.getRequestDispatcher("/资源文件名");  // 一定要以/开头
   // 2、将报告对象发送给Tomcat
   report.forward(当前请求对象，当前响应对象)
   

3. 优点：

   1. 无论本次请求涉及到多少个Servlet，用户只需要手动通过浏览器发送一次请求
   2. Servlet之间调用发生在服务端计算机上，节省服务端与浏览器之间往返次数增加处理服务速度

4. 特征：

   1. 请求次数：
      • 在请求转发过程中，浏览器只发送一次请求
   2. 请求地址：
      • 只能向Tomcat服务器申请调用当前网站下资源文件地址
      • request.getRequestDispathcer("/资源文件名") ！！不要写网站名
   3. 请求方式：
      • 在请求转发过程中，浏览器只发送一个Http请求协议包，
      • 参与本次请求的所有Servlet共享同一个请求协议包，
      • 因此这些Servlet接收的请求方式（get/post）与浏览器发送的请求方式保持一致（浏览器在第一次发送什么样的请求方式，接下来的请求方式就是这个）

12.多个Servlet之间数据共享实现方案

1. 数据共享：OneServlet工作完毕后，将产生的数据交给TwoServlet来使用
2. Servlet规范中提供四种数据共享方案：
   1. ServletContext接口
   2. Cookie类
   3. HttpSeeion接口
   4. HttpServletRequest接口

13.ServletContext接口（全局作用域对象）

1. 介绍：

   1. ServletContext接口来自于Servlet规范中的一个接口，在Tomcat中的servlet-api.jar，由Tomcat负责提供这个接口的实现类
   2. 如果两个Servlet来自于同一个网站，彼此之间通过网站的ServletContext实例对象来实现数据共享
   3. 开发人员习惯于将ServletContext对象称为全局作用域对象

2. 工作原理：

   1. 每一个网站都存在一个全局作用域对象，它相当于一个Map，
   2. 在这个网站中的OneServlet可以将一个数据存入到全局作用域对象，
   3. 当前网站中其他Servlet都可以从全局作用域对象得到这个数据进行使用

   如图：

   

3. 全局作用域对象生命周期：

   1. 在Http服务器启动过程中，自动为当前网站在内存中创建一个全局作用域对象
   2. 在Http服务器运行期间时，一个网站只有一个全局作用域对象
   3. 在Http服务器运行期间，全局作用域对象一直处于存活状态
   4. 在Http服务器准备关闭时，负责将当前网站中全局作用域对象进行销毁处理

   全局作用域对象生命周期贯穿网站整个运行期间

4. 命令实现：

   //【同一个网站】OneServlet将数据共享给TwoServlet
   
   OneServlet{
   	public void doGet(HttpServletRequest request,HttpServletResponse response){
   //1.通过【请求对象】向Tomcat索要当前网站中【全局作用域对象】
   	ServletContext application = request.getServletContext();
   //2.将数据添加到全局作用域对象作为【共享数据】
   	application.setAttribute("key1",数据)
   	}				 
   }
   
   TwoServlet{
   	public void doGet(HttpServletRequest request,HttpServletResponse response){
   //1.通过【请求对象】向Tomcat索要当前网站中【全局作用域对象】
   	ServletContext application = request.getServletContext();
   //2.从全局作用域对象得到指定关键字对应数据
   	Object 数据 =  application.getAttribute("key1");
   	}
   }
   

14.Cookie（它是一个类，不是接口）

1. 介绍：

   1. Cookie来自于Servlet规范中一个工具类，存在Tomcat中servlet-apr.jar
   2. 如果两个Servlet来自于同一个网站，并且为同一个浏览器/用户提供服务，此时借助于Cookie对象进行数据共享
   3. Cookie存放的是当前用户的私人数据，在共享数据过程中，提高服务质量
   4. 在现实生活场景中，Cookie想到于用户在服务端得到【会员卡】

2. 工作原理：

   1. 用户通过浏览器第一次向myWeb网站发送请求申请OneServlet，
   2. OneServlet在运行期间，创建一个Cookie来存储当前用户的相关数据
   3. OneServlet工作完毕后，将Cookie写入响应头交还给当前浏览器
   4. 浏览器接收到响应包之后，将Cookie 存储在浏览器的缓存中
   5. 一段时间过后，用户通过同一个浏览器再次向【myWeb网站】发送请求申请TwoServlet时，浏览器需要无条件的将myWeb网站之前推送过来的Cookie写入到请求头中，然后发送过去
   6. 此时，TwoServlet在运行时，就可以通过读取请求头中C
      ookie中的信息，得到OneServlet的共享数据

   如图：

3. 实现命令：

   // 同一个网站OneServlet与TwoServlet借助于Cookie实现数据共享
   OneServlet{
   	public void doGet(HttpServletRequest request,HttpServletResponse resp){
   //1.创建一个cookie对象，保存共享数据（当前用户数据）
   	Cookie card = new Cookie("key1","abc");
   	Cookie card1= new Cookie("key2","efg");
   	****cookie相当于一个map
   	****一个cookie中只能存放一个键值对
   	****这个键值对的key与value只能是String
   	****键值对中key不能是中文
   	//2.【发卡】将cookie写入到响应头，交给浏览器
   	resp.addCookie(card);
   	resp.addCookie(card1)
   	}			
   }
   /*
   浏览器/用户      <---------响应包 【200】
   			                   【cookie: key1=abc;key2=eft】
   							   【】
   							   【处理结果】
   浏览器向myWeb网站发送请求访问TwoServlet---->请求包 																				【url:/myWeb/two method:get】	                                                     	 【请求参数：xxxx ;Cookie:key1=abc;key2=efg】
   									    【】
   									    【】
   */
   TwoServlet{
   	public void doGet(HttpServletRequest request,HttpServletResponse resp){
   //1.调用请求对象从请求头得到浏览器返回的Cookie
       Cookie  cookieArray[] = request.getCookies();
   //2.循环遍历数据得到每一个cookie的key 与 value
   	for(Cookie card:cookieArray){
   		String key =   card.getName(); 读取key  "key1"
   		Strign value = card.getValue();读取value "abc"
   		提供较好的服务。。。。。。。。
   		}
   	}
   }
   

4. Cookie销毁时机：

   1. 在默认情况下，Cookie对象存放在浏览器的缓存当中，只要浏览器关闭，Cookie对象就会被销毁掉
   2. 在手动设置情况下，可以要求浏览器将接收的Cookie存放在客户端计算机的硬盘上，同时需要指定Cookie在硬盘上的存活时间。在存活时间范围内，关闭浏览器，关闭客户端计算机，关闭服务器，都不会导致Cookie被销毁。存活时间到达时，Cookie自动从硬盘上被删除
   3. cookie.setMaxAge(60); //cookie在硬盘上存活1分钟

5. Cookie练习小项目：

   流程图如下：

   

15.HttpSession接口（会话作用域对象）

1. 介绍：

   1. HttpSession接口来自于Servlet规范下的一个接口
   2. 如果两个Servlet来自于同一个网站，并且为同一个浏览器/用户提供服务，此时可以借助于HttpSession对象来进行数据共享
   3. 开发人员习惯将HttpSession接口修饰的对象称为会话作用域对象

2. HttpSession与Cookie的区别：（面试题）

   1. 存储位置：一个在天上，一个在地下
      • Cookie存放在客户端计算机（浏览器内存/硬盘）
      • HttpSession存放在服务端计算机内存
   2. 数据类型：
      • Cookie对象存储的共享数据类型只能是String
      • HttpSession对象可以存储任意类型的共享数据（Object）
   3. 数据数量：
      • 一个Cookie对象只能存储一个共享数据
      • HttpSession使用map集合存储共享数据，所以可以存储任意数量共享数据
   4. 参照物：
      • Cookie相当于客户在服务端的【会员卡】
      • HttpSession相当于客户在服务端的【私人保险柜】

3. 命令实现：

   同一个网站（myWeb）下OneServlet将数据传递给TwoServlet

   OneServlet{
   	public void doGet(HttpServletRequest request,HttpServletResponse response){
   	//1.调用请求对象向Tomcat索要当前用户在服务端的私人储物柜
   	HttpSession session = request.getSession();
       //2.将数据添加到用户私人储物柜
   	session.setAttribute("key1",共享数据)
   	}
   }
   浏览器访问/myWeb中TwoServlet
   TwoServlet{
   	public void doGet(HttpServletRequest request,HttpServletResponse response){
   	//1.调用请求对象向Tomcat索要当前用户在服务端的私人储物柜
   	HttpSession session = request.getSession();
       //2.从会话作用域对象得到OneServlet提供的共享数据
   	Object 共享数据 = session.getAttribute("key1");
   	}
   }
   

4. Http服务器如何将用户与HttpSession关联起来

   使用Cookie

   • Tomcat在创建一个HttpSession对象时自动为这个HttpSession对象生成一个编号
   • Tomcat将编号保存到Cookie对象，推送到当前浏览器缓存
     • Cookie：JSESSIONId=123455
   • 等到用户第二次来访时，Tomcat根据请求头JSESSIONId确认用户是否由HttpSession，以及哪个HttpSession时当前用户

   如图所示：

   

5. getSession() 与 getSession(false)

   1. getSession()：

      • 如果当前用户在服务端已经拥有了自己的私人储物柜，要求Tomcat将这个私人储物柜进行返回
      • 如果当前用户在服务端尚未拥有子集的私人储物柜，要求Tomcat为当前用户创建一个全新的私人储物柜

   2. getSession(false)：

      • 如果当前用户在服务端已经拥有了自己的私人储物柜，要求Tomcat将这个私人储物柜进行返回
      • 如果当前用户在服务端尚未拥有子集的私人储物柜，此时Tomcat将返回null

   3. 如果当前用户是合法的，可用getSession()

      如果用户是非法的，可用getSession(false)

6. HttpSession销毁时机：

   1. 用户与HttpSession关联时使用的Cookie，只能存放在浏览器缓存中
   2. 在浏览器关闭时，意味着用户与他的HttpSession关系被切断
   3. 由于Tomcat无法检测浏览器何时关闭，因此在浏览器关闭时并不会导致Tomcat将浏览器关联的HttpSession进行销毁
   4. 为了解决这个问题，Tomcat为每一个HttpSession对象设置了空闲时间，这个空闲时间默认为30分钟，如果当前HttpSession对象空闲时间达到30分钟，此时Tomcat认为用户已经放弃了自己的HttpSession，Tomcat就会销毁掉这个HttpSession

7. HttpSession空闲时间手动设置

   在当前网站/web/WEB-INF/web.xml
   <session-config>
   <session-timeout>5</session-timeout> <!--当前网站中每一个session最大空闲时间5分钟-->
   </session-config>
   

16.HttpServletRequest接口实现数据共享（请求作用域对象）

1. 介绍：

   1. 在同一个网站中，如果两个Servlet之间通过的是请求转发方式进行调用，彼此之间共享同一个请求协议包。而一个请求协议包只对应一个请求对象，因此Servlet之间共享同一个请求对象，此时可以利用这个请求对象在两个Servlet之间实现数据共享
   2. 在请求对象实现Servlet之间数据共享功能时，开发人员将请求对象称为请求作用域对象

2. 命令实现：

   OneServlet通过请求转发申请调用TwoServlet时，需要给TwoServlet提供共享数据

   OneServlet{
   	public void doGet(HttpServletRequest req,HttpServletResponse response){
   	//1.将数据添加到【请求作用域对象】中attribute属性
   	req.setAttribute("key1",数据); //数据类型可以任意类型Object
       //2.向Tomcat申请调用TwoServlet
   	req.getRequestDispatcher("/two").forward(req,response)
   	}
   }
   TwoServlet{
   	public void doGet(HttpServletRequest req,HttpServletResponse response){
       //从当前请求对象得到OneServlet写入到共享数据
   	Object 数据 = req.getAttribute("key1");
   	}
   }
   

17.监听器接口（监听器接口实现类写在Listener包下）

1. 介绍：

   1. 监听器接口是一组来自于Servlet规范下的接口，共有8个接口
   2. 监听器接口需要开发人员亲自实现，Http服务器提供jar包中并没有对应的实现类
   3. 监听器接口用于监控作用域对象生命周期变化时刻以及作用域对象共享数据变化时刻

2. 作用域对象：

   1. 在Servlet规范中，认为在服务端内存中可以在某些条件下，为两个Servlet之间提供数据共享方案的对象，被称为作用域对象
   2. Servlet规范下的作用域对象：
      1. ServletContext（全局作用域对象）
      2. HttpSession（会话作用域对象）
      3. HttpServletRequest（请求作用域对象）

3. 监听器接口实现类开发规范：三步

   1. 根据监听的实际情况，选择对应监听接口 进行实现
   2. 重写监听器接口声明【监听事件处理方法】
   3. 在web.xml文件将监听器接口实现类注册到Http服务器

4. ServletContextListener接口（介绍两个接口）

   1. 作用：通过这个接口来合法的检测全局作用域对象被初始化时刻以及被销毁时刻

   2. 监听事件处理方法：

      • public void contextlnitlized()

        在全局作用域对象被Http服务器初始化时 被调用

      • public void contextDestory()

        在全局作用域对象被Http服务器销毁时 被调用

   3. 将监听器接口实现类注册到Tomcat

      <listener>
      <listener-class>com.bjpoewrnode.listener.OneListener</listener-class>
      </listener>
      

5. ServletContextAttributeListener接口（介绍两个接口）

   1. 作用：通过这个接口来合法的检测全局作用域对象共享数据变化时刻

   2. 监听事件处理方法：

      • public void contextAdd()

        在全局作用域对象添加共享数据 监听？

      • public void contextReplaced()

        在全局作用域对象更新共享数据 监听？

      • public void contextRemove()

        在全局作用域对象删除共享数据 监听？

      • 全局作用域对象共享数据变化时刻

        ServletContext application = request.getServletContext();	 application.setAttribute("key1",100); //新增共享数据
        application.setAttribute("key1",200); //更新共享数据
        application.removeAttribute("key1");  //删除共享数据
        

6. 基于监听器模拟数据库连接池方案

   …没理解。。。妈的法克- -！！！(lll￢ω￢)

18.Filter接口（过滤器接口）

1. 介绍：

   1. Filter接口来自于Servlet规范下的接口
   2. Filter接口实现类写在filter包下
   3. Filter接口实现类由开发人员负责提供，Http服务器不负责提供
   4. filter接口在Http服务器调用资源文件之前，对Http服务器进行拦截

2. 具体作用：

   1. 拦截Http服务器，帮助Http服务器检测当前请求合法性
   2. 拦截Http服务器，对当前请求进行增强操作

3. Filter接口实现类开发步骤：三步

   1. 创建一个Java实现类实现Filter接口
   2. 重写Filter接口中doFilter方法
   3. web.xml将过滤器接口实现类注册到Http服务器

4. Filter拦截地址格式

   1. 命令格式：

      <filter-mapping>
          <filter-name>oneFilter</filter-name>
          <url-pattern>拦截地址</url-pattern>
      </filter-mapping>
      

   2. 命令作用：

      拦截地址通知Tomcat在调用何种资源之前，需要调用OneFilter过滤器来进行拦截

   3. 要求Tomcat在调用某一个具体文件之前，来调用OneFilter拦截

      /img/m.jpg

   4. 要求Tomcat在调用某一个文件夹下所有的资源文件之前，来调用OneFilter拦截

      /img/*

   5. 要求Tomcat在调用任意文件夹下某种类型文件之前，来调用OneFilter拦截

      *.jpg

   6. 要求Tomcat在调用网站中任意文件时，来调用OneFilter拦截

      /*

5. 利用过滤器防止用户恶意登录

   没听懂…淦。。。嘤嘤嘤