javaWeb学习笔记

javaWeb学习笔记（老杜）

1.0 预备知识

1.0.1C/S架构

Client / Server（客户端 / 服务器）

QQ（先去腾讯官网下载一个QQ软件，几十MB，然后把这个客户端软件安装上去，然后输入QQ号以及密码，登录之后，就可以和你的朋友聊天了，就可以使用这个软件了。）

C/S架构的特点：需要安装特定的客户端软件。

1.0.2B/S架构

B/S（Browser / Server，浏览器 / 服务器）

B/S结构的系统，其实就是开发网站，其实就是开发一个WEB系统。

1.0.3关于Tomcat服务器的目录

• bin ： 这个目录是Tomcat服务器的命令文件存放的目录，比如：启动Tomcat，关闭Tomcat等。
• conf： 这个目录是Tomcat服务器的配置文件存放目录。（server.xml文件中可以配置端口号，默认Tomcat端口是8080）
• lib ：这个目录是Tomcat服务器的核心程序目录，因为Tomcat服务器是Java语言编写的，这里的jar包里面都是class文件。
• logs: Tomcat服务器的日志目录，Tomcat服务器启动等信息都会在这个目录下生成日志文件。
• temp：Tomcat服务器的临时目录。存储临时文件。
• webapps：这个目录当中就是用来存放大量的webapp（web application：web应用）
• work：这个目录是用来存放JSP文件翻译之后的java文件以及编译之后的class文件。

1.1开发一个带有Servlet的webapp

第一步：在webapps目录下新建一个目录，起名javawebOA_war,当然，也可以是其它项目。

第二步：在webapp的根下新建一个目录：WEB-INF

这个目录的名字是Servlet规范中规定的，必须全部大写，必须一模一样。必须的必须（没有为什么）。

第三步：在WEB-INF目录下新建一个目录：classes

这个目录的名字必须是全部小写的classes。这也是Servlet规范中规定的。另外这个目录下一定存放的是Java程序编译之后的class文件（这里存放的是字节码文件）。

第四步：在WEB-INF目录下新建一个目录：lib

例如java语言连接数据库需要数据库的驱动jar包。那么这个jar包就一定要放到lib目录下。这Servlet规范中规定的。

第五步：在WEB-INF目录下新建一个文件：web.xml

这个文件是必须的，这个文件名必须叫做web.xml。这个文件必须放在这里。一个合法的webapp，web.xml文件是必须的，这个web.xml文件就是一个配置文件，在这个配置文件中描述了请求路径和Servlet类之间的对照关系。

DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Applicationdisplay-name>
  <servlet>
      
	
    <servlet-name>listdepservlet-name>
      
    <servlet-class>com.oa.entity.Deptlistservlet-class>
  servlet>
  <servlet-mapping>
      
    <servlet-name>listdepservlet-name>
      
		
		
    <url-pattern>/dept/listurl-pattern>
  servlet-mapping>
web-app>

第六步：编写一个Java程序

总结：一个合法的webapp目录结构应该是:

webapproot
     |------WEB-INF
     		  |------classes(存放字节码)
     		  |------lib(第三方jar包)
     		  |------web.xml(注册Servlet)
     |------html
     |------css
     |------javascript
     |------image
     ....

第七步：启动Tomcat服务器

第八步：打开浏览器，在浏览器地址栏上输入一个url，这个URL必须是：

• http://127.0.0.1:8080/crm/fdsa/fd/saf/d/sa/fd/sa/fd

• 非常重要的一件事：浏览器上的请求路径不能随便写，这个请求路径必须和web.xml文件中的url-pattern一致。

• 注意：浏览器上的请求路径和web.xml文件中的url-pattern的唯一区别就是：浏览器上的请求路径带项目名：/crm

• 浏览器上编写的路径太复杂，可以使用超链接。（非常重要：html页面只能放到WEB-INF目录外面。）

• 以后不需要我们编写main方法了。tomcat服务器负责调用main方法，Tomcat服务器启动的时候执行的就是main方法。我们javaweb程序员只需要编写Servlet接口的实现类，然后将其注册到web.xml文件中，即可。

---

浏览器发送请求，到最终服务器调用Servlet中的方法，大概是怎样的一个过程？

• 用户输入URL，或者直接点击超链接：http://127.0.0.1:8080/crm/fdsa/fd/saf/d/sa/fd/sa/fd
• 然后Tomcat服务器接收到请求，截取路径：/crm/fdsa/fd/saf/d/sa/fd/sa/fd
• Tomcat服务器找到crm项目
• Tomcat服务器在web.xml文件中查找/fdsa/fd/saf/d/sa/fd/sa/fd 对应的Servlet是：com.bjpowernode.servlet.HelloServlet
• Tomcat服务器通过反射机制，创建com.bjpowernode.servlet.HelloServlet的对象。
• Tomcat服务器调用com.bjpowernode.servlet.HelloServlet对象的service方法。

1.2使用IDEA集成开发工具开发Servlet

第一步：New Project

第二步：让IDEA工具去关联Tomcat服务器。关联的过程当中将webapp部署到Tomcat服务器当中。

1.3Servlet对象的生命周期

1.3.1什么是Servlet对象生命周期？

• Servlet对象什么时候被创建。
• Servlet对象什么时候被销毁。
• Servlet对象创建了几个？
• Servlet对象的生命周期表示：一个Servlet对象从出生在最后的死亡，整个过程是怎样的。

1.3.2Servlet对象是由谁来维护的？

• Servlet对象的创建，对象上方法的调用，对象最终的销毁，Javaweb程序员是无权干预的。
• Servlet对象的生命周期是由Tomcat服务器（WEB Server）全权负责的。
• Tomcat服务器通常我们又称为：WEB容器。（这个叫法你要知道【WEB Container】）
• WEB容器来管理Servlet对象的死活。

1.3.3自己new的Servlet对象受WEB容器的管理吗？

• 我们自己new的Servlet对象是不受WEB容器管理的。
• WEB容器创建的Servlet对象，这些Servlet对象都会被放到一个集合当中（HashMap），只有放到这个HashMap集合中的Servlet才能够被WEB容器管理，自己new的Servlet对象不会被WEB容器管理。（自己new的Servlet对象不在容器当中）
• web容器底层应该有一个HashMap这样的集合，在这个集合当中存储了Servlet对象和请求路径之间的关系

1.3.4服务器在启动的Servlet对象有没有被创建出来（默认情况下）？

• 在Servlet中提供一个无参数的构造方法，启动服务器的时候看看构造方法是否执行。
• 经过测试得出结论：默认情况下，服务器在启动的时候Servlet对象并不会被实例化。
• 这个设计是合理的。用户没有发送请求之前，如果提前创建出来所有的Servlet对象，必然是耗费内存的，并且创建出来的Servlet如果一直没有用户访问，显然这个Servlet对象是一个废物，没必要先创建。

1.3.5Servlet对象生命周期

• 默认情况下服务器启动的时候AServlet对象并没有被实例化

• 用户发送第一次请求的时候，控制台输出了以下内容：

