Java Web笔记

HTML

• 关于标签

1. 标签的格式:
   <标签名>封装的数据</标签名>
2. 标签名大小写不敏感。
3. 标签拥有自己的属性。
   i. 分为基本属性： bgcolor=“red” 可以修改简单的样式效果
   ii. 事件属性： οnclick=“alert(‘你好！’);” 可以直接设置事件响应后的代码。
4. 标签又分为，单标签和双标签。
   i. 单标签格式： <标签名 /> br 换行 hr 水平线
   ii. 双标签格式: <标签名> …封装的数据…</标签名>

CSS

• HTML中使用CSS的三种方式

1. 在标签的 style 属性上设置”key:value value;”，修改标签样式
2. 在 head 标签中，使用 style 标签来定义各种自己需要的 css 样式。
   格式如下：

xxx {
	Key : value value;
}

3. 把 css 样式写成一个单独的 css 文件，再通过 link 标签引入即可复用。

<link rel="stylesheet" type="text/css" href="./styles.css" /> 

• 选择器

1. 标签名选择器
2. id选择器
3. class选择器
4. 组合选择器

JavaScript

一、JS介绍

1. 交互性（它可以做的就是信息的动态交互）
2. 安全性（不允许直接访问本地硬盘）
3. 跨平台性（只要是可以解释 JS 的浏览器都可以执行，和平台无关）

二、JS结合HTML两种方式

1. 标签<script type="text/javascript"></script>
2. 引入<script type="text/javascript" src="...."></script>

三、JS数据类型

数值类型：number
字符串类型：string
对象类型：object			
布尔类型：boolean
函数类型：function

特殊的值：undefined、null、NAN

四、运算符

等于：==
全等于：===

&&：真：返回最后；
	假：返回第一个假			
||：真：返回第一个真；
	假：返回最后一个假
！

0、undefined、null、""都是false

五、数组

var arr = [];
var arr = [1,"abc","true"];

六、函数

1. 定义方式一：

function func(形参列表){
	函数体；
	return ....;
}

2. 定义方式二：

var func = function(形参列表){
	函数体；
	return ...;
}

• 不支持重载，会直接覆盖原函数
• arguments隐形参数---->类比java中的可变形参
• JS函数可以嵌套定义---->java不能

七、自定义对象

1. Object形式：

var  obj = new Object();
obj.属性 = 值；
obj.函数 = function(){}

2. 花括号形式：

var obj = {
	obj.属性 = 值,
	obj.函数 = function(){}	
};
	     

八、关于事件

1. 常见事件：onload、onclick、onblur、onchange、onsubmit(静态加return)
2. 事件注册：

静态注册：通过HTML标签
<button onclick="func()"></button>
动态注册：通过js获取DOM对象，再DOM对象.事件名 = function(){}

九、DOM

document对象

1. document 它管理了所有的 HTML 文档内容。
2. document 它是一种树结构的文档。有层级关系。
3. 它让我们把所有的标签都对象化
4. 我们可以通过 document访问所有的标签对象。

document中的方法

document.getElementById(elementId)
通过标签的 id 属性查找标签 dom 对象，elementId 是标签的 id 属性值

document.getElementsByName(elementName)
通过标签的 name 属性查找标签 dom 对象，elementName 标签的 name 属性值

document.getElementsByTagName(tagname)
通过标签名查找标签 dom 对象。tagname 是标签名

document.createElement( tagName)
通过给定的标签名，创建一个标签对象。tagName 是要创建的标签名

注意点：

• document 对象的三个查询方法，如果有 id 属性，优先使用getElementById 方法来进行查询
• 如果没有 id 属性，则优先使用 getElementsByName 方法来进行查询
• 如果 id 属性和 name 属性都没有最后再按标签名查getElementsByTagName
• 以上三个方法，一定要在页面加载完成之后执行，才能查询到标签对象

节点的常用属性和方法

• 方法：

通过具体的元素节点调用getElementsByTagName()方法，获取当前节点的指定标签名孩子节点

appendChild( oChildNode )方法，可以添加一个子节点，oChildNode 是要添加的孩子节点

• 属性：

childNodes
属性，获取当前节点的所有子节点
firstChild
属性，获取当前节点的第一个子节点
lastChild
属性，获取当前节点的最后一个子节点
parentNode
属性，获取当前节点的父节点
nextSibling
属性，获取当前节点的下一个节点
previousSibling
属性，获取当前节点的上一个节点
className
用于获取或设置标签的 class 属性值
innerHTML
属性，表示获取/设置起始标签和结束标签中的内容
innerText
属性，表示获取/设置起始标签和结束标签中的文本

jQuery

一、jQuery核心函数

• $ 是 jQuery 的核心函数，能完成 jQuery 的很多功能。$()就是调用$这个函数

1. 传入参数为 [ 函数 ] 时：
   表示页面加载完成之后。相当于 window.onload = function(){}
2. 传入参数为 [ HTML 字符串 ] 时：
   会对我们创建这个 html 标签对象
3. 传入参数为 [ 选择器字符串 ] 时：

$("#id 属性值"); id 选择器，根据 id 查询标签对象
$("标签名"); 标签名选择器，根据指定的标签名查询标签对象
$(".class 属性值"); 类型选择器，可以根据 class 属性查询标签对象

4. 传入参数为 [ DOM 对象 ] 时：
   会把这个 dom 对象转换为 jQuery 对象

二、jQuery对象与DOM对象区分

• DOM 对象

1. 通过 getElementById()查询出来的标签对象是 Dom 对象
2. 通过 getElementsByName()查询出来的标签对象是 Dom 对象
3. 通过 getElementsByTagName()查询出来的标签对象是 Dom 对象
4. 通过 createElement() 方法创建的对象，是 Dom 对象

DOM 对象 Alert 出来的效果是： [object HTML 标签名 Element]

• jQuery 对象

1. 通过 JQuery 提供的 API 创建的对象，是 JQuery 对象
2. 通过 JQuery 包装的 Dom 对象，也是 JQuery 对象
3. 通过 JQuery 提供的 API 查询到的对象，是 JQuery 对象

jQuery 对象 Alert 出来的效果是：[object Object]

• jQuery对象的本质： dom 对象的数组 + jQuery 提供的一系列功能函数

• jQuery对象与DOM对象的使用区别

  jQuery 对象不能使用 DOM 对象的属性和方法
  DOM 对象也不能使用 jQuery 对象的属性和方法

• DOM对象和jQuery互转：

$(DOM对象)--->jQuery对象
jQuery对象[index]--->DOM对象

三、jQuery选择器

1. 基础选择器----id,class,标签,组合

#ID 选择器：根据 id 查找标签对象
.class 选择器：根据 class 查找标签对象
element 选择器：根据标签名查找标签对象
* 选择器：表示任意的，所有的元素
selector1，selector2 组合选择器：合并选择器 1，选择器 2 的结果并返回

2. 层级选择器

