动力节点Java Web知识笔记

2024-03-19 18:20:04 分类：前端 热度：85 评论： 0

前言

  • 本文来自动力节点老杜的JavaWeb视频教程，跟着老杜学javaweb零基础入门到精通_哔哩哔哩_bilibili
  • 本文是对原视频内容进行归纳总结，由于作者记笔记时图片用的是本机路径，所以导致本文无法显示图片，如果有图片需求可以看上方的pdf

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.***是域名

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

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

    • IP地址

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

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

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

    • 端口号

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

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

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

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

  1. 用户输入网址（URL）

    • 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代码，展示效果

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服务器解析配置文件，找到资源

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

  • 绝对路径

<!--以/开始，带项目名，是一个绝对路径。不需要添加：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角色和协议

角色

  • 浏览器软件开发商

  • 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规范

开发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-***plete="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-***plete="true">
	<!--servlet描述信息-->
	<!--任何一个servlet都对应一个servlet-mapping -->
	<servlet>
		<servlet-name>fdsafdsagfdsafdsa</servlet-name>
		<servlet-class>***.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对象初始化信息等等

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

      • http://127.0.0.1:8080/项目名称/url-pattern

    • 浏览器上的请求路径必须和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目录下（***.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>***.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对象和请求路径之间的关系

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