1.3.6结论

• 用户在发送第一次请求的时候Servlet对象被实例化（AServlet的构造方法被执行了。并且执行的是无参数构造方法。）
• AServlet对象被创建出来之后，Tomcat服务器马上调用了AServlet对象的init方法。（init方法在执行的时候，AServlet对象已经存在了。已经被创建出来了。）
• 用户发送第一次请求的时候，init方法执行之后，Tomcat服务器马上调用AServlet对象的service方法。

根据以上输出结果得知，用户在发送第二次，或者第三次，或者第四次请求的时候，Servlet对象并没有新建，还是使用之前创建好的Servlet对象，直接调用该Servlet对象的service方法，这说明：

• 第一：Servlet对象是单例的（单实例的。但是要注意：Servlet对象是单实例的，但是Servlet类并不符合单例模式。我们称之为假单例。之所以单例是因为Servlet对象的创建我们javaweb程序员管不着，这个对象的创建只能是Tomcat来说了算，Tomcat只创建了一个，所以导致了单例，但是属于假单例。真单例模式，构造方法是私有化的。）

• 第二：无参数构造方法、init方法只在第一次用户发送请求的时候执行。也就是说无参数构造方法只执行一次。init方法也只被Tomcat服务器调用一次。

• 第三：只要用户发送一次请求：service方法必然会被Tomcat服务器调用一次。发送100次请求，service方法会被调用100次。

• 通过以上输出内容，可以得出以下结论：

  • Servlet的destroy方法只被Tomcat服务器调用一次。
  • destroy方法是在什么时候被调用的？
    • 在服务器关闭的时候。
    • 因为服务器关闭的时候要销毁AServlet对象的内存。
    • 服务器在销毁AServlet对象内存之前，Tomcat服务器会自动调用AServlet对象的destroy方法。

• 请问：destroy方法调用的时候，对象销毁了还是没有销毁呢？

  • destroy方法执行的时候AServlet对象还在，没有被销毁。destroy方法执行结束之后，AServlet对象的内存才会被Tomcat释放。

• Servlet对象更像一个人的一生：

  • Servlet的无参数构造方法执行：标志着你出生了。
  • Servlet对象的init方法的执行：标志着你正在接受教育。
  • Servlet对象的service方法的执行：标志着你已经开始工作了，已经开始为人类提供服务了。
  • Servlet对象的destroy方法的执行：标志着临终。有什么遗言，抓紧的。要不然，来不及了。

  1.3.7关于Servlet类中方法的调用次数？

  • 构造方法只执行一次。
  • init方法只执行一次。
  • service方法：用户发送一次请求则执行一次，发送N次请求则执行N次。
  • destroy方法只执行一次。

• 当我们Servlet类中编写一个有参数的构造方法，如果没有手动编写无参数构造方法会出现什么问题？

  • 报错了：500错误。
  • 注意：500是一个HTTP协议的错误状态码。
  • 500一般情况下是因为服务器端的Java程序出现了异常。（服务器端的错误都是500错误：服务器内部错误。）
  • 如果没有无参数的构造方法，会导致出现500错误，无法实例化Servlet对象。
  • 所以，一定要注意：在Servlet开发当中，不建议程序员来定义构造方法，因为定义不当，一不小心就会导致无法实例化Servlet对象。

• 思考：Servlet的无参数构造方法是在对象第一次创建的时候执行，并且只执行一次。init方法也是在对象第一次创建的时候执行，并且只执行一次。那么这个无参数构造方法可以代替掉init方法吗？

  • 不能。
  • Servlet规范中有要求，作为javaweb程序员，编写Servlet类的时候，不建议手动编写构造方法，因为编写构造方法，很容易让无参数构造方法消失，这个操作可能会导致Servlet对象无法实例化。所以init方法是有存在的必要的。

  1.3.8init、service、destroy方法中使用最多的是哪个方法？

  • 使用最多就是service方法，service方法是一定要实现的，因为service方法是处理用户请求的核心方法。
  • 什么时候使用init方法呢？
    • init方法很少用。
    • 通常在init方法当中做初始化操作，并且这个初始化操作只需要执行一次。例如：初始化数据库连接池，初始化线程池…
  • 什么时候使用destroy方法呢？
    • destroy方法也很少用。
    • 通常在destroy方法当中，进行资源的关闭。马上对象要被销毁了，还有什么没有关闭的，抓紧时间关闭资源。还有什么资源没保存的，抓紧时间保存一下。

1.4关于WEB-INF目录

• 在WEB-INF目录下新建了一个文件：welcome.html
• 打开浏览器访问：http://localhost:8080/servlet07/WEB-INF/welcome.html 出现了404错误。
• 注意：放在WEB-INF目录下的资源是受保护的。在浏览器上不能够通过路径直接访问。所以像HTML、CSS、JS、image等静态资源一定要放到WEB-INF目录之外。

1.5HttpServletRequest接口详解

• HttpServletRequest接口是Servlet规范中的一员。

• HttpServletRequest接口的父接口：ServletRequest

  • public interface HttpServletRequest extends ServletRequest {}
    

• HttpServletRequest接口的实现类谁写的? HttpServletRequest对象是谁给创建的？

  • 通过测试：org.apache.catalina.connector.RequestFacade 实现了 HttpServletRequest接口

    • public class RequestFacade implements HttpServletRequest {}
      

• HttpServletRequest对象中都有什么信息？都包装了什么信息？

  • HttpServletRequest对象是Tomcat服务器负责创建的。这个对象中封装了什么信息？封装了HTTP的请求协议。
  • 实际上是用户发送请求的时候，遵循了HTTP协议，发送的是HTTP的请求协议，Tomcat服务器将HTTP协议中的信息以及数据全部解析出来，然后Tomcat服务器把这些信息封装到HttpServletRequest对象当中，传给了我们javaweb程序员。
  • javaweb程序员面向HttpServletRequest接口编程，调用方法就可以获取到请求的信息了。

• request和response对象的生命周期？

  • request对象和response对象，一个是请求对象，一个是响应对象。这两个对象只在当前请求中有效。
  • 一次请求对应一个request。
  • 两次请求则对应两个request。
  • …

• HttpServletRequest接口中有哪些常用的方法？

  • 怎么获取前端浏览器用户提交的数据？

    • Map<String,String[]> getParameterMap() 这个是获取Map
      Enumeration<String> getParameterNames() 这个是获取Map集合中所有的key
      String[] getParameterValues(String name) 根据key获取Map集合的value
      String getParameter(String name)  获取value这个一维数组当中的第一个元素。这个方法最常用。
      // 以上的4个方法，和获取用户提交的数据有关系。
      

    • 思考：如果是你，前端的form表单提交了数据之后，你准备怎么存储这些数据，你准备采用什么样的数据结构去存储这些数据呢？

      • 前端提交的数据格式：username=abc&userpwd=111&aihao=s&aihao=d&aihao=tt

      • 注意：前端表单提交数据的时候，假设提交了120这样的“数字”，其实是以字符串"120"的方式提交的，所以服务器端获取到的一定是一个字符串的"120"，而不是一个数字。（前端永远提交的是字符串，后端获取的也永远是字符串。）

