Java Web笔记

day-01

Java Web

web应用开发，网站开发
网站=前端+后端

HTML + CSS + JavaScript(JS)
init(); setStyle(); registHandler();
初始化样式处理
public void show(){
init();//初始化控件
setStyle();//设置大小、位置、样式
registHandler();//绑定事件，操作页面
}

HTML
Hyper Text Markup Language
超文本标记语言

作用
显示逻辑（显示界面）
制作网页

开发工具
HTML文件(文档)，纯文本文件，扩展名.html
纯文本编辑器

运行工具
不需要编译
直接使用浏览器来运行

标记
标签
用<、>扩住的字母序列

单标签
单个出现
<xxx />
对标签
成对出现
<xxx>yyyy</xxx>

标记语言
由一套标记(标签)组成的语言
HTML 可使用的标记是固定的，(W3C)预定义好的

W3C
www
World Wide Web 万维网
World Wide Web Consortium 万维网联盟
发布Web技术规范

HTML注释
浏览器会忽略


新建web工程：
File --> New --> Web project 或 others，输入web project
快捷键：ctrl + N

新建HTML文件：
File --> New --> html 或 others，输入html
快捷键：ctrl+N

设置使用外部浏览器打开HTML页面：
windows --> preferences --> 输入web browsers --> 选择使用外部浏览器
--> New -->选择到浏览器的可执行文件，如chrome.exe

HTML文件的基本结构
<html>
根标签
用于标记HTML文档的开始和结束

<head>
文档的头标签
指定文档的标题
<title>
文档的标题标签
标题会显示在浏览器的标题中
设置和当前页面相关的一些信息
<meta>
http-equiv 用于指定名称/值对中的名称
如：content-type
用于设置文件内容的类型及编码
content 用于指定名称/值对中的值
如：text/html;charset=utf-8
<body>
主体标签
会显示在浏览器的内容区

开发者工具
查看与调试前端代码
1.浏览器的菜单
2.ctrl+shift+I F12
3.直接在页面的某个元素上，右键-->查看元素|检查元素

常用标签
文本标签
标题标签
<h1>,<h2>,...<h6>
<h1>--><h6> 依次变小
其他文本标签
<b> 加粗
<i> 斜体
<u> 下划线
<del>中划线
<sup> 上标
<sub> 下标

换行标签
<br/>

字符实体
一些字符在HTML中有特殊的含义或通过键盘无法输入
字符实体的形式：
&实体名称;
&#字符的十进制编码值;
预格式标签
<pre>
会保留内容的所有空白

浏览器对空白字符的处理
多个连续的空白，只会解析为一个空格

字体标签
<font>
color
颜色值
预定义好的颜色名
RGB
三基色（三原色）
每个基色用两位的16进制值来表示，00-FF --> 0 - 255
#00FF00 采用6位16进制数来表示的
每一个基色的值越小，表示这个颜色越暗，反之越亮
size 1-7
face

水平线标签
<hr/>
color

居中标签
<center>

段落标签
<p>
浏览器会自动在其前后加一些空白

<div> <span>
没有任何的特殊的显示效果
主要用于将其他的标签组合起来，形成一个块，只要拿到了这个块，
就拿到了这个块中的所有东西
<div>
默认独占一行
定义页面中的一块区域
<span>
默认不独占一行
定义了行内的某一块区域

块级标签
独占一行
定义页面中的一块区域

行内标签
不独占一行
且相邻的行内标签，会排列在同一行里，直到一行排不下，才换行
定义了行内的某一块区域

块级标签和行内标签可以互相转换，css

注释快捷键
ctrl + shift + c 切换注释

列表标签
<ul>
无序列表
<li>
代表列表中的每一条，即列表项
属性
type
设置列表项的符号的类型
<ol>
有序列表
<li>
代表列表中的每一条，即列表项
属性
type
设置列表项的符号的类型
start
指定从第几个开始

有序、无序体现在他的列表项符号能不能体现出顺序

图片标签
<img>
在页面上显示一张图片

属性
src
用于指定图片的位置
相对路径
相对的是当前html文件
.. 代表上一级目录
绝对路径
其他网站上的位置或包含根目录的位置
Windows：以盘符开头
Linux：以/开头
绝对路径
协议://位置
file://
浏览器访问本地计算机中的文件所使用的协议
alt
用于指定找不到图片时，显示的文本信息
超链接标签
<a>
用于
跳转到某个页面
跳转到某个页面的某个位置

属性
href
用于指定要跳转到的位置，如果没有指定该属性，超链接不会出现可点击的效果
"" 表示跳转到当前页面
绝对路径
相对路径
------> 同<img> src属性

target
用于指定在什么地方打开页面
_blank (blank) 在新窗口中打开
_self (self) 在当前窗口中打开
_parent
_top
frameName

跳转到某个页面的某个位置
<a href="页面的位置#position">
position 当前页面中的任意一个标签的id属性的值
点击该超链接，可以跳转到id属性值标识的位置(id属性的值等于指定值的标签所在的位置)

页面中某一个<a> name属性的值

框架标签
<frameset>
窗口集
用于在一个页面上显示多个窗口，用于组织多个窗口
每个窗口显示一个独立的html页面

不能与<body>标签一起使用

属性
cols
用于指定将页面在列的方向上，分成几部分
每部分可指定大小，各个部分用,分隔
%
* 剩余的区域
px
rows
在行的方向上，将一个页面分成n部分
每部分可指定大小，各个部分用,分隔
%
* 剩余的区域
px

<frameset>可以嵌套，即<frameset>可以嵌套<frameset>标签
<frame>是单标签

<frame>
代表一个窗口
属性
src
指定当前窗口显示的页面的位置
noresize
值noresize
指定窗口大小不可调整
name
窗口的名字
<iframe>
一个窗口中的另一个窗口
属性
src
width
height
name
窗口的名字

超文本
超级文本
可以包含图片、超链接、音视频、程序等非文字内容
不能呈现在纸上，一般都是电子档
计算机出现之后的产物

属性
标签拥有属性
属性总是在开始标签中指定
属性为整个元素提供附加的信息，如数据、显示
属性总是以名称/值对的形式出现，属性名="属性值" 属性名='属性值' 属性名=属性值
属性间无顺序
元素
通过标签定义元素
元素时页面的基本组成单位
<xxx>dfasdf</xxx>
<xxx yyy="zz">dsfdasf</xxx>
<xxx />，空元素
<xxx yyy="zz" />

css、js 选择、操作的基本单位都是元素

大小写
html4 的标签和属性名，不区分大小写
建议
用小写
XHTML要求必须用小写

XHTML
内容与HTML4几乎相同
要求更严格
目的替代HTML4

day-02

表格
由若干行单元格组成
<table> 定义一个表格
<tr> 表格中的一行
<td> 一行中的一个单元格
<caption> 表格的标题居中显示
<thead> 表头，标题行 <tr> 标题行中的一行 <th> 标题行中的一个单元格加粗、居中
<tbody> 表格的数据主体

可以省略<thead>、<tbody>

<table>属性
width="500px"
设置表格的宽度
border="1px"
表格的边框的粗细
cellspacing="20px"
单元格之间的空白
cellpadding="10px"
单元格的内容与单元格的边框之间的空白
align="right"
控制的是表格自己的对齐方式
bgcolor="red" background="../imgs/lyx.gif"
<tr>属性
align="right"
设置这一行中的单元格的内容的对齐方式
<td>属性
align="right"
设置单元格的内容的对齐方式

合并单元格
<td>属性
colspan="2"
跨列合并单元格跨的列数的最大值不能>每一行单元格的个数
rowspan="2"
跨行合并单元格
应用
展示数据
可用于简单的页面布局
<td>可嵌套其他的标签
利用单元格的整齐排列的特点，进行简单的页面布局

表单
为用户的输入提供了途径
发送数据到指定位置

表单标签
<form>
本身无任何显示效果
作用
将一组组件组织起来
属性
action
指定表单数据提交到的位置
表单组件
表单控件
<input />
type
指定控件的类型

text 单行文本框默认值
password 密码框
radio 单选按钮一组单选按钮的name属性的值一样时，才可实现单选效果
checkbox 复选框
file 文件选择框(文件域)

sumit 提交按钮
提交表单数据到指定位置
reset 重置按钮
将表单控件的值恢复成初始值
button 普通按钮
value属性设置按钮的文本

image 图片提交按钮
src="../imgs/ly.gif" width="100px" height

hidden
隐藏域
用户看不到，不会显示在页面上
可提交数据
<input type="hidden" name="ip" value="192.168.4.8"/>

如果想让某个表单的数据提交，则必须给这个表单控件指定名字，通过name属性指定
value属性
用于指定提交的值
默认值
其他常用属性：
readonly
用于指定输入控件(text、password)是只读的
maxLength
指定输入字符的最大个数
size
指定的是输入控件的宽度

checked
使某个单选框、复选框处于选中状态

disabled
是控件不可用

提交的数据格式：
?username=dasfas
&
pwd=sdfads
&
sex=on
&
hobbies=on&hobbies=on
&
photo=secondarytile.png

下拉列表
<select> 代表一个下拉列表
<option> 代表下拉列表中的一个选项

name属性加在<select>
默认提交的数据是，选中的选项的文本内容
如果给<option>指定了value属性，提交的数据时候value属性的值

<select>属性
multiple
指定可多选
disabled
使下拉列表不可用

文本域
多行文本框
<textarea>
cols
指定文本域的列数
rows
指定文本域的行数

<textarea>
dfadsfdsafsad
dsfasdf
sdfasd
</textarea>
<textarea>元素的元素内容就是它的值
提交的数据是输入的内容
<textarea>没有value属性

如果没有结束标签，会把<textarea>后的所有html代码全都当成它的内容

CSS
Cascading Style Sheet
层叠样式表

样式
所有用于控制显示外观的东西

作用
用于控制内容的显示效果

W3C建议
页面内容数据 HTML
页面效果外观 CSS
页面行为功能 JavaScript

优点
可以将页面的数据和显示效果分开
便于维护和复用
定义样式表的语法：
selector{
property1:value1;
property2:value2;
property3:value3;
...
}

引入CSS样式的方式
行内样式表
在标签中，通过标签的style属性指定的样式表
仅对当前元素有效

内部样式表
在<head>中，使用<style>子标签，在<style>子标签中，写样式表定义
<head>
<style type="text/css">
//样式定义
</style>
</head>

仅对当前页面有效

外部样式表
把所有的样式表定义写在一个单独的css文件中，css文件的扩展名.css
<link rel href>
链接一个外部的文件到当前文件中，还可以引入其他类型的文件
rel
必须
指定引入文件与当前文件的关系，css-->stylesheet
href
用于指定引入的文件的位置
可以是相对路径或绝对路径
优先级
行内 > (外部、内部)同级

浏览器的加载顺序
加载HTML页面
应用浏览器默认的样式
读取样式定义：
1.按文件中书写的顺序，读取内部与外部样式，后读取的会覆盖先读取的同名的属性
2.读取行内样式
选择器
作用
选择到某些元素

基础选择器
标签选择器
以标签的名字作为样式应用的依据
通过标签名选择到某些元素
形式：
标签名{
样式规则
}
id选择器
根据标签的id属性的值，去选择到某一个元素
#id属性的值{
样式规则
}
class选择器
根据标签的class属性的值，去选择到某些元素
形式:
.class属性的值{
样式规则
}

优先级
id > class > 标签

派生选择器
是由基础选择器扩展出来的
通过某种方式将多个基础选择器组合起来形成的选择器

后代选择器
形式：
选择器1 选择器2 ....

选择器1 选择器2
选择器1的后代元素且满足选择器2

子元素选择器
形式：
选择器1 > 选择器2 > ....

交集(多条件)选择器
形式：
选择器1选择器2...
满足选择器1且满足选择器2
选择器分组
选择器1,选择器2,...
当前定义的样式，对所有选择器选择到的元素都有效

伪类选择器
状态选择器
根据元素的状态来选择到某些元素
形式：
选择器:状态名
状态名
link 代表从未被访问过的状态
visited 已被访问过的状态
hover 鼠标悬停时的状态
active 正在点击的状态

样式继承
子元素会继承父元素的样式
子元素自己的样式会覆盖从父元素继承的同名的样式

!important 重要的样式属性，不会被覆盖
color:red!important;

盒子模型
Box Model
元素在页面中占用的区域，都是一个矩形的框，称之为框模型；可以看成一个盒子，所以也叫做盒子模型
每个盒子都有外边距、边框、内边距、宽度、高度这几个属性
每个盒子都有4个方向上、右、下、左
CSS提供了分别用于单独设置某个方向上的外边距、边框、内边距的属性

元素的内容区域的尺寸
width
height
边框
border
每条边框都有三个方面：宽度、样式、颜色

形式1：
border-方向-边框的某一个方面
方向：top、right、bottom、left
边框的某一个方面：width、style、color
形式2：
border-方向
在一个属性中设置一条边框的三个方面
方向：top、right、bottom、left
形式3：
border-边框的某一个方面
边框的某一个方面：width、style、color

四个值：上右下左
三个值：上左右下
两个值：上下左右
一个值：上下左右
形式4：
简写属性
border
在一个属性中设置所有的边框的所有的方面
内边距
padding
内容区域与元素的边框之间的空白
形式1：
padding-方向
方向：top、right、bottom、left
简写属性
padding
在一个属性中设置所有方向上的内边距
四个值：上右下左
三个值：上左右下
两个值：上下左右
一个值：上下左右

