动力节点Java Web知识笔记

最新推荐文章于 2024-05-05 13:57:09 发布
最新推荐文章于 2024-05-05 13:57:09 发布
阅读量959 收藏 27
点赞数 21
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64897866/article/details/136750140
版权

前言

servlet

系统架构

c/s架构

  • 全称：Client/Server(客户端/服务器)

  • 代表：QQ

  • 特点：需要安装特定的客户端软件

  • 优缺点

    • 优点

      • 速度快（因为大量数据集成在客户端软件，服务器端只用传输少量数据）

      • 服务器压力小（理由同上，因为服务器传输数据少，所以压力小）

      • 界面酷炫（有专门的语言实现，更加灵活）

      • 数据安全（大量数据在客户端有缓存，服务器故障对其影响较小，并且有多个客户端）

    • 缺点

      • 难升级维护

        • 每个客户端软件都需要升级维护

        • 有些软件不易安装

        • 成本高

  • 适用场景：娱乐性软件

b/s架构

  • 全称：Browser/Server(浏览器/服务器)

  • 特点

    • 本质上是一个特殊的c/s架构,只不过client是个浏览器软件

    • 开发b/s系统其实就是开发一个网站（web系统）

  • 优缺点

    • 优点

      • 易升级维护，成本低（只需要升级服务器端即可）

      • 不需要安装特定的客户端软件，用户操作方便（只需打开浏览器输入网址即可）

    • 缺点

      • 速度慢（所有数据都是在服务器上的，用户发送的每个请求都需要服务器响应数据，传输的数据量大）

      • 体验差（界面不酷炫，浏览器只支持html，css，js，而且速度慢）

      • 不安全（数据都在服务器上，服务器出故障会导致数据丢失）

  • 适用场景

    • 公司内部的业务软件

      • 需要维护成本低

      • 不追求界面酷炫

      • 使用的企业级系统主要能够进行数据的维护即可

  • 需要的技术

    • web前端（三剑客）

    • web后端（服务器端）

      • 多种编程语言都可以

      • java（javaWEB开发最核心规范：Servlet【Server Applet服务器端的Java小程序】）

      • Servlet是javaEE（WEB方向/系统）规范之一

b/s结构通信原理

域名

  • 百度一下，你就知道是网址

  • www.baidu.com是域名

  • 浏览器输入域名回车之后，域名解析器会将其解析成一个具体的IP地址和端口号等等

    • 解析结果百度一下，你就知道（百度服务器ip地址）:80（该服务器上某个软件）/index.html（资源路径）

    • IP地址

      • 相当于计算机在网络中的身份证号（唯一标识），同一网络中，IP地址唯一

      • A计算机要想和B计算机通信，首先你需要知道B计算机的IP地址，有了IP地址才能建立连接

      • 用于定位计算机/服务器

    • 端口号

      • 一个端口代表一个软件、一个服务

      • 计算机中每个软件启动后都有一个端口号

      • 同一计算机上，端口号具有唯一性

web系统通信原理/步骤（以百度浏览器为例）

  1. 用户输入网址（URL）

  2. 域名解析器进行域名解析（解析出IP地址和端口号）：百度一下，你就知道

  3. 浏览器软件在网络中搜索110.242.68.3（IP地址）这一台主机，直到找到这台主机

  4. 定位110.242.68.3这台主机上的服务器软件，定位到80端口对应的服务器软件

  5. 80端口对应的服务器软件得知浏览器想要的资源名：index.html

  6. 服务器软件找到index.html文件，并且将index.html文件中的内容直接输出响应到浏览器上

    • 请求和响应实际上说的是数据的流向不同

      • 请求（request）：从b端（浏览器）发送数据到s端（服务器）

      • 响应（response）：从s端发送数据到b端

  7. 浏览器接收到来自服务器的代码（HTML CSS JS），浏览器渲染，执行HTML CSS JS代码，展示效果

image-20221224133346309

web服务器软件

包括

  • Tomcat（WEB服务器）【apache】

    • tomcat开源免费的轻量级WEB服务器。

    • 体积小，运行速度快，只实现了Servlet+JSP规范

    • tomcat是java语言写的，Tomcat服务器要想运行，需要先有jre，所以要先安装JDK，配置java运行环境。

  • jetty（WEB服务器）

  • JBOSS（应用服务器）【内嵌tomcat服务器】

  • WebLogic（应用服务器）

  • WebSphere（应用服务器）

  • 应用服务器和web服务器的关系

    • 应用服务器实现了javaee的所有规范（13个）

    • WEB服务器只实现了JavaEE中的Servlet + JSP两个核心的规范（体积比较小）

    • 应用服务器包含web服务器

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文件

启动Tomcat

  • bin目录下有一个文件：startup.bat,通过它可以启动Tomcat服务器

    • 分析startup.bat文件得出，执行这个命令，实际上最后是执行：catalina.bat文件

    • catalina.bat文件中有这样一行配置：MAINCLASS=org.apache.catalina.startup.Bootstrap （这个类就是main方法所在的类）

    • tomcat服务器就是Java语言写的，启动Tomcat服务器就是执行main方法

  • tomcat服务器提供了bat和sh文件，说明了这个tomcat服务器的通用性(在windows和linux系统都能使用)

    • bat文件是windows操作系统专用的，bat文件是批处理文件，这种文件中可以编写大量的windows的dos命令，然后执行bat文件就相当于批量的执行dos命令

    • startup.sh，这个文件在windows当中无法执行，在Linux环境当中可以使用。在Linux环境下能够执行的是shell命令，大量的shell命令编写在shell文件当中，然后执行这个shell文件可以批量的执行shell命令

关闭tomcat

  • shutdown.bat

  • 建议shutdown.bat重命名为stop.bat，因为：

    • shutdown命令和windows中的关机命令冲突

    • 关闭服务器只能写全命令，.bat不能省略，而startup可以省略

配置tomcat的环境变量

  • JAVA_HOME=JDK的根

  • CATALINA_HOME=Tomcat服务器的根

  • PATH=①%JAVA_HOME%\bin;②%CATALINA_HOME%\bin；

    • %%：把变量的值取出来，即取出目录

测试tomcat启动成功

  • 浏览器输入相应url：http://ip地址:端口号

    • 端口号：8080

    • IP地址：本机的IP地址是127.0.0.1,或者是localhost

网页资源

  • 一个路径代表一个资源：可能是静态资源，也可能是动态资源（java小程序）

    • 静态：页面中的数据是写死在HTML文件当中的，称为静态资源

    • 动态：需要连接数据库。编写Java程序（jdbc）连接数据库，数据库中有多少条记录，页面上就显示多少条记录，这种技术被称为动态网页技术（动态网页技术指数据是动态的，根据数据库中数据的变化而变化）

  • 后端执行哪个java小程序取决于前端浏览器发送的请求路径，一个路径对应一个servlet程序

  • 请求路径和Java小程序之间有对应关系，该关系由webapp开发者（java程序员）提供

    • 通过指定配置文件，在文件中描述请求路径和servlet之间的对照关系

    • tomcat服务器解析配置文件，找到资源

image-20221231165854546

通过超链接访问同一项目的其它资源

  • 绝对路径

<!--以/开始，带项目名，是一个绝对路径。不需要添加：http://127.0.0.1:8080-->
<a href="/oa(项目名)/login.html">user login2</a>
<!--多个层级-->
<!--注意：我们目前前端上的路径都以“/”开始的，都是加项目名的-->
<a href="/oa/test/debug/d.html">d page</a>

  • 相对路径（及不以'/'开头）

    • 起始就是发起跳转的文件的所在路径（相对的就是当前文件所在的路径的前缀）

b/s角色和协议

image-20230102210834126

角色

  • 浏览器软件开发商

  • WEB Server（服务器）的开发团队

  • DB Server（数据库）的开发团队

  • webapp的开发团队（WEB应用是我们做为JavaWEB程序员开发的）

    • 编写一个类实现Servlet接口

    • 将该类配置到配置文件中，指定请求路径和类名的对应关系

      • 因为tomcat服务器已经写好了，所以配置文件文件名和路径有要求

角色和角色之间的协议和规范

  • webapp的开发团队 和 WEB Server的开发团队之间===》 JavaEE规范之一Servlet规范

    • 作用：WEB Server 和 webapp解耦合

      • 耦合：两个子系统（或类）之间的关联程度

        • 当一个子系统（或类）发生变化时对另一个子系统（或类）的影响很小，则称它们是松散耦合的

        • 反之，如果变化的影响很大时，则称它们是紧密耦合的

    • 遵循Servlet规范的webapp，可以放在不同的WEB服务器中运行

    • 包括

      • 规范了哪些接口、类、配置文件

      • 规范了一个web应用中配置文件的名字、存放的路径以及内容（请求路径和Servlet类的对应关系）

      • 规范了一个合法有效的web应用的目录结构

  • Browser 和 WebServer之间有一套传输协议：HTTP协议（超文本传输协议）

  • webapp开发团队 和 DB Server的开发团队之间===》JDBC规范

image-20230102212438269

开发Servlet程序

!!!开发一个带有Servlet（Java小程序）的webapp!!!

  • 步骤

    • 第一步：在webapps目录下新建一个目录，起名crm（crm就是webapp的名字）

      • crm就是这个webapp的根

      • 命名非强制

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

      • 命名是Servlet规范中规定的，必须全部大写

    • 第三步：在WEB-INF目录下新建如下目录和文件

      1. classes

      • 注意：命名必须是全部小写的classes，这是Servlet规范中规定的

      • 这个目录下一定存放的是Java程序编译之后的class文件（字节码文件）

      1. lib

      • 不是必须的。但如果一个webapp需要第三方的jar包的话，这个jar包要放到这个lib目录下，这个目录的名字必须是全部小写的lib

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

      1. 新建文件：web.xml

      • 是必须的，文件名必须叫做web.xml，必须放在这里

      • 本质是一个配置文件，在这个配置文件中描述了请求路径和Servlet类之间的对照关系

      • 最好从其他的webapp中拷贝

      • <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
                      https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
  version="5.0"
  metadata-complete="true">
</web-app>

    • 第四步：编写一个Java程序，必须实现Servlet接口

      • 这个Servlet接口不在JDK当中（Servlet属于JavaEE，是另外的一套类库）

      • Servlet接口（Servlet.class文件）是Oracle提供的（最原始的是sun公司提供的）

      • Tomcat服务器实现了Servlet规范，所以Tomcat服务器也需要使用Servlet接口。Tomcat服务器的CATALINA_HOME\lib目录下有一个servlet-api.jar，解压这个servlet-api.jar之后，里面有一Servlet.class文件

      • 重点：从JakartaEE9开始，Servlet接口的全名变为jakarta.servlet.Servlet（tomcat10之后的版本不能运行javax）

      • 注意：编写这个Java小程序的时候，java源代码位置无所谓，只需要将java源代码编译之后的class文件放到classes目录即可

    • 第五步：编译我们编写的HelloServlet

      • 重点：怎么能让HelloServlet编译通过--配置环境变量CLASSPATH

        CLASSPATH=.;C:\dev\apache-tomcat-10.0.12\lib\servlet-api.jar

      • 以上配置的CLASSPATH和Tomcat服务器运行没有任何关系，该环境变量只是为了能够正常编译生成class文件

    • 第六步：将以上编译之后的HelloServlet.class文件拷贝到WEB-INF\classes目录下

    • 第七步：在web.xml文件中编写配置信息，让“请求路径”和“Servlet类名”关联在一起

      • 这一步用专业术语描述：在web.xml文件中注册Servlet类

      • <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
                      https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
  version="5.0"
  metadata-complete="true">
	<!--servlet描述信息-->
	<!--任何一个servlet都对应一个servlet-mapping -->
	<servlet>
		<servlet-name>fdsafdsagfdsafdsa</servlet-name>
		<servlet-class>com.bjpowernode.servlet.HelloServlet</servlet-class>
        <!--这个位置必须是带有包名的 全限定类名,最好是复制-->
	</servlet>
	<!--servlet映射信息-->
	<servlet-mapping>
		<servlet-name>fdsafdsagfdsafdsa</servlet-name>
        <!--这个命名要和上面的内容一致-->
		<url-pattern>/fdsa/fd/saf/d/sa/fd/sa/fd</url-pattern>
        <!--这里需要一个路径-->
		<!--这个路径唯一的要求是必须以 / 开始-->
		<!--当前这个路径可以随便写-->
	</servlet-mapping>
</web-app>

      • 可以在<servlet><servlet>中配置servlet对象初始化信息等等

      image-20230108114825303

    • 第八步：启动Tomcat服务器，在浏览器地址栏上输入一个url，这个URL必须是：

    • 浏览器上的请求路径必须和web.xml文件中的url-pattern一致

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

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

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

  • 总结一下：一个合法的webapp目录结构

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

  • 浏览器发送请求大致过程（以http://127.0.0.1:8080/crm/fdsa/fd/saf/d/sa/fd/sa/fd 为例）

    • 用户输入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

      • 通过反射机制，创建对应的Servlet的对象

      • 调用该对象的方法

  • 输出字符串

    • 输出到浏览器：response.getWriter()获取输出流对象

      • 该对象由tomcat服务器维护，不需要自行刷新和关闭

      • 对象.print方法输出到浏览器

      • 浏览器可以识别html代码，因此可以输出一段html代码，前提是要设置响应内容类型

        response.setContentType("text/html");
//设置相应的内容类型是普通文本和html代码，设置响应的内容必须要在获取流之前

    • 输出到控制台：System.out.....

      • 解决Tomcat服务器在DOS命令窗口中的乱码问题（控制台乱码）

        • 将CATALINA_HOME/conf/logging.properties的内容修改成：java.util.logging.ConsoleHandler.encoding = GBK

Servlet中连接数据库

  • servlet是Java程序，可以直接编写java代码（jdbc）连接数据库

  • 在一个webapp中去连接数据库，需要将驱动jar包放到WEB-INF/lib目录下（com.mysql.cj.jdbc.Driver类就在驱动jar包中）

在集成开发环境（idea）中开发Servlet程序

  • 第一步：New Project，这个Empty Project起名为：javaweb（非必须，一般情况下新建的Project的名字最好和目录的名字一致）

  • 第二步：新建模块（File --> new --> Module...）

    • 这里新建的是一个普通的JavaSE模块

    • 这个Module自动会被放在javaweb的project下面

  • 第三步：让Module变成JavaEE的模块（webapp的模块，符合Servlet规范的Module）

    • 在Module上点击右键：Add Framework Support...（添加框架支持）

    • 在弹出的窗口中，选择Web Application（选择的是webapp的支持）

    • IDEA会自动给你生成一个符合Servlet规范的webpp目录结构

    • 重点，需要注意的：在IDEA工具中根据Web Application模板生成的目录中有一个web目录，这个目录就代表webapp的根

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

    • IDEA工具右上角，绿色小锤子右边有一个：Add Configuration

    • 左上角加号，点击Tomcat Server --> local

    • 设置服务器Server的参数（基本上不用动）

      • vm options配置虚拟机

      • after launch勾选表示启动服务器默认打开浏览器

      • on update action更新源代码执行的操作

      • on frame deactivation光标离开idea执行的操作

    • 在当前窗口中有一个Deployment（用来部署webapp），继续点击加号，部署即可

    • 修改 Application context（webapp的根，也就是项目名称）

  • 第五步：编写Servlet类

    • 要继承Servlet接口

    • 将CATALINA_HOME/lib/servlet-api.jar和jsp-api.jar添加到classpath（IDEA的classpath）

      • File --> Project Structrue --> Modules --> + 加号 --> Add JARS....

    • 实现jakarta.servlet.Servlet接口中的5个方法（tomcat10之前的是javax不是jakarta）

  • 第六步：在WEB-INF目录下新建一个子目录：lib（这个目录名必须是全部小写的lib），并且将连接数据库的驱动jar包放到lib目录下

  • 第七步：在Servlet当中的service方法中编写业务代码

  • 第八步：在web.xml文件中完成StudentServlet类的注册（请求路径和Servlet之间对应起来）

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>studentServlet</servlet-name>
        <servlet-class>com.bjpowernode.javaweb.servlet.StudentServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>studentServlet</servlet-name>
        <url-pattern>/servlet/student</url-pattern>
    </servlet-mapping>