1.6ServletContext当中有三个操作域的方法

void setAttribute(String name, Object obj); // 向域当中绑定数据。
Object getAttribute(String name); // 从域当中根据name获取数据。
void removeAttribute(String name); // 将域当中绑定的数据移除

// 以上的操作类似于Map集合的操作。
Map<String, Object> map;
map.put("name", obj); // 向map集合中放key和value
Object obj = map.get("name"); // 通过map集合的key获取value
map.remove("name"); // 通过Map集合的key删除key和value这个键值对。

请求域”对象

• “请求域”对象要比“应用域”对象范围小很多。生命周期短很多。请求域只在一次请求内有效。

• 一个请求对象request对应一个请求域对象。一次请求结束之后，这个请求域就销毁了。

• • 请求域对象也有这三个方法：

    • void setAttribute(String name, Object obj); // 向域当中绑定数据。
      Object getAttribute(String name); // 从域当中根据name获取数据。
      void removeAttribute(String name); // 将域当中绑定的数据移除
      

  • 请求域和应用域的选用原则？

    • 尽量使用小的域对象，因为小的域对象占用的资源较少。

• 跳转

  • 转发（一次请求）

    • // 第一步：获取请求转发器对象
      RequestDispatcher dispatcher = request.getRequestDispatcher("/b");
      // 第二步：调用转发器的forward方法完成跳转/转发
      dispatcher.forward(request,response);
      
      // 第一步和第二步代码可以联合在一起。
      request.getRequestDispatcher("/b").forward(request,response);
      
      

• 两个Servlet怎么共享数据？

  • 将数据放到ServletContext应用域当中，当然是可以的，但是应用域范围太大，占用资源太多。不建议使用。
  • 可以将数据放到request域当中，然后AServlet转发到BServlet，保证AServlet和BServlet在同一次请求当中，这样就可以做到两个Servlet，或者多个Servlet共享同一份数据。

• 转发的下一个资源必须是一个Servlet吗？

  • 不一定，只要是Tomcat服务器当中的合法资源，都是可以转发的。例如：html…
  • 注意：转发的时候，路径的写法要注意，转发的路径以“/”开始，不加项目名。

关于request对象中两个非常容易混淆的方法

// uri?username=zhangsan&userpwd=123&sex=1
String username = request.getParameter("username");

// 之前一定是执行过：request.setAttribute("name", new Object())
Object obj = request.getAttribute("name");

// 以上两个方法的区别是什么？
// 第一个方法：获取的是用户在浏览器上提交的数据。
// 第二个方法：获取的是请求域当中绑定的数据。

1.7在一个web应用中应该如何完成资源的跳转?

• 在一个web应用中通过两种方式，可以完成资源的跳转：

  • 第一种方式：转发
  • 第二种方式：重定向

• 转发和重定向有什么区别？

  • 代码上有什么区别？

    • 转发

      • // 获取请求转发器对象
        RequestDispatcher dispatcher = request.getRequestDispatcher("/dept/list");
        // 调用请求转发器对象的forward方法完成转发
        dispatcher.forward(request, response);
        
        // 合并一行代码
        request.getRequestDispatcher("/dept/list").forward(request, response);
        // 转发的时候是一次请求，不管你转发了多少次。都是一次请求。
        // AServlet转发到BServlet，再转发到CServlet，再转发到DServlet，不管转发了多少次，都在同一个request当中。
        // 这是因为调用forward方法的时候，会将当前的request和response对象传递给下一个Servlet。
        

    • 重定向

      • // 注意：路径上要加一个项目名。为什么？
        // 浏览器发送请求，请求路径上是需要添加项目名的。
        // 以下这一行代码会将请求路径“/oa/dept/list”发送给浏览器
        // 浏览器会自发的向服务器发送一次全新的请求：/oa/dept/list
        response.sendRedirect("/oa/dept/lit");
        

  • 形式上有什么区别？

    • 转发（一次请求）
      • 在浏览器地址栏上发送的请求是：http://localhost:8080/servlet10/a ，最终请求结束之后，浏览器地址栏上的地址还是这个。没变。
    • 重定向（两次请求）
      • 在浏览器地址栏上发送的请求是：http://localhost:8080/servlet10/a ，最终在浏览器地址栏上显示的地址是：http://localhost:8080/servlet10/b

  • 转发和重定向的本质区别？

    • 转发：是由WEB服务器来控制的。A资源跳转到B资源，这个跳转动作是Tomcat服务器内部完成的。
    • 重定向：是浏览器完成的。具体跳转到哪个资源，是浏览器说了算。

  • 使用一个例子去描述这个转发和重定向

    • 借钱（转发：发送了一次请求）
      • 杜老师没钱了，找张三借钱，其实张三没有钱，但是张三够义气，张三自己找李四借了钱，然后张三把这个钱给了杜老师，杜老师不知道这个钱是李四的，杜老师只求了一个人。杜老师以为这个钱就是张三的。
    • 借钱（重定向：发送了两次请求）
      • 杜老师没钱了，找张三借钱，张三没有钱，张三有一个好哥们，叫李四，李四是个富二代，于是张三将李四的家庭住址告诉了杜老师，杜老师按照这个地址去找到李四，然后从李四那里借了钱。显然杜老师在这个过程中，求了两个人。并且杜老师知道最终这个钱是李四借给俺的。

• 转发和重定向应该如何选择？什么时候使用转发，什么时候使用重定向？

  • 如果在上一个Servlet当中向request域当中绑定了数据，希望从下一个Servlet当中把request域里面的数据取出来，使用转发机制。
  • 剩下所有的请求均使用重定向。（重定向使用较多。）

• 跳转的下一个资源有没有要求呢？必须是一个Servlet吗？

  • 不一定，跳转的资源只要是服务器内部合法的资源即可。包括：Servlet、JSP、HTML…

• 转发会存在浏览器的刷新问题。

1.8Cookie

• session的实现原理中，每一个session对象都会关联一个sessionid，例如：

  • JSESSIONID=41C481F0224664BDB28E95081D23D5B8
  • 以上的这个键值对数据其实就是cookie对象。
  • 对于session关联的cookie来说，这个cookie是被保存在浏览器的“运行内存”当中。
  • 只要浏览器不关闭，用户再次发送请求的时候，会自动将运行内存中的cookie发送给服务器。
  • 例如，这个Cookie: JSESSIONID=41C481F0224664BDB28E95081D23D5B8就会再次发送给服务器。
  • 服务器就是根据41C481F0224664BDB28E95081D23D5B8这个值来找到对应的session对象的。

• cookie怎么生成？cookie保存在什么地方？cookie有啥用？浏览器什么时候会发送cookie，发送哪些cookie给服务器？？？？？？？

• cookie最终是保存在浏览器客户端上的。

  • 可以保存在运行内存中。（浏览器只要关闭cookie就消失了。）
  • 也可以保存在硬盘文件中。（永久保存。）