外边距
margin
元素的边框之外的空白

形式1：
margin-方向
方向：top、right、bottom、left

简写属性
margin
在一个属性中设置所有方向上的外边距
四个值：上右下左
三个值：上左右下
两个值：上下左右
一个值：上下左右

day-03

display
用于指定元素的类型(块级或行内)
block
块级元素
对于
div...
默认block
inline
行内元素

不可设置尺寸(宽度、高度)

对于span img font... 默认inline

inline-block
行内元素
可以设置尺寸

none
不显示
不再占用页面的空间

visibility
设置元素的可见性
hidden
visiable

CSS定位
用于确定元素在页面中的位置
position
用于指定定位的类型

static
默认的定位类型
元素按照在HTML文件中的书写顺序，在页面上自动按从上到、从左到有的顺序排列

absolute
绝对定位
相对于第一个非static定位的祖先元素或html页面进行定位
默认位置是在该元素采用static定位时，在页面中应该排放的位置

元素的位置可通过left、top、right、bottom属性进行指定
绝对定位的元素之后的任意元素会认为该绝对定位的元素时不存在的
relative
相对定位
相对于其正常位置(static)进行定位
默认位置是在该元素采用static定位时，在页面中应该排放的位置
fixed
固定定位
相对于浏览器窗口进行定位
固定定位的元素之后的任意元素会认为该固定定位的元素时不存在的
left、top、right、bottom属性
只对非static定位的元素有效

px
pt
cm mm
em 倍数父元素的字体大小的倍数

JavaScript
是网景公司(Netscape)开发的
运行在客户端(浏览器)
脚本语言

和Java没有任何关系
红午粤利粤康帅博
和sun合作过

非面向对象语言
有类的概念
满足面向对象的三个基本特征

js是基于对象的语言

作用
在客户端动态操作页面
在客户端做数据校验
发送Ajax请求

不需要编译，直接在浏览器中运行

使用JS方式
js代码写的位置的不同：
内部js
HTML文件中，<script type="text/javascript">js代码</script>
外部js
js代码写在一个单独的js文件中，扩展名.js
HTML引入外部js：
<script type="text/javascript" src="外部js文件的位置"></script>
行内js
标签的属性值
<a href="javascript:js代码" />
<form action="javascript:js代码">
<xxx onyyy="js代码">
带有事件属性的标签
js代码可作为事件属性的值
当事件发生时，执行这段js代码
对于事件属性，javascript:可省略
基本语法
语法借鉴了C、Java语言，语法更宽松

标识符
同Java
给变量、函数起名字
区分大小写
不能是关键字、保留字

Java：int i = 1.1;
JS中的变量是无类型的，值是有类型的(值的类型，即数据类型)

变量
定义变量的语法：
var 变量名 [= 初始值];
无类型(弱类型)
可用于存放任意类型的值

字面量
直接量
可以直接写的值

数据类型
值的类型

基本数据类型
number
数值类型
boolean
true false
其他的类型中都有与这两个值等价的值
string
用引号引起来的0个或多个字符
引号：双引号单引号
undefined
值undefined
表示未初始化
如果定义了一个变量，从未给这个变量赋过值，则这个的值默认为undefined
null
值null
不存在
一个不存在的对象的空引用
复合数据类型
函数
数组
String
Date
Object
typeof
操作符
检测保存到变量中的值、字面量值的数据类型
返回的结果是字符串string

"number"
"boolean"
"string"
"undefined"
"object"
"function"

特殊的数值
NaN
Not a Number
数值类型的
表示无法获得正常的数值结果
NaN不等于任何值，包括NaN自己
isNaN(任意类型的值)
返回boolean
是否不是一个数
任意类型的值底层运行时，先调用Number()将参数值尝试转换为数值
Infinity
Java:1.0d / 0 --> Infinity

被除数为非0，除数为0，计算把0看成是一个无限接近0的极小数 --> Infinity
被除数为0，除数为0，都当成0处理 --> NaN

类型转换
JS存在自动类型转换

string --> number
parseInt()
parseFloat()
参数是string
将字符串转换成数值
返回值类型number

会忽略字符串前面的空格
从前到后一个一个解析，直到解析完所有字符或遇到非法数字字符
Number()
字符串必须全都是合法的数字字符，否则返回NaN

任意类型 --> string
+ "" --> string

运算符
算术
+ - * / % ++ -- + -

+ 有一个操作数是string，表示的是字符串连接运算
比较
> < >= <=
== !=
比较值相不相等
null == undefined --> true
===
恒等于
类型相同且值相同
!==
类型不同或值不等
逻辑
&& || !
位
& | ^ >> << >>>
赋值
= += -= ...

流程控制
条件语句
if
if-else
if-else if
switch
switch-case
循环语句
while
do-while
for
forIn
for(var i in arr){
}
中断控制流程语句
break;
continue;

""、undefined、null、NaN、0 --> false
--------------------------->反之，其他的值都等价于true
复合数据类型
函数类型
函数是有名字的代码块
可以通过函数名进行调用

函数是函数类型的值(数据)

创建函数
function 函数名(形参列表){
js语句
}
不需要也不能指定返回值类型
形参不需要也不能使用var定义
可以有返回值，使用return语句返回值，并结束函数的运行

调用
调用时才执行
函数名(参数值列表)

参数
调用函数时，不关系传递的参数的个数、类型
函数在运行时：
首先会在函数内部创建一个名字叫arguments的数组，
然后通过该数组来接收所有的参数值
检查函数定义时是否声明了形参，如果声明了形参，会把用arguments会组件接收到的值
依次赋值形参
函数名
是变量
存放了函数类型的值
一函数有多个名字

没有重载
只有变量覆盖

函数分类
普通函数：创建目的就是直接调用，命名规范同Java方法
构造函数：创建目的是用于创建对象，命名规范同Java类
匿名函数：没有名字的函数
用于一次性执行的函数
用于给某个变量赋值
function(){
js语句
}
必须用某个变量来接收

day-04
函数返回值
函数总是有返回值的，默认返回undefined

数组类型
一块连续的存储空间
数组元素按添加序存放

js中的数组：
大小可动态调整，长度不固定
可以存放任意类型的数据(对于同一个数组)
不会引起下标越界错误

创建数组的方式：
new Array构造函数
new Array(参数值列表)
参数个数及含义：
不传参数
创建一个长度为0的数组
一个number
创建一个长度为指定number参数的数组
其他数量、类型的参数
参数值为创建的数组的初始化数据
字面量方式
[e1,e2,e3,....]
属性：
length 设置或返回数组中元素的个数

数组的遍历
for...in循环
for(var i in arr){
}
赋给变量i的值是数组下标

多维数组：
数组的数组

方法：
toString()
返回数组的字符串表示形式
reverse()
反转原数组元素的顺序
concat(arr1,...)
连接若干数组，返回连接后的新数组
join("separator")
使用指定的分隔符，分隔数组的每个元素，返回一个字符串
没传入参数或传入的是undefined，则默认是用,作为分隔符
""表示不使用任何分隔符
slice(m,n)
m,n number类型 [m,n)
截取数组的一部分
sort(fn)
给数组元素排序
默认按字符串中字符的编码值，升序排序

fn为排序规则

String类型
var str = new String("dsfasdf");

属性：length 返回字符串长度

方法：
charAt
substring
indexOf
lastIndexOf
toLowerCase
toUpperCase
trim

split(regexp)
根据指定分割符将字符串分割成一个数组
分割符:
可以是普通字面量，string
可以是正则表达式
返回结果保存了分割后的结果的一个数组
replace(oldStr|regexp, newStr)
将原字符串中的某个子串替换成指定字符串后，返回替换后的新字符串
到底替换一个就结束，还是替换所有才结束：和使用的正则表达式有关，是否有全局匹配标志
match(str|regexp)
查找匹配给定字符串或正则表达式的子串
到底匹配一个就结束，还是匹配所有才结束：和使用的正则表达式有关，是否有全局匹配标志
返回存放了匹配结果的数组

search
检索当前字符串中某个特定部分
某个特定部分
字符串字面量
正则表达式
返回第一个匹配的结果的起始下标

正则表达式
Regular Expression
RegExp
规则表达式
用于查找符合某些规则的字符串的工具

js创建正则表达式：
new RegExp构造函数
new RegExp("pattern","attributes")
直接量语法
/pattern/attributes

组成部分
匹配模式(规则)
元字符
具有特殊含义的字符
. 除换行符外的任意一个字符
\w 任意一个单词字符 <==> [a-zA-Z0-9_]
\W 非\w <==> [^a-zA-Z0-9_]
\d 任意一个数字 <==> [0-9]
\D 非\d <==> [^0-9]
\s 任意一个空白字符
\S 非\s
量词
指定字符出现几次
{n} 它前面的字符连续出现n次
{n,} 它前面的字符至少连续出现n次 >= n
{n,m} 它前面的字符至少连续出现n次，最多m次
* 0次或多次 <==> {0,}
+ 1次或多次 <==> {1,}
? 0次或1次 <==> {0,1}

0次含义：如果匹配，则不计算元字符串前面的空
如果不匹配，则将元字符串前面的空计算在内

当两次具有至少含义时，执行的是最长匹配

特殊符号
具有特定含义的符号
[]
表示要匹配的一个字符的范围
[a,b,c]
[abc]
[a-c]
\w
^
在[]外，表示匹配整个字符串的开始
在[]内，表示非的意思
$ 表示匹配字符串的末尾
()
表示分组
组合查找：圆括号中的内容与正则表达式的其他部分组合起来先进行一次查找
分组查找：使用圆括号内的部分单独查找，使用上面组合查找的匹配结果，再单独匹配
全局匹配时，不会进行分组匹配
匹配特性
i 执行对大小写不敏感的匹配，匹配时不区分大小写。
g 执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）。
方法：
test(str)
检测给定字符串是否匹配当前正则表达式
Date类型
创建日期时间对象：
new Date(参数值列表)
1.无参数
new Date()
返回当前浏览器所在机器的系统时间
2.日期字符串
能识别的日期格式字符串与浏览器实现有关
3.年、月、日、时、分、秒、毫秒

4.当前日期时间到1970-1-1 00:00:00经过的毫秒数

具有将时间日期自动调整为正确时间日期的能力

day-05

Date
方法
getFullYear() 四位的年
getMonth() 月份(0~11)
getDate() 一个月中的某一天(1~31)
getHours()
getMinutes()
getSeconds()
getMilliSeconds()
getDay() 星期中的某一天(0-6)
getTime() 1970-1-1 00:00:00 到当前日期经过的毫秒数

parse(日期格式字符串)
静态方法
解析日期格式字符串，如果能够解析，返回日期格式字符串代表的日期至格林尼治时间的毫秒数
如果不能解析，返回NaN

setXxx/getXxx 获得或设置日期时间的某个特定部分

Date对象 ---> string
format()
new Date() ---> yyyy-MM-dd hh:mm:ss

string --> Date
new Date(日期格式字符串)
new Date(毫秒数)
setTime()

Object类型
使用基本类型（undefined、null除外）调用属性和方法时，后台自动完成下列处理：
创建基本类型值对应的包装类型(String、Boolean、Number)的一个实例
用实例调用指定的属性或方法
销毁实例
创建Object类型的对象：
new Ojbect()

Object类型的对象本身用处不大，但是所有对象都是从Object类型的对象扩展出
js对象，属性的集合（属性值可以是函数）
创建自定义对象：
方式1：
var obj = new Object();

获取或设置对象的属性(对js中的所有对象都适用)：
点方式：
obj.attrName [= value]
方括号方式：
ojb[string类型的值] [= value]
string类型的值，对象中的属性的名字字符串
设置属性值时：
如果指定的属性在对象中，已存在，设置属性的值
如果指定的属性在对象中，不存在，添加属性到对象中并设置属性的值

JS中，对象的属性名允许是非法JS标识符，访问该属性时只能适用方括号方式
删除对象的属性：
1.把属性值设置为undefined
2.delete obj.attrName
遍历对象：
for...in
for(var attr in obj){
//赋给定义的变量attr的是要遍历的对象的属性名字符串
//如果要访问某个属性的值，需要通过方括号方式
}
方式2：
工厂模式
function objectFatory(name,age){
var obj = new Object();
obj.name = name;
obj.age = age;
obj.play = function(){
console.debug(obj.name + "正在玩！！！");
}
return obj;
}
方式3：
对象字面量

var obj = {
attr1:val1,
attr2:val2,
attr3:val3
};
var stu = {
name:"zhangsan",
age:12,
hobbies:["吃饭","睡觉","打豆豆"],
isMarried:false,
"class":{grade:1,"class":2},
play:function(){
console.debug(this.name);
}
}

this
代表当前对象
谁调用就代表谁

//定义一个圆对象，属性：半径；方法：求面积：πr^2

方式4：
构造函数(自定义类型)
function Student(name,age){
this.name = name;
this.age = age;
this.play = function(){
console.debug(this.name + "正在玩！！！");
}
}
-------------------------------->
在函数执行体执行之前，对象已创建好
对对象执行初始化
函数体执行完毕，会自动返回该对象

构造函数中的this
正在调用该构造函数进行初始化的对象

通过new操作符调用构造函数，创建一个对象

new操作符的作用：
调用构造函数
在堆内存中，开辟一块空间
创建一个Object类型的对象，并将该对象保存在开辟的堆空间中
由该对象调用当前构造函数，执行初始化
返回该对象
数组问题：
数组是对象
可以同过访问、设置、添加、删除对象的一般方式来操作数组