</web-app>

  • 第九步：新建一个HTML页面，里面编写一个超链接，点击这个超链接，发送请求，Tomcat执行后台的StudentServlet

    • 这个文件只能放到WEB-INF目录外面

    • student.html文件

    • <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>student page</title>
</head>
<body>
    <!--这里的项目名是 /xmm ，html是静态页面，无法动态获取-->
    <a href="/项目名称/servlet/student">student list</a>
</body>
</html>

  • 第十步：启动Tomcat服务器

    • 在右上角有绿色的箭头，或者绿色的小虫子

      • 点击绿色的小虫子，可以采用debug的模式启动Tomcat服务器

      • 开发中建议用debug模式启动Tomcat

  • 第十一步：打开浏览器，在浏览器地址栏上输入：http://localhost:8080/xmm/student.html

Servlet对象的生命周期相关

  • Servlet对象是由tomcat维护，其生命周期由tomcat服务器（通常又称为web容器【web container】）负责

  • WEB容器创建的Servlet对象会被放到一个集合当中（HashMap），只有在集合中的Servlet才能被WEB容器管理

  • web容器底层应该有一个HashMap这样的集合，当中存储了Servlet对象和请求路径之间的关系

image-20230106144929952

  • 自己创建的servlet对象是不受web容器管理（自己new的Servlet对象不在容器当中）

服务器启动

  • 默认情况下，服务器在启动时Servlet对象不会被实例化,原因：

    • 用户发送请求之前，如果提前创建出来所有的Servlet对象，必然是耗费内存的

    • 创建出来的Servlet如果一直没有用户访问就废了

  • 如何在服务器启动时创建servlet对象

    • 在servlet标签中添加<load-on-startup>子标签，在该子标签中填写整数（负数不行），越小的整数优先级越高

      <servlet>
    <servlet-name>aservlet</servlet-name>
    <servlet-class>com.bjpowernode.javaweb.servlet.AServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>aservlet</servlet-name>
    <url-pattern>/a</url-pattern>
</servlet-mapping>
！！！生命周期！！！

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

  • 用户在发送第一次请求时

    • Servlet对象被实例化（执行的是无参数构造方法，通过反射机制创建对象）

    • Servlet对象被创建出来之后，Tomcat服务器调用该对象的init方法（init方法执行时，Servlet对象已经被创建出来了）

    • init方法执行之后，Tomcat服务器调用Servlet对象的service方法

  • 用户之后发送多次请求的时候，还是使用之前创建好的Servlet对象（没有新建），直接调用该对象的service方法，说明：

    • 第一：Servlet对象是单例的（单实例的），多线程共享一个对象

      • 注意：Servlet对象是单实例的，但是Servlet类并不符合单例模式。我们称之为假单例。

        • 假单例是因为Servlet对象只能由Tomcat创建，Tomcat只创建了一个，导致了单例

        • 并且我们没有权限去创建对象，所以属于假单例

      • 真单例模式，构造方法是私有化的，这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象

        注意：

        • 1、单例类只能有一个实例

        • 2、单例类必须自己创建自己的唯一实例

        • 3、单例类必须给所有其他对象提供这一实例

    • 第二：无参数构造方法、init方法只在第一次用户发送请求的时候执行

      • 无参数构造方法只执行一次

      • init方法只被Tomcat服务器调用一次

    • 第三：只要用户发送一次请求，service方法必然会被Tomcat服务器调用一次（service方法可以多次被调用）

  • Servlet的destroy方法只被Tomcat服务器调用一次

    • destroy方法在服务器关闭时被调用

      • 因为服务器关闭的时候要销毁Servlet对象的内存

      • 服务器在销毁对象内存之前，Tomcat服务器会自动调用对象的destroy方法。

    • destroy方法执行的时候Servlet对象没有被销毁（因为destroy方法是实例对象的方法）destroy方法执行结束后，对象的内存才被Tomcat释放(自杀)

    • destory方法可以编写销毁前的准备（遗言）

Servlet类中各方法的调用次数

  • 构造方法、init方法（初始化）、destroy方法只执行一次

  • service方法：用户发送一次请求则执行一次，可执行多次

    • 处理用户请求的核心方法

Servlet类中编写一个有参数的构造方法，没有手动编写无参数构造方法会出现的问题

image-20230106164905724

  • 报错：500错误

    • 500是一个HTTP协议的错误状态码。

    • 500一般情况下是因为服务器端的Java程序出现了异常（服务器端的错误都是500错误：服务器内部错误）

  • 没有无参数的构造方法，会导致出现500错误，无法实例化Servlet对象

  • 在Servlet开发当中，不建议程序员来定义构造方法，定义不当会导致无法实例化Servlet对象

  • Servlet的无参数构造方法和init方法是在对象第一次创建的时候执行，并且只执行一次，但是无参数构造方法不能代替init方法

    • Servlet规范中要求，编写Servlet类的时候，不建议手动编写构造方法

    • 编写构造方法容易让无参数构造方法消失，可能会导致Servlet对象无法实例化。init方法是有存在的必要的

init、service、destroy方法中使用频率和使用情境

  • 使用最多就是service方法

    • service方法是一定要实现的，因为service方法是处理用户请求的核心方法

  • init方法很少用

    • 通常在init方法当中做初始化操作，并且这个初始化操作只需要执行一次

    • 例如：初始化数据库连接池，初始化线程池....

  • destroy方法也很少用

    • 通常在destroy方法当中，进行资源的关闭

    • 对象被销毁前，对未关闭/保存的资源进行关闭/保存

适配器设计模式改造servlet

Servlet类直接实现Servlet接口的缺点

  • 业务中只需要service方法，其他方法大部分情况下是不需要使用的，代码很丑陋

适配器设计模式Adapter的理解

  • 手机直接插到220V的电压上，手机直接就报废了怎么办？可以找一个充电器。这个充电器就是一个适配器。手机连接适配器。适配器连接220V的电压。这样问题就解决了

编写一个GenericServlet类

  • 是一个抽象类，其中有一个抽象方法service

  • GenericServlet实现Servlet接口

  • GenericServlet是一个适配器

  • 以后编写的所有Servlet类继承GenericServlet，重写service方法即可

改造GenericServlet类

  • 提供了一个GenericServlet之后，init方法还会执行,如果子类没有重写父类的init方法，就会执行GenericServlet类中的init方法

  • init方法是Tomcat服务器调用的

    • Tomcat服务器伪代码

      • public class Tomcat {
    public static void main(String[] args){
        // .....
        // Tomcat服务器伪代码
        // 创建LoginServlet对象（通过反射机制，调用无参数构造方法来实例化LoginServlet对象）
        Class clazz = Class.forName("com.bjpowernode.javaweb.servlet.LoginServlet");
        Object obj = clazz.newInstance();
        Servlet servlet = (Servlet)obj;// 向下转型
        
        /*创建ServletConfig对象
        Tomcat服务器负责将ServletConfig对象实例化出来。
        多态（Tomcat服务器完全实现了Servlet规范）*/
        ServletConfig servletConfig = new org.apache.catalina.core.StandardWrapperFacade();
        //父类型的引用                指向                             子类型对象
        // 调用Servlet的init方法
        servlet.init(servletConfig);
        // 调用Servlet的service方法
        // ....  
    }
}

  • init方法中的ServletConfig对象

    • 由Tomcat创建并且传过来

    • Tomcat服务器先创建了ServletConfig对象，然后调用init方法，将ServletConfig对象传给了init方法

      • init方法中的Servletconfig对象是局部变量

      • 可以声明一个成员变量config，将该局部变量赋值给成员变量（改造一）

      image-20230107160133526

      • getServletConfig方法返回该成员变量config，子类就可以通过该方法获取config对象

  • 子类重写的init方法

    • 问题：父类的init方法没调用会导致父类的成员变量config未被赋值

    • 解决（模板方法设计模式）

      1. 将父类的init方法final，使得子类无法重写（改造二）

      2. 然后父类中定义一个新的init方法（改造三），子类就可以重写init方法，并且也能完成父类的成员变量赋值

      image-20230107161442539

GenericServlet类已有现成的(tomcat提供的)
public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    private static final long serialVersionUID = 1L;//用于区分类
    private transient(游离) ServletConfig config;//transient修饰的变量不可以序列化
    public GenericServlet() {
    }
    public void destroy() {
    }
    public String getInitParameter(String name) {
        return this.getServletConfig().getInitParameter(name);
    }
    public Enumeration<String> getInitParameterNames() {
        return this.getServletConfig().getInitParameterNames();
    }
.....详情请通过idea ctrl+shift+N查看反编译代码
}

ServletConfig

定义、作用

  • Servlet对象的配置信息对象

  • 一个Servlet对应一个ServletConfig对象（一对一，不是多个servlet对象共享一个servletconfig对象）

  • ServletConfig对象中封装了<servlet></servlet>标签中的配置信息（web.xml文件中servlet的配置信息）

  • 可以获取<servlet></servlet>标签中的配置信息（初始化参数信息等等）

//遍历输出初始化参数信息 
Enumeration<String> initParameterNames = config.getInitParameterNames();
        while(initParameterNames.hasMoreElements()){
            String element = initParameterNames.nextElement();
            String initParameter = config.getInitParameter(element);
            writer.println(element+"  "+initParameter+"<br>");
        }
接口的实现和对象的创建

  • Servlet对象和ServletConfig对象都是Tomcat服务器创建。默认情况下，都是在发送第一次请求的时候被创建

    image-20230107233627064

    • Tomcat服务器调用Servlet对象的init方法的时候需要传一个ServletConfig对象的参数给init方法

    • ServletConfig接口的实现类是Tomcat服务器实现的

ServletConfig接口方法
  • public String getInitParameter(String name); // 通过初始化参数的name获取value
public Enumeration<String> getInitParameterNames(); // 获取所有的初始化参数的name集合
public ServletContext getServletContext(); // 获取ServletContext对象
public String getServletName(); // 获取Servlet的name

  • 以上方法在Servlet类中都可以用this（this指当前对象，前提是继承GenericServlet）去调用。因为GenericServlet实现了ServletConfig接口，所以不需要额外获取该对象

GenericServlet类中代码
public String getInitParameter(String name) {
    return this.getServletConfig().getInitParameter(name);
}
public Enumeration<String> getInitParameterNames() {
    return this.getServletConfig().getInitParameterNames();
}

ServletContext

获取

  1. 通过config对象调用getServletContext方法

  2. 因为GenericServlet实现了ServletConfig接口，所以可以直接用this调用获取

定义

  • 是servlet对象的环境/上下文对象

  • 对应的就是整个web.xml文件

  • Tomcat服务器中有一个webapps（容器），可以存放多个webapp，一个webapp对应一个ServletContext对象

  • 在同一个webapp当中，所有的Servlet对象共享同一个ServletContext对象

理解

  • 一个教室里有多个学生，这些学生都在同一个教室当中，在同一个教室当中，物品都是共享的

    • 每一个学生是一个Servlet

    • 这个教室就是一个ServletContext对象

    • 放在ServletContext对象中的数据，里面的所有Servlet是共享的（假设多个servlet想共享一个数据，可以把该数据放入ServletContext对象中）

接口的实现和对象的创建

  • servletContext接口由tomcat服务器实现

  • servletContext对象由tomcat服务器创建，在web服务器

    • 启动时创建

    • 关闭时销毁

！！！应用域！！！

  • ServletContext对象别名应用域

  • 服务器启动的时候，应用域就开启了

  • 如果所有的用户共享一份数据，并且这个数据很少被修改，且数据量小，可以将这些数据放到应用域中

    • ServletContext这个对象只有一个，只有共享的数据放进去才有意义

    • 数据量比较大的话，占用堆内存较多，并且这个对象的生命周期比较长，在服务器关闭时才会被销毁,从而会影响服务器的性能

    • 所有用户共享的数据，如果涉及到修改操作，必然会存在线程并发所带来的安全问题。所以放在ServletContext对象中的数据一般都是只读的

  • 数据量小、所有用户共享、不修改，这样的数据放到ServletContext这个应用域当中，会大大提升效率

    • 应用域相当于一个缓存，放到缓存中的数据，下次使用时不需要从数据库中再次获取，大大提升执行效率

    • 内存和硬盘文件交互需要IO流，IO流读硬盘数据（机械行为，通过硬盘中的磁针），获取的速度无法达到非常快

    • 高并发的系统频繁连接数据库性能会有问题

常用方法
获取context-param中的配置信息
public String getInitParameter(String name); // 通过初始化参数的name获取value
public Enumeration<String> getInitParameterNames(); // 获取所有的初始化参数的name
//遍历获取方式和servletconfig的一致
<context-param>
    <param-name>pageSize</param-name>
    <param-value>10</param-value>
</context-param>
<context-param>
    <param-name>startIndex</param-name>
    <param-value>0</param-value>
</context-param>

  • 以上的配置信息属于应用级的配置信息，一般一个项目中共享的配置信息会放到以上的标签中（相当于全局配置）

  • 如果配置信息只是给某个servlet作为参考，则配置到servlet标签当中，使用ServletConfig对象来获取（相当于局部配置）

  • 理解：公用垃圾桶和家用垃圾桶的区别

！！！获取应用的根路径（非常重要）！！！

  • 可以动态获取应用的根路径

  • java源码不要将应用的根路径写死，因为应用在最终部署的时候的命名可能有变动

public String getContextPath();
//String contextPath = application.getContextPath();
获取文件的绝对路径（真实路径）

  • path指该文件在该项目的相对路径，该路径前加不加/都可以

    • /代表web的根

    • 不加/也是默认从web的根开始找，所以加不加/不影响

public String getRealPath(String path);
public InputStream getResourceAsStream(String path);//获取资源，以流的形式返回（也可以通过路径获取流）
通过ServletContext对象可以记录日志(也可以通过框架)

  • 如果通过项目部署的方式，日志文件会被记录到CATALINA_HOME/Logs目录下

  • 使用idea，日志文件会被记录到idea相关目录下

    • 因为idea会创建多个tomcat副本

    • idea中的tomcat副本是参照本地的tomcat目录下的资源生成的

  • Tomcat服务器的logs目录下的日志文件

    • catalina.2021-11-05.log 服务器端的java程序运行的控制台信息

    • localhost.日期.log ServletContext对象的log方法记录的日志信息

    • localhost_access_log.日期.txt 访问日志

public void log(String message);// 这些日志信息记录到localhost.日期.log
public void log(String message, Throwable t);//记录异常信息

image-20230113162634034

image-20230113162655693

向应用域存取删数据
// 存（向ServletContext应用域中存数据）
public void setAttribute(String name, Object value); // map.put(k, v)
// 取（从ServletContext应用域中取数据）
public Object getAttribute(String name); // Object v = map.get(k)
// 删（删除ServletContext应用域中的数据）
public void removeAttribute(String name); // map.remove(k)

// 以上的操作类似于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这个键值对
缓存机制

  • 向ServletContext应用域中存储数据，也等于是将数据存放到缓存cache当中了

  • 堆内存中

    • 字符串常量池（待学习）

      • "abc" 先在字符串常量池中查找，有就直接拿来用

      • 没有则新建，然后再放入字符串常量池。

    • 整数型常量池（待学习，可能在打包那一块）

      • [-128 ~ 127] 一共256个Integer类型的引用，放在整数型常量池中（没有超出这个范围的话，直接从常量池中取）

  • 连接池(Connection Cache)（jdbc时可能会学到，待学习）

    • 这里所说的连接池中的连接是java语言连接数据库的连接对象：java.sql.Connection对象

    • 问题：JVM是一个进程，MySQL数据库是一个进程。进程和进程之间建立连接，打开通道是很费劲且很耗费资源的

    • 解决：可以提前先创建好N个Connection连接对象，将连接对象放到一个集合当中，放有Connection对象的集合称为连接池。每一次用户连接的时候不需要再新建连接对象，省去了新建的环节，直接从连接池中获取连接对象，大大提升访问效率

    • 连接池

      • 最小连接数

      • 最大连接数

      • 连接池可以提高用户的访问效率。当然也可以保证数据库的安全性。

  • 线程池（待学习，进线程）

    • Tomcat服务器本身支持多线程的

    • Tomcat服务器不是在用户发送一次请求，就新建一个Thread线程对象

      • 实际上是在Tomcat服务器启动的时候，会先创建好N多个线程Thread对象，然后将线程对象放到集合当中，称为线程池。用户发送请求过来之后，需要有一个对应的线程来处理这个请求，这个时候线程对象就会直接从线程池中拿，效率比较高。

      • 所有的WEB服务器，或者应用服务器，都是支持多线程的，都有线程池机制

  • 后期学习的缓存技术

    • redis

      • NoSQL数据库，非关系型数据库，缓存数据库

    • mongoDB