• cookie有啥用呢？

  • cookie和session机制其实都是为了保存会话的状态。
  • cookie是将会话的状态保存在浏览器客户端上。（cookie数据存储在浏览器客户端上的。）
  • session是将会话的状态保存在服务器端上。（session对象是存储在服务器上。）
  • 为什么要有cookie和session机制呢？因为HTTP协议是无状态 无连接协议。

• cookie的经典案例

  • 京东商城，在未登录的情况下，向购物车中放几件商品。然后关闭商城，再次打开浏览器，访问京东商城的时候，购物车中的商品还在，这是怎么做的？我没有登录，为什么购物车中还有商品呢？
    • 将购物车中的商品编号放到cookie当中，cookie保存在硬盘文件当中。这样即使关闭浏览器。硬盘上的cookie还在。下一次再打开京东商城的时候，查看购物车的时候，会自动读取本地硬盘中存储的cookie，拿到商品编号，动态展示购物车中的商品。
      • 京东存储购物车中商品的cookie可能是这样的：productIds=xxxxx,yyyy,zzz,kkkk
      • 注意：cookie如果清除掉，购物车中的商品就消失了。
  • 126邮箱中有一个功能：十天内免登录
    • 这个功能也是需要cookie来实现的。
    • 怎么实现的呢？
      • 用户输入正确的用户名和密码，并且同时选择十天内免登录。登录成功后。浏览器客户端会保存一个cookie，这个cookie中保存了用户名和密码等信息，这个cookie是保存在硬盘文件当中的，十天有效。在十天内用户再次访问126的时候，浏览器自动提交126的关联的cookie给服务器，服务器接收到cookie之后，获取用户名和密码，验证，通过之后，自动登录成功。
      • 怎么让cookie失效？
        • 十天过后自动失效。
        • 或者改密码。
        • 或者在客户端浏览器上清除cookie。

• cookie机制和session机制其实都不属于java中的机制，实际上cookie机制和session机制都是HTTP协议的一部分。php开发中也有cookie和session机制，只要是你是做web开发，不管是什么编程语言，cookie和session机制都是需要的。

• HTTP协议中规定：任何一个cookie都是由name和value组成的。name和value都是字符串类型的。

• 在java的servlet中，对cookie提供了哪些支持呢？

  • 提供了一个Cookie类来专门表示cookie数据。jakarta.servlet.http.Cookie;
  • java程序怎么把cookie数据发送给浏览器呢？response.addCookie(cookie);

• 在HTTP协议中是这样规定的：当浏览器发送请求的时候，会自动携带该path下的cookie数据给服务器。（URL。）

• 关于cookie的有效时间

  • 怎么用java设置cookie的有效时间
    • cookie.setMaxAge(60 * 60); 设置cookie在一小时之后失效。
  • 没有设置有效时间：默认保存在浏览器的运行内存中，浏览器关闭则cookie消失。
  • 只要设置cookie的有效时间 > 0，这个cookie一定会存储到硬盘文件当中。
  • 设置cookie的有效时间 = 0 呢？
    • cookie被删除，同名cookie被删除。
  • 设置cookie的有效时间 < 0 呢？
    • 保存在运行内存中。和不设置一样。

• 关于cookie的path，cookie关联的路径：

  • 假设现在发送的请求路径是“http://localhost:8080/servlet13/cookie/generate”生成的cookie，如果cookie没有设置path，默认的path是什么？
    • 默认的path是：http://localhost:8080/servlet13/cookie 以及它的子路径。
    • 也就是说，以后只要浏览器的请求路径是http://localhost:8080/servlet13/cookie 这个路径以及这个路径下的子路径，cookie都会被发送到服务器。
  • 手动设置cookie的path
    • cookie.setPath(“/servlet13”); 表示只要是这个servlet13项目的请求路径，都会提交这个cookie给服务器。

• 浏览器发送cookie给服务器了，服务器中的java程序怎么接收？

  • Cookie[] cookies = request.getCookies(); // 这个方法可能返回null
    if(cookies != null){
        for(Cookie cookie : cookies){
            // 获取cookie的name
            String name = cookie.getName();
            // 获取cookie的value
            String value = cookie.getValue();
        }
    }
    
    

• 使用cookie实现一下十天内免登录功能。

  • 先实现登录功能
    • 登录成功
      • 跳转到部门列表页面
    • 登录失败
      • 跳转到登录失败页面
  • 修改前端页面
    • 在登录页面给一个复选框，复选框后面给一句话：十天内免登录。
    • 用户选择了复选框：表示要支持十天内免登录。
    • 用户没有选择复选框：表示用户不想使用十天内免登录功能。
  • 修改Servlet中的login方法
    • 如果用户登录成功了，并且用户登录时选择了十天内免登录功能，这个时候应该在Servlet的login方法中创建cookie，用来存储用户名和密码，并且设置路径，设置有效期，将cookie响应给浏览器。（浏览器将其自动保存在硬盘文件当中10天）
  • 用户再次访问该网站的时候，访问这个网站的首页的时候，有两个走向:
    • 要么跳转到部门列表页面
    • 要么跳转到登录页面
    • 以上分别有两个走向，这显然是需要编写java程序进行控制的。

1.9JSP

• 我的第一个JSP程序：

  • 在WEB-INF目录之外创建一个index.jsp文件，然后这个文件中没有任何内容。

• 将上面的项目部署之后，启动服务器，打开浏览器，访问以下地址：

  • http://localhost:8080/jsp/index.jsp 展现在大家面前的是一个空白。
  • 实际上访问以上的这个：index.jsp，底层执行的是：index_jsp.class 这个java程序。
  • 这个index.jsp会被tomcat翻译生成index_jsp.java文件，然后tomcat服务器又会将index_jsp.java编译生成index_jsp.class文件
  • 访问index.jsp，实际上执行的是index_jsp.class中的方法。

• JSP实际上就是一个Servlet。

  • index.jsp访问的时候，会自动翻译生成index_jsp.java，会自动编译生成index_jsp.class，那么index_jsp 这就是一个类。
  • index_jsp 类继承 HttpJspBase，而HttpJspBase类继承的是HttpServlet。所以index_jsp类就是一个Servlet类。
  • jsp的生命周期和Servlet的生命周期完全相同。完全就是一个东西。没有任何区别。
  • jsp和servlet一样，都是单例的。（假单例。）

• jsp文件第一次访问的时候是比较慢的，为什么？

  • 为什么大部分的运维人员在给客户演示项目的时候，为什么提前先把所有的jsp文件先访问一遍。
  • 第一次比较麻烦：
    • 要把jsp文件翻译生成java源文件
    • java源文件要编译生成class字节码文件
    • 然后通过class去创建servlet对象
    • 然后调用servlet对象的init方法
    • 最后调用servlet对象的service方法。
  • 第二次就比较快了，为什么？
    • 因为第二次直接调用单例servlet对象的service方法即可。