添加属性：
指定的属性名，若能通过Number()函数转换成数字，则该属性值作为数组的元素
若通过Number()函数不能转换成数字，则该属性回认为是数组对象的属性
DOM
Document Object Model
文档对象模型
HTML DOM

DOM是由w3c定义的关于如何访问、操作HTML元素的标准，然后由各个浏览器厂商提供实现

DOM要求将HTML文档转换成内存中的一颗树，节点树
DOM定义了对树中节点的增删改查的API

浏览器对DOM实现后：
浏览器读取HTML文档
按照w3c定义的DOM
将HTML文档转换成内存中的树(浏览器的容错性：修正文档中的一些错误)
按照这棵树中的数据显示页面
-------------------------->
我们写的是HTML文档
浏览器会将HTML文档转换成树(不需要我们自己解析)
我们在JS中要使用的是DOM定义的对象去操作页面
DOM中定义的类型
Node
节点
DOM中，所有东西都是节点
Document
HTMLDocument
一个Document类型的对象，表示一个HTML文档，是DOM树的最顶层节点(根)

每个读取到浏览器中的HTML文档，浏览器会为之创建一个Document类型的对象
这个对象的名字是document，我们可以通过这个document对象对HTML页面中的所有元素进行访问

文档节点也是节点，Document类型是Node类型的子类型(可以使用Node类型中定义的所有属性和方法)
Element
元素
一个Element类型的对象，代表了页面中一个具体的元素
不同的元素，提供了不同的类型：
HTMLElement
HTMLHeadElement
HTMLBodyElement
....
HTMLXxxElement
元素节点也是节点，Element类型是Node类型的子类型（可以使用Node类型中定义的所有属性和方法）

Node
属性
childNodes
当前节点的所有子节点构成的NodeList集合
NodeList
属性
length
访问集合元素
下标方式

方法：
item(index)
parentNode
当前节点的父节点
firstChild
第一个子节点
lastChild
最后一个子节点
previousSibling
前面一个兄弟
nextSibling
后面一个兄弟
-------------------------->
如果上述的节点不存在，返回null
会根据节点的实际类型，返回实际类型的对象
nodeType
返回当前节点的类型
节点类型：
文档 DOCUMENT_NODE 9
元素 ELEMENT_NODE 1
属性 ATTRIBUTE_NODE 2
文本
注释
通过Node的常量提供
方法：
appendChild(childNode)
将childNode追加到当前节点的子节点的末尾
insertBefore(newNode,refNode)
将newNode子节点插入到refNode子节点之前
replaceChild(newNode,oldNode)
用newNode子节点替换oldNode子节点
removeChild(chidNode)
删除当前节点的指定子节点
Document
属性
方法
创建元素(对象)
createElement("tagName")
创建文本(节点)
createTextNode("text")
查找整个页面中的元素
getElementById("id属性的值")
返回标签的id属性的值等于指定值的第一个元素对应的Element对象
getElementsByTagName("标签名")
返回标签名等于指定值的所有元素对象构成的集合(HTMLCollection)
getElementsByName("name属性的值")
返回标签的name属性等于指定的值的所有元素对象构成的集合
HTMLCollection
用法同NodeList
write()
向页面中写HTML内容
Element
属性
innerHTML
返回或设置当前元素的HTML内容

方法
getElementsByTagName("tagName")
（当前元素的所有后代元素中找）
返回标签名等于指定值的所有元素对象构成的集合(HTMLCollection)
getAttribute("attrName")
获取指定属性的值
setAttribute("attrName","attrValue")
设置属性的值
removeAttribute("attrName")
删除某个属性

remove()
删除当前元素(IE浏览器不支持)

直接访问元素的属性
元素对象会将对应元素的属性作为自己的同名属性
(class除外，class是js中的保留字，使用className属性替代)
(只能访问w3c为某个标签定义标准属性)

day-06

appendChild(childNode)
将childNode追加到当前节点的子节点的末尾
insertBefore(newNode,refNode)
将newNode子节点插入到refNode子节点之前
replaceChild(newNode,oldNode)
用newNode子节点替换oldNode子节点

事件
标签中的事件属性
onload
当页面的所有内容加载完成后，执行的js代码
onchange
域的内容改变且失去焦点
<input id="textId" onchange="alert(111);"/>
<input type="password"/>
<input type="file"/>
<textarea rows="10" cols="5"></textarea>
单选框、复选框的选中状态改变时
单选框，引发change事件的元素是处于选中状态的单选框
onsubmit
onblur
onfocus
onclick
onmouseover
onmouseout
元素对象中的事件属性

function onclick(event) {
var i = 0;
var j = 1;
alert(i+j);
}
------------------------------>
标签的事件属性的值，是一段js代码
在标签元素转换成JS DOM对象时，这段代码会被封装成一个函数
将该函数赋给元素对象的对应事件属性
--------------------------->
元素对象的事件属性是函数
这个函数当在事件发生时，由发生事件的元素对象来调用
this 谁调用代表谁当前元素对象

Table
rows 表格所有的行组成的集合

insertRow(index)
index表格行编号，从0开始
在表格中指定index位置之前插入一个新行
返回新插入的行 TableRow
deleteRow(index) 从表格删除一行

TableRow
cells 返回表格的一行中所有单元格的一个集合
rowIndex 返回该行在表中的位置

insertCell(index)
在一行中的指定位置index之前插入一个空的 <td> 元素
返回新插入的单元 TableCell
deleteCell(index) 删除行中的指定的单元格

TableCell
cellIndex 返回单元格在某行的单元格集合中的位置
innerHTML 设置或返回单元格的开始标签和结束标签之间的 HTML
修改元素的样式
方式1：
通过元素对象的style属性访问标签的style属性
通过style属性，访问具体的样式属性
element.style.样式属性名
单个单词的样式属性名：
element.style.xxx
多个单词的样式属性名：
将-后的单词的首字母大写，然后-前面的单词拼在一起
background-color --> backgroundColor

方式2：
通过元素对象的className属性，修改标签的class属性的值

作业：
1.放大缩小某一个元素
2.写一个注册页面
用户名字母、数字、下划线组成，不小于6字符，不大于12字符
密码同用户名
确认密码与密码一致
手机号验证手机号的合法性

标签中的属性名与值一样的属性，在元素对象中，对应的属性的值是boolean类型的值，true|false

day-07

禁止元素的默认行为
<form>
onsubmit 的事件处理函数返回false，即<form onsubmit="return false;">
<input type="submit" onclick="return false;">
<a>
<a href="xxx.html" onclick="return false;">

window
表示在浏览器中打开的窗口
对象名window
iframe、frame也是窗口，会为frame、iframe也创建一个window对象

全局变量、函数
函数外部定义
会自动成为当前窗口对象(window)的属性
调用window对象的属性，可以省略window.前缀

没有使用var定义且赋了值的变量(包括在函数中)，是全局变量

局部变量、函数
函数内部定义

属性
onload
当页面的所有内容加载完成后，执行的函数

document
document.forms
表示当前文档中的所有表单元素对象组成的一个集合
可通过下标访问
可通过表单<form>的name访问到某个具体的表单对象,forms["name"]
可通过表单元素<input> <select> <textarea>的name访问到某个具体的表单元素对象,forms["Fname"]["Ename"]
location
地址对象
代表当前窗口显示的页面的位置信息(地址栏)

href
当前窗口中显示的页面的地址
缺省属性(不指定访问的哪个属性，默认使用的属性)
parent
返回当前窗口的父窗口
方法
alert(str)
弹出一个警告框
框里只有一个按钮，确认按钮
参数作为弹出框的显示内容
prompt(msg[,val])
输入框
msg输入框要显示的提示信息
val输入的默认值
两个按钮：确定、取消

返回值：
取消--> null，表示点击的是取消按钮
确定
--->返回输入内容，string
如果没有输入任何内容，返回空字符串
confirm(msg)
确认框
两个按钮：确定、取消
返回值：
点的确定按钮 ---> true
点的取消按钮 ---> false
open([url,name,features])
用于打开一个新的浏览器窗口或查找一个已命名的窗口
返回值：返回打开新窗口(window对象)

url
如果省略了这个参数，或者它的值是空字符串，那么新窗口就不会显示任何文档
name
可以用作标记 <a> 和 <form> 的属性 target 的值
已经存在的窗口，那么 open() 方法就不再创建一个新窗口
features
参考文档
close()
调用者是window对象
关闭调用者window表示的窗口

定时器方法：
setTimeout(fn|code,number)
在指定number毫秒后，执行指定的函数或js代码块一次
返回定时器的标识

clearTimeout(定时器的标识)
清楚定时器的任务，使其在指定时间后不再执行

setInterval(fn|code,number)
在指定number毫秒后循环执行指定的函数或js代码块
返回定时器的标识
clearInterval(定时器的标识)
清楚定时器的任务，使其在指定时间后不再执行
下拉列表
Select
属性
options
返回包含下拉列表中的所有选项的一个集合
selectedIndex
设置或返回下拉列表中被选中选项的索引
索引从0开始
length
返回下拉列表中的选项数目
方法
add(Option)
向下拉列表中添加一个选项
remove(index)
删除指定索引处的选项
Option
创建Option对象：
new Option(text[,value])

属性
index
当前选项在下拉列表中的索引
text
设置或返回某个选项的纯文本值
value
设置或返回对应元素的value属性
options
HTMLOptionsCollection
是集合
通过下标访问 [index]
item()
length
属性
selectedIndex
设置或返回下拉列表中被选中选项的索引
方法
add(Option)
向下拉列表中添加一个选项
remove(index)
删除指定索引处的选项
额外操作：
增加一个选项：
options[options.length] = option
删除一选项：
options[index] = null
删除所有选项：
options.length = 0

day-08

Event
事件源事件发生的地方
事件一些操作
事件处理器事件发生时，处理事件的函数

<xxx onyyy="test();">
----------------------->DOM Object
obj.onyyy = function onyyy(event) {
test(aaa);
}

标签的事件属性的值，是一段JS代码 f(event);
在元素转换成DOM对象时，会封装在一个函数中 function fx(event){f(event);}
然后将该函数赋给DOM对象的对应的事件属性，当这个事件发生时，将会调用该函数(事件处理函数)

事件对象，当发生某些事件时，浏览器会自动生成一个与之对象的事件对象

调用事件处理函数时，会为该函数传入当前的事件对象

事件冒泡
事件会从里往外传播

事件对象
target
返回事件源对象
cancelBubble
设置或获取是否阻止事件传播

方法
stopPropagation()
停止事件的传播

JQuery
一个JS库

作用
可以替换掉几乎所有的原始DOM操作

window.jQuery = window.$ = jQuery;

min
使用版
能省则省(空白、换行、注释等)
原因：小
不带min
阅读版
使用版与阅读版，功能上完全一致

要使用JQuery，首先引入JQuery的JS文件

核心
JQuery函数
window.jQuery = window.$ = jQuery;

4种调用JQuery函数的形式：
window.jQuery()
window.$()
jQuery()
$()

JQuery对象
通过JQuery函数返回的对象都是JQuery对象
只有JQuery对象才能使用JQuery中提供的方法、属性

DOM对象
使用DOM操作获得对象
只有DOM对象才能使用DOM中提供的方法

JQuery对象 --> DOM
$obj[index]
$obj.get(index)

DOM对象 --> JQuery对象
$(domObj)

$(document).ready(fn)
当页面加载完成后，执行指定的函数fn
简写方式：
$(fn);
当页面加载完成后，就是要执行的函数

选择器
选择器
作用
选择到某些元素
基础选择器
标签选择器
通过标签名选择到某些元素
形式：
$("tagName")
id选择器
根据标签的id属性的值，去选择到某一个元素
$("#idVal")
class选择器
根据标签的class属性的值，去选择到某些元素
形式:$(".classVal")
派生选择器
是由基础选择器扩展出来的
通过某种方式将多个基础选择器组合起来形成的选择器

后代选择器
形式：
选择器1 选择器2 ....

选择器1 选择器2
选择器1的后代元素且满足选择器2

子元素选择器
形式：
选择器1 > 选择器2 > ....

交集(多条件)选择器
形式：
选择器1选择器2...
满足选择器1且满足选择器2
选择器分组
选择器1,选择器2,...
当前定义的样式，对所有选择器选择到的元素都有效
方法
write less,do more

attr(name[,value])
设置或返回每一个被选元素的属性值
属性值指定为null，则会删除该属性
prop(name[,value])

removeAttr()

addClass

removeClass

css()

html()
text()

val()

fadeIn
fadeOut

animate()

day-09

toggle()
size()

each(fn)
以每一个匹配的元素的DOM对象作为调用者调用指定的函数
调用函数时会传入元素在集合中的索引

find("selector")
在当前正在处理的元素中，再去查找元素

parent()
返回当前所有匹配元素的父元素

插入
a、b都是JQuery对象
内部插入
a.append(b)
将b添加到a的子元素的末尾
b.appendTo(a)
将b添加到a的子元素的末尾
外部插入
a.before(b)
b插入到a之前
a.after(b)
b插入到a之后
a.insertBefore(b)
a插入在b之前
a.insertAfter(b)
a插入在b之后

删除
remove()
删除所有的匹配元素

清空元素内容
empty()

克隆(复制)
clone()

绑定数据
data(key,value)
data(key)
data({attr1:val1,...})

事件
为元素的某种事件绑定事件处理函数
onxxx
xxx(fn)
fn事件处理函数
on("eventType",fn)
enventType
click
focus
blur
onxxx --> xxx
bind("eventType",fn)