HTTP协议

协议

  • 协议实际上是某些人，或者某些组织提前制定好的一套规范，大家都按照这个规范来，这样可以做到沟通无障碍

  • 协议就是一套规范，就是一套标准

HTTP协议定义

  • 是W3C制定的一种超文本传输协议（通信协议：发送消息的模板提前被制定好）

    • W3C

      • 万维网联盟组织

      • 负责制定标准的：HTTP HTML4.0 HTML5 XML DOM等规范都是W3C制定的

      • 万维网之父：蒂姆·伯纳斯·李

    • 超文本

      • 即不是普通文本，比如流媒体：声音、视频、图片等

      • HTTP协议支持：不但可以传送普通字符串，同样支持传递声音、视频、图片等流媒体信息

    • 这种协议游走在B和S之间。B向S和S向B发数据都要遵循HTTP协议，这样B和S才能解耦合

      • 解耦合：S和B不互相依赖（前面有提过）

      • B/S表示：B/S结构的系统（浏览器访问WEB服务器的系统）

  • HTTP协议就是提前制定好的一种消息模板

    • 不论哪个品牌的浏览器/WEB服务器,都要按照模板

    • 浏览器不依赖具体的服务器品牌

    • WEB服务器也不依赖具体的浏览器品牌

HTTP协议包括

  • 发送的数据需要遵循一套标准，这套标准中规定了发送的数据具体格式

请求协议（B-->S）

  • 浏览器向WEB服务器发送数据，叫做：请求（request)

  • HTTP的请求协议包括：4部分

    • 请求行

      • 包括三部分：

        • 第一部分：请求方式（7种）

          • get（常用的）

          • post（常用的）

          • delete

          • put

          • head

          • options

          • trace

        • 第二部分：URI

          • URI: 统一资源标识符

            • 代表网络中某个资源的名字。但是通过URI是无法定位资源的（因为路径不全）

          • URL:统一资源定位符

            • 代表网络中某个资源，同时，通过URL是可以定位到该资源的

          • URI和URL的关系和区别

        • 第三部分：HTTP协议版本号

    • 请求头

      • 请求的主机

      • 主机的端口

      • 浏览器信息

      • 平台信息

      • cookie等信息

      • ....

    • 空白行

      • 空白行是用来区分“请求头”和“请求体”

    • 请求体

      • 向服务器发送的具体数据

  • HTTP请求协议的具体报文：GET请求

    • GET  /servlet05/getServlet?username=lucy&userpwd=1111  HTTP/1.1                         请求行
Host: localhost:8080                                                                    请求头
Connection: keep-alive
sec-ch-ua: "Google Chrome";v="95", "Chromium";v="95", ";Not A Brand";v="99"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Referer: http://localhost:8080/servlet05/index.html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
                                                                                        空白行
                                                                                        请求体

  • HTTP请求协议的具体报文：POST请求

    • POST /servlet05/postServlet HTTP/1.1                                                  请求行
Host: localhost:8080                                                                  请求头
Connection: keep-alive
Content-Length: 25
Cache-Control: max-age=0
sec-ch-ua: "Google Chrome";v="95", "Chromium";v="95", ";Not A Brand";v="99"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Upgrade-Insecure-Requests: 1
Origin: http://localhost:8080
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Referer: http://localhost:8080/servlet05/index.html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
                                                                                      空白行
username=lisi&userpwd=123                                                             请求体
响应协议（S-->B）

  • WEB服务器向浏览器发送数据，叫做：响应（response）

  • HTTP的响应协议包括：4部分

    • 状态行

      • 三部分组成

        • 第一部分：协议版本号（HTTP/1.1）

        • 第二部分：状态码（HTTP协议中规定的响应状态号，不同的响应结果对应不同的号码）

          • 200 表示请求响应成功，正常结束

          • 404表示访问的资源不存在，404错误是前端错误，通常是因为

            • 路径写错了

            • 路径写对了，但是服务器中对应的资源并没有启动成功

          • 405表示前端发送的请求方式与后端请求的处理方式不一致时发生

            • 比如：前端是POST请求，后端的处理方式按照get方式进行处理时，发生405（反之亦然）

          • 500表示服务器端的程序出现了异常。一般会认为是服务器端的错误导致的

          • 以4开始的，一般是浏览器端的错误导致的；以5开始的，一般是服务器端的错误导致的（4浏5服）

        • 第三部分：状态的描述信息（chrome浏览器没有显示描述信息）

          • ok 表示正常成功结束

          • not found 表示资源找不到

    • 响应头

      • 响应的内容类型

      • 响应的内容长度

      • 响应的时间

      • ....

    • 空白行

      • 用来分隔“响应头”和“响应体”

    • 响应体

      • 响应体就是响应的正文，这些内容是一个长的字符串，这个字符串被浏览器渲染，解释并执行，最终展示出效果

  • HTTP响应协议的具体报文：

    • HTTP/1.1 200 ok                                     状态行
Content-Type: text/html;charset=UTF-8               响应头
Content-Length: 160
Date: Mon, 08 Nov 2021 13:19:32 GMT
Keep-Alive: timeout=20
Connection: keep-alive
                                                    空白行
<!doctype html>                                     响应体
<html>
    <head>
        <title>from get servlet</title>
    </head>
    <body>
        <h1>from get servlet</h1>
    </body>
</html>
！！！Get请求和Post请求！！！
使用Get/Post请求的情况

  • 只有用表单并且声明post（method="post"）才是post请求

  • 剩下的都是get请求

    • 在浏览器地址栏上直接输入URL，回车

    • 在浏览器上直接点击超链接

    • 使用form表单提交数据时，form标签中没有写method属性，默认就是get

    • 或者使用form的时候，form标签中method属性值为：method="get"

    • ....

区别
发送数据的位置

  • get请求发送数据，数据会挂在URI的后面的"?"之后，发送的数据会回显在浏览器的地址栏上（get请求在“请求行”上发送数据）

  • post请求发送数据，在请求体当中发送。不会回显到浏览器的地址栏上（post在“请求体”当中发送数据）

  • get请求和post请求，发送的请求数据格式是完全相同的（位置不同，格式统一，http协议规定的，便于拆分存取数据）

    • name=value&name=value&name=value&name=value

    • name

      • 以form表单为例：form表单中input标签的name

    • value

      • 以form表单为例：form表单中input标签中用户填写的信息，没填写默认为该标签的value属性值

发送数据的要求

  • get请求

    • 只能发送普通的字符串

    • 发送的字符串长度有限制（无法发送大数据量），不同的浏览器限制不同，这个没有明确的规范

  • post请求

    • 可以发送任何类型的数据，包括普通字符串，流媒体等信息：视频、声音、图片

    • 可以发送大数据量，理论上没有长度限制

  • W3C中是这样说的（get获取post传，字面意思）

    • get请求比较适合从服务器端获取数据

    • post请求比较适合向服务器端传送数据

安全性

  • get请求是绝对安全的

    • 因为get请求只是为了从服务器上获取数据。不会对服务器造成威胁

    • get本身是安全的，用get传数据不好（会回显数据到地址栏）

  • post请求是危险的

    • 因为post请求是向服务器提交数据，如果这些数据通过后门的方式进入到服务器当中，服务器是很危险的

    • 另外post是为了提交数据，所以一般情况下拦截请求的时候，大部分会选择拦截（监听）post请求

缓存

  • get请求支持缓存

  • post请求不支持缓存（POST是用来修改服务器端的资源的）

    • post请求之后，服务器“响应的结果”不会被浏览器缓存起来

    • 该缓存没有意义，比方说银行交易，交易成功与否缓存下来没有意义

选择（衡量标准）

  • 使用post（向服务器提交数据，建议使用POST请求）

    • 大部分的form表单提交，都是post方式，因为form表单中要填写大量的数据，收集的用户的信息一般是需要传给服务器，服务器将这些数据保存/修改等

    • 表单中有敏感信息，还是建议适用post请求，因为get请求会回显敏感信息到浏览器地址栏上（例如：密码信息）

    • 做文件上传，一定是post请求。要传的数据不是普通文本

  • 使用get（从服务器上获取资源，建议使用GET请求）

  • 除了上述使用post的情况，其他情况都可以使用get请求

注意事项

  • 浏览器编写的请求路径以及同一项目中的超链接要加上项目路径

  • 网页换行

    • println是源代码换行,但是网页上没有换行效果

    • 页面换行用

  • 查看协议内容:使用chrome浏览器,F12,然后找到network，通过这个面板可以查看协议的具体内容

模板方法设计模式
设计模式定义

  • 某个问题的固定的解决方案(可以被重复使用)

  • 不同业务中遇到相同的问题所抽取出的解决方案

设计模式包括

  • GoF设计模式：

    • 通常我们所说的23种设计模式（Gang of Four：4人组提出的设计模式）

    • 单例模式

    • 工厂模式

    • 代理模式

    • 门面模式

    • 责任链设计模式

    • 观察者模式

    • 模板方法设计模式

    • .....

  • JavaEE设计模式：

    • DAO

    • DTO

    • VO

    • PO

    • pojo

    • ....

  • ....

模板方法设计模式

  • 在模板类的模板方法当中定义核心算法骨架，具体的实现步骤可以延迟到子类当中完成

  • 模板类通常是一个抽象类，模板类当中的模板方法定义核心算法，通常是可以final的

    • final可以保护核心算法，不能被子类修改

    • 代码复用

    • 算法得到了重复使用

  • 模板类当中的抽象方法就是不确定实现的方法（具体问题具体分析），交给子类去做

  • 举例

    • 学生类和老师类

    • 两个类除了dosome方法不同，其他的一模一样（方法名，方法体都一样）

    • 定义一个人类（抽象类，作为模板类），把所有方法放进一个模板方法

    • 然后将dosome改为抽象方法，子类（学生老师）根据自己的需求重写该方法

image-20230115171114302

HttpServlet

到目前为止接触的servlet规范中的接口和类

  • jakarta.servlet.Servlet 核心接口（接口）

  • jakarta.servlet.ServletConfig Servlet配置信息接口（接口）

  • jakarta.servlet.ServletContext Servlet上下文接口（接口）

  • jakarta.servlet.ServletRequest Servlet请求接口（接口）

  • jakarta.servlet.ServletResponse Servlet响应接口（接口）

  • jakarta.servlet.ServletException Servlet异常（类）

  • jakarta.servlet.GenericServlet 标准通用的Servlet类（抽象类）

HttpServlet相关知识

  • HttpServlet类是专门为HTTP协议准备的，比GenericServlet更加适合HTTP协议下的开发

  • HttpServlet位置：jakarta.servlet.http.HttpServlet

  • http包下的类和接口：jakarta.servlet.http.*

    • jakarta.servlet.http.HttpServlet （HTTP协议专用的Servlet类，抽象类）

    • jakarta.servlet.http.HttpServletRequest （HTTP协议专用的请求对象）

      • HttpServletRequest对象

        • HttpServletRequest，简称request对象

        • HttpServletRequest中封装了请求协议的全部内容（四部分）

        • Tomcat服务器（WEB服务器）将“请求协议”中的数据全部解析出来，然后将这些数据全部封装到request对象当中

        • 面向HttpServletRequest，就可以获取请求协议中的数据

    • jakarta.servlet.http.HttpServletResponse （HTTP协议专用的响应对象）

      • HttpServletResponse对象

        • 是专门用来响应HTTP协议到浏览器的

继承HttpServlet

  • 以后我们编写Servlet类的时候，不用直接去继承GenericServlet类的

    • 因为我们是B/S结构的系统，这种系统是基于HTTP超文本传输协议的

    • 在Servlet规范当中，提供了一个HTTP协议准备的一个Servlet类（HttpServlet，是HTTP协议专用的）

    • 使用HttpServlet处理HTTP协议更便捷，它的继承结构

    • jakarta.servlet.Servlet（接口）【爷爷】
jakarta.servlet.GenericServlet implements Servlet（抽象类）【儿子】
jakarta.servlet.http.HttpServlet extends GenericServlet（抽象类）【孙子】

    • 以后编写的Servlet类要继承HttpServlet类

HttpServlet源码分析
public class HelloServlet extends HttpServlet {
	// 用户第一次请求，创建HelloServlet对象的时候，会执行这个无参数构造方法。
	public HelloServlet() {
    }
    //HttpServlet类没有init()方法，会执行GenericServlet的init()方法
    //没有Service方法，先回执行HttpServlet类中原始的service方法，完成向下转型之后，执行重载的service模板方法
    //override 重写 doGet方法
    //override 重写 doPost方法
}
public abstract class GenericServlet implements Servlet, ServletConfig,
        java.io.Serializable {
	// 用户第一次请求的时候，HelloServlet对象第一次被创建之后，这个init方法会执行。
    public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }
	// 用户第一次请求的时候，带有参数的init(ServletConfig config)执行之后，会执行这个没有参数的init()
	public void init() throws ServletException {
        // NOOP by default
    }
}

// HttpServlet模板类
public abstract class HttpServlet extends GenericServlet {
    // 用户只要发送一次请求，这个service方法就会执行一次
    @Override
    public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {
        HttpServletRequest  request;
        HttpServletResponse response;
        try {
            // 将ServletRequest和ServletResponse向下转型为带有Http的HttpServletRequest和HttpServletResponse
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            throw new ServletException(lStrings.getString("http.non_http"));
        }
        // 调用重载的service方法
        service(request, response);
    }
    
    // 这个service方法的两个参数都是带有Http的
    // 这个service是一个  模板方法
    // 在该方法中定义核心算法骨架，具体的实现步骤延迟到子类中去完成
    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 获取请求方式
        // 这个请求方式最终可能是：""
        // 注意：request.getMethod()方法获取的是请求方式，可能是七种之一：
        // GET POST PUT DELETE HEAD OPTIONS TRACE
        String method = req.getMethod();