• JSP是什么？

  • JSP是java程序。（JSP本质还是一个Servlet）
  • JSP是：JavaServer Pages的缩写。（基于Java语言实现的服务器端的页面。）
  • Servlet是JavaEE的13个子规范之一，那么JSP也是JavaEE的13个子规范之一。
  • JSP是一套规范。所有的web容器/web服务器都是遵循这套规范的，都是按照这套规范进行的“翻译”
  • 每一个web容器/web服务器都会内置一个JSP翻译引擎。

• 对JSP进行错误调试的时候，还是要直接打开JSP文件对应的java文件，检查java代码。

• 开发JSP的最高境界：

  • 眼前是JSP代码，但是脑袋中呈现的是java代码。

• JSP既然本质上是一个Servlet，那么JSP和Servlet到底有什么区别呢？

  • 职责不同：
    • Servlet的职责是什么：收集数据。（Servlet的强项是逻辑处理，业务处理，然后链接数据库，获取/收集数据。）
    • JSP的职责是什么：展示数据。（JSP的强项是做数据的展示）

• JSP的基础语法

  • 在jsp文件中直接编写文字，都会自动被翻译到哪里？

    • 翻译到servlet类的service方法的out.write(“翻译到这里”)，直接翻译到双引号里，被java程序当做普通字符串打印输出到浏览器。
    • 在JSP中编写的HTML CSS JS代码，这些代码对于JSP来说只是一个普通的字符串。但是JSP把这个普通的字符串一旦输出到浏览器，浏览器就会对HTML CSS JS进行解释执行。展现一个效果。

  • JSP的page指令（这个指令后面再详细说，这里先解决一下中文乱码问题），解决响应时的中文乱码问题：

    • 通过page指令来设置响应的内容类型，在内容类型的最后面添加：charset=UTF-8
      • <%@page contentType=“text/html;charset=UTF-8”%>，表示响应的内容类型是text/html，采用的字符集UTF-8
      • <%@page import=“java.util.List,java.util.ArrayList”%>

  • 怎么在JSP中编写Java程序：

    • <% java语句; %>
      • 在这个符号当中编写的被视为java程序，被翻译到Servlet类的service方法内部。
      • 这里你要细心点，你要思考，在<% %>这个符号里面写java代码的时候，你要时时刻刻的记住你正在“方法体”当中写代码，方法体中可以写什么，不可以写什么，你心里是否明白呢？
      • 在service方法当中编写的代码是有顺序的，方法体当中的代码要遵循自上而下的顺序依次逐行执行。
      • service方法当中不能写静态代码块，不能写方法，不能定义成员变量。。。。。。
      • 在同一个JSP当中 <%%> 这个符号可以出现多个。
    • <%! %>
      • 在这个符号当中编写的java程序会自动翻译到service方法之外。
      • 这个语法很少用，为什么？不建议使用，因为在service方法外面写静态变量和实例变量，都会存在线程安全问题，因为JSP就是servlet，servlet是单例的，多线程并发的环境下，这个静态变量和实例变量一旦有修改操作，必然会存在线程安全问题。
    • JSP的输出语句
      • 怎么向浏览器上输出一个java变量。
      • <% String name = “jack”; out.write("name = " + name); %>
      • 注意：以上代码中的out是JSP的九大内置对象之一。可以直接拿来用。当然，必须只能在service方法内部使用。
      • 如果向浏览器上输出的内容中没有“java代码”，例如输出的字符串是一个固定的字符串，可以直接在jsp中编写，不需要写到<%%> 这里。
      • 如果输出的内容中含有“java代码”，这个时候可以使用以下语法格式：
        • <%= %> 注意：在=的后面编写要输出的内容。
        • <%= %> 这个符号会被翻译到哪里？最终翻译成什么？
          • 翻译成了这个java代码： out.print();
          • 翻译到service方法当中了。
        • 什么时候使用<%=%> 输出呢？输出的内容中含有java的变量，输出的内容是一个动态的内容，不是一个死的字符串。如果输出的是一个固定的字符串，直接在JSP文件中编写即可。

  • 在JSP中如何编写JSP的专业注释

    • <%–JSP的专业注释，不会被翻译到java源代码当中。–%>

  • JSP基础语法总结：

    • JSP中直接编写普通字符串
      • 翻译到service方法的out.write(“这里”)
    • <%%>
      • 翻译到service方法体内部，里面是一条一条的java语句。
    • <%! %>
      • 翻译到service方法之外。
    • <%= %>
      • 翻译到service方法体内部，翻译为：out.print();
    • <%@page contentType=“text/html;charset=UTF-8”%>
      • page指令，通过contentType属性用来设置响应的内容类型。

  • 使用Servlet + JSP完成oa项目的改造。

    • 使用Servlet处理业务，收集数据。 使用JSP展示数据。

    • 将之前原型中的html文件，全部修改为jsp，然后在jsp文件头部添加page指令（指定contentType防止中文乱码），将所有的JSP直接拷贝到web目录下。

    • 完成所有页面的正常流转。（页面仍然能够正常的跳转。修改超链接的请求路径。）

      • <%=request.getContextPath() %> 在JSP中动态的获取应用的根路径。

    • Servlet中连接数据库，查询所有的部门，遍历结果集。

      • 遍历结果集的过程中，取出部门编号、部门名、位置等信息，封装成java对象。
      • 将java对象存放到List集合中。
      • 将List集合存储到request域当中。
      • 转发forward到jsp。

    • 在JSP中：

      • 从request域当中取出List集合。
      • 遍历List集合，取出每个部门对象。动态生成tr。

    • 思考一个问题：如果我只用JSP这一个技术，能不能开发web应用？

      • 当然可以使用JSP来完成所有的功能。因为JSP就是Servlet，在JSP的<%%>里面写的代码就是在service方法当中的，所以在<%%>当中完全可以编写JDBC代码，连接数据库，查询数据，也可以在这个方法当中编写业务逻辑代码，处理业务，都是可以的，所以使用单独的JSP开发web应用完全没问题。
      • 虽然JSP一个技术就可以完成web应用，但是不建议，还是建议采用servlet + jsp的方式进行开发。这样都能将各自的优点发挥出来。JSP就是做数据展示。Servlet就是做数据的收集。（JSP中编写的Java代码越少越好。）一定要职责分明。

    • JSP文件的扩展名必须是xxx.jsp吗？

      • jsp文件的扩展名是可以配置的。不是固定的。

      • 在CATALINA_HOME/conf/web.xml，在这个文件当中配置jsp文件的扩展名。

      • <servlet-mapping>
            <servlet-name>jspservlet-name>
            <url-pattern>*.jspurl-pattern>
            <url-pattern>*.jspxurl-pattern>
        servlet-mapping>
        

      • xxx.jsp文件对于小猫咪来说，只是一个普通的文本文件，web容器会将xxx.jsp文件最终生成java程序，最终调用的是java对象相关的方法，真正执行的时候，和jsp文件就没有关系了。

      • 小窍门：JSP如果看不懂，建议把jsp翻译成java代码，就能看懂了。

    • 同学问：包名bean是什么意思？

      • javabean（java的logo是一杯冒着热气的咖啡。javabean被翻译为：咖啡豆）
      • java是一杯咖啡，咖啡又是由一粒一粒的咖啡豆研磨而成。
      • 整个java程序中有很多bean的存在。由很多bean组成。
      • 什么是javabean？实际上javabean你可以理解为符合某种规范的java类，比如：
        • 有无参数构造方法
        • 属性私有化
        • 对外提供公开的set和get方法
        • 实现java.io.Serializable接口
        • 重写toString
        • 重写hashCode+equals
        • …
      • javabean其实就是java中的实体类。负责数据的封装。
      • 由于javabean符合javabean规范，具有更强的通用性。

    • 完成剩下所有功能的改造。