trigger("eventType")

$obj.click([function]);
$("a").click(function(){
$("form").submit();
});
事件对象
只需给事件处理函数指定一个形参(第一个形参)，则运行时该形参接受到的值就是当前事件对象
arguments[0]

bubbles
target
stopPropagation

day-09

Servlet
Java服务器小程序
sun公司在JDK1.2时开发的一种用于扩展web服务的功能一组组件技术
Servlet技术，将Java和HTML结合起来

该组件要求实现Servlet接口(要求符合Servlet规范)

放在符合Servlet规范的web服务器中运行

组件(程序员自己的开发的类)
按照特定的规范开发(Servlet规范)
不需要考虑一些基础服务(网络通信、多线程、xml解析等)
只需要实现业务逻辑

容器(程序员使用的一个软件)
按照特定的规范开发的程序
实现了基础服务
提供了组件的运行环境

组件+容器
特点
简化了开发不需要写基础服务，容器已实现
组件不依赖于特定的容器只需要提供任意一个符合规范的容器
客户端不需要安装jre和其他的任何软件
只需要有一个浏览器

tomcat
先安装JDK Java编写的
开源免费的Servlet容器，实现了web服务大部分功能

安装
解压
tomcat目录结构：
bin
启动和关闭tomcat的脚本文件
conf
tomcat服务器的各种配置文件
lib
tomcat和web应用程序都可以访问的jar包
logs
tomcat的日志文件
temp
tomcat运行时产生的临时文件
webapps
发布web应用程序的目录
work
存放JSP生成的Servlet源代码和字节码
配置环境变量
tomcat依赖：
JAVA_HOME=jdk安装目录
CLASSPATH=jdk搜索字节码文件或jar中字节码文件所找的目录
tomcat自己：
CATALINA_HOME=tomcat的安装目录
系统：
PATH=原来的PATH+tomcat安装目录下的bin

启动服务器
catalina.sh run
catalina.bat run

catalina.bat start

停止服务器
shutdown.sh
shutdown.bat
ctrl+c
访问
浏览器地址输入
http://ip:port

改变默认端口号
CATALINA_HOME/conf/server.xml

开发Servlet
定义一个符合Servlet规范的类
实现Servlet接口或者继承HttpServlet

Servlet类的编译，需要依赖servlet-api.jar
带包编译
javac -d ../bin -cp ../lib/servlet-api.jar HelloServlet.java

web应用程序的目录结构
创建一个目录(appname)
WEB-INF
classes 存放字节码文件
lib 存放第三方的jar包
web.xml
web应用程序部署描述符文件
包含了web应用程序的配合和部署信息

公共资源(图片、js、css、html等)

部署
将整个web应用目录拷贝到tomcat的webapps目录下

启动服务器

访问：
http://ip:port/appname/url-pattern

MyEclipse对tomcat进行集成：
window --> preferences --> 搜tomcat --> 对应的版本进行配置(CATALINA_HOME)
选择Enable

dya-10

Java Web
J2SE
Standard Edition
J2EE
Enterprise Edition
Web开发网站开发
J2ME

Web应用程序
Web应用程序的目录结构
根目录
一些公共资源
WEB-INF
一些私有资源
classes
lib
web.xml

根目录
Web应用程序的根目录
属于某个Web应用程序的所有资源都要放在该应用程序的根目录下
资源
程序中的所有文件都是当前程序的资源
包括：
类、接口的字节码文件
程序依赖的jar文件
页面文件
配置文件
js、css文件
图片等其他文件
公共资源
直接放在Web应用程序的根目录下
可以通过浏览器直接访问
私有资源
放在WEB-INF目录下的
不能通过浏览器直接访问，需要通过程序才能访问的到
WEB-INF目录
该目录对浏览器是不可见的
classes目录
存放字节码文件
web应用程序的类加载路径
lib
存放jar文件
web.xml
web应用程序的部署描述符文件
包含了web应用程序的配置和部署信息

web应用程序定义
由一组资源组成
以结构化的有层次的目录形式存在
运行在web服务器上
的程序

使用MyEclipse开发Web应用时，需要了解：
WebRoot目录
该目录与Web应用部署后的根目录对应
放在该目录下的所有内容就是部署后的Web应用程序的内容
src
该目录是我们写Java源代码的地方
一些配置文件
对应了web应用程序的类加载路径
MyEclipse会帮我们把Java源文件编译成字节码文件，并输出到WebRoot目录下的WEB-INF目录下的classes目录下
不能编译的配置文件会直接输出到classes目录下

MyEclipse允许直接创建一个Servlet类，并帮我们配置好Servlet
右键 --> New --> Servlet（others --> Servlet）可以修改servlet name mapping url
ctrl + N

修改部署后的Web应用程序的名字
右键项目 --> properties --> 搜索web --> web context-root

Servlet类由Servlet容器负责实例化，service方法也是由容器通过Servlet对象调用的

请求数据和响应数据
请求数据浏览器向服务器发送的数据
响应数据服务器向浏览器发送的数据

请求参数
以name1=value1&name2=value2&name3=value3...形式发送给服务器的数据
name=dsfdas&age=123&hobbies=1&hobbies=2
HttpServletRequest接口
HttpServletRequest对象封装了客户端的请求信息
容器在调用Servlet对象中的service()方法时，会为service()方法传入一个HttpServletRequest接口的实现类的对象
该实现类是由服务器实现的
方法：
String getParameter(String)
要获取的请求参数值的名字
返回值返回指定名字的请求参数的值
如果请求参数中没有指定名字的参数，则返回null
如果指定参数有多个值，则只能获得值列表中的第一个值
String[] getParameterValues(String)
返回指定请求参数的所有值
如果请求参数中没有指定名字的参数，则返回null
HttpServletResponse接口
HttpServletResponse对象封装了发送给客户端的响应数据
容器在调用service()方法时，会为service()方法传入一个HttpServletResponse接口的实现类的对象
该实现类是服务器实现的

方法：
PrintWriter getWriter()
获得将字符数据写出到响应内容的字符输出流

Servlet的运行过程
浏览器发送请求到达服务器
浏览器会将请求中的所有数据打成一个包
封装成一个对象(HttpServletRequest的实现类的对象)
同时还会创建一个响应对象(HttpServletReponse接口的实现类的对象)

服务器会根据请求路径
url http://ip:port/appName/servletPath?参数1=值&参数2=值2...

查找访问的web应用
查找要访问Servlet
在当前web应用的web.xml文件查找
匹配的url-pattern ---> servletName ---> Servlet类

调用该Servlet的service方法处理当前请求，并会将服务器创建好的request和response对象传给该service方法
在service方法中：
通过request对象可以获得请求中的数据
通过response对象，可以提供响应数据

服务器根据response对象生成响应结果发送给客户端(浏览器)

在请求到Servlet之前：
服务器已创建好请求、响应对象
然后会传给service方法
service把请求处理完后，请求、响应对象还要传回给服务器
服务器根据响应对象，生成响应结果发送给客户端

HTTP协议
Hypert Text Transport Protocol
超文本传输协议
协议是约定好的通信规则

定义了浏览器与Web服务器之间，数据的传输过程与数据的格式

传输过程
无状态协议
一次请求，一次响应，响应完成后连接就会被关闭

浏览器向服务器发送连接请求
浏览器与服务器之间建立连接
浏览器向服务器发送请求数据
服务器处理请求，生成响应
服务器发送响应数据给浏览器
服务器关闭连接

浏览器如果需要再次发送请求，需要重新建立新的连接

数据格式
请求格式
请求头(请求头中的字符的编码只能是ISO8859-1,如果存放了文件，则中文字符会被转码)
请求行
请求方式(GET/POST)
请求路径(url)
对于GET请求
请求参数以?传参的形式，紧跟在请求URL后面
请参数都存放在请求头中
协议版本号(HTTP1.0/HTTP1.1)
若个消息头
消息头是浏览器与服务器之间约定的一些通信规则
由W3C定义的
如访问的服务器的地址、浏览器的信息、语言、cookies
请求体
用于存放post请求方式的请求参数
name=dsfdas&age=123&hobbies=1&hobbies=2
get方式，没有请求体
响应格式
响应头
响应行
协议版本号
状态码
服务器告诉浏览器发生了什么事情
200 响应成功
404 资源不存在
500 服务器内部程序出错
>=400 都是错误

响应体
用于存放响应数据(如html)

GET /webApp/sayHello?name=zhangsan&age=23&hobbies=1&hobbies=2&hobbies=3 HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:48.0) Gecko/20100101 Firefox/48.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Connection: keep-alive
Upgrade-Insecure-Requests: 1
------------------------------------------------------------------------
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Content-Length: 23
Date: Mon, 16 Jan 2017 06:15:26 GMT

请求方式
<form action> <a href> <img src> <script src> <link href> 都可用于访问资源，发送一个请求，来请求资源
get
表单的默认提交
<a href> <img src> <script src> <link href>
通过浏览器地址栏直接发送的请求
通过js改变location
post
表单提交
<form method="post">

get/post区别
GET/POSt方式存放数据的位置不同
get 请求头中
post 请求体中
数据大小
get 提交的数据大小是有限制
post 大小无限制
安全性
get 不安全
post 较安全

公司员工添加
写添加页面
姓名
工资
性别
学历
兴趣爱好

mysql:
create database web charset=utf8;
create table t_emp(
id int primary key auto_increment,
name varchar(20),
salary double,
sex varchar(1),
edu varchar(1),
hobbies varchar(20)
);

oracle jdbc:oracle:thin:@ip:1521:<database_name>

AddEmpServlet
//获得提交数据

//保存数据

//返回响应

显示员工列表

<<<<<<< .mine

=======

windows \r\n
linux/unix \n
mac \r

>>>>>>> .r82

day-11
响应重定向
HttpServletResponse
sendRedirect("重定向的位置")
重定向到指定的位置
重定向的过程
一次请求后，浏览器收到了服务器的一个响应
响应告诉浏览器重新发送一个请求，浏览器紧接着自动发送一个请求
由于是浏览器自己又重新发了一个请求，所以浏览器地址栏地址会发生改变

重定向的请求是GET请求

状态码
302
表示重定向(重新发送请求) Location

HTTP/1.1 302 Moved Temporarily
Server: Apache-Coyote/1.1
Location: http://127.0.0.1:8080/webApp/list
Content-Length: 0
Date: Tue, 17 Jan 2017 01:39:29 GMT

路径
相对路径
不以/开头的路径
相对于当前浏览器地址栏的位置
不是相对于文件所在的目录

相对于浏览器路径中的最后一个/
可以用.. 表示上一层路径

http://ip:port/appName/imgs/ly.gif

绝对路径
以/开头的路径

开头的/表示的是端口号后面的/
<form action="/xxx">
<a href>
<img src>
<script src>
<link href>

重定向 response.sendRedirect("/")

http://ip:port/xxx

应用名后的/
请求转发 include
request.getRequestDispatcher("/xxx")
/appName/xxx

HttpServletRequest方法
//应用的上下文路径应用的根目录
request.getContextPath()
//访问某个Servlet时指定的路径 servlet的访问路径
request.getServletPath()
//请求url
request.getRequestURL()
//contextPath + servletPath
request.getRequestURI()

getRemoteAddr()
获得客户端的IP地址

getRemotePort()
获得客户端端口号

getMethod()
获得请求方式

getParameter(String)
getParameterValues(String)
Map<String, String[]>getParamterMap()
返回所有的参数的名字与对应的值数组组成的Map集合

