Tomcat_Servlet_Jsp基本详解
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■↓↓↓↓↓↓ＷＥＢ↓↓↓↓↓↓↓↓■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
WEB
是什么？
web就是指网页，网站。
为什么要有Web？
有了WEB可以使得电脑资源可以在互联网上共享
[
开发是什么？
WEB开发就是通过网站发布资源提供访问给外界访问的技术
【后台技术（PHP,C#,JAVA.....）】总称就是WEB开发。
项目结构分类；
C/S；
client客户端/server服务器
如；QQ，飞秋等。
特点；服务端更新，客户端也要更新，不便于维护
B/S；
Browser浏览器/server服务器
如；网页QQ，等
特点；便于维护，服务端更新，客户端不必更新，受限于网速
--- 什么是服务器？
服务器就是一台配置很好的电脑，可以同时进行N多个线程操作。
JavaWeb；
是什么？
JavaWeb开发就是使用Java技术开发网站所用到的技术的统称。
有什么用？
可以用于通过网站发布资源提供给外界访问。
JavaWeb和JavaEE的区别?
JavaWed；是通过Java技术开发网站
JavaEE；企业级版本，是用于开发企业应用所需的技术。
而Java是针对B/S结构进行开发的，也是基于浏览器，基于网页（网站）
1、JavaWEB和JavaEE没有区别，
JavaEE是指使用Java技术开发
WEB开发是一个概括所有开发B/S结构语言的。
Java语言的技术分类；
JavaSE；
Standard Edition标准版本，是一个基础
JavaEE；
Enterprise Edition企业版本，是用于企业级应用开发的。
JavaME；
Micro Edition 微型版本。
总结；
JavaEE是用于企业级开发的，是公司内部管理使用的或者是别的用途。
如；有多个分公司，每个分公司，每天都要提交报表到总公司，
而总公司是要如何接收？
这是一个异地的传输，如果是开发桌面应用不便于维护，
因为桌面应用的更新不能···及时···的让···所有···的分公司都进行一个更新
而开发B/S结构的，无论总公司的应用程序如何的改变都不会影响到分公司的操作。
那么总公司的服务器是要如何将服务器的资源发布给···来访问···的分公司？
通过服务器软件
怎么发布服务器资源？
因为每一台服务器通过网站向外界发布资源是要通过WEB软件的，
而通过WEB软件向外界发布资源的服务器叫做WEB服务器。
什么是WEB服务器？
1.可以安装WEB服务器软件
2.可以运行网站的电脑。
因为服务器就是一台配置较好的电脑。
常用的WEB服务器软件；
Tomcat ----- Apache
WebShpere ----- Microsoft
WebLogin ----- Oracle
--------------------------------------↓↓↓↓↓ＷＥＢ —— ＵＲＬ↓↓↓↓↓↓↓↓------------------------------------------------
Web-URL；
URL；
为什么要有？
因为IP地址的数量太多，以及不便于人们的记忆。
是什么？
是统一定位资源符。
作用；
可以通过某一个网站定义好的URL地址访问到网站发布的资源
特点；
每一个URL对应这一个IP
是全球唯一的
过程；
1.会先到本地系统自带的hosts文件中查找有没有定义这个URL的键值对
127.0.0.1 www.123456789.com
2.找不到了，在到DNS服务器中发布消息查找。
DNS；
域名解析服务器，是一个专门用于解析访问的域名所对应的IP
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■↓↓↓↓↓Ｔｏｍｃａｔ↓↓↓↓↓↓↓↓■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
Tomcat；
为什么要有？
因为每一台WEB服务器通过网站向外界发布资源是要通过WEB软件的，
是什么？
俗称为，猫。是由Apache开源组织和Sun公司以及其他公司共同开发的技术
作用；
是一个服务器向外界发布资源所使用的一个服务器软件。
特点；
1.性能稳定
2.每一个页面都可能是动态生成的。
3.默认是8080端口
4.实现了Servlet规范，按照这个规范将数据都封装成了对象
◆注；Tomcat是一定实现了Servlet接口规范的
◆◆◆注；要配置环境变量 ◆◆◆
新建的变量名必须是；JAVA_HOME
指定路径必须是JDK；D:\JDK and JRE\JDK
--------------------------------------↓↓↓↓↓Ｔｏｍｃａｔ目录下文件夹↓↓↓↓↓↓↓↓------------------------------------------------
Tomcat目录下文件夹作用；
1.bin -----> 存放Tomcat运行时文件 （二进制）
startup；启动Tomcat
shutdown；关闭Tomcat
2.conf -----> 存放Tomcat配置文件
web.xml 修改显示页面
server.xml 设置访问地址
3.lib -----> 存放架包
servlet 架包
4.logs -----> 日志信息
如；错误的的信息，便于管理，提升用户体验
5.temp -----> 临时文件
用于存放Tomcat产生的临时文件，可以删除
6.webapps -----> 存放项目资源
而Tomcat运行时，会到这个文件夹下找所需的资源
7.work -----> 工作目录
存放运行WEB相关的文件
--------------------------------------↓↓↓↓↓Ｔｏｍｃａｔ项目结构↓↓↓↓↓↓↓↓------------------------------------------------
Tomcat项目结构；
Tomcat
|--- webapps
|--- 项目资源 —————> 存放用户可见的资源，图片，*.css *.jsp *.html......
|--- WEB-INF —————> 存放用户不可见的资源，二进制文件，架包，配置文件......
|--- classes -----> 存放二进制运行文件
|--- lib -----> 存放架包，如servlet.jar
|--- web.xml -----> 配置信息，如显示的页面
◆◆◆ 注；因为在Tomcat运行的时候会默认到webapps文件夹下找项目资源.......
|---------> 如果没有指定项目资源路径则会到Root文件夹中找web.xml配置文件指定的项目名
|
|
|
|
|
|
--------|---------------------------↓↓↓↓↓Ｔｏｍｃａｔ项目发布方式↓↓↓↓↓↓↓↓------------------------------------------------
|
|
| Tomcat项目发布方式；
| 1.在webapps下建立一个自定义的文件夹，在文件夹中存放项目资源
| 访问；localhost:8080/自定义文件夹名/资源名
| localhost:8080/bb/1.html
|
|
<--------------- 2.在Root下直接访问
访问；localhost:8080/资源名
localhost:8080/1.html
3.虚拟路径访问1；
访问；localhost:8080/虚拟名/资源名
localhost:8080/gg/1.html
在conf的server.xml的host节点下添加一个子节点
缺点；每次配置都要重启服务器
4.虚拟路径访问2；
访问；localhost:8080/xml文件名/资源名
在conf文件夹下新建 catalina 夹/ localhost夹/ xxx.xml
在xxx.xml文件中写入
注意；写入的空格等·····
5.发布多网站；
访问；www.123456789.com:8080/1.html
1.在conf文件夹下的 server.xml 添加一个host节点，
name 是 自定义域名
appBase 是 资源路径
2.在系统自带的 hosts 文件中添加一个访问域名
127.0.0.1www.123456789.com
另；可以通过修改端口号，设置web.xml的起始页达到和平时访问的效果
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■↓↓↓↓↓ＨＴＴＰ —— 协议↓↓↓↓↓↓↓↓■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
什么是协议？
1.协议就是用于规定通信两端的传输方式以及格式......
2.每一个协议都对应一个端口，
3.端口是用于区分服务的，
······如果没有端口，那么计算机无法识别所要处理的信息是需要如何进行处理
······以及处理的应该是哪一个应用的服务信息，应该传输到哪个应用。
4.每一个应用都有自己处理信息的格式，以及是如何传输的格式。
5.常用的端口；
http --- 80
ftp --- 21
DNS --- 53
。。。。。。
Http协议；
为什么要有？
1.每一个浏览器的内核，以及数据封装的格式都是不一样的
2.如果进行通信会导致服务端无法识别数据等.......
是什么？
HyperText Transfer Protocol 超文本传输协议。
作用；
用于规定（规范）通信两端之间的传输格式。。。。。。
主要用于B/S结构的
版本；
http 1.0 ---> 每次传输的WEB对象都需要重新连接，如图片.....
===== 只要下载完一个就断了连接
http 1.1 ---> 会有一个数秒的短暂连接时间，不必为每一个的对象都进行一个重新连接
===== 下载完了一个还是有一个保持连接时间
如；页面有3张图片
如果3张图片相同则是同一个对象，需要传输2次
如果3张图片不同则不是同一个对象，需要传输4次
连接一次，获取图片次数
HTTP1.1就是一个连接可以传输多个对象。
-------------------------------------↓↓↓↓↓ＨＴＴＰ包的分类↓↓↓↓↓↓↓↓------------------------------------------------
HTTP包的分类；
请求包；客户端向服务器发送请求，如；登录，注册，下载图片......
响应包；服务器根据客户端的请求，发送相应的响应，如；传输图片给用户......
◆◆◆◆◆注；请求包和响应包都是 键-值对的格式
--------------------------------------↓↓↓↓↓ＨＴＴＰ请求包结构↓↓↓↓↓↓↓↓------------------------------------------------
http 请求：
POST /day08/test HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Content-Length: 0
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Origin: http://localhost:8080
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Referer: http://localhost:8080/day08/index.html
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8
Cookie: JSESSIONID=BBA577290FFCF46AF38BF8C83A581FA7
★★★★★请求包；
■■■ 包括； A.B.C
A、|——— 请求头；
|--- 位于；HTTP协议的一行
|--- 包括；1.协议版本 2.提交方式 3.请求提交地址
１--- 协议版本现在都是 http-1.1
２--- 提交方式有 Get 和 Post 两种方式
Get -- 是提交的信息现在在地址栏上，并且大小不能大于1KB
Post -- 提交的信息封装在包里提交给服务器的
▲注；···默认···都是Get提交，除非设置，否则···都是···。
３--- 提交地址，就是服务器所对应的项目资源的路径
/day08_myeclipse_servlet_02/Work
B、|——— 请求协议的内容；
|--- 是key－value对的
|--- 常见的key；
1.Host － 主机 和 端口号
2.Content-Length － 发送的内容字节长度
pragma no-cache
缓存相关的请求协议头, 表示不缓存
cache-control no-cache
缓存相关的头, 表示不缓存
expires 0
缓存相关的头, 表示缓存时间，
为0表示不缓存!
3.referer － 当前请求来源（本地URL） 【防盗链】
防盗链；就是为了限定用户不能从这里进入等.....
4.User-Agent － 当前请求的浏览器信息
C、|——— 请求的数据；
|--- Form data;
默认中间是使用 ＆ 分隔的，
而在浏览器中是 ？ 分开的之后的数据都是使用＆
--------------------------------------↓↓↓↓↓ＨＴＴＰ响应包结构↓↓↓↓↓↓↓↓------------------------------------------------
http-响应；
HTTP/1.1 302 Moved Temporarily
Server: Apache-Coyote/1.1
Location: http://localhost:8080/day08_myeclipse_servlet_02/Work.html
Content-Type: text/html;charset=UTF-8
Content-Length: 0
Date: Sun, 27 Dec 2015 05:37:32 GMT
★★★★★响应包；
A、|——— 响应状态行；
|--- 位于；第一行
|--- 包括； 1.协议版本 2.响应状态码
1.协议版本，现在基本都是 http-1.1
2.响应状态码；
1XX 响应正在处理
2XX 响应完成
3XX 响应尚未处理完成，需要进一步处理
4XX 客户端错误
5XX 服务端错误
常用的状态码；
200 响应正常完成
302 配合location一起使用，达到跳转的效果
304 客户端没有更新完成，读取浏览器缓存
404 客户端路径错误
505 服务器内部错误
B、|——— 常用的响应头
|--- 位于；第一行下面
1.Content-Type 服务器响应信息的编码 --- 设置编码
2.Location 响应给客户端地址 --- 配合 302 实现跳转（重定向）
3.Content-Length 服务器响应信息的长度
4.Refresh 刷新 --- 设置定时刷新，定时页面跳转
5.Content-Disposition 下载
6.Content-Encoding 压缩格式 --- 通常是GZIP
7.Date 服务器响应时间
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■↓↓↓↓↓ Ｓｅｒｖｌｅｔ↓↓↓↓↓↓↓↓■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
Servlet；
为什么要有？
1.服务器获取到信息要如何进行处理？
2.如何通过Java代码实现，给用户响应？
是什么？
Servlet是由SUN公司推出的一项运行在服务端的技术。
也是一套用于服务器上的框架/技术。
Servlet是一个普通Java类，而且必须与Servlet接口有关系。
作用；
1.实现用户与服务器的动态交互
2.可以用于生成动态页面【开发打开动态网站】
特点；
1.是一个Java-Servle框架的一个顶层接口，
这个框架下的所有类和接口都是继承与Servlet的，类似Object
2.不可以独立运行，···必须···在WEB服务器软件···中运行
3.可移植
4.是一个规范，◆···而Tomcat是·◆·一定·◆·实现了这个规范的
5.是JavaWeb开发和JavaEE开发必备的技术
开发模型；
Servlet是一个基于请求、响应的开发模型。
◆注；必须与Servlet接口有关系，必须交给服务器运行
也是一个适用于Tomcat的一个规范【接口】。
◆注；在Tomcat中有Servlet架包
Servlet域；
ServletContext --- 范围是全局的
ServletSession --- 只在一个会话范围
HttpServletRequest --- 范围只在一个请求中
PageContent --- 当前页面
---------------------------------------↓↓↓↓↓ 什么是 Ｓｅｒｖｌｅｔ规范？↓↓↓↓↓↓↓↓------------------------------------------------------
规范是什么？
规范就是用于规定某一个东西的表现形式等........
Servlet规范；
是什么？
是一套接口，而这套接口是规定了Tomcat服务器，响应和请求的规范。
---------------------------------------↓↓↓↓↓ 什么是 Ｓｅｒｖｌｅｔ域？↓↓↓↓↓↓↓↓------------------------------------------------------
Servlet域；
为什么要有？
有了域那么可以在指定的需求范围之内操作这个范围的数据，
而不会导致其他数据的修改。
是什么？
Servlet域是一个在Tomcat服务器的，
一个指定范围内操作指定的范围的数据，
而操作的数据会作用在这个整个这个指定域。
作用；
提高程序的可维护性，以及可操作性，
因为在修改时，只是需要修改指定的范围数据
特点；
1.操作的数据，只作用这个特定范围。
2.不会影响到其他的数据修改
---------------------------------↓↓↓↓↓Ｔｏｍｃａｔ和Ｓｅｒｖｌｅｔ关系↓↓↓↓↓↓↓↓------------------------------------------------
Tomcat和Servlet关系；
Servlet是一套规范，接口
Tomcat是一个Web服务器软件
Tomcat是实现了Servlet规范（接口），
而Tomcat按照Servlet的规范将数据封装成对象。
因为Tomcat按照Servlet的规范将数据封装成对象，
从而使得可以使用Java代码对Tomcat数据进行操作
|----------------> 总结； Tomcat将数据封装成对象，
| 从而可以通过Java代码操作这些对象，
| 因为Tomcat实现了Servlet规范(接口)，
| 而在Servlet规范(接口)中定义了，
| 如何通过Java代码对数据进行操作的。
|
|
|
|
--------|-------------------------↓↓↓↓↓Ｓｅｒｖｌｅｔ相关的部分接口和类↓↓↓↓↓↓↓↓--------------------------------------------------
|
|
|
|
| Servlet相关的接口；
| |---Servlet = Interface
| 顶层接口；
| ······定义了生命周期。。。。。。
|
| |--- GenericServlet = abstractClass
| 通用的Servlet是实现类，对接口封装
| ·······实现了Servlet、ServletConfig接口
|
| |---HttpServlet = abstractClass
| ·······通常开发时用这个，没有定义抽象方法
| 但是定义成一个抽象类的存在
|
|
| ◆注；Servlet的大部分接口都是单例
|
|
|
|
|
--------|-------------------------↓↓↓↓↓Ｓｅｒｖｌｅｔ在Myeclipse中的创建方式↓↓↓↓↓↓↓↓--------------------------------------------------
|
|
|
| Myeclipse创建方式；
| 1.直接创建*.java文件
|
| a.实现HttpServlet/Servlet/GenericServlet接口
| b.配置web.xml文件的配置信息
|
| web.xml配置信息；
| 1.
| |--------->
| |
| |
| |
| |
| | 2.
| <---------
|
|
|
|
| 2.直接创建一个Servlet文件，会自动实现接口，和配置web.xml文件配置信息
|
|
|
|
|
|
|
--------|-------------------------↓↓↓↓↓Ｓｅｒｖｌｅｔ开发的三种方式 ↓↓↓↓↓↓↓↓--------------------------------------------------
|
|
|
| Servlet开发；
<--------------- 因为Servlet接口定义了如何通过Java代码对数据进行操作，
而这些就是Servlet中的接口、类、方法、等。。。。。。。
第一种方式；
直接实现顶层接口 Servlet
▲.重写这个接口下的所有方法
▲.不便于使用
第二种方式；
实现GenericServlet抽象类，
▲.重写service方法
第三种方式；
实现HttpServlet类，
▲.通过重写doPost和重写doGet方法
-------------------------------------↓↓↓↓↓Ｓｅｒｖｌｅｔ获取数据过程↓↓↓↓↓↓↓↓------------------------------------------------
Servlet获取数据过程；
1.Tomcat获取到数据会先封装成对象
2.Servlet会执行service()方法
3.通过 service() 方法获取到数据 ------ 开发方式一
|--- 而在GenericServlet实现类中未重写这个方法 ------ 开发方式二
|--- 而在HttpSetvlet中重写了service()方法 ------ 开发方式三
另；通过HttpServletRequest的getMethod()方法可以获取到提交的方式
在HttpServlet类中重写的service()方法中，
就已经进行了判断提交方式是什么，
从而调用相应的提交方式所对应的方法
通过提交方式对应的方法进行操作Tomcat的数据。
|------------------>◆注；开发都是使用HttpServlet类，
| 因为在调用service()方法内部
| 已经获取到了数据的提交方法，
| 并且定义了根据提交方法，
| 调用对应的方法进行操作。
| doGet()、doPost()方法
|
|
|
|
|
|
--------|--------------------------↓↓↓↓↓Ｓｅｒｖｌｅｔ生命周期↓↓↓↓↓↓↓↓------------------------------------------------
|
|
| Servlet生命周期；
| 为什么要有？
| 1.如果没有生命周期，那么Tomcat获取数据时，将数据封装成对象
| 通过Servlet进行操作，那么这些数据存放在哪里，
| 而这个对象是在哪里，是什么？
|
| 2.通过Servlet操作Tomcat数据，那么这个过程是要如何执行，如何定义？
|
| 3.关闭服务器时，这些数据是要如何进行处理？
|
|
| 是什么？
| 描述Tomcat将数据封装成对象，通过Servlet进行操作的开始，操作，结束过程。
|
|
| 作用；
| 1.定义数据的开始，初始化
| 2.定义数据的操作、执行过程
| 3.定义服务器关闭时，数据是如何处理
|
|
|
| ◆◆◆注；Servlet生命周期是在超接口Servlet接口下定义的。
|
|
|
|
|
|
--------|------------------------↓↓↓↓↓Ｓｅｒｖｌｅｔ生命周期-过程和方法↓↓↓↓↓↓↓↓-----------------------------------------------
|
|
|
| Servlet生命周期过程的方法；
| 1.会创建一个实例，因为Tomcat将数据封装成对象
| |--- 创建了实例一定时实现了构造方法
| |--- 实现了构造方法不一定创建了实例 --- 抽象类
|
|
| 2.调用init()方法，ˉˉˉˉˉˉ 用于初始化对象（数据）
| |--- 初始化就是，需要一开始就加载到内存中，随时可以调用的。
|
<--------------------------3.调用service() 方法，ˉˉˉˉˉˉ 对数据进行处理
|--- 在HttpServlet中定义了doGet()和doPost根据提交方式调用
4.正常关闭服务器会调用destroy()方法，ˉˉˉˉˉˉ 销毁数据
|--- 如果是非正常关闭，如断电，则不会执行destroy()方法
Ａ、init()
public void init(ServletConfig config) throws ServletException {
super.init(config);
}
public void init() throws ServletException {
}
说明；
避免了忘记，显示的调用父类的init方法，
因为在父类的init源码中可以看见this.init()
调用当前运行时类的init()方法。
Ｂ、service()
public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException {
}
说明；
如果重写HttpServlet只是需要调用doGet()或doPost()方法
因为在类的service()方法内部就进行了判断客户端提交方式
再根据判断的结果调用对应的提交方式的方法进行处理
Ｃ、destroy()
public void destroy() {
}
说明；
如果是非正常关闭则直接清空内存的缓存信息。
◆◆◆◆◆注；Servlet接口是单例的。
Servlet生命周期的过程；
1.启动服务器
|--- 加载conf中的web.xml和wabapps中的所有web.xml和*.tld文件
2.用户发送信息，则会创建一个实例
3.服务器根据用户请求的资源，到web.xml中匹配对应的路径
|--- 根据web.xml文件的内部名称，找到Servlet对应类全路径
4.匹配成功，找到Servlet对应的类全路径之后，通过反射创建对象
5.调用init()、service()
6.正常关闭服务器，调用destroy()
——————————■■■■■■■■■■■■===↓↓↓↓↓Ｓｅｒｖｌｅｔ_init() —— ＳｅｒｖｅｒＣｏｎｆｉｇ↓↓↓↓↓↓↓↓===■■■■■■■■■■■■————————————————
ServletConfig接口；
为什么要有？
如果服务器在启动的时候，
在配置文件中定义了某些信息
那么如何保证在操作数据的时候
★ 如何来保证这些信息的一致性？
以及如何便于他人的需求修改测试.....？
是什么？
ServletConfig，Servlet中的配置文件信息。
作用；
1.用于同步配置文件的信息，
2. 以及便于需求更改，
3. 而不必更改源代码，
4. 因为只是需要更改配置文件信息，
5. 提高程序的可维护性，可操作性......。
因为在Tomcat启动的时候就加载了web.xml配置文件信息
特点；
1.ServletConfig只有Get没有Set，
◆ 因为是为了在操作数据时，
与配置文件的信息是同步的。
2.在配置信息中是键值对的存在
3....单例
4.在配置文件中，是位于某一个Servlet下的，
因为配置信息是作用于某一个Servlet的。
5.是当前项目下的配置信息
6.是一个独立的接口，没有继承别的接口
7.是一个局部变量的存在
★★★★★ 在init() 初始化方法中的形参就是ServletConfig，
因为ServletConfig就是获取初始化配置文件的信息的
-------------------------------↓↓↓↓↓↓↓ＳｅｒｖｅｒＣｏｎｆｉｇ —— 运行流程↓↓↓↓↓↓↓------------------------------------------------
SevletConfig运行流程；
1.开启服务器
2.加载conf文件夹下的所有配置文件，
以及所有···项目··的web.xml配置文件和*.tld文件。
3.浏览器访问服务器
4.服务器创建一个实例
5.服务器调用init() 方法，
就可以获取到web.xml的配置文件中的定义的配置信息
6.调用service()方法
7.关闭浏览器
8.关闭服务器，调用destroy()方法
----------------------------===↓↓↓↓↓ＳｅｒｖｅｒＣｏｎｆｉｇ —— Ｗｅｂ文件配置格式===---------------------------------
ServletConfig——Web.xml文件配置格式；
因为是作用于某一个Servlet的
......某一个Servlet路径配置信息
◆注；服务器一开始加载web.xml文件的时，
会将init-param的数据封装成一个对象，
所以一开始就可以进行调用这个文件的数据。
-------------------------------↓↓↓↓↓↓↓ＳｅｒｖｅｒＣｏｎｆｉｇ获取配置文件信息↓↓↓↓↓↓↓------------------------------------------------
ServletConfig配置文件信息；
通过ServletConfig接口的方法，
可以获取到配置文件的信息，
而获取到配置文件的信息，
之后可以按照配置文件中
的信息进行数据的操作。
方法；
1.String --- this.getInitParameter("name");
根据配置文件初始化配置信息的键获取相应的值
2. Enumration --- this.getInitParameterNames()
获取配置文件的所有初始化信息的键
2.Map
获取客户端所有提交信息
因为是name和value的
4.String[] --- request.getParameValues("name");
获取客户端所有提交信息的值
◆◆◆◆◆注；获取的都是····当前····访问的····项目····
····的web.xml文件····中的···配置信息
◆注；服务器一开始加载web.xml文件的时，
会将init-param的数据封装成一个对象，
所以一开始就可以进行调用这个文件的数据。
————————————■■■■■■■■■■■■===↓↓↓↓↓Ｓｅｒｖｌｅｔ —— ＳｅｒｖｅｒＣｏｎｔｅｘｔ↓↓↓↓↓↓↓↓===■■■■■■■■■■■■————————————————
ServletContext；
为什么要有？
如；在Tomcat启动的时候某些设置固定的，
而且是作用于Tomcat服务器所有的项目资源，
★ 那么完全没有必须要为每一个项目资源都要设置。
当是作用于整个Tomcat服务器上的时候可以使用ServletContext
是什么？
ServletContext是Servlet_API下的一个接口，是一个上下文（环境）接口。
表示Servlet运行环境。
作用；
1.用于配置全局变量的，以及被所有的对象共享，
2.可以管理所有的Servlet对象
3.设置的数据是适合较少修改的数据
4.存储数据
特点；
1.是一个单例的
2.是作用在整个Tomcat服务器项目资源的
3.服务器一启动，就会创建ServletContext在内存中
4.被所有对象共享
5.可以管理所有对象
6.是一个域对象
7.是以键值对的形式存储
域范围；
ServletContext这个域是一个范围最大的一个域对象。
这个域的作用是作用在Tomcat所有的项目
---------------------------↓↓↓↓↓↓↓ＳｅｒｖｅｒＣｏｎｔｅｘｔ —— 运行流程↓↓↓↓↓↓↓------------------------------------------------
ServlerContext运行流程；
1.启动服务器
2.创建SetvletContext对象，一直存在在内存中
----------------------------===↓↓↓↓↓ＳｅｒｖｅｒＣｏｎｔｅｘｔ —— Ｗｅｂ文件配置格式===---------------------------------
ServletContext文件配置格式；
是在web.xml文件中配置的
★★★★★★注；ServletContext和SevletConfig在Web.xml文件配置的区别
区别；
ServletContext；在
ServletConfig；在
--------------------------------↓↓↓↓↓↓↓ＳｅｒｖｌｅｒＣｏｎｔｅｘｔ获取对象的方式-----------------------------------------------
ServerContext获取对象的方式；
1.this.getServletConfig().getServletContext()
说明；
通过SerlvetConfig对象获取，因为在ServletConfig接口
提供了获取SerlverContext对象的方法。
。。。。。。。。
2.this.getServletContext()
说明；
因为在Tomcat服务器一开启的时候就
创建了SerlvetContext的一个实例，
而当前的类继承了HttpSerlvet
那么通过父类可以获取到
因为Servlet是一个顶层接口
而HttpServlet继承了Serlvet接口
------------------------------------↓↓↓↓↓↓↓ＳｅｒｖｅｒＣｏｎｔｅｘｔ方法-----------------------------------------------
ServerContext方法；
1.setAttribute("name","value");
--- 设置当前域的属性，注意是键-值对，不可以有多个值
2.getAttribute("name");
--- 获取到当前域 某一个属性的值
3.getAttributeNames();
--- 获取到当前域所有的属性名
^^^^^^^^^^^^^^^^^^^↓↓↓↓↓↓↓ＳｅｒｖｅｒＣｏｎｔｅｘｔ ㄩ●Щ 区别 Щ●ㄩ ＳｅｒｖｅｒＣｏｎｆｉｇ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
创建时间；
ServletContext --- 服务器启动就创建
ServletConfig --- 客户端浏览器请求服务器执行到 init 方法才创建
配置文件；
SerlvetContext ---
SerlvetConfig ---
作用；
ServletContext 范围是···作用···在整个Tomcat服务器的项目资源的
ServletConfig 范围是可以···获取···到web.xml配置文件所有的属性
用途；
SerlvetConfig --- 获取配置信息的，便于维护，和修改……
ServletContext --- 设置全局的信息，则少修改的。如；时间，省份列表，城市列表……
◆◆◆重◆◆◆注；ServletContext是作用在Tomcat所有的项目资源，
◆ 但是对象的范围决定了数据的范围，因为只有访问了的对象才会作用。
因为如果对象是没有访问过的，那么这个是不会作用在这个对象的。
个人理解；这是一个节省资源的办法。
——■■■■■■■■■■■■===↓↓↓↓↓Ｓｅｒｖｌｅｔ_service() —— ＨｔｔｐＳｅｒｖｌｅｔＲｅｑｕｅｓｔ↓↓↓↓↓↓↓↓===■■■■■■■■■■■■————————————————
HttpServletRequest；
为什么要有？
当Tomcat实现了Servlet规范将数据封装成对象，
那么Servlet规范(接口)中又是如何获取到数据的？
是什么？
HttpServletRequest是一个Servlet_API下的一个接口。
作用；
1.Tomcat按照Servlet规范将请求信息的数据封装成对象
2.通过HttpServletRequest接口的方法可以获取到请求信息的数据
特点；
1.是一个接口，继承了ServletRequest（独立接口）
2......单例
3.也是一个域对象，
范围是在发送请求信息的一个范围，
只有跳转了才可以获取到域信息。
◆◆◆◆◆注；封装的是 ▲ 请求包 ▲
-----------------------↓↓↓↓↓↓↓ＨｔｔｐＳｅｒｖｌｅｔＲｅｑｕｅｓｔ封装数据的流程↓↓↓↓↓↓↓------------------------------------------------
HttpServletRequest封装数据的流程；
1.启动服务器
2.加载conf文件夹的所有配置文件，
所有项目的web.xml配置文件和*tld文件
3.浏览器访问服务器，发送一个请求信息，请求当前路径的资源
4.服务器获取浏览器发送的请求信息数据，
5.将请求信息的按照Servlet的规范封装成一个对象
◆而这个对象就是HttpServletRequest
7.关闭浏览器
8.关闭服务器
◆◆◆◆◆注；封装的是 ▲ 请求包 ▲
请求包是一个键值对的格式
----------------↓↓↓↓↓↓↓ＨｔｔｐＳｅｒｖｌｅｔＲｅｑｕｅｓｔ常用的获取请求包数据方法↓↓↓↓↓↓↓------------------------------------------------
http 请求：
POST /day08/test HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Content-Length: 0
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Origin: http://localhost:8080
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Referer: http://localhost:8080/day08/index.html
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8
Cookie: JSESSIONID=BBA577290FFCF46AF38BF8C83A581FA7
HttpServletRequest常用的方法；
1.String getHeader("name")
--- 获取到请求包，包头的某一个指定name的值
2.Enumeration getHeaderNames()
--- 获取到请求包，包头的所有name
3.Enumeration getHeaders("name")
--- 获取到请求包，包头的某一个指定name的所有值
4.String getMethod()
--- 获取到请求包的提交方式
5.String getContextPath() 获取到提交路径的项目路径
7.String getRequestURL() 获取到用户访问的URL地址
8.setCharacter("字符集") 设置获取到的请求信息的编码集
9.getRequestURI() 获取访问的项目资源路径，URL
◆◆◆◆◆注；可以查看上面的包结构，查看请求包各个属性的作用
request.getRemoteXX() 获取客户端请求的基本信息(IP.....)
—■■■■■■■■■■■■===↓↓↓↓↓Ｓｅｒｖｌｅｔ_service() —— ＨｔｔｐＳｅｒｖｌｅｔＲｅｓｐｏｎｓｅ↓↓↓↓↓↓↓↓===■■■■■■■■■■■■————————————————
HttpServletResponse；
为什么要有?
Tomcat服务器获取到了请求的数据，
那么Tomcat服务器怎么根据这个请求数据的信息，做出回应？
是什么？
HttpServletResponse是Servlet_API的一个接口，
继承ServletResponse(独立接口)
作用；
用于根据客户端浏览器的请求信息做出一个响应
特点；
是一个接口继承ServletResonse(独立接口)
一般位于doPost,doGet,形参中
◆◆◆◆◆注；响应包是一个键值对的格式
-----------------------↓↓↓↓↓↓↓ＨｔｔｐＳｅｒｖｌｅｔＲｅｓｐｏｎｓｅ响应信息的流程↓↓↓↓↓↓↓------------------------------------------------
HttpServletResponse响应信息的流程；
1.启动服务器
2.加载conf文件夹的所有配置文件，以及所有项目的web.xml配置文件
3.客户端浏览器访问服务器
4.服务器获取到客户端的请求信息
5.服务器根据客户端的请求信息，做出相应的响应
6.将响应信息发送给客户端浏览器
7.客户端浏览器关闭
8.服务器关闭
-------------------↓↓↓↓↓↓↓ＨｔｔｐＳｅｒｖｌｅｔＲｅｓｐｏｎｓｅ常用的设置响应信息↓↓↓↓↓↓↓------------------------------------------------
http-响应；
HTTP/1.1 302 Moved Temporarily
Server: Apache-Coyote/1.1
Location: http://localhost:8080/day08_myeclipse_servlet_02/Work.html
Content-Type: text/html;charset=UTF-8
Content-Length: 0
Date: Sun, 27 Dec 2015 05:37:32 GMT
HttpServletResponse响应信息；
是根据请求包的内容进行一个响应的。
设置常用响应信息；
１.setHeader("name","value");
--- 设置响应包的属性，和对应的值
２.setContentType("text/html; charset=编码集")
--- 设置响应信息的编码集
３.sendRedirect("path")
--- 设置重定向跳转，标签设置
４.setIntHeader("Refresh",S)
--- 设置页面刷新时间
５. setHeader("Content-Disposition","attachment;fileName="
+ URL.encoder("pathName") + "字符集");
--- 设置文件给用户下载，
URL的方法可以设置中文文件名
乱码问题
ａ.提供位于服务器的下载路径，避免中文的文件名
response.setHeader("/path/Fname","attachment;fileName=" + URL.encoder("Fname","UTF-8"));
ｂ.获取到输出流
OutpuStream os = response.getOutputStream();
ｃ.获取到当前项目Servlet文件的输入流，
传入要下载的文件位于当前项目路径
InputStream is = this.getServletContext().getResourceAsStream("/Fname");
ｄ.读取文件流，并且写出
.......
ｅ.关闭流
.....
６.setHeader("Content-Encoding","GZIP");
--- 设置压缩文件，而浏览器普遍支持GZIP解码
ａ.设置压缩格式
response.setHeader("Content-encoding","GZIP");
ｂ.获取到要压缩的数据
.........
ｃ.创建压缩数据存放容器
ByteArrayOutpuStream bos = new ByteArrayOutputStream();
ｄ.获取到压缩数据工具类，将容器传入
GZIPOutputStream gos = new GZIPOutputStream(bos);
ｅ.调用压缩工具类的方法压缩数据
gos.wirte(数据);
ｆ.获取到压缩数据容器的所有字节码
byte [] b = bos.toByteArray();
ｇ.写出.....如果是文件则和下载的方式一样
ｈ.关闭流
◆◆◆◆◆注；查看···上面···包结构获悉每一个属性是什么用的？
——————————————■■■■■■■■■■■■===↓↓↓↓↓Ｓｅｒｖｌｅｔ转发和重定向的作用以及区别↓↓↓↓↓↓↓↓===■■■■■■■■■■■■——————————————————
Servlet转发和重定向作用；
都是用于跳转
区别；
重定向；
1.地址栏会发生变化
2.可以转发到别的资源下
3.是浏览器引擎负责转发的，因为是封装在响应包的
a.通过resposne 转发
4.重定向后是不可以访问request对象的，因为请求2次
◆ 5.重定向必须要写项目名
转发；
1.地址栏不会发生变化
2.只能转发到当前的资源下
3.是Tomcat服务器负责转发的，是一个内部跳转
a.通过request转发
b.通过ServletContext转发
4.转发后都是同一个request和response对象
◆ 5.转发是不需要写项目名
------------------------------↓↓↓↓↓↓↓Ｓｅｒｖｌｅｔ转发和重定向代码实现↓↓↓↓↓↓↓------------------------------------------------
Servlet转发代码；
1.通过request对象获取
RequestDispatcher rd = request.getRequestDispatcher("path");
1.A.调用forward方法转发
rd.forward(request,response);
2.通过ServletContext获取
RequestDispatcher rd = this.getServletContext().getRequestDispatcher("path");
2.A.调用forward方法转发
rd.forward(request,response);
Servlet重定向代码；
1.resposne.sendRedirect("path");
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■↓↓↓↓↓↓Ｓｅｒｖｌｅｔ会话技术↓↓↓↓↓↓↓↓■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
会话；
为什么要有？
如果没有会话，那么怎么知道每一次在进行请求的都是这个客户端浏览器？
如果没有会话，怎么保存这个客户端浏览器访问服务器的数据，以及确保是这个用户？
是什么?
会话就是一个进程，而这个进程会一直维护着，直到有一方断开。
作用；
1.识别客户端浏览器
2.保存当前访问客户端浏览器数据
特点；
一个会话中包含有多次请求和响应（只进来就退出，极端的情况不算）
技术分类；
Cookie --- 客户端
HttpSession --- 服务器
————————————■■■■■■■■■■■■■■■===↓↓↓↓↓Ｓｅｒｖｌｅｔ会话技术 —— Ｃｏｏｋｉｅ↓↓↓↓↓↓↓↓===■■■■■■■■■■■■■■■■■■——————————————————
Cookie；
为什么要有？
在Servlet中定义了会话的概念，
那么这概念要实现只用通过会话技术
客户端也是要保存数据的，那么要怎么保存？
是什么？
Cookie是Servlet_API定义的一个会话技术。
Cookie是Servlet_API的一个类，继承Cloneable接口(独立接口)
Cookie是一个位于在客户端浏览器的
作用；
将数据保存的保存到客户端浏览器
特点；
1.基于客户端浏览器的一个数据保存
2.Cookie类的所有方法都不是实现接口的方法，因为实现是一个空接口
3.如果访问时别的项目那么这个Cookie会失效
4.Cookie信息是以键值对的形式存在的
------------------------------------↓↓↓↓↓↓↓Ｃｏｏｋｉｅ运行过程↓↓↓↓↓↓↓------------------------------------------------
Cookie运行流程；
1.客户端访问服务器
2.服务器执行了reponse.addCookie(cookie)方法
3.服务器会将这个cookie对象的信息添加到响应头set-Cookie发送给客户端浏览器
4.客户端浏览器接收到这个响应包浏览器引擎会解析这个响应包信息，提取出cookie信息
5.当客户端浏览器再次访问服务器的时候会在请求包中添加这个cookie信息到Http协议体中
●.如果服务器没有设置Cookie的有效缓存时间，那么默认是客户端浏览器关闭了就失效。
客户端浏览器存储；
客户端浏览器是将Cookie缓存在进程中 --------- 最大有效时间为0
客户端浏览器是将Cookie存储到缓存的文件中的 -------- 最大有效时间不为0或负数
------------------------------------↓↓↓↓↓↓↓Ｃｏｏｋｉｅ使用流程以及方法↓↓↓↓↓↓↓------------------------------------------------
Cookie使用流程；
1.创建Cookie对象，设置Cookie信息
Cookie cookie = new Cookie("name","value");
◎设置有效时间
cookie.setMaxAge(S); --- 秒
◎修改值
cookie.setValue("newValue");
◎设置项目路径
cookie.setPath();
◆◆◆注；一个Cookie可以设置多个项目路径，默认是当前项目
2.调用response响应对象，将设置了信息的Cookie对象发送给客户端浏览器
response.addCookie();
◎获取到所有的Cookie
Cookie[] c = request.getCookies();
●通过Cookie的方法获取到name和value
● c.getValue()
● c.getName()
◎获取到访问的当前项目路径
request.getContextPath()
◆注；Cookie一般只有一个，因为客户端浏览器访问的时候只会携带一个Cookie
Cookie如果要设置永久这个就要根据浏览器引擎了，因为每一个浏览器都不一样
有一些是设置负数就是永久。
Cookie限制在4KB
----------------------------------------↓↓↓↓↓↓↓Ｃｏｏｋｉｅ使用细节↓↓↓↓↓↓↓------------------------------------------------
Cookie使用细节；
1.Cookie是键值对
◆ 2.Cookie只能是String类型的
3.Cookie设置最大化时间在设置为0
或者是负数时查看一下浏览器支持，
因为有一些是设置0则为永久，有一些浏览器是负数则为永久
4.一般一个网站只能发送20个Cookie
◆ 5.Cookie限制在4KB
6.一般浏览器只能存放300个Cookie
———————■■■■■■■■■■■■■■■===↓↓↓↓↓Ｓｅｒｖｌｅｔ会话技术 —— ＨｔｔｐＳｅｓｓｉｏｎ↓↓↓↓↓↓↓↓===■■■■■■■■■■■■■■■■■■——————————————————
HttpSerlvet；
为什么要有？
服务器怎么保存用户数据？
服务器怎么辨别是某一个用户登录？
是什么？
HttpSession是Servlet_API的一个独立接口，是一个服务器端会话技术
也是一个域对象
作用；
用于用户保存数据到服务器中
客户端与服务器的交互。
将会话封装成一个HttpSession对象
维护客户端和服务器之间的进程
特点；
1.必须手动创建
2.Id是唯一的
3.还是基于Cookie实现
4.是一个域对象
5.只有2个set方法 ( setMaxInactiveInterval(S) , setAttribute("string",object))
------------------------------↓↓↓↓↓↓↓ＨｔｔｐＳｅｓｓｉｏｎ运行过程↓↓↓↓↓↓↓------------------------------------------------
HttpSession运行过程；
1.客户端访问服务器
2.服务器执行request.getSession();方法则创建一个Session对象
●生成一个Id序列号，作为一个值添加到Cookie中发送出去
●将这个序列号保存到服务器内存中
3.客户端浏览器没有关闭继续访问这个项目资源
●获取到请求数据的Id
●获取到在内存保存的Id
●判断是否一样
------如果是一样则···不···创建一个新的对象
------如果是不一样则···创建···一个新的对象
5.客户端浏览器关闭，在打开访问则会创建一个新的对象
●客户端浏览器没有携带任何的Cookie信息
6.默认的存活时间是30分钟，
30分钟后这个Session对象对应的用户Id没有进行
任何的访问服务器的操作则会调用invalidate()方法销毁这个对象
◆注；一个HttpSession是由N个request组成的
只要执行到request.getSession()方法则会自动创建一个Session对象，
前提是第一次访问，或者是关闭了浏览器再次进行一个访问的情况下。
------------------------------↓↓↓↓↓↓↓ＨｔｔｐＳｅｓｓｉｏｎ创建对象方式↓↓↓↓↓↓↓------------------------------------------------
HttpSession创建对象方式；
方式一；
HttpSession s = request.getSession();
说明；
可以获取到Session信息和创建对象
方式二；
HttpSession s = request.getSession(true);
说明；
和方式一的作用一样
方式三；
HttpSession s = request.getSession(false);
说明；
不会创建新的对象，只能获取
------------------------------↓↓↓↓↓↓↓ＨｔｔｐＳｅｓｓｉｏｎ使用流程以及方法↓↓↓↓↓↓↓------------------------------------------------
HttpSerlvet使用流程及方法；
1.创建HttpSession对象
HttpSession hs = request.getSession();
◆◆◆注；如果构造器形参是false的那么则不会创建Session对象只可以获取到Session的属性
2.设置属性
hs.setAttribute("string","object");
3.设置最大存活时间
默认的存活时间是30分钟，
30分钟后这个Session对象对应的用户Id没有进行
<---任何的访问服务器的操作则会调用Invalidate()方法
|------>销毁这个对象。
hs.setMaxInactiveInterval(M); --- 分钟
可以通过设置配置文件设置最大存活时间也可以
4.获取到所有的属性
Enumeratrion em = hs.getAttributeName();
5.获取到某一个属性
String s = hs.getAttribute("name");
6.获取到最大存活时间
String s = hs.getMaxInactiveInterval();
7.销毁对象
hs.invalidate()
------------------------------↓↓↓↓↓↓↓ＨｔｔｐＳｅｓｓｉｏｎ在web.xml文件的配置↓↓↓↓↓↓↓------------------------------------------------
HttpSession在web.xml文件的配置；
◆注；在web.xml的文件配置中是一个全局的变量
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■↓↓↓↓↓↓ＪＳＰ↓↓↓↓↓↓↓↓■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
JSP；
为什么要有？
1.使用Servlet操作响应信息并且要将响应后的结果显示到客户端浏览器页面，
不便于编写JS,CSS等其余脚本代码，并且在写的时候容易出错，
更改困难，不便于排错等。。。。。。。。。。。。。。。
是什么？
JSP就是Servlet，本质就是java代码。
只是与Servlet表现形式不一样，
是与HTML，CSS,JS等一起写在同一个文件中。
作用；
JSP主要是为了便于显示业务逻辑处理后的结果，
因为是与HTML，CSS，JS等。。。一起写在同一个文件中
那么便于排错，更改等。。。。
特点；
JSP文件后缀是 *.jsp
JSP可以嵌套HTML代码
JSP可以写Java代码，因为本质就是一个*.java文件
JSP内置了四大域对象，九大常用对象
JSP继承HttpJspBase类的
-------------------------------↓↓↓↓↓↓↓ＪＳＰ与Ｓｅｒｖｌｅｔ的关系和区别↓↓↓↓↓↓↓------------------------------------------------
JSP与Servlet的关系；
JSP就是Servlet，只是表现的形式不一样而已
JSP和Servlet是一个互补的关系。
JSP不利于操作业务逻辑信息
Servlet不利于显示逻辑业务处理结果
JSP与Servlet的区别；
Serlvet；
用于获取请求信息
处理业务处理逻辑
将数据保存到域中
JSP；
将Servlet处理好的业务逻辑结果···显示···在客户端浏览器中
-------------------------------------------↓↓↓↓↓↓↓ＪＳＰ运行原理↓↓↓↓↓↓↓----------------------------------------------------
JSP运行原理；
1.客户端浏览器访问Tomcat服务器资源
2.Tomcat服务器获取到客户端访问信息，
使用Servlet处理好业务逻辑，跳转到JSP文件
3. JSP将从域中获取到处理后的业务逻辑则会显示到页面中
●Tomcat服务器获知这个跳转的地方是一个*.jsp文件
●Tomcat服务器会将这个*.jsp解析成一个*.java文件
●Tomcat服务器将解析好的*.java文件进行一个编译
●Tomcat服务器在将这个编译好的*.class文件响应给客户端浏览器
●并且将这个响应的信息显示在客户端浏览器页面
◆Tomcat内部运行过程； 原(*.jsp)-----> 解析(*.java)----->编译(*.class)----->运行(客户端浏览器页面)
------------------------------------------↓↓↓↓↓↓↓ＪＳＰ解析后*.java文件↓↓↓↓↓↓↓----------------------------------------------------
JSP解析后的*.java文件；
在JSP中是内置了四大域对象和九大常用对象，所以在JSP文件中可以调用
在JSP文件解析成*.java文件之后，
只要不是使用JSP语法编写的代码都会转换成Servlet的书写
而是使用JSP语法编写的代码不会有任何改变的。。。。。
在JSP文件中处理指令时不会在文件中的，而会转换成Servlet的编写，
如；编码的设置，导包等一系列处理指令。。。。。。。。。。
四大域对象；
application ----- 全局
session ----- 会话
request ----- 只在当前请求有效，要获取要进行转发
page ----- 只是在当前页面有效，
◆ 主要；获取其他的对象
九大对象；
application ----- ServletContext
session ----- HttpServlet
request ----- HttpServletRequest
pageContext ----- 在Servlet包中是没有的，这个域对象是JSP文档特有的
page ----- this
out ----- request,getWriter
exception ----- Exception
config ----- ServletConfig
response ---- response
◆◆◆◆◆◆注；在JSP中因为是内置对象，所以在用户访问JSP页面的时候就会自动创建了Session对象
-----------------------------------------------↓↓↓↓↓↓↓ＪＳＰ语法↓↓↓↓↓↓↓----------------------------------------------------
JSP语法；
1.脚本代码；
<% …… java代码 %>
说明；
1.用于写java代码
2.代码注释只能是java的单行和多行注释其余不行
3.可以写多行代码
4.变量是一个局部变量
5.不可以写方法因为在解析本.java文件中就是一个service方法
6.可以有输出语句
2.表达式；
<%= …… %>
说明；
1.是输出的表达式
2.是不可以定义变量的，只能引用在<% …… %>定义好的
3.只能写一行代码
4.可以是调用方法输出方法中的数据
5.不可以有输出语句
6.代码注释只能是java的单行和多行注释其余不行
3.声明
<%! …… %>
说明；
1.是用于定义方法和全局变量的
2.不可以有输出语句，只能在方法中输出
3.定义的方法，变量
4.代码注释只能是java的单行和多行注释其余不行
4.注释；
<%-- …… --%>
说明；
只能在HTML代码中，不能再JSP声明表达式脚本代码等写这个注释
JSP特有的注释是客户端浏览器不可见的 而HTML的注释是客户端浏览器可见的
在解析成*.java文件的时候会忽略特有的JSP注释
5.处理指令；
<%@ …… %>
1.处理指令是用于告知Tomcat服务器是要如何操作这个文档的，
以及这个文档不能有什么等。。。。。
如；这个文档不不能写EL表达式等...
2.处理指令时不可见的输出的，是不会输出到浏览器
3.处理指令时不会原样的存在解析后的*.java文件的
page；
定义页面属性。。。。。。
page常用属性；
language="java" --- 声明这个文件可以使用什么语言进行编写
import = "java.util.*" --- 是用于导包
注；导包一般都是创建一个新的page便于维护的和排错等
······可是可以在一个page的import属性中同时导入多个包
······如果是同时导入多个包则使用 ( , )进行分隔
◆ 不可以使用( ; )进行导包的分隔会报错
contentType="text/html; charset=UTF-8" --- 设置文档的输出编码集，
比pageEncoding优先级◆···高
pageEncoding="UTF-8" --- 设置文档的解析成*.jsp编码集，
比contentType优先级◆···低
buffer="8kb" --- 默认是8K，这缓存是用于输出的缓存。。。后续out
|----> errorPage="_03_00_Jsp_ProcesssingInstruction_Instroduce.jsp"
|
|----------------->是设置当页面出现错误的时候跳转到一个错误的页面
◆而这个错误是只是作用在Jsp脚本代码的
这个跳转是一个内部的跳转，不是重定向是转发
isErrorPage="true" --- 设置是否是一个错误页面，默认是false
=== 如果设置为一个错误页面，
那么则可以调用exception对象，
来获取到异常，或者抛出。
session="true" --- 设置是否为每一个访问的用户都创建一个会话，
默认是true
◆ 可以通过设置这个session为false来优化页面访问
autoFlush="true" --- 设置是否自动刷新，默认是true
isELIgnored="false" --- 是否忽略EL表达式，默认是false
isThreadSafe="false" --- 是否是线程安全的，默认是true，
也保证了Servlet的单例规范
代码；
<%@ page import="java.lang.*,java.util.*">
◆注；每一个JSP必须有一个page指令用于定义这个*.jsp文件的信息定义等。
一个JSP文档中可以有多个page指令，但是在设置属性时不要冲突。
多个page处理指令基本都是导包的时候用的。。。。。。。
include；
是用于页面静态包含的。
是用于进行一个预定义页面的引用，而这个是一个静态的包含其他页面
因为在页面中有N个位置时一样的，那么就没有必须要每次都要写，
只需要引用其他页面，提高效率
特点；将所需要的页面进行一个合并了在进行一个解析之后在进行编译运行
弊端；在合并的页面不要写HTML文档的结构标签，如,html。。。
因为如果写了那么会造成有有个标签那么就违反了规范了
|-----------include---------> ● 可以使用被合并的文件标签数据等。。。。。。。
|
|
| 代码；
| <@% include file="path" %>
|
| ◆注；一个JSP文档中可以有多个include处理指令，
| 因为可以会有多个页面要合并
|
|
|
| taglib；
| 是用于引用标签库的文件。
| 代码；
| <%@ taglib uri="文件对应的uri" prefix="文件的标签标识"%>
|
|
|
| ◆注；pageEncoding是jsp文件本身的编码
| contentType的charset是指服务器发送给客户端时的内容编码
|
|
|
|
|
|
|
|
--------|--------------------------------↓↓↓↓↓↓↓ＪＳＰ常用内置标签↓↓↓↓↓↓↓----------------------------------------------------
|
|
| Jsp常用标签；
| 为什么要有？
| 在JSP规范中要求尽量要少出现Java代码，
|
| 1.Jsp是用于显示页面的，不是进行处理业务逻辑的
|
| 2.Jsp文件要是要进行解析-编译-运行
| 如果Java代码太多会导致解析，编辑等效率下降，因为是显示在浏览器的
|
| 所以SUN公司为 Jsp设计了一部分的标签，便于使用
|
|
|
| 语法；
| 1.
| 2.
|
|
| 常用标签；
| 1、
|
| 说明；合并的文件是分开的，
| 如果被引用的页面代码太多了
| 会先显示当前页面的代码
|
--------include---------> ● 无法使用被合并文件的数据等。。。。。。。
2、
说明；是一个···转发的跳转···
不是重定向，注意转发和重定向的区别。
3.
说明；这个是设置一个属性，
● 这个是必须要和forward标签一起使用，不可以单独使用。
◆◆◆◆◆注；Jsp语法内置标签，也叫 ● Jsp动作标签 ●
--------------------------------------------↓↓↓↓↓↓↓ＪＳＰ —— ＥＬ表达式↓↓↓↓↓↓↓----------------------------------------------------
EL表达式；
因为Jsp的规范中尽量不要写Java代码，
那么获取到Servlet.java文件处理完成的
业务逻辑结果显示到页面那么只能通过EL表达式获取
主要是用于···计算···和···获取到域数据···逻辑判断
所以一般处理好的业务逻辑都是会存放到域中的。
◆注；在EL表达式不可以写在注释里，会报错
-----------------------------------------↓↓↓↓↓↓↓ＪＳＰ —— ＥＬ表达式_语法↓↓↓↓↓↓↓----------------------------------------------------
EL表达式语法；
${ …… }
◆注；EL表达式的语法不可以写在注释里，要使用字符分隔否则会报错
--------------------------------------------↓↓↓↓↓↓↓ＪＳＰ —— ＥＬ表达式_应用↓↓↓↓↓↓↓----------------------------------------------------
EL表达式；
EL获取到域的值；
{ 内置对象.属性名 }
{ 属性名 }
EL表达式中改变了域的名称。
page ----- pageScope
request ----- requestScope
session ----- sessionScope
application ----- applicationScope
代码；
1、通过内置对象获取到域的name对应的值
${ pageScope.a }
${ requestScope.b }
${ sessionScope.c }
${ application.d }
2.直接获取到name对应的值 --- 不指定域
${ c }
说明；直接获取没有指定域获取的话，
默认是按照从一个范围的小到大获取
如果在一个范围中获取到了，那么则直接返回值
3.获取到单列集合的值
${ name(键)[num] } --- 获取到集合的某一个值
${ request.sett[0]} --- 获取到request域中集合的第一个值
${ name(键) } --- 获取到整个集合
${ sett } ----- 获取到整个集合
4.获取到双列集合的值
${ name.集合key } ----- 获取到Map集合指定的key的值
${ request.map.a } ----- 获取到request域key为a 的值
${ name } ----- 获取到整个双列集合（是一个内存地址）
${ map } ----- 获取到整个双列集合
5.获取到对象
${ name } ----- 获取到这个类的对象
${ request.student} ----- 获取到request域的学生对象
${ name } ----- 获取到某一个域的key的对象
${ student } ------ 获取到某一个域key的student对象
6.获取到方法的值
类；studen 属性 name 方法 getName()
${ request.student.name } ------ 获取到request域的学生名字
${ stdent.name } ----- 获取到某一个域的学生的名字
◆◆◆注； 在EL表达式中要获取方法的值，
这个方法必须是无参的，而且是没有返回值的，一般都是get方法
在EL表达式中调用这个方法是不加get
◆ 直接属性名小写
◆◆◆◆◆◆注；在EL表达式中是可以使用三元运算符的，
因为EL表达式本质就是java代码，
而且EL表达式的用途包括逻辑判断的。。。。。。
但是EL表达式无法使用if等语句。。。。。。
但是三元运算也是逻辑判断的，
而且是符合EL表达式的要求的。
-------------------------------↓↓↓↓↓↓↓ＪＳＰ —— Ｏｕｔ和ＰｒｉｎｔＷｒｉｔｅｒ区别↓↓↓↓↓↓↓----------------------------------------------------
Out和PrintWriter区别；
在JSP中的Out对应的Servlet对象是response.getWriter
JSP的Out是带有缓冲功能的写出，
先将页面加载到缓存中在一起写出。
Out写出的时机；
1.页面加载完成
2.缓存满了
◆注；默认的缓存是8KB，可以通过修改page处理指令的buffer属性来修改缓存
如果修改的缓存为0KB的话，那么当前页面的Out对象则失去缓存功能
response.getWriter是没有缓存的加载到一条则直接写出。
相同；都是写出功能
◆◆◆注；response.getWriter获取到的对象和Out是一样的都是JspWriter，
只不过reseonse.getWriter进行了封装，都是指向JspWriter
——————————————————————■■■■■■■■■■■■■■■===↓↓↓↓↓ＪＳＰ —— 自定义标签↓↓↓↓↓↓↓↓===■■■■■■■■■■■■■■■■■■—————————————————————
Jsp自定义标签；
为什么要有？
JSP的自定义标签是为了取代JSP页面的Java代码，
而Jsp自带的标签有时根本就满足不了需求，
所以要根据需求进行定义相关的标签。
因为JSP页面的Java代码不便于维护，而且使得JSP页面的简洁性差，
维护困难，因为如果前端在进行定义样式等一系列的页面布局的时候
JSP页面的Java代码过多的话，不便于后期的维护，而且在维护
期间可能出现不小心删除美工代码等。。。。。。
是什么？
JSP自定义标签本质就是一系列的Java代码
作用；
取代JSP页面的Java代码，如同EL表达式取代JSP表达式<%=……%>
使得JSP页面变得简洁，提高维护性等。。。。。
特点；
本质还是Java代码
需要建立*.tld文件做关联
标签是有一个声明的
-------------------------------------------↓↓↓↓↓↓↓ＪＳＰ开发步骤↓↓↓↓↓↓↓----------------------------------------------------
JSP开发步骤；
1.创建一个类继承SimpleTagSupport类
2.调用这个类的doTag()方法
3.在doTag()方法内部写业务逻辑处理代码
a.当前继承的对象通过父类的方法获取到PageContext对象
可以通过PageContext获取到其他八大类对象，或者设置其他域的属性。
代码； 因为获取到的是父类的
PageContext pc = (PageContext)this.getContext();
4.创建一个*.tld文件，
在这个文件的里定义文件关联标签名，
以及定义这个标签类对应的标签名。
5.在JSP文件中导入
代码；
<@% taglib uri="*.tld文件对应的" prefix="*.tld文件标签名"%>
<@% taglib uri="http://www.baidu.com" prefix="bd"%>
6.在JSP文件调用
代码；
-------------------------------------↓↓↓↓↓↓↓ＪＳＰ自定义标签的执行过程↓↓↓↓↓↓↓----------------------------------------------------
JSP自定义标签的执行过程；
一、解析；
1.Tomcat服务器启动，
就会自动加载WEB-INF下
的web.xml和*.tld文件到内存中。
2.客户端访问JSP文件页面
3.服务器解析JSP文件，解析到这个自定义标签的时候
4.检查这个标签是否来自于自定义标签
则会检查这个JSP文件的taglib标签库声明
a)不是则会报错
5.是来自标签库的则会查找内存中
是否有*.tld文件的uri标签
和JSP文件声明的uri是一致的
以及声明的文档标签声明
是否是一样的。。。。。。
a)不一致则报错
5.一致则会获取到这个标签对应的标签类
6.创建对象，调用doTag()方法
◆◆◆注；一个标签对应则的是一个类
因为都是调用doTag()方法
而每一个类的继承都只有一个doTage()方法
----------------------------------------↓↓↓↓↓↓↓ＪＳＰ —— *.tld文件书写↓↓↓↓↓↓↓----------------------------------------------------
*.tld文件书写；
方式一；在Tomcat服务器查找*.tld文件，将这个文件的信息拷贝过去
方式二；手写
|---------------设置输出格式-------------->
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|-----> 设置输出的格式；
1.jsp --- 这个只能用在JSP1.0的版本，
标签内容可以写java代码和起作用
这个违反了JSP页面的规范，所以不到极端不使用。。。。。。
2.scriptless --- 标签内容不能写java代码，会报错
a)在scriptless中标签的内容
不可以是纯字符或纯数字
必须和字母或中文一起使用
3.tagdependent --- 标签的内容可以写java代码，但是不会其作用，会原样的输出
4.empty --- 标签内容是空的，这个标签是一个空标签
◆◆重◆注；
所有的标签属性都是标签类的成员变量，
◆ 而这个成员变量必须要提供set方法，
否则会出现报错的情况，
因为在调用时类都是遵循封装性的，
而在JSP页面调用都是不需要加上set，
◆ 直接小写的属性名就可以了。
代码；
标签类；setName()
调用；name
-------------------------------------------↓↓↓↓↓↓↓ＪＳＰ内部执行顺序↓↓↓↓↓↓↓----------------------------------------------------
JSP内部执行顺序；
在JSP的自定义标签类中都是继承SimpleTagSupport类
而SimpleTagSupport实现了SimpleTag接口的，
从而所有的自定义标签类都是间接的实现了SimpleTag接口。
而在这个SimpleTagSupport类实现了SimpleTag所有的方法，从而执行也是执行这些方法
顺序；而这些方法的执行的顺序都是优先执行doTag()方法，而在doTag()方法中一般都是
调用接口的其他方法进行使用的，而在这些方法的执行顺序都是取决位于
doTag()方法内部调用的顺序的。。。。。。。。。
SimpleTag接口的方法；
1.doTag() --- 在使用自定义标签类的时候，
内部会自动的调用这个方法，
执行这个方法的逻辑业务处理。
2.setParaent(JspTag paraent) --- 设置父类标签，传入一个父类的标签类
3.setJspBody(JspFragment jf) --- 设置标签内容，传入一个内容存储类的对象
4.setJspContext(JspContext jc) --- 设置标签内容的属性，实际传入是子类
PageContext pc ---实际传入是子类
◆注；一个标签会被Tomcat服务器翻译成一个方法，在这个方法按照逻辑顺序处理
---------------------------------------↓↓↓↓↓↓↓ＪＳＰ自定义标签常用的用途↓↓↓↓↓↓↓----------------------------------------------------
JSP自定义标签常用的用途；
1.控制标签内容是否显示 --- 在doTag()方法中执行顺序↓↓↓↓↓↓↓↓
代码；
方式一；
0.获取到标签的内容，而这个标签内容被封装成了对象
JspFragment jf = this.getBody();
1.获取到PageContext类的父类
PageContext pc = (PageContext)this.getContext();
2.通过PageContext类可以获取到其他八大对象
JspWriter out = pc.getOut();
3.调用JspFragment的invoke方法，
传入一个输出网页的输出流对象，将其内容写出
jf.invoke(out);
方式二；
1.获取到标签的内容
JspFragment jf = this.getBody();
2.直接调用JspFragmentinvoke方法，传入一个null，
在内部会进行输出的处理，从而提高开发效率。
jf.invoke(null);
2.控制标签后面的内容是否显示或不显示 --- 在doTag()方法中
抛出SkipPageException
代码；
一、不显示后面的内容
---抛出SkipPageException异常，
则后面内容都不会显示。
二、不显示标签内容
---在doGet方法中什么都不写为空
3.重复显示标签内容或动态的显示标签内容 --- 使用循环
代码；
一、静态的重复显示标签内容
1.获取到标签的内容
JspFragment jf = this.getBody();
2.使用for循环输出
for(int i =0; i < 5; i++){
//调用invoke方法
jf.invoke(null);
}
二、动态的重复显示标签内容
1.创建一个成员变量，
而这个成员变量作为标签的属性存在。
可以通过EL表达式获取到这个属性的信息。
在使用时将这个属性放到域中，从而使用EL表达式获取。
4.改变标签内容
代码；
1.获取到标签内容
JspFragment jf = this.getBody();
2.创建一个输出流的容器
StringWriter sw = new StringWriter();
3.调用invoke方法，传入一个输出流的容器，
通过这个invoke方法的获取到这个内容到输出流容器
jf.invoke(sw);
4.获取到输出流容器的存储的内容
String temp = sw.toString();
5.必须手动写出
this.getContext().getOut().write(temp);
-----------------------------------------↓↓↓↓↓↓↓ＪＳＰ —— 注意↓↓↓↓↓↓↓----------------------------------------------------
1.重启了服务器等一系列操作，操作后还是没有错，
那么则要看下 Tomcat —> webapps —> 项目源文件是否修改的时候重发布成功
2.在调用域的信息的时候，可以先在文件测试域是否为空，
避免出现遍历等一系列业务逻辑处理的时候错误。
3.在属性中使用EL表达式必须要使用" "
4.在属性中使用EL表达式必须设置*.tld文件的属性标签下的子标签内容为true
5.在scriptless格式中不能输出纯数字或纯字符必须和字母或中文一起使用
—————————————————————■■■■■■■■■■■■■■■===↓↓↓↓↓ＪＳＰ —— Ｊｓｔｌ标签库↓↓↓↓↓↓↓↓===■■■■■■■■■■■■■■■■■■——————————————————————
Jstl标签库；
为什么要有？
SUN公司为了提高业界开发效率将，
经常需要实现的功能的代码封装成一个一个标签，
而这些标签都统称为Jstl标签库。
是什么？
Jstl标签库是一系列封装好的标签。
作用；
用于页面逻辑，处理自定义标签等。。。。。
便于调用，提高开发效率。。。。。。。
特点；
-----------------------------------------↓↓↓↓↓↓↓Ｊｓｔｌ标签库分类↓↓↓↓↓↓↓---------------------------------------------------
Jstl标签库的分类；
核心标签库 ---> core/c ---> 文件标签名是( c )
国际化(格式化)标签库 ---> framat/fmt
fn(EL)标签库 ---> fn
/SQL标签库 ---> sql
|
\XML标签库 ---> x
◆注；SQL标签库和XML标签库基本都不使用了，
因为XML和SQL都是用于存放数据了，
而不会将这些数据显示在客户端浏览器。
------------------------------------------↓↓↓↓↓↓↓Ｊｓｔｌ开发步骤↓↓↓↓↓↓↓----------------------------------------------------
Jstl开发步骤；
1.在MyExlipce中创建web项目
2.检查是否有J2ee5的lib
a)如果没有则需要导包
3.在JSP文件中直接调用。
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
a)一般使用的是核心标签库的标准版，要注意uri的地址
4.直接调用
--------------------------------------↓↓↓↓↓↓↓Ｊｓｔｌ核心标签库常用标签↓↓↓↓↓↓↓----------------------------------------------------
Jstl核心标签库常用标签；
导标签库；
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
1.set；
设置属性，默认设置的属性作用在pageContext域
代码；
说明；
var --- 设置域属性名
value --- 设置域属性名对应的属性值
scope --- 设置域的作用域，如果不设置默认是pageContext
2.out；
输出内容
代码；
说明；
value --- 域的属性名
defalut --- 默认值，如果value/值为null则输出默认值
escpeXml --- 设置默认值是否有效
3.if
单条件判断，输出内容，只有true和false。
代码；
说明；
test --- 设置判断语句
如果要判断则需要使用EL表达式
因为EL的作用就是逻辑处理，
和获取域的属性值。
4.choose-when-otherwise
多条件判断，输出符合条件内容
代码；
xxx
vvv
ccc
说明；
与if-else if...-else 使用相同
choose - when -otherwise
if else if else
test --- 设置判断语句,boolean
如果要判断一般都是EL表达式，
因为EL的作用就是逻辑处理，
和获取域的属性的值。
5.forEach
遍历数据和集合
xxxxxxxxxxxxxxxxxxxx
说明；
items --- 遍历的集合或数组，
只能传入集合或者是数组，
如果不是集合或者数据，
会原样输出这个items的值。
所以一般都是传入一个EL表达式获取到的集合或数组
begin --- 从哪个元素的角标开始遍历，默认是第一个
end --- 遍历到哪个角标结束，默认是最后一个
step --- 每次遍历的角标的位置，默认是 1++
var --- 接收元素每一个遍历的元素
varStatus --- 每一个元素的状态，
而在varStatus有一个count方法，
获取到每一个元素的系列号，
代表的是第几个元素。
6.forTokens
遍历字符串
xxxxxxxxxxx
说明；
items --- 传入一个字符串
delims --- 切割的字符
begin --- 开始位置，切割符号的子字符串是元素，
begin是指从第几个子字符开始。
以切割字符作为一个分隔。
默认是第一个元素。
end --- 结束位置，
是以切割的元素的角标进行标识的
默认是这个字符切割符的最后一个元素。
step --- 每次切割的字符的位置遍历是增加几，默认是1++
var --- 用于接收每次切割之后的元素
varStatus --- 每一个切割的之后的元素的状态，
有一个count的方法可以，
获取到这个状态Id。
7.redirect
简化重定向
代码；
说明；
url要跳转的资源，
而这个资源只能是当前项目下的，
◆但是不用指定项目名而已。
8.url
简化的url
代码；
说明；
value是要跳转的地址，不需要写项目名
这个标签主要是用于 ( a ) 标签等一起使用，
因为可以避免路径出错
如果单独使用则是无效的，
如果有项目下的一个文件路径则会输出这个项目的路径
◆◆◆注；在属性中是可以嵌套EL表达式，注意↓↓↓
◆◆◆注；建议在标签属性使用EL表达式必须EL表达式必须要使用"EL"，
并且不可以有空格，因为会认为是一个字符串。。。。。。
—————————————————————■■■■■■■■■■■■■■■===↓↓↓↓↓ＪａｖａＢｅａｎ规范↓↓↓↓↓↓↓↓===■■■■■■■■■■■■■■■■■■——————————————————————
JavaBean规范；
为什么要有？
有了JavaBean规范，将数据进行封装，提高代码的重用性等。。。。。。。
是什么？
是SUN公司定义的规范，
JavaBean也叫PoJo(plain old java Object)
VO(Value Object)或DO(data Object)
◆JavaBean就是一个java类，JavaBean只是一个规范。
作用；
主要是为了封装数据，提高代码的重用性，使得代码的页面整洁等。。。。。
◆规范要求（特点）；
JavaBean规范的类，必须要有无参的构造方法
必须把属性私有化
必须提供public 的 get/is和set方法
◆注；is方法也是属性get方法，因为这个主要是在一些布尔类型会使用。。。。。。
◆◆◆◆◆注；建议(必须)要实现Serializable接口，
使得该类可以进行系列化，
才可以在网络上进行一个传输。
———————————————————————■■■■■■■■■■■■■■■===↓↓↓↓↓ＭＶＣ ＆ 三层架构↓↓↓↓↓↓↓↓===■■■■■■■■■■■■■■■■■■————————————————————————
MVC&三层架构开发模型；
为什么要有？
1.在开发架构模型中，
a)可以使用 Jsp + javaBean
但是程序的操作过于依赖Jsp
可是简单，开发效率高，
不便于进行一个维护。
b)可以使用jsp + servlet + javaBean
但是Serlet类似一个数据到显示页面的桥梁
而这个业务处理，如果在Serlvet类中太多
不便于程序的维护，排错等。。。。
因为所有的业务逻辑到
写在Servlet类中。
是什么？
是一个架构开发的模型。
作用；
使得程序的，代码简洁，客观，利于排错，维护等。。。。。。
特点；
分层开发
--------------------------------------↓↓↓↓↓↓↓ＭＶＣ ＆ 三层架构层次↓↓↓↓↓↓↓----------------------------------------------------
MVC架构层次；
1.表示层(web) --- javaBean(model)、servlet(control)、jsp(view)
a)javaBean将获取到的数据进行一个封装
b)jsp是用于显示后台处理的结果的
c)servlet是控制数据的处理(如；登录需要进行什么业务处理)
2.业务逻辑层(service) --- 处理业务
客户端浏览器要与服务器进行交互数据，
而这个数据的交互规则则是业务处理。
如；登录等。。。
3.数据访问层(Dao) --- CRUD 增删改查
控制客户端浏览器访问数据的操作。
Dao是直接与数据进行交互的。
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■↓↓↓↓↓↓Ｓｅｒｖｌｅｔ域↓↓↓↓↓↓↓↓■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
↓↓↓↓↓↓大到小↓↓↓↓↓↓
Servlet域分类；
ServletContext ----- 全局范围
作用；
存储作用的整个服务器的数据。
如；下拉列表等，固定的非常少修改的数据。。。。。。
HttpSession ----- 会话范围
作用；
存储当前会话的用户的数据。
HttpServletRequest ----- 当前请求的范围
作用；
存储当前请求信息的数据，如果不是转发那么再次请求会创建一个新的
【pageContext】 ----- 当前页面的范围
作用；
只是在JSP中有，并且是咋当前的页面获取到其他对象
Servlet域；
ServletContext ---J--- application ---E--- applicationScope
HttpSession ---J--- session ---E--- sessionScope
HttpServletRequest ---J--- page ---E--- request
特殊；【PageContext】 ---J--- pageContext ---E--- pageScope
◆ 注；在Servlet中是无法使用pageContext域的，
因为也没有意义，这个域的只作用在当前页面
这个域的作用是为了获取其他的对象
◆◆◆◆◆注；在EL表达式中域对象如果加上了Scope则是获取域信息，
如果没有加上Scope则是调用方法，
而在EL表达式中要是需要获取别的对象要使用pageContext域对来获取
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■↓↓↓↓↓↓Ｓｅｒｖｌｅｔ常见的错误↓↓↓↓↓↓↓↓■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
常见的错误；
◆ 1.在获取到域信息的时候注意空指针的异常
2.注意路径的异常，建议把web.xml的访问虚拟路径名改成和文件一样的
3.在JSP中的注释不可以写EL表达式，JS脚本代码语法，表达式，声明等。。。。。。
有时出错了就是这里的注释出错，而工具没有检测出来这个错误。。。。
4.重定向的路径是要写项目名的，转发是不用写项目名的
◆ 5.在获取文件的时候，注意；如果不是Servlet的语句块内，可能写相对路径没用
a.可以使用类获取到
b.绝对路径
6.JSP文件必须要翻译的。。。。。才会在页面显示出效果
7.在使用EL表达式调用域的属性值的时候，是使用xxxScope，在EL表达式中必须要加上Scope
8.在使用PageContext域的
setAttribute(x,x,x)方法
调用其他域的时候，
◆ 使用常量的XXX_SCOPE
9.注意在使用Jstl标签库的时候，
在属性的值是使用EL表达式获取的，
那么这个 " " 双引号不可以有空格
因为会认为是一个字符串。。。。。。
value="${ request.s }" 正确
value=" ${request.s} " 错误
不能是闭合标签
◆10.技巧；可以使用自定义异常，来抛出，
从而进行将这个异常的内容进行一个转发输出到页面
11.注意；如果在一条语句中有多个EL表达式使用 ( ) 空格分隔
————————————————————————————————————↓↓↓↓↓↓Ｓｅｒｖｌｅｔ开发小技巧↓↓↓↓↓↓↓↓——————————————————————————————————————————
表单；
1.在对表单的数据进行某些后台处理的时候可以在表单使用 recodonly='xxx'事件，
这个事件可以使得用户无法修改某一个表单的数据，
以达到用户无法修改表单的某些数据。
在JSP中使用EL配合使用
如；
2.当需要获取某些数据，
而这些数据是不想让用户看见的可以使用hidden，
在CSS中也有hidden关键字，
也可以在表达中使用hidden格式使得用户提交的时候，要获取到某些信息。
如；
3.在使用标签的时候可以将href属性的值设置为javascript:void()，
可以使得href属性失效，但是不会影响到a连接的特性
4.在Servlet开发中在EL表达式里要善用三元运算符