服务器启动

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

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

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

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

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

      <servlet>
    <servlet-name>aservlet</servlet-name>
    <servlet-class>***.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类中编写一个有参数的构造方法，没有手动编写无参数构造方法会出现的问题

  • 报错：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("***.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，将该局部变量赋值给成员变量（改造一）

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

  • 子类重写的init方法

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

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

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

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

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服务器创建。默认情况下，都是在发送第一次请求的时候被创建

    • 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_a***ess_log.日期.txt 访问日志

public void log(String message);// 这些日志信息记录到localhost.日期.log
public void log(String message, Throwable t);//记录异常信息
向应用域存取删数据
// 存（向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的关系和区别

            • URL包括URI

            • http://localhost:8080/servlet05/index.html 是URL

            • /servlet05/index.html 这是URI

        • 第三部分：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
A***ept: 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
A***ept-Encoding: gzip, deflate, br
A***ept-Language: zh-***,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
A***ept: 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
A***ept-Encoding: gzip, deflate, br
A***ept-Language: zh-***,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请求在“请求行”上发送数据）

    • http://localhost:8080/servlet05/getServlet?username=zhangsan&userpwd=1111

  • 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请求支持缓存

    • https://n.sinaimg.***/finance/590/w240h350/20211101/b40c-b425eb67cabc342ff5b9dc018b4b00***.jpg

    • 任何一个get请求最终的“响应结果”都会被浏览器缓存起来。在浏览器缓存当中：

      • 一个get请求的路径对应一个资源

    • 发送get请求，浏览器先从本地浏览器缓存中找，找不到的时候才会去服务器上获取。这种缓存机制目的是为了提高用户的体验

      • 需求：避免get请求走缓存，让这个get请求都去服务器上找资源，不从本地浏览器的缓存中取的

        • 只要每一次get请求的请求路径不同即可

      • 解决：可以在路径的后面添加一个每时每刻都在变化的“时间戳”，每一次的请求路径都不一样，浏览器就不走缓存

        • https://n.sinaimg.***/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00***.jpg?t=系统毫秒数

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

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

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

选择（衡量标准）

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

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

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

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

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

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

注意事项

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

  • 网页换行

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

    • 页面换行用

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

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

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

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

设计模式包括

  • GoF设计模式：

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

    • 单例模式

    • 工厂模式

    • 代理模式

    • 门面模式

    • 责任链设计模式

    • 观察者模式

    • 模板方法设计模式

    • .....

  • JavaEE设计模式：

    • DAO

    • DTO

    • VO

    • PO

    • pojo

    • ....

  • ....

模板方法设计模式

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

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

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

    • 代码复用

    • 算法得到了重复使用

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

  • 举例

    • 学生类和老师类

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

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

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

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 ***pare
                    // 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

      • 以上图为例，浏览器发送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测试方法

    • 命令行编译

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

    • 数组的toString

    存放的元素类型 地址

请求域对象操作
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方法

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

  • 两个Servlet共享数据

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

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

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

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

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

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

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

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

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

      • http://localhost:8080/servlet06/login.html 这种方式是指定了要访问的就是login.html资源。

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

      • http://localhost:8080/servlet06 我们访问的就是这个站点，没有指定具体的资源路径，默认会访问你设置的欢迎页面

  • 设置欢迎页面

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

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

      • <wel***e-file-list>
    <wel***e-file>login.html</wel***e-file>
</wel***e-file-list>

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

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

      • http://localhost:8080/servlet07

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

    • 在webapp根下新建page1

    • 在page1下新建page2目录

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

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

      • <wel***e-file-list>
    <wel***e-file>page1/page2/page.html</wel***e-file>
</wel***e-file-list>

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

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

    • <wel***e-file-list>
    <wel***e-file>page1/page2/page.html</wel***e-file>
    <wel***e-file>login.html</wel***e-file>
</wel***e-file-list>

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

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

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

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

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

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

        • <wel***e-file-list>
    <wel***e-file>index.html</wel***e-file>
    <wel***e-file>index.htm</wel***e-file>
    <wel***e-file>index.jsp</wel***e-file>
</wel***e-file-list>

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

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

  • 欢迎页可以是一个Servlet

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

    • 静态资源：index.html wel***e.html .....

    • 动态资源：Servlet类。

    • 步骤：

      • 第一步：写一个Servlet

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

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

        • <servlet>
        <servlet-name>wel***eServlet</servlet-name>
        <servlet-class>***.bjpowernode.javaweb.servlet.Wel***eServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>wel***eServlet</servlet-name>
        <url-pattern>/fdsa/fds/a/fds/af/ds/af/dsafdsafdsa</url-pattern>
    </servlet-mapping>

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

        • <wel***e-file-list>
        <wel***e-file>fdsa/fds/a/fds/af/ds/af/dsafdsafdsa</wel***e-file>
</wel***e-file-list>

！！！WEB-INF目录！！！

  • 在WEB-INF目录下新建了一个文件：wel***e.html，打开浏览器访问：http://localhost:8080/servlet07/WEB-INF/wel***e.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=***.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>***.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>***.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代码中

    • http://localhost:8080/oa/dept/delete?deptno=30

  • web.xml文件

    • 重写doGet方法

     //先获取部门编号
        String deptno = req.getParameter("deptno");
      Connection connection=null;
        PreparedStatement preparedStatement=null;
        int count=0;
        try {    
            connection = DBUtils.getConnection();
            //开启事务(关闭自动提交)
            connection.setAuto***mit(false);
            String sql="delete from dept where deptno=?";//占位符
            preparedStatement= connection.prepareStatement(sql);
            preparedStatement.setString(1,deptno);//给占位符赋值
            count = preparedStatement.executeUpdate();//返回值是影响了多少条记录
            connection.***mit();
        } 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代码错误

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

    • elements配合

      使用，选择页面元素信息

    • source可以进行断点调试

  • 后端，debug

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

    • 预览程序的所有断点

转发与重定向

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服务器内部完成的

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

选择

  • 如果在上一个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);
            }
        }
    }
}

  • 运行结果

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对象打标记，浏览器通过直接记下的标记找到该会话对象

  • 实现原理

    • web服务器中有个session列表

      • session列表是一个Map

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

        • value是session对象

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

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

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

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

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

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禁用

  • 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关联的路径)

    • 假设发送的请求路径是“http://localhost:8080/servlet13/cookie/generate”生成的cookie，如果cookie没有设置path

      • 浏览器提不提交cookie取决于默认路径，不在默认路径下的资源不提交

      • 默认的path是：http://localhost:8080/servlet13/cookie 以及它的子路径

        • http://localhost:8080/servlet13/cookie和http://localhost:8080/servlet13/cookie/generate都会发送cookie对象

      • 只要浏览器的请求路径是http://localhost:8080/项目名称（根路径）/生成cookie的servletpath的根目录【/子目录】

    • 设置cookie路径cookie.setPath("路径");

      • cookie.setPath(“/项目”); 只要是当前项目的请求路径，都会提交这个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翻译引擎

  • 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代码的后面也比<%%>中的代码先执行

    • 而两个<%%>是有先后执行顺序的

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方法不会报异常

    • 如果实体类作为数组或者集合的元素，域中传入数组或者集合，取实体类元素的属性，该属性也要满足第一条

  • 从Map集合中取数据

    • ${name.key}

  • 从数组中取数据

    • 取数组对象${name}

    • 取数组元素${name[0]}

    • 数组越界处理

      • 取不出数据在浏览器显示空白，不报错（不会出现下标越界）

  • 从list集合取数据

    • 取list对象${name}

    • 取list集合元素${name[0]}

  • 从set集合中取数据

    • 取set对象${name}

    • 因为set无序，所以无法取set集合的元素，否则会报错

忽略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方法）

    • 通过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