{name=[Ljava.lang.String;@3667e137}
{name=[Ljava.lang.String;@5df2fdc8}
{name=[Ljava.lang.String;@7bf385a7}

解决中文乱码
请求数据的编码格式跟浏览器有关，所使用的编码就是打开页面时所使用的编码
在程序中，只是告诉服务器用什么编码解析，如果告诉它的编码与浏览器传过来的数据的编码不一致，仍会乱码
请求
POST
request.setCharacterEncoding("编码名");
告诉容器 (tomcat) 解析请求体中的数据所使用的编码
只对post有效
一定要在解析数据前就设置
GET
new String(request.getParameter("name").getBytes("ISO8859-1"),"UTF-8")
响应
response.setCharacterEncoding("编码名")
将响应数据转换为指定的编码
告诉服务器将数据以指定编码传送给浏览器
response.scharset=utf-8");
告诉服务器响应数据的格式字符编码etContentType("text/html;
将响应数据转换为指定的编码
告诉服务器将数据以指定编码传送给浏览器
告诉浏览器使用指定的编码解析响应数据，并使用指定编码打开页面

一定要在获得输出流之前就设置

day-12

复选框、单选框
如果什么都没选，提交时不会提交name，获得参数值-->null
域元素
如单行文本框、密码框、文本域等
会提交名字为name的参数，值为""

配置Servlet
web.xml
<servlet>
用于声明一个Servlet
<servlet-name>
给Servlet指定一个名字
唯一
名字可以为空字符串，只能有一个
<servlet-class>
指定Servlet类的全限定名

<servlet-mapping>
用于定义Servlet和请求路径之间的对应关系

<servlet-name>
指定使用哪个Servlet
<url-pattern>
指定什么样的请求路径是与当前Servlet对应的

url-pattern的3中形式
路径匹配
以/开头的url-pattern
先去掉用请求url的http://ip:port/appName
精确匹配
/xxx
可以使用多层路径
/xxx/yyy/zzz...
通配符*匹配
* 表示任意个(包括0)任意字符 / . *
必须以/开头，以/*结尾否则认为是普通字符*

通过getServletPath()获得servletPath时，不会输出与*匹配的部分

扩展名匹配
*.xxx
* 表示任意个(包括0)任意字符 / . *
只有这一种形式
只比较扩展名是否匹配

* 前后不能有任何的/
/*.do 错误
*.do/action 错误

通过getServletPath()获得servletPath时，会输出与*匹配的所有部分

默认匹配
/
配置默认的Servlet
没有找到匹配的Servlet时，使用该Servlet来处理请求

匹配顺序
容器会进行：
1.精确匹配
2.通配符路径匹配
3.查找扩展名匹配
4.默认匹配
5.404
只要找到了一个匹配的，则不会继续往下找

Servlet基本API
is a 是
继承
实现
has a 有
组合
人和心脏
聚合
车与发动机
关联
人与车
use a 用
依赖
人与火车
创建一个Servlet类的根本途径就是实现Servlet接口

Servlet接口
init(ServletConfig config)
初始化方法
Servlet实例化后，Servlet容器会自动调用该方法，并传递一个封装了当前Servlet配置信息的ServletConfig对象
在让Servlet处理请求之前，完成一些初始化操作

service(ServletRequest request, ServletResponse reponse)
服务方法
容器会调用该方法来处理客户端的请求，并会把创建好的request、resonse对象传给该方法
destroy()
销毁方法
当前Servlet对象从容器中移除时自动执行
可用于释放当前Servlet所占用的一些资源

停止服务器

GenericServlet抽象类
表示一个通用Servlet，不和具体的协议关联

只有一个抽象方法：service(ServletRequest,ServletResponse)

为destroy()方法提供了空实现

额外提供了一个无参init()方法

为init(ServletConfig)方法提供了实现：
将接收到的ServletConfig对象，保存了下来，赋值给一个属性
调用无参的init()

ServletConfig getServletConfig(){
reutrn this.config;
}

HttpServlet抽象类
专门用于HTTP协议的Servlet
里面没有抽象方法

实现了Servlet接口中定义的service(ServletRequest,ServletResponse)方法：
首先把接收到的参数值，强转成HttpServletRequest、HttpServletResponse
然后调用自己额外定义的service(HttpServletRequest,HttpServletResponse)
额外提供了
doGet(HttpServletRequest,HttpServletResponse)
doPost(HttpServletRequest,HttpServletResponse)
根据所使用的http协议的版本号，直接响应SC_METHOD_NOT_ALLOWED（405）、SC_BAD_REQUEST
service(HttpServletRequest,HttpServletResponse)
根据不同的请求方式，调用对应的doXxx(HttpServletRequest,HttpServletResponse)

当一个请求到达服务器后，服务器找到用于处理该请求的Servlet后：
调用Servlet接口service(ServletRequest,ServletResponse)
-->HttpServlet提供的service(HttpServletRequest,HttpServletResponse)
-->doGet()、doPost()

服务器只认识Servlet接口，即只认识Servlet接口中定义的方法

创建Servlet对象的时机：
默认
第一次请求处理时
<servlet>
<load-on-startup>n</load-on-startup>
n>=0
用于配置服务器启动时，就去创建当前Servlet的对象
n代表加载顺序，数字越小，越先加载

创建对象用的是无参的构造方法

Servlet对象是单例的
所以Servlet中的属性是线程不安全的
多个人同时对同一个属性进行修改操作时，就会出问题

Servlet生命周期
Servlet运行在Servlet容器中，其生命周期是由容器管理

加载、实例化
加载实例化的时机
初始化
实例化之后，调用init(ServletConfig )
处理请求
调用service(ServletRequest,ServletResponse)对请求进行处理
服务终止
Servlet实例从容器中移除
移除之前调用destroy()

JSP
静态页面
内容都是写死的
动态页面
页面是在程序运行时，通过某种技术动态生成的

JSP其实就是Servlet

Java Server Page
是一种服务器动态生成页面的技术
使用它可以在HTML代码中插入Java代码和JSP标签
生成一个扩展名为.jsp的文本文件，jsp文件

html 运行在客户端
jsp 运行在服务器中

作用
简化页面的开发

Servlet 负责处理业务逻辑
JSP 负责处理显示逻辑(显示界面)

JSP文件在第一次被用户请求时，会被转换成一个Servlet类，然后由这个Servlet来处理用户的请求，JSP是运行时的Servlet
JSP文件的两个阶段：
转换阶段
当有对jsp页面的请求时，jsp容器会检查jsp页面的语法是否正确
将JSP文件转换为Servlet源文件
调用javac工具将源文件编译成字节码文件
执行阶段
Servlet容器加载字节码文件，并实例化一个对象，处理请求
请求处理完后，将响应对象交还给容器
容器将HTML格式的响应数据发送给浏览器

在JSP执行时，JSP容器会检查JSP文件是否有修改
如果有修改，JSP重复上面两个阶段
如果没有修改，会直接使用之前产生的Servlet对象处理请求

JSP文件的组成：
模板数据
是jsp容器不处理的部分
如HTML内容
元素
是JSP容器会处理的部分

指令
脚本
动作
指令元素
<%@ 指令名属性名="属性值" %>
在.jsp转换成.java时，要求JSP引擎做的一些额外的处理

page指令
提供了很多与页面相关的属性
language="java"
用于指定在脚本元素中使用的脚本语言
默认值java
只能是java
import="java.util.*"
向Java源文件中导入指定的类
多个值之间使用逗号分隔

重复使用page指定中的import
<%@ page import="java.util.*"%>
<%@ page import="java.util.*"%>
默认已导入了java.lang.*、javax.servlet.*、javax.servlet.http.*、javax.servlet.jsp.*
pageEncoding
编写jsp文件时，jsp文件中的字符使用的字符编码
如果没有指定这个属性，则使用contentType属性指定的字符集
如果也没有指定contentType属性，则使用ISO8859-1
contentType
用于指定响应数据的MIME类型和字符编码
如果没有设置个属性，则MIME类型默认text/html，字符编码pageEncoding属性的值
如果也没有指定pageEncoding，默认使用text/html;charset=iso8859-1

脚本元素
写Java代码的地方
声明：
<!%
Java定义语句
定义属性、方法
%>
声明中的内容，会作为生成的Servlet类的成员
脚本段：
<%
Java代码
%>
脚本中的代码，会作为生成的Servlet的service()（_jspService）方法的执行体的内容
表达式：
<%=Java表达式或方法调用 %>

转换规则：
html代码 ------------> out.write("html代码");
指令<%@ %>------------>影响生成Servlet时的源代码
<%!Java代码 %> --------------->直接将中间的代码放到生成的Servlet类体中
<%Java代码%> ----------------->直接将中间的代码放在service方法对应的位置上
<%=Java代码 %>---------------->service()方法中的out.print(Java代码 );

JSP内置对象
request
response
out
等等
响应重定向
response.sendReidrect("重定向的位置")
告诉服务器生成一个重定向响应发送给浏览器
本次请求已处理完

会生成一个302响应给浏览器
该响应告诉浏览器重新发送一个新的请求，到Location消息头指定的位置

浏览器自己又重新发了一个请求
浏览器知道自己又发送了一个新请求，所以浏览器的地址栏会发生改变
重定向发送的请求是一个新的请求，服务器会为之重新创建新的request、response
收到2个响应

请求转发
一个Servlet(JSP)将未完成的请求交给另一个Servlet(JSP)继续处理
request.getRequestDispatcher("/servlet2").forward(request, response);
把当前请求转发给另一个Servlet(JSP)继续处理
需要把当前的请求、响应对象交给它
本次请求还未理完

特点
同一个请求在服务器内部进行传递
客户端只知道自己发了一次请求，所以浏览器地址栏不会发生改变
收到1个响应
转发涉及到的多个组件，使用的都是同一个request、response对象
通过转发可以访问到WEB-INF下的资源

HttpServletRequest
void setAttribute(String name,Object value)
在request对象中保存属性值
key-value
Object getAttribute(String name)

什么时候用重定向
两件事都可以单独完成

什么时候用转发
一件事没做完
需要传数据
访问WEB-INF下的资源

RequestDisptcher
forward 会清空原来的所有的响应数据
include 会保留原来的响应数据

day-14

代码重复
不便于维护
不便于复用

指令元素
用于为转换阶段提供相关的信息

<%@ 指令名属性名="属性值" ... %>
page

include
<%@ include file="relativePath|absPath" />
用于在JSP页面中静态的包含一个文件
发生在转换阶段
在转换阶段
相对于当前JSP文件的位置找到被包含的文件
在使用include的位置处将被包含的文件的内容包含进来，成为一个整体
转换为Servlet源文件

file="relativePath|absPath"
relativePath相对于当前JSP文件的位置
absPath / web应用名后的/

避免在被包含的文件中使用<html>、<body>等标签
避免在被包含的文件中定义同名的变量、非重载同名的方法

taglib

动作元素
用于为请求处理阶段提供信息
会影响JSP的运行时行为
<jsp:动作元素属性1="值1" 属性2="值2" ... >[内容]</jsp:动作元素>
<jsp:动作元素属性1="值1" 属性2="值2" ... />

include
<jsp:include page="relativePath|absPath"></jsp:include>
<jsp:include page="relativePath|absPath" />

作用同RequestDispatcher的include

用于在JSP页面中动态包含一个资源
发生请求处理阶段(执行阶段)
在请求处理时
根据指定的路径找到要包含的资源这是当前JSP页面和被包含的资源是独立的
当前页面将请求转发给被包含的资源
被包含的资源对请求进行处理，处理结果作为当前页面对请求响应的一部分发送给客户端
page="relativePath|absPath"
同RequestDispatcher

forward
<jsp:forward page="relativePath|absPath"></jsp:forward>
<jsp:forward page="relativePath|absPath" />
作用同RequestDispatcher的forward

page="relativePath|absPath"
同RequestDispatcher

include指令、include动作区别
包含时机
include指令转换阶段成为一个整体
include动作执行阶段各个资源仍是独立的

配置欢迎文件列表
<welcome-file-list>
<welcome-file>index.jsp</welcome-file> 可以访问WEB-INF下的资源
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
</welcome-file-list>
服务器默认已配置

ServletConfig
表示Servlet配置
可用于读取配置文件中为Servlet配置的初始化参数

为Servlet配置初始化参数
<servlet>
<servlet-name>servlet2</servlet-name>
<servlet-class>day13.Servlet2</servlet-class>
<init-param>
<param-name>name</param-name>
<param-value>zhangsan</param-value>
</init-param>
<init-param>
<param-name>password</param-name>
<param-value>123</param-value>
</init-param>
</servlet>

ServletConfig
String getInitParameter(String name)
Enumeration getInitParameterNames()

在其他地方使用ServletConfig对象
只需要调用Servlet中getServletConfig()

JSP内置对象 9个
request
HttpServletRequest
请求对象

response
HttpServletResponse
响应对象

out
JspWriter
响应输出流对象

pageContext
PageContext
当前JSP页面的上下文

session
HttpSession
会话

application
ServletContext
Servlet的上下文

config
ServletConfig
ServletConfig对象

page
Object
this
JSP转换后的得到的Servlet类的实例

exception
Throwable
异常对象
只能在<%@ page isErrorPage="true"%>的jsp页面中使用

config
<servlet>
<servlet-name>index.jsp</servlet-name>
<jsp-file>/index.jsp</jsp-file> 必须以/开头可以访问WEB-INF下的资源
<init-param>
<param-name>name</param-name>
<param-value>lisi</param-value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>index.jsp</servlet-name>
<url-pattern>/index</url-pattern>
</servlet-mapping>

exception
指定出错时的错误处理页面：
方式1：在web.xml中配置错误处理页面
<error-page> 配置错误代码或异常类型与错误处理页面之间的对应关系
 指定错误码
<exception-type>java.lang.Exception</exception-type> 指定异常类型
<location>/500.jsp</location> 指定错误处理页面的位置必须以/开头可以访问WEB-INF下的资源
</error-page>

方式2：使用page指令的errorPage属性指定错误处理页面

page指令的属性
isErrorPage
指定当前JSP页面是否是一个错误处理页面
值true、false
默认值false
会影响下面这块代码的生成：
Throwable exception = org.apache.jasper.runtime.JspRuntimeLibrary.getThrowable(request);
if (exception != null) {
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
}
一个JSP页面不是错误处理页面，就不能使用exception内置对象
errorPage
指定当前JSP页面运行发生异常时，要转向的错误处理页面
如果指定了该属性，则在web.xml中配置的对应错误处理页面都将不会被使用

page
类型Object
this
JSP转换后的得到的Servlet类的实例

pageContext
当前JSP页面的上下文，即当前JSP页面运行时的环境，包含了当前页面可以访问的所有信息
JSP容器会为每个JSP实例创建一个PageContext对象，这个对象在JSP页面中可以通过pageContext内置对象来使用
作用
绑定数据
setAttribute(Stering key, Object value)
Object getAttribute(String key)
数据范围
在当前页面的pageContext中绑定的数据，只能在当前页面取

获得其他的内置对象
pageContext.getRequest();
pageContext.getResponse();
pageContext.getOut();
pageContext.getSession();
pageContext.getServletContext();
pageContext.getServletConfig();
pageContext.getException();
pageContext.getPage();

Http状态管理
Http协议是一个无状态协议
每一次请求
需要建立一个新的连接
用完后会释放连接
服务器不会记住谁曾经访问过

为了提高服务器的工作效率
连接会及时释放，可以为更多的客户端服务

cookie技术
将信息记录在客户端
session技术
将信息记录服务器端

cookie
在客户端(浏览器)保存用户状态的一种管理技术

当客户端访问服务器时，服务器可以将少量的数据(通过cookie)发送给客户端
当浏览器接收到这些数据时，会将这些数据保存到客户端机器的硬盘上
当浏览器下一次访问服务器的时候，会将这些数据再发送给服务器
这样浏览器和服务器多次交互，这些数据会一直来回传递
通过这种方式，来维护用户的状态

使用
创建cookie
Cookie cookie = new Cookie(String name, String value);
response.addCookie(cookie);
cookie是在请求头和响应头中传递的只支持ISO8859-1，不支持中文
如果传了中文，需要转码
URLEncoder.encode(String str, String encode)
只对非西欧字符转码，对于一些西欧字符还是保持不变
获得cookie
Cookie[] cookies = request.getCookies();
一次性获得所有浏览器传过来的cookie
如果没有任何cookie，则返回null
Cookie
getName()
getValue()
编码之后的字符，需要解码：
URLDecoder.decode(String str, String encode);
只对编码后的字符解码

cookie的生存时间
默认
会话结束时
浏览器关闭删除保存的cookie
设置cookie生存时间
Cookie
setMaxAge(int secondes) 单位是秒

删除cookie
添加一个同名的cookie
设置生存时间为0

修改
添加一个同名的cookie

封装工具类CookieUtil

cookie限制
只能保存字符串
字符串编码只能是ISO8859-1
cookie的数据大小有限制(大约4k)
cookie保存在客户端，不安全
浏览器可以禁用cookie
浏览器能保存的cookie的数据有限制
session
会话
一次会话可以包括多次请求/响应

在服务器端维护用户状态的一种管理技术

当同一个浏览器或同一个用户第一次访问服务器时，服务器会为之创建一个HttpSession对象
该对象有一个唯一标识sessionId
服务器在默认情况下，会使用cookie技术，将sessionId发送给浏览器保存
JSESSIONID=8955497EEFB156F4B64E10C0BDF5C7B6
当浏览器下次访问时，会使用cookie将sessionId传回给服务器
服务器通过sessionId查找对应的session对象
通过这种方式，可以保存不同用户多次操作的中间结果

使用
获得session
request.getSession()
就是request.getSession(true)
request.getSession(boolean flag)
flag
true
浏览器发送请求
服务器检查请求中是否有sessionId
没有服务器会创建一个新的session对象返回
有
服务会检查该sessionId对应的session对象是否存在
不存在
创建一个新的session对象返回
存在
直接返回该session对象
无新建
有用原来的

false
浏览器发送请求
服务器检查请求中是否有sessionId
没有返回null
有
服务会检查该sessionId对应的session对象是否存在
不存在
返回null
存在
直接返回该session对象
无 null
有用原来的

常用方法
setAttribute(String key, Object value)
setAttribute("name",null)
Object getAttribute(String key)
removeAttribute(String key)

invalidate()
使session失效

setMaxInactiveInterval(int secondes)
与这个session对应用户多长时间没有访问服务器时释放session

会话结束时机
默认不再访问之后30min
浏览器关闭
setMaxInactiveInterval(int secondes)
invalidate()

session作用范围
只要同一个会话不释放放到session中的数据就能取得到
一个session过程中，可以包括多次请求/响应

常用于
登录检查
保存数据
跨请求传递数据
验证码
验证验证码
<img src>
当src的值改变时，浏览器会自动发送请求去重新加载图片

day-17

会话跟踪
维护客户端的状态

cookie
数据保存在客户端
只能保存字符串(ISO8859-1)
安全性较差
客户端分担了服务器的压力
浏览器可以禁用cookie
cookie大小有限制

session
数据保存在服务器端
保存任意类型的对象
相对较安全
所有的数据在服务器内存，增加了服务器的压力
session默认依赖cookie技术实现，但可以通过传就sessionid找到对应的session(URL重写)
服务器时根据用户发送的请求中携带的sessionId来判断当前用户的会话的
只要服务器内存够，随便使用

URL重写
超链接href 表单action
response.encodeURL("地址")
重定向
response.encodeRedirectURL("地址")

day-18

过滤器
过滤器是web规范中定义的一种类型
可以在指定的某些请求发送到目标资源、响应发送到浏览器之前，截获请求、响应对象，预先做一些处理

常用于
编码处理
日志
安全控制
权限控制

开发
1.编写过滤器类
实现Filter接口
实现doFilter方法

2.在web.xml配置
<filter>
<filter-name>logFilter</filter-name>
<filter-class>filter.LogFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>logFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

FilterChain接口
doFilter(ServletRequest request, ServletResponse response)
调用下一个组件
会调用过滤器链中的下一个过滤器
如果当前过滤器链中没有下一个过滤器了，则调用目标资源

过滤器链中的过滤器执行的顺序
和<filter-mapping>配置顺序一致

FilterConfig
表示Filter的配置
可用于读取配置文件中为Filter配置的初始化参数

为Filter配置初始化参数：
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>filter.EncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>

方法：
getInitParameter(String name)

作用域对象

pageContext 当前页面
request 同一个请求
session 同一个会话
application 整个web应用，同一个应用

范围大小 pageContext < request < session < application
存放数据规则能用范围小的不用范围的

ServletContext
Servlet的上下文
表示整个web应用

服务器启动时
会为每一个已经部署的web应用
创建一个唯一的ServletContext对象
该对象会一直存在，直至停止服务器

获得ServletContext对象
HttpServlet
getServletContext()

ServletConfig
getServletContext()

jsp中内置对象application

常用于
绑定数据,使用时注意线程安全问题
setAttribute getAttribute removeAttribute
作用范围
整个web应用
同一个web应用

可以访问全局初始化参数
为web应用配置的初始化参数
<context-param>
<param-name>name</param-name>
<param-value>wangwu</param-value>
</context-param>

application.getInitParameter(String name)

跟整个应用相关的一些方法
application.getRealPath(String path)
返回运行时该目录所在的位置的绝对路径

application.setAttribute("count",1);
count + 1
count - 1

监听器
web规范中定义的一种类型
作用
监听ServletContext、HttpSession、HttpServletRequest对象的创建和销毁事件
以及这三种对象上的数据的绑定、删除、替换的事件
当这些事件发生时，会自动调用在对应的事件监听器中定义的对应事件处理方法
并将当前事件封装成一个事件对象传给事件处理方法

使用
1.创建一个监听器类，实现web规范中提供的监听器接口
用于监听创建和销毁事件
ServletContextListener
HttpSessionListener
ServletRequestListener

绑定、删除、替换数据事件
ServletContextAttributeListener
HttpSessionAttributeListener
ServletRequestAttributeListener
2.配置 web.xml
<listener>
<listener-class>listener.ApplicationListener</listener-class>
</listener>

cookie的生存时间
默认
客户端会话结束时，即关闭浏览器，会删除客户端保存的默认生存时间的cookie
设置
setMaxAge(int sencodes)

会话的结束时机
客户端会话
打开一个浏览器时，就开始了一个客户端会话
关闭浏览器时，结束客户端会话

服务器端的会话
在指定时间内不再使用某个session对象，就会销毁
默认
30min
自己设置
web.xml
<session-config>
<session-timeout>10</session-timeout>
</session-config>
setMaxInactiveInterval(int sencodes)
立即销毁
invalidate()

day-19

文件上传
设置表单提交请求的方式method必须为post
设置表单的enctype属性必须为multipart/form-data
enctype
指定表单提交的数据的编码方式
值
application/x-www-form-urlencoded
默认值
在发送数据前，编码所有字符
multipart/form-data
不对任何数据编码
文件上传时，必须使用该值

enctype="multipart/form-data"
浏览器不再对表单的数据进行编码
以二进制流直接发送给服务器

但是使用request.getParamenter方法无法获得表单提交的数据
需要使用request.getInputStream方法获得请求数据
然后对这个二进制数据进行解析

因为解析二进制数据比较麻烦
需要了解Http协议定义的数据规范
所以一般使用第三方工具来解析

工具做的是解析，不是上传

第三方工具commons-fileupload
commons-fileupload.jar
依赖包：
commons-io.jar

commons
www.apache.org

-----------------------------24499315501126
Content-Disposition: form-data; name="name"

zhangsan
-----------------------------24499315501126
Content-Disposition: form-data; name="file"; filename="a.txt"
Content-Type: text/plain

abcdefghijk
-----------------------------24499315501126--

EL表达式和JSTL标签
在JSP文件不出现Java代码

EL表达式
Expression Language
EL是官方在JSP中定义的一种语法规范

语法
${表达式}

作用
1.能访问作用域对象中的数据
pageContext
request
session
application

${作用域对象中数据对应名字}

默认先从pageContext.getAttribute("key")中找数据
如果没找到，则依次到request、session、application中去找数据
如果在其中某个作用域对象中找到了数据，则不再向下查找
找到以后会输出到浏览器页面中显示
如果没找到，则什么都不显示

也可以使用
pageScope
rquestScope
sessionScope
applicationScope

用于访问指定作用域对象中的数据

2.访问对象中的属性
${对象.属性名}
属性名指的是get/set方法后的单词，首字母小写，之后的名字
EL表达式中没有request、session、application这些内置对象
但有一个内置对象pageContext，通过pageContext可以获得其他的作用域对象
如：获得contextPath ${pageContext.request.contextPath}
访问对象的属性：${对象[属性名字符串]}
访问集合：${集合[index]}
3.运算
EL表达式中可以使用运算符
算术运算符
+ - * /|div %|mod
+不能用于字符串的连接
比较运算符
==|eq !=|ne <|lt >|gt <=|le >=|ge
逻辑运算符
&&|and || |or !|not
empty
用于检测一个对象是否为null
三目运算符
表达式? 值1:值2
圆括号()
4.获得请求参数
内置对象param
${param.参数名}

5.访问自定义方法
EL表达式中不能调用对象的方法，但可以调用自定义方法

自定义方法
1.在一个Java类中定义方法
方法是public static的

2.配置方法
定义一个.tld文件(xml格式)
放在WEB-INF目录下

3.在JSP的EL表达式中使用
<%@ tablib uri="在tld文件中指定的uri，通过该uri用于找到自定义的方法" prefix="指定调用自定义方法时所使用的前缀，习惯和tld文件中配置的short-name"%>
${前缀:tld中定义的方法名(实参列表)}

JSTL
Java Server Page Standard Tag Library
是由官方提供的一套标签

<c:if test>
<c:forEach>
items 指定要循环集合或数组通过EL表达式获取
var 用于指定一个变量的名字，这个变量用于保存当前正在遍历的元素这个变量放在NESTED作用域中作用域范围是当前标签的标签体
varStatus 用于指定一个变量的名字，这个变量保存了当前的迭代状态是一个LoopTagSupport对象 NESTED
LoopTagSupport对象中的常用属性：
index 当前正在遍历的元素的下标从0开始
count 到当前为止，已遍历的元素的个数从1开始
current 当前正在遍历的元素

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

<c:catch var>
<c:url value>
<%=request.getContextPath()%>/servletPath
${pageContext.request.contextPath}/servletPath
<c:url value="/servletPath">
<c:import url>
<c:redirect >
<fmt:formatDate>

alter table t_order add createDate date;

自定义标签
简单的自定义标签开发
1.写一个Java类
继承SimpleTagSupport
重写doTag()

2.配置自定义标签
配置在一个tld文件中
放在WEB-INF下
3.在JSP中使用，使用之前要引入，taglib指令

<my:dateFormate value="${xxx}" pattern="yyyy/MM/dd">

day-21

Ajax
传统的请求/响应模式
请求-->等待-->响应模式
浏览器发送请求时，会发送所有的请求数据
在服务器处理请求时、浏览器完全接受到响应数据之前，要求浏览器不可以去做其他的操作
不允许浏览器再发送其他的请求，要求浏览器等待响应完成
通过重新加载整个页面的内容来获取数据

缺点
用户体验不友好，服务器返回响应之前、浏览器完全接收到响应数据之前，要求用户不能操作页面的其他功能
因为服务器必须将整个页面的数据传输给浏览器，浏览器也必须把所有的请求数据发送给服务器，所以造成浏览器与服务器之间传输了大量的冗余数据，对性能有影响
用户已填写数据在验证失败后，会全部丢失，用户需要重新填写

Ajax请求/响应模式
发送请求时，不会发送所有的数据，只需要发送希望发送的数据
从同一个页面中可以同时发出多个请求，这多个请求间互不影响，对这些请求的响应也互不影响，即发送是异步请求
不会去重新加载页面，页面中已经输入的数据不会丢失，只会加载希望加载的数据
JS中可以获得Ajax请求的响应数据，通过JS操作DOM，通过DOM操作可以实现页面的局部更新

Asynchronouse JavaScript and XML
异步请求

是为了改善传统的web应用中请求-等待-响应这种模式的弊端

使用JavaScript，调用浏览器提供一个对象(XMLHttpRequest，js对象，可以称为ajax引擎)
向服务器异步的发送请求
此时浏览器不会丢失任何数据
用户仍然可以操作页面的其他功能
当服务器返回响应数据(文本或xml)之后
JavaScript可以操作这些响应数据
更新DOM
用户的界面可以实现局部更新，不会刷新整个页面

Ajax编程
获得XMLHttpRequest对象
function getXMLHttpRequest(){
var xmlHttpRequest;
//考虑浏览器的兼容性
if(typeof XMLHttpRequest != "undefined"){
xmlHttpRequest = new XMLHttpRequest();
}else{
xmlHttpRequest = new ActiveXObject("Mircrosoft.XMLHTTP");
}
return xmlHttpRequest;
}
XMLHttpRequest对象
open方法
准备请求信息
参数
1.用于指定请求方式，get/post
2.请求路径
3.发送的是不是异步请求，true|false，一般用true
send方法
发送请求
参数
post请求的请求参数
readyState属性
表示XMLHTTP请求的当前状态
0 (未初始化状态)对象已创建，但尚未初始化
1 (初始化状态)对象已创建，请求信息已准备好，尚未调用send方法
2 (发送请求数据)send方法已调用，但当前的响应状态码和Http头未知
3 (接收响应数据中)已经接收到部分响应数据，但还未全部接收到
4 (响应结束)响应数据接收完毕

//XMLHttpRequest对象状态为4 服务器正确的处理了请求，即响应状态码200
if(xmlHttpRequest.readyState == 4 && xmlHttpRequest.status == 200){
alert(xmlHttpRequest.responseText);
}

onreadystatechange属性
指定当readyState属性值(XMLHTTP请求的状态)发生改变时执行的函数

responseText属性
获得响应文本

post请求方式
请求参数作为send的参数发送：name1=value1&name2=value2...
在发送请求前(send方法执行之前)，设置一个请求头xmlHttpRequest.setRequestHeader("Content-Type","application/x-www-form-urlencoded");

跨语言传输数据
文本
普通字符串 "用户名已存在"

JSON格式字符串
一定格式的字符串
JSON对象格式字符串：'{"id":1,"username":"zhangsan", "phone":"123","address":"sfsdafsdaf"}'
JSON数组格式字符串：'[{"id":1,"no":"1231231"},{"id":2,"no":"1231231"},...]'
window.eval(string)
执行一段JS代码，JS代码即字符串参数的内容
返回这段JS代码的执行结果
eval("(" + jsonStr +")")
JSON.parse(jsonStr)

JSON工具
json-lib-version.jar
需要依赖一些其他的jar包

xml格式的字符串

事件处理函数参数
Event e

e.clientX
e.clientY
事件发生时，鼠标光标相对于当前内容区的x、y坐标
内容区的最左上角坐标是(0,0)

create table t_data(
keyword varchar(20),
content varchar(60)
);

JQuery Ajax
$.ajax(options)
options可选 $.ajax();
options是一个JS对象，为Ajax请求提供一些设置
$.ajax({async:true,type:"post", url:"${pageContext.request.contextPath}/xxxx",data:{name:"zhangsan",age:"123"}});
可设置的项：
async
指定发送的请求是不是异步请求
boolean
默认true
注意，同步请求将锁住浏览器，用户其它操作必须等待请求完成才可以执行
type
指定请求方式
string
默认值get
url
指定发送请求的地址
string
默认当前页面的地址
data
指定发送到服务器的数据，请求参数
object
会自动转换为请求参数格式
string
请求参数格式的字符串 name1=value1&name2=value2...
get请求方式，请求数据会被自动附加在请求URL后面
dataType
预期服务器返回的数据类型
string
text
json
"\"abc\""

xml
如果不指定，则根据相应数据类型自己判断
success
对应了xmlHttpRequest.readyState == 4 && xmlHttpRequest.status == 200
指定的是请求成功后执行的函数
function

在执行该函数时，会根据dataType对响应数据做转换，然后传给该函数的第一个参数
JSON对象格式字符串 --> JS对象
JSON数组格式字符串 --> JS数组
error:function(xmlHttpRequest,textStatus,errorThrown){
alert(textStatus);
alert(errorThrown);
}

$.get(url, data,callback,dataType)
以get方式发送Ajax请求
url
请求地址
string
data
请求参数
object
string
请求参数格式字符串
callback
请求成功后执行的函数
dataType

$.post(ur,data,callback,dataType)
以post方式发送Ajax请求
请参考$.get

$.getJSON(url,data,callback)
参数同上
以get方式发送Ajax请求，响应数据格式为json

load(url)
请求加载html格式的数据，插入DOM中
异步请求

serialize()
序列化表单数据为请求参数格式字符串

Ajax事件
监听全局的Ajax事件，只要当前页面中发生了某一个Ajax事件，对应的事件处理函数就会被调用一次
ajaxStart(function)
ajaxStop(function)

ajaxSend(function)
ajaxSuccess(function)

ajaxError(function)
ajaxComplete(function)

jquery1.9 全局Ajax事件，只能在document对象上触发
1.9以前，可在任意对象上触发

html() 获得或设置HTML内容 <div id="d"><font color="red">abc</font></div>
text() 获得或设置文本
val() 获得或设置value属性的值

day-23

MVC
Model 数据模型
View 视图
Controller 控制器

是一种软件架构的开发模式
是一种设计思想

将一个操作分成了三种不同的部分

Model 封装了业务逻辑，对于业务数据按一定的规则进行加工处理
负责处理数据

View 封装了显示逻辑
负责处理显示

Controller
协调视图和模型
请求不再直接发送给模型和视图
而是统一交给控制器

由控制器来分发给合适模型来处理
模型处理后，也不再直接访问视图

而是统一的交给控制器
由控制器分发给合适的视图来处理

视图处理之后，生成显示界面返回给用户

负责管理程序的流程

优点
多个视图可以共享同一个模型
不同的部分方便维护

使用者关心的是URL
方便工作分配

缺点
MVC只是一个设计思想，对于实际的系统，需要做详细设计
增加了代码量

Struts1
MVC框架，是对MVC的实现

为项目添加struts1支持：
MyEclipse插件：右键项目 --> MyEclipse --> add Struts Capabilities

使用Struts1的目的
是编写的程序符合MVC架构

使用Strut1框架进行开发的步骤：
1.编写Action类(Model)
1)自定义一个类，使之继承Action类
重写execute方法
2.编写JSP文件(View)
3.在struts-config.xml文件中做配置

程序执行过程：
浏览器发送*.do-->ActionServlet(C)
-->struts-config.xml的<action>
-->根据配置的type找到一个Action类，调用该类中定义的业务处理方法
-->return mapping.findForward(String forwardName)
-->path

ActionMapping mapping
一个ActionMapping对象对应了配置文件中的一个<action>配置
ActionForward findForward(String forwardName)
将找到的<forward>信息封装成一个ActionForward类型的对象，返回给控制器
业务处理方法在返回值时需要用到
ActionForward
一个ActionForward对象对应了配置文件中的一个<forward>配置

Struts配置
<action path forward >
告诉控制器直接将请求路径为path的请求直接转发给forward指定的资源

例：

<action path="/showRegist" forward="/WEB-INF/private/regist.jsp"></action>

<action path type >
告诉控制器请求路径为path调用type指定的Action类的execute方法处理
例：

<action path="/regist" type="action.HelloAction">
<forward name path redirect>
告诉控制器名字为name的处理结果使用redirect指定的方式跳转path指定的资源
注意：
redirect默认值为false
path
这个资源可以是另一个已配置的action
跳转路径要加扩展名
如果是重定向，控制器会帮我们在path指定的路径前拼上应用路径，即request.getContextPath() + path
例：

<forward name="success" path="/showHello.do" redirect="true"></forward>

ActionForm form
用于接收请求参数
使用步骤：
1.编写ActionForm类
自定义一个类，使之继承ActionForm类
定义属性
提供get/set方法
要求属性名和要接收的请求参数同名
如果属性是一个复合类型的属性
该属性必须手动实例化
请求参数的名字必须为 actionForm属性名.属性名
2.struts-config.xml配置
在<form-beans>中，使用<form-bean>进行配置
<form-bean>属性
name 指定一个名字
type
指定ActionForm的完整类名
3.使用
<action name>
name属性
用于指定要使用的ActionForm的名字
该名字是在<form-bean>中使用name属性指定的
例：
<form-beans >

<form-bean name="registForm" type="form.RegistForm"></form-bean>
</form-beans>

<action path="/regist" type="action.HelloAction" name="registForm">

Struts1的异常处理机制
声明业务处理方法出现type指定的异常时，要处理
<action input="errorPage的位置">
<exception key="错误消息的key" type="异常类的完整类名">
</action>
在ApplicationResource.properties文件中指定错误消息：
错误消息的key=错误消息（可以写HTML代码）

在JSP中通过Struts1提供的<html:errors>标签来获得错误消息
标签库的tld文件：/WEB-INF/struts-html.tld

业务处理方法返回null
return null;
Ajax请求时，返回的数据数据是JSON格式字符串
文件下载
out.print();

编写Action类(Model)
2)
自定义一个类，使之继承DispatchAction类
自定义业务处理方法，可定义多个
注意：
自定义的方法除了方法名不叫execute之外
方法声明的其余部分都要与execute方法相同

当Action类是通过继承DispatchAction类来定义时：
<action parameter>
parameter属性
指定
请求参数中
用于指定要执行的方法的
请求参数的名字

一个Action类只需要配置一个<action>
3)
自定义一个类，使之继承MappingDispatchAction、
自定义业务处理方法，可定义多个
注意：
自定义的方法除了方法名不叫execute之外
方法声明的其余部分都要与execute方法相同

当Action类是通过继承MappingDispatchAction类来定义时：
<action parameter>
parameter属性
指定要执行的方法的名字

一个方法对应了一个<action>配置
使用Struts1时，常用的自定义Action类的方式

day-24

XML
Extendsible Markup Language
可扩展标记语言
没有固定标签，可任意创建新的标签

作用
保存数据和传输数据

xml文件
文本文件
扩展名.xml

形式良好的xml文件，符合xml语法
合法的xml文件，形式良好的且符合规范
<?xml version="1.0" encoding="UTF-8"?>
XML声明
xml表示是一个xml文件
xml版本
内容的编码

<![CDATA[
<a></a>
>< " ' <
纯文本
]]>
规范(了解)
DTD
Schema

解析
jdk解析方式

第三方解析方式
dom4j
SAXReader
用于读取并解析xml文件的工具
创建实例SAXReader reader = new SAXReader();
方法
read(InputStream|InputSource|Reader|URL)
读取并解析参数指定的xml文件
解析之后xml文档会变成内存中dom4j自己做的一颗树
返回表示整个文档的Document对象
Document
表示整个XML文档
封装了XML文档的所有内容
方法：
Element getRootElement()
Element
从开始标签开始，到结束标签结束的全部，成为一个元素
一个Element对象表示文档中的一个元素，封装了一个元素的所有数据
方法：
获得元素名字
getName()

获得元素的属性
String attributeValue(String attrName)
返回指定名字的属性的值
Attribute attribute(index)
根据属性的位置获得属性
index从0开始
返回Attribute对象
Attribute attribute(String name)
返回指定名字的属性
Attribute对象
List<Attribute> attributes()
返回所有的属性
Iterator<Attribute> attributeIterator()
返回所有属性的迭代器

获得子元素
Element element(String elementName)
返回指定名字第一个子元素
List<Element> elements(String elementName)
返回指定名字的所有子元素
List<Element> elements()
或的所有的子元素
Iterator<Element> elementIterator()
获得所有子元素的迭代器

获得元素的文本内容
getText()
getTextTrim()
Attribute
表示元素的一个属性
主要封装了一个属性的名字、值信息
方法：
getName()
getValue()

commons-digester
将xml文件的内容转换为Java中的对象
1.自定义类
2.提供一个digester的配置文件规则文件
<pattern value="元素名">
配置一个元素的处理规则
3.解析XML文件
//获得解析器，加载配置文件
Digester digester = DigesterLoader.createDigester(url);

//准备一个空的根元素对应的对象
Clazz clazz = new Clazz();

//将这个对象交给解析器digester，与文档的根元素对应
digester.push(clazz);

//解析xml文件
digester.parse(TestDigesterParser.class
.getClassLoader()
.getResourceAsStream("students.xml"));

rule.xml

<pattern value="class">

<set-properties-rule></set-properties-rule>


<pattern value="student">

<object-create-rule classname="entity.Student"></object-create-rule>


<set-properties-rule></set-properties-rule>



<bean-property-setter-rule pattern="name"></bean-property-setter-rule>



<set-next-rule methodname="addStudent"></set-next-rule>
</pattern>
</pattern>

<?xml version="1.0" encoding="UTF-8"?>
<action-mappings >

<action path="/regist" type="action.UserAction" parameter="regist">
<forward name="success" path="/showHello.do" redirect="true"></forward>
<forward name="fail" path="/WEB-INF/private/regist.jsp"></forward>
</action>

<action path="/login" type="action.UserAction" parameter="login">
<forward name="success" path="/showHello.do" redirect="true"></forward>
<forward name="fail" path="/WEB-INF/private/regist.jsp"></forward>
</action>
</action-mappings>

action-mappings ModuleConfig
action ActionConfig path作为map的key
forward ForwardConfig name作为map的key

day-25

分层作用
降低耦合度
提高复用度
便于维护
面向接口编程
降低耦合度
方便工作分配，便于协同开发

表示层
显示逻辑
跟用户做数据交互
数据合法性校验
调用业务层完成核心业务逻辑

业务层
处理核心业务逻辑
调用持久化层完成持久化操作
交叉业务逻辑(事务、日志、安全等)

持久化层
处理单一的持久化操作

action 表示层的model
service 业务层接口
service .impl 业务层实现类
dao 持久化层的接口
dao.impl 持久化层实现类
constant 常量
entity 实体
util 工具类
vo 值对象
exception 异常

day-26

MyBatis
是一个开源的
持久层框架

前身
IBatis

持久层框架，需要我们提供的信息：
驱动
url
用户名
密码

sql
orm
两种配置文件
config配置
习惯叫做mybatis-config.xml

连接信息
系统环境变量
mpper配置
习惯叫做XxxMapper.xml

sql语句
映射信息

添加mybatis配置文件的dtd到MyEclipse：
window --> preferences --> xml catalog --> Add --> 选择dtd文件

config
key:-//mybatis.org//DTD Config 3.0//EN
web address:http://mybatis.org/dtd/mybatis-3-config.dtd
mapper
key:-//mybatis.org//DTD Mapper 3.0//EN
web address:http://mybatis.org/dtd/mybatis-3-mapper.dtd

创建xml文件：new --> xml -->basic templates --> mybatis-config.xml/XxxMapper.xml
-->next --> create from DTD file --> next --> XML Catalog -->选择前面配置的dtd

持久层框架
底层是jdbc
关心：对应关系

orm
对象关系映射

表类
字段属性
关系关系
实现原理：反射+配置(配置文件、注解@xxx)

<mapper namespace="">
namespace
任意指定或必须指定为dao接口完整名字
建议指定为对应接口的完整名字
<select id="">
为当前配置指定一个名字
任意指定或必须指定为对应方法的名字
建议指定为对应方法的名字
#{paramName}
参数名
任意指定或必须指定为属性名、key

MyBatis常用API
SqlSessionFactoryBuilder
是SqlSessionFactory的创建者，用于创建工厂
new SqlSessionFactoryBuilder();
方法：
SqlSessionFactory build(InputStream)
读取config配置文件
并创建一个SqlSessionFactory对象返回

SqlSessionFactory
创建SqlSession对象的工厂
使用SqlSessionFactoryBuilder的buil方法
线程安全

SqlSession
会话，持久化管理器
用于持久化操作
SqlSessionFactory#openSession()
打开一个新的会话
线程不安全

执行具体操作的方式：
方式1：
SqlSession的方法：
select(String,Object)
selectOne(String,Object)
delete(String,Object)
update(String,Object)
insert(String,Object)
参数：
String namespace.id
Object sql语句需要的参数
调用SqlSession中的方法去访问数据库时，
通过mapper配置的namespace和标签id来
确定要执行的sql语句，这时只要名字匹配就能找到
使用这种方式：
mapper配置文件中的namespace和id可以任意指定

方式2：
通过dao层接口的实现类的对象调用方法
通过SqlSession#getMapper(Calss)方法获得指定dao接口类型的对象
使用这种方式：
要求namespace必须为对应接口名
要求id必须为对应方法名

mapper配置文件相当于该接口的实现
实现类的实际类型是一个内存中的动态代理类型

注解方式提供mapper配置：
在方法上，通过使用注解来提供当前方法需要的sql语句
然后在config配置文件的<mappers>标签中，
使用<mapper class="接口完整整名">，
告诉config配置文件需要注册的接口

使用MyBatis步骤(方式2)：
1.准备数据库
2.创建表对应的实体类
3.添加数据库驱动和mybatis的jar
4.创建config配置配置文件
数据库连接信息
事务管理器
5.定义dao层接口，定义方法
6.创建mapper配置文件
namespace必须指定为对应的接口的完整的名字
select、insert、delete、update标签的id必须指定为对应方法的名字
7.在config配置文件中，配置mapper配置的位置
resource
class
8.通过MyBatis访问数据库：
SqlSessionFactoryBuilder 读取config配置文件，创建SqlSesssionFactory对象
SqlSesssionFactory 用于创建SqlSession对象
SqlSesssion 持久化管理器
9.关闭sqlSession

config配置
properties
访问properties文件
<properties resource="dataSource.properties"></properties>
resource 指定的是相对于类加载路径位置
访问语法：${key}

<typeAliases>

<package name="entity" /> 对于配置文件中使用的没有包名的类，都认为是该包下的类
</typeAliases>

environments
配置多个数据库环境
default属性
当在程序中，未明确表明使用的是哪个environment时，默认使用的环境

environment
配置一个数据库环境
配置连接信息和事务管理器

id
为整个environment起一个名字

transactionManager
配置事务管理器
type
JDBC
自己管理事务，使用JDBC管理事务
MANAGED
什么都不做，事务交给其他框架管理
dataSource
用于配置连接信息
type
UNPOOLED
每次获得新的连接，用完就关
下次再要使用，重新获得新的
POOLED
程序刚运行的时候，预先创建好一些连接，放到连接池中
需要用到连接的时候，从池中取，用完放回池中
提高了效率
JNDI
从其他框架获取

property
name值都是固定的
mappers
配置映射信息的位置
mapper文件
<mapper resource="相对于类加载路径的位置"> mapper/UserMapper.xml
接口
<mapper class="接口的完整名" > dao.UserDao

mapper配置
查询结果字段与对象属性的对应关系，默认按名字对应

resultMap
配置查询结果对应的类
配置查询结果中字段与类的属性的对应关系
type
返回结果的类型或集合中元素的类型
id
名字

<id>
主键映射
主键 <--> OID
property
指定OID属性名
column
指定主键列名
<result>
普通属性映射
属性 <--> 字段
property
指定属性名
column
指定列名
select
查询时使用
id
对应方法名
parameterType
参数的类型
resultType
返回结果的类型或集合中元素的类型
resultMap
指定要使用的结果映射的名字

parameterType
多个参数：
在select标签中，不指定parameterType属性
#{0}、#{1}、#{2}...按顺序表示参数
#{param1}、#{param2}、#{param3}...按顺序表示参数
将多个参数封装到一个对象中,然后指定parameterType为对象的类型
将多个参数封放到到一个Map中，不需要指定parameterType属性

sql语句中，参数名字：
当参数是一个简单值时，参数名任意
当参数是通过一个对象传入时，参数名要与对应属性同名
当参数是通过一个Map传入时，参数名要与对应key同名
当多个参数不通过任何封装时，参数名要为#{0} #{parma1}这种名字

insert
插入时使用
id
方法名
parameterType
参数的类型
事务
factory.openSession()时，开始事务
提交、回滚
session.commit()
session.rollback()
返回主键值
useGeneratedKeys="true"
是否返回主键
keyProperty="id"
主键对应的属性名
keyColumn="id"
当前表的主键列名

update
update时使用
id
方法名
parameterType
参数类型

delete
delete时使用
id
方法名
parameterType
参数类型
sql
id
指定一个名字
定义一个sql代码片段
可以在其他语句中引用

<inclue>
refid
在其他的sql语句中，通过refid来指定引用的已配置的sql的名字

多表操作
关联保存
先保存主表记录，再保存子表记录
保存主表记录时，指定返回当前生成的主键

保存子表记录的sql语句中，外键参数可以指定为#{dept.id}

多对一
一对多
从多方关联查询一方
关联属性的封装
1.<association>
连接查询
配置关联属性的映射
property
关联属性的名字
javaType
关联属性在Java中的类型
直接在<association>标签体中配置关联属性的映射信息
2.<association property column select>
n+1次查询
property
关联属性的名字
column
指定把当前查询结果的哪一列的值，作为将要执行的select语句的参数值
select
用于指定将要执行的select语句的名字

3.<association property resultMap>
连接查询
property
关联属性的名字
resultMap属性
用于指定要使用的一个已配置的resultMap元素的名字

如果要封装关联的属性，则必须配置<resultMap>
<resultMap>
<id/>
<result />
<association></association>
</resultMap>

从一方关联查询多方
关联集合属性的封装
1.<collection property ofType>
连接查询
property
集合属性的名字
ofType
集合元素的类型
直接在<collection>标签体中配置集合元素的映射信息
2.<collection property column select>
n+1次查询
property
关联属性的名字
column
指定把当前查询结果的哪一列的值，作为将要执行的select语句的参数值
select
用于指定将要执行的select语句的名字
3.<collection property resultMap>
连接查询
property
关联属性的名字
resultMap属性
用于指定要使用的一个已配置的resultMap元素的名字
动态sql
<if test>
test 用于指定判断条件
test指定的判断条件为true时，则在sql语句中拼接<if>标签体中的sql片段
test中
不能使用#{}
参数是一个对象，直接写对象属性名
参数是一个map，直接写key、
参数是各自独立的，只能使用param1、param2...

<where>
如果sql语句有条件，则自动拼上where关键字
并且会自动去除拼出的sql中，紧跟在where之后and、or

<choose>、<when>、<otherwise>
选择其中一个分支作为条件
一旦找到了一个判断条件成立的，则不会再继续往下查找

<trim>
prefix 指定要增加的前缀如果没有任何内容则不会添加
prefixOverrides 指定原sql片段中要删除的前缀有则删
suffix 指定要增加的后缀如果没有任何内容则不会添加
suffixOverrides 指定原sql片段中要删除的后缀有则删

<set>
如果有需要设置的字段，则添加set关键字
并且去除sql片段的最后一个,

<foreach>
遍历一个集合或数组，拼成一个字符串
如果参数是List集合或数组，Mybatis会将该集合或数组封装在一个map中
List集合以list作为key
数组以array作为key
属性
collection 指定集合或数组的key
item 当前正在遍历的元素存放的变量
open 指定结果以什么开始
close 指定结果以什么结束
separator 元素之间的分隔符
<foreach>标签体中#{item变量}获取正在遍历的元素

<bind name value>
为名字为name的变量绑定value值
绑定之后，通过#{name}获取值

value中
直接写属性名
可以使用_parameter，表示当前传入的参数值
_paramter.property
_paramter.method()
_paramter
进行运算，+ 当有一个参数是字符串，表示字符串拼接运算

day-28

log4j
logger for java

用于将日志信息以指定格式输出到指定的地方

三个主要的组件：
Logger
记录器
用于产生日志信息
Appender
添加器
用于将日志信息输出到指定的地方
Layout
用于指定日志信息的输出格式

获得/创建记录器
Logger Logger.getLogger(String name)
name
用于指定记录器的名字
叫某个名字的记录器，最多只有一个
调用getLogger方法时，会首先检查指定名字的记录器是否已存在：
存在直接返回
不存在创建新的返回
Logger Logger.getLogger(Class clazz)
<==> Logger.getLogger(clazz.getName())
使用当前类的完整类名作为记录器的名字

Logger Logger.getRootLogger()
获得根记录器
在log4j中，跟记录器总是存在的，名字叫root
位于记录器层次的顶部

记录器之间的层次关系
父子关系
通过名字结构来表示：
a.b.c
当前记录器名字叫a.b.c
如果名字叫a.b的记录器存在，则a.b.c的父记录器是a.b
如果名字叫a.b的记录器不存在，则查看名字叫a的记录器存不存在：
存在 a.b.c的父记录器是a
不存在 a.b.c的父记录器是root

Logger方法
getParent() 父记录器
getName() 记录器的名字

记录器的一个重要属性：
日志级别
从低到高 debug(调试) info(普通) warn(警告) error(错误) fatal(致命的)
Level类中提供了表示日志级别的常量：DEBUG INFO WARN ERROR FATAL

根记录器总是有日志级别的，默认是Level.DEBUG
如果一个记录器没有指定日志级别，则它会继承父记录器的日志级别

Logger方法
设置记录器的日志级别
setLevel(Level)

用于产生日志信息
debug()
info()
warn()
error()
fatal()

这些方法对应了不同的日志级别
在这些方法生成日志信息之前先检查记录器的日志级别，
自己的级别低于记录器的级别，则该方法指定的日志信息不会被产生

常用的Appender
ConsoleAppender
表示将日志信息输出到控制台
FileAppender
表示将日志信息输出到文件中

方法：
setName() 设置名字
setWriter() 设置输出日志信息的输出流
setLayout() 设置输出的日志信息的格式

如果没有为某个记录器指定Appender，则继承父记录器的

Logger方法
addAppender()
为当前的记录器添加一个Appender
一个记录器可以有多个Appender

常用的Layout
SimpleLayout 日志级别-日志信息
PatternLayout 按照指定的格式输出日志信息
格式语法：% + number + 转换字符

常用转换字符：
c 记录器的名字
C 产生日志信息的类的全限定名
d 产生日信息的时间
可以指定日期格式%d{yyyy-MM-dd hh:mm:ss,SSS}
默认日期格式yyyy-MM-dd hh:mm:ss,SSS
m 日志信息
n 当前系统的换行符
p 日志级别
number表示输出的最小字符数且右对齐，如果小于最小字符数，左边补空格
-number表示输出的最小字符数且左对齐，如果小于最小字符数，右边补空格
方法
setConversionPattern(String pattern)
设置自定义的转换格式

配置
默认读取路径：类加载路径下，log4j.properties
配置Appender
名字、类型
log4j.appender.自定义Appender名字=Appender类型
如果使用的是FileAppender，需要设置文件路径：
log4j.appender.appender名字.File=文件路径
相对路径：相对于java命令运行时所在的目录
日志信息格式
log4j.appender.appender名字.layout=Layout类型
如果使用的Layout是PatternLayout，需要设置ConversionPattern
log4j.appender.appender名字.layout.ConversionPattern=格式
配置Logger
为Logger指定日志级别、添加器
自定义的记录器
log4j.logger.自定义记录器名=日志级别,添加器1,添加器2...
根记录器
log4j.rootLogger=日志级别,添加器1,添加器2...

猜你喜欢