• 当前的oa应用存在的问题：

  • 任何一个用户都可以访问这个系统，都可以对这个系统当中的数据进行增删改这些危险的操作。我只想让合法的用户去使用这个系统，不合法的用户不能访问这个系统，怎么办？
    • 加一个登录功能。登录成功的可以访问该系统，登录失败不能访问。
  • 实现登录功能：
    • 步骤1：数据库当中添加一个用户表：t_user
      • t_user表当中存储的是用户的登录信息，最基本的也包括：登录的用户名和登录的密码。
      • 密码一般在数据库表当中存储的是密文。一般不以明文的形式存储。（这里先使用明文方式。）
      • 向t_user表中插入数据。
    • 步骤2：再实现一个登录页面。
      • 登录页面上应该有一个登录的表单。有用户名和密码输入的框。
      • 用户点击登录，提交表单，提交用户名和密码。form是post方式提交。
    • 步骤3：后台要有一个对应的Servlet来处理登录的请求。
      • 登录成功：跳转到部门列表页面。
      • 登录失败：跳转到失败的页面。
    • 步骤4：再提供一个登录失败的页面。

• 登录功能实现了，目前存在的最大的问题：

  • 这个登录功能目前只是一个摆设，没有任何作用。只要用户知道后端的请求路径，照样可以在不登录的情况下访问。
  • 这个登录没有真正起到拦截的作用。怎么解决？

• JSP的指令

  • 指令的作用：指导JSP的翻译引擎如何工作（指导当前的JSP翻译引擎如何翻译JSP文件。）

  • 指令包括哪些呢？

    • include指令：包含指令，在JSP中完成静态包含，很少用了。（这里不讲）
    • taglib指令：引入标签库的指令。这个到JJSTL标签库的时候再学习。现在先不管。
    • page指令：目前重点学习一个page指令。

  • 指令的使用语法是什么？

    • <%@指令名 属性名=属性值 属性名=属性值 属性名=属性值…%>

  • 关于page指令当中都有哪些常用的属性呢？

    • <%@page session="true|false" %>
      true表示启用JSP的内置对象session，表示一定启动session对象。没有session对象会创建。
      如果没有设置，默认值就是session="true"
      session="false" 表示不启动内置对象session。当前JSP页面中无法使用内置对象session。
      

    • <%@page contentType="text/json" %>
      contentType属性用来设置响应的内容类型
      但同时也可以设置字符集。
      <%@page contentType="text/json;charset=UTF-8" %>
      

    • <%@page pageEncoding="UTF-8" %>
      pageEncoding="UTF-8" 表示设置响应时采用的字符集。
      

    • <%@page import="java.util.List, java.util.Date, java.util.ArrayList" %>
      <%@page import="java.util.*" %>
      import语句，导包。
      

    • <%@page errorPage="/error.jsp" %>
      当前页面出现异常之后，跳转到error.jsp页面。
      errorPage属性用来指定出错之后的跳转位置。
      

    • <%@page isErrorPage="true" %>
      表示启用JSP九大内置对象之一：exception
      默认值是false。
      

• JSP的九大内置对象

  • jakarta.servlet.jsp.PageContext pageContext 页面作用域

  • jakarta.servlet.http.HttpServletRequest request 请求作用域

  • jakarta.servlet.http.HttpSession session 会话作用域

  • jakarta.servlet.ServletContext application 应用作用域

    • pageContext < request < session < application
    • 以上四个作用域都有：setAttribute、getAttribute、removeAttribute方法。
    • 以上作用域的使用原则：尽可能使用小的域。

  • java.lang.Throwable exception

  • jakarta.servlet.ServletConfig config

  • java.lang.Object page （其实是this，当前的servlet对象）

  • jakarta.servlet.jsp.JspWriter out （负责输出）

  • jakarta.servlet.http.HttpServletResponse response （负责响应）

2.0EL表达式

• EL表达式是干什么用的？

  • Expression Language（表达式语言）
  • EL表达式可以代替JSP中的java代码，让JSP文件中的程序看起来更加整洁，美观。
  • JSP中夹杂着各种java代码，例如<% java代码 %>、<%=%>等，导致JSP文件很混乱，不好看，不好维护。所以才有了后期的EL表达式。
  • EL表达式可以算是JSP语法的一部分。EL表达式归属于JSP。

• EL表达式出现在JSP中主要是：

  • 从某个作用域中取数据，然后将其转换成字符串，然后将其输出到浏览器。这就是EL表达式的功效。三大功效：
    • 第一功效：从某个域中取数据。
      • 四个域：
        • pageContext
        • request
        • session
        • application
    • 第二功效：将取出的数据转成字符串。
      • 如果是一个java对象，也会自动调用java对象的toString方法将其转换成字符串。
    • 第三功效：将字符串输出到浏览器。
      • 和这个一样：<%= %>，将其输出到浏览器。

• EL表达式很好用，基本的语法格式：

  • ${表达式}