ancestor descendant 后代选择器 ：在给定的祖先元素下匹配所有的后代元素
parent > child 子元素选择器：在给定的父元素下匹配所有的子元素
prev + next 相邻元素选择器：匹配所有紧接在 prev 元素后的 next 元素
prev ~ sibings 之后的兄弟元素选择器：匹配 prev 元素之后的所有 siblings 元素

3. 过滤选择器

• 基本过滤器

:first 获取第一个元素
:last 获取最后个元素
:not(selector) 去除所有与给定选择器匹配的元素
:even 匹配所有索引值为偶数的元素，从 0 开始计数
:odd 匹配所有索引值为奇数的元素，从 0 开始计数
:eq(index) 匹配一个给定索引值的元素
:gt(index) 匹配所有大于给定索引值的元素
:lt(index) 匹配所有小于给定索引值的元素
:header 匹配如 h1, h2, h3 之类的标题元素
:animated 匹配所有正在执行动画效果的元素

• 内容过滤器

:contains(text) 匹配包含给定文本的元素
:empty 匹配所有不包含子元素或者文本的空元素
:parent 匹配含有子元素或者文本的元素
:has(selector) 匹配含有选择器所匹配的元素的元素

• 属性过滤器

[attribute] 匹配包含给定属性的元素。
[attribute=value] 匹配给定的属性是某个特定值的元素
[attribute!=value] 匹配所有不含有指定的属性，或者属性不等于特定值的元素。
[attribute^=value] 匹配给定的属性是以某些值开始的元素
[attribute$=value] 匹配给定的属性是以某些值结尾的元素
[attribute*=value] 匹配给定的属性是以包含某些值的元素
[attrSel1][attrSel2][attrSelN] 复合属性选择器，需要同时满足多个条件时使用

• 表单过滤器

input 匹配所有 input, textarea, select 和 button 元素
:text 匹配所有 文本输入框
:password 匹配所有的密码输入框
:radio 匹配所有的单选框
:checkbox 匹配所有的复选框
:submit 匹配所有提交按钮
:image 匹配所有 img 标签
:reset 匹配所有重置按钮
:button 匹配所有 input type=button <button>按钮
:file 匹配所有 input type=file 文件上传
:hidden 匹配所有不可见元素 display:none 或 input type=hidden

• 表单对象属性过滤器

:enabled 匹配所有可用元素
:disabled 匹配所有不可用元素
:checked 匹配所有选中的单选，复选，和下拉列表中选中的option  标签对象
:selected 的 匹配所有选中的 option

四、jQuery元素筛选

eq() 获取给定索引的元素 功能跟 :eq() 一样
first() 获取第一个元素 功能跟 :first 一样
last() 获取最后一个元素 功能跟 :last 一样
filter(exp) 留下匹配的元素
is(exp) 判断是否匹配给定的选择器，只要有一个匹配就返回，true
has(exp) 返回包含有匹配选择器的元素的元素 功能跟 :has 一样
not(exp) 删除匹配选择器的元素 功能跟 :not 一样
children(exp) 返回匹配给定选择器的子元素 功能跟 parent>child 一样
find(exp) 返回匹配给定选择器的后代元素 功能跟 ancestor descendant 一样
next() 返回当前元素的下一个兄弟元素 功能跟 prev + next 功能一样
nextAll() 返回当前元素后面所有的兄弟元素 功能跟 prev ~ siblings 功能一样
nextUntil() 返回当前元素到指定匹配的元素为止的后面元素
parent() 返回父元素
prev(exp) 返回当前元素的上一个兄弟元素
prevAll() 返回当前元素前面所有的兄弟元素
prevUnit(exp) 返回当前元素到指定匹配的元素为止的前面元素
siblings(exp) 返回所有兄弟元素
add() 把 add 匹配的选择器的元素添加到当前 jquery 对象中

day02

五、jQuery的属性操作

html() 它可以设置和获取起始标签和结束标签中的内容。 跟 dom 属性 innerHTML 一样。
text() 它可以设置和获取起始标签和结束标签中的文本。 跟 dom 属性 innerText 一样。
val() 它可以设置和获取表单项的 value 属性值。 跟 dom 属性 value 一样

attr() 可以设置和获取属性的值，不推荐操作 checked、readOnly、selected、disabled 等等
attr 方法还可以操作非标准的属性。比如自定义属性：abc,bbj

prop() 可以设置和获取属性的值,只推荐操作 checked、readOnly、selected、disabled 等

六、DOM的增删改

内插入：

appendTo() a.appendTo(b) 把 a 插入到 b 子元素末尾，成为最后一个子元素
prependTo() a.prependTo(b) 把 a 插到 b 所有子元素前面，成为第一个子元

外插入：

insertAfter() a.insertAfter(b) 得到 ba
insertBefore() a.insertBefore(b) 得到 ab
	

替换：

replaceWith() a.replaceWith(b) 用 b 替换掉 a
replaceAll() a.replaceAll(b) 用 a 替换掉所有 b

删除：

remove() a.remove(); 删除 a 标签
empty() a.empty(); 清空 a 标签里的内容

七、jQuery中css样式操作

addClass() 添加样式
removeClass() 删除样式
toggleClass() 有就删除，没有就添加样式。
offset() 获取和设置元素的坐标

八、jQuery动画

• 基本动画

show() 将隐藏的元素显示
hide() 将可见的元素隐藏。
toggle() 可见就隐藏，不可见就显示

以上动画方法都可以添加参数。

1. 第一个参数是动画 执行的时长，以毫秒为单位
2. 第二个参数是动画的回调函数 (动画完成后自动调用的函数)

• 淡入淡出动画

fadeIn() 淡入（慢慢可见）
fadeOut() 淡出（慢慢消失）
fadeTo() 在指定时长内慢慢的将透明度修改到指定的值。0 透明，1 完成可见，0.5 半透明
fadeToggle() 淡入/淡出 切换

九、jQuery事件

1.$( function(){} );和window.onload = function(){}的区别

他们分别是在什么时候触发？

• jQuery 的页面加载完成之后是浏览器的内核解析完页面的标签创建好 DOM 对象之后就会马上执行。
• 原生 js 的页面加载完成之后，除了要等浏览器内核解析完标签创建好 DOM 对象，还要等标签显示时需要的内容加载完成

他们触发的顺序？

• jQuery 页面加载完成之后先执行
• 原生 js 的页面加载完成之后

他们执行的次数？

• 原生 js 的页面加载完成之后，只会执行最后一次的赋值函数。
• jQuery 的页面加载完成之后是全部把注册的 function 函数，依次顺序全部执行

2. jQuery中的各种事件处理方法

click() 它可以绑定单击事件，以及触发单击事件
mouseover() 鼠标移入事件
mouseout() 鼠标移出事件
bind() 可以给元素一次性绑定一个或多个事件。
one() 使用上跟 bind 一样。但是 one 方法绑定的事件只会响应一次。
unbind() 跟 bind 方法相反的操作，解除事件的绑定
live() 也是用来绑定事件。它可以用来绑定选择器匹配的所有元素的事件。哪怕这个元素是后面动态创建出来的也有效

