内容包括：Servlet+JSP+EL表达式+JSTL标签库+Filter过滤器+Listener监听器
目录
- Servlet
- Session
- cookie
- JSP
- EL表达式
- JSTL标签库
- Filter过滤器
- Listener监听器
- MVC架构模式
Servlet
系统架构
1.系统架构包括什么形式？
- C/S架构
- B/S架构
2.C/S架构
-
Client/Servlet(客户端/服务器)
-
B/S架构
-
C/S架构的软件或者说系统有那些呢？
QQ（先去腾讯官网下载一个QQ软件，几十MB，然后把这个客户端软件安装上去，然后输入QQ号以及密码，登陆之后，就可以和你的朋友聊天了，就可以使用这个软件了）
-
C/S架构的特点：需要安装特定的客户端软件
-
C/S架构的系统的优点和缺点分别是什么？
- 优点
- 速度快（软件中的数据大部分都是集成到客户端软件当中的，很少量的数据从服务的传送过来，所以C/S结构的系统速度快）
- 体验好（速度又快，界面又酷炫，当然体验好了）
- 界面酷炫（专门的语言去实现界面，更加灵活）
- 服务端压力小（因为大量的数据都是集成在客户端软件当中，所以服务器只需要传送很少的数据级量，当然服务器压力小）
- 安全（因为大量的数据集成在客户端软件当中，并且客户端有很多个，服务器虽然只有一个，就算服务器那边地震了，火灾了，问题也不大，因为大量的数据在多个客户端上有缓存）
- 缺点
- 升级维护比较差劲（升级维护比较麻烦，成本比较高，每一个客户端软件都需要升级，有一些软件不是那么容易安装。）
- 优点
3.B/S架构？
-
B/S（Browser/Server,浏览器/服务器）
-
http://www.baidu.com
-
http://www.126.com
-
B/S结构的系统优点和缺点是：
-
优点
- 升级维护方便，成本比较低（只需要升级服务端即可。）
- 不需要女装特定的客户端软件，用户操作极其方便，只需要打开浏览器，输入网址即可。
-
缺点
- 速度慢（不是因为带宽低的问题，是因为所有的数据都是在服务器上，用户发送的每一个请求都是需要服务器全身心的响应数据，所以B/S结构的系统在网络中传送的数据量比较大）
- 体验差（界面不是那么酷炫，因为浏览器只支持三个语言HTML,CSS,javaScript,在加上速度慢）
- 不安全（所有的数据都是在服务器上，只要服务器发生火灾，地震等不可抗力，最终数据全部丢失）
- ……
-
4.C/S和B/S结构的系统，哪个好，哪个不好?
-
不同结构的系统在不同业务场景下有不同的适用场景。
-
娱乐性软件建议使用？
-
C/S结构
-
公司内部使用的一些业务软件建议使用？
-
公司内部使用的系统，需要维护成本低。
-
公司内部使用的系统，不需要很酷炫。
-
公司内部使用的企业级系统主要是能进行数据的维护即可
-
B/S结构。
-
-
5.注意了：开发B/S结构的系统，其实就是开发网站，其实就是开发一个WEB系统。
-
开发一个WEB系统你需要会哪些技术？
-
WEB前端（运行在浏览器上的程序）
- HTML
- CSS
- JavaScript
-
WEB后端（运行在WEB服务端的程序）
-
java (java做WEB开发我们称为javaWEB开发，javaWEB开发最核心的规范：Servlet [Server Applet服务器端的java小程序.])
-
c
-
c++
-
python
-
php
-
6.javaEE是什么？
- java包括三大块：
- javaSE
- Java标准版（一套类库：别人写好的一套类库，只不过这个类库是标准类库，走EE，或者走ME，这个SE一定是基础，先学。）
- javaEE(WEB方向，WEB系统)
- java企业版（也是一套类库，只不过这套类库可以帮助我们完成企业级项目的开发，专门为企业内部提供解决放啊的一套（多套）类库）
- 别人写好的，你用就行了，用它可以开发企业级项目
- 可以开发web系统
- java比较火爆的就是这个JavaEE方向
- javaME
- java微型版（还是一套类库，只不过这套类库帮助我们进行电子微型设备内核程序的开发）
- 机顶和内核程序，吸尘器内核程序，电冰箱内核程序，电饭煲内核程序.
- javaEE实际上包括很多中规范，13种规范，其中SErvlet就是Java规范之一。学SErvlet还是Java语言。
- javaSE
B/S结构的系统通信原理
- WEB系统的访问过程
- 第一步：打开浏览器
- 第二步：找到地址栏
- 第三步：输入一个合法的网址
- 第四步：回车
- 第五步：在浏览器上会展示相应的结果
- 关于域名
- https://www.baidu.com/(网址)
- www.baidu.com是一个域名
- 在浏览器地址栏上输入域名，回车之后，域名解析器会将域名解析出来一个具体的IP地址和端口号等。
- 解析结果也许是：http://110.242.68.3:80/index.html
- IP地址是啥？
- 计算机在网络当中的一个身份证号，在同一个网络当中，IP地址是唯一的。
- A计算机要和B计算机通信，首先你需要知道B计算机的IP地址，有了IP地址才能建立连接。
- 端口号是啥？
- 一个端口代表一个软件（一个端口代表一个应用，一个端口仅代表一个服务）
- 一个计算机当中有很多软件，每一个软件启动之后都有一个端口号
- 在同一个计算机上，端口号具有唯一性
- 一个WEB系统的通信原理？通信步骤：
- 第一步：用户输入网址（URL）
- 第二步：域名解析器进行域名解析：http://110.242.68.3.80/indeex.html
- 第三步：浏览器软件在网络中搜索110.242.68.3这一台主机，直接找到这台主机
- 第四步：定位110.242.68.3这台主机上的服务器软件，因为是80端口，可以很轻松的定位到80端口对应的服务器软件中。
- 第五步：80端口对应的服务器软件得知浏览器想要的资源名：index.html
- 第六步：服务器软件遭到index.html文件，并且将index.html文件中的内容直接输出响应到浏览器上。
- 第七步：浏览器接收到来自服务器的代码（HTML,CSS,JS）
- 第八步：浏览器渲染，执行HTML,CSS,JS代码，展示效果
- 什么是URL?
- 统一资源定位符（http://www.baidu.com）
WEB服务器软件
-
WEB服务器软件都有哪些？（这些软件都是提前开发好的）
- Tomcat(WEB服务器)
- Jetty(WEB服务器)
- JBoss(应用服务器)
- WebLogic(应用服务器)
- WebSphere(应用服务器)
-
应用服务器和WEB服务器的关系？
- 应用服务器实现了javaEE的所有规范。（javaEE有13个不同的规范。）
- WEB服务器只实现了javaEE中的Servlet+JSP两个核心规范
- 通过这个讲解说明了；应用服务器是包含WEB服务器的
- 用过JBOSS服务器的同学应该很清楚，JBOSS中内嵌了一个Tomcat服务器
-
Tomcat下载
-
apache官网地址：https://www.apache.org/
-
tomcat官网地址：https://tomcat.apache.org/
-
tomcat开源免费的轻量级WEB服务器
-
tomcat还有一个名字：catalina(catalina是美国的一个岛屿，风景秀丽，作者在此岛上开发了一个轻量级WEB服务器，体积小，运行速度快，因此tomcat又被称为catalina)
-
tomcat的logo是一只公猫（寓意表示Tomcat服务器是轻巧的，小巧的，体积小，运行速度快，只实现了Servlet+JSP规范）
-
tomcat是java语言写的
-
tomcat服务器要向运行，必须先又jre(java的运行环境)
- JAVA_HOME=C:\Program Files\Java\jdk-17.0.1
-
PATH=%JAVA_HOME%bin
-
-
Tomcat服务器安装：
-
绿色版本的安装很简单，直接zip包解压即可，解压就是安装
-
启动Tomcat
-
关于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文件
-
本机的IP地址：127.0.0.1，或者是localhost
<!--注意以下的路径，以/开始，带项目名，是一个绝对路径，不需要添加：http://127.0.0.1:8080-->
<a href="/oa/login.html">user login</a>
<!--多个层级也没有关系，正常访问即可-->
<a href="/oa/test/debug/d.html">d page</a>
-
访问一个地址，可以展示一个用户列表页面，但是这个用户列表页面时写在HTML文件当中的，这种资源我们称之为静态资源，怎么变成动态资源，需要连接数据库。
-
连接数据库需要JDBC程序，也就是说需要编写java程序连接数据库，数据库中有多少条记录，页面就显示多少条记录，这种技术被称为动态网页技术。（动态网页技术并不是说页面中的数据是动态的，根据数据库中的数据的变化而变化。）
-
在整个BS结构的系统中，有哪些人参与进去了
- 浏览器软件的开发团队（谷歌浏览器，火狐浏览器……）
- WEB Server的开发团队（Tomcat,jetty,WebLogic,JBOSS,WebSphere……）
- DB Server的开发团队（Oracle,MySQL……）
-
角色与角色之间需要遵守哪些规范，哪些协议
-
webapp的开发团队和WEB Server的开发团队 之间有一套规范：javaEE规范之一Servlet规范。
-
Servlet规范的作用是什么？
- WEB Server 和webapp解耦合。
-
Browser和WebServer之间有一套传输协议：HTTP协议。（超文本传输协议）
-
webqpp开发团队和DB Server的开发团队之间有一套规范：JDBC规范。
-
Servlet本质
分析：
-
对于我们javaweb程序员来说，我们只需要做两件事：
- 编写一个类实现Servlet接口
- 将编写的类配置到配置文件中：指定 请求路径 和 类名 的关系。
-
注意：
- 这个配置文件的文件名不能乱来，固定的
- 这个配置文件的存放路径不能乱来，固定的
- 文件名，文件路径都是SUN公司制定的Servlet规范中的明细
-
严格意义上来说Servlet其实并不是简单的一个接口：
- Servlet规范中规定了：
- 一个合格的webapp应该是一个怎样的目录结构
- 一个合格的webapp应该是一个怎样的配置文件
- 一个合格的webapp配置文件路径放在哪里
- 一个合格的webapp中java程序放在哪里
- 这些都是Servlet规范中规定的
- Servlet规范中规定了：
-
Tomcat服务器要遵守Servlet规范，javaWEB程序员也要遵守这个Servlet规范。这样Tomcat服务器和webapp才能解耦合。
-
总结一下：一个合法的webapp目录结构应该是怎么样的
webapproot |----WEB_INF |----classes(存放字节码) |----lib(第三方jar包) |----web.xml(注册Servlet) |----html |----css |----javascript |----image -
浏览器发送请求，到最终服务器调用Servlet中的方法，是一个怎样的一个过程？
- 用户输入URL,或者直接点击超链接:http://127.0.0.1:8080/crm/a/b/c
- 然后Tomcat服务器接收到请求，获取路径：/crm/a/b/c
- Tomcat服务端找到crm项目
- Tomcat服务器在web.xml文件中查找/a/b/c对应的Servlet:com.bjpowernode.servlet.HelloServlet
- Tomcat服务器通过反射机制，创建com.bjpowernode.servlet.HelloServlet的对象
- Tomcat服务器调用com.bjpowernode.servlet.HelloServlet对象的service方法
开发带Servlet(java小程序)的webapp
-
开发步骤
1.在webapps目录下新建一个目录，起名crm（注意：crm就是这个webapp的根）
2.在webapp的根下新建一个目录：WEB_INF（注意：这个目录的名字是SErvlet规范中规定的，必须全部大写，必须一模一样）
3.在WEB_INF目录下新建一个目录：classes（注意：这个目录的名字必须全部小写，这也是Servlet规范中规定的，另外这个目录下一定存放的是java程序编译之后的class文件（这里存放的是字节码文件））
4.在WEB_INF目录下新建一个目录：lib
注意：这个目录不是必须的。但如果一个webapp需要第三方的jar包的话，这个jar包要放在lib目录下，这个目录的名字也不能随意编写，必须是全部小写的lib.例如java语言连接数据库需要数据库的驱动jar包，那么这个jar包就一定要放在lib目录下。这Servlet规范中规定的。
5.在WEB-INF目录下新建一个文件：web.xml
注意：这个文件是必须的，这个文件名必须叫做web.xml,这个文件必须放在这里，一个合法的webapp,web.xml文件是必须的，这个web.xml文件就是一个配置文件，在这个配置文件中描述了请求路径和Servlet类之间的对照关系。
这个文件最好从其他的webapp里面拷贝，最好别手写，没必要，复制粘贴。
<?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" metadata-complete="true"> </web-app>6.编写一个java程序，这个小java程序也不能随意开发，这个小java程序必须实现Servlet接口
- 这个Servlet接口不在JDK当中（因为Servlet不是javaEE。Servlet属于JavaEE，是另外一套类库）
- Servlet接口（Servlet.class文件）是Oracle提供的
- Servlet接口是javaEE规范中的一员
- Tomcat服务器实现了Servlet规范，所以Tomcat服务器也需要Servlet接口。tomcat服务器的CATALINA_HOME\lib目录下有一个servlet-api.jar，解压这个servlet-api.jar之后，你会看到里面有一个Servlet.class文件。
7.编译HelloServlet
CLASSPATH=.;E:\apache-tomcat\lib\servlet-api.jar
8.将以上编译之后的HelloSErvlet.class文件拷贝到WEB-INF\classes目录下。
9.在web.xml文件中编写配置信息，让请求路径和Servlet类名关联。（在web.xml文件中注册Servley类）
<?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" metadata-complete="true"> <servlet> <servlet-name>aaa</servlet-name> <servlet-class> com.bjpowernode.servlet.HelloServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>aaa</servlet-name> <url-pattern>/a/b/c</url-pattern> </servlet-mapping> </web-app>10.启动Tomcat服务器
11.打开浏览器，在浏览器地址上输入一个url,这个url必须和web.xml文件中的url-pattern一致。（注意：浏览器上的请求路劲和web.xml中的url-pattern的唯一区别就是：浏览器的请求路径带项目名：/crm）
浏览器上编写的路劲太复杂，可以使用超链接（非常重要：html页面只能放在WEB-INF目录外面）
以后不需要我们编写main方法了，tomcat服务器负责调用main方法，Tomcat服务器启动的时候执行的就是main方法。我们javaweb程序员只需要编写SErvlet接口的实现类，然后将其注册到web.xml文件中，即可
关于javaEE版本
javaEE目前最高版本是javaEE8
javaEE被Oracle捐献了，Oracle将JavaEE规范捐献给apache了。
Apache把javaEE换名了，以后不叫javaEE了，以后叫做jakarta EE.
以后没有javaEE了，以后都叫做jakarta EE
javaEE8版本升级之后的javaEE9,不是javaEE9这个名字了，叫做jakartaEE9
javaEE8的时候对应的Servlet类名是：javax.servlet.Servlet
jakartaEE9的时候对应的Servlet类名是：jakarta.servlet.Servlet(包名都换了)
如果你之前的项目还是在使用javax.servlet.Servlet,那么你的项目无法直接部署到Tomcat10+版本上，你只能部署在Tomcat9-版本上，在Tomcat9以及Tomcat9之前的版本还是能够识别javax.servlet这个包。
乱码问题
解决Tomcat服务器在DOS命令窗口中乱码问题（控制台乱码）
将CATALINA_HOME/conf/logging.properties文件中的内容修改如下：
java.util.logging.ConsoleHandler.encoding = GBK
向浏览器响应一段HTML代码
public void service(ServletRequest request,ServletResponse response){
response.setContentType("text/html;charset=UTF-8");
PrintWriter out=response.getWriter();
out.print("<h1>hello servlet!</h1>")
}
在Servlet中连接数据库
Servlet是java程序，所以在Servlet中完全可以编写JDBC代码连接数据库。
在一个webapp中去连接数据库，需要将驱动jar包放在WEB-INF/lib目录下。（com.mysql.cj.jdbc.Driver这个类就在驱动jar包当中。）
集成开发环境中开发Servlet程序
集成开发工具很多，其中目前使用比较多的是：
- Intelli IDEA(这个居多)
- Eclipse(这个少一些)
使用IDEA集成开发工具开发Servlet
-
New Project(空项目)
-
新建模块（File–>new–>Module）
- 这里新建的是一个普通的JavaSE模块（先不要新建Java Enterprise模块）
- 这个Module自动会被放在javaweb的project下面
- 这个Module起名：servlet01
-
让Module变成JavaEE模块。（让Module变成webapp的模块，符合webapp规范，符合Servlet规范的Module）
- 在Module上点击右键：Ad Framework Support…(添加框架支持)
- 在弹出的窗口中，选择Web Application(选择的是webapp的支持)
- 选择了这个webapp的支持以后，IDEA会自动给你生成一个符合Servlet规范的webapp目录结构
- 重点，需要注意的：在IDEA工具中根据Web Application模板生成的目录中有一个web目录，这个目录就代表webapp的根
-
根据Web Application生成的资源中有index.jsp文件
-
编写Servlet(StudentServlet)
- class StudentServlet implements Servlet
- 这个时候发现Servlet.class文件没有，怎么办？将CATALINA_HOME/lib/servlet-api.jar和jsp-api.jar添加到classpath当中（这里的classpath说的是IDEA的classpath）
- File–>Project Structrue–>Modules–>+加号–>Add JARS…
- 实现javax.servlet.Servlet接口里的5个方法
-
在Servlet当中的service方法中编写业务代码（我们这里连接数据库）
-
在WEB_INF目录下新建一个子目录：lib，将连接数据库的驱动jar包放在lib目录下。
-
在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.zlqnode.javaweb.servlet.StudentServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>studentServlet</servlet-name> <url-pattern>/servlet/student</url-pattern> </servlet-mapping> </web-app> -
给一个html页面，在HTML页面上编写一个超链接，用户迪阿尼这个超链接，发送请求，Tomcat执行后台的StudentServlet。
-
student.html
-
这个文件不能放在WEB-INF目录里面，只能放在WEB-INF目录外面
-
student.html文件的内容
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>student page</title> </head> <body> <a href="/xmm/servlet/student">student list</a> </body> </html>
-
-
让IDEA工具去关联Tomcat服务器，关联的过程当中将webappp部署到Tomcat服务器当中。
- IDEA工具右上角，绿色小锤子右边有一个：Add Configuration
- 左上角加号，点击Tomcat Server–>local
- 在弹出的界面中设置服务器Servlet的参数（基本上不用动）
- 在当前窗口中有一个Deployment(点击这个用来部署webapp)，继续点击加号，部署即可
- 修改Application context为：/xmm
-
启动Tomcat服务器
- 在右上角有卢瑟的箭头，或者绿色的小虫子，可以采用debug的模式启动Tomcat服务器。
- 我们开发建议使用debug模式启动Tomcat
-
打开浏览器，在浏览器地址上输入：http://localhost:8080/xmm/student.html
Servlet对象的生命周期
-
Servlet对象的生命周期表示：一个Servlet对象从出生到最后的死亡，整个过程是怎样的。
-
Servlet对象是由谁来维护：
-
Servlet对象的创造，对象上方法的调用，对象最终的销毁，javaweb程序员是无权干预的。
-
Servlet对象的生命周期是由Tomcat服务器（WEB Server）全权负责的
-
Tomcat服务器通常我们又称为：WEB容器。（这个叫法你要知道【WEB Container】）
-
WEB容器来管理Servlet对象的死活
-
-
我们自己new的Servlet对象是不受WEB容器管理的。WEB容器创建的Servlet对象，这些Servlet对象都会被放在一个集合当中（HashMap）,只有放在这个HashMap集合中的Servlet才能够被WEB容器管理，自己new的Servlet对象不会被WEB容器管理。（自己new的Servlet对象不在容器当中）。web容器底层应该有一个HashMap这样的集合，在这个集合当中存储了Servlet对象和请求路径之间的关系。
-
服务器在启动时Servlet有没有被创建出来（默认情况下?）
-
默认情况下，服务器在启动的时候Servlet并不会被实例化
-
这个设计是合理的，用户没有发送请求之前，如果提前创建出来所有的Servlet对象，必然是耗费内存的，并且创建出来的Servlet如果一直没有用户访问，显然这个Servlet对象是一个废物，没必要创建。
-
-
怎么让服务器启动的时候创建Servlet对象？
在Service标题中添加子标签，在这个子标签中填写生疏，越小的整数优先级越高。
<servlet>
<servlet-name>studentServlet</servlet-name>
<servlet-class>com.zlqnode.javaweb.servlet.StudentServlet</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>studentServlet</servlet-name>
<url-pattern>/servlet/student</url-pattern>
</servlet-mapping>
- 总结
- Servlet对象是单例的（单实例的，但是需要注意的是：Servlet对象是但是实例的，但是Servlet类并不符合单例模型，我们称之为假单例，之所以单例是因为Servlet对象的创建我们javaweb程序员管不着，这个对象的创建只能是Tomcat来说了算，Tomcat只创建了一个，所以导致了单例，但是属于假单例。真单例模式，构造方法是私有化的）
- 无参数构造方法，init方法只在第一次用户发送请求的时候执行，也就是说五参数构造方法只执行一次，init方法也被Tomcat服务器调用一次。
- 只要用户发送一次请求，service方法必然会被Tomcat服务器调用一次，发送100次，service方法会被调用100次。
- Servlet的destroy方法只被Tomcat调用一次，在服务器关闭的时候，因为服务器关闭的时候要销毁AServlet对象的内存，服务器在销毁AServlet对象内存之前，Tomcat服务器会自动调用AServlet对象的destroy方法，destroy方法执行的时候AServlet对象还在，没有被销毁。destroy方法执行结束之后，AServlet对象的内存才会被Tomcat释放。
init,service,destroy方法
-
Servlet规范中有要求，作为javaweb程序员，编写Servlet类的时候，不建议手动编写构造方法，因为编写构造方法，很容易让无参数构造方法消失，这个操作可能会导致Servlet对象无法实例化，所以init方法是有存在的必要的。
-
使用最多就是service方法，service方法是一定要实现的，因为service方法是处理用户请求的核心方法。
-
什么时候使用init方法？
- init方法很少用
- 通常init方法当中做初始化操作，并且这个初始化操作只需要执行一次，例如：初始化数据库连接池，初始化线程池…
-
什么时候使用destroy方法
- destroy方法也很少用
- 通常在destroy方法当中，进行资源的关闭，马上对象要被销毁了，还有什么没有关闭的，抓紧时间关闭资源。还有什么资源没保存的，抓紧时间保存一下。
-
我们编写一个Servlet类直接实现Servlet接口有什么缺点？
- 我们只需要Service方法，其他方法大部分是不需要使用的，代码很丑陋。
-
编写一个GENERicServlet类，这个类是一个抽象类，其中有一个抽象方法service
- GenericServlet实现Servlet接口
- GenericSevlet是一个适配器
- 以后编写的所有Servlet类继承GenericServlet,重写service方法即可
ServletConfig
-
什么是ServletConfig
- Servlet对象的配置信息对象
- ServletConfig对象中封装了标签中的配置信息。（web.xml文件中的servlet的配置信息）
-
一个Servlet对应一个ServletConfig对象
-
Servlet对象是Tomcat服务器创建，并且ServletCong对象也是Tomcat服务器创建，并且默认情况下，他们都是在用户发送第一次请求的时候创建。
-
Tomcat服务器调用Servlet对象的init方法的时候需要传一个ServletConfig对象的参数给init方法。
-
ServletConfig接口的实现类是Tomcat服务器给实现的。（Tomcat服务器说的就是WEB服务器）
-
ServletConfig接口中有4个方法
- 第一个方法：通过初始化参数name获取value
public String getInitParameter(String name); - 第二个方法：获取所有的初始化参数的name
public Enumeration getInitParameterNames(); - 第三个方法：获取ServletContext对象
public ServletContext getServletContext(); - 第四个方法：获取Servlet的name
public String getServletName(); - 以上的4个方法，在自己编写的Servlet类当中也可以使用this去掉用。（这个Servlet继承了GenericServlet接口）
ServletContext
-
一个Servlet对象对应一个ServletConfig,100个Servlet对象对应100个ServletConfig对象。
-
只要在同一个webapp当中，只要在同一个应用当中，所有的Servlet对象都是共享同一个ServletContext对象的。
-
ServletContext对象在服务器启动阶段创建，在服务器关闭的时候销毁，这就是ServletContext对象的生命周期，ServletContext对象是应用级对象。
-
Tomcat服务器中有一个webapps，这个webapps下可以存放webapp,可以存放多个webapp,假如有100个webapp,那么就有100个ServletContext对象，但是，总之，一个应用，一个webapp肯定只有一个ServletContext对象。
-
ServletContext被称为Servlet上下文对象。（Servlet对象的四周环境对象。）
-
一个ServletContext对象通常对应的是一个web.xml文件
-
ServletContext对应显示生活中的什么例子呢？
- 一个教室里有很多学生，那么每一个学生就是一个Servlet,这些学生都在同一个教室当中，那么我们可以把这个教室叫做ServletContext对象，那么也就是说放在这个ServletContext对象（环境）当中的数据，在同一个教室当中，物品都是共享的，比如：教室里的空调，所有的学生都可以操作。
-
ServletContext是一个接口，Tomcat服务器对ServletContext接口进行了实现。
- ServletContext对象也是Tomcat服务器来完成的，启动webapp的时候创建的。
-
ServletContext接口中有哪些常用的方法？
public String getInitParameter(String name);//通过初始化参数的name获取value
public Enumeration<String> getInitParameterNames();//获取所有的初始化参数的name
<!--以上两个方法是ServletContext对象的方法，这个方法获取的是什么信息？是如下配置信息-->
<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源代码当中有一些地方可能会需要应用到根路径，这个方法可以动态获取应用的根路径
//在java源码当中，不要将应用的跟路径写死，因为你永远都不知道这个应用在最终部署的时候，起一个什么名字
public String getContextPath();
//String contextPath=application.getContextPath();
//获取文件的绝对路径（真实路径）
public String getRealPath(String path);
//通过ServletContext对象也是可以记录日志的
public void log(String message);
public void log(String message,Throwable t);
//这些日志信息记录到哪里了？
//localhost.2022-12-29.log
//Tomcat服务器的logs目录下都有哪些日志文件？
//catalina.2022-12-29.log 服务器端的java程序运行的控制台信息
//localhost.2022-12-29.log ServletContext对象的log方法记录的日志信息存储到这个文件中
//localhost_access_log.2022-12-29.txt 访问日志
//ServletContext对象还有另一个名字：应用域（后面还有其他域，例如：请求域，会话域）
//如果所有的用户共享一份数据，并且这个数据很少被修改，并且这个数据很少被修改，并且这个数据量很少，可以将这些数据放在ServletContext这个应用域中
//为什么是所有用户共享的数据？不是共享的没有意义。因为ServletContext这个对象只有一个。只有共享的数据放进去才有意义
//为什么数据量小？因为数据量比较大的话，太暂用堆内存，并且这个对象的生命周期比较长，服务器关闭的时候，这个对象才会被销毁。大数据量会影响服务器性能。占用内存较小的数据量可以考虑放进去。
//为什么这些共享数据很少被修改，或者说几乎不修改。
//所有用户共享的数据，如果设计到修改操作，必然会存在线程并发所带来的安全问题，所有放在ServletContext对象中的数据一般都是只读的。
//数据量小，所有用户共享，又不修改，这样的数据放在ServletaContext这个应用域当中，会大大提升效率。因为应用域相当于一个缓存，放在缓存中的数据，下次再用的时候，不需要从数据库中再次获取，大大提升执行效率。
//存（怎么向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)
-
注意：以后我们编写Servlet类的时候，实际上是不会直接基础GenericServlet类的，因为我们是B/S结构的系统，这种系统是基于HTTP超文本传输协议的，在Servlet规范当中，提供了一个类叫做HttpServlet,它是专门为http协议准备的一个Servlet类，我们编写Servlet类要基础HttpServlet。（HttpServlet是HTTP协议专用的）使用HttpServlet处理HTTP协议更便捷，但是你需要知道它的集成结构。
javax.servlet.Servlet(接口)[爷爷] javax.servlet.GenericServlet implements Servlet(抽象类)[儿子] javax.servlet.http.HttpServlet extends GenericServlet(抽象类)[孙子] 我们以后编写的Servlet要基础HttpServlet类。
大家到目前位置都接触过哪些缓存机制了?
-
堆内存当中的字符串常量池
- "abc"先在字符串常量池中查找，如果有，直接拿来用，如果没有则新建，然后再放入字符串常量池。
-
堆内存当中的整数型常量池
- [-128~127]一共256个Integer类型的引用，放在整型常量池中，没有超过这个范围的话，直接从常量池中取
-
连接池（Connection Cache）
-
这里所说的连接池中连接是java语言连接数据库的连接对象：java.sql.Connection对象。
-
JVM是一个进程。MySQL是数据库是一个进程，进程和进程之间建立连接，打开通道是很费劲的，是很耗费资源的。可以提前先创建好N个Connection连接对象，将连接对象放在一个集合当中，我们吧这个放在Connection对象的集合称为连接池。每一次用户连接的时候不需要再新建连接对象，省去了新建的环节，直接从连接池中获取连接对象，大大提升访问效率。
-
连接池
- 最小连接数
- 最大连接数
- 连接池可以提高用户的访问效率，当然也可以保证数据库的安全性
-
线程池
- Tomcat服务器本身就是支持多线程的
- Tomcat服务器是在用户发送一次请求，就新建一个Thread线程对象吗？
- 当然不是，实际上是在Tomcat服务器启动的时候，会先创建好N多个线程Thread对象，然后将线程对象放在集合当中，称为线程池。用户发送请求过来之后，需要有一个对应的线程来处理这个请求，这个时候线程对象就会直接从线程池中哪，效率比较高
- 所有WEB服务器，或者应用服务器，都是支持多线程的，都有线程池机制。
-
redis
- NoSQL数据库，非关系型数据库，缓存数据库
-
向ServletContext应用域中存储数据，也等于是将数据存放到缓存cache当中了。
-
HTTP协议
-
什么是协议？
- 协议实际上是某希尔，或者某些组织提前指定好的一套规范，大家都按照这个规范来，这样可以做到沟通无障碍。
- 协议就是一套规范，就是一套标准，由其他人或其他组织来负责制定的。
- 我说的话你能听懂，你说的话，我也能听懂，这说明我们之间是有一套规范的。
-
什么是HTTP协议
-
HTTP协议：是W3C指定的一种超文本传输协议（通信协议：发送消息的模板提前被制定好）
-
W3C:
-
万维网联盟组织
-
负责指定标准的:HTTP ，HTML4.0，HTML5，XML，DOM等规范都是W3C制定的。
-
万维网之父：蒂姆.博纳斯.李
-
-
什么是超文本？
- 超文本就是：不是普通文本，必然流没听：声音，视频，图片等。
- HTTP协议支持：不但可以传送普通字符串，同样支持传递声音，视频，图片等流媒体信息。
-
这种协议又走在B和S之间。B向S发送数据要遵循HTTP协议。S向B发送数据同样需要遵循HTTP协议，这样B和S才能解耦合。
-
什么是解耦合？
- B不依赖S
- S也不依赖B
-
B/S表示：B、S结构的系统（浏览器访问WEB服务器的系统）
-
浏览器 向 WEB服务器发送数据，加载：请求（request）
-
WEB服务器 向 浏览器发送数据，叫做：想要（response）
-
HTTP协议包括：
- 请求协议
- 浏览器 向 WEB服务器发送数据的时候，这个发送的数据需要遵循一套标准，这套标准中规定来发送的数据具体格式。
- 响应协议
- WEB服务器 向 浏览器发送数据的时候，这个发送的数据需要遵循一套标准，这套标准中规定了发送的具体格式。
- 请求协议
-
HTTP协议就是提前指定好的一种消息模板
- 不管你是哪种平拍的浏览器，都是这么发
- 不管你是那个平拍的WEB服务器，都是这么发
-
-
HTTP的请求协议（B–>S）
-
HTTP的请求协议包括：4部分
- 请求行
- 包括三部分：
- 第一部分：请求方式（7种）
- get(常用的)
- post(常用的)
- delete
- put
- head
- options
- trace
- 第二部分：URI
- 什么是URI?统一资源标识符。代表网络中某个资源的名字。但是通过URL是无法定位资源的。
- 什么是URL？统一资源定位符。代表网络中的某个资源。同时，通过URL是可以定位到该资源的。
- URL和URI什么关系，有什么区别？
- URL包括URI
- http://localhost:8080/servlet04/index.html这是URL
- /servlet04/index.html这是URI
- 第三部分：HTTP协议版本号
- 第一部分：请求方式（7种）
- 包括三部分：
- 请求头
- 请求的主机
- 主机的端口
- 浏览器信息
- 平台信息
- cookie等信息
- …
- 空白行
- 空白行是用来区分“请求头”和"请求体"。
- 请求体
- 向服务器发送的具体数据。
- 请求行
-
HTTP请求协议的具体报文 GET请求
-
GET /servlet04/getServlet?username=lucy&userpwd=122 HTTP/1.1 请求行 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 Accept-Encoding: gzip, deflate, br Accept-Language: zh-CN,zh;q=0.9 Connection: keep-alive Host: localhost:8080 Referer: http://localhost:8080/servlet04/index.html Sec-Fetch-Dest: document Sec-Fetch-Mode: navigate Sec-Fetch-Site: same-origin Sec-Fetch-User: ?1 Upgrade-Insecure-Requests: 1 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36 sec-ch-ua: "Not?A_Brand";v="8", "Chromium";v="108", "Google Chrome";v="108" sec-ch-ua-mobile: ?0 sec-ch-ua-platform: "Windows" 空白行 请求体
-
-
HTTP请求协议的具体报文：POST请求
-
GET /servlet04/postServlet?username=jack&userpwd=123 HTTP/1.1 请求行 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 Accept-Encoding: gzip, deflate, br Accept-Language: zh-CN,zh;q=0.9 Cache-Control: max-age=0 Connection: keep-alive Host: localhost:8080 Referer: http://localhost:8080/servlet04/index.html Sec-Fetch-Dest: document Sec-Fetch-Mode: navigate Sec-Fetch-Site: same-origin Sec-Fetch-User: ?1 Upgrade-Insecure-Requests: 1 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36 sec-ch-ua: "Not?A_Brand";v="8", "Chromium";v="108", "Google Chrome";v="108" sec-ch-ua-mobile: ?0 sec-ch-ua-platform: "Windows" 空白行 username=jack&userpwd=123 请求体
-
-
-
HTTP的响应协议（S–>B）
-
HTTP的响应协议包括：4部分
-
状态行
-
响应头
-
空白行
-
响应体
-
-
HTTP响应报文
-
HTTP/1.1 200 OK 状态行 Content-Type: text/html;charset=UTF-8 响应头 Content-Length: 125 Date: Thu, 29 Dec 2022 12:59:29 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> -
状态行
- 三部分组成
- 第一部分：协议版本号（HTTP/1.1）
- 第二部分：状态码（HTTP协议中规定的响应状态好，不同的响应结果对应不同的号码。）
- 200表示请求响应成功，正常结束
- 404表示访问的资源不存在，通常是因为要么是你路径写错了，要么是路径写对了，但是服务器中对应的资源冰没有启动成功，总之404错误是前端错误。
- 405表示前端发送的请求方式与后端请求的处理方式不一致时发生：
- 比如：前端是POST请求，后端的处理方式按照get方式进行处理时，发生405
- 比如：前端是GET请求，后端的处理方式按照post方式进行处理时，发生405
- 500表示服务器端的程序出现了异常，一般人物是服务器端的出哦我导致的
- 以4开头的，一般是浏览器端的出错导致的
- 以5开始的，一般是服务器端的出错导致的
- 第三部分：状态的描述信息
- ok表示正常结束
- not found表示资源找不到
- 响应头：
- 响应的内容类型
- 响应的内容长度
- 响应的时间
- …
- 空白行
- 用来分隔"响应头"和"响应体"的。
- 响应体：
- 响应体就是响应的征文，这些内容是一个长的字符串，这个字符串被浏览器渲染，解释冰执行，最终展示出效果。
- 三部分组成
-
怎么查看协议内容
- 使用chrome浏览器：F12,然后遭到network,通过这个面板可以查看协议的具体内容。
-
怎么向服务器发送GET请求，怎么向服务器发送POST请求？
- 到目前位置，只有一种情况可以发送POST请求：使用form表单，并且form标签中的method属性值为：method=“post”.
- 其他所有情况一律都是get请求的：
- 在浏览器地址上直接输入URL,敲回车，属于grt请求
- 在浏览器上直接点击超链接，属于get请求。
- 使用form表单提交数据时，form标签中没有写method属性，默认是get
- 或者使用form的时候，form标签中method属性值为:method属性值为：method=“get”
- …
-
GET请求和POST请求有什么区别？
-
get请求发送数据的时候，数据会挂在URI的后面，并且在URL后面添加一个"?“,”?"后面是数据。这样会导致发送的数据会显示在浏览器的地址栏上。(get请求在“请求行”上发送数据)
- http://localhost:8080/servlet04/getServlet?username=lucy&userpwd=123
-
post请求发送数据的时候，在请求体当中发送。不会显示到浏览器的地址栏上，也就是说post发送的数据，在浏览器地址栏上看不到。（post在“请求体”当中发送数据）
-
get请求只能发送普通的字符串，并且发送的字符串长度有限制，不同的浏览器限制不同。这个没有明确的规范。
-
get请求无法发送大数据量
-
post请求可以发送任何类型的数据，包括普通字符串，流媒体等信息：视频，声音，图片。
-
post请求可以发送大数据量，理论上没有长度限制。
-
get请求在W3C是这样说的：get请求比较时候从服务器获取数据。
-
post请求在W3C中是这样说的：post请求比较适合向服务器端传送数据。
-
get请求是安全的，get请求是绝对安全的。为什么？因为get请求只是为了从服务器上获取数据
-
post请求是危险的，为什么？因为post庆七一是向服务器提交数据，如果这些数据通过后门规定方式进入服务器当中，服务器是很危险的。另外post是为了提交数据，所有一般情况下拦截请求的时候，大部分会选择拦截（监听）post请求。
-
get请求支持缓存
-
https://www.jj20.com/sj/fj/314784.html
-
任何一个get请求最终的“响应结果”都会被浏览器缓存起来，在浏览器缓存当中：
- 一个get请求路径 对应 一个资源
- 一个get请求路径 对应 一个资源
- …
-
实际上，你只要发送get请求，浏览器做的第一件事都是先从本地浏览器缓存中找，找不到的时候才会取服务器上获取。这种缓存机制目的是为了提高用户的体验。
-
我们不希望get请求缓存?
- 只要每一次请求的路径不同即可.
- https://www.jj20.com/sj/fj/314784.html?t=78911
- https://www.jj20.com/sj/fj/314784.html?t=78912
- https://www.jj20.com/sj/fj/314784.html?t=系统毫秒数
- 怎么解决?可以在路径的后面添加一个每时每刻都在变化的"时间戳",这样,每一次的请求路径都不一样,浏览器就不走缓存了.
- 只要每一次请求的路径不同即可.
-
-
post请求不支持缓存(post是用来修改服务器端的资源的)
- post请求之后，服务器“响应的结果”不会被浏览器缓存起来，因为这个缓存没有意义。
-
-
GET请求和POST请求如何选择，什么时候使用GET请求，什么时候使用POST请求?
- 怎么选择GET请求和POST请求呢?衡量标准是什么?你这个请求时想获取服务端的数据,还是想向服务器发送数据.如果你是想从服务器上提交,建议使用GET请求,如果你这个要求是未来想服务端提交数据,建议使用POST请求.
- 大部分的form表单提交,都是post方式,因为form表单中要填写大量的数据,这些数据是手机用户的信息,一般是需要传输给服务器,服务器将这些数据保存/修改等.
- 如果表单中有敏感的信息,还是仅有使用post请求,因为get请求会回显敏感信息到浏览器地址栏上.(例如:密码信息)
- 做文件上传,一定是post请求,要传的数据不是普通文本
- 其他情况都可以使用get请求
-
不管你是get请求还是post请求，发送的数据格式是完全相同的，只不过位置不同，格式都是统一的；
- name=value&name=value&name=value
- name是什么？
- 以form表单为例：form表单中input标签的name
- value是什么？
- 以form表单为例：form表单中input标签的value
-
模板方法设计模式
- 什么是设计模式?
- 某个问题的固定的解决方案.(可以被重复使用.)
- 你知道哪些设计模式?
- Gof设计模式:
- 通常我们所说的23种设计模式(Gang of Four:4人组提出的设计模式)
- 单例模式
- 工厂模式
- 代理模式
- 蒙面模式
- 责任链设计模式
- 观察者模式
- 模板方法设计模式
- …
- JavaEE设计模式
- DAD
- DTO
- VO
- PO
- pojo
- …
- …
- Gof设计模式:
- 什么是模板方法设计模式?
- 在模板类的模板方法当中定义核心算法股价,具体的实现步骤可以延迟到子类当中完成
- 模板类通常是一个抽象类,模板类当中的模板方法定义核心算法,这个方法通常是final的(但也可以不是final的)
- 模板类当中的抽象方法就是不确定实现的方法,这个不确定怎么实现的事儿交给子类去做.
HttpServlet源码分析
-
HttpServlet类是专门为HTTP协议准备的。比GEnericServlet更加时候HTTP协议下的开发
-
HttpServlet是在哪个包下
- javax.servlet.http.HttpServlet
-
到目前为止我们接触了servlet规范中哪些接口
- javax.servlet.Servlet 核心接口 （接口）
- javax.servlet.ServletConfig Servlet配置信息接口（接口）
- javax.servlet.ServletContext Servlet上下文接口 （接口）
- javax.servlet.ServletRequest Servlet请求接口 （接口）
- javax.servlet.ServletResponse Servlet响应接口 （接口）
- javax.servlet.ServletException Servlet异常 （类）
- javax.servlet.GenericServlet 标准统一的Servlet类 （抽象类）
-
http包下都有哪些类和接口?javax.servlet.http.*
- javax.servlet.http.HttpServlet (HTTP协议专用的Servlet类，抽象类)
- javax.servlet.http.HttpServletRequest（HTTP协议专用的请求对象）
- javax.servlet.http.HttpServletResponse（HTTP协议专用的响应对象）
-
HttpServletRequst对象中封装了什么信息？
- HttpServletRequest,检测requst对象
- HttpServletRequst中封装了请求协议的全部内容
- Tomcat服务器（WEB服务器）将“请求协议”中的数据全部解析出来，然后将这些数据全部封装到request对象当中
- 也就是说，我们只要面对HttpServletRequest,就可以获取请求协议中的数据
-
HttpServletResponse对象是专门用来响应HTTP协议到浏览器的
-
回顾Servlet生命周期？
- 用户第一次请求
- Tomcat服务器通过反射机制，调用无参数构造方法，创建Servlet对象。（web.xml文件中配置的Servlet类对应的对象。）
- Tomcat服务器调用Servlet对象的init方法1完成初始化
- Tomcat服务器调用Servlet对象的service方法处理请求
- 用户第二次请求
- Tomcat服务器调用Servlet对象的service方法处理请求
- ……
- Tomcat服务器调用Servlet对象的service方法处理请求
- 服务器关闭
- Tomcat服务器调用Servlet对象的destroy方法，做销毁之前的准备工作
- Tomcat服务器销毁Servlet对象
- 用户第一次请求
-
HttpServlet源码分析：
public class HelloServlet extends HttpServlet { //通用户第一次请求，创建helloServlet对象的时候，会执行这个无参数构造方法 public HelloServlet(){} } 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 } } public abstract class HttpServlet extends GenericServlet { //用户发送第一次请求的时候这个service会执行 //用户发送第N次请求的时候，这个service方法还是会执行 //用户只要发送一次请求，这个service方法就会执行一次 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 var6) { throw new ServletException(lStrings.getString("http.non_http")); } //调用重载的servlet方法 this.service(request, response); } //这个service方法的两个参数都是带有Http的 //这个service是一个模板方法 //在该方法中定义核心算法股价，具体的实现步骤延迟到子类中去实现 protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //获取请求方式 //这个请求方式最终肯是：“” //注意：requst.getMethod()方法获取的是请求方式，肯是其中之一 //GET POST PUT DELETE HEAD OPTIONS TRACE String method = req.getMethod(); long lastModified; //如果请求方式是GET请求，则执行doGet方法 if (method.equals("GET")) { lastModified = this.getLastModified(req); if (lastModified == -1L) { this.doGet(req, resp); } else { long ifModifiedSince; try { ifModifiedSince = req.getDateHeader("If-Modified-Since"); } catch (IllegalArgumentException var9) { ifModifiedSince = -1L; } if (ifModifiedSince < lastModified / 1000L * 1000L) { this.maybeSetLastModified(resp, lastModified); this.doGet(req, resp); } else { resp.setStatus(304); } } } else if (method.equals("HEAD")) { lastModified = this.getLastModified(req); this.maybeSetLastModified(resp, lastModified); this.doHead(req, resp); } else if (method.equals("POST")) { //如果请求方法是POST请求，则执行doPost方法 this.doPost(req, resp); } else if (method.equals("PUT")) { this.doPut(req, resp); } else if (method.equals("DELETE")) { this.doDelete(req, resp); } else if (method.equals("OPTIONS")) { this.doOptions(req, resp); } else if (method.equals("TRACE")) { this.doTrace(req, resp); } else { String errMsg = lStrings.getString("http.method_not_implemented"); Object[] errArgs = new Object[]{method}; errMsg = MessageFormat.format(errMsg, errArgs); resp.sendError(501, errMsg); } } } /** 通过以上源代码分析： 假设前端发送的请求是get请求，后端程序员重写的方法是doPost 假设前端发送的请求是post请求，后端型恒星员重写的方法是doGet 会报405错误 405表示前端的戳我，发送的请求方式不对，和服务器不一致，不是服务器需要的请求方式。 通过以上代码可以知道：只要HttpServlet类中的doGet方法执行了，必然405 这种前端到底需要怎么样的请求，其实应该后端说了栓，后端让法什么方式，前端就得发什么方式 如果你要是重写；了doGet和doPost,那还不如你直接重写service方法好了。这样代码还能少一点 */ -
到今天我们终于得到了最终一个Servlet类的开发步骤：
- 第一步：编写一个Servlet类，直接继承HttpServlet
- 第二步：重写doGet方法或者重写doPost方法，到底重写谁，javaweb程序员说了算
- 第三步：将Servlet类配置到web.xml文件当中
- 第四步：准备前端的页面（form表单），form表单中制定请求路径即可。
关于一个web站点的欢迎页面
-
什么是web站点的欢迎页面
- 对于一个webapp来说，我们是可以设置他的欢迎页面的
- 设置了欢迎页面之后，当你访问这个webapp的时候，或者访问这个web站点的时候，没有指定任何“资源路径”，这个时候会默认访问你的欢迎页面
- 我们一般的访问方式
- http://localhost:8080/servlet06/login.html这种方式是指定了要访问的资源
- 如果我们访问的方式是：
- http://localhost/servlet06 如果我们访问的就是这个站点，没有指定具体的资源路径，它默认会访问你设置的欢迎页面
-
怎么设置欢迎页面？
-
第一步：在IEDA工具的web目录下新建了一个文件login.html
-
第二步：在web.xml文件中进行了一下的配置
-
<welcome-file-list> <welcome-file>login.html</welcome-file> </welcome-file-list>- 注意：在设置欢迎页面的时候，这个路径不需要以"/"开始，并且这个路径默认是从webqpp的根下开始查找的。
-
第三步：启动服务器，浏览器地址栏输入地址
- http://localhost:8080/servlet06
-
-
如果在webapp的根下新建一个目录，目录中再给一个文件，那么这个欢迎页该如何设置呢？
<welcome-file-list> <welcome-file>page1/page2/page.html</welcome-file> </welcome-file-list>注意：一个webapp是可以设置多个欢迎页的
越靠上的优先级越高，早不到的继续向下找
-
index.html ,index.htm ,index.jsp可以不用配置
- 因为小猫咪Tomcat服务器已经提前配置好了
- 实际上欢迎页面有两个地方可以配置
- webapp内部的web.xml文件中（在这个地方配置属于局部配置）
- 一个是在CATALINA_HOME/conf/web.xml文件进行配置（全局配置）
- 注意原则：局部优先原则（就近原则）
-
欢迎页可以是一个Servlet吗？
- 当然可以
- 动态资源：Servlet类
- 静态资源：index.html,welcom.html…
关于WEB-INF目录
- 注意：放在WEB-INF目录下的资源是受保护的，在浏览器上不能通过路径直接访问。所有像HTML,CSS,JS,image等静态资源一定要放在WEB-INF目录下。
HttpServletRequest接口详解
-
HttpServlet是一个接口，全名：javax.servlet.httpServletRequest
-
HttpServletRequest接口是Servlet规范中的一员
-
HttpServletRequest接口的父接口：
-
public interface HttpServletRequest extends ServletRequest {} -
HttpServletRequst接口的实现类谁写的？HttpServletRequst对象是谁给创建的？
-
通过测试：org.apache.catalina.connector.RequestFacade实现了HttpServletRequest接口
-
public class RequestFacade implements HttpServletRequest{} -
测试结果说说明：Tomcat服务器（WEB服务器，WEB容器）实现了HttpServletRequest接口，还是说明了Tomcat服务器实现了Servlet规范。而对于我们javaweb程序员来说，实际上不需要关心这个，我们只需要面向接口编程即可，我们关系的是HttpServletRequest接口中有哪些方法，这些方法可以完成说明功能！！！
-
-
HttpServletRequst对象都要说明信息？都包装了说明信息？
- HttpServletRequest对象是Tomcat服务器负责创建的。这个对象封装了什么信息？封装了HTTP的请求协议
- 实际上是用户发送请求的时候，遵循了HTTP协议，发送的是HTTP的请求协议，Tomcat服务器将HTTP协议中的信息以及数据全部解析出来，然后Tomcat服务器把这些信息封装到HttpServletRequest对象当中，传给了我们javaweb程序员。
- javaweb程序员面向HttpServletRequest接口编程，调用方法就可以获取到请求的信息了。
-
request和response对象的生命周期？
- request对象和reponse对象，一个是请求对象，一个是响应对象，这两个对象只在当前请求中有效
- 一个请求对应一个request
- 两个请求则对应两个request
- ……
-
HttpServletRequest接口中有哪些常用的方法？
-
怎么获取前端浏览器用户提交的数据
-
Map<String,String[]> getParameterMap() 这个是获取Map 这个是获取Map集合中所有的key Enumeration<String> getParameterNames() 这个是获取Map集合中所有的key String[] getParameterValues(String name) 根据key获取Map集合的value String[] getParameter(String name) 获取value这个一维数组当中的第一个元素。这个方法最常用 //以上的4个方法，和获取用户提交的数据有关系思考：如果是你，前端的form表单提交了数据之后，你准备怎么存储这些数据呢？
-
前端提交的数据格式：username=jack&password=123&aihao=s&aihao=d&aihao=tt
-
使用Map集合来存储：
-
Map<String, String[]> key存储String value存储String[] key value -------------------- username {"abc"} userpwd {"111"} aihao {"s","d","tt"}
-
-
注意：前端表单提交数据的时候，假设提交了120这样的“数字”，其实也是以字符串“120”的方式提交的。
-
request对象实际上又称为“请求域”对象
-
应用域对象是生命？
-
ServletContext（Servlet上下文对象）
-
什么情况下会考虑向ServletContext这个应用域当中绑定数据呢？
- 所有用户共享的数据
- 这个共享的数据量很小
- 这个共享的数据很骚的修改操作
- 在以上三个条件都满足的情况下，只用这个应用域对象，可以大大提高我们程序执行效率
- 实际上向应用于当中绑定数据，就相当于把数据放在了缓存（Cache）当中，然后用户访问的时候直接从缓存中去，见扫IO的操作，大大提示系统的性能，所以缓存技术是提高系统性能的重要手段。
-
你见过哪些缓存技术
- 字符串常量池,“abc”,“abc”
- 整肃型常量池【-128-127】，但凡在这个范围当中的Interger对象不再创建新对象，直接从缓存中取，减少IO的操作，大大提升系统的性能，所以缓存技术是提高系统性能的重要手段。
- 数据库连接池（提前创建好N个连接对象，将连接对象放在集合当中，使用连接对象的时候，直接从缓存中拿，省去了连接对象的创建过程，效率提升。）
- 线程池（Tomcat服务器就是支持多线程的，所谓线程池就是提前先创建好N个线程对象，将线程对象存储到集合中，然后用户请求过来之后，直接从线程池中获取线程对象，直接拿来用，提升系统性能）
- 后期你还会学习更多的缓存技术，例如：redis.mongDB……
-
ServletContext当中有桑操作域的方法
void serAttribute(String name,Object obj); //向域中绑定数据 Object getAttribute(String name); //从域中根据name获取数据 void removeAttribute(String name); //将域中当定的数据移除 //以上的操作类似于Map集合的操作 Map<String ,Object> map; map.put("name",obj);//向map集合中放key和value Object obj=map.get("name");//通过map集合的key获取value map.remove("name"); //通过Map集合的key删除key删除key和value这个键值对 -
"请求域"对象
-
“请求域"对象要比”应用域“对象范围小很多，生命周期短很多，请求域只在一次请求内有效
-
一个请求对象request对应一个请求域对象，一次请求结束之后，这个请求域就销毁了。
-
请求域对象也有这桑方法。
-
void serAttribute(String name,Object obj); //向域中绑定数据 Object getAttribute(String name); //从域中根据name获取数据 void removeAttribute(String name); //将域中当定的数据移除 -
请求域和应用域的选用原则？
- 尽量使用小的域对象，因为小的域对象暂用的资源较少
-
-
跳转
-
转发（一次请求）
-
//第一步：获取请求转发器对象 RequestDispatcher dispatcher = req.getRequestDispatcher("/b"); //第二步：调用请求转发器RequestDispatcher的forward方法，进行转发 //转发的时候，这两个参数很重要，request和response都是要传递给下一个资源的、 dispatcher.forward(req,resp); //第一步和第二步代码可以联合在一起。 req.getRequestDispatcher("/b").forward(req,resp);
-
-
两个Servlet怎么共享数据？
- 将数据放在ServletContext应用域当中，当然是可以的，但是应用域范围太大，占用资源太多，不建议使用。
- 可以将数据放在request域当中，然后Aservlet转发到BServlet，保证AServlet和BServle在同一次请求中，这样就可以做到两个Servlet,或者多个Servlet共享同一份数据。
-
转发的下一个资源必须是一个Servlet吗？
- 不一定，只要是Tomcat服务器当中的合法资源，都是可以转发的,例如：html……
- 注意：转发的时候，路径的写法要注意，转发的路径以”/“开始，不加项目名。
-
关于request对象中两个非常容易混淆的方法：
-
//url?username=zhangsan&userpwd=123&sex=1 String username=req.getParameter("username"); //之前一定是执行过：request.setAttribute("name",new Object()) Object obj=req.getAttribute("name"); //以上两个方法的区别是什么？ //第一个方法：获取的是用户在浏览器上提交的数据 //第二个方法：获取的是请求域当中绑定的数据 -
HttpServletRequest接口的其他常用方法：
//获取客户端的IP地址 String remoteAddr=req.getRemoteAddr(); //get请求在请求行上提交数据 //post请求在请求体中提交数据 //设置请求体的字符集(显然这个方法是处理POST请求的乱码问题，这种方法并不能处理GET请求的乱码问题) //Tomcat10之后，request请求体当中的字符集默认就是UTF-8，不需要设置字符集，不会出现乱码问题 req.setCharacterEncoding("UTF-8"); //在Tomcat9之前（包括9），响应中文也是有乱码的，怎么解决这个响应的乱码？ resp.setContentType("text/html;charset=UTF-8") //get请求发送的时候，数据是在请求行上提交的，不是在请求体当中提交的 //get请求乱码怎么解决 //方案：修改CATALINA_HOME/conf/server.xml配置文件 <Connector URIEncoding="UTF-8"> //注意：从Tomcat8之后，URIEncoding1的默认值就是UTF-8,所以GET请求也没有乱码问题了。 //这个方法使用比较多，（动态获取应用的根路径。） String contextPath =req.getContextPath(); //获取请求方式 String method=req.getMethod(); //获取请求的URI String requestURI = req.getRequestURI();// /aaa/test //获取servlet path String servletPath=req.getServletPath();// /test
-
-
-
-
使用纯Servlet做一个单表的CRUD操作
-
使用纯粹的Servlet完成单表【对部门】的增删改查操作（B/S结构的）
-
实现步骤
-
第一步：准备一张数据库表(sql脚本)
-
# 部门表 drop table if exists dept; create table dept( deptno int primary key, dname varchar(255), loc varchar(255) ); insert into dept(deptno,dname,loc) values(10,'销售部','北京'); insert into dept(deptno,dname,loc) values(20,'研发部','上海'); insert into dept(deptno,dname,loc) values(30,'技术部','广州'); insert into dept(deptno,dname,loc) values(40,'媒体部','深圳'); commit; select * from dept; -
第二步：准备一套HTML页面（项目原型）【前端开发工具使用HBuilder】
- 把HTML页面准备好
- 然后将HTML页面中的连接都能够跑通。（页面流转没有问题）
- 应该设计哪些页面呢？
- 欢迎页面：index.html
- 列表页面：list.html（以列表页面为核心，展开其他操作）
- 新增页面：add.html
- 修改页面：edit.html
- 详情页面：detail.html
-
第三步：分析我们这个系统包括哪些功能？
- 什么叫做一个功能呢？
- 只要这个操作连接了数据库，就表示一个独立的功能。
- 包括哪些功能？
- 查看部门列表
- 新增部门
- 删除部门
- 查看部门详细信息
- 跳转到修改页面
- 修改部门
-
第四步：在IDEA当中搭建开发环境
- 创建一个webapp(给这个webapp添加Servlet-api.jar和jsp-api.jar到classpath当中)
- 向webappp中添加连接数据库的jar包（mysql驱动）
- 必须在WEB-INF目录下新建lib目录，然后将mysql的驱动jar包拷贝到这个lib下
- JDBC的工具类
- 向所有HTML页面拷贝到web目录下
-
第五步：实现第一个功能：查看部门列表
-
我们应该怎么取实现一个功能呢？
- 建议：你可以从后端往前端一步一步写，也可以从前端一步一步往后端写，都可以。但是前往要记住不要想起来什么写什么。你写代码的过程最好是代码的执行过程，也就是说：程序执行到哪里，你就写到哪里，这样一个顺序流下来之后，级别上不会出现什么意外，错误。
- 从哪里开始？
- 假设从前端开始，那么一定是从用户点击按钮那里开始的
-
第一：先修改前端页面的超链接，因为用户先点击的就是这个超连接。
-
<a href="/oa/dept/list">查看部门列表</a>
-
-
第二：编写web.xml文件
-
<servlet> <servlet-name>List</servlet-name> <servlet-class>com.oa.web.action.DeptListServerlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>List</servlet-name> <!-- web.xml文件中这个路径也是以“/”开始的，但是不需要加项目名--> <url-pattern>/dept/list</url-pattern> </servlet-mapping>
-
-
编写DeptListServlet类继承HttpServlet.然后重写doGet方法。
-
package com.oa.web.action; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; public class DeptListServerlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { } }
-
-
第四：在DeptListServlet类的doGet方法中连接数据库，查询所有部门，动态的展示部门列表页面
-
分析liat.html页面中哪部分是固定死的，哪部分是需要动态展示的
-
list.html页面中的内容所有的双引号要替换成单引号，因为out.print(“”)这里有一个双引号，容易冲突。
-
现在完成这个功能之后，你会有一种感觉。感觉开发很繁琐，只使用servlet写代码太繁琐了
-
while (rs.next()){ String depno=rs.getString("a"); String dname=rs.getString("dname"); String loc=rs.getString("loc"); out.print(" <tr>"); out.print(" <th>"+(++i)+"</th>"); out.print(" <th>"+depno+"</th>"); out.print(" <th>"+dname+"</th>"); 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>"); }
-
-
-
第六步：查看部门详情
-
详情：从前端往后端一步一步实现。首先要考虑的是，用户点击的是什么？用户点击的东西在哪里？
-
一定要先找用户点击的“详情”在哪里。找了半天，终于在后端的java程序中找到了
-
<a href='写一个路径'>详情</a> -
详情 是需要连接数据库的，所以这个超链接点击之后也是需要执行一段java代码的，所以要将这个超链接的路径修改一下。
-
-
技巧
-
out.print("<a href='"+contextPath+"/dept/datail?deptno="+depno+"'>详情</a>"); -
重点：向服务器提交数据的格式：url?name=value&name=value&name=value
-
这里的问号，必须是英文的问号。不能中文的问号。
-
-
解决404的问题，写web.xml文件
-
<servlet> <servlet-name>detail</servlet-name> <servlet-class>com.oa.web.action.DeptDetailServerlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>detail</servlet-name> <!-- web.xml文件中这个路径也是以“/”开始的，但是不需要加项目名--> <url-pattern>/dept/datail</url-pattern> </servlet-mapping> -
编写一个类：DeptDetailServer继承HttpServlet,重写doGet方法。
-
package com.oa.web.action; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; public class DeptDetailServerlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //中文思路（思路来源于：你要做什么?目标：查看部门详细信息） //第一步：获取部门编号 //第二步：根据部门编号查询顺巨款，获取该部门编号对应的部门信息 //第三步：将部门信息响应到浏览器上。（显示一个详情.） } }
-
-
在doGet方法当中：连接数据库，根据部门编号查询该部门的信息。动态展示部门详情页。
-
-
-
第七步：删除部门
-
怎么开始？从哪里开始？从前端页面开始，用户点击删除按钮的时候，应该提示用户是否删除？因为删除这个动作是比较危险的。任何系统在进行删除操作之前，是必须要提示用户的，因为删除的动作有可能是用户误操作。
-
<a href="javascript:void(0)" onclick="del(30)">删除</a> <script> function del(dno){ var ok =window.confirm("亲，删了不可恢复喔！"); if(ok){ document.location.href="/oa/dept/delete?deptno="+dno; } } </script> -
解决404问题
-
http://localhost:8080/oa/dept/delete?deptno=10
-
web.xml文件
-
<servlet> <servlet-name>delete</servlet-name> <servlet-class>com.oa.web.action.DeptDELServerlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>delete</servlet-name> <!-- web.xml文件中这个路径也是以“/”开始的，但是不需要加项目名--> <url-pattern>/dept/delete</url-pattern> </servlet-mapping>
-
-
编写DeptDelServlet继承HttpServlet,重写doGet方法。
-
package com.oa.web.action; import com.oa.utils.DBUtil; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; public class DeptDELServerlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //根据部门编号,删除部门. } } -
删除成功或者失败的时候的一个处理（这里我们选择了转发，并没有使用重定向机制。）
-
//判断删除成功了还是失败了 if(count==1){ //删除成功 //仍然跳转到部门累表页面 //部门列表页面的显示需要执行另一个Servlet.怎么办?转发. req.getRequestDispatcher("/dept/list").forward(req,resp); }else{ //删除失败 req.getRequestDispatcher("/error.html").forward(req,resp); }
-
-
-
第八步：新增部门
- 注意：最后保存成功之后，转发到/dep/list的时候，会出现405，为什么？
- 第一：保存用的是post请求，底层当中只有一个doGet方法
- 第二：转发是一次请求，之前是post,之后还是post,因为它是一次请求
- 第三：/dep/list Servlet当中只有一个doGet方法
- 怎么解决？两种方案
- 第一种：在/dep/list Servlet中添加doPost方法。然后再doPost方法中调用doGet。
- 第二种：重定向
- 注意：最后保存成功之后，转发到/dep/list的时候，会出现405，为什么？
-
第九步：跳转到修改部门的页面
-
第十步：修改部门
-
再一个web应用中应如何完成资源的跳转
-
再一个web应用中如何实现资源跳转?
- 转发
- 重定向
-
转发和重定向有什么区别？
-
代码上
-
转发
-
//第一步：获取请求转发器对象 RequestDispatcher dispatcher = req.getRequestDispatcher("/b"); //第二步：调用请求转发器RequestDispatcher的forward方法，进行转发 //转发的时候，这两个参数很重要，request和response都是要传递给下一个资源的、 dispatcher.forward(req,resp); //第一步和第二步代码可以联合在一起。 req.getRequestDispatcher("/b").forward(req,resp); //转发的时候是一次请求，不管你转发了多少次，都是一次请求 //这是因为调用foward方法的时候，会将当前的req和resp对象传递给下一个Servlet。
-
-
重定向
-
//注意：路径上要加一个项目名。为什么？ //浏览器发送请求，请求路径上是需要添加项目名的 //以下这一行代码会将请求路径“/oa/dept/list”发送给浏览器 //浏览器会自发的向服务器发送一次全新的请求:/oa/dept/list resp.sendRedirect("/oa/dept/list");
-
-
-
形式上有什么区别？
- 转发（一次请求）
- 在浏览器地址栏上发送的请求是：http://localhost:8080/servlet07/a
- 转发（一次请求）
-
* 重定向（两次请求）
* 在浏览器地址栏上发送的请求是：http://localhost:8080/servlet07/b\
-
转发和重定向的本质区别？
- 转发：是由WEB服务器来控制的，A资源跳转到B资源，这个跳转动作是由Tomcat服务器内部完成的。
- 重定向：是浏览器来完成的，具体跳转到哪个资源，是浏览器说了算。
-
转发和重定向应该如何选择？什么时候使用转发，什么时候使用重定向？
- 如果在上一个Servlet当中向request域中绑定了数据，希望从下一个Servlet当中把request域里面的数据取出来，使用转发机制。
- 剩下的所有请求均使用重定向（重定向使用较多）
-
跳转的下一个资源有没有要求呢？必须是一个Servlet吗？
- 不一定，跳转的资源只要是服务器内部合法的资源即可，包括：Servlet,JSP,HTML……
- 转发会出现刷新问题
将oa项目中的资源跳转修改为合适的跳转方式
- 删除之后，重定向
- 修改之后，重定向
- 保存之后，重定向
Servlet注解，简化配置
-
分析oa项目的web.xml文件
-
现在只是一个单表的CRUD，没有复炸的业务逻辑，很简单的功能。web.xml文件中就有如此多的配置信息，如果采用这种方式，对于一个大的项目来说，这样的话web.xml文件会非常庞大，有肯最终会到达几十兆。
-
而且web.xml文件中的配置很少被修改的，所以这种配置信息能不能直接写到java类中呢？当然可以。
-
-
Sevlet3.0版本之后，推出了各种Servlet基于注解式的开发，优点是什么？
-
开发效率高，不需要编写大量的配置信息。直接在java类中使用注解进行标注。
-
web.xml文件体积变小了
-
-
并不是说注解有了之后，web.xml文件就不需要了：
- 有一些需要变化的信息，还是要配置到web.xml文件中，一般都是 注解+配置文件 的开发模式。
- 一些不会经常变化修改的配置建议使用注解。一些可能会被修改写到配置文件中。
import javax.servlet.annotation.WebServlet;
- 在Servlet类上使用：@WebServlet,WebServlet注解中有哪些属性呢？
- name属性：用来指定Servlet的名字，等价于：
- urlPatterns属性：用来指定Servlet的映射路径，可以指定多个字符串。
- loadOnStartUp属性：用来指定在服务器启动阶段是否加载该Servlet,等同于：
- value属性：value属性名是可以省略的。
- 注意：不是必须要将所有属性都写上，只需要提供需要的。（需要什么用什么）
- 注意：属性是一个数组，如果数组中只有一个元素，使用该注解的时候，value属性名的大括号可以省略的。
- 注解对象的使用格式
- @注解名称（属性名=属性值，属性名=属性值，属性名=属性值）
使用模板方法设计模式优化oa项目
- 上面的注解解决了配置文件的问题，但是现在的oa项目人人存在一个比较臃肿的问题。
- 一个单表的CRUD,就写了6个Servlet,如果一个复炸的业务系统，这种开发方式，显然会导致类爆炸。（类的数量太大）
- 怎么解决这个类爆炸问题？可以使用模板方法设计模式
- 怎么解决类爆炸问题？
- 以前的设计是一个请求一个Servlet类，1000个请求对应1000个Servlet类，导致类爆炸。（类的数量太大）
- 可以这样做：一个请求对应一个方法，一个业务对应一个Servlet类。
- 处理部门相关业务的对应一个DeptServlet。处理用户相关业务的对应一个UserServlet.处理英航卡卡片业务对应一个CardServlet.
分析使用纯粹Servlet开发web应用的缺陷
-
在Servlet当中编写HTML/CSS/JavaScript等前端代码，存在什么问题？
- java程序中编写前端代码，编写难度大，麻烦
- java程序中编写前端代码，显然程序的耦合度非常高
- java程序中编写前端代码，代码非常不美观
- java程序中编写前端代码，维护成本太高（非常难于维护）
- 修改小小的一个前端代码，只要有改动，就需要重新编译java代码，生成新的class文件，打一个新的war包，重新发布。
-
思考以下，如果是你的话，你准备怎么解决这个问题？
- 思路很重要，使用什么样的思路去做，去解决这个问题
- 上面的哪个Servlet(java程序)能不能不写了，让机器自动生成，我们程序员只需要写这个Servlet程序中的“前端的代码”，然后让机器将我们写的“前端代码”自动翻译生成“Servlet这种java程序“。然后机器再自动将"java"程序编译生成class文件，然后再使用JVM调用这个class中的方法。
- 思路很重要，使用什么样的思路去做，去解决这个问题
Session
关于B/S结构系统的会话机制（sesssion机制）
-
什么是会话
- 会话对应的英语单词：sesssion
- 用户打开浏览器，进行一系列操作，然后最终将浏览器关闭，这个整个过程叫做：一次会话。会话在服务器端也有一个对应的java对象，这个java对象叫做：session
- 回顾：什么是一次请求：用户在浏览器上点击了一下，然后到页面停下来，可以粗略认为是一次请求，请求对应的服务器java对象是：request.
- 一个会话当中包含多次请求。（一次会话对应N次请求。）
-
在java的servlet规范当中，session对应的类名：HttpSession(javax.sevlet.http.HttpSession)
-
session机制属于B/S结构的一部分，如果使用php语言开发WEB项目，同样也是有session这种机制的。session机制实际上是一种规范。然后不同的语言对这种会话机制都有实现。
-
session对象最主要的作用是：保存会话状态。（用户登录成功了1，这是一种登录成功的状态，你怎么把登录成功的状态一直保留起来呢？使用session对象可以保留会话状态。）
-
为什么需要session对象来保存会话状态呢？
- 因为HTTP协议是一种无状态协议
- 什么是无状态：请求的时候，B和S是连接的，但是请求结束之后，连接就断了。为什么要这么做？HTTP协议为什么要设计成这样？因为这样的无状态协议，可以降低服务器的压力，请求的瞬间是连接的，请求结束之后，连接断开，这样服务器压力小。
- 只要B和S断开了，那么关闭浏览器这个动作，服务器知道吗？
- 不知道，服务器是不知道浏览器关闭的。
-
张三打开一个浏览器A,李四打开一个浏览器B，访问服务器之后，在服务端会生成：
- 张三专属的session对象
- 李四专属的session对象
-
为什么不使用request对象保存会话状态?为什么不使用ServletContext对象保存会话状态？
- request.setAttribute()存，request.getAttribute()取，ServletContext也有这个方法。request是请求域。ServletContext是应用域。
- request是一次请求一个对象
- ServletContext对象是服务器启动的时候创建，服务器关闭的时候销毁，这个ServletContext对象只有一个。
- ServletContext对象的域太大
- request请求域（HttpServletRequest）,session会话域(HttpSession),application域（ServletContext）
- request<session<application
1.session对象是存储在服务器端的 2.一个session对象对应一个会话 3.一次会话包含多次请求 4.session怎么获取 HttpSession session = request.getSession(); 从服务器中获取当前的session对象。 如果没有获取到任何session对象，则新建。 HttpSession session=request.getSession(false); 从服务器中获取当前session对象。 如果获取不到session,则不会新建，返回一个null. 5.session的实现原理 在web服务器中有一个session列表，类似于map集合， 这个map集合的key存储的是sessionid 这个map集合的value存储的是对应的session对象 用户发送一次请求的时候：服务器会创建一个新的session对象，同时给session对象生成一个id,然后web服务器会将session的id发送给浏览器，浏览器将session的id保存在浏览器的缓存中。 用户发送第二次请求的时候：会自动将浏览器缓存中的sessionid自动发送给服务器，服务器获取到sessionid,然后从session列表中查找到对应的session对象。 6.为什么关闭浏览器，会话结束？ 关闭浏览器之后，浏览器中保存的sessionid消失，下次重新打开浏览器之后，浏览器缓存中没有这个sessionid,自然早不到服务器中对应的session对象。session对象找不到等同于会话结束。 7.session对象什么时候被销毁？ 一种销毁：是超时销毁 浏览器关闭的时候，服务器无法检测到浏览器关闭了，所以session的销毁要依靠session超时机制。 一种销毁：是手动销毁 也有一种可能，系统提供了“安全退出”机制，用户可以点击这个按钮，然后服务器就知道你安全退出了，然后服务器会自动销毁session对象。 -
session的实现原理：
- JSSIONID=xxxxx,这个是以Cookie的形式保存在浏览器的内存中的，浏览器只要关闭，这个cookie就没有了。
- session列表是一个Map,map的key是sessionid,map的value是session对象。
- 用户第一次请求，服务器生成session对象，同时生成id,将id发送给浏览器。
- 用户第二次请求，自动将浏览器内存中的id发送给服务器，服务器根据id查找session对象
- 关闭浏览器，内存消失，cookie消失，sessionid消失，会话等同于结束。
-
Cookie禁用了，session还能找到吗？
- cookie禁用是什么意思？服务器正常发送cookie给服务器，但是浏览器不要了，拒收了。并不是服务器不发了。
- 找不到了，session机制还能实现吗？
- 可以，需要使用URL重写机制。
- http://localhost:8080/servlet09/test/session;JSESSIONID=C7D219385FDFAA2D73722616D8A20C46
- URL重写机制会提高开发者的成本，开发人员在编写任何请求路径的时候，后面都要添加一个sessionid,给开发者带来了很大的难度，很大的成本。所以大部分的网址都是这样设计的，你要是禁用cookie，你就别用了。
-
总结一下到目前为止我们所了解的域对象：
- request(对应的类名：HttpServletRequest)
- 请求域（请求级别的）
- session(对应的类名：HttpSession)
- 会话域（用户级别的）
- application(对应的类名：ServletContext)
- 应用域（项目级别的，所有用户共享的）
- 这桑域对象的大小关系
- request<session<application
- 他们三个对象都有一下三个公共的方法：
- setAttribute(向域中绑定数据)
- getAttruibute(从域中获取数据)
- removeAttribute(删除域当中的数据)
- 使用原则：尽量使用小的域。
- request(对应的类名：HttpServletRequest)
-
session掌握之后，我们可以怎么解决oa项目中的登录问题，怎么让登录起作用。
- 登录成功之后，可以将用户的登录信息存储到session当中，也就是说session中如果有用户的信息就代表用户登录成功了。session中没有用户信息，表示用户没有登录过，则跳转到登录页面。
-
销毁session对象：
-
session.invalidate();
-
cookie
-
session的实现原理中，每一个session对象都会关联一个sessionid,例如：
- JSESSIONID=91E5619562D68483E540FAAF38478261
- 以上的这个键值对数据其实就是cookie对象
- 对于session关联的cookie来说，这个cookie是被保存在浏览器的“运行内存”当中。
- 只要浏览器不关闭，用户再次发送请求的时候，会自动将内存中的cookie发送给服务器
- 例如：这个Cookie: JSESSIONID=91E5619562D68483E540FAAF38478261就会再次发送给服务器。
- 服务器就是根据91E5619562D68483E540FAAF38478261这个值来找到对应的session对象的。
-
cookie怎么生成？cookie保存在什么地方？cookie有啥用？浏览器什么时候会发送cookie，发送哪些cookie给服务器？
-
cookie最终是保存在浏览器客户端上。
- 可以保存在运行内存中（浏览器只要关闭cookie就消失了）
- 也可以保存在硬盘文件中。（永久保存）
-
cookie有啥用？
- cookie和session机制其实都是为了保存会话的状态
- cookie是将会话的状态保存在浏览器客户端上（cookie数据存储在浏览器客户端上）
- session是将会话的状态保存在服务端上（session对象是存储在服务器上）
- 为什么要有cookie和session机制呢？因为HTTP协议是无状态 无连接协议。
-
cookie经典案例？未登录的状态加进购物车。
- 将购物车的商品编号放进cookie当中，cookie保存在硬盘文件当中，这样即使关闭浏览器，硬盘上的cookie还在。下一次再打开京东商城查看购物车的时候，会自动读取本地硬盘中存储的cookie,拿到商品编号，动态展示购物车中的商品。
- 京东存储购物车的cookie肯是这样的:productids=xxxx,yyyy,zzzz
- 注意：cookie如果清除掉，购物车中的商品就消失了。
- 126邮箱有一个功能：十天内免登录
- 这个功能也是需要cookie来实现的。
- 怎么实现的呢？
- 用户输入正确的用户名和密码，并且同时选择十天内免登录。浏览器客户端会保存一个cookie,这个cookie中保存了用户名和密码等信息。这个cookie是保存再硬盘文件当中的，十天内有效。在十天内用户再次访问126的时候，浏览器会自动提交126的关联的cookie给服务器，服务器接收到cookie之后，获取用户名和密码，验证，通过之后，自动登录成功。
- 怎么让cookie失效
- 十天内自动失效
- 改密码
- 清浏览器的cookie
- cookie机制和session机制其实都不属于java中的机制，实际上cookie机制和session机制都是HTTP协议的一部分。php开发中也有cookie和session机制，只要你是做web开发，不管是什么编程语言，cookie和session机制都是需要的。
- HTTP协议中规定：任何一个cookie都是由name和value组成的。name和value都是字符串类型的。
- 将购物车的商品编号放进cookie当中，cookie保存在硬盘文件当中，这样即使关闭浏览器，硬盘上的cookie还在。下一次再打开京东商城查看购物车的时候，会自动读取本地硬盘中存储的cookie,拿到商品编号，动态展示购物车中的商品。
-
在java的servlet中，对cookie提供哪些支持？
- 提供了一个Cookie类来专门表示cookie数据。javax.servlet.http.Cookie；
- java程序怎么把cookie数据发送给浏览器？response.addCookie(cookie);
-
在HTTP协议中是这样规定的：当浏览器发送请求的时候，会自动携带该path下的cookie数据给服务器。(URL)
-
关于cookie的有效时间
-
怎么用java设置cookie的有效时间
-
//设置cookie在一小时之后失效 cookie.setMaxAge(60*60);
-
-
没有设置有效时间：默认保存在浏览器的运行内存中，浏览器关闭则cookie消失。
-
只要设置cookie的有效时间>0,这个cookie一定会存储到硬盘文件当中。
-
设置cookie的有效时间=0，表示cookie被删除，主要应用在，使用这种方式删除浏览器上的同名cookie
-
设置cookie的有效时间<0呢，表示该cookie不会被存储 （表示不会被存储到硬盘当中，会被存储到浏览器运行内存当中。）和不调用setMaxAge是同一个效果。
-
-
关于 cookie的path,cookie关联的路径：
- 假设现在发送的请求路径是“http://localhost:8080/servlet10/cookie1/generate”生成的cookie,如果cookie没有设置path,默认的path是什么？
- 默认的path是：http://localhost:8080/servlet10/cookie1以及它的子路径
- 也就是说，只要是http://localhost:8080/servlet10/cookie1以及它的子路径，cookie都会被发送到服务器。
- 手动设置cookie的path
- cookie.setPath(“/servlet10”);表示只要是servlet10项目的请求路径，都会提交这个cookie给服务器。
- 假设现在发送的请求路径是“http://localhost:8080/servlet10/cookie1/generate”生成的cookie,如果cookie没有设置path,默认的path是什么？
-
浏览器发送Cookie给服务器了，服务器中的java程序怎么接收？
-
//注意细节，如果浏览器没有提交cookie,返回null,而不是一个空数组 Cookie[] cookies = req.getCookies(); //如果不是null,表示一定有cookie if (cookies != null) { //遍历数组 for (Cookie cookie : cookies) { //获取cookie name和value String name=cookie.getName(); String value=cookie.getValue(); System.out.println(name+"="+value); } } -
使用cookie实现十天内免登陆功能
-
先实现登陆功能
- 登陆成功：
- 跳转到部门列表页面
- 登陆失败
- 跳转到登陆失败页面
- 登陆成功：
-
修改前端页面
- 在登陆页面给一个复选框，复选框后面给一句话：十天内免登陆
- 用户选择了复选框：表示支持十天内免登录
- 用户没有选择复选框：表示用户不想使用十天内免登陆功能
-
修改Servlet中的login方法
- 如果用户登陆成功了，并且用户登录时选择了十天内免登陆功能，这个时候应该在Servlet的login方法中创建cookie,用来存储用户名和密码，并且设置路径，设置有效期，将cookie响应给浏览器。（浏览器将其自动保存在硬盘文件当中十天）
-
用户再次访问该网站的时候，访问这个网站的首页的时候，有两个走向：
- 要么跳转到部门列表页面
- 要么跳转到登录页面
- 以上分别有两个走向，这显然是需要编写java程序进行控制的。
JSP
JSP基础语法
-
我的第一个JSP程序：
- 再WEB-INF目录之外创建一个index.jsp文件，然后这个文件中没有任何内容
-
将上面的部门部署之后，启动服务器，打开浏览器，访问以下地址：
- http://localhost:8080/jsp/index.jsp展现在大家面前的是一个空白
- 实际上访问以上的这个index.jsp，底层执行的是：index_jsp.class这个java程序
- 这个index.jsp会被tomcat翻译生成index_jsp.java文件，然后tomcat服务器又将index_jsp.java编译生成index_jsp.class文件。
- 访问index.jsp,实际上执行的是index_jsp.class中的方法。
-
JSP实际上就是一个Servlet。
- index.jsp访问的时候，会自动翻译生成index_jsp.java,会自动编译生成index_jsp.class，那么index_jsp这就是一个类。
- index_jsp类继承HttpJspBase,而HttpJspBase类继承的是HttpSevlet,而HttpServlet类继承的是HttpServlet.所以index_jsp就是一个Servlet类。
- jsp的生命周期和Servlet的生命周期完全相同，完全就是一个东西，没有任何区别。
- jsp和sevlet一样，都是单例的。（假单例）
-
jsp文件第一次访问的时候是比较慢的，为什么？
- 为什么大部分的运维人员在给客户演示项目的时候，为什么提前先把所以的jsp文件先访问一遍。
- 第一次比较麻烦：
- 要把jsp文件翻译生成java源文件
- java源文件要翻译生成class字节码文件
- 然后通过class去创建servlet对象
- 然后调用servlet对象的init方法
- 最后调用servlet对象的service方法
- 第二次就比较快了，为什么？
- 因为第二次直接调用单例servlet对象的service方法即可。
-
JSP是什么？
- JSP是java程序（JSP本质还是一个Servlet）
- JSP是：JavaServer Pages的缩写。（基于java语言实现的服务器端的页面。）
- Servlet是JavaEE13个子规范之一，那么JSP也是JavaEE的13个子规范之一。
- 么一个web容器/web服务器都会内置一个JSP翻译引擎。
-
对JSP进行戳五调试的时候，还是要直接打开JSP文件对应的java文件，检查java代码。
-
开发JSP的最高境界：
- 眼前是JSP代码，但是脑袋中呈现的是java代码。
-
JSP既然本质上是一个Servlet,那么JSP和Servlet到底有什么区别呢？
- 职责不同：
- Servlet的职责是什么：手机数据。（Servlet的强项是逻辑处理，业务处理，然后连接数据库，获取/收集数据。）
- JSP的职责是什么：展示数据（JSP的强项是做数据的展示）
- 职责不同：
-
JSP的基础语法
-
在jsp文件中直接编写文字，都会自动被翻译到哪里？
- 翻译到servlet类中的service方法的out.write(“翻译到这里”)，直接翻译到双括号里，被java程序当作普通字符串打印输出到浏览器。
- 在JSP中编写的HTML CSS JS 代码 这些代码对于JSP来说只是一个普通的字符串，但是JSP把这个普通的字符串一旦输出到浏览器，浏览器就会对HTML CSS JS进行解释执行，展现出一个效果。
-
JSP的page指令，解决响应的中文乱码问题：
-
通过page指令来设置响应的内容类型，在内容类型的最后添加charset+UTF-8
-
<%@page contentType="text/html; charset=UTF-8" %>- 表示响应的内容类型是text/html,采用的字符集UTF-8
-
-
怎么在JSP中编写Java程序：
- <%java语句：%>
- 在这个符号当中编写的被视为java程序，被翻译到Servlet的service方法内部
- 这里你要细心电，你要思考，在<%%>这个符号里面写java代码的时候，你要时时刻刻的记住你正在“方法体”当中写代码，方法体中可以写，不可以写什么，你心里是否明白。
- 在service方法当中编写的代码是有顺序的，方法体当中的代码要遵循自上而下的顺序一次逐行执行。
- service方法当中不能写静态代码块，不能定义成员变量……
- 在同一个JSP当中<%%>这个符号可以出现多个。
- <%!%>
- 在这个符号当中编写的java程序会自动翻译到service方法之外。
- 这个语法很少用，为什么？不建议使用，因为在service方法外面写静态变量和实例变量，都会存在线程安全问题，因为JSP就是servlet是单例的，多线程并发的环境下，这个静态变量和实例变量一旦有修改操作，必然会存在线程安全问题。
- JSP的输出语句
- 怎么向浏览器上输出一个java变量
- <%String name=“jack”;out.write(“name=”+name);%>
- 注意：代码当中的out是JSP的九大内置对象之一。可以直接拿来用，当然，必须只能在service方法内部使用。
- 如果向浏览器上输出的内容中没有"java代码"，例如输出的字符串是一个固定的字符串，可以在JSP中直接编写，不用写在<%%>里。
- 如果输出的内容含有"java"代码，这个时候可以使用以下语法格式：
- <%=%>注意：在=的后面编写要输出的内容
- <%=%>这个符号会被编译到哪里？最终翻译成什么？
- 翻译成了这个java代码：out.print();
- 翻译到service方法当中了。
- <%java语句：%>
-
在JSP中如何编写JSP的专业注释
- <%–JSP的专业注释，不会被翻译到java源代码当中–%>
-
JSP基础语法总结：
- JSP中直接编写普通字符串
- 翻译到service方法的out,write(“这里”)
- <%%>
- 翻译到service方法体内部，里面是一条由一条的java语句。
- <%!>
- 翻译到service方法之外
- <%=%>
- 翻译到service方法内部，翻译为:out.print();
- <%@page contentType=“text/html;charset=UTF-8”%>
- page指令，通过contentType属性用来设置相应的内容类型。
- JSP中直接编写普通字符串
-
使用Servlet+JSP完成oa项目的改造。
-
使用Servlet处理业务，收集数据。使用JSP展示数据。
-
将之前原型中的html文件，全部修改为jsp，然后在jsp文件头部添加page指令（指定contentType防止中文乱码），将所有的JSP直接拷贝到web目录下
-
完成所有页面的正常流转。(页面仍然能够正常的跳转，修改超链接的请求路径。)
- <%=request.getContextPath() %> 在JSP中动态获取应用的根路径。
-
Servlet中连接数据库，查询所有的部门，遍历结果集。
- 遍历结果集的过程中，取出部门编号，部门名，位置等信息，封装成java对象。
- 将java对象存放到List集合中
- 将List集合村粗到request域当中。
- 转发forward到jsp
-
在JSP中：
- 从request域当中去除List集合。
- 遍历List集合，去除每个部门对象，动态生成tr
-
思考一个问题：如果我只用JSP这一种激素，能不能开发web应用？
- 当然可以使用JSP来完成所有的功能，因为JSP就是Servlet,在JSP的<%%>里面写的代码就是在service方法当中的，所以在<%%>当中完全可以编写JDBC代码，连接数据库，查询数据，也可以在这个方法当中编写业务逻辑代码，处理业务，都是可以的，所以使用单独的JSP开发web应用完全没问题。
- 虽然JSP一个技术就可以完成web应用，但是不建议，还是建议采用servlet+jsp的方式进行开发。这样都能将各自的优点发挥出来，JSP就是做数据展示。Servlet就是做数据的收集。（JSP中编写的代码越少越好）一定要职责分明
-
JSP文件的扩展名必须是xxx.jsp吗？
-
jsp文件的扩展名是可以配置的，不是固定的。
-
在CATALINA_HOME/conf/xml，在这个文件当中配置jsp文件的扩展名
-
<servlet-mapping> <servlet-name>jsp</servlet-name> <url-pattern>*.jsp</url-pattern> <url-pattern>*.jspx</url-pattern> </servlet-mapping> -
xxx.jsp文件对于小猫咪来说，只是一个普通的文本文件，web容器会将xxx.jsp文件最终生成java程序，最终调用的是java对象相关的方法，真正执行的时候，和jsp文件没有关系了。
-
-
-
-
当前oa应用中存在的问题:
- 任何一个用户都可以访问这个系统，都可以对这个系统中的数据进行增删改这些危险操作。我指向让合法的用户去使用这个系统，不合法的用户不能访问这个系统，怎么办？
- 加一个登陆功能，登陆成功的可以访问该系统，登陆失败不能访问
- 实现登陆功能：
- 步骤1：数据库当中添加一个用户表：t_user
- t_user表当中存储的是用户的登陆信息，最基本的也包括：登陆的用户名和登陆的密码。
- 密码一般在数据库当中存储的是密文，一般不以明文的形式1存储。（这里先使用明文方式）
- 向t_user表中插入数据
- 步骤2：再实现一个登陆页面
- 登陆页面上应该由一个登陆的表单。由用户名和密码输入的框
- 用户点击登陆，提交表单，提交用户名和密码，form是post方式提交。
- 步骤3：后台要由一个对于的Servlet来处理登陆的请求。
- 登陆成功：跳转到部门泪飙页面
- 登陆失败：跳转到失败页面
- 步骤4：再提供一个登陆失败的页面
- 步骤1：数据库当中添加一个用户表：t_user
- 任何一个用户都可以访问这个系统，都可以对这个系统中的数据进行增删改这些危险操作。我指向让合法的用户去使用这个系统，不合法的用户不能访问这个系统，怎么办？
-
登陆功能实现了，目前存在的最大的问题：
- 这个登陆功能目前只是一个摆设，没有任何作用，只要用户知道后端的请求路径，照样可以在不登录的情况下访问。
JSP的指令
-
指令的作用：指导JSP的翻译引擎如何工作。（指导当前的JSP翻译引擎如何翻译JSP文件）
-
指令包括那些：
- include指令：包含指令，在JSP中完成静态包含，很少用
- taglib指令：引入标签库的指令，与JSTL标签库关联，在下面JSTL进行学习
- page指令：这里重点学习
-
指令的使用语法是什么？
- <%@指令名 属性名=属性值 属性名=属性值 属性名=属性值……%>
-
关于page指令当中有那些常见的属性？
-
<%@page session="true|false" %> true表示启用JSP的内置对象session,表示一定启动session对象。没有session对象会创建。 如果没有设置，默认值就是session="true" session="false"表示不启动内置对象session。当前JSP页面中无法使用内置对象session. -
<%@page contentType="text/json" %> contentType属性用来设置响应的内容类型 但同时也可以设置字符集 <%@page contentType="text/json";charset=UTF-8 %> -
<%@page pageEncoding="UTF-8" %> pageEncoding="UTF-8" 表示设置响应响应时采用的字符集 -
<%@page import="java.util.List,java.util.ArrayList" %> <%@page import="java.util.*" %> import语句，导包 -
<%@page errorPage="/error.jsp" %> 当前页面出现异常之后，跳转到error.jsp页面 errorPage属性用来指定处处哦之后的跳转位置。 -
<%@page isErrorPage="true" %> 表示启用JSP九大内置对象之一：exception 默认值是false
-
JSP的九大内置对象
-
javax.sevlet.jsp.PageContext pageContext 页面作用域
-
javax.servlet.http.HttpServletRequest request 请求作用域
-
javax.setvlet.http.HttpServletSession session 会话作用域
-
javax.servlet.ServletContext application 应用作用域
- pageContext<request<session<application
- 以上四个作用域都有：setAttribute,getAttribute,removeAttribute
- 以上作用域的使用原则：经肯使用小的域
-
java.lang.Throwable exception
-
javax.servlet.ServletConfig config
-
java.lang.Object page（其实是this,当前的servlet对象）
-
javax.servlet.jsp.jspWriter out（负责输出）
-
javax.servlet.http.HttpServletResponse response（负责响应）
EL表达式
-
EL表达式是干什么用的？
- Expression Language(表达式语言)
- EL表达式可以代替JSP中的java代码，让JSP文件中的程序看起来更加整洁，美观
- JSP中夹杂着各种java代码，例如<% java代码%>,<%=%>等，导致JSP文件很混乱，不好看，不好维护。所以才有了后期的EL表达式。
- EL表达式可以算是JSP语法的一部分。EL表达式归属域JSP
-
EL表达式出现在JSP中主要是：
-
从某个作用域中取数据，然后将其转换成字符串，然后将其输出到浏览器。这就是EL表达式的功效。三大功效：
- 第一功效：从某个域中取数据
- 四个域：
- pageContext
- request
- session
- application
- 四个域：
- 第二功效：将取出的数据转为字符串
- 如果是一个java对象，也会自动调用java对象的toString方法将其转换成字符串。
- 第三功效：将字符串输出到浏览器
- 和这个一样：<%=>，将其输出到浏览器
- 第一功效：从某个域中取数据
-
EL表达式很好用，基本的语法格式：
- ${表达式}
-
EL表达式的使用
-
<% //创建user对象 User user=new User(); user.setUsername("jackson"); user.setPassword("1234"); user.setAge(50) //将user对象存储到某个域当中，一定要存，因为EL表达式只能从某个范围中取出 request.setAttribute("userObj",user); %> <%--使用EL表达式取--%> ${这个位置写什么？？？这里写的一定是要存储到域对象当中的name} 要这么写： ${userObj} 等同于java代码：<%=request.getAttribute("userObj")%> 不要这样写：${"userObj"} 面试题： ${abc}和${"abc"}的区别是什么？ ${abc}表示从某个域中取出数据，并且被取的这个数据的name是"abc",之前一定有这样的代码：域.setAttribute("abc",对象)； ${"abc"}表示直接将"abc"当做普通字符串输出到浏览器。不会再从某个域中取数据了。 ${userObj}底层是怎么做的？从域中取数据，取出user对象，然后调用user对象的toString方法，转换成字符串，输出到浏览器 <%--如果想要输出对象的属性值，怎么办？--%> ${userObj.username}使用这个语法的前提是：user对象有getUsername()方法 ${userObj.password}使用这个语法的前提是：user对象有getPassword()方法 ${userObj.age}使用这个语法的前提是：user对象有getAge()方法 ${userObj.email}使用这个语法的前提是：user对象有getEmail()方法 EL表达式中的这个语法，实际上调用了底层的getXxx()方法。 注意：如果没有对应的get方法，则会出现异常，报500错误 ${userObj.addr.city} 以上EL表达式对应的java代码： user.getAddr().getCity() -
EL表达式优先从小范围读取数据
- pageContext<request<session<application
-
EL表达式中有四个隐含的隐式的范围：
- pageScope对应的是pageContext范围
- requestScope对应的是request范围
- sessionScope对应的是session范围
- applicationScope对应的是application范围
-
EL表达式对null进行了预处理，如果是null,则向浏览器输出一个空字符串
-
EL表达式取数据的时候有两种形式：
- 第一种：. (大部分使用这种方式)
- 第二种：[] (如果存储到域的时候，这个name中含有特殊字符，可以使用[])
- request.setAttribute(“abc.def”,“zhangsan”);
- ${requestScope.abc.def}这样是无法获取的
- 应该这样：${requestScope[“abc.def”]}
-
掌握使用EL表达式，怎么从Map集合中取数据：
- ${map.key}
-
掌握使用EL表达式，怎么从数组和List集合中取数据
- ${数组[0]}
- ${数组[1]}
- ${list[0]}
-
page指令中，有一个属性，可以忽略EL表达式
-
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="true" %> isELIgnored="true"表示忽略EL表达式，默认不忽略EL表达式 isELIgnored="true"这个是全局的控制 可以使用反斜杠进行局部控制：\${username}这样也可以忽略EL表达式
-
-
通过EL表达式获取应用的根
- ${pageContext.request.contextPath}
-
EL表达式中其他的隐式对象
-
pageContext
-
param
-
paramValue
-
initParam
-
-
EL表达式的运算符
-
1.算术运算符 + - * / % 2.关系运算符 == != > >= < <= eq 3.逻辑运算符 ! && || not and or 4.条件运算符 ? : 5.取值运算符 []和. 6.empty运算符
-
-
JSTL标签库
-
什么是JSTL标签库？
- Java Standard Tag Lib(java标准的标签库)
- JSTL标签库通常结合EL表达式一起使用，目的是让JSP中的java代码消失。
-
使用JSTL标签库的步骤
-
第一步：引入JSTL标签库的jar包（tomcat9)
mpl:
Spec:
-
在IDEA当中怎么引入：
- 在WEB-INF下新建lib目录，然后将jar包拷贝到lib当中，然后将其"Add Lib……"
- 一定是要和mysql的数据驱动一样，都是放在WEB-INF/lib目录下的。
- 什么时候需要将jar包放在WEB-INF/lib目录下？如果这个jar是tomcat服务器没有的
-
第二步：在JSP中引入要使用的标签库（使用taglib指令标签库）
-
JSTL提供了很多种标签，你要引入哪种标签？？？重点掌握核心标签库。
-
<%--引入标签库指令,这里引入的是jstl核心标签库--%> <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> prefix="这里随便起一个名字就可以了，核心标签库，大家默认的叫做c"
-
-
第三步：在需要使用标签的位置使用即可，表面使用的是标签，底层实际上还是java程序。
-
-
JSTL标签的原理
-
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 以上uri后面的路径实际上指向了一个xxx.tld文件。 tld文件实际上是一个xml配置文件 在tld文件中描述了"标签"和"java类"之间的关系 以上核心标签库对应的tld文件是：c.tld文件。它在哪里。 在taglibs-standard-impl-1.2.5.jar里面的META-INF目录下，有一个c.tld文件。 -
源码解析：配置文件tld解析
-
<tag> <description>对标签的描述</description> <name>forEach</name>标签的名字 <tag-class>org.apache.taglibs.standard.tag.rt.core.ForEachTag</tag-class> <tei-class>org.apache.taglibs.standard.tei.ForEachTEI</tei-class>标签对应的java类 <body-content>JSP</body-content>标签体当中可以出现的内容，如果是JSP,就表示标签体中可以出现符合JSP所有JSP语法的代码，例如:EL表达式。 <attribute> <description>对这个属性的描述</description> <name>items</name>属性名 <required>false</required>false表示这个属性不是必须的，true表示该属性是必须的。 <rtexprvalue>true</rtexprvalue>这个描述说明了该属性是否支持EL表达式，false表示不支持，true表示支持EL表达式。 <type>java.lang.Object</type> <deferred-value> <type>java.lang.Object</type> </deferred-value> </attribute> …… </tag>
-
-
jstl中的核心标签库core当中有哪些常用的标签呢？
-
c:if
- <c:if test=“boolean类型，支持EL表达式” ></c: if>
-
c:forEach
- <c:forEach items=“集合，支持EL表达式” var=“集合中的元素” varStatus=“元素状态对象”>${元素状态对象.count}</c: forEach>
-
c:choose c:when c:otherwise
-
<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
-
使用什么技术改造呢？
- Servlet+JSP+EL表达式+JSTL标签。进行改造。
-
在前端HTML代码中，有一个标签，叫做base标签，这个标签可以设置整个网页的基础路径
-
这不是java语法，也不是JSP的语法。是HTML中的一个语法。HTML中有一个标签。通常出现在head标签中。
-
<base href="http://localhost:8080/oa3/"> -
在当前页面中，凡是路径没有以"/"开始的，都会自动将base中的路径添加到这些路径之前。
- < a href=“ab/def”></ a>
- 等同于:< a href=“http://localhost:8080/oa3/ab/def”></ a>
-
需要注意：在JS代码中的路径，保险起见，最好不要依赖base标签。JS代码中的路径最好写上全路径。
-
<base href="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${pageContext.request.contextPath}/">
-
Filter过滤器
-
当前的OA项目存在什么缺陷？
- DeptServlet,EmpServlet,OrderServlet.每一个Servlet都是处理自己相关的业务。在这些Servlet执行之前都需要判断用户是否登陆了。如果用户登录了，可以继续操作，如果没有登录，需要用户登录。这段判断用户登录的代码是固定的，并且在每一个Servlet类当中都需要编写，显然代码没有得到重复利用。怎么解决这个问题？
- 可以使用Servlet规范中的Filter过滤器来解决这个问题。
- DeptServlet,EmpServlet,OrderServlet.每一个Servlet都是处理自己相关的业务。在这些Servlet执行之前都需要判断用户是否登陆了。如果用户登录了，可以继续操作，如果没有登录，需要用户登录。这段判断用户登录的代码是固定的，并且在每一个Servlet类当中都需要编写，显然代码没有得到重复利用。怎么解决这个问题？
-
Filter是什么，有什么用，执行原理是什么？
-
Filter是过滤器
-
Filter可以在Servlet这个目标程序执行之前添加代码。也可以在目标Servlet执行之后添加代码，之前之后都可以添加过滤规则
-
一般情况下，都是在过来器当中编写公共代码
-
一个过滤器怎么写呢？
-
第一步：编写一个java类实现一个接口：javax.servlet.Filter。并且实现这个接口当中所有的方法。
- init方法：在Filter对象第一次被创建之后调用，并且只调用一次。
- doFilter方法：只要用户发送一次请求，则执行一次，发送N次请求，则执行N次，在这个方法中编写过滤规则。
- destroy方法：在Filter对象被创建/销毁之前调用，并且只调用一次。
-
第二步：在web.xml文件中对Filter进行配置，这个配置和Servlet很像
-
<filter> <filter-name>filter1</filter-name> <filter-class>com.javaweb.servlet.Filter1</filter-class> </filter> <filter-mapping> <filter-name>filter1</filter-name> <url-pattern>*.do</url-pattern> </filter-mapping> -
或者使用注解：@WebFilter({“*.do”})
-
-
-
注意：
- Servlet对象默认情况下，在服务器启动的时候是不会新建对象的
- Filter对象默认情况下，在服务器启动的时候会新建对象
- Servlet是单例的。Filter也是单例的。（单实例）
-
目标Servlet是否执行，取决于两个条件：
- 第一：在过滤器当中是否编写了：chain.doFilter(request,response);代码。
- 第二：用户发送的请求路径事故否和Servlet的请求路径一致
-
chain.doFilter(request,response);这条代码的作用：
- 执行下一个过滤器，如果没有过滤器了，执行最终的Servlet.
-
注意：Filter的优先级，天生的就比Servlet优先级高
- /a.do对应一个Filter,也对应一个Servlet,那么一定是先执行Filter,然后再执行Servlet.
-
关于Filter的配置路径
- /a.do,/b.do,/dept/save。这些匹配方式都是精确匹配
- /*匹配所有路径
- *.do后缀匹配。不要以/开始
- /dept/* 前缀匹配
-
在web.xml文件中进行配置的时候，Filter的执行顺序是什么？
- 依靠filter-mapping标签的配置位置，越靠上优先级越高
-
过滤器的调用顺序，遵循栈数据结构
-
使用@WebFilter的时候，Filter的执行顺序是怎样的呢？
- 执行顺序是：比较Filter这个类名
- 比如:FilterA和FilterB,则先执行FilterA.
- 比如:Filter1和Filter2,则先执行Filter2.
-
Filter的生命周期
- 和Servlet对象生命周期一致
- 唯一的区别：Filter默认情况下，在服务器启动阶段就实例化。Servlet不会。
-
Filter过滤器这里有一个设计模式
-
责任链设计模式。
-
过滤器最大的优点：
- 在程序编译阶段不会确定调用顺序，因为Filter的调用顺序是配置到web.xml文件中的，只要修改web.xml配置文件中的filter-mapping的顺序就可以调整Filter的执行顺序，显然Filter的执行顺序是在程序运行阶段动态组合的，那么这种设计模式被称为责任链设计模式。
-
责任链设计模式最大的核心思想：
- 在程序运行阶段，动态组合程序的调用顺序。
-
-
使用过滤器改造oa项目
Listener监听器
-
什么是监听器？
- 监听器是Servlet规范中的一员，就像Filter一样，Filter也是Servlet规范中的一员。
- 在Servlet中，所有的监听器接口都是以"Listener"结尾
-
监听器有什么用？
- 监听器实际上是Servlet规范留给我们javaweb程序员的特殊时机
- 特殊的时刻如果想执行这段代码，你需要使用对应的监听器
-
Servlet规范中提供了哪些监听器？
- javax.servlet包下：
- ServletContextListener
- ServletContextAttributeListener
- ServletRequestListener
- ServletRequestAttributeListener
- javax.servlet.http包下：
- HttpSessionListener
- HttpSessionAttributeListener
- 该监听器需要使用@WebListener注解进行标注
- 该监听器监听的是什么？是session域中数据的变化。只要数据变化，则执行响应的方法，主要监测点在session域对象上
- HttpSessionBindingListener
- 该监听器不需要使用@WebListener进行标注
- 假设User类实现了该监听器，那么User对象在被放入session的时候触发bind事件，User对象从session中删除的时候，触发unbind事件。
- 假设Customer类没有实现监听器，那么Customer对象放入session删除的时候，不会触发bind和unbind事件。
- HttpSessionIdListener
- session的id发生改变的时候，监听器中的唯一一个方法就会被调用。
- HttpSessionActivationListener
- 监听session对象的钝化和活化的
- 钝化：session对象从内存存储到硬盘文件
- 活化：从硬盘文件把session回复到内存
- javax.servlet包下：
-
实现一个监听器的步骤：以ServletContextListener为例。
-
第一步：编写一个类实现ServletContextListener接口。并且实现里面的方法
@Override public void contextInitialized(ServletContextEvent sce) { } @Override public void contextDestroyed(ServletContextEvent sce) { } -
第二步：在web.xml文件中对ServletContextListener进行配置，如下：
-
<listener> <listener-class>com.javaweb.listener.MyServletContextListener</listener-class> </listener> -
当然，第二步可以不是有配置文件，也可以使用注解，例如：@WebListener
-
-
-
注意：所有监听器中的方法都是不需要javaweb程序员调用的，由服务器来调用？什么时候被调用？
- 当某个特殊的时间发生（特殊的时间发生其实就是某个时机到了。）之后，被web服务器自动调用。
-
思考一个业务场景：
- 请编写一个功能，记录该网站实时的在线用户个数。
- 我们可以通过服务器端有没有分配session对象，因为一个session代表了一个用户。如果你采用这种逻辑去实现的话。session有多少个，在线用户就有多少个。这种方式的话：HttpSessionListener够用了。session对象只要创建，则count++，然后将count存储到ServletContext域当中，在页面展示在线人数即可。
- 业务发生改变了，只统计登录的用户的在线数量，这个该怎么办？
- session.setAttribute(“user”,userObj);
- 用户登录的标志是什么？session中曾经存储过User类型的对象，那么这个时候可以让User类型的对象实现HttpSessionBindingListener监听器要User类型对象存储到session域中，则count++,然后将count++存储到ServletContext对象中，页面展示在线人数即可。
-
实现oa项目中当前登录在线的人数
- 什么代表用户登录了？
- session.setAttribute(“user”,userObj);User类型对象只要往session中存储过，表示有新用户登录。
- 什么代表着用户退出了？
- session.removeAttribute(“user”);User类型的对象从session域中移除了。
- 或者可能是session销毁了。（session超时）
- 什么代表用户登录了？
MVC架构模式
在不使用MVC的情况下编写代码
- 在不使用MVC架构模式的前提下，完成银行账户转账
package servlet;
import exception.AppException;
import exception.MoneyNotEnoughException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.*;
@WebServlet("/transfer")
public class AccountTransferServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("UTF-8");
//获取响应流对象
resp.setContentType("text/html;charset=UTF-8");
PrintWriter out = resp.getWriter();
//获取转账相关信息
String fromActno = req.getParameter("fromActno");
String toActno = req.getParameter("toActno");
double money = Double.parseDouble(req.getParameter("money"));
//编写转账业务逻辑代码，连接数据库，进行转账操作
//1.转账之前要判断转账的余额是否充足
Connection conn=null;
PreparedStatement ps=null;
PreparedStatement ps2=null;
PreparedStatement ps3=null;
ResultSet rs=null;
try {
//注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//获取连接
String url="jdbc:mysql://localhost:3306/mvc?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8";
String user="root";
String password="y1873896";
conn= DriverManager.getConnection(url,user,password);
//开启视为（不再自动给提交了，改为搜东提交，业务完成之后在提交。）
conn.setAutoCommit(false);
//获取预编译的数据库操作对象
String sql1="select balance from t_act where actno = ?";
ps=conn.prepareStatement(sql1);
ps.setString(1,fromActno);
//执行SQL语句，返回结果集
rs = ps.executeQuery();
//处理结果集
if(rs.next()){
double balance = rs.getDouble("balance");
if(balance<money){
//余额不足（使用异常处理机制）
throw new MoneyNotEnoughException("对不起，余额不足");
}
//程序能够执行到这里，说明余额一定是充足的
//开始转账
//act001账户减去10000
//act002账户加上10000
String sql2="update t_act set balance = balance - ? where actno = ?";
ps2=conn.prepareStatement(sql2);
ps2.setDouble(1,money);
ps2.setString(2,fromActno);
int count=ps2.executeUpdate();
//模拟异常
// String s=null;
// s.toString();
String sql3="update t_act set balance = balance + ? where actno = ?";
ps3=conn.prepareStatement(sql3);
ps3.setDouble(1,money);
ps3.setString(2,toActno);
//累计
count+=ps3.executeUpdate();
if(count!=2){
throw new AppException("App异常，请联系管理员");
}
//手动提交事务
conn.commit();
//转账成功
out.print("转账成功");
}
} catch (Exception e) {
//保险起见，回滚事务
try {
if(conn!=null) {
conn.rollback();
}
} catch (SQLException ex) {
ex.printStackTrace();
}
//异常处理，发生异常之后，你准备怎么做
//e.printStackTrace();
out.print(e.getMessage());
}finally {
//释放资源
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
if (ps != null) {
try {
ps.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
if (ps2 != null) {
try {
ps2.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
if (ps3 != null) {
try {
ps3.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
if(conn != null) {
try {
conn.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
}
}
-
分析这个程序存在哪些问题？
- 缺点1>代码的复用性太差。（代码的复用性太差）
- 导致缺点1的原因？
- 因为没有进行“职能分工”，没有独立组件的概念，所以没有办法进行代码复用，代码和代码之间的耦合度太高，扩展性太差。
- 缺点2>耦合度高，导致了代码很难扩展
- 缺点3>操作数据库的代码和业务逻辑混杂在一起1，很容易出错，编写代码的时候很容易出错，无法专注业务逻辑的编写。
- 缺点1>代码的复用性太差。（代码的复用性太差）
-
分析以下AccountTransferServlet他都是负责了什么？
-
1>负责了数据接收
-
2>负责了核心的业务处理
-
3>负责了数据表中数据的CRUD操作（Create[增] Retrive[查] Update[改] Delete[删]）
-
4>负责了页面的数据展示
-
MVC的含义
-
系统为什么要分层？
希望专人敢专事，各司其职，只能分工要明确。这样可以让代码耦合度降低，扩展力增强，组件的可复用性增强。
-
软件的架构中，有一个非常著名的架构模式：MVC架构模式
M(Model:数据/事务) V(View:试图/展示) C(Controller:控制器)
C(是核心，是控制器，是司令官)
M(处理业务/处理数据的一个秘书)
V(负责页面展示的一个秘书)
MVC:一个司令官，调度两个秘书，去做这件事
- MVC与三层架构之间的关系
事务的控制
事务一定时在业务逻辑层进行控制的，一般是一个业务方法对应一个完整的业务。
thread_local
private static ThreadLocal<Connection> local = new ThreadLocal<>();
/**
* 这里没有使用数据库连接池
* @return 连接对象
* @throws SQLException
*/
public static Connection getConnection() throws SQLException{
Connection conn=local.get();
if (conn==null) {
conn= DriverManager.getConnection(url,user,password);
local.set(conn);
}
return conn;
}
/**
* 关闭资源
* @param conn 连接对象
* @param stmt 数据库操作对象
* @param rs 结果集对象
*/
public static void close(Connection conn, Statement stmt, ResultSet rs){
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn != null) {
try {
conn.close();
//思考以下：为什么conn关闭之后，这里要从大Map中移除呢？
//根本原因是：Tomcat服务器是支持线程池的，也就是说一个人用过了t1线程，t1线程还有可能被其他用户使用
local.remove();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
注意：层与层之间一般是采用接口来访问的（面向接口编程），为了降低耦合度，提高扩展力。
扫一扫
2217
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
