前段基础
不同语言的注释
Java //单行注释 /* 多行注释 */ /** 文本注释 */
HTML <!-- 注释内容 -->
Css <!-- 注释内容 -->
JavaScript //单行注释 /* 多行注释 */
XML <! -- 注释内容 -->
HTML
<html> //开头必写
<head> //头标签 css和JavaScript最好写在里面
</head>
<body> //体标签 Html 标签语言写在里面
注意：<table>表格标签里面有两个隐式<tbody>表格主体 <tfoot>表格页脚
飘动的标签语<marquee>
标记 <按钮> 事件语句全部是on开头在DHTML API里面
type文件类型，value是值，name标签名，方法写在事件里。
DW快捷键 shift+enter 是</br> shift+Ctrl+空格是&nbs;
注释是<!-- 注释语句-->
</body>
</html>
概念：
html语言： html语言是网页开发技术的基础语言。
html: 超文本标记语言
html：负责网页的结构
Css
概念：
Css ：负责网页的样式
Css的引入
内部引用css<style type="text/css">
外部引入css<link href="1.css" rel="stylesheet"/>
idea开发工具中必须引入rel="stylesheet"这个属性，否则不能识别css样式
Css选择器
标签选择
格式：
标签名{
样式1；样式2;.....
}
例子：
a{
color:#B93178;
text-decoration:none;
}
类选择器： 使用类选择器的时候一定要给html标签添加一个class的属性值。
格式：
.class的属性值{
样式1;样式2....
}
例子：
.one{
color:#FF0; /* 黄色 */
font-size:36px;
}
注意的事项：
1.使用类选择器的时候class的属性值不能以数字开头。
2. 类选择器的优先级要高于标签选择器。
id选择器: 如果需要使用id选择器，那么首先必须要给html标签添加一个id属性值。
格式：
#id属性值{
样式1；样式2；...
}
id选择器要注意 的事项：
1. id的属性值不能以数字开头.
2. 在一个html页面中不能出现重复的id属性值。
3. id选择器是在所有选择器中优先级别最高一个选择器。
交集选择器：
格式： 对选择器1中的选择器2的数据进行样式话。
选择器1 选择器2{
样式1; 样式2....
}
例子：
div span{
color:#00F;
font-size:36px;
}
并集选择器：
选择器1,选择器2{
样式1，样式2;
}
例子：
a,div{
color:#F00;
}
通用选择器：
格式：
*{
样式1；样式2...
}
伪类选择器:
a:link {color: #FF0000} /* 未访问的链接 */
a:visited {color: #00FF00} /* 已访问的链接 */
a:hover {color: #FF00FF} /* 鼠标移动到链接上 */
a:active {color: #0000FF} /* 选定的链接 */
注意：html中css文档查看定位 隐式固定定位fixed 盒子模型
JavaScript
概念：负责实现网页交互功能 分为基本ECMAscript DOM BOM
特殊点：
所有类型只需要定义一个 var接收就可以
所有JavaScript输出字面语句是String类型
for in 循环等价于java增强for循环
for (sProp in window) {
alert(sProp);
}
switch 语句的语法选择项中可以增加表达式而java中不可以
With 语句：
<script type="text/javascript">
<!—
with(document){
write("您好 !");
write("<br>这个文档的标题是 : \"" + title + "\".");
write("<br>这个文档的 URL 是: " + URL);
write("<br>现在您不用每次都写出 document 对象的前缀了 !");
}
// -->
</script>
如何写入JavaScript文件
内部引入<script type="text/javascript">
外部引入<script src="tool.js" type="text/javascript"></script> //需要写入时要在写入内部引入
JavaScript api查找需要注意就是对象和方法剩下多数在DHTML api中，DHTML注意点击目录输入需要查找的字符开头会跳转
JavaScript有几种类型
number 代表了所有的整数与小数。
boolean 布尔类型。
string javascript是没有字符的概念的。字符与字符串都是string类型。
undefined 如果一个变量没有存储数据，那么默认的值为undefined， undefined类型只有一个
写入方法function 类名{}
DHTML需要记住几个重要查找单词
用typeof可以查看数据类型 typeof 变量名
parseInt(); 把字符串转换成整数
parseFloat()； 把字符串转换成小数。
prototype要注意的事项：
1. 在javascript中任何一个函数都有prototype的属性，这个属性是隐式维护的。
2. prototype的值是一个对象
3. 可以任意修改函数的prototype属性的值
4.一个对象会自动拥有这个对象所属构造函数的prototype的成员属性和方法。
例如：Array.prototype.getMax = function() 可以重写方法
innerHTML 写入文本
创建、删除、添加子节点:
document.createElement("标签名") 创建新元素节点
elt.setAttribute("属性名", "属性值") 设置属性
elt.appendChild(e)
elt.insertBefore(new, child); 添加到elt中，child之前// 参数1：要插入的节点 参数2：插入目标元素的位置
elt.removeChild(eChild) 删除指定的子节点
通过节点关系找节点：
parentNode 获取当前元素的父节点。
childNodes 获取当前元素的所有下一级子元素。
firstChild 获取当前节点的第一个子节点。
lastChild 获取当前节点的最后一个子节点。
nextSibling 获取当前节点的下一个节点。（兄节点）
previousSibling 获取当前节点的上一个节点。（弟节点）
Window代表浏览器中一个打开的窗口。可以省略不写直接用方法
注意的方法
Window.setInterval() 每经过指定毫秒值后计算一个表达式
Window. setTimeout() 经过指定毫秒值后计算一个表达式。
Window. Open(“地址值”,”打开方式”,”打开样式” )
alert() 弹出框
moveBy() 将窗口的位置移动指定 x 和 y 位置上，该xy的值是相对于原本位置进行移动的。
moveTo() 将窗口左上角的屏幕位置移动到指定的 x 和 y 位置。 (相对屏幕当前的位置)
location对象
注意的事项
location 地址栏对象： 代表了浏览器窗口的地址栏
location对象常用的属性： href
location常用的方法： reload() 刷新页面
Screen 屏幕对象
注意事项
Screen 常用的属性：
availHeight 获取系统屏幕的工作区域高度，排除 Microsoft® Windows® 任务栏。
availWidth 获取系统屏幕的工作区域宽度，排除 Windows 任务栏。
height 获取屏幕的垂直分辨率。
width 获取屏幕的垂直分辨率。
Document对象代表给定浏览器窗口中的 HTML 文档。
注意的方法
createElement 为指定标签创建一个元素的实例。
getElementById 获取对 ID 标签属性为指定值的第一个对象的引用。
getElementsByName 根据 NAME 标签属性的值获取对象的集合。
getElementsByTagName 获取基于指定元素名称的对象集合。
select 对象下拉框标题 option 对象下拉框
注意例如 DHTML API中三列的话 最左边是HTML标签语 中间是JavaScript代码
<select>
<option>--xx--</option>
</select>
JavaScript正则表达式与java基本一样
JavaScript开头和结尾要加/ 内容/ java是“内容”
位置：
^ 开头
$ 结尾
标志：
g （全文查找出现的所有 pattern）
i （忽略大小写）
m （多行查找）
正则常用的方法：
test() -- 判断字符串是否匹配正则的内容。
exec() --- 查找符合正则的字符。
例如
var reg = /^[a-z]{3}$/i; //边界匹配器
document.write(reg.test("123abc123"));
xml(Dom4j架包、sax解析器（自带）、Xpath架包、dtd约束、schema约束)在html文档点xml中可查询
xml ： 可拓展标记语言。
可拓展 ： xml里面的标签都是可以自定义的。
标记语言：该语言全部都是由标签构成。
html与xml的区别：
1. xml文件的标签是可以自定义的，html的标签是固定的。
2. html的标签是由浏览器去解释, xml的标签由我们自己写程序解释。
xml文件的解释技术：
dom4jxml解释技术：导入架包
xml的作用：
1. 可以把有关系的数据描述清楚。
2. 可以用于不同系统的数据传输。
xml的解释方式:
dom4j的解释方式：
找节点：
方式一： 通过根节点去一级一级往下去找。
找标签子节点：
getRootElement() 获取根节点：
Elements() 获取所有的直接子标签元素
Elements("标签名") 指定名称获取所有的子标签。
Element(标签名) 获取指定名称的第一个子标签。
elementText("标签名") 获取指定名称的子标签的内容。
找属性子节点：
attributes() 获取标签中的所有属性。
attirbute("属性名") 获取指定名称属性对象。
attributeValue("属性名") 获取指定属性名的属性值。
方式二： 通过xpath表达式找节点。
常用的方法：
selectNodes(xpath表达式); 找到所有符合xpaht表达式的所有节点。
selectSingleNode(xpath) 找到符合xpath表达式的第一个子节点。
xapath表达式找节点的路径方式：
绝对路径 ： 绝对路径是以“/”开头的路径。 “/”代表了document对象。
相对路径 : 相对路径是以“.”开头的路径， .代表了当前节点，当前节点就是指调用selectSingleNode或者是SelectNodes方法的调用者对象。
全文搜索路径： "//"
谓语： 找节点的筛选条件。 筛选的条件应该写在 []里面。
创建：
创建xml文件，那么需要使用到以下两个类：
1. XMLWriter 可以把一个document对象写出生成一个xml文件。
2. outputformat 可以指定xml文件使用的encoding以及xml文件的格式。
3. DocumentHelper;
dom4j技术的缺陷：
1. 一次性要读取整个xml文件生成一个document对象，如果xml文件过于庞大，容易导致内存溢出。
2. 网络速度比较慢的时候，使用dom4j解释结束，会造成用户体验效果差。
Sax解释方式：
Sax技术主要涉及的类：
1.SaxParserFactory sax解释器工厂。
2. SaxParser sax解释器。
3. DEfaultHandler 处理器
处理器涉及到的方法：
1. startElement() 一旦读到了开始标签会调用的方法。
2. characters (*) 一旦读取到文本内容的时候会调用的方法。
3. endElement() 一旦读取到了结束标签的时候就会调用的方法。
xml约束技术： 限制xml文件出现的元素类型。
xml文件的约束技术主要有：
1. dtd文件约束。
2. schema约束技术。
/*
通过根节点找其他标签节点、属性(Attribute)、注释(Comment)、文本节点(Text)。
*/
public class Demo2 {
public static void main(String[] args) throws Exception {
//第一步： 创建xml的解释器
SAXReader reader = new SAXReader();
//第二步： 读取xml文件 得到docuemnt对象
Document document = reader.read(new File("persons.xml"));
//第三步： 获取根节点
Element rootEle = document.getRootElement();
findComments(rootEle);
}
/*
获取注释
没有专门查找注释的方法。
nodeIterator() 返回所有的子节点（包括了注释、标签、文本节点。）
*/
public static void findComments(Element rootEle){
Iterator<Node> it = rootEle.nodeIterator();
while(it.hasNext()){
Node node = it.next();
if(node instanceof Comment){
System.out.println(node.getText());
}
}
}
/*
通过根标签找属性节点。
attributes() ; 获取所有的属性。
attribute("属性名") 获取指定名字的属性
atrributeValue("属性名") 获取指定名字的属性值。
*/
public static void findAttri(Element rootEle){
List<Element> persons = rootEle.elements(); //得到了所有的person节点
for(Element personEle: persons){
/*
//获取标签体的所有属性
List<Attribute> attributes = personEle.attributes();
for(Attribute attribute : attributes){
System.out.println(attribute.getName()+"="+attribute.getValue());
}*/
/*获取单个属性。 attribute
Attribute attribute = personEle.attribute("id");
System.out.println(attribute.getName()+"="+attribute.getValue());
*/
//根据指定的属性名，获取属性值
String id = personEle.attributeValue("id");
System.out.println(id);
}
}
/*
通过根节点找其他的标签节点。
elements() 获取所有的直接子节点。
elements("标签名") 指定标签名获取所有的直接子节点。
element("标签名") 指定标签名获取第一个直接子节点。
elementText("标签名") 获取直接子标签的标签体内容。
*/
public static void findElement(Element rootEle){
/*List<Element> children = rootEle.elements();
for(Element personEle : children){
List<Element> list = personEle.elements();
for(Element item : list){
System.out.println(item.getName()+"="+item.getText());
}
}
List<Element> children = rootEle.elements("person"); //获取所有的person子节点。
for(Element personEle : children){
System.out.println(personEle.getName());
}
*/
Element personEle = rootEle.element("person"); //指定标签名获取第一个。
String name = personEle.elementText("name");
System.out.println(name);
/*Element nameEle = personEle.element("name");
System.out.println(nameEle.getText());*/
}
生成xml文件：
生成xml文件主要使用两个类：
XMLWriter xml文件的生成器，可以把一个document对象生成一个xml文件。
OutputFormat xml文件的格式器 ： 可以指定xml文件使用的码表与格式。
利用IO流写入XML文件
生成xml必须要存在的对象：
document
XMlWriter
public class Demo2 {
public static void main(String[] args) throws IOException {
//创建一个全新的document对象。
Document document = DocumentHelper.createDocument();
//给document对象添加根节点
Element rootEle = document.addElement("books");
//在根节点的基础上添加其他的书籍。
Element bookEle = rootEle.addElement("book");
//给书添加属性
bookEle.addAttribute("id", "a1");
//给书添加其他的子节点
bookEle.addElement("name").setText("西游记");
bookEle.addElement("author").setText("张孝祥");
bookEle.addElement("price").setText("5");
//创建一个xml文件的格式器
// OutputFormat format = OutputFormat.createCompactFormat(); // 紧凑型
OutputFormat format = OutputFormat.createPrettyPrint(); // 漂亮型
//设置xml文件的encoding使用的码表。
format.setEncoding("GBK");
//把document写出
XMLWriter xmlWriter = new XMLWriter(new FileWriter("books.xml"), format);
xmlWriter.write(document);
//关闭资源
xmlWriter.close();
}
}
更多例子在day05 (增 删 改 查)
SAX解析器：（sun再带）
xml文件的作用可以用于不同系统的数据传输。
dom4j解释技术有缺陷：
1. dom4j技术解释xml文件的时候要一次性读取整个xml文件生成一个document对象。
如果xml文件比较庞大，那么就很容易导致内存溢出。
2. 数据传递的时候如果网速较慢，用户显示数据是一次性要显示所有，这时候给用户造成体验效果较差。
sax解释器： sax解释器方式是sun自己实现的。不需要导入任何jar包。
sax解释方式设计到的类：
1. SAXParser --- Sax解释器。
2. Defaulthandler -- 默认处理器。
sax解释方式的特点：
2. 解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方法，
解析器在调用事件处理器的方法时，会把当前解析到的xml文件内容作为方法的参数传递给事件处理器。
3. 事件处理器由程序员编写，程序员通过事件处理器中方法的参数，就可以很轻松地得到sax解析器解析到的数据，从而可以决定如何对数据进行处理。
自定义的处理器。 类需要继承 DefaultHandler
xml的处理器一般都需要重写： startElement ， characters , endElement
Dtd 约束（在HTML API中查找）
xml文件的约束技术:
xml文件的约束技术只要解决的问题：限制xml文件出现的元素。
xml文件的约束技术主要有：
1. dtd文件约束
2. schema文件约束技术。
数据类型：
PCDATA 实现：(#PCDATA) 被解释的字符串数据
EMPTY 实现：EMPTY 即空元素
ANY 实现：ANY 即任意类型
符号类型：
* 表示元素可以出现0到多个
+ 表示元素可以出现1到多个
? 表示元素可以是0或1个
， 表示元素需要按照顺序显示
| 表示元素需要选择其中的某一个
属性类型：
CDATA 实现方式：isbn CDATA #REQUIRED
ID 实现方式：isbn ID #REQUIRED 即唯一
ENUMERATED 实现方式：book_type (社科类|工程类|教育类) "社科类"
属性说明：
#REQUIRED 代表属性的必须的。
#IMPLIED 代表可有可无
#FIXED 实现方式：book_info CDATA #FIXED "我是固定值"
schema约束技术（html中）
约束标题
名称空间 : 名称空间的概念有点类似于schema的元素的唯一标识。
schema规定：
schema文件定义好的所有元素都必须要绑定到一个名称空间上面。
名称空间是一个schema文件的唯一标识。
targetNamespace : 名称空间。
<书架 lang="aa" xmlns="http://www.itcast.cn"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.itcast.cn book.xsd">
书写标题
如果需要使用schema文件，那么必须要使用schema文件的唯一标识（名称空间）
引用schema文件的方式：
1. 在xml文件的根标签使用schemaLocation的属性指定即可。
如果需要使用schema的元素要在根标签上使用： xmlns 指定标签的前缀名。
xmlns:itcast="http://www.itcast.cn" 告诉xml文件，我下面要使用到这个schema文件的元素。最好后面加上文件位置
例如
<书架 lang="aa" xmlns="http://www.itcast.cn"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.itcast.cn book.xsd">
web服务器
tomcat服务器
bin目录开启和关闭
conf 目录server.xml更改域名 tomcat-users.xml更改管理员用户
lib 目录jar包
logs 目录日志文件
temp 目录放临时文件
在tomcat服务器中怎么实现web发布
在tomcat文件夹中wabapps里需要建立文件夹在放文件才能访问，需要访问java文件需要建立一个web-inf文件夹和一个web.xml文件，web-inf文件夹中需要建立classes（放java的class文件）和lib（放jar包）文件夹
默认使用iso8859-1编码 需要使用setCharacterEncoding 只对post有效
http协议(servlet)
概念：http协议： 对浏览器客户端和服务器端之间数据传输的格式规范。
http请求：浏览器->服务器端
格式：
请求行（请求方式（GET/POST） 请求资源（URI） http协议版本（http1.1））
请求头（键值对形式存在。 host、user-agent、referer）
一个空行
实体内容（POST提交的参数）
HttpServletRequest对象： 请求对象。获取请求信息。
请求行：request.getMethod() request.getRequestURI/getRequestURL()请求地址 request.getProtocol();请求版本
请求头： request.getHeader("name") request.getHeaderNames()
实体内容： request.getInputStream()
http响应： 服务器->浏览器端
格式：
响应行（http协议版本 状态码 描述）
常用的状态码： 200 302 404 500
响应头（ location（结合302状态码完成请求重定向功能）、 refresh（定时刷新）、content-type、 content-disiposition（以下载方式打开））
一个空行
实体内容
HttpServletResponse对象： 响应对象。设置响应信息。
响应行: response.setStatus();
响应头： response.setHeader("name","value")
实体内容：
(PrintWriter) response.getWriter().writer(); 字符内容
（OutputStream）response.getOutputStream().writer(); 字节内容
获取参数数据：(GET或POST)
request.getParameter("name") 一个值的参数
request.getParameterValues("name"); 多个值的参数
request.getParameterNames() 所有参数
请求头信息
Accept: text/html,image/* --支持数据类型
Accept-Charset: ISO-8859-1... --字符集
Accept-Encoding: gzip --支持压缩
Accept-Language:zh-cn --语言环境
Host: www.itcast.com:80 --访问主机
If-Modified-Since: Tue, 11 Jul 2000 18:23:51 GMT --缓存时间
Referer: http://www.itcast.com/index.jsp --来自哪个页面、防盗链
User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)
Cookie
Connection: close/Keep-Alive --链接状态
Date: Tue, 11 Jul 2000 18:23:51 GMT --时间
Api查询 HttpServletRequest 请求头与接口 ServletRequest
乱码问题get与post不同
//返回用于发出此请求的 HTTP 方法的名称，例如 GET、POST 或 PUT。
if("post".equalsIgnoreCase(request.getMethod())){
//设置编码格式
request.setCharacterEncoding("UTF-8");
//获取密码和账号的输入值
String s = request.getParameter("userName");
String s1 =request.getParameter("password");
//输出
System.out.println("用户名:"+s+"密码:"+s1);
//返回用于发出此请求的 HTTP 方法的名称，例如 GET、POST 或 PUT。
}else if("get".equalsIgnoreCase(request.getMethod())){
//get需要获取地址栏的信息，没有可以设置获取地址栏的编码方法
String s =request.getParameter("userName");
//request默认返回是iso-8859-1编码，所以需要通过字节读取
byte[] bye= s.getBytes("iso-8859-1");
//转换成UTF-8编码
String s2 =new String(bye,"utf-8");
System.out.println("用户名："+s2);
//选取框的值需要获取，因为不止一个选项需要获取全部
String[] s3= request.getParameterValues("hobit");
System.out.println(Arrays.toString(s3));
响应头信息
HTTP请求中的常用响应头
Location: http://www.it315.org/index.jsp --跳转方向
Server:apache tomcat --服务器型号
Content-Encoding: gzip --数据压缩
Content-Length: 80 --数据长度
Content-Language: zh-cn --语言环境 "text/html;charset=utf-8"输入底下
Content-Type: text/html; charset=GB2312 –指定编码格式response.setContentType()
Last-Modified: Tue, 11 Jul 2000 18:23:51 GMT --最后修改时间
Refresh: 1;url=http://www.it315.org --定时刷新
Content-Disposition: attachment; filename=aaa.zip --下载
Set-Cookie:SS=Q0=5Lb_nQ; path=/search
Expires: -1 --缓存
Cache-Control: no-cache --缓存
Pragma: no-cache --缓存
Connection: close/Keep-Alive --连接
Date: Tue, 11 Jul 2000 18:23:51 GMT --时间
Content-Encodingd 通知浏览器先解压在读取
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//通知浏览器数据是以压缩包的形式发送给你的，你要先解压再使用哦。
response.setHeader("content-encoding","gzip");
StringBuilder sb = new StringBuilder();
for(int i = 0; i < 100 ; i++){
sb.append("abcd");
}
byte[] buf = sb.toString().getBytes(); //400字节。---29
OutputStream out = response.getOutputStream();
/*
GZIPOutputStream的作用就是可以把数据压缩成 压缩包的形式。 gzip
使用GZIPOutputStream的write方法的时候，GZIPOutputStream首先会先把你要写出的数据
先压缩，压缩完毕之后就会调用你传入进来的outputstream的write方法把压缩之后的数据真正写出到页面上。
*/
GZIPOutputStream outputStream = new GZIPOutputStream(out);
outputStream.write(buf); //第一步： 压缩。 第二步：调用你传入进来的outputstream对象的writer方法把压缩包写出去。
//GZIPOutputStream内部有缓存字节数组，数据如果需要真正的写出，需要调用finish.
outputStream.finish();
}
响应乱码问题
Content-type头的作用：设置response使用的码表，并且会通知浏览器使用指定的码表来解释数据，必须让服务器和浏览器使用一致的码表
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//response.setHeader("content-type","text/html;charset=utf-8");
//content-type的作用： 设置response使用指定的码表，并且通知浏览器使用指定的码表解释。
response.setContentType("text/html;charset=utf-8"); //简化了
//字符流 打印流
PrintWriter out = response.getWriter(); //字符流
out.write("中国");
}
开发Servlet
request是服务器处理用的，response是浏览器处理用的
- 本身是java类，继承HttpServlet类
- 具备的特点：可以接受用户的请求数据，并且可以向浏览器 输出数据。
3）重新doGet和doPost方法
4）Servlet程序交给tomcat服务器运行！！
3.1 servlet程序的class码拷贝到WEB-INF/classes目录
3.2 在web.xml文件中进行配置
Servlet重要的四个生命周期方法
构造方法： 创建servlet对象的时候调用。默认情况下，第一次访问servlet的时候创建servlet对象只调用1次。证明servlet对象在tomcat是单实例的。
init方法： 创建完servlet对象的时候调用。只调用1次。
service方法： 每次发出请求时调用。调用n次。
destroy方法： 销毁servlet对象的时候调用。停止服务器或者重新部署web应用时销毁servlet对象。只调用1次。
通配符的格式：
格式一： 如果需要匹配后缀名，必须使用*开头。
例子： *.后缀名
格式二： 如果一个url路径以”/” 开头，那么就不能再匹配后缀名了，必须与”/*”结尾。不要使用缺省路径 /和/*,因为所有的静态资源都需要通过DefuleServlet转发过去，本身就是缺省路径
*等价于/*
可以作为域对象存储数据
域对象： 域对象其实就是指该对象可以用于存储数据，域对象可以用于不同servlet之间的数据传递。
在java中有四大域对象： request、 ServletContext , session, pageContext.
域对象常用的方法：
setAttribute(“名字”,”数据”) 往request域中添加数据
getAttribute(“名字”) 根据名字获取request域对象中的数据
removeAttribute(“名字”) 根据名字删除request域对象中的数据。
ServletConfig对象 servlet配置对象(局部只对servlet有效)
getInitParameter(name) 根据参数名获取参数值
getInitParameterNames() 往request域中添加数据
getServletContext() 根据名字获取request域对象中的数据
getServletName() 根据名字删除request域对象中的数据
web.xml配置
<servlet>
<servlet-name>Demo4</servlet-name>
<servlet-class>cn.itcast_01.Demo4</servlet-class>
<init-param>
<param-name>path</param-name>
<param-value>e:/b.txt</param-value>
</init-param>
<init-param>
<param-name>CCCC</param-name>
<param-value>CCCC's value</param-value>
</init-param>
</servlet>
ServletContext对象； servlet的上下文对象(全局)
--得到当前web应用的路径
getContextPath()
--得到web应用的初始化参数
getInitParameter(name)
getInitParameterNames()
--域对象有关的方法
setAttribute(String name, Object object) 设置值
getAttribute(String name) 获取值
removeAttribute(name) 删除值
--转发（类似于重定向）
getRequestDispatcher(“地址”).forward(request, response) 域对象
--得到web应用的资源文件
getRealPath(path)
getResourceAsStream(path)
web.xml配置
<!-- 配置全局参数 , 如果是全局配置参数，任何一个servlet都可以获取到-->
<context-param>
<param-name>charset</param-name>
<param-value>utf-8</param-value>
</context-param>
请求转发与请求重定向的区别:
1. 请求转发浏览器会发出一次请求，创建一个reuqest与response对象，请求重定向浏览器发出两次请求，创建两个request与response对象。
2. 请求转发的时候浏览器的url地址栏是不会发生变化的，请求重定向的时候url地址栏是会发生变化的。
3. 请求转发的时候跳转的资源路径可以省略工程名， 请求重定向的时候不能省略工程名。
4. "/"代表的数据
1. "/如果给服务器使用，那么该"/"代表了： localhost:8080/工程名
2. "/"如果是给浏览器去使用的，那么“/”则代表了localhost:8080
5. 请求转发不能跳转到站外的资源，请求重定向可以跳转到站外的资源。
Cookie会话技术（客户端技术）
Cookie和Cession是会话技术，会话可简单理解为：用户开一个浏览器，点击多个超链接，访问服务器多个web资源，然后关闭浏览器，整个过程称之为一个会话(默认情况)。
常用
cookie常用方法
new Cookie(“cookie名字”,数据); 创建一个Cookie对象。
response.addCookie(cookie对象) 向浏览器发送 一个cookie文件
request.getCookies(); 获取所有的Cookie.
Cookie.getName() 获取Cookie的名字
cookie.getValue() 获取cookie的值。
cookie.setMaxAge() 设置cookie最大有效时间(秒)。
cookie.setPath("/day10/getCookie"); 设置有效路径.
Cookie要注意的事项：(cookie只能是字符串，浏览器保持有限制，cookie利用浏览器运行能力)
1. 一个Cookie文件如果没有设置有效时间，那么是不会在浏览器产生cookie文件的，而cookie的数据只要浏览器一旦关闭马上会消失。
2. 如果一个Cookie没有设置有效路径，那么默认是当前工程。
3. 删除cookie的方法是创建一个同名的cookie文件并且有效路径也必须一致，然后设置其有效时间为0.
Session会话技术（服务端技术）
Session是服务器端技术，利用这个技术，服务器在运行时可以为每一个用户的浏览器创建一个其独享的session对象，session对于服务器关闭依然存在，对象进行钝化，保存到硬盘中。
Session常用方法
request.getSession() : 问Tomcat获取一个Session，如果没有一个session专门服务于该浏览器的，那么tomcat就会创建 一个session，如果已经有一个session为该浏览器的，那么就会直接返回以前的session。
setAttribute() : 往session中添加数据。
getAttribute() : 往session中取数据
removeAttribute() : 删除session的数据
session数据类型没有限制，大小没有限制，sission利用服务器运行能力。
Session是基于cookie技术所以关闭浏览器数据就会消失，如果需要关闭浏览器后访问，需要配置时间。
疑问二: 既然session技术是基于cookie实现的，那么为什么浏览器一旦关闭之后session的数据就会马上消失呢？ 是否有办法可以解决现状？
答案： 其实session并没有消失，主要的原因是因为tomcat发出cookie文件的时候没有设置有效的时间，所以该cookie文件 只要浏览器一旦关闭就会消失，一旦cookie文件消失，那么浏览器则不知道session之前的id号了。
解决方案： 创建一个同名的cookie文件，然后设置有效时间，再向浏览器添加覆盖之前的cookie文件即可。
<!-- 配置session的销毁时间 -->
<session-config>
<session-timeout>1</session-timeout>
</session-config>
小结servlet：
重点把握好6个对象：
1）ServletConfig： servlet配置对象，用于获取servlet的配置参数（init-param）
2)SerletContext: servlet上下文对象，
2.1 获取应用路径： getContextPath()
2.2 域对象： setAttribute() getAttribute()
2.3 读取文件： getRealPath()
2.4 转发： getRequestDispatcher(xx).foward()
**3)HttpServletRequest: 请求对象，用于获取请求信息
请求行： request.getMethod()
请求头: request.getHeader()
请求正文：
request.getParameter()
request.getParameterValues()
request.getParameterNames()
request.getParameteMap()
**4)HttpServletResponse: 响应对象，用于设置响应信息
响应行： setStatus()
响应头： setHeader(xx,xxx);
响应正文：
字符： getWriter().write()
字节： getOutputStream().write()
5)Cookie对象：用于保存会话数据，浏览器端
6）HttpSession: 用于保存会话数据，服务器端
Jsp(就是servlet)
Jsp=html+servlet
jsp的运行机制（重要）
1）tomcat服务器把jsp页面 翻译 成 java源文件 （%tomcat%/work/应用目录）
2）tomcat服务器把java源文件 编译 成 class文件 （%tomcat%/work/应用目录）
3）tomcat服务器创建类的对象
4）tomcat服务器类里面的方法
Jsp用法：
注意：
- 第1,2个步骤只有在第一次访问jsp页面时候执行
4.1 jsp模块
语法：就是html代码部分
作用：输出静态网页结果给用户看
注意：
1）原理是通过out.write()方法输出模块内容
**4.2 jsp表达式
语法：<%=变量或表达式%>
作用：输出变量或表达式给用户看
注意：
1）原理是通过out.print()方法输出表达式内容
4.3 jsp脚本
语法：<% java代码 %>
作用：执行java代码
注意：
1）原理原封不动地翻译到java文件的_jspService()方法里面
2）jsp表达式和jsp脚本和jsp模块通常会混合使用
jsp指令
指令 设置 jsp页面如何翻译成java源文件
include指令
用于包含其他页面
语法： <%@include file="页面路径"%>
注意：
include包含指令的原理是在jsp页面翻译时，把被包含页面的源码一起翻译到主页面，叫静态包含。
page指令
用于设置常用的属性
language: jsp使用什么语言翻译 java
import: jsp翻译成java文件时导入哪些类
pageEncoding: jsp页面使用什么编码翻译成java文件
contentType: jsp页面内容使用什么编码输出给用户看
response.setContentType("text/html; charset=ISO-8859-1");
errorPage: jsp页面发生错误时，指向的错误页面
isErrorPage: 是错误页面，可以获取错误信息。
buffer: 设置jsp页面缓存区大小，默认8kb
session：是否开启session功能，true：开启（默认），false：不开启
结论：
在myecplie工具开发jsp时，文件保存的编码和contentType的编码会参考pageEncoding，所以jsp页面中只需要写pageEncoding即可！！！！
Jsp内置对象（9个对象）
对象名 类型 备注
request HttpServletRequest 请求对象，获取请求信息
response HttpServletResponse 响应对象，设置响应信息
session HttpSession 会话对象，会话管理
config ServletConfig 配置对象，用于获取servlet配置信息
application ServletContext 上下文对象
exception Throwable 异常对象，用于获取异常信息
--------------------------------------------------------------------------------------
out JspWriter 输出对象，相当于带缓存的PrintWriter
page Object 当前jsp页面对象
*pageContext PageContext jsp上下文对象（包含其他8个对象）
全部域对象特点
PageContext域对象: 只能在当前jsp页面共享（传递）数据
Request域对象：只能在一个请求内共享数据
sessoin域对象：只能在一次会话（不同请求）内共享数据
application域对象：在一个web应用（不同会话）内共享数据
pageContext < request < session < application
EL表达式
获取不同字符串
字符串：${name}
普通对象：${stu.name} 底层调用getName()方法
List集合: ${list[下标]} 从0开始
Map集合：${map[key值]}
El内置对象
el表达式 jsp语法
*${pageContext} <%=pageContext%>
${pageScope.name} <%=pageContext.getAttribute("name")%>
${requestScope.name} <%=request.getAtribute("name")%>
${sessionScope.name} <%=session.getAtribute("name")%>
${applicationScope.name} <%=application.getAttribute("name")%>
${param['name']} <%=request.getParameter("name")%>
${paramValues['name']} <%=request.getParameterValues("name")%>
${header['user-agent']} <%=request.getHeader("user-agent")%>
${headerValues['user-agent']} <%=request.getHeaders("user-agent")%>
${cookie['JSESSIONID']} <%=request.getCookies() xxxx%>
${initParam['name']} <%=application.getInitParameter("name")%>
自定义标签
1：普通的类继承simpleTagSupport,重写doTag()方法。
用getJspContext();获取pageContext对象，获取后就能通过pageContext获取里面的8个对象。
2：在web-inf建立tld文件
<taglib>
<!-- 标签库版本 -->
<tlib-version>1.0</tlib-version>
<!-- jsp的版本 -->
<jsp-version>1.2</jsp-version>
<!-- 建议的前缀 -->
<short-name>itcast</short-name>
<!-- tld文件的唯一名称 -->
<uri>http://gz.itcast.cn</uri>
<!-- 一个标签的声明 -->
<tag>//需要在导入只需要在添加tag就行
<!-- 标签名称 -->
<name>showip</name>
<!-- 标签处理类的名称（包+类） -->
<tag-class>gz.itcast.tags.ShowIPTag</tag-class>
<!-- 标签内容的类型 -->
<body-content>scriptless</body-content>
</tag>
</taglib>
3：在jsp文件先导入
<%@ taglib uri=”tld里面设置的地址” prefix=”前缀名” %>
标签的作用
1）控制标签内容是否显示
显示：执行getJspBody().invoke(null)
不显示： 什么都不做！
2）控制标签余下的内容是否显示
显示：什么都不做！
不显示： 抛出一个SkipPageException即可
3）控制标签内容重复显示
for(int i=1;i<=num;i++){
getJspBody().invoke(null);
}
添加属性：
1）在标签处理类中添加一个setXXX方法
//必须使用setXXX()方法：获取属性值
public void setNum(int num){
this.num = num;
}
改变标签内容
//1.获取标签内容
JspFragment jspBody = getJspBody();
//2.创建一个临时的输出流
StringWriter sw = new StringWriter();
//3.把标签内容写入到临时输出流中
jspBody.invoke(sw);
//4.从临时的输出流取出标签内容
String content = sw.toString();
//5.改变
content = content.toUpperCase();
//6.手动输出给浏览器看
//jspBody.invoke(null);
getJspContext().getOut().write(content);//让jsp调用