3. 关于事件冒泡
   事件的冒泡是指，父子元素同时监听同一个事件。当触发子元素的事件的时候，同一个事件也被传递到了父元素的事件里去响应，在子元素事件函数体内，return false; 可以阻止事件的冒泡传递
4. 关于事件对象
   在给元素绑定事件的时候，在事件的 function( event ) 参数列表中添加一个参数，这个参数名，我们习惯取名为 event，这个 event 就是 javascript 传递参事件处理函数的事件对象，绑定多个事件时，可以借事件对象判断哪个事件触发的

XML

XML语法

1. 所有 XML 元素都须有关闭标签 （也就是闭合）
2. XML 标签对大小写敏感
3. XML 必须正确地嵌套
4. XML文档必须有根元素
5. XML的属性值须加引号
6. XML中的特殊字符，如>
7. 文本区域（CDATA 区）:
   CDATA 语法可以告诉 xml 解析器，我 CDATA 里的文本内容，只是纯文本，不需要 xml 语法解析

CDATA 格式：
<![CDATA[ 这里可以把你输入的字符原样显示，不会解析 xml ]]>

dom4j解析技术

xml 可扩展的标记语言。不管是 html 文件还是 xml 文件它们都是标记型文档，都可以使用 w3c 组织制定的 dom 技术来解析

• dom4j 编程步骤：

1. 先加载 xml 文件创建 Document 对象
2. 通过 Document 对象拿到根元素对象
3. 通过根元素.elelemts(标签名); 可以返回一个集合，这个集合里放着。所有你指定的标签名的元素对象
4. 找到你想要修改、删除的子元素，进行相应在的操作
5. 保存到硬盘上

// 第一步，通过创建 SAXReader 对象。来读取 xml 文件，获取 Document 对象
SAXReader reader = new SAXReader();
Document document = reader.read("src/books.xml");
// 第二步，通过 Document 对象。拿到 XML 的根元素对象
Element root = document.getRootElement();
// 打印测试
// Element.asXML() 它将当前元素转换成为 String 对象
// System.out.println( root.asXML() );
// 第三步，通过根元素对象。获取所有的 book 标签对象
// Element.elements(标签名)它可以拿到当前元素下的指定的子元素的集合
List<Element> books = root.elements("book");
// 第四小，遍历每个 book 标签对象。然后获取到 book 标签对象内的每一个元素，
for (Element book : books) {
	// 测试
	// System.out.println(book.asXML());
	// 拿到 book 下面的 name 元素对象
	Element nameElement = book.element("name");
	// 拿到 book 下面的 price 元素对象
	Element priceElement = book.element("price");
	// 拿到 book 下面的 author 元素对象
	Element authorElement = book.element("author");
	// 再通过 getText() 方法拿到起始标签和结束标签之间的文本内容
	System.out.println("书名" + nameElement.getText() + " , 价格:"
	+ priceElement.getText() + ", 作者：" + authorElement.getText());
}

Tomcat

Tomcat服务器和Servlet版本的对应关系

Servlet 程序从 2.5 版本是现在世面使用最多的版本（xml 配置）
到了 Servlet3.0 之后。就是注解版本的 Servlet 使用

Tomcat的使用

Servlet

一、什么是Servlet

1. Servlet 是 JavaEE 规范之一。规范就是接口
2. Servlet 就 JavaWeb 三大组件之一。三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。
3. Servlet 是运行在服务器上的一个 java 小程序，它可以接收客户端发送过来的请求，并响应数据给客户端

二、通过实现Servlet接口实现Servlet程序(方法一)

1. 编写一个类去实现 Servlet 接口
2. 实现 service 方法，处理请求，并响应数据
3. 到 web.xml 中去配置 servlet 程序的访问地址

<!-- servlet 标签给 Tomcat 配置 Servlet 程序 -->
<servlet>
<!--servlet-name 标签 Servlet 程序起一个别名（一般是类名） -->
<servlet-name>HelloServlet</servlet-name>
<!--servlet-class 是 Servlet 程序的全类名 -->
<servlet-class>com.atguigu.servlet.HelloServlet</servlet-class>
</servlet>
<!--servlet-mapping 标签给 servlet 程序配置访问地址 -->
<servlet-mapping>
<!--servlet-name 标签的作用是告诉服务器，我当前配置的地址给哪个 Servlet 程序使用 -->
<servlet-name>HelloServlet</servlet-name>
<!--url-pattern 标签配置访问地址 <br/>
/ 斜杠在服务器解析的时候，表示地址为： http://ip:port/ 工程路径 <br/>
/hello 表示地址为： http://ip:port/ 工程路径 /hello <br/>
-->
<url-pattern>/hello</url-pattern>
</servlet-mapping>

三、url访问到Servlet程序过程

四、Servlet生命周期—单例

1. 执行 Servlet 构造器方法
2. 执行 init 初始化方法
   第一、二步，是在第一次访问的时候创建 Servlet 程序会调用
3. 执行 service 方法
   第三步，每次访问都会调用。
4. 执行 destroy 销毁方法
   第四步，在 web 工程停止的时候调用。

五、Servlet请求分发

@Override
	public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
		System.out.println("3 service === Hello Servlet  被访问了");
		// 类型转换（因为它有 getMethod() 方法）
		HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
		// 获取请求的方式
		String method = httpServletRequest.getMethod();
		if ("GET".equals(method)) {
			doGet();
		} else if ("POST".equals(method)) {
			doPost();
		}
}

六、通过继承HttpServlet实现Servlet程序(方法二)

一般在实际项目开发中，都是使用继承 HttpServlet 类的方式去实现 Servlet 程序。

1. 编写一个类去继承 HttpServlet 类
2. 根据业务需要重写 doGet 或 doPost 方法
3. 到 web.xml 中的配置 Servlet 程序的访问地址

IDEA可以快速创建HttpServlet实现类

七、Servlet继承体系

八、ServletConfig类

• ServletConfig 类从类名上来看，就知道是 Servlet 程序的配置信息类。
• Servlet 程序和 ServletConfig 对象都是由 Tomcat 负责创建，我们负责使用。
• Servlet 程序默认是第一次访问的时候创建，ServletConfig是每个 Servlet 程序创建时，就创建一个对应的ServletConfig 对象
• 在init方法中才可以访问到数据，若重写init方法,必须调用super.init(config)
• 三大作用：
  1. 可以获取 Servlet 程序的别名 servlet-name 的值
  2. 获取初始化参数 init-param
  3. 获取 ServletContext 对象
• web.xml中配置：

<!--init-param 是初始化参数 -->
<init-param>
<!-- 是参数名 -->
<param-name>username</param-name>
<!-- 是参数值 -->
<param-value>root</param-value>
</init-param>
<!--init-param 是初始化参数 -->
<init-param>
<!-- 是参数名 -->
<param-name>url</param-name>
<!-- 是参数值 -->
<param-value>jdbc:mysql://localhost:3306/test</param-value>
</init-param>