        // 如果请求方式是GET请求，则执行doGet方法。
        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                } catch (IllegalArgumentException iae) {
                    // Invalid date header - proceed as if none was set
                    ifModifiedSince = -1;
                }
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            // 如果请求方式是POST请求，则执行doPost方法
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);

        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }
    
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException{
        // 报405错误
        String msg = lStrings.getString("http.method_get_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 报405错误
        String msg = lStrings.getString("http.method_post_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
}
/*
通过以上源代码分析：
	假设前端发送的请求是get请求，后端程序员重写的方法是doPost
	假设前端发送的请求是post请求，后端程序员重写的方法是doGet
	会发生什么呢？
		发生405这样的一个错误。
		405表示前端的错误，发送的请求方式不对。和服务器不一致。不是服务器需要的请求方式。
	
	通过以上源代码可以知道：只要HttpServlet类中的doGet方法或doPost方法执行了，必然405.

*/

  • 编写的Servlet可以直接重写HttpServlet类中的service()方法，只不过享受不到HTTP协议专属的东西（405报错信息等等...）

    • 405报错信息本质

      • 浏览器发送的请求和服务器端的需要的请求方式不一致

      • 只要HttpServlet类中的doGet或doPost方法执行了，必然405

      image-20230116150907482

      • 以上图为例，浏览器发送get请求，但是子类中没有重写doget方法，就会执行父类的doget，而父类的doget会执行sendMethod方法发送405报错信息

    • 解决/避免405报错：后端需要的请求方式决定前端的请求方式

      • 后端重写了doGet/doPost方法，前端一定要发get/post请求

    • 错误解决方式

      • 在Servlet类当中，将doGet和doPost方法都进行了重写（然后在一个方法里面调用另一个方法）

        • 可以避免405的发生，但是不建议，405错误还是有用的。该报错的时候就应该让他报错（掩耳盗铃）

        • 同时重写了doGet和doPost不如直接重写service方法。这样代码还能少写一点

  • 最终的Servlet类的开发步骤

    • 第一步：编写一个Servlet类，直接继承HttpServlet

    • 第二步：重写doGet方法或者重写doPost方法（重写谁，javaweb程序员说了算）

    • 第三步：将Servlet类配置到web.xml文件当中

    • 第四步：准备前端的页面（form表单），form表单中指定请求路径即可

！！！HttpServletRequest接口！！！
相关知识

  • HttpServletRequest是一个接口，全限定名称：jakarta.servlet.http.HttpServletRequest

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

  • HttpServletRequest接口的父接口：ServletRequest

public interface HttpServletRequest extends ServletRequest {}

  • 接口的实现和对象的创建

    • org.apache.catalina.connector.RequestFacade 实现了 HttpServletRequest接口

    • public class RequestFacade implements HttpServletRequest {}

    • Tomcat服务器（WEB服务器、WEB容器）实现了HttpServletRequest接口，Tomcat服务器实现了Servlet规范

    • HttpServletRequest对象是Tomcat服务器负责创建的

  • 对象封装的信息

    • 用户发送请求的时候，发送的是HTTP的请求协议，Tomcat服务器将HTTP协议中的信息以及数据全部解析出来，然后Tomcat服务器把这些信息封装到HttpServletRequest对象当中

    • 面向HttpServletRequest接口编程，就可以获取到请求的信息

  • ！！！request和response对象生命周期！！！

    • 一个request对象只在一次请求中存活

    • request对象和response对象，这两个对象只在当前请求中有效

    • 一次请求对应一个request

常用方法
！！！获取前端浏览器用户提交的数据！！！
Map<String,String[]> getParameterMap() 这个是获取Map
Enumeration<String> getParameterNames() 这个是获取Map集合中所有的key
String[] getParameterValues(String name) 根据key获取Map集合的value（复选框提交的数据通常使用）
String getParameter(String name)  获取value这个一维数组当中的第一个元素。这个方法最常用
// 以上的4个方法，和获取用户提交的数据有关系

  • 底层存储前端数据采用的数据结构

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

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

    • 采用Map集合来存储

      • 错误

        • 如果采用以上的数据结构存储会发现key重复的时候value覆盖

        • map的key不能重复

      Map<String,String>
    key存储String
    value存储String
    key         value
    ---------------------
    username    abc
    userpwd     111
    aihao       s
    aihao       d
    aihao       tt

      • 正确

      Map<String, String[]>
    key存储String
    value存储String[]
    key				value
    -------------------------------
    username		{"abc"}
    userpwd			{"111"}
    aihao			{"s","d","tt"}

  • 手写webapp测试方法

    • 命令行编译

      image-20230117163051861

    编译 编译生成的class文件存放的位置 待编译的java文件

    • 数组的toString

      image-20230117164655019

    存放的元素类型 地址

请求域对象操作
void setAttribute(String name, Object obj); // 向域当中绑定数据
Object getAttribute(String name); // 从域当中根据name获取数据
void removeAttribute(String name); // 将域当中绑定的数据移除
获取请求转发器对象
RequestDispatcher dispatcher = request.getRequestDispatcher("/b");//用于请求转发
其他常用方法

  • 获取客户端的IP地址

String remoteAddr = request.getRemoteAddr();

  • 中文乱码的解决（在Tomcat10包括10在内之后的版本，中文将不再出现乱码）

    • 设置请求体的字符集

      • 这个方法是处理POST请求的乱码问题，不能解决get请求的乱码问题

      • 因为get请求在请求行上提交数据， post请求在请求体中提交数据

      • Tomcat10之后，request请求体当中的字符集默认就是UTF-8，不需要设置字符集，不会出现乱码问题,Tomcat9前（包括9在内），前端请求体提交的是中文，后端获取之后出现乱码解决方式

    request.setCharacterEncoding("UTF-8");//该代码要设置到获取数据之前

    • 在Tomcat9之前（包括9），响应出现中文乱码的解决方式（Tomcat10之后，包括10在内，响应中文时不再出现乱码）

    response.setContentType("text/html;charset=UTF-8");

    • get请求乱码问题解决方式

      • 方案：修改CATALINA_HOME/conf/server.xml配置文件

      <Connector URIEncoding="UTF-8" />

      • 从Tomcat8之后，URIEncoding的默认值就是UTF-8，所以GET请求也没有乱码问题了

  • ！！！获取应用的根路径！！！(动态获取)

    String contextPath = request.getContextPath();

  • 获取请求方式

    String method = request.getMethod();

  • 获取请求的URI（带项目名）

    String uri = request.getRequestURI();  // /aaa/testRequest

  • 获取servlet path（不带项目名）

    • getServletPath():获取能够与“url-pattern”中匹配的路径，注意是完全匹配的部分，*的部分不包括

    • getPageInfo():与getServletPath()获取的路径互补，能够得到的是“url-pattern”中*d的路径部分

    • getServletPath()加上getPageInfo()获取到的是用户发送请求路径中项目名之后的路径

    String servletPath = request.getServletPath(); //   /testRequest
！！！注意以下两个方法不要搞混！！！
// uri?username=zhangsan&userpwd=123&sex=1
String username = request.getParameter("username");

Object obj = request.getAttribute("name");

  • getParameter():获取的是用户在浏览器上提交的数据

  • getAttribute():获取的是请求域当中绑定的数据

    • 之前执行过：request.setAttribute("name", new Object())才能获取到数据，否则为null

！！！请求域！！！

  • “请求域”对象

    • “请求域”对象要比“应用域”对象范围小很多，生命周期短很多

    • 请求域只在一次请求内有效

      • 一个请求对象request对应一个请求域对象

      • 请求对象创建时请求域就开启了

      • 一次请求结束之后，这个请求域就销毁了

    • 域的选用原则:尽量使用小的域对象，小的域对象占用的资源较少

  • 转发机制

    • 一次请求中，实现资源跳转

      1. 获取请求转发器对象(相当于把路径包装到转发器中，实际上是把下一个跳转资源的路径告诉tomcat服务器)

      RequestDispatcher dispatcher = request.getRequestDispatcher("/b");

      1. 调用转发器的forward方法完成跳转/转发，将当前资源的request和respond对象传递

      dispatcher.forward(request,response);
      // 第一步和第二步代码可以联合在一起
request.getRequestDispatcher("/b").forward(request,response);

    • 错误的servlet资源共享方式：Aservlet类中new另一个Bservlet对象，然后将Aservlet的request对象作为参数传递给Bservlet的doget/dopost方法

      image-20230117224054214

      • 虽然可以实现功能，但是自己new的Servlet对象不受tomcat管理（非法对象）

  • 两个Servlet共享数据

    1. 将数据放到ServletContext应用域当中，但是应用域范围太大，占用资源太多（不建议使用）

    2. 将数据放到request域中，同过转发，保证两个Servlet在同一次请求中，这样就可以做到两个或者多个Servlet共享同一份数据

      • Tomcat服务器当中的合法资源都是可以转发的。例如：html....

      • 转发的路径以“/”开始，不加项目名

关于一个web站点的欢迎页面

  • 一个web站点的欢迎页面（默认页面）

    • 对于一个webapp来说是可以设置它的欢迎页面的

    • 设置了欢迎页面之后，当你访问这个webapp或者web站点的时候，没有指定任何“资源路径”，会默认访问你的欢迎页面

    • 我们一般的访问方式是：

    • 如果我们访问的方式是：

  • 设置欢迎页面

    • 第一步：在IDEA工具的web目录下新建了一个文件login.html由于作为欢迎界面

    • 第二步：在web.xml文件中进行了以下的配置

      • <welcome-file-list>
    <welcome-file>login.html</welcome-file>
</welcome-file-list>

      • 设置欢迎页面时，这个路径不以“/”开始（会出现双斜杠从而找不到资源），并且这个路径默认从webapp的根下开始查找

    • 第三步：启动服务器，浏览器地址栏输入地址

  • 如果在webapp的根下新建一个目录，目录中再给一个文件，如何设置这个欢迎页

    • 在webapp根下新建page1

    • 在page1下新建page2目录

    • 在page2目录下新建page.html页面

    • 在web.xml文件中应该这样配置

      • <welcome-file-list>
    <welcome-file>page1/page2/page.html</welcome-file>
</welcome-file-list>

      • 路径不以“/”开始，默认从webapp的根下开始找。

  • 一个webapp是可以设置多个欢迎页面

    • <welcome-file-list>
    <welcome-file>page1/page2/page.html</welcome-file>
    <welcome-file>login.html</welcome-file>
</welcome-file-list>

    • 越靠上的优先级越高。找不到的继续向下找

  • 文件名设置为index.html的时候，不需要在web.xml文件中进行配置欢迎页面

    • 这是因为小猫咪Tomcat服务器已经提前配置好了

    • 实际上配置欢迎页面有两个地方可以配置：

      • 一个是在webapp内部的web.xml文件中（局部配置）

      • 一个是在CATALINA_HOME/conf/web.xml文件中进行配置（全局配置）

        • <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>

        • Tomcat服务器的全局欢迎页面是：index.html index.htm index.jsp。一个web站点没有设置局部的欢迎页面，Tomcat服务器就会以index.html index.htm index.jsp作为一个web站点的欢迎页面

      • 注意原则：局部优先（就近）原则

  • 欢迎页可以是一个Servlet

    • 欢迎页就是一个资源，可以是静态资源，也可以是动态资源

    • 静态资源：index.html welcome.html .....

    • 动态资源：Servlet类。

    • 步骤：

      • 第一步：写一个Servlet

        • public class WelcomeServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.print("<h1>welcome to bjpowernode!</h1>");
    }
}

      • 第二步：在web.xml文件中配置servlet

        • <servlet>
        <servlet-name>welcomeServlet</servlet-name>
        <servlet-class>com.bjpowernode.javaweb.servlet.WelcomeServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>welcomeServlet</servlet-name>
        <url-pattern>/fdsa/fds/a/fds/af/ds/af/dsafdsafdsa</url-pattern>
    </servlet-mapping>

      • 第三步：在web.xml文件中配置欢迎页

        • <welcome-file-list>
        <welcome-file>fdsa/fds/a/fds/af/ds/af/dsafdsafdsa</welcome-file>
</welcome-file-list>

！！！WEB-INF目录！！！

  • 在WEB-INF目录下新建了一个文件：welcome.html，打开浏览器访问：http://localhost:8080/servlet07/WEB-INF/welcome.html 出现了404错误

  • 原因：

    • 放在WEB-INF目录下的资源是受保护的，在浏览器上不能够通过路径直接访问

    • 像HTML、CSS、JS、image等静态资源一定要放到WEB-INF目录之外