• EL表达式的使用：

  • <%
    	// 创建User对象
    	User user = new User();
    	user.setUsername("jackson");
    	user.setPassword("1234");
    	user.setAge(50);
    
    	// 将User对象存储到某个域当中。一定要存，因为EL表达式只能从某个范围中取数据。
    	// 数据是必须存储到四大范围之一的。
    	request.setAttribute("userObj", user);
    %>
    
    <%--使用EL表达式取--%>
    ${这个位置写什么？？？？这里写的一定是存储到域对象当中时的name}
    要这样写：
    ${userObj}
    等同于java代码：<%=request.getAttribute("userObj")%>
    你不要这样写：${"userObj"}
    
    面试题：
    	${abc} 和 ${"abc"}的区别是什么？
    		${abc}表示从某个域中取出数据，并且被取的这个数据的name是"abc"，之前一定有这样的代码: 域.setAttribute("abc", 对象);
    		${"abc"} 表示直接将"abc"当做普通字符串输出到浏览器。不会从某个域中取数据了。
    
    ${userObj} 底层是怎么做的？从域中取数据，取出user对象，然后调用user对象的toString方法，转换成字符串，输出到浏览器。
    
    <%--如果想输出对象的属性值，怎么办？--%>
    ${userObj.username} 使用这个语法的前提是：User对象有getUsername()方法。
    ${userObj.password} 使用这个语法的前提是：User对象有getPassword()方法。
    ${userObj.age} 使用这个语法的前提是：User对象有getAge()方法。
    ${userObj.email} 使用这个语法的前提是：User对象有getEmail()方法。
    EL表达式中的. 这个语法，实际上调用了底层的getXxx()方法。
    注意：如果没有对应的get方法，则出现异常。报500错误。
    
    ${userObj.addr222.zipcode}
    以上EL表达式对应的java代码：
    user.getAddr222().getZipcode()
    

  • EL表达式优先从小范围中读取数据。

    • pageContext < request < session < application

  • EL表达式中有四个隐含的隐式的范围：

    • pageScope 对应的是 pageContext范围。
    • requestScope 对应的是 request范围。
    • sessionScope 对应的是 session范围。
    • applicationScope 对应的是 application范围。

  • EL表达式对null进行了预处理。如果是null，则向浏览器输出一个空字符串。

  • EL表达式取数据的时候有两种形式：

    • 第一种：. （大部分使用这种方式）
    • 第二种：[ ] （如果存储到域的时候，这个name中含有特殊字符，可以使用 [ ]）
      • request.setAttribute(“abc.def”, “zhangsan”);
      • ${requestScope.abc.def} 这样是无法取值的。
      • 应该这样：${requestScope[“abc.def”]}

  • 掌握使用EL表达式，怎么从Map集合中取数据：

    • ${map.key}

  • 掌握使用EL表达式，怎么从数组和List集合中取数据：

    • ${数组[0]}
    • ${数组[1]}
    • ${list[0]}

  • page指令当中，有一个属性，可以忽略EL表达式

    • <%@page contentType="text/html;charset=UTF-8" isELIgnored="true" %>
      isELIgnored="true" 表示忽略EL表达式
      isELIgnored="false" 表示不忽略EL表达式。（这是默认值）
      
      isELIgnored="true" 这个是全局的控制。
      
      可以使用反斜杠进行局部控制：\${username} 这样也可以忽略EL表达式。
      

  • 通过EL表达式获取应用的根：

    • ${pageContext.request.contextPath}

  • EL表达式中其他的隐式对象：

    • pageContext
    • param
    • paramValues
    • initParam

  • EL表达式的运算符

    • 算术运算符
      • +、-、*、/、%
    • 关系运算符
      • == eq != > >= < <=
    • 逻辑运算符
      • ! && || not and or
    • 条件运算符
      • ? :
    • 取值运算符
      • [ ]和.
    • empty运算符
      • empty运算符的结果是boolean类型
      • ${empty param.username}
      • ${not empty param.username}
      • ${!empty param.password}

2.1JSTL标签库

• 什么是JSTL标签库？

  • Java Standard Tag Lib（Java标准的标签库）
  • JSTL标签库通常结合EL表达式一起使用。目的是让JSP中的java代码消失。
  • 标签是写在JSP当中的，但实际上最终还是要执行对应的java程序。（java程序在jar包当中。）

• 使用JSTL标签库的步骤：

  • 第一步：引入JSTL标签库对应的jar包。

    • tomcat10之后引入的jar包是：
      • jakarta.servlet.jsp.jstl-2.0.0.jar
      • jakarta.servlet.jsp.jstl-api-2.0.0.jar
    • 在IDEA当中怎么引入？
      • 在WEB-INF下新建lib目录，然后将jar包拷贝到lib当中。然后将其“Add Lib…”
      • 一定是要和mysql的数据库驱动一样，都是放在WEB-INF/lib目录下的。
      • 什么时候需要将jar包放到WEB-INF/lib目录下？如果这个jar是tomcat服务器没有的。

  • 第二步：在JSP中引入要使用标签库。（使用taglib指令引入标签库。）

    • JSTL提供了很多种标签，你要引入哪个标签？？？？重点掌握核心标签库。

    • <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
      这个就是核心标签库。
      prefix="这里随便起一个名字就行了，核心标签库，大家默认的叫做c，你随意。"
      

  • 第三步：在需要使用标签的位置使用即可。表面使用的是标签，底层实际上还是java程序。

• JSTL标签的原理

  • <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    以上uri后面的路径实际上指向了一个xxx.tld文件。
    tld文件实际上是一个xml配置文件。
    在tld文件中描述了“标签”和“java类”之间的关系。
    以上核心标签库对应的tld文件是：c.tld文件。它在哪里。
    在jakarta.servlet.jsp.jstl-2.0.0.jar里面META-INF目录下，有一个c.tld文件。
    

  • 源码解析：配置文件tld解析

    • 
          对该标签的描述
          catch 标签的名字
          org.apache.taglibs.standard.tag.common.core.CatchTag 标签对应的java类。
          JSP 标签体当中可以出现的内容，如果是JSP，就表示标签体中可以出现符合JSP所有语法的代码。例如EL表达式。
          
              
              	对这个属性的描述
              
              var 属性名
              false false表示该属性不是必须的。true表示该属性是必须的。
              false 这个描述说明了该属性是否支持EL表达式。false表示不支持。true表示支持EL表达式。
          
        
      
      
      	JSP....
      
      

  • jstl中的核心标签库core当中有哪些常用的标签呢？

    • c:if

    • c:forEach

      • ${元素状态对象.count}
      • ${i}

    • c:choose c:when c:otherwise

      • 
            
                青少年
            
            
                青年
            
            
                中年
            
            
                老年
            
        
        

2.2Filter过滤器

• Filter是什么，有什么用，执行原理是什么？

  • Filter是过滤器。
  • Filter可以在Servlet这个目标程序执行之前添加代码。也可以在目标Servlet执行之后添加代码。之前之后都可以添加过滤规则。
  • 一般情况下，都是在过滤器当中编写公共代码。

• 一个过滤器怎么写呢？

  • 第一步：编写一个Java类实现一个接口：jarkata.servlet.Filter。并且实现这个接口当中所有的方法。

    • init方法：在Filter对象第一次被创建之后调用，并且只调用一次。
    • doFilter方法：只要用户发送一次请求，则执行一次。发送N次请求，则执行N次。在这个方法中编写过滤规则。
    • destroy方法：在Filter对象被释放/销毁之前调用，并且只调用一次。

  • 第二步：在web.xml文件中对Filter进行配置。这个配置和Servlet很像。

    • 
          filter2
          com.bjpowernode.javaweb.servlet.Filter2
      
      
          filter2
          *.do
      
      

    • 或者使用注解：@WebFilter({“*.do”})

• 注意：

  • Servlet对象默认情况下，在服务器启动的时候是不会新建对象的。
  • Filter对象默认情况下，在服务器启动的时候会新建对象。
  • Servlet是单例的。Filter也是单例的。（单实例。）

• 目标Servlet是否执行，取决于两个条件：

  • 第一：在过滤器当中是否编写了：chain.doFilter(request, response); 代码。
  • 第二：用户发送的请求路径是否和Servlet的请求路径一致。

• chain.doFilter(request, response); 这行代码的作用：

  • 执行下一个过滤器，如果下面没有过滤器了，执行最终的Servlet。