九、ServletContext类

1. ServletContext 是一个接口，它表示 Servlet 上下文对象
2. 一个 web 工程，只有一个 ServletContext 对象实例。
3. ServletContext 对象是一个域对象。
   域对象，是可以像 Map 一样存取数据的对象，叫域对象。这里的域指的是存取数据的操作范围，整个 web 工程

域对象三个方法：
setAttribute();getAttribute();removeAttribute();

4. ServletContext 是在 web 工程部署启动的时候创建。在 web 工程停止的时候销毁

5. 四个作用：
   1. 获取 web.xml 中配置的上下文参数 context-param
   2. 获取当前的工程路径，格式: /工程路径
   3. 获取工程部署后在服务器硬盘上的绝对路径
   4. 像 Map 一样存取数据

<!--context-param 是上下文参数 ( 它属于整个 web 工程 )-->
<context-param>
<param-name>username</param-name>
<param-value>context</param-value>
</context-param>
<!--context-param 是上下文参数 ( 它属于整个 web 工程 )-->
<context-param>
<param-name>password</param-name>
<param-value>root</param-value>
</context-param>

十、Http协议

请求的格式

1. GET

   • 请求行：
     (1) 请求的方式
     (2) 请求的资源路径[+?+请求参数]
     (3) 请求的协议的版本号
   • 请求头：
     key : value 组成 不同的键值对，表示不同的含义

   GET 请求有哪些：
   1、form 标签 method=get
   2、a 标签
   3、link 标签引入 css
   4、Script 标签引入 js 文件
   5、img 标签引入图片
   6、iframe 引入 html 页面
   7、在浏览器地址栏中输入地址后敲回车

2. POST：

   • 请求行：
     (1) 请求的方式
     (2) 请求的资源路径[+?+请求参数]
     (3) 请求的协议的版本号
   • 请求头：
     key : value 组成 不同的键值对，表示不同的含义
   • 空行
   • 请求体：即发送给服务端的内容，key=value&key=value

   POST 请求有哪些：
   form 标签 method=post

响应的格式

1. 响应行：
   (1) 响应的协议和版本号
   (2) 响应状态码
   (3) 响应状态描述符
2. 响应头：
   key : value 不同的响应头，有其不同含义
3. 空行
4. 响应体：返回给客户端的内容

常见响应码

200 表示请求成功
302 表示请求重定向（明天讲）
404 表示请求服务器已经收到了，但是你要的数据不存（请求地址错误）
500 表示服务器已经收到请求，但是服务器内部错误（代码错误）

MIME类型说明

HTTP协议中的数据类型 大类型/小类型

十一、HttpServletRequest类

作用

每次只要有请求进入 Tomcat 服务器，Tomcat 服务器就会把请求过来的 HTTP 协议信息解析好封装到 Request 对象中。然后传递到 service 方法（doGet 和 doPost）中给我们使用。我们可以通过 HttpServletRequest 对象，获取到所有请求的信息

常用方法

getRequestURI() 获取请求的资源路径
getRequestURL() 获取请求的统一资源定位符（绝对路径）
getRemoteHost() 获取客户端的 ip 地址
getHeader() 获取请求头
getParameter() 获取请求的参数
getParameterValues() 获取请求的参数（多个值的时候使用）
getMethod() 获取请求的方式 GET 或 POST
setAttribute(key, value); 设置域数据
getAttribute(key); 获取域数据
getRequestDispatcher() 获取请求转发对象

//解决中文乱码，必须在获取前使用
req.setCharacterEncoding("UTF-8");

十二、请求的转发

请求转发是指，服务器收到请求后，从一次资源跳转到另一个资源的操作叫请求转发

//Servlet1
String username = req.getParameter("username");
System.out.println(username);
req.setAttribute("key1"," 柜台 1  的章");
RequestDispatcher requestDispatcher =req.getRequestDispatcher("/servlet2");
requestDispatcher.forward(req,resp);

//Servlet2
String username = req.getParameter("username");
System.out.println(username);
Object key1 = req.getAttribute("key1");
System.out.println(" Servlet1 是否有章：" + key1);
System.out.println("Servlet2处理自己的业务 ");

十三、base标签的作用：

相对路径默认参照浏览器地址栏，可以在html的head中添加base标签作为当前页面所有相对路径的参照

十四、Java Web中的绝对路径和相对路径

1. 绝对路径：
   

2. base+相对

十五、web 中斜杠的不同意义

在 web 中 / 斜杠 是一种绝对路径。

• 如果被浏览器解析，得到的地址是：http://ip:port/

• 如果被服务器解析，得到的地址是：http://ip:port/工程路径

1、<url-pattern>/servlet1</url-pattern>
2、servletContext.getRealPath("/");
3、request.getRequestDispatcher("/");

• 特殊情况： response.sendRediect(“/”); 把斜杠发送给浏览器解析。得到 http://ip:port/

十六、HttpServletResponse类

作用

HttpServletResponse 类和 HttpServletRequest 类一样。每次请求进来，Tomcat 服务器都会创建一个 Response 对象传递给 Servlet 程序去使用。HttpServletRequest 表示请求过来的信息，HttpServletResponse 表示所有响应的信息，我们如果需要设置返回给客户端的信息，都可以通过HttpServletResponse 对象来进行设置

两个输出流

字节流 getOutputStream(); 常用于下载（传递二进制数据）
字符流 getWriter(); 常用于回传字符串（常用）
//不能同时使用

使用

//设置字符集方式一
// 设置服务器字符集为 UTF-8
//resp.setCharacterEncoding("UTF-8");
// 通过响应头，设置浏览器也使用 UTF-8 字符集
//resp.setHeader("Content-Type", "text/html; charset=UTF-8");
//方式二：
resp.setContentType("text/html; charset=UTF-8");
PrintWriter writer = resp.getWriter();
writer.write("response's content!!!");

十七、请求重定向

方式一：

// 设置响应状态码 302 ，表示重定向，（已搬迁）
resp.setStatus(302);
// 设置响应头，说明 新的地址在哪里
resp.setHeader("Location", "http://localhost:8080/project/Servlet2");

方式二：

resp.sendRedirect("http://localhost:8080");

Java EE 的三层架构

分层的目的是为了解耦。解耦就是为了降低代码的耦合度。方便项目后期的维护和升级

JSP

什么是JSP：Java Server Pages

代替 Servlet 程序回传 html 页面的数据

jsp页面的本质

第一次访问 jsp 页面的时候。Tomcat 服务器会把 jsp 页面翻译成为一个 java 源文件，并且对它进行编译成为.class 字节码程序，jsp本质就是一个Servlet程序，其继承了HttpJspBase 类，间接地继承了HttpServlet类

jsp头部的page指令

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