运算符（了解）

  • 算术运算符

    • +、-、*、/、%

    • el表达式中+不会做字符串拼接，只能做求和运算（会先把字符串转化成数字，无法转换就报错）

      • #{10+"20"}输出结果是30（字符串"20"自动转化成数字20）

      • #{10+"abc"}会报数字转化异常

  • 关系运算符

    • ==/eq != > >= < <=

    • el表达式的==、eq、!=底层都调用了equal方法(下面的例子和字符串常量池无关，就是两个不同的字符串对象)

    • eq使用#{变量A eq 变量B}等同于<%= A.equal(B)%>

  • 逻辑运算符

    • == ! && || 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有延迟，非必须）

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

    • JSTL提供了很多种标签，重点掌握核心标签库

      <%@taglib prefix="c" uri="http://java.sun.***/jsp/jstl/core" %>

    • prefix="随便起一个名字,只是一个标识，大家默认把核心标签库叫做c"

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

JSTL标签的原理

<%@taglib prefix="c" uri="http://java.sun.***/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.***mon.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一起联用

          • 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过滤器来解决这个问题

定义、作用和执行原理

  • 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>***.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>***.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

  • 纵向三层架构

  • 二者关系图解

实现mvc架构

封装数据库

  • 新建数据库工具类

  • 将构造方法私有化

    • 为了防止创建对象

    • 因为工具类中的方法都是静态的，不需要创建对象

  • 使用静态代码块，在类加载的时候注册驱动

DAO

  • 定义：data a***ess object数据访问对象

  • 实际上是javaEE的设计模式（不是23种设计模式）

  • 作用：只负责数据增删改查，没有任何业务逻辑

  • 实操

    • 先创建账户类a***ount（pojo或者JavaBean或者domain【领域模型对象】）

      • 实体类用于封装信息

      • 一般是一张表一个

      • 成员变量的类型不为基本数据类型，建议使用引用数据类型（包装类）

        • 因为从数据库中可能查到null

        • null赋给基本数据类型会报错

service类

  • 业务类

  • 类中只编写纯业务代码

  • 类名不一定要叫xxxService

  • 方法取名要和业务挂钩，一般是一个业务对应一个方法

  • 实操

    • 转账业务

    • 定义一个账户数据操作对象（DAO对象）作为成员变量，定义在业务方法之外是因为每个业务方法都可能需要连接数据库

    • 事务问题

      • 转出和转入操作要执行两次update，如果中间发生异常会导致财产损失

      • 事务是在业务逻辑层进行控制，一般一个完整的业务流程对应一个事务

      • 解决

        1. 修改DAO代码，方法中接收service中传入的connection对象

          • DAO代码中的方法不能关闭connection对象，要在service方法执行接受之后关闭

          • try括号中可以写多行语句，会自动关闭括号中的资源，无需finally

            try(Connection conn= DBUtils.getConnection())

        2. 线程

          • 一个栈对应一个线程，可以将这个线程作为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();
        }
    }
}
按职能将类放入对应的包
面向接口编程

  • 原因：为了降低耦合度，提高扩展力

  • 对应包下再创建对应接口和一个impl包，impl包中存放实现类，类名以impl结尾

  • 利用多态的方式，父类型引用指向父类型对象，所有方法中的对象调用的都是接口中的方法

A***ountService a***ountService=new A***ountServiceimpl();

  • 仍存在的问题

    • 业务方法有控制事务的代码（动态代理可以解决，aop）

    • 引用接口方法仍要创建实现类，当前类和引用接口的实现类的耦合度较高，并没有完全解决对象和对象之间的依赖关系（使用 ioc容器可以解决）

其它知识

JavaBean

定义与功能

  • 可以理解为符合某种规范的java类

  • 其实是java中的实体类，负责数据的封装

  • 由于javabean符合javabean规范，具有更强的通用性

规范要求

  • 有无参数的构造方法

  • 属性私有化对外

  • 提供setter和getter方法

  • 重写toString()，hashCode + equals

  • 实现java.io.Serializable接口（建议手动加个序列化版本号）

静态代码块

  • 在类加载时执行，并且只执行一次

  • 静态代码块用的实际上不多，用途

    • 静态代码块是java语言为java程序员预留的一个特殊的时机:类加载时机

    • 需要在类加载时机去执行一段代码，就可以把这个代码写入静态代码块

转载请说明出处内容投诉
CSS教程_站长资源网 » 动力节点Java Web知识笔记
艾热ar上海商贸艾热ar隔膜泵

艾热ar上海商贸艾热ar隔膜泵

分享到：

发表评论

欢迎 访客 发表评论

一个令你着迷的主题！

查看演示 官网购买