• 注意：Filter的优先级，天生的就比Servlet优先级高。

  • /a.do 对应一个Filter，也对应一个Servlet。那么一定是先执行Filter，然后再执行Servlet。

• 关于Filter的配置路径：

  • /a.do、/b.do、/dept/save。这些配置方式都是精确匹配。
  • /* 匹配所有路径。
  • *.do 后缀匹配。不要以 / 开始
  • /dept/* 前缀匹配。

• 在web.xml文件中进行配置的时候，Filter的执行顺序是什么？

  • 依靠filter-mapping标签的配置位置，越靠上优先级越高。

• 过滤器的调用顺序，遵循栈数据结构。

• 使用@WebFilter的时候，Filter的执行顺序是怎样的呢？

  • 执行顺序是：比较Filter这个类名。
  • 比如：FilterA和FilterB，则先执行FilterA。
  • 比如：Filter1和Filter2，则先执行Filter1.

• Filter的生命周期？

  • 和Servlet对象生命周期一致。
  • 唯一的区别：Filter默认情况下，在服务器启动阶段就实例化。Servlet不会。

• Filter过滤器这里有一个设计模式：

  • 责任链设计模式。
  • 过滤器最大的优点：
    • 在程序编译阶段不会确定调用顺序。因为Filter的调用顺序是配置到web.xml文件中的，只要修改web.xml配置文件中filter-mapping的顺序就可以调整Filter的执行顺序。显然Filter的执行顺序是在程序运行阶段动态组合的。那么这种设计模式被称为责任链设计模式。
  • 责任链设计模式最大的核心思想：
    • 在程序运行阶段，动态的组合程序的调用顺序。

• 使用过滤器改造OA项目。

2.3Listener监听器

• 什么是监听器？

  • 监听器是Servlet规范中的一员。就像Filter一样。Filter也是Servlet规范中的一员。
  • 在Servlet中，所有的监听器接口都是以“Listener”结尾。

• 监听器有什么用？

  • 监听器实际上是Servlet规范留给我们javaweb程序员的特殊时机。
  • 特殊的时刻如果想执行这段代码，你需要想到使用对应的监听器。

• Servlet规范中提供了哪些监听器？

  • jakarta.servlet包下：
    • ServletContextListener
    • ServletContextAttributeListener
    • ServletRequestListener
    • ServletRequestAttributeListener
  • jakarta.servlet.http包下：
    • HttpSessionListener
    • HttpSessionAttributeListener
      • 该监听器需要使用@WebListener注解进行标注。
      • 该监听器监听的是什么？是session域中数据的变化。只要数据变化，则执行相应的方法。主要监测点在session域对象上。
    • HttpSessionBindingListener
      • 该监听器不需要使用@WebListener进行标注。
      • 假设User类实现了该监听器，那么User对象在被放入session的时候触发bind事件，User对象从session中删除的时候，触发unbind事件。
      • 假设Customer类没有实现该监听器，那么Customer对象放入session或者从session删除的时候，不会触发bind和unbind事件。
    • HttpSessionIdListener
      • session的id发生改变的时候，监听器中的唯一一个方法就会被调用。
    • HttpSessionActivationListener
      • 监听session对象的钝化和活化的。
      • 钝化：session对象从内存存储到硬盘文件。
      • 活化：从硬盘文件把session恢复到内存。

• 实现一个监听器的步骤：以ServletContextListener为例。

  • 第一步：编写一个类实现ServletContextListener接口。并且实现里面的方法。

    • void contextInitialized(ServletContextEvent event)
      void contextDestroyed(ServletContextEvent event)
      

  • 第二步：在web.xml文件中对ServletContextListener进行配置，如下：

    • 
          com.bjpowernode.javaweb.listener.MyServletContextListener
      
      

    • 当然，第二步也可以不使用配置文件，也可以用注解，例如：@WebListener

• 注意：所有监听器中的方法都是不需要javaweb程序员调用的，由服务器来负责调用？什么时候被调用呢？

  • 当某个特殊的事件发生（特殊的事件发生其实就是某个时机到了。）之后，被web服务器自动调用。

• 思考一个业务场景：

  • 请编写一个功能，记录该网站实时的在线用户的个数。
  • 我们可以通过服务器端有没有分配session对象，因为一个session代表了一个用户。有一个session就代表有一个用户。如果你采用这种逻辑去实现的话，session有多少个，在线用户就有多少个。这种方式的话：HttpSessionListener够用了。session对象只要新建，则count++，然后将count存储到ServletContext域当中，在页面展示在线人数即可。
  • 业务发生改变了，只统计登录的用户的在线数量，这个该怎么办？
    • session.setAttribute(“user”, userObj);
    • 用户登录的标志是什么？session中曾经存储过User类型的对象。那么这个时候可以让User类型的对象实现HttpSessionBindingListener监听器，只要User类型对象存储到session域中，则count++，然后将count++存储到ServletContext对象中。页面展示在线人数即可。

• 实现oa项目中当前登录在线的人数。

  • 什么代表着用户登录了？
    • session.setAttribute(“user”, userObj); User类型的对象只要往session中存储过，表示有新用户登录。
  • 什么代表着用户退出了？
    • session.removeAttribute(“user”); User类型的对象从session域中移除了。
    • 或者有可能是session销毁了。（session超时）

nt event)
void contextDestroyed(ServletContextEvent event)
```

• 第二步：在web.xml文件中对ServletContextListener进行配置，如下：

  • 
        com.bjpowernode.javaweb.listener.MyServletContextListener
    
    

  • 当然，第二步也可以不使用配置文件，也可以用注解，例如：@WebListener

• 注意：所有监听器中的方法都是不需要javaweb程序员调用的，由服务器来负责调用？什么时候被调用呢？

  • 当某个特殊的事件发生（特殊的事件发生其实就是某个时机到了。）之后，被web服务器自动调用。

• 思考一个业务场景：

  • 请编写一个功能，记录该网站实时的在线用户的个数。
  • 我们可以通过服务器端有没有分配session对象，因为一个session代表了一个用户。有一个session就代表有一个用户。如果你采用这种逻辑去实现的话，session有多少个，在线用户就有多少个。这种方式的话：HttpSessionListener够用了。session对象只要新建，则count++，然后将count存储到ServletContext域当中，在页面展示在线人数即可。
  • 业务发生改变了，只统计登录的用户的在线数量，这个该怎么办？
    • session.setAttribute(“user”, userObj);
    • 用户登录的标志是什么？session中曾经存储过User类型的对象。那么这个时候可以让User类型的对象实现HttpSessionBindingListener监听器，只要User类型对象存储到session域中，则count++，然后将count++存储到ServletContext对象中。页面展示在线人数即可。

• 实现oa项目中当前登录在线的人数。

  • 什么代表着用户登录了？
    • session.setAttribute(“user”, userObj); User类型的对象只要往session中存储过，表示有新用户登录。
  • 什么代表着用户退出了？
    • session.removeAttribute(“user”); User类型的对象从session域中移除了。
    • 或者有可能是session销毁了。（session超时）