1. language 属性表示 jsp 翻译后是什么语言文件。暂时只支持 java
2. contentType 属性表示 jsp 返回的数据类型是什么。也是源码中 response.setContentType()参数值
3. pageEncoding 属性表示当前 jsp 页面文件本身的字符集。
4. import 属性跟 java 源代码中一样。用于导包，导类。
5. autoFlush 属性 设置当 out 输出流缓冲区满了之后，是否自动刷新冲级区。默认值是 true。
6. buffer 属性设置 out 缓冲区的大小。默认是 8kb
7. errorPage 属性设置当 jsp 页面运行时出错，自动跳转去的错误页面路径
8. isErrorPage 属性 设置当前 jsp 页面是否是错误信息页面。默认是 false。如果是 true 可以获取异常信息
9. session 属性 设置访问当前 jsp 页面，是否会创建HttpSession 对象。默认是 true。
10. extends 属性 设置 jsp 翻译出来的 java 类默认继承谁

jsp中常用脚本

声明脚本(极少使用)

作用：可以给 jsp 翻译出来的 java 类定义属性和方法甚至是静态代码块。内部类等

 <%! 声明 java 代码 %>

表达式脚本(常用)

作用：在页面上输出数据

<%=表达式%>

表达式脚本的特点：

1. 所有的表达式脚本都会被翻译到_jspService() 方法中
2. 表达式脚本都会被翻译成为 out.print()输出到页面上
3. 由于表达式脚本翻译的内容都在_jspService() 方法中,所以_jspService()方法中的对象都可以直接使用。
4. 表达式脚本中的表达式不能以分号结束

代码脚本

作用：可以在 jsp 页面中，编写我们自己需要的功能（写的是 java 语句）

<%
java 语句
%>

代码脚本的特点是：

1. 代码脚本翻译之后都在_jspService 方法中
2. 代码脚本由于翻译到_jspService()方法中，所以在_jspService()方法中的现有对象都可以直接使用。
3. 还可以由多个代码脚本块组合完成一个完整的 java 语句。
4. 代码脚本还可以和表达式脚本一起组合使用，在 jsp 页面上输出数据

jsp中三种注释

html注释

java注释

jsp注释

<%--   jsp注释可以注释页面中的一切  --%>

jsp中九大内置对象

九大内置对象

jsp 中的内置对象，是指 Tomcat 在翻译 jsp 页面成为 Servlet源代码后，内部提供的九大对象，叫内置对象

四个域对象及其有效范围

pageContext (PageContextImpl 类)：当前 jsp 页面范围内有效
request (HttpServletRequest 类)：一次请求内有效
session (HttpSession 类)：一个会话范围内有效（打开浏览器访问服务器，直到关闭浏览器）
application (ServletContext 类)：整个 web 工程范围内都有效（只要 web 工程不停止，数据都在）

四个域在使用的时候，优先顺序分别是，他们从小到大的范围的顺序：

pageContext --> request --> session --> application

jsp 中的out输出对比response.getWriter 输出

out.write()和out.print()区别：

out.write() 输出字符串没有问题
out.print() 输出任意数据都没有问题（都转换成为字符串后调用的 write 输出

jsp中常用标签

jsp静态包含

<%@ include   file="/..."    %>

静态包含的特点：
1 . 静态包含不会翻译被包含的 jsp 页面。
2 . 静态包含其实是把被包含的 jsp 页面的代码拷贝到包含的位置执行输出

jsp动态包含

<jsp:include page="/..."></jsp:include>

动态包含的特点：

1. 动态包含会把包含的 jsp 页面也翻译成为 java 代码
2. 动态包含底层代码使用如下代码去调用被包含的 jsp 页面执行输出。

JspRuntimeLibrary.include(request, response,"/include/footer.jsp", out, false);

3. 动态包含，还可以传递参数

4. 动态包含底层原理：
   

jsp标签-转发

<jsp:forward page=""></jsp:forward> 对应servlet中req.getRequestDispatcher(" ...").forward(req,resp);

EL

EL(Expression Language)

作用：EL 表达式主要是代替 jsp 页面中的表达式脚本在 jsp 页面中进行数据的输出，因为 EL 表达式在输出数据的时候，要比 jsp 的表达式脚本要简洁很多

${表达式}

注：EL 表达式在输出 null 值的时候，输出的是空串。jsp 表达式脚本输出 null 值的时候，输出的是 null 字符串

EL表达式搜索四个域的顺序

EL 表达式主要是在 jsp 页面中输出数据，主要是输出域对象中的数据。
当四个域中都有相同的 key 的数据的时候，EL 表达式会按照四个域的从小到大的顺序去进行搜索，找到就输出

EL表达式的使用

${ 变量.属性 }中的属性对应该属性的get方法或is方法

输出 Person：${ p }<br/>
输出 Person 的 name 属性：${p.name} <br>
输出 Person 的 pnones 数组属性值：${p.phones[2]} <br>
输出 Person 的 cities 集合中的元素值：${p.cities} <br>
输出 Person 的 List 集合中个别元素值：${p.cities[2]} <br>
输出 Person 的 Map 集合: ${p.map} <br>
输出 Person 的 Map 集合中某个 key 的值: ${p.map.key3} <br>
输出 Person 的 age 属性：${p.age} <br>

EL表达式的各种运算

1. 关系运算
2. 逻辑运算
3. 算数运算
4. empty运算

   以下几种情况为空：
   1、值为 null 值的时候，为空
   2、值为空串的时候，为空
   3、值是 Object 类型数组，长度为零的时候
   4、list 集合，元素个数为零
   5、map 集合，元素个数为零

${ empty 变量 } 

5. 三元运算
6. “ . ”点运算和[ ]中括号运算符

EL表达式中的11个隐含对象

EL 个达式中 11 个隐含对象，是 EL 表达式中自己定义的，可以直接使用

EL获取四个特定域中的属性

<body>
<%
	pageContext.setAttribute("key1", "pageContext1");
	pageContext.setAttribute("key2", "pageContext2");
	request.setAttribute("key2", "request");
	session.setAttribute("key2", "session");
	application.setAttribute("key2", "application");
%>
${ applicationScope.key2 }
</body>

pageContext对象

1. 协议：
2. 服务器 ip：
3. 服务器端口：
4. 获取工程路径：
5. 获取请求方法：
6. 获取客户端 ip 地址：
7. 获取会话的 id 编号

1.协议： ${ req.scheme }<br>
2.服务器 ip：${ pageContext.request.serverName }<br>
3.服务器端口：${ pageContext.request.serverPort }<br>
4.获取工程路径：${ pageContext.request.contextPath }<br>
5.获取请求方法：${ pageContext.request.method }<br>
6.获取客户端 ip 地址：${ pageContext.request.remoteHost }<br>
7.获取会话的 id 编号：${ pageContext.session.id }<br>

其他

请求地址：http://localhost:8080/09_EL_JSTL/other_el_obj.jsp?username=wzg168&password=666666&hobby=java&hobby=cpp