servlet实现单表的增删改查

  • 实现步骤

    • 第一步：准备一张数据库表（部门表）

    • 第二步：准备一套HTML页面（项目原型）【前端开发工具使用HBuilder】

      • 然后将HTML页面中的链接都能够跑通（页面流转没问题）

      • 需要的页面

        • 欢迎页面：index.html

        • 列表页面：list.html（专门显示所有信息，以列表页面为核心，展开其他操作）

        • 新增页面：add.html

        • 修改页面：edit.html（业务需求：部门编号不可修改）

        • 详情页面：detail.html

    • 第三步：分析系统包含的功能

      • 功能

        • 一个操作连接了数据库，就表示一个独立的功能

      • 包括

        • 查看部门列表

        • 新增部门

        • 删除部门

        • 查看部门详细信息

        • 跳转到修改页面

        • 修改部门

    • 第四步：在IDEA当中搭建开发环境

      • ①创建一个webapp（添加servlet-api.jar和jsp-api.jar到classpath当中）

      • ②向webapp中添加连接数据库的jar包（mysql驱动）

        • 必须在WEB-INF目录下新建lib目录，将mysql的驱动jar包拷贝到这个lib目录下（目录名必须是全部小写的lib）

        • 复制完jar包之后要右键Add as Library（否则包会找不到）

      • ③创建JDBC的工具类（封装获取数据库连接对象操作）

        1. 注册驱动

        • 只用注册一次，所以放在静态代码块中，在类加载的时候执行

        static {
        //注册驱动,只用注册一次
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

        • 连接驱动不能写死（考虑到要连接不同数据库），所以在配置文件中声明信息（jdbc.properties），通过ResourceBundle绑定资源文件

          • 如果连接oracle数据库的时候，还需要修改java代码，违背了0CP开闭原则

        • OCP开闭原则:对扩展开放，对修改关闭（扩展不要建立在修改的基础上）

          • 在进行功能扩展的时候，不需要修改java源代码符合0CP

          • 配置信息

          driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
username=root
password=1212go12

        • 属性资源文件绑定，根据key获取value

          • 静态变量，在类加载的时候执行，有顺序（自上而下）

        private static ResourceBundle bundle=ResourceBundle.getBundle("resources.jdbc");
private static String driver=bundle.getString("driver");
private static String url=bundle.getString("url");
private static String user=bundle.getString("username");
private static String password=bundle.getString("password");

        1. 获取数据库连接对象

          //获取数据库连接对象
  public static Connection getConnection() throws SQLException {
      Connection connection = DriverManager.getConnection(url, user, password);
      return connection;
  }

        1. 执行sql语句、处理查询结果集（具体业务代码不写在工具类中）

        2. 释放资源

          public static void close(Connection conn, Statement ps, ResultSet rs){
      if(conn!=null){
          try {
              conn.close();
          } catch (SQLException throwables) {
              throwables.printStackTrace();
          }
      }if(ps!=null){
          try {
              ps.close();
          } catch (SQLException throwables) {
              throwables.printStackTrace();
          }
      }if(rs!=null){
          try {
              rs.close();
          } catch (SQLException throwables) {
              throwables.printStackTrace();
          }
      }
  }

      • ④将所有HTML页面拷贝到web目录下

    • 第五步：实现功能

查看部门列表

  • 建议

    • 从后端往前端一步一步写或者从前端一步一步往后端写，不要想起来什么写什么

    • 写代码的过程最好是程序的执行过程，程序执行到哪里就写哪里。这样一个顺序流下来之后，基本上不会出现什么错误、意外

  • 功能的开始

  • 假设从前端开始，从用户点击查看按钮开始

  • 第一：设定前端页面的超链接，该链接对应查询部门列表的servlet（要加项目名）

  • 第二：编写web.xml文件

    • <servlet>
    <servlet-name>list</servlet-name>
    <servlet-class>com.bjpowernode.oa.web.action.DeptListServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>list</servlet-name>
    <!--web.xml文件中的这个路径也是以“/”开始的，但是不需要加项目名-->
    <url-pattern>对应前端不加项目名的链接</url-pattern>
</servlet-mapping>

  • 第三：编写ListServlet类继承HttpServlet类，重写doGet方法

  • 第四：doGet方法中连接数据库，查询所有的部门，动态的展示部门列表页面

    • 分析list.html页面中哪部分是固定死的，哪部分是需要动态展示的

    • list.html页面中的内容所有的双引号要替换成单引号，因为out.print("")这里有一个双引号，容易冲突

    • 只使用servlet写代码太繁琐

    • while(rs.next()){
    String deptno = rs.getString("a");
    String dname = rs.getString("dname");
    String loc = rs.getString("loc");
    out.print("			<tr>");
    out.print("				<td>"+(++i)+"</td>");
    out.print("				<td>"+deptno+"</td>");
    out.print("				<td>"+dname+"</td>");
    out.print("				<td>");
    out.print("					<a href=''>删除</a>");
    out.print("					<a href='edit.html'>修改</a>");
    out.print("					<a href='detail.html'>详情</a>");
    out.print("				</td>");
    out.print("			</tr>");
}

    • jdbc获取查询结果

      • 根据查询结果的列名获取信息，如果起别名则根据别名获取

      • 如果采用*查询，则根据原数据库表中的列名获取

String deptno = rs.getString("deptno");
查看部门详情

  • 建议

    • 从前端往后端一步一步实现

      • 先找到用户点的详情位置==》在后端的java程序中(因为是用servlet打印html代码)

      • <a href='写一个路径'>详情</a>

      • 详情 是需要连接数据库的，这个超链接点击之后需要执行一段java代码的,所以要设置这个超链接的路径（servlet绑定）

      • 修改路径之后，这个路径是需要加项目名的。"/oa/dept/detail"

      • 配置servlet映射

        • <servlet>
    <servlet-name>detail</servlet-name>
    <servlet-class>com.bjpowernode.oa.web.action.DeptDetailServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>detail</servlet-name>
    <url-pattern>/dept/detail</url-pattern>
</servlet-mapping>

      • 技巧

        • out.print("<a href='"+contextPath+"/dept/detail?deptno="+deptno+"'>详情</a>");

        • 向服务器提交数据的格式：uri?name=value&name=value&name=value&name=value

        • 这里的问号，必须是英文的问号

        • 字符串拼接技巧：在拼接位置中先加双引号，然后在双引号中加两个加号，添加内容写在两个加号之中

  • doGet方法中

    1. 连接数据库

    2. 根据部门编号查询该部门的信息

      1. 先获取部门编号，request调用getParameter()

      2. 根据该部门编号查询

    3. 动态展示部门详情页

删除部门

  • 从前端页面开始，用户点击删除时，提示用户是否删除

    • 删除这个动作是比较危险的,任何系统在进行删除操作之前，必须要提示用户

    • 删除的动作有可能是用户误操作

  • 在提示用户是否删除的js代码

    • <a href="javascript:void(0)" οnclick="del(30)" >删除</a>
<script type="text/javascript">
	function del(dno){
		if(window.confirm("亲，删了不可恢复哦！")){
			document.location.href = "/oa/dept/delete?deptno=" + dno;
		}
	}
</script>

    • href后面设置为javascript:void(0) 表示

      • 保留住超链接的样子，点击此超链接之后，不进行页面的跳转

      • 数字不一定要是0

    • confirm会弹出确认框，返回一个布尔值（确定为true取消false）

    • 跳转（去掉href也可以），前端发请求路径要带项目名

      • document.location.href=”请求路径“

      • window.location.href=”请求路径“

  • 以上的前端程序要写到后端的java代码中

  • web.xml文件

    • 重写doGet方法

     //先获取部门编号
        String deptno = req.getParameter("deptno");
      Connection connection=null;
        PreparedStatement preparedStatement=null;
        int count=0;
        try {    
            connection = DBUtils.getConnection();
            //开启事务(关闭自动提交)
            connection.setAutoCommit(false);
            String sql="delete from dept where deptno=?";//占位符
            preparedStatement= connection.prepareStatement(sql);
            preparedStatement.setString(1,deptno);//给占位符赋值
            count = preparedStatement.executeUpdate();//返回值是影响了多少条记录
            connection.commit();
        } catch (SQLException throwables) {
            if(connection!=null){
                try {
                    //出现异常就回滚
                    connection.rollback();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

    • 删除成功或者失败的时候的一个处理（这里选择了转发，但是应该用重定向机制）

      • // 判断删除成功
if (count == 1) {
    //删除成功
    //仍然跳转到部门列表页面
    //部门列表页面的显示需要执行另一个Servlet。怎么办？转发。
    request.getRequestDispatcher("/dept/list").forward(request, response);
}else{
    // 删除失败
    request.getRequestDispatcher("/error.html").forward(request, response);
}
新增部门

  • 问题：最后保存成功之后，转发到 /dept/list 的时候，会出现405

  • 原因

    • 保存用的是post请求,底层要执行doPost方法。

    • 转发是一次请求，之前是post，之后还是post

    • 转发到/dept/list，该Servlet中只有doGet方法

  • 解决

    • 第一种：在/dept/list Servlet中添加doPost方法，然后在doPost方法中调用doGet

    • 第二种：重定向

修改部门

  • 跳转到修改部门的页面

    • 先查询需要修改的部门信息（类似于详情功能）

    • 动态输出页面

调试

  • 前端/浏览器

    • console看JavaScript代码错误

    • network看具体的浏览器和服务器通信的协议

    • elements配合

      image-20230120195825374

      使用，选择页面元素信息

    • source可以进行断点调试

  • 后端，debug

    • image-20230120195955368

      跳到下一个断点位置（这个图标在左边那一列）

    • image-20230120200139942

      预览程序的所有断点

转发与重定向

web中有两种方式完成资源跳转

  • 转发

  • 重定向

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

区别

  • 代码上

    • 转发

      • 转发的时候是一次请求，转发多少次都是一次请求

      • 转发的servlet对象都在同一个请求域中，调用forward方法会将当前的request和response对象传递给下一个Servlet（转发过程中的所有servlet共享同一个request对象和同一个response对象）

      // 获取请求转发器对象
RequestDispatcher dispatcher = request.getRequestDispatcher("/dept/list");
// 调用请求转发器对象的forward方法完成转发
dispatcher.forward(request, response);
      // 合并一行代码
request.getRequestDispatcher("/dept/list").forward(request, response);

    • 重定向

      • 请求路径上是需要添加项目名，相当于浏览器又发了一次新请求（浏览器发送请求都需要加项目名）

      • response会将请求路径发送给浏览器，浏览器会自发地向服务器发送一次全新的请求

      response.sendRedirect("/项目名/文件路径");

  • 形式

    • 转发（转发不论多少次都是一次请求）

      • 在浏览器地址栏上发送的请求是：http://localhost:8080/servlet10/a ，请求结束之后，浏览器地址栏上的地址不变

      • 转发会存在浏览器的刷新问题（刷新浏览器还是发送最初的请求），如果是新增操作的话就会重复添加相同数据

    • 重定向（重定向一次是两次请求）

      • 最终在浏览器地址栏上显示的地址是最后一次请求的地址，重定向会导致浏览器地址栏的地址改变

  • 本质区别

    • 转发：是由WEB服务器来控制的。A资源跳转到B资源，跳转动作是Tomcat服务器内部完成的

    image-20230121193313871

    • 重定向：是浏览器完成的（新发送一次请求）。具体跳转到哪个资源，浏览器说了算

image-20230121193525443

选择

  • 如果在上一个Servlet当中向request域当中绑定了数据，希望从下一个Servlet中把request域里面的数据取出来，使用转发机制

  • 剩下所有的请求均使用重定向（重定向使用较多）

Servlet注解

问题及解决

  • 没使用注解前(仅使用web.xml)遇到的问题

    • web.xml文件中的配置信息对于一个大的项目来说，会非常庞大

    • 在web.xml文件中进行servlet信息的配置，开发效率比较低，每个servlet都需要配置

    • web.xml文件中的配置是很少被修改

  • Servlet3.0版本之后，推出了各种Servlet基于注解式开发

    • 开发效率高，不需要编写大量的配置信息（直接在java类上使用注解进行标注）

    • web.xml文件体积变小

  • 注解加配置文件的开发方式

    • 有一些需要变化的信息，还是要配置到web.xml文件中。一般都是 注解+配置文件 的开发模式

    • 一些不会经常变化修改的配置建议使用注解。一些可能会被修改的建议写到配置文件中

webservlet（注解）
@Target({ElementType.TYPE}) 
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WebServlet {
    String name() default "";
    String[] value() default {};
	.....
}

  • target表示该注解使用的位置，{ElementType.TYPE}表示该注解可以出现在类上

  • 常用属性

    • (String)name属性：用来指定Servlet的名字<servlet-name>

    • (String[])urlPatterns属性

      • 用来指定Servlet的映射路径。可以指定多个字符串（多个路径指向同一servlet对象）<url-pattern>

      • urlPatterns底层是数组，指定多个元素的格式：urlPatterns={"元素1"，"元素2"，"元素3".....}

    • value属性

      • 和urlPatterns作用相同

      • 当注解的属性名是value时且注解中只有一个属性，value可以省略

      @WebServlet( {"/a","/b"})

    • （int）loadOnStartUp属性：用来指定在服务器启动阶段是否加载该Servlet<load-on-startup>

    • （WebInitParam[] ）initParams属性

      • 配置初始化参数

      • 底层是WebInitParam注解数组

      public @interface WebInitParam {
    String name();
    String value();
    String description() default "";
}

      • 使用：initParams={@WebInitParam(name="1"，value="1"),@WebInitParam(name="2"，value="2")...}

    • 注意

      • 不是必须将所有属性都写上，需要什么用什么

      • 如果属性是一个数组并且只有一个元素，使用该注解时，属性值的大括号可以省略

  • 注解对象的使用格式

    • @注解名称(属性名=属性值, 属性名=属性值, 属性名=属性值....)

使用反射机制解析类上的注解

  • 代码

public class test {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取类class对象
        Class<?> helloServlet = Class.forName("HelloServlet");
        //获取这个类上面的注解对象（先判断有没有该对象）
        if (helloServlet.isAnnotationPresent(WebServlet.class)) {
            //获取类上的注解对象
            WebServlet annotation = helloServlet.getAnnotation(WebServlet.class);
            String[] value = annotation.value();
            String[] urlPatterns = annotation.urlPatterns();
            for (String s : value) {
                System.out.println(s);
            }
            System.out.println("-----------");
            for (String urlPattern : urlPatterns) {
                System.out.println(urlPattern);
            }
        }
    }
}

  • 运行结果

image-20230123170954083

value有值，而urlpatterns没有值，说明webServlet只有一个value属性时，可以省略value

使用模板方法设计模式优化oa项目

  • 问题

    • 注解解决了配置文件的问题

    • 当前的项目一个单表的CRUD，就写了6个Servlet。如果一个复杂的业务系统，一个请求一个Servlet类这种开发方式，显然会导致类爆炸（类的数量太大）

  • 解决类爆炸

    • 一个请求对应一个方法，一个业务对应一个Servlet类

    • 例如

      • 处理部门相关业务的对应一个DeptServlet

      • 处理用户相关业务的对应一个UserServlet

      • 处理银行卡卡片业务对应一个CardServlet

    • /dept/*

      • 请求路径以/dept开始的就执行这个servlet

      • 注意

        • getServletPath()获取能够与“url-pattern”中匹配的路径，注意是完全匹配的部分，*的部分不包括

        • getPageInfo():与getServletPath()获取的路径互补，能够得到的是“url-pattern”中*d的路径部分

        • 两者拼接的时候要判断info()是否为空

@WebServlet("/dept/*")
public class DeptServlet extends HttpServlet {
    //模板方法,重写service（因为不知道前端发送的是get还是post请求）
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取servlet path（不带项目名）
        String servletPath = request.getServletPath();
        String pathInfo = request.getPathInfo();
        String path;
        if (pathInfo != null) {
             path = servletPath + pathInfo;
        }
        path = servletPath;
        //一个路径对应一个功能
        if ("/dept/list".equals(path)) {
            doList(request, response);
        } else if ("/dept/save".equals(path)) {
            doSave(request, response);
        } else if ("/dept/edit".equals(path)) {
            doEdit(request, response);
        } else if ("/dept/detail".equals(path)) {
            doDetail(request, response);
        } else if ("/dept/delete".equals(path)) {
            doDel(request, response);
        } else if ("/dept/modify".equals(path)) {
            doModify(request, response);
        } else {
            System.out.println("路径不存在");
        }
    }

  • 只用Servlet开发web应用的缺陷

    • java程序中编写前端代码

      • 编写难度大、麻烦

      • 程序的耦合度非常高

      • 代码不美观

      • 维护成本太高，修改一个前端代码，就需要重新编译java代码，生成新的class文件，打一个新的war包，重新发布

    • 解决思路

      • 程序员编写Servlet程序中需要的前端代码，让机器把前端代码自动翻译生成java代码（自动加上out.print）

      • 然后机器再自动将“java”程序编译生成"class"文件。然后再使用JVM调用这个class中的方法

b/s系统的会话机制

会话

  • 会话对应的英语单词：session

  • 用户打开浏览器，进行一系列操作，然后最终将浏览器关闭，这个整个过程叫做一次会话

  • 会话在服务器端有一个对应的java对象叫做session（一个session对象对应一次会话）

  • 用户在浏览器上点击了一下，然后到页面停下来，可以粗略认为是一次请求。请求对应的服务器端的java对象是request

  • 一个会话当中包含多次请求（一次会话对应N次请求）

session
定义和作用

  • 在java的servlet规范当中，session对应的类名：HttpSession（jarkata.servlet.http.HttpSession）

  • session机制属于B/S结构的一部分，实际上是一个规范，不同的语言对这种会话机制都有实现（使用php语言开发WEB项目，也是有session这种机制的）

  • session对象存储在服务器

  • session对象最主要的作用是保存会话状态（用户登录成功了，这是一种登录成功的状态，可以用session对象把登录成功的状态一直保存下来）

！！！需要session保存会话状态的原因！！！

  • 因为HTTP协议是一种无状态协议

    • 无状态：请求的时候，B和S是连接的，但是请求结束之后，连接就断了

    • 无状态协议，可以降低服务器的压力。请求的瞬间是连接的，请求结束之后，连接断开，这样服务器压力小

  • B和S断开，但是服务器不知道用户关闭浏览器这个动作

    • 举例：网银有个安全退出按钮，点击安全退出比直接关闭浏览器安全，因为点击该按钮会发送请求告诉服务器，然后清除会话信息，直接关闭浏览器服务器端不知道关闭了，所以不安全

  • 不使用request对象和ServletContext对象保存会话状态的原因（域的范围不合适）

    • request是一次请求一个对象，两次请求的数据不共享，request对象域太小

    • ServletContext对象是服务器启动时创建，服务器关闭时销毁，ServletContext对象只有一个，ServletContext对象的域太大

  • request请求域（HttpServletRequest）、session会话域（HttpSession）、application域（ServletContext）

    • setAttribute()存，getAttribute()取，request、ServletContext和session都有这个方法

    • 使用原则：尽量使用小的域

    • request < session < application，session是一次会话，相当于一个用户一个会话

获取session对象

  • HttpSession session = request.getSession();

    • 从服务器中获取当前的session对象，如果没有获取到任何session对象则新建

  • HttpSession session = request.getSession(false);

    • 从服务器中获取当前session对象，如果获取不到session，则不会新建，返回一个null

session对象的销毁

  1. 超时销毁（时间限制可以在web.xml中配置）

    <session-config>
    <session-timeout>30</session-timeout>
</session-config>

    • 单位分钟，默认30分钟

    • 在规定时间范围内未被访问，则对象被销毁

  2. 手动销毁

    session.invalidate();
session对象的实现原理

  • 理解：相当于浏览器给服务器端的某个session对象打标记，浏览器通过直接记下的标记找到该会话对象

    image-20230128002843131

  • 实现原理

    • web服务器中有个session列表

      • session列表是一个Map

        • key是JSESSIONID（session对象的编号）

        • value是session对象

    • 用户第一次请求，服务器生成session对象，同时给该对象生成id，将id发送给浏览器，然后浏览器将id保存到浏览器内存中

      • JSESSIONID=xxxxxx 这个是以Cookie的形式保存在浏览器的内存中的

    • 用户第二次请求，自动将浏览器内存中的id发送给服务器，服务器根据id查找session对象

    • 关闭浏览器，浏览器的缓存消失，cookie消失，sessionid消失，会话等同于结束

    • 下次打开浏览器访问找不到原来的session对象，就会重新获取一个新的session对象

    image-20230128183039387

session改造登录功能

  1. 登录成功之后，先获取session对象（如果没有获取到就创建，也就是getSession不能有false参数）

  2. 然后将用户的登录信息存储到session当中

  3. 模板类中先获取session对象（这里要传false，如果没有获取到就不创建session对象），然后判断是否有session对象

    • 有session就进行下一步判断

    • 没有session对象说明没有用户访问或者非法访问

  4. 判断session对象中是否有用户信息

    • 有用户的信息就代表登录成功了

    • 没有用户信息，表示用户没有登录过，则跳转到登录页面

    • 只判断有session对象就证明有用户是错误的，因为如果先访问了其它服务器资源就有可能先创建出一个会话对象，后续操作都使用这个对象，比如说jsp中有session的内置对象

      • 设置访问jsp时不创建session对象

      <%@page session="false"%>

      • 如果写上述代码，jsp就不能通过session对象获取会话域的数据

  5. 登出功能

    • 在登出的方法中手动销毁session对象

    • 然后跳转到登录页面

Cookie
相关知识

  • 每个session对象都会关联一个sessionid，例如：JSESSIONID=41C481F0224664BDB28E95081D23D5B8

    • 以上的键值对数据就是cookie对象

    • 对于session关联的cookie来说，这个cookie是被保存在浏览器的运行内存当中

    • 只要浏览器不关闭，用户再次发送请求的时候，会自动将运行内存中的cookie（例如上述cookie对象）发送给服务器

    • 然后服务器根据41C481F0224664BDB28E95081D23D5B8这个值来找到对应的session对象

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

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

保存位置

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

    • 可以保存在运行内存（浏览器只要关闭cookie就消失了）

    • 也可以保存在硬盘文件（永久保存）

用途

  • cookie和session机制都是为了保存会话的状态

    • cookie是将会话的状态保存在浏览器客户端（cookie数据存储在浏览器客户端）

    • session是将会话的状态保存在服务器端（session对象是存储在服务器）

  • 因为HTTP协议是无状态、无连接协议，所以需要有cookie和session机制

Cookie禁用

image-20230128180307180

  • cookie禁用指服务器正常发送cookie给浏览器，但是浏览器拒收，并不是服务器不发

  • Cookie禁用后session就找不到了（每一次请求都会获取新的session对象）

  • cookie禁用后实现session机制（不建议）

    • 需要使用URL重写机制：在url后面加个分号已经jssessionid=xxxxxxxxxxxxxxxx（32位）

    • http://localhost:8080/servlet12/test/session;jsessionid=19D1C99560DCBF84839FA43D58F56E16

    • URL重写机制会提高开发者的成本

      • 开发人员在编写任何请求路径的时候，后面都要添加一个sessionid（而且还是动态的），给开发带来了很大的难度

      • 大部分的网站是这样设计的：禁用cookie，就无法访问

cookie的经典案例

  • 京东商城，在未登录的情况下，向购物车中放几件商品。然后关闭商城，再次打开浏览器访问京东商城的时候，购物车中的商品还在

    • 将购物车中的商品编号放到cookie当中，cookie保存在硬盘文件当中。这样即使关闭浏览器。硬盘上的cookie还在。下一次再打开京东商城的时候，查看购物车的时候，会自动读取本地硬盘中存储的cookie，拿到商品编号，动态展示购物车中的商品

      • 京东存储购物车中商品的cookie可能是这样的：productIds=xxxxx,yyyy,zzz,kkkk

      • crtl+shift+delete可以清除硬盘文件的cookie，cookie如果被清除掉，购物车中的商品就消失了

  • 126邮箱中有一个功能：十天内免登录

    • 需要cookie来实现

      • 用户输入正确的用户名和密码，并且选择十天内免登录。登录成功后，浏览器客户端会保存一个cookie，这个cookie中保存了用户名和密码等信息，这个cookie是保存在硬盘文件当中的

      • 在十天内用户再次访问126的时候，浏览器自动提交126的关联的cookie给服务器，服务器接收到cookie之后，获取用户名和密码，验证通过之后，自动登录成功

    • 让cookie失效

      • 十天过后自动失效

      • 或者改密码

      • 或者在客户端浏览器上清除cookie

Cookie类

  • servlet提供了一个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消失

    • 只要设置cookie的有效时间 > 0，这个cookie一定会存储到硬盘文件当中

    • 设置cookie的有效时间 = 0 ，即删除该cookie，应用在删除同名cookie

    • 设置cookie的有效时间 < 0 ，不存储该cookie到硬盘中，保存在运行内存（默认情况保存在运行内存）

  • 删除cookie的注意事项

    • 设置完时间为0之后，要将该cookie对象重新响应给浏览器才能实现覆盖

    • 删除Cookie时，新建的Cookie除value、maxAge之外的所有属性，都要与原Cookie完全一样。否则浏览器将视为两个不同的Cookie不予覆盖，导致删除失败

    Cookie[] cookies = req.getCookies();
for (int i = 0; i < cookies.length; i++) {
    if("username".equals(cookies[i].getName())||"password".equals(cookies[i].getName())){
        cookies[i].setMaxAge(0);
        //覆盖原有cookie
        resp.addCookie(cookies[i]);
    }
}
resp.sendRedirect(req.getContextPath());

  • 关于cookie的path（cookie关联的路径)

  • 接收浏览器发送的cookie（模拟服务器接收cookie对象）request.getCookies();

    • Cookie[] cookies = request.getCookies();
if(cookies != null){
    for(Cookie cookie : cookies){
        // 获取cookie的name
        String name = cookie.getName();
        // 获取cookie的value
        String value = cookie.getValue();
    }
}

    • 注意：

      • 浏览器中如果没有cookie则获取到null而不是空数组

      • cookie数组长度一定大于0

使用cookie实现十天内免登录功能

  • 先实现登录功能

    • 登录成功

      • 跳转到部门列表页面

    • 登录失败

      • 跳转到登录失败页面

  • 修改前端页面

    <input type="checkbox" name="Logofree" value="1">十天免登录

    • 在登录页面添加一个复选框

      • 选择了复选框：表示要支持十天内免登录

      • 没有选择复选框：表示不想使用十天内免登录功能

    • checkbox(复选框)的value属性

      • value 属性可设置或者返回 checkbox 的value属性值

      • value 属性用于表单数据的提交，只有选中的复选框才会传递数据到服务端（什么都没选则不传递复选框数据）

  • 修改Servlet中的login方法

    • 如果用户登录成功，并且登录时选择了十天内免登录功能

      • 思路：在Servlet的login方法中创建cookie，用来存储用户名和密码，并且设置路径，设置有效期，将cookie响应给浏览器（浏览器将其自动保存在硬盘文件当中10天）

      • 实操：如果走login方法就先获取复选框的数据，判断是否选中，然后创建cookie等一系列操作

  • 用户再次访问该网站的时候，访问这个网站的首页的时候，有两个走向

    • 跳转到部门列表页面

    • 跳转到登录页面

    • 两个走向需要编写java程序进行控制的

      • 先获取cookie数组，数组不为null就遍历获取username和password字符串

      • 两者都获取到之后，两者

        • 不为空进入下一步判断

        • 为空直接重新登录

      • 验证用户名和密码是否正确

        • 正确进入列表页面

        • 错误进入登录页面

jsp

访问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

  • jsp文件对应的类继承 HttpJspBase，而HttpJspBase类继承HttpServlet，所以jsp类是一个Servlet类

  • jsp的生命周期和Servlet的生命周期完全相同

  • jsp和servlet一样都是单例（假单例，只创建一个对象）

  • JSP和Servlet的区别（职责不同）

    • Servlet的职责：收集数据（Servlet的强项是逻辑处理，业务处理，然后链接数据库，获取/收集数据）

    • JSP的职责：展示数据（JSP的强项是做数据的展示）

jsp文件第一次被访问比较慢的原因

  1. 要把jsp文件翻译生成java源文件

  2. java源文件要编译生成class字节码文件

  3. 通过class去创建servlet对象

  4. 然后调用servlet对象的init方法

  5. 最后调用servlet对象的service方法

之后访问就可以直接执行servlet对象的service方法

！！！Jsp相关知识！！！

  • JSP是java程序（JSP本质还是一个Servlet）

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

    • 开发JSP的最高境界：眼前是JSP代码，但是脑袋中呈现的是java代码

  • 全名：JavaServer Pages的缩写（基于Java语言实现的服务器端的页面）

  • JSP是一套规范

    • JSP是JavaEE的13个子规范之一（因为Servlet是JavaEE的13个子规范之一）

    • 所有的web容器/web服务器都是遵循这套规范的，并且按照这套规范进行翻译（jsp中有个out流对象，每行jsp代码通过out的write方法输出）

    • 每一个web容器/web服务器都会内置一个JSP翻译引擎

image-20230123234958626

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

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

    <servlet-mapping>
    <servlet-name>jsp</servlet-name>
    <url-pattern>*.jsp</url-pattern>
    <url-pattern>*.jspx</url-pattern>
</servlet-mapping>

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

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

      • 作用域使用原则：尽可能使用小的域

  • 响应相关

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

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

  • java.lang.Throwable exception

  • jakarta.servlet.ServletConfig config

  • java.lang.Object page （其实是this，当前的servlet对象【jsp本质就是servlet】）

！！！基础语法！！！

jsp文件中编写文字

  • 会被自动翻译到servlet类的service方法的out.write("")中的双引号里

  • 被java程序当做普通字符串打印输出到浏览器

  • 在JSP中编写的HTML CSS JS代码，对于JSP来说只是普通的字符串。输出到浏览器，浏览器会对进行解释执行，展现一个效果

  • 解决响应时的中文乱码问题

    • jsp不是默认utf-8

    • 通过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代码时，就相当于在“方法体”当中写代码，要符合java语法中的方法规范

      • 在service方法当中编写的代码是有顺序的，方法体当中的代码要遵循自上而下的顺序逐行执行

      • service方法当中不能写静态代码块，不能写方法，不能定义成员变量(定义的变量不能被访问权限修饰符修饰)

    • 在同一个JSP当中 <%%> 这个符号可以出现多个

    • 注意：在<%%>中调用setAttribute等方法会爆红，但是可以正常运行

  • <%! %>

    • 在这个符号当中编写的java程序会自动翻译到service方法之外

    • 这个语法很少用，在service方法外面写静态变量和实例变量，都会存在线程安全问题，因为JSP就是servlet，servlet是单例的，多线程并发的环境下，这个静态变量和实例变量一旦有修改操作，必然会存在线程安全问题

  • JSP的输出语句

    • 向浏览器上输出一个java变量

      • <% String name = “jack”;  
out.write("name = " + name); %>

      • 以上代码中的out是JSP的九大内置对象之一（在service方法中被创建），可以直接拿来用（只能在service方法内部使用）

    • 向浏览器上输出的内容中没有“java代码”，可以直接在jsp中编写，不需要写到<%%> 这里

    • 输出的内容中含有“java代码”，可以使用以下语法格式

    • <%= %> ，在=的后面编写要输出的内容

      • <%= %>

        • 翻译成java代码：out.print();，里面的代码不能加分号

        • 翻译到service方法当中

      • 使用<%=%> 的情况

        • 输出的内容中含有java的变量，是一个动态的内容，不是一个死的字符串

        • 如果输出的是一个固定的字符串，直接在JSP文件中编写即可

JSP的专业注释

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

  • <!--这种注释属于HTML的注释，这个注释信息仍然会被翻译到java源代码当中，不建议-->

JSP基础语法总结

  • JSP中直接编写普通字符串

    • 翻译到service方法的out.write("普通字符串")

  • <%%>

    • 翻译到service方法体内部，里面是一条一条的java语句

  • <%! %>

    • 翻译到service方法之外

  • <%= %>

    • 翻译到service方法体内部，翻译为：out.print();

  • <%@page contentType="text/html;charset=UTF-8"%>

    • page指令，通过contentType属性用来设置响应的内容类型

  • 在jsp中编写的代码最终执行顺序不一定是从上到下的，要根据具体的符号而定，相同符号有从上到下的先后顺序

    • <%! %>中的代码最终翻译在类体中，即使在jsp代码的后面也比<%%>中的代码先执行

    • 而两个<%%>是有先后执行顺序的

    image-20230124234006572

JSP的指令

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

  • 包括

    • include指令：包含指令，在JSP中完成静态包含，很少用

    • taglib指令：引入标签库的指令(到JJSTL标签库的时候再学习)

    • page指令：目前重点学习

  • 指令的使用语法

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

  • 关于page指令中常用的属性

    • 启/禁用JSP的内置对象session

      • true表示启用JSP的内置对象session，一定启动session对象（没有session对象会创建），没有设置，默认值就是session="true"

      • session="false" 表示不启动内置对象session，当前JSP页面中无法使用内置对象session

      <%@page session="true|false" %>

    • contentType属性

      • 设置响应的内容类型

      <%@page contentType="text/json" %>

      • 也可以设置响应字符集（方式一）

      <%@page contentType="text/json;charset=UTF-8" %>

    • pageEncoding属性

      • 设置响应时采用的字符集（方式二）

      <%@page pageEncoding="UTF-8" %>

    • import语句，导包

      <%@page import="java.util.List, java.util.Date, java.util.ArrayList" %>
<%@page import="java.util.*" %>

    • errorPage属性

      • 指定出错之后的跳转位置

      <%@page errorPage="/error.jsp" %>
<%--当前页面出现异常之后，跳转到error.jsp页面--%>

    • isErrorPage属性

      • 启用JSP九大内置对象之一：exception(异常对象),默认值是false（可以在错误处理页面启用）

      <%@page isErrorPage="true" %>

Servlet + JSP改造oa项目

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

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

  • 完成所有页面的正常流转（修改超链接的请求路径）

    • 如果发现修改路径后，浏览器的展示的路径还是没变，就要！！！清除浏览器缓存！！！

      • crtl+shift+delete

    • 在JSP中动态的获取应用的根路径并且输出到jsp代码中

      <%=request.getContextPath() %>

    • 动态根路径写到超链接中注意事项

      <a href="<%=request.getContextPath() %>/资源路径">超链接名称</a>

      • <%= %>之中可以随便加空格，最终都会被翻译成根路径

      • <%= %>之外不能随便加空格，因为符号之外的只是普通字符串，空格会被当成超链接的一部分

  • 展示数据

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

    • 遍历结果集的过程中，取出部门编号、部门名、位置等信息，封装成java对象

      • 将java对象存放到List集合中

      • 将List集合存储到request域当中

      • 转发forward到jsp(不要重定向)

    • 在JSP中

      • 从request域当中取出List集合

      • 遍历List集合，取出每个部门对象，动态生成表单

      • 注意

        • jsp中的符号不能嵌套使用，比如<% <%= %> %>是错的

        • 但是jsp符号有截断功能（本质就是翻译成java代码）

  • 修改功能的页面回显和详情功能获取数据基本一致，可以合并

    • 合并技巧（初版）

      • jsp中，二者跳转路径相同，请求头携带的数据不同，通过f的值来标识是哪个功能

      <a href="<%=request.getContextPath()%>/dept/detail?f=m&deptno=<%=dept.getDeptno()%>">修改</a>
<a href="<%=request.getContextPath()%>/dept/detail?f=d&deptno=<%=dept.getDeptno()%>">详情</a>

      • servlet中，获取f参数，根据f值决定查询数据之后要执行的功能

      String f = request.getParameter("f");
if ("m".equals(f)) {
    //走修改
    request.getRequestDispatcher("/edit.jsp").forward(request,response);
}else if("d".equals(f)) {
    //走详情
    request.getRequestDispatcher("/detail.jsp").forward(request, response);
}

    • 技巧升级版（缺点：如果两者跳转的资源文件后缀名不同，字符串拼接就有问题）

      • jsp中，二者跳转路径相同，请求头携带的数据不同，通过path的值来指定跳转路径

      <a href="<%=request.getContextPath()%>/dept/detail?path=edit&deptno=<%=dept.getDeptno()%>">修改</a>
<a href="<%=request.getContextPath()%>/dept/detail?path=detail&deptno=<%=dept.getDeptno()%>">详情</a>

      • servlet中，获取前端选择的跳转资源路径，进行字符串拼接转发

      String path=request.getParameter("path");
request.getRequestDispatcher("/"+path+".jsp").forward(request,response);

  • 只用JSP这一个技术也可以开发web应用

    • JSP就是Servlet，在JSP的<%%>里面写的代码就是在service方法当中的，所以在<%%>当中完全可以编写JDBC代码，连接数据库，查询数据，编写业务逻辑代码，处理业务等等

    • 建议采用servlet + jsp的方式进行开发，将各自的优点发挥出来，JSP就是做数据展示，Servlet就是做数据的收集（JSP中编写的Java代码越少越好）

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

    • 任何用户都可以访问这个系统，对系统当中的数据进行增删改操作。只让合法用户访问该系统的方式

      • 加一个登录功能。登录成功的可以访问该系统，登录失败不能访问

    • 实现登录功能：

      • 步骤1：数据库中添加一个用户表：t_user

        • t_user表当中存储的是用户的登录信息，最基本的包括：用户名和密码

        • 密码一般在数据库表中存储的是密文，不以明文的形式存储（一般采用MD5加密，这里先使用明文方式）

        • 向t_user表中插入数据

      • 步骤2：再实现一个登录页面和登录失败的页面

        • 登录页面上应该有一个登录的表单，有用户名和密码输入框

        • 用户点击登录，提交用户名和密码（form以post方式提交）

      • 步骤3：后台要有一个对应的Servlet来处理登录的请求

        • 登录成功：跳转到部门列表页面

        • 登录失败：跳转到失败的页面

  • 目前的登录功能存在的最大问题

    • 只是一个摆设，没有任何作用：只要用户知道后端的请求路径，照样可以在不登录的情况下访问

    • 没有真正起到拦截作用

EL表达式

定义和作用

  • Expression Language（表达式语言）

    • 表达式：由变量或常量与符号的组合

  • EL表达式可以代替JSP中的java代码，让JSP文件中的程序看起来更加整洁、美观（简化jsp）

    • JSP中夹杂着各种java代码，例如<% java代码 %>、<%=%>等，导致JSP文件很混乱，不好看且不好维护

    • jsp2.0时引入el表达式

  • EL表达式可以算是JSP语法的一部分，EL表达式归属于JSP

  • jsp中EL表达式的功效（只负责取不负责存）

    • 从某个作用域中取数据，然后将其转换成字符串，然后将其输出到浏览器，三大功效

      • 第一功效：从某个域中取数据

        • 四个域

          • pageContext

          • request

          • session

          • application

      • 第二功效：将取出的数据转成字符串

        • 如果是一个java对象，会自动调用java对象的toString方法将其转换成字符串。

      • 第三功效：将字符串输出到浏览器

        • 等同于<%= %>

  • EL表达式对null进行了预处理

    • 如果是null，则向浏览器输出空字符串

    • el表达式实际运行时会被翻译成Java代码

    ${usernam} 等同于 <%=request.getAttribute("usernam")==?"":request.getAttribute("usernam") %>

    • 相较于<%=域.getAttribute()%>输出null，el表达式更适合页面展示

EL表达式的使用

  • 基本语法格式：${表达式}

具体获取数据步骤

  • 先通过jsp符号将User对象存储到某个域当中，EL表达式只能从某个范围中取数据（ 数据是必须存储到四大范围之一）

    <%
	// 创建User对象
	User user = new User();
	user.setUsername("jackson");
	user.setPassword("1234");
	user.setAge(50);
	request.setAttribute("userObj", user);
%>

  • 使用EL表达式

    • ${这里写的是存储到域对象中name}(不含双引号)

    • ${userObj}等同于java代码<%=request.getAttribute("userObj")%>

    • ${userObj} 底层执行

      • 从域中取数据，取出user对象

      • 调用user对象的toString方法，转换成字符串，输出到浏览器

  • 输出对象的属性值

    • 语法${存储到域对象中name.属性名对应的get方法去掉get并且把首字母大写后的字符串}

    • 使用这个语法的前提是：该对象有get方法，不一定要有与之对应的属性（和成员变量无关，只取决于get方法）

    • EL表达式中. 这个语法，实际上调用了底层的getXxx()方法，没有对应的get方法，会报500错误

    ${userObj.username} 使用这个语法的前提是：User对象有getUsername()方法
${userObj.password} 使用这个语法的前提是：User对象有getPassword()方法
${userObj.age} 使用这个语法的前提是：User对象有getAge()方法
${userObj.email} 使用这个语法的前提是：User对象有getEmail()方法

${userObj.addr222.zipcode}
以上EL表达式对应的java代码：
user.getAddr222().getZipcode()

  • 面试题：${abc} 和 ${"abc"}的区别

    • ${abc}表示从某个域中取出数据，并且这个数据的name是"abc"，取之前一定有这样的代码: 域.setAttribute("abc", 对象);

    • ${"abc"} 表示直接将"abc"当做普通字符串输出到浏览器(不会从某个域中取数据）

取数据的范围

  • EL表达式优先从小范围中读取数据(没指定范围的前提)

    • pageContext < request < session < application

    • 假设不同域存的数据name相同，输出最小范围域的数据

  • EL表达式隐含的隐式的范围（可以从指定范围中取数据）

  • el表达式四个隐式范围对象对应的范围

    • pageScope 对应的是 pageContext范围

      • requestScope 对应的是 request范围

      • sessionScope 对应的是 session范围

      • applicationScope 对应的是 application范围

    • 语法${范围.name}

    • 注意：指定了范围，如果找不到对应的name就不会从其它域去找

取数据的两种形式

  • 第一种：. name （大部分使用）

  • 第二种：[" name"]

    • 存储到域的name中含有特殊字符，可以使用 [ ]

    • 比如request.setAttribute("abc.def", "zhangsan");

      • ${requestScope.abc.def} 这样是无法取值的

    • 应该这样：${requestScope["abc.def"]}

    • 使用[]要加双引号，不加双引号会将其看成变量

不同数据结构中取数据

  • 如果取的是对象，则会调用该对象的toString方法

  • 从实体类中取数据（前面的取数据都是）

    • 实体类的属性要有对应的get方法

    • 会报500异常的情况

      • 属性没有get方法

      • 不是属性而且也没有get方法

    • 不是实体类的属性但是有get方法不会报异常

    • 如果实体类作为数组或者集合的元素，域中传入数组或者集合，取实体类元素的属性，该属性也要满足第一条

    image-20230201210117002

  • 从Map集合中取数据

    • ${name.key}

image-20230201204755974

image-20230201205057681

  • 从数组中取数据

    • 取数组对象${name}

    • 取数组元素${name[0]}

    image-20230201205314347

    • 数组越界处理

      • 取不出数据在浏览器显示空白，不报错（不会出现下标越界）

  • 从list集合取数据

    • 取list对象${name}

    • 取list集合元素${name[0]}

    image-20230201211801478

  • 从set集合中取数据

    • 取set对象${name}

    • 因为set无序，所以无法取set集合的元素，否则会报错

    image-20230201211543656

忽略EL表达式

  • 设置忽略el表达式会导致其被当成普通字符串来看待，即在浏览器输出${name}这样的字符串

  • page指令中的isELIgnored属性（全局忽略）

    <%@page contentType="text/html;charset=UTF-8" isELIgnored="true" %>
isELIgnored="true" 表示忽略EL表达式
isELIgnored="false" 表示不忽略EL表达式（默认值）

  • 局部忽略

    • 使用反斜杠

      \${username}

其他隐式对象

  • pageContext

    • 和jsp中的内置对象是同一个

    • el表达式中没有其他域对象，但是pageContext对象有获取其它域对象的get方法（el表达式可以调用对象的get方法）

    image-20230201214038711

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

      • ${pageContext.request.contextPath}等同于

        <%=((HttpServletRequest)pageContext.getRequest()).getContextPath()%>
//获取到的request对象要强转成httpServletRequest

        • pageContext.getRequest()获取到的是ServletRequest的request对象

        • getContextPath()是httpServletRequest对象的方法

      • <%=request.getContextPath()%>

  • param

    • 获取单个提交的数据

      ${param.username}等同于<%=request.getParameter("username")%>

    • 如果提交多个数据，则获取第一个数据

  • paramValues

    • 获取多个提交的数据，以数组形式存储

      ${paramValues.habbies}等同于<%=request.getParameterValues("habbies")%>

    • 获取 数组单个元素需要通过下标

      ${paramValues.habbies[0]}

  • initParam

    • 获取初始化配置信息

      • initParam获取的属性名必须是web.xml文件中context-param标签中的param-name

      • 没有对应的属性则输出空白

    • 初始化配置信息存在ServletContext（上下文）对象中，对应的jsp九大内置对象——application

image-20230202180628062

运算符（了解）

  • 算术运算符

    • +、-、*、/、%

    • el表达式中+不会做字符串拼接，只能做求和运算（会先把字符串转化成数字，无法转换就报错）

      • #{10+"20"}输出结果是30（字符串"20"自动转化成数字20）

      • #{10+"abc"}会报数字转化异常

      image-20230202181940622

  • 关系运算符

    • ==/eq != > >= < <=

    • el表达式的==、eq、!=底层都调用了equal方法(下面的例子和字符串常量池无关，就是两个不同的字符串对象)

    image-20230202185426651

    • eq使用#{变量A eq 变量B}等同于<%= A.equal(B)%>

image-20230202195307073

  • 逻辑运算符

    • == ! && || not(!和not都是取反) and or

  • 条件运算符

    • ? :

    • 条件？满足条件的情况：不满足的情况

  • 取值运算符

    • [ ]和.

  • empty运算符

    • 判断是否为空，结果是boolean类型

      • 为空为true

    • 使用：${empty 获取的数据}

      • ${empty param.username}

      • ${empty 空数据==null}

        • 结果是false

        • 因为前半部分是Boolean类型，Boolean类型==null结果为false

        • ${empty 空数据！=null}结果就为true

JSTL标签库

定义与作用

  • 全称Java Standard Tag Lib（Java标准的标签库）

  • JSTL标签库通常结合EL表达式一起使用，目的是代替jsp中的java代码

  • 标签是写在JSP当中的，但实际上最终还是要执行对应的java程序（java程序在jar包当中）

使用步骤

  • 第一步：引入JSTL标签库对应的jar包（tomcat没有自带，要自己去找）

    • tomcat10之后引入的jar包是（之前的就是javax.servlet....）

      • 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服务器没有的

        • tomcat自带的直接在项目模块导入依赖

      • 引入之后可以在build中对项目进行rebuild（防止idea有延迟，非必须）

        image-20230202202312266

        image-20230202202326516

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

    image-20230202203402291

    • 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文件是：c.tld文件

    • tld文件实际上是一个xml配置文件

      • 在tld文件中描述了“标签”和“java类”之间的关系

      • 在jakarta.servlet.jsp.jstl-2.0.0.jar里面META-INF目录下，有一个c.tld文件

      • jsp找到标识之后就去找对应的uri，通过uri定位到tld文件

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

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

<c:catch var="">
	JSP....
</c:catch>

  • jstl中的核心标签库core中常用标签

    • c:if

      • <c:if test="boolean类型，支持EL表达式" var="boolean类型的值 " scope="指定var的存储域 "></c: if>

        • test属性是必须的，为true时执行该标签体内容

        • var和scope都是非必须的

          • scope不能单独使用，要和var一起联用

          image-20230203115632668

          • scope有四个值可选（request，page，session，application）

      • 标签库没有else标签，实现if-else效果可以用两个if代替

    • c:forEach

      <c:forEach items="集合，支持EL表达式" var="名字随意，代表集合中的元素" varStatus="元素的状态对象"> </c:forEach>

      • varStatus这个状态对象有个count属性（可以直接使用）

        • ${状态对象.count}

        • count从1开始，用于编/序号

      <c:forEach var="指定循环的变量" begin="开始值" end="结束值" step="步长"> ${i} </c:forEach>

      • 底层将var中的变量存到page域，所以才能使用el表达式将其取出

    • c:choose c:when c:otherwise

      • 类似 if——if-else若干——else

      • <c:choose>
    <c:when test="${param.age < 18}">
        青少年
    </c:when>
    <c:when test="${param.age < 35}">
        青年
    </c:when>
    <c:when test="${param.age < 55}">
        中年
    </c:when>
    <c:otherwise>
        老年
    </c:otherwise>
</c:choose>

改造OA

  • 在前端HTML代码中，有一个base标签，可以设置整个网页的基础路径

    • 是HTML中的一个语法（不Java的语法，也不是JSP的语法，通常出现在head标签中）

  • < base href="http://localhost:8080/oa/">（以”/"结尾）

    • 在当前页面中，凡是路径没有以“/”开始的，都会自动将base中的路径添加到这些路径之前（对没以”/“开始的路径起作用）

      • < a href="ab/def"></ a>

    • 等同于：< a href="http://localhost:8080/oa/ab/def"></ a>

    • 在JS代码中的路径，保险起见，最好不要依赖base标签（最好写上全路径）

  • 动态获取base

    <base href="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${pageContext.request.contextPath}/">

    • ${pageContext.request.scheme}获取协议名（http..）

    • ${pageContext.request.serverName}服务器ip地址

    • ${pageContext.request.serverPort}端口号

    • ${pageContext.request.contextPath}项目根路径

    • 注意最后结尾的“/”不能丢

Filter过滤器

  • 当前的OA项目存在的缺陷

    • DeptServlet、EmpServlet、OrderServlet每一个Servlet都是处理自己相关的业务

      • 在这些Servlet执行之前都是需要判断用户是否登录了

        • 判断用户是否登录的代码是固定的，并且在每一个Servlet类当中都需要编写，代码没有得到重复利用

      • 每一个Servlet都要解决中文乱码问题，也有公共的代码这些代码目前都是重复编写，并没有达到复用

    • 可以使用Servlet规范中的Filter过滤器来解决这个问题

定义、作用和执行原理

image-20230205203106721

  • Filter是过滤器，是一个java程序，过滤器和请求路径对应

  • 把Servlet程序看成目标程序（Servlet和请求路径对应）

    • Filter可以在目标程序执行之前添加过滤代码

    • 也可以在目标执行之后添加代码

    • 之前之后都可以添加过滤规则

  • 一般情况下，都是在过滤器当中编写公共代码

编写一个过滤器

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

    • tomcat10之后Filter的init和destroy方法被声明成默认方法，可以不用继承

    • init方法：在Filter对象第一次被创建之后调用，并且只调用一次

    • doFilter方法：只要用户发送一次请求，则执行一次。发送N次请求，则执行N次。在这个方法中编写过滤规则

    • destroy方法：在Filter对象被释放/销毁之前调用，并且只调用一次

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

    • <filter>
    <filter-name>filter2</filter-name>
    <filter-class>com.bjpowernode.javaweb.servlet.Filter2</filter-class>
</filter>
<filter-mapping>
    <filter-name>filter2</filter-name>
    <url-pattern>*.do</url-pattern>
</filter-mapping>

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

  • Filter的生命周期

    • 和Servlet对象生命周期基本一致

      • 唯一的区别：Filter默认情况下，在服务器启动阶段就实例化

        • Servlet对象默认情况下，在服务器启动的时候是不会新建对象的

        • Servlet和Filter都是单例的（单实例）

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

    • 第一：在过滤器当中是否编写了：chain.doFilter(request, response);

      • chain.doFilter(request, response);的作用：执行下一个过滤器，如果下面没有过滤器了，执行最终的Servlet

      • chain.doFilter

        • 之前的代码是在请求时添加过滤规范

        • 之后的代码是在响应时添加过滤规范

    • 第二：用户发送的请求路径是否和Servlet的请求路径一致

  • 注意：Filter的优先级比Servlet优先级高

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

关于Filter的配置路径

  • /a.do、/b.do、/dept/save这些配置方式都是精确匹配

  • 模糊匹配

    • /* 匹配所有路径

    • *.do 后缀/扩展匹配（匹配所有以.do结尾的路径，不要以 / 开始）

    • /dept/* 前缀匹配（匹配所有以/dept开始的路径，要以 / 开始）

Filter的执行顺序

  • 在web.xml文件中进行配置的时候

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

  • 使用@WebFilter的时候

    • 执行顺序的原则是：比较Filter这个类名

      • 比如：FilterA和FilterB，则先执行FilterA

      • 比如：Filter1和Filter2，则先执行Filter1

  • 过滤器的调用顺序，遵循栈数据结构(先进后出)

责任链设计模式

  • 责任链设计模式最大的核心思想：在程序运行阶段，动态组合程序的调用顺序

  • Filter过滤器有该设计模式

  • 过滤器最大的优点

    • 在程序编译阶段不会确定调用顺序

      • Filter的调用顺序是配置到web.xml文件中的，只要修改web.xml配置文件中filter-mapping的顺序就可以调整Filter的执行顺序，显然Filter的执行顺序是在程序运行阶段动态组合的。那么这种设计模式被称为责任链设计模式

      • Filter一般路径配置到web.xml中，如果是写注解，修改顺序时还要修改相应类名，违背了ocp开闭原则

改造项目

  • 使用filter检查登录状态

  • 先把filter中的request和response对象强转为HttpServletRequest和HttpServletResponse

  • 然后通过请求对象获取session对象

  • 注意filter路径

    • index.jsp不能拦截（用户要去登录被拦截）

    • 欢迎界面不能拦截

    • 登录界面不能拦截

    • 如果写错可能导致项目访问失败

Listener监听器

相关知识

  • 监听器是Servlet规范中的一员

  • 在Servlet中，所有的监听器接口都是以“Listener”结尾

  • 实际用的不多

  • 作用

    • 监听器实际上是Servlet规范留给我们javaweb程序员的特殊时机

Servlet规范中提供的监听器

  • 总共有九个

  • 类型

    • xxxListener监听对应的域对象创建和销毁等等

    • xxxAttributeListener监听的是对应的域中数据变化

      • 接口中有三个方法分别对应数据的增删改（改指的是覆盖原有的同名数据）

  • jakarta.servlet包下

    • ServletContextListener

    • ServletContextAttributeListener

    • ServletRequestListener

    • ServletRequestAttributeListener

  • jakarta.servlet.http包下

    • HttpSessionListener

    • HttpSessionAttributeListener

      • 该监听器需要使用@WebListener注解进行标注

      • 该监听器监听的是session域中数据的变化

      • 只要数据变化，则执行相应的方法。主要监测点在session域对象上

    • HttpSessionBindingListener

      • 该监听器不需要使用@WebListener进行标注，不是web监听器，用来监听普通java对象

      • 假设User类实现了该监听器，那么该对象

        • 在被放入session时触发bind事件

        • 从session中删除时触发unbind事件

      • 实体类继承了就有专属待遇

    • HttpSessionIdListener

      • session的id发生改变的时候，监听器中的唯一一个方法就会被调用。

    • HttpSessionActivationListener

      • 监听session对象的钝化和活化的

        • 钝化：session对象从内存存储到硬盘文件

        • 活化：从硬盘文件把session恢复到内存

实现一个监听器的步骤

  • 以ServletContextListener为例

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

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

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

    • <listener>
    <listener-class>com.bjpowernode.javaweb.listener.MyServletContextListener</listener-class>
</listener>

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

  • 注意：所有监听器中的方法不需要javaweb程序员调用，由服务器来负责调用

    • 当某个特殊的事件发生之后被web服务器自动调用

      • 例如上面的两个方法分别在context创建和销毁时被服务器调用

业务场景

  • 请编写一个功能，记录该网站实时的在线用户（所有用户包括游客）的个数

    • HttpSessionListener够用了。session对象只要新建，则count++

    • 然后将count存储到ServletContext域当中，在页面展示在线人数即可

  • 业务发生改变了，统计登录的用户的在线数量

    • session.setAttribute("user", userObj);

    • 用户登录的标志是session中存储过User类型的对象

    • 可以让User类型的对象实现HttpSessionBindingListener监听器，只要User类型对象存储到session域中，则count++

    • 然后将count存储到ServletContext对象中，页面展示在线人数即可

统计当前登录在线的人数

  • 用户登录

    • session.setAttribute("user", userObj); User类型的对象只要往session中存储过，表示有新用户登录

      @Override
public void valueBound(HttpSessionBindingEvent event) {
    //先通过event对象获取count，因为是所有用户数量，所以去application域中取
    ServletContext application = event.getSession().getServletContext();
    Integer count = (Integer) application.getAttribute("count");
    if(count==null){
        //说明当前只有一个用户登录,要把count存入域中
        application.setAttribute("count",1);
    }else {
        count++;
        application.setAttribute("count",count);
    }
}

    • 然后执行用户的监听器，从application域中获取当前用户数量count，执行count+1

  • 用户退出

    • session.removeAttribute("user"); User类型的对象从session域中移除

    • 或者有可能是session超时被销毁

    • 执行监听器将count-1

      @Override
public void valueUnbound(HttpSessionBindingEvent event) {
  //先通过event对象获取count，因为是所有用户数量，所以去application域中取
  ServletContext application = event.getSession().getServletContext();
  Integer count = (Integer) application.getAttribute("count");
  count--;
  application.setAttribute("count",count);
}

    • 缺点

      • 同一浏览器登录两个不同用户只算一人登录

！！！Mvc架构模式！！！

案例引入

  • 银行项目转账

    • 不用mvc之前的问题

      • 代码复用性差，没有进行职能分工，没有独立组件的概念

      • 代码之间的耦合度太高，导致代码扩展力差

      • 操作数据库和业务逻辑混在一起，容易出错

理论基础

  • 系统分层的原因

    • 各司其职，让代码耦合度降低，扩展力增强，组件可复用性提高

  • Mvc架构模式

    • Modle：数据/业务

      • pojo/bean/domain

      • service（只执行业务逻辑）

      • dao(只执行数据库相关操作)

    • View：视图/展示

    • Controller：控制器

      • 是核心

      • 调度作用

  • 横向MVC

    image-20230208151937321

  • 纵向三层架构

image-20230210000028989

  • 二者关系图解

image-20230210000054342

实现mvc架构

封装数据库

  • 新建数据库工具类

  • 将构造方法私有化

    • 为了防止创建对象

    • 因为工具类中的方法都是静态的，不需要创建对象

  • 使用静态代码块，在类加载的时候注册驱动

DAO

  • 定义：data access object数据访问对象

  • 实际上是javaEE的设计模式（不是23种设计模式）

  • 作用：只负责数据增删改查，没有任何业务逻辑

  • 实操

    • 先创建账户类account（pojo或者JavaBean或者domain【领域模型对象】）

      • 实体类用于封装信息

      • 一般是一张表一个

      • 成员变量的类型不为基本数据类型，建议使用引用数据类型（包装类）

        • 因为从数据库中可能查到null

        • null赋给基本数据类型会报错

service类

  • 业务类

  • 类中只编写纯业务代码

  • 类名不一定要叫xxxService

  • 方法取名要和业务挂钩，一般是一个业务对应一个方法

  • 实操

    • 转账业务

    • 定义一个账户数据操作对象（DAO对象）作为成员变量，定义在业务方法之外是因为每个业务方法都可能需要连接数据库

    • 事务问题

      • 转出和转入操作要执行两次update，如果中间发生异常会导致财产损失

      • 事务是在业务逻辑层进行控制，一般一个完整的业务流程对应一个事务

      • 解决

        1. 修改DAO代码，方法中接收service中传入的connection对象

          • DAO代码中的方法不能关闭connection对象，要在service方法执行接受之后关闭

          • try括号中可以写多行语句，会自动关闭括号中的资源，无需finally

            try(Connection conn= DBUtils.getConnection())

        2. 线程

          image-20230327203357457

          • 一个栈对应一个线程，可以将这个线程作为map集合的键，值为connection对象，其它方法可以通过当前线程去获取同一个connection对象

          • 不同用户可以根据各自的线程去获取自己connection对象

            • java中已经有现成的ThreadLocal类（本质是大Map，key为当前线程，value为绑定的数据）

          • 改造工具类

            • 关闭连接对象之后要移除当前线程，因为tomcat支持线程池，一个用户用过的线程可能会被其他用户获取到

              • 如果不移除，该线程绑定的connect对象已经被关闭，会出现问题

            • 关闭连接对象的操作要在service执行完之后关闭,在dao中的方法关闭会获取到不一样的连接对象

          private static ThreadLocal<Connection> local=new ThreadLocal<>();//用于将当前线程和连接对象绑定
public static Connection getConnection() throws SQLException {
        Connection connection=local.get();
        if(connection==null){ 
            //当前线程未绑定connection对象就创建对象，并且存入集合
        connection= DriverManager.getConnection(url, user, password);
        local.set(connection);
        }
        return connection;
    }
//释放资源
public static void close(Connection conn, Statement ps, ResultSet rs){
    if(conn!=null){
        try {
            conn.close();
            local.remove();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }if(ps!=null){
        try {
            ps.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }if(rs!=null){
        try {
            rs.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}
按职能将类放入对应的包

image-20230328195035580

面向接口编程

  • 原因：为了降低耦合度，提高扩展力

  • 对应包下再创建对应接口和一个impl包，impl包中存放实现类，类名以impl结尾

image-20230328201708544

  • 利用多态的方式，父类型引用指向父类型对象，所有方法中的对象调用的都是接口中的方法

AccountService accountService=new AccountServiceimpl();

  • 仍存在的问题

    • 业务方法有控制事务的代码（动态代理可以解决，aop）

    • 引用接口方法仍要创建实现类，当前类和引用接口的实现类的耦合度较高，并没有完全解决对象和对象之间的依赖关系（使用 ioc容器可以解决）

其它知识

JavaBean

定义与功能

  • 可以理解为符合某种规范的java类

  • 其实是java中的实体类，负责数据的封装

  • 由于javabean符合javabean规范，具有更强的通用性

规范要求

  • 有无参数的构造方法

  • 属性私有化对外

  • 提供setter和getter方法

  • 重写toString()，hashCode + equals

  • 实现java.io.Serializable接口（建议手动加个序列化版本号）

静态代码块

  • 在类加载时执行，并且只执行一次

  • 静态代码块用的实际上不多，用途

    • 静态代码块是java语言为java程序员预留的一个特殊的时机:类加载时机

    • 需要在类加载时机去执行一段代码，就可以把这个代码写入静态代码块

断线续传
关注
  • 21
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
动力节点老杜Java零基础笔记第二章 初识Java
A_coding的博客
06-01 824
计算机是一种现代化的电子设备，它能够接受、存储、处理和输出数据。计算机由硬件和软件两部分组成，硬件包括中央处理器（CPU）、内存、硬盘、显示器、键盘、鼠标等部件，软件则包括系统软件和应用软件。计算机可以进行各种操作，如文字处理、图形设计、音视频播放、游戏等，并且可以通过网络连接进行通信和数据交换。计算机技术的发展对人类社会的影响非常深远，它已经成为现代化社会中不可或缺的一部分。硬件是计算机系统的物理部分，主要包括以下组件：还有其他硬件组件，如声卡、网卡、显卡、光驱、散热器等。这些硬件组件共同工作，使计算机能
Spring动力节点老杜课程学习笔记
m0_48038376的博客
01-01 1364
Spring动力节点老杜课程笔记
动力节点Maven课程笔记
while(true)
08-19 263
为了能能够实现软件的流水线式生产，在设计和构建软件的是hi偶能能够有一种规范和工程化的方法，人们便提出了软件工程的概念。用的是Junit，junit是一个专门测试的框架（工具），测试的是类中的方法，每一个方法都是独立测试的。方法是测试的基本单位（单元）。maven借助单元测试，批量的测试你类中大量的方法是否符合预期。...
[Java]Mybatis学习笔记(动力节点老杜)
emmmm.....
02-01 2788
🥽 Mybatis下载 🥽 了解Mybatis 🌊 ORM思想 🌊 Mybatis与ORM 🌊 MyBatis框架特点 🥽 Mybatis入门程序 🌊 数据库表的准备 🌊 创建Project 🌊 创建Module 🌊 设置打包⽅式 🌊 引⼊依赖 🌊 编写mybatis核心配置文件：mybatis-config.xml 🌊 mybatis中有两个主要的配置文件： 🌊 编写XxxxMapper.xml文件 🌊 在mybatis-config.xml文件中指定XxxxMapper.x
HTML笔记-动力节点
qwerasdctds的博客
07-03 190
HTML笔记
动力节点springboot笔记
m0_51654746的博客
07-20 584
创建好springboot项目就代表了已经创建好了springmvc项目，因为springboot框架已经帮助我们自动配置了springmvc，之后按照springmvc的代码书写规范就可以进行书写了注：创建包的时候一定要创建在application类的同级包下IndexController类 启动项目的方式就是直接运行applicaiton中的main方法注：核心配置文件在一个项目中只能有一个 3.2、yml和yaml配置文件 使用springboot核心配置文件application.yml或者appl
动力节点-MyBatis框架笔记
丶没胡子的猫
10-09 1055
目录MyBatis 框架第1章 框架概述1.1 软件开发常用结构1.1.1 三层架构1.1.2 常用框架1.2 框架是什么1.2.1 框架定义1.2.2 框架解决的问题1.3 JDBC 编程1.3.1 使用 JDBC 编程的回顾1.3.2 使用 JDBC 的缺陷1.4 MyBatis 框架概述1.4.1 MyBatis 解决的主要问题第2章 MyBatis 框架快速入门2.1 入门案例2.1.1 使用 Mybatis 准备2.1.2 搭建 MyBatis 开发环境2.2 基本的 CURD2.2.1 inse
[Java]JavaWeb学习笔记(动力节点老杜2022)【Javaweb+MVC架构模式完结】
emmmm.....
01-25 8657
主要内容包括：Servlet、JSP、EL表达式、JSTL标签库、Filter过滤器、Listener监听器。
jdbc(B站动力节点老杜)学习笔记复习使用
weixin_53818758的博客
05-04 1763
jdbc概述 什么是jdbc? java语言连接数据库的一套接口,jdbc是SUN公司定制的一套接口 为什么要SUN公司要制定一套接口？ 每个数据库的底层实现原理不同，程序员要想使用java连接某一个数据库就需要遵循哪一个数据库的规范。设想,我们程序员如果想用另一个数据库,就要遵循另一个数据库的规范,这样非常的繁琐。 所以SUN公司制定一套接口，每个数据库厂家负责编写JDBC的实现类，这些实现类存储在jar包，这些jar包就是驱动。我们程序员面向JDBC接口写代码。 引用B站老杜的一张图来描述.
动力节点王鹤Spring框架学习笔记
01-12
动力节点王鹤老师的Spring框架教程配套笔记分享
动力节点老杜Spring6，配套笔记PDF文件
02-08
动力节点老杜Spring6，配套笔记PDF文件 源自https://www.yuque.com/dujubin/ltckqu/kipzgd?singleDoc#Kp2MS
动力节点_Java零基础_课堂笔记.zip
05-09
动力节点_Java零基础_课堂笔记 不过只有开头几节，谨慎下载
Java Socket编程笔记_动力节点Java学院整理
08-30
Socket对于我们来说就非常实用了。下面是本次学习的笔记。主要分异常类型、交互原理、Socket、ServerSocket、多线程这几个方面阐述
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1198
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1074
介绍了Java泛型中的重要知识点——通配泛型及其应用。
Java---类和方法的再学习
最新发布
m0_74012211的博客
05-05 1114
Java类与对象
【Java基础】三大特性——多态
qq_43714449的博客
05-05 407
它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。实现一个功能时，功能的一部分是确定的，一部分是不确定，确定的部分还会用到不确定的部分，那么就把不确定的部分暴露出去，让子类去实现。通常通过重写toString方法，来返回有用的数据。instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。确定的部分：记录一个开始时间，记录一个结束时间，结束时间 - 开始时间。对类存在的语法，对接口也存在。，返回对象的字符串表示形式。判断两个人是否是同龄人。
动力节点javase笔记
09-07
动力节点Javase笔记是一份非常重要的学习资料。首先，这份笔记涵盖了JavaSE相关的基本概念和知识点。它可以帮助学习者系统地掌握JavaSE的核心语法、面向对象编程、异常处理、集合框架等基础知识。 其次，动力节点Javase笔记提供了大量实际案例和代码示例。这些案例可以帮助学习者更好地理解JavaSE的应用场景和实际应用。通过阅读这些案例，学习者可以学会如何解决实际编程中遇到的问题，提高编程能力。 另外，这份笔记还强调了重要的注意事项和常见错误。对于初学者来说，这些提示非常有帮助。它们可以帮助学习者避免一些常见的编码错误，提高代码质量和调试能力。 总而言之，动力节点Javase笔记是一份非常全面和实用的学习资料。无论你是刚刚入门的初学者，还是有一定基础的中级开发者，这份笔记都可以帮助你进一步提高和巩固JavaSE的知识。相信通过认真阅读和实践，你一定能够掌握JavaSE的核心概念和技能，成为一个优秀的Java开发者。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值