输出请求参数 username 的值：${ param.username } <br>
输出请求参数 password 的值：${ param.password } <br>
输出请求参数 username 的值：${ paramValues.username[0] } <br>
输出请求参数 hobby 的值：${ paramValues.hobby[0] } <br>
输出请求参数 hobby 的值：${ paramValues.hobby[1] } <br>

输出请求头【User-Agent】的值：${ header['User-Agent'] } <br>
输出请求头【Connection】的值：${ header.Connection } <br>
输出请求头【User-Agent】的值：${ headerValues['User-Agent'][0] } <br>

获取 Cookie 的名称：${ cookie.JSESSIONID.name } <br>
获取 Cookie 的值：${ cookie.JSESSIONID.value } <br>

输出<Context-param>中username 的值：${ initParam.username } <br>
输出<Context-param>中url 的值：${ initParam.url } <br

JSTL

JSTL(JSP Standard Tag Library)

JSP 标准标签库是为了替换代码脚本，这样使得整个 jsp 页面变得更加简洁
JSTL 由五个不同功能的标签库组成：

使用JSTL标签库步骤

1. 先导入 jstl 标签库的 jar 包。
   taglibs-standard-impl-1.2.1.jar
   taglibs-standard-spec-1.2.1.jar
2. 使用 taglib 指令引入标签库。

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

core核心库

<c:set />

<c:set scope="session" var="key1" value="value1"/>
${ sessionScope.key1 } <br>

<c:if />

<c:if  test="${ 12 == 12 }"></c:if>

<c:choose> <c:when> <c:otherwise>

<c:choose>
	<c:when test="EL表达式1">
	操作1...
	</c:when>
	<c:when test="EL表达式2">
	操作2...
	</c:when>
	<c:otherwise>
		<c:choose>
			<c:when test="EL表达式3">
			操作3...
			</c:when>
			<c:otherwise>
			其他操作...
			</c:otherwise>
		</c:choose>
	</c:otherwise>
</c:choose>

<c:forEach />

• 遍历i：

<c:forEach bedin="0"  end="9" var="i">
	${i}
</c:forEach>

• 遍历数组：

<c:forEach items="${requestScope.arr}" var="item">
	${item}
</c:forEach>

• 遍历map:

<c:forEach items="${requestScope.map}" var = "e">
    ${e.key}+${e.value}<br/>
</c:forEach>

• 遍历list:

<c:forEach items="${requestScope.list}" var="item">
 	${item.id}<br>
 	${item.name}<br>
 	${item.age}<br>
</c:forEach>

Listener监听器

Listener监听器是什么

1. JavaWeb 的三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。
2. Listener 它是 JavaEE 的规范，就是接口
3. 监听器的作用是，监听某种事物的变化。然后通过回调函数，反馈给客户（程序）去做一些相应的处理

ServletContextListener 监听器

1. ServletContextListener 它可以监听 ServletContext 对象的创建和销毁。
2. ServletContext 对象在 web 工程启动的时候创建，在 web 工程停止的时候销毁。
3. 监听到创建和销毁之后都会分别调用ServletContextListener监听器的方法反馈
4. 使用：

1、编写一个类去实现 ServletContextListener
2、实现其两个回调方法
3、到 web.xml 中去配置监听器

<!-- 配置监听器 -->
<listener>
<listener-class>com.atguigu.listener.MyServletContextListenerImpl</listener-class>
</listener>

文件上传下载

文件上传

文件上传步骤

1. 要有一个 form 标签，method=post 请求
2. form 标签的 encType 属性值必须为 multipart/form-data 值
3. 在 form 标签中使用 input type=file 添加上传的文件
4. 编写服务器代码（Servlet 程序）接收，处理上传的数据。encType=multipart/form-data 表示提交的数据，以多段（每一个表单项一个数据段）的形式进行拼接，然后以二进制流的形式发送给服务器

文件上传中HTTP协议内容分析:

文件上传的处理：

1. 导入jar包：

commons-fileupload-1.2.1.jar
commons-io-1.4.jar

jar包中常用的类及方法：
ServletFileUpload 类，用于解析上传的数据。
FileItem 类，表示每一个表单项

boolean ServletFileUpload.isMultipartContent(HttpServletRequest request);
判断当前上传的数据格式是否是多段的格式。

public List<FileItem> parseRequest(HttpServletRequest request)
解析上传的数据

boolean FileItem.isFormField()
判断当前这个表单项，是否是普通的表单项。还是上传的文件类型。
true 表示普通类型的表单项
false 表示上传的文件类型

String FileItem.getFieldName()
获取表单项的 name 属性值

String FileItem.getString()
获取当前表单项的值。

String FileItem.getName();
获取上传的文件名

void FileItem.write( file );
将上传的文件写到 参数 file 所指向抽硬盘位置

2. Servlet程序编写代码

//1 先判断上传的数据是否多段数据（只有是多段的数据，才是文件上传的）
if (ServletFileUpload.isMultipartContent(req)) {
	// 创建 FileItemFactory 工厂实现类
	FileItemFactory fileItemFactory = new DiskFileItemFactory();
	// 创建用于解析上传数据的工具类 ServletFileUpload 类
	ServletFileUpload servletFileUpload = new ServletFileUpload(fileItemFactory);
	try {
		// 解析上传的数据，得到每一个表单项 FileItem
		List<FileItem> list = servletFileUpload.parseRequest(req);
		// 循环判断，每一个表单项，是普通类型，还是上传的文件
		for (FileItem fileItem : list) {
			if (fileItem.isFormField()) {
				// 普通表单项
				System.out.println(" 表单项的 name  属性值：" + fileItem.getFieldName());
				// 参数 UTF-8. 解决乱码问题
				System.out.println(" 表单项的 value  属性值：" + fileItem.getString("UTF-8"));
			} else {
				// 上传的文件
				System.out.println(" 表单项的 name  属性值：" + fileItem.getFieldName());
				System.out.println(" 上传的文件名：" + fileItem.getName());
				fileItem.write(new File("e:\\" + fileItem.getName()));
				}
		}
	} catch (Exception e) {
			e.printStackTrace();
	}
}

文件下载

代码示例：

@Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        1、获取要下载的文件名
        String downloadFileName = "2.jpg";
//        2、读取要下载的文件内容 (通过ServletContext对象可以读取)
        ServletContext servletContext = getServletContext();
        // 获取要下载的文件类型
        String mimeType = servletContext.getMimeType("/file/" + downloadFileName);
        System.out.println("下载的文件类型：" + mimeType);
//        4、在回传前，通过响应头告诉客户端返回的数据类型
        resp.setContentType(mimeType);
//        5、还要告诉客户端收到的数据是用于下载使用（还是使用响应头）
        // Content-Disposition响应头，表示收到的数据怎么处理
        // attachment表示附件，表示下载使用
        // filename= 表示指定下载的文件名
        // url编码是把汉字转换成为%xx%xx的格式
        if (req.getHeader("User-Agent").contains("Firefox")) {
            // 如果是火狐浏览器使用Base64编码
            resp.setHeader("Content-Disposition", "attachment; filename==?UTF-8?B?" + new BASE64Encoder().encode("中国.jpg".getBytes("UTF-8")) + "?=");
        } else {
            // 如果不是火狐，是IE或谷歌，使用URL编码操作
            resp.setHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode("中国.jpg", "UTF-8"));
        }
        /**
         * /斜杠被服务器解析表示地址为http://ip:prot/工程名/  映射 到代码的Web目录
         */
        InputStream resourceAsStream = servletContext.getResourceAsStream("/file/" + downloadFileName);
        // 获取响应的输出流
        OutputStream outputStream = resp.getOutputStream();
        //        3、把下载的文件内容回传给客户端
        // 读取输入流中全部的数据，复制给输出流，输出给客户端
        IOUtils.copy(resourceAsStream, outputStream);
    }

文件下载的处理：
解决中文问题：
URLEncoder.encode("",“UTF-8”); //解决谷歌、IE
关于Base64
Base64解决火狐

Cookie

Cookie是什么

1. Cookie 翻译过来是饼干的意思。
2. Cookie 是服务器通知客户端保存键值对的一种技术。
3. 客户端有了 Cookie 后，每次请求都发送给服务器。
4. 每个 Cookie 的大小不能超过 4kb

怎么创建Cookie

怎么获取Cookie

Cookie值的修改----->不支持特殊值

方案一:创建同名cookie

Cookie cookie = new Cookie("key1","newValue1");
resp.addCookie(cookie);

方案二：获取cookie并重新赋值

Cookie cookie = CookieUtils.findCookie("key2",req.getCookies());
if (cookie != null) {
	cookie.setValue("newValue2");
	resp.addCookie(cookie);
}

Cookie的生命周期控制

setMaxAge()
正数，表示在指定的秒数后过期
负数，表示浏览器一关，Cookie 就会被删除（默认值是-1）
零，表示马上删除 Cookie

Cookie有效路径Path

cookie.setPath( req.getContextPath() + "/abc" ); 

Session

Session是什么

1. Session 就一个接口（HttpSession）。
2. Session 就是会话。它是用来维护一个客户端和服务器之间关联的一种技术。
3. 每个客户端都有自己的一个 Session 会话。
4. Session 会话中，我们经常用来保存用户登录之后的信息。

创建和获取Session

request.getSession()
第一次调用是：创建 Session 会话
之后调用都是：获取前面创建好的 Session 会话对象

isNew(); 判断到底是不是刚创建出来的（新的）
true 表示刚创建
false 表示获取之前创建

每个会话都有一个身份证号。也就是 ID 值。而且这个 ID 是唯一的。
getId() 得到 Session 的会话 id 值

Session域对象存取数据

req.getSession().setAttribute("key1", "value1");

Object attribute = req.getSession().getAttribute("key1");

Session的生命周期控制

public void setMaxInactiveInterval(int interval) 设置 Session 的超时时间（以秒为单位），超过指定的时长，Session
就会被销毁。
值为正数的时候，设定 Session 的超时时长。
负数表示永不超时（极少使用）
public int getMaxInactiveInterval()获取 Session 的超时时间
public void invalidate() 让当前 Session 会话马上超时无效

Session 默认的超时时间长为 30 分钟。
因为在Tomcat服务器的配置文件web.xml中默认有以下的配置，它就表示配置了当前Tomcat服务器下所有的Session超时配置默认时长为：30 分钟。
<session-config>
<session-timeout>30</session-timeout>
</session-config>

Session超时的概念

浏览器与服务器session交互的底层细节

Session 技术，底层其实是基于 Cookie 技术来实现的

Filter过滤器

Filter是什么

1. Filter 过滤器它是 JavaWeb 的三大组件之一。三大组件分别是：Servlet 程序、Listener 监听器、Filter 过滤器
2. Filter 过滤器它是 JavaEE 的规范。也就是接口
3. Filter 过滤器它的作用是： 拦截请求，过滤响应。

拦截请求常见的应用场景有：

• 权限检查
• 日记操作
• 事务管理
  ……

Filter的使用

Filter 过滤器的使用步骤：

1. 编写一个类去实现 Filter 接口
2. 实现过滤方法 doFilter()

HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
HttpSession session = httpServletRequest.getSession();
Object user = session.getAttribute("user");
// 如果等于 null ，说明还没有登录
if (user == null) {
	servletRequest.getRequestDispatcher("/login.jsp").forward(servletRequest,servletResponse);
return;
} else {
	// 让程序继续往下访问用户的目标资源
	filterChain.doFilter(servletRequest,servletResponse);
}

3. 到 web.xml 中去配置 Filter 的拦截路径

<!--filter 标签用于配置一个 Filter 过滤器 -->
<filter>
<!-- 给 filter 起一个别名 -->
<filter-name>AdminFilter</filter-name>
<!-- 配置 filter 的全类名 -->
<filter-class>com.atguigu.filter.AdminFilter</filter-class>
</filter>
<!--filter-mapping 配置 Filter 过滤器的拦截路径 -->
<filter-mapping>
<!--filter-name 表示当前的拦截路径给哪个 filter 使用 -->
<filter-name>AdminFilter</filter-name>
<!--url-pattern 配置拦截路径
/ 表示请求地址为： http://ip:port/ 工程路径 / 映射到 IDEA 的 web 目录
/admin/* 表示请求地址为： http://ip:port/ 工程路径 /admin/*
-->
<url-pattern>/admin/*</url-pattern>
</filter-mapping

Filter的生命周期

Filter 的生命周期包含几个方法

1. 构造器方法
2. init 初始化方法
   第 1，2 步，在 web 工程启动的时候执行（Filter 已经创建）
3. doFilter 过滤方法
   第 3 步，每次拦截到请求，就会执行
4. destroy 销毁
   第 4 步，停止 web 工程的时候，就会执行（停止 web 工程，也会销毁 Filter 过滤器）

FilterConfig类

FilterConfig 类见名知义，它是 Filter 过滤器的配置文件类。
Tomcat 每次创建 Filter 的时候，也会同时创建一个FilterConfig 类，这里包含了 Filter 配置文件的配置信息。

FilterConfig 类的作用是获取 filter 过滤器的配置内容

1. 获取 Filter 的名称 filter-name 的内容
2. 获取在 Filter 中配置的 init-param 初始化参数
3. 获取 ServletContext 对象

FilterChain过滤器链

Filter拦截路径的三种配置方式

Filter 过滤器它只关心请求的地址是否匹配，不关心请求的资源是否存在

1. 精确匹配

<url-pattern>/target.jsp</url-pattern>
//http://ip:port/工程路径/target.jsp

2. 目录匹配

<url-pattern>/admin/*</url-pattern>
//http://ip:port/工程路径/admin/*

3. 后缀名匹配

<url-pattern>*.html</url-pattern>
//以上配置的路径，表示请求地址必须以.html 结尾才会拦截到

JSON

什么是json

1. JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式
2. 轻量级指的是跟 xml 做比较
3. 数据交换指的是客户端和服务器之间业务数据的传递格式

在JavaScript（客户端）使用json

json的定义

var jsonObj = {"key1":"value1","key2":12};

json的访问

jsonObj.key1;
jsonObj.key2;

json对象与字符串转换

json 的存在有两种形式。
一种是：对象的形式存在，我们叫它 json 对象。
一种是：字符串的形式存在，我们叫它 json 字符串

JSON.stringify(jsonObj)；
JSON.parse(jsonString)；

在Java（服务端）使用json

导入jar包，Gson gson = new Gson();

javaBean和json转换

gson.toJson(person)----->json字符串
gson.fromJson(json字符串，Person.class)---->JavaBean

List和json转换

gson.toJson(List<T>)----->json字符串
gson.fromJson(json字符串，new TypeToken子类().getType())---->List<T>
//该有一个类继承TypeToken<List<T>>

Map和json转换

gson.toJson(Map<K,V>)----->json字符串
//方式一：
gson.fromJson(json字符串，new TypeToken子类().getType())---->Map<K,V>
//方式二：
gson.fromJson(json字符串，new TypeToken<Map<K,V>>(){}.getType())---->Map<K,V>

AJAX

什么是AJAX

• AJAX：Asynchronous Javascript And XML，即异步JavaScript 和 XML
• ajax 是一种浏览器通过 js 异步发起请求，局部更新页面的技术。
• Ajax 请求的局部更新，浏览器地址栏不会发生变化局部更新不会舍弃原来页面的内容

原生AJAX使用

// 在这里使用 javaScript 语言发起 Ajax 请求，访问服务器 AjaxServlet 中 javaScriptAjax
function ajaxRequest() {
	// 1 、我们首先要创建 XMLHttpRequest
	var xmlhttprequest = new XMLHttpRequest();
	// 2 、调用 open 方法设置请求参数		
	xmlhttprequest.open("GET","http://localhost:8080/16_json_ajax_i18n/ajaxServlet?action=javaScriptAjax",true)
	// 4 、在 send 方法前绑定 onreadystatechange 事件，处理请求完成后的操作。
	xmlhttprequest.onreadystatechange = function(){
		if (xmlhttprequest.readyState == 4 && xmlhttprequest.status == 200) {
			var jsonObj = JSON.parse(xmlhttprequest.responseText);
			// 把响应的数据显示在页面上
			document.getElementById("div01").innerHTML = " 编号：" + jsonObj.id + " ,  姓名：" +jsonObj.name;
		}
	}
	// 3 、调用 send 方法发送请求
	xmlhttprequest.send();
}

jQuery中的请求

$.ajax方法

$.ajax 方法
	url 表示请求的地址
	type 表示请求的类型 GET 或 POST 请求
	data 表示发送给服务器的数据
			格式有两种：
				一：name=value&name=value
				二：{key:value}
	success 请求成功，响应的回调函数
	dataType 响应的数据类型
			常用的数据类型有：
				text 表示纯文本
				xml 表示 xml 数据
				json 表示 json 对象

$("#ajaxBtn").click(function(){
	$.ajax({
		url:"http://localhost:8080/16_json_ajax_i18n/ajaxServlet",
		// data:"action=jQueryAjax",
		data:{action:"jQueryAjax"},
		type:"GET",
		success:function (data) {
			// alert(" 服务器返回的数据是： " + data);
			// var jsonObj = JSON.parse(data);
			$("#msg").html(" 编号：" + data.id + " ,  姓名：" + data.name);
		},
		dataType : "json"
	});
});

$.get 方法和 $.post 方法

$.get 方法和$.post 方法
		url 请求的 url 地址
		data 发送的数据
		callback 成功的回调函数
		type 返回的数据类型

$.get(url,data,callback,type);
$.post(url,data,callback,type);

$.getJSON方法

$.getJSON 方法
	url 请求的 url 地址
	data 发送给服务器的数
	callback 成功的回调函数

$.getJSON(url,data,callback)

表单序列化 serialize()

serialize()可以把表单中所有表单项的内容都获取到，并以 name=value&name=value 的形式进行拼接

form对象.serialize()

i18n国际化（了解）

什么是i18n国际化

国际化（Internationalization）指的是同一个网站可以支持多种不同的语言，以方便不同国家，不同语种的用户访问

国际化三要素

使用

1. 配置两个语言的配置文件：
   i18n_en_US.properties ：

   username=username
   password=password
   

   i18n_zh_CN.properties ：

   username=用户名
   password=密码
   

2. 获取Locale对象

   // 获取中文，中文的常量的 Locale 对象
   System.out.println(Locale.CHINA);
   // 获取英文，美国的常量的 Locale 对象
   System.out.println(Locale.US);
   

3. 创建ResourceBundle

   @Test
   public void testI18n(){
   	// 得到我们需要的 Locale 对象
   	Locale locale = Locale.CHINA;
   	// 通过指定的 basename 和 Locale 对象，读取 相应的配置文件
   	ResourceBundle bundle = ResourceBundle.getBundle("i18n", locale);
   	System.out.println("username ：" + bundle.getString("username"));
   	System.out.println("password ：" + bundle.getString("password"));
   }
   

通过请求头国际化页面

<%
	// 从请求头中获取 Locale 信息（语言）
	Locale locale = request.getLocale();
	System.out.println(locale);
	// 获取读取包（根据 指定的 baseName 和 Locale 读取 语言信息）
	ResourceBundle i18n = ResourceBundle.getBundle("i18n", locale);
%>
<td><%=i18n.getString("username")%></td>

通过标签手动选择进行国际化

<%
	// 从请求头中获取 Locale 信息（语言）
	Locale locale = null;
	String country = request.getParameter("country");
	if ("cn".equals(country)) {
		locale = Locale.CHINA;
	} else if ("usa".equals(country)) {
		locale = Locale.US;
	} else {
		locale = request.getLocale();
	}
	System.out.println(locale);
	// 获取读取包（根据 指定的 baseName 和 Locale 读取 语言信息）
	ResourceBundle i18n = ResourceBundle.getBundle("i18n", locale);
%>
<a href="i18n.jsp?country=cn">中文</a>|
<a href="i18n.jsp?country=usa">english</a>
<td><%=i18n.getString("username")%></td>

通过JSTL标签库

<%--1 使用标签设置 Locale 信息 --%>
<fmt:setLocale value="${param.locale}" />
<%--2 使用标签设置 baseName--%>
<fmt:setBundle basename="i18n"/>
< %--3 输出指定 key 的国际化信息 --%>
<fmt:message key="username" />

<a href="i18n_fmt.jsp?locale=zh_CN">中文</a>|
<a href="i18n_fmt.jsp?locale=en_US">english</a>