javaweb

来源：互联网发布：win8制作mac启动盘编辑：程序博客网时间：2024/05/18 12:43

Day01.6

1.myeclipse的介绍...6

2.xml入门...7

3.xml乱码【★★★】...9

4.xml约束...9

5.xml约束--dtd【☆】...9

6.名字解释...12

7.xml约束--schema.12

8.解析技术...14

9.JAXP.14

Day02.16

1. dom4j（dom for java）(day02)17

2.myeclipse介绍 (day02)17

3.debug【★★★★★】(day02)18

4.jdk5.0特性(day02)19

5.反射(day02)20

6.junit(day02)22

Day03.22

1.web入门 (day03)24

2.web服务器介绍(day03)25

3.tomcat安装/启动【★】(day03)25

4.tomcat启动异常(day03)25

5.tomcat端口占用【★★】(day03)26

6.tomcat目录介绍(day03)26

7.server.xml文件介绍(day03)28

8.tomcat账号管理(day03)28

9.资源的访问：【☆】(day03)29

10.web项目的结构【★★★】(day03)29

11.myeclipse创建web项目(day03)30

12.虚拟路径(day03)30

13.虚拟主机(day03)31

Day04.35

1 Servlet介绍（day04）...37

2.servlet继承关系（day04）...38

3.servlet编写流程【★★★】（day04）...38

4.servlet编写实现（day04）...39

5.servlet的生命周期（day04）...40

6.servlet进行优化（day04）...42

7.servlet虚拟路径【☆】（day04）...43

8 servlet路径总结（day04）...44

9. 缺省路径（day04）...45

10.ServletContext（day04）...46

11.servlet初始化方法（day04）...47

Day05.47

1.路径【☆】(day05)49

2.tomcat请求与响应执行流程分析【阅读excel】(day05)50

3.response(day05)51

4.request(day05)52

5.修改myeclipse的servlet模板(day05)54

6.ReuqestDispatcher对象(day05)55

7.案例【★★★★★必须完成】(day05)55

Day06.56

1.JSP入门(day06)58

2.思考：两个servelt之间数据共享(day06)59

3.会话(day06)59

4.cookie技术(day06)60

5.cookie综合案例：查看商品浏览记录(day06)61

6.session(day06)62

7. URL 重写(day06)63

8.session案例：一次性验证码(day06)63

9.总结(day06)64

Day07.65

1.JSP指令(day07)66

2.JSP内置对象(day07)68

3.out缓存机制(day07)69

4.总结，jsp的4作用域(day07)69

Day08.74

1.EL.75

2. 自定义JSP标签(day08)76

3.tld文件的位置(day08)77

4.tld配置文件的内容：(day08)77

5.JSTL(day08)79

6.EL函数(day08)81

7.BeanUtils(day08)81

8.模式介绍(day08)81

Day09.82

Day10.82

1.数据库介绍(day10)83

2.mysql安装(day10)84

3.mysql目录：(day10)84

4.mysql启动与登录(day10)85

5.mysql root账号密码重置(day10)86

6.mysql基本操作命令(day10)86

7.sql介绍(day10)87

8. DDL数据定义语言(day10)87

9、DML数据操纵语言(day10)89

10、DQL 数据查询语言(day10)90

11.中文乱码处理(day10)90

12、mysql异常(day10)90

13.sql文件(day10)91

Day11.96

1.约束【★★★-- 关键字】(day11)97

2.表与表之间的关系【★★★】(day11)99

3. 数据库的备份与恢复(day11)100

4. JDBC(day11)100

5.JDBC细节分析(day11)101

6.工具类(day11)103

7.重写day09案例，将数据保存到数据(day11)105

8. PreparedStatement对象：预处理对象【★★★--CURD操作--思考CUD】(day11)105

Day12.106

1.JDBC操作(day12)106

2.事务(day12)107

Day13.113

Day14.115

1.带有条件的查询...116

2.mysql分页...116

3.国际化...117

4.监听器Listener117

Day15.119

1.Filter 过滤器(day15)122

2.Filter过滤路径(day15)124

3.filter-mapping中的dispatcher标签(day15)124

4.案例(day15)125

Day16.125

1.JavaMail(day16)126

Day17.132

Day21.139

1.泛型类型...139

2.Annotation 注解...140

3.annotation案例...144

4.Servlet3.0.144

5、代理...146

6.类加载器ClassLoader146

1.struts2入门...148

2 struts2目录介绍...148

3. struts2开发流程...149

4. struts2开发实现--helloworld【★★★★★】...149

5. struts配置文件们...150

6.struts.xml详解【★★ 多读】...151

7.struts.xml配置默认值...152

8.struts的常量【★ 看看】...152

9 错误总结...153

10.Action的编写...154

11.struts中操作servlet api154

12.结果集的类型...155

Day01

1.myeclipse的介绍

* 版本：10.7

* 阅读：day01/参考/Java培训--MyEclipse操作图解.doc

* 设置

* 工作空间workspace编码设置：/截图/1.设置workspace默认编码.png

2.xml入门

* xml:可扩展标记语言,XML(EtensibleMarkup Language)

* xml用途：配置文件、数据存储

* xml涉及的名称：根元素，元素Element，属性Attribute、文本Text

* 语法

* 文档声明

* 通过文档声明确定xml文档的设置

* 格式：<?xml 属性=值?>

* version：版本，只有一个值 1.0

* encoding：编码，确定当前xml文档的编码

* 注意：值必须使用引号括住

* 编码：【★★★☆】

* ISO-8859-1，拉丁码，只能处理英文。

* GB2312，国标码，只能处理简体中文

* Big5，大5码，只能处理繁体。

* GBK，GB2312升级版，处理繁体

* GB18030，GBK升级版，支持特殊文字（少数名族等）

* UTF-8，万国码，变长1-6字符

* 元素

* 格式1：<名称></名称> ,<a></a>

* 格式2：<名称 /> , <img />

*名称：自定义

* 注意：

* 1.标签不能交叉嵌套 (交叉嵌套，例如：<a><b></a></b>)

* 2.格式化良好的文档，必须只有一个根标签（根元素）【★】

* 3.xml文档对回车换行、制表符、空格等进行处理

* 4.命名

* 区分大小写【★】

* 不能以数字开头

* 不能使用空格分隔：<ab c />

* 不能保留字符：冒号(:)

* 属性

* 格式：<元素属性名称=属性的值 />

* 注意：

* 属性值一定要用双引号（"）或单引号（'）引起来

* 注释

* 格式：

* 转义字符

* 格式：&名称; -->  

* 例如：& --> & <--> < (less than) >--> > (grant than)

* CDATA区

* 存放所有不需要编译的内容

* 格式：<![CDATA[ 内容 ]]>

* 处理指令（processinginstruction）（了解）

* 通过解析引擎如果处理xml文档

* 添加样式：<?xml-stylesheet type="text/css"href="1.css"?>

3.xml乱码【★★★】

* 乱码产生的原因：编码不统一

* 文件的编码：window默认编码，GBK

* 内容的编码：使用“文档声明”encoding进行设置

* 如果处理：统一编码

4.xml约束

* 编写一个文档来约束一个XML文档的书写规范

* 约束分类：dtd、schema

* XML Schema 是基于 XML 的 DTD 替代者

5.xml约束--dtd【☆】

* 文档关联

* 将xml文档与指定的dtd文件进行关联

* 关联方式

* 内部DTD：

* 在xml内部书写dtd内容

* 格式：<!DOCTYPE 根元素名称 [语法]> -->docType

* 外部DTD

* 在xml文档中引用当前系统的DTD文档

* 格式：<!DOCTYPE 根元素名称SYSTEM "dtd文件路径">

* 公共DTD

* 在xml文档中引用互联网中的DTD文档

* 格式：<!DOCTYPE 根元素名称PUBLIC "dtd名称" "dtd文件路径">

* 阅读：java web项目1.3版本，WebRoot/WEB-INF/web.xml

* 元素element

* 格式：<!ELEMENT 元素名称元素内容声明>

* 元素名称：自定义

* 元素内容声明：包含两部分，符号和数据类型

* 符号：

? --> 0 或 1

+ --> >=1

* --> >=0

()--> 分组

| --> 选择

, --> 顺序

* 数据类型

*(#PCDATA) --> 被修饰的元素必须为字符，不能添加子元素

*EMPTY --> 不能有标签体

* 属性attribute

* 前提：必须具有元素

* 格式：<!ATTLIST 元素名称 (属性名称属性类型约束)+>

* 属性名称：自定义

* 属性类型：

CDATA --> 字符数据

ID --> 唯一标识，必须字母开头

( | | ) --> 选择

* 约束

#REQUIRED ,required必填

#IMPLIED ， implied可选

#FIXED value，fixed固定值

defaultValue，默认值

* 实体entity

* 实体相当于java中的变量

* 分类：

* 内部实体：

* 引用实体：

* 定义位置：dtd文档中

* 定义格式：<!ENTITY名称 "内容">

* 使用位置：xml文档中

* 使用格式：&名称;

* 参数实体：

* 定义位置：dtd文档中

* 定义格式：<!ENTITY % 名称 "内容">

* 使用位置：dtd文档中

* 使用格式：%名称;

* 外部实体：

* 要求

* 基本：会读

* 高级：会写

6.名字解释

* URL：统一资源定位符，完整的web路径：http://www.itcast.cn/news/index.html

* URI：统一资源标识符，标记的作用，可以为不完成路径。 URL为URI的子集

7.xml约束--schema

* XML Schema 是基于 XML 的 DTD 替代者。

* schema文档就是xml文档。schema的内容为xml内容；扩展名为，*.xsd

* 必须具有一个根元素，名称为：<schema></schema>

* 文档关联--命名空间（namespace）【★★★】

* schema文档

* 例如：

<xsd:schemaxmlns:xsd="http://www.w3.org/2001/XMLSchema"

targetNamespace="http://www.example.org/books"

xmlns:tns="http://www.example.org/books">

* 1.当前books.xsd是schema文档，根元素为schema

* 2.具有一个已经官方写好的约束文档

* 命名空间：对指定的schema文档进行引用

* 格式1 ## xmlns="URL" (xml namespace),默认命名空间声明

* 例如：xmlns="http://www.w3.org/2001/XMLSchema"

* 根元素为schema,为官方文档的规定

* 格式2 ## xmlns:别名="URL"，显示命名空间声明

* 例如：xmlns:xsd="http://www.w3.org/2001/XMLSchema"

* 别名在当前文档必须唯一，名称自定义

* 使用格式：<别名:标签名称>

*例如：<xsd:elementname="books"></xsd:element>

* 官方建议：默认命名空间指向官方文档

* 3.当前schema文档进行命名

* targetNamespace属性给文档进行命名，名称自定义

* 例如：targetNamespace="http://www.itcast.cn/books"

* 例如：官方文档中也使用当前属性，<xs:schema targetNamespace="http://www.w3.org/2001/XMLSchema"...

* 4.定义根元素，通过官方的标签确定元素

<xsd:elementname="books"></xsd:element>

* xml文档

* 例如：

<booksxmlns="http://www.example.org/books"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.example.org/booksbooks.xsd" >

* 5.确定自定义schema文档的位置

5.1 确定使用的schema文档的url，使用约束内容

xmlns="http://www.example.org/books"

5.2 固定内容，进行schema实例化引用，目的使用schemaLocation

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

5.3确定schema文档的位置

* 格式：xsi:schemaLocation="schema文档的URL schema文档的位置"

* 例如：xsi:schemaLocation="http://www.example.org/booksbooks.xsd"

* 总结：

*http://www.w3.org/2001/XMLSchema 官方定义schema文档时使用的约束文档，在xsd文档中使用

*http://www.w3.org/2001/XMLSchema-instance 官方规定确定schema文档位置的约束文档，在xml文档中使用

8.解析技术

* dom和sax解析技术，Stax（Streaming api for xml）

* 解析器，采用不同的解析技术解析xml文档。不易理解，难以开发

* 解析开发包，封装解析器，提供便捷API

* DOM：DocumentObject Model, 即文档对象模型，w3c标准

* 将xml文档加载到内存，形参一个dom树

* 优点：CURD操作(create update read delete)

* 缺点：文件过大，极易出现内存溢出

* 需要获得document文档

* 所有的内容都可以成为节点Node

* SAX：Simple APIfor XML

9.JAXP

* JAXP(Java API for XML Processing )，sun一套XML解析API

* JAXP很好的支持DOM和SAX解析方式

* 设计的包结构

* javax.xml ，java实现类的包目录

* org.w3c.dom ，w3c提供接口

10.jaxp--dom 【★★★】

* 编写流程

* 1. 获得document -->DocumentBuilderFactory -->DocumentBuilder --> Document

* 2. 操作

* R ：遍历，getElementsByTagName() , NodeList(getLength(),item(i)) ,getChildNode() , getNodeType() ,getTextContent()

* CUD ：

* C , 先创建，后添加

* D , 先获取，再通知父节点，删除当前

* 3. 保存(提阅读供文档，不掌握)

11.jaxp--sax

* 事件驱动的 XML 处理方法，逐行扫描文档，一边扫描一边解析

* 事件驱动，将每一个动作发生时，将自动触发相应的事件（java方法）

* 编写自定义事件处理类，继承基类DefaultHandler

* 元素开始：startElement

* 字符：characters()

* 元素结束：endElement

Day02

回顾

* xml

* 扩展名：*.xml

* 文档声明：<?xmlversion="1.0" encoding=""?>

* 元素：<名称></名称> <名称 />

* 命名：区分大小写

* 格式化良好的xml文档，只有一个根元素。

* xml约束

* DTD

* 文档关联 <!DOCTYPE 根元素名称SYSTEM "URL,路径"> --> 相对/ ./当前 ../上一层绝对d:

* 元素：<!ELEMENT 元素名称约束>

* 符号： ? + * , | ()

* 约束：(#PCDATA) EMPTY

* 属性：<!ATTLIST 元素名称 [属性名称类型约束 ]*>

* 类型：ID、CDATA、()

* 约束：#REQUIRED / #IMPLIED / #FIXED value / defaultValue

* schema

* 命名空间：

* 对schema文档进行名称：targetNameSpace="唯一名称"

* 默认引用：xmlns="url" --><标签>

* 显示引用：xmlns:别名="url" --> <别名:标签>

* jaxp--dom

* 使用dom解析必须获得document

* 获得document方法：DocumentBuilderFactory.newInstance() --> factory.newDocumentBuilder() --> builder.parse() --> Document

* jaxp--sax

* 读取一行之后，将释放资源。只能读r

* 解析方法：SaxParserFactory--> SaxParser -->parser(file,DefaultHandler)

#####################################################################################################

1. dom4j（domfor java）(day02)

* 第三方解析xml的工具包

* 需要jar包

* 核心包：dom4j-1.6.1.jar

* 强制转换

* 一般不存在强制转换，只要出现，必须检查导包

* 程序运行时的类型，可以强转为当前类型或父类类型

2.myeclipse介绍(day02)

*%myeclipse%/configuration/.settings/org.eclipse.ui.ide.prefs

* RECENT_WORKSPACES= 设置已经使用的workspace

*SHOW_WORKSPACE_SELECTION_DIALOG=true 运行myeclipse时，是否提示选择workspace

* 快捷键

// alt + / 内容提示

// ctrl + 1 修复【】

// ctrl + / 注释

// ctrl + d 删除

// alt + shift + s 常用操作

// ctrl + L 跳转行

// ctrl + t 显示当前类的继承结构

// ctrl + shift + t 搜索源码

// ctrl + shift + o 整理包【】

* 阅读：day01\参考\Eclipse最实用快捷键.txt, Eclipse快捷键大全.txt

3.debug【★★★★★】(day02)

* 程序中提供一种调试程序的功能。

* 断点breakpoint，程序暂定的位置标记

* 快捷键：

* f6 执行一行

* f5 跳入方法

* f7 跳出方法

* f8 执行到下一个断点，如果没有断点，程序结束

4.jdk5.0特性(day02)

* Static Import 静态导入[不讲]

* Annotations 注解@Override，javaweb最后一天[后讲]

* Autoboxing/Unboxing ，自动装箱与拆箱

* 基本类型与相应的包装类型的转换。

* jdk1.4转换

* 基本类型-->包装类型： new 包装类(基本类型)

* 包装类型-->基本类型：包装类.基本类型Value()

* Varargs ：可变参数

* 形参格式：类型 ...变量名

* 例如： sum(Integer... arrs)

* 实际参数：个数不定

* 总结：

* jvm 将可变参数当成数组使用

* 当实际参数为数组，数组将被打散，以多个参数的形式进行赋值

* 形参可变参数，必须放置在参数列表的最后一位

* Enhanced for Loop ，增强for循环，foreach

* 格式：for(类型变量名 : 数组 | 集合(Iterable)){}

* 练习：数组、list和map的遍历

* 注意：增强for是iterator的简化，只能进行迭代(遍历)，不能直接修改

* Generics ：泛型

* 使用格式：类型<类型,类型,....>

* 注意：

* 前后必须一致

* 基本类型不能在泛型中使用

* 泛型只为编译服务，在class文件不存在泛型。

* 自定义

* 方法： public <T> void print(T t) --> Type ,template

* 类 : public class HelloWorld<K,V> {} --> key,value

* Typesafe Enums : 枚举

* 关键字：enum

* 构造方法默认为私有的

* 常量值建议为大写，且必须放置在所有代码之前。如果常量之后没有内容，分号可以不写，建议填写。

5.反射(day02)

* 反射，在运行时操作指定的对象

* Class对象，class文件在内存中的描述对象。

* 获得方法

* 1 已经类的完整路径名(字符串) ：Class.forName(..) [常用]

* 2 已经类型：String.class ，确定参数列表

* 3 已经对象：obj.getClass()

* 注意：

* Class提供获得默认构造方法实例对象：newInstance()

* 构造Constructor

* 获得方法

* 公共的构造方法： Constructor<T> getConstructor(Class<?>...parameterTypes) ，可变参数用于确定形式参数列表

* 已经声明的构造方法：Constructor<T>getDeclaredConstructor(Class<?>... parameterTypes) ，获得私有的构造

* 实例化

*newInstance(Object... initargs) ，可变参数用于确定实际参数列表

* 字段Field

* 获得方法

* 公共：Field getField(String name) ，通过字段名称

* 声明：Field getDeclaredField(String name)

* 操作

* 获得内容：Object get(Object obj)

* 设置内容： void set(Object obj, Object value) ，确定实例对象

* 方法Method

* 获得方法

* 公共：Method getMethod(String name, Class<?>... parameterTypes) 通过方法name获得方法，可变参数为方法的形式参数列表

* 声明：Method getDeclaredMethod(String name,Class<?>... parameterTypes)

* 执行

* Object invoke(Object obj, Object...args) 执行指定对象obj，指定方法，可变参数为方法的实际参数列表

6.junit(day02)

* 单元测试工具类，测试用例

* 测试用例的编写

* 给方法添加@Test注解

* 测试方法必须为，

公共public，

没有返回值void，

非静态的

方法名自定义(建议使用测试方法的名称，在之前添加test)

没有参数

* 其他注解

@Before：在测试方法之前执行

@After：在测试方法之后执行

* 断言Assert,测试方法中进行结果逻辑的判断

Day03

回顾

* day01

* xml

# 格式化良好的xml文档，必须有一个根元素

* dtd

# ? + * | ,

* schema

# 命令空间：namespace，用于区分来自不同约束文档的元素或属性等。每一个文档进行名称(唯一，URL字符串)

# 格式：xmlns="URL" 默认引用最多只有一句， xmlns:别名="URL"显示引用，当前文档别名唯一

* jaxp-dom

# dom解析原理，将xml文档加载到内容，形参一个dom树。CURD操作

* jaxp-sax

# 事件驱动，逐行解析。读取当前行时，将释放之前的内容。使用较小的内存，读取大文件。

* day02

* dom4j:CURD

* 读：SaxReader

* 写：XmlWriter

* 获得根元素：getRootElement()

* xpath ://book[@id='b001'] -->selectSingleNode(xpath)

* jdk5特性：

* 自动装箱与拆箱、可变参数，泛型，增强for。--使用

* for循环（数组、List、Map遍历）

* 枚举enum，简单枚举使用

* 反射：基本操作

* Class 获得

*Method方法

* 获取getMethod(name,...) --确定的形参

* 执行invoke(对象，实际参数)

* debug：不断操作

* junit：@Test使用

#####################################################################################

1.web入门 (day03)

* 通信模式

* B/S(browser / server) : 浏览器/服务器模式。特殊的C/S模式，服务器升级，浏览器不需要同步

* C/S(client / server) : 客户端/服务器模式，例如：QQ。QQ软件升级

* URL详解：【★★★★★】

* 例如： http://localhost:8080/abc/1.html

* http --> 协议， ftp:// svn:// https://

* :// --> 分隔符

* localhost --> 本地域名，对应本地IP

* 例如：www.itcast.cn 公网域名（注册）

* IP地址：所有的计算机之间进行通信，必须使用一个唯一标识

* IPv4，将数字使用.进行分隔，

公网IP：211.100.52.213

局域网IP：192.168.1.100 -->10

本地IP：127.0.0.1

* IPv6 : win7支持，6分隔

* DNS：域名解析服务

* 端口：服务器端每一个应用程序都需要占用至少一个端口

* tomcat web服务器，默认端口：8080

* http协议默认端口：80

* abc/1.html : 服务器端的资源

2.web服务器介绍(day03)

* WebLogic，oracle公司，支持javaee 13核心技术，收费

* WebSphere，IBM公司，支持javaee 13核心技术，收费

* tomcat，apache组织，支持javaee 两个核心技术，Servlet和JSP

3.tomcat安装/启动【★】(day03)

* 解压：apache-tomcat-7.0.27.zip

* 注意：解压的目录不建议包含中文和空格

* 启动：

* %tomcat% -->D:\java\tomcat\apache-tomcat-7.0.27tomcat的安装目录

* %tomcat%/bin/startup.bat

* 测试：http://localhost:8080

4.tomcat启动异常(day03)

* 没有配置java_home

* 使用cmd运行，错误提示

Neither the JAVA_HOME northe JRE_HOME environment variable is defined

At least one of theseenvironment variable is needed to run this program

* java_home配置错误

* 错误提示

The JAVA_HOME environmentvariable is not defined correctly.

It is needed to run thisprogram in debug mode.

NB: JAVA_HOME should pointto a JDK not a JRE.

* 错误配置了catalina_home

* 所有startup.bat文件将启动一个tomcat

5.tomcat端口占用【★★】(day03)

* 异常提示：Causedby: java.net.BindException: Address already in use: JVM_Bind

* 修改端口

* 文件位置：%tomcat%/conf/server.xml

* 端口位置：

* <Serverport="8005" shutdown="SHUTDOWN"> 第22行

* <Connectorport="8080" protocol="HTTP/1.1"/> 第70行

* <Connectorport="8009" protocol="AJP/1.3"redirectPort="8443" />第91行

6.tomcat目录介绍(day03)

* bin目录：启动/停止服务

* startup.bat启动

* bootstrap.jar，启动引导jar

* bootstrap.jar/META-INF/MANIFEST.MF/

* Main-Class:org.apache.catalina.startup.Bootstrap

* 总结：tomcat是java编写，Bootstrap类main方法

* shutdown.bat停止

* server.xml，核心配置文件

* tomcat-users.xml，tomcat的用户配置文件

* web.xml，tomcat管理的所有web项目的基本配置文件。

* lib目录：tomcatjava项目需要的jar文件

* servlet-api.jar，servlet需要的jar文件

* jsp-api.jar，jsp需要的jar文件

* catalina.*.log，tomcat运行维护日志

* tomcat是以天进行日志记录

# *.tmp临时文件

* webapps目录：tomcat管理的所有web项目的目录【★★★★★】

* work目录：tomcat处理jsp的工作目录【★★★★★】

7.server.xml文件介绍(day03)

* 端口的配置

* 内容介绍：

<Servicename="Catalina">

<Connectorport="8080"

<Connectorport="8009"

<Enginename="Catalina" defaultHost="localhost">

<Hostname="localhost" appBase="webapps"

8.tomcat账号管理(day03)

* 执行URL：http://localhost:8080/manager/html

* 配置文件的位置：%tomcat%/conf/tomcat-users.xml

* 配置的内容：

<rolerolename="manager-gui"/>

<userusername="tomcat" password="s3cret"roles="manager-gui"/>

* 重新启动

9.资源的访问：【☆】(day03)

* / 表示的 ROOT目录

* 例如1

* 资源位置：%tomcat%/webapps/ROOT/abc.html

* 访问：http://localhost:8080/abc.html

* 例如2:

* 资源位置：%tomcat%/webapps/demo/dmeo.html

* 访问：http://localhost:8080/demo/demo.html

* 注意：如果出现404提示，说明路径写错

10.web项目的结构【★★★】(day03)

| 项目名称

|-- WEB-INF 目录，tomcat不允许浏览器通过url直接访问

|-- classes目录，等价于java项目的bin目录，存放class文件

|-- lib 目录，存放web项目需要的jar文件

|-- web.xml文件，当前web项目的配置文件

* 注意：%tomcat%/conf/web.xml配置相同，当前文件将覆盖%tomcat%/conf/web.xml文件

* 例如：

* web项目的名称为：demo

* 在web.xml文件中配置--欢迎页面

<welcome-file-list>

<welcome-file>demo.html</welcome-file>

</welcome-file-list>

* 在访问当前web项目时，如果没有书写具体的访问资源名称，将访问欢迎页面

*http://localhost:8080/demo/

11.myeclipse创建web项目(day03)

* WebRoot目录，中的所有内容将被发布到tomcat中，等价%tomcat%/webapps/项目名称/...

* ContextRoot,表示发布到tomcat中的项目名称

12.虚拟路径(day03)

* 如果webapps所在目录空间大小有限，如何将web项目放置到其他盘符？

* %tomcat%/conf/server.xml --><Host name="localhost" appBase="webapps"

* 虚拟路径的配置：

* 1 在server.xml配置

* <Host><Contextpath="/xxx" docBase="F:\demo"/>

* path属性：表示浏览器访问的名称，必须使用/开头

* docBase属性：其他目录的web项目的位置

* 必须重启

* 2 %tomcat%/conf/引擎名称/主机名称配置xml文件

* 位置：%tomcat%/conf/catalina/localhost

* 文件名称（不带扩展名）将为path的内容

* 文件内容：<Context docBase="F:\demo"/>

* 增强

* 不填写web项目的名称：将xml文件的名称修改为ROOT

* 不填写资源路径：在项目目录/WEB-INF/web.xml -->配置欢迎页面

<welcome-file-list>

<welcome-file>demo.html</welcome-file>

</welcome-file-list>

* 不填写端口：将端口修改为80

13.虚拟主机(day03)

* 将tomcat中配置一个主机<Host>

<Hostname="www.itcast.cn" appBase="webapps"

unpackWARs="true"autoDeploy="true">

</Host>

* 修改window操作系统的hosts文件

* 位置：C:\WINDOWS\system32\drivers\etc\hosts

* 注意：如果localhost不能访问本地资源，hosts没有配置

* 缺少：127.0.0.1 localhost

##############################################################################

1.http协议

* 基于TCP连接（三次握手，建议连接）

* 默认端口：80

* 基于请求--响应模式

2.web资源

* 静态资源：html、image、视频、音频等

* 动态资源：可以动态生成的资源（服务器端程序生成）

3.http版本

* http1.0 ，一次连接只是用一次

* http1.1 ，一次连接可以使用多次

4.http协议--请求request

* 请求格式：请求行、请求头、请求体

* 请求行

* 格式：请求方式请求资源路径协议/版本

* 例如：GET/day03_web/1.html HTTP/1.1

* 请求方式：http协议7种请求方式

* 常用：GET、POST【★★★】

* 区别：

* get:将请求参数追加到请求资源路径之后

* 例如：/day03_web/1.html?username=jack&password=1234

* post:将请求参数放置到请求体中

* 比较：

* post安全

* post可以发送大数据，get发送1kb数据(1024字符)

* 请求头

Accept: text/html,image/* --支持数据类型，浏览器可以解析内容

Accept-Charset: ISO-8859-1 --字符集（编码）

Accept-Encoding: gzip --支持压缩

Accept-Language:zh-cn --语言环境

Host: www.itcast.com:80 --访问主机

If-Modified-Since: Tue, 11 Jul2000 18:23:51 GMT --缓存时间

Referer:http://www.itcast.com/index.jsp --来自哪个页面、防盗链

User-Agent: Mozilla/4.0(compatible; MSIE 5.5; Windows NT 5.0) --用户的浏览器版本

Cookie --cookie

Connection: close/Keep-Alive --链接状态

Date: Tue, 11 Jul 2000 18:23:51GMT --时间

* 重要：Referer、If-Modified-Since【★】

* 请求体

* 一般没有数据，只存放post请求方式的数据

* “请求体”与“请求头”之间存在一个空行

5.http协议--响应response

* 响应格式：响应行、响应头、响应体

* 响应行：

* 格式：协议/版本状态码状态码对象的信息

* 例如：HTTP/1.1200 OK

* 状态码

* 1 1xx，链接进行中

* 2 2xx，正常请求完成。

* 200，正常

* 3 3xx，服务性通知浏览器，浏览器需要进一步操作完成整个过程。

* 304，服务器通知浏览器，读取本地缓存

* 302，服务器通知浏览器，使浏览器去访问指定的资源。（响应头，location，用于确定页面）--跳转(重定向)

* 4 4xx，服务器通知浏览器，浏览器操作异常

* 404，资源没有找到。（浏览器端编写路径有误）

* 5 5xx，服务器通知浏览器，服务器端异常

* 500，服务器端异常（java程序异常）

* 重要：200、302、304、404、500【★★★】

* 响应头

Location:http://www.it315.org/index.jsp --跳转方向

Server:apache tomcat --服务器型号

Content-Encoding: gzip --数据压缩

Content-Length: 80 --数据长度

Content-Language: zh-cn --语言环境

Content-Type: text/html; charset=GB2312 --数据类型，解决响应的中文乱码

Last-Modified: Tue, 11 Jul 200018:23:51 GMT --最后修改时间

Refresh:1;url=http://www.it315.org --定时刷新

Content-Disposition: attachment;filename=aaa.zip --下载

Set-Cookie:SS=Q0=5Lb_nQ;path=/search --添加cookie

Expires: -1 --缓存

Cache-Control: no-cache --缓存

Pragma: no-cache --缓存

* 注意，在jsp页面查询

<metahttp-equiv="expires" content="0">

<metahttp-equiv="cache-control" content="no-cache">

<metahttp-equiv="pragma" content="no-cache">

Connection: close/Keep-Alive --连接

Date: Tue, 11 Jul 2000 18:23:51GMT --时间

* 重要：Content-Type、Location、Content-Disposition、Content-Encoding、Refresh【★★★】

* 响应体

* 服务器端返回给浏览器的数据

* “响应头”和“响应体”之间存在一个空行

Day04

回顾

* tomcat

* B/S(浏览器/服务器)

* URL书写：http://localhost:8080/abc/1.html

* tomcat目录结构

* %tomcat%/bin/startup.bat

* %tomcat%/conf/web.xml , 当tomcat启动时加载web.xml文件，每一个项目的web.xml文件的内容将覆盖全局的内容（内存）

* %tomcat%/webapps

* %tomcat%/work

* web项目目录结构

项目名称

|-- WEB-INF

|--classes

|--lib

|--web.xml

* 虚拟路径

* 扩展web应用的位置：%tomcat%/conf/Catalina/localhost/demo.xml --> <ContextdocBase="d:/xxx"/>

* URL :http://localhost:8080/demo/....

* 不填写web项目的名称：将文件的名称修改为ROOT --> / ROOT

* URL :http://localhost:8080/....

* 省略资源路径：配置欢迎页面

* web.xml

<welcome-file-list>

<welcome-file>index.html</welcome-file>

</welcome-file-list>

* URL :http://localhost:8080/

* http协议默认端口80，修改tomcat的端口

* server.xml --> <Connector port="80" protocol="HTTP/1.1"

* URL :http://localhost/

* 虚拟主机

* 在server.xml文件添加<Host>

<Hostname="www.itcast.cn" appBase="webapps"

unpackWARs="true"autoDeploy="true">

* name属性：域名

* appBase属性：编写自己的webapps目录，d:/mywebapps (此目录中可以存放多个web项目)

* 模拟域名，修改hosts文件

* 内容：127.0.0.1 www.itcast.cn

* URL ： http://www.itcast.cn/

* 思考：http://127.0.0.1

* server.xml文件：<Engine name="Catalina"defaultHost="localhost">

* 默认主机，defaultHost，没有确定主机时使用的主机

* 例如

* window系统 hosts文件 127.0.0.1 www.baidu.com

* http协议

* 请求request

* 请求行--请求方式：GET、POST

* 请求头：referer，if-modifed-since

* 响应response

* 响应行--状态码：200、302、304、404、500

* 响应头：content-type、content-disposition、content-encoding、location、refresh、last-modifed等

##########################################################################

1 Servlet介绍（day04）

* servlet = Server Applet

* servlet java提供的处理动态web资源的技术

* servelt是一个类，此类必须直接或间接与javax.servlet.Servlet接口有关。

* 特点：单实例，多线程。（servlet存在线程安全）

* servlet必须放置到web容器（web服务器，tomcat）中

2.servlet继承关系（day04）

* 接口：javax.servlet.Servlet

* 实现类：javax.servlet.GenericServlet

* 实现类：javax.servlet.http.HttpServlet【】 --> 覆写 doGet（get请求处理方法）、 doPost（post请求处理方法）

3.servlet编写流程【★★★】（day04）

* 1.编写实现类（implementsServlet）

* 2.配置servlet（web.xml）

* 3.测试

* 注意：

* tomcat启动时，将加载所有web项目的web.xml文件。

* 启动时异常，有可能xml文件配置错误

* 1.标签名称写错

*2.<url-pattern>没有/开头

* 错误提示：Caused by: java.lang.IllegalArgumentException: Invalid<url-pattern> oneServlet in servlet mapping

* 3.<servlet>与<servlet-mapping>使用的名称不一致

* 错误提示：Caused by: java.lang.IllegalArgumentException: Servletmapping specifies an unknown servlet name OneServlet

4.servlet编写实现（day04）

* 1.编写实现类（implementsServlet）

public class HelloServletimplements Servlet {

* 2.配置servlet（web.xml）

* 注册servlet，将当前servlet配置给tomcat，使用<servlet>标签

* 使用<servlet-name>标签，给注册的servlet进行唯一命名

* 名称自定义，要求当前web.xml文件中唯一

* 使用<servlet-class>标签确定servlet的实现类

* 使用servelt，将注册的servlet与路径进行映射，使用<servlet-mapping>标签

* 确定注册servlet的名称,使用<servlet-name>标签

* 使用<url-pattern>标签，确定访问路径

* 要求必须/开头，名称自定义

* 例如

<servlet-name>HelloWorld</servlet-name>

<servlet-class>cn.itcast.servlet.HelloServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>HelloWorld</servlet-name>

<url-pattern>/hello</url-pattern>

</servlet-mapping>

* 3.测试

* url :http://localhost:8080/day04/hello

5.servlet的生命周期（day04）

* init(ServletConfig),初始化方法【★★★★★本行】

* 完成准备工作

* 执行次数：1

* 执行者(调用者)：tomcat，执行过程中，需要传递实际参数

* ServletConfig对象

* 当前servlet的配置对象，获得servlet的名称与初始化内容

* API【★】

* 1 获得servlet的名称 -- web.xml --<servlet><servlet-name>

StringservletName = config.getServletName();

* 2 通过名称获得初始化参数 ,没有参数返回null

Stringusername = config.getInitParameter("username");

* 3 获得所有初始化参数的名称

Enumeration<String>names = config.getInitParameterNames();

while(names.hasMoreElements()){

Stringname = names.nextElement();

Stringvalue = config.getInitParameter(name);

System.out.println("## " + name + " : " + value);

}

* 4 获得第一个特殊对象ServletContext ？？？

ServletContextsc = config.getServletContext();

* 在web.xml文件中配置初始化参数

<init-param>

<param-name>username</param-name>

<param-value>凤姐</param-value>

</init-param>

* <param-name>必须唯一

*service(ServletRequest,ServletResponse),servlet执行方法【★★★★★本行】

* 执行次数：一次请求执行一次

* 执行者：tomcat，执行过程中，需要传递实际参数

* 分析过程：

* request分析

* 接口：javax.servlet.ServletRequest

* 实现类：org.apache.catalina.connector.RequestFacade

* * 继承关系：

* * public class RequestFacadeimplements HttpServletRequest {

* * public interfaceHttpServletRequest extends ServletRequest {

* * 总结：RequestFacade --> HttpServletRequest --> ServletRequest

* ArrayList List Object

* 结果获得对比分析

Object obj =new ArrayList();

List list =(List) obj;

ServletRequestreq = new RequestFacade()

HttpServletRequestrequest = ()req;

* response分析

* 接口：javax.servlet.ServletResponse

* 实现类：org.apache.catalina.connector.ResponseFacade

* * 继承关系：

* * public class ResponseFacadeimplements HttpServletResponse {

* * public interfaceHttpServletResponse extends ServletResponse {

* * 总结：ResponseFacade --> HttpServletResponse -->ServletResponse

* 分析总结：【★★★★★】

HttpServletRequest request= (HttpServletRequest) req;

HttpServletResponseresponse = (HttpServletResponse) resp;

* destory()，销毁方法【★★★★★本行】

* 执行次数：正常关闭服务器时，执行1次

* 执行者：tomcat

6.servlet进行优化（day04）

* 工具类MyGenericServlet implments Filter,ServletConfig

* GenericeServlet中缓存config对象，方法对config中API调用【★★★】

* 获得ServletContext

this.getServletContext(); //直接获得父类通过config获得Servletcontext

this.getServletConfig().getServletContext(); //父类缓存了config，通过config获得ServletContext

* 提供了一个没有参数的init(),需要进行初始化操作时，仅需要覆写init()方法即可

* 可以覆写init(ServletConfig),但必须在此方法中显示的调用父类的方法，super.init(config)

* this调用方法时，当前运行类（执行方法时，编译看左边，运行看右边）

* 工具类MyHttpServlet

* 强转(使用)

HttpServletRequest request= (HttpServletRequest) req;

HttpServletResponseresponse = (HttpServletResponse) res;

* 分流【★★★】

* 提供doGet和doPost方法，分别处理get请求与post请求

* 注意：

* web.xml文件，注册servlet必须出现在映射之前。

* myeclipse自动创建的servlet，所有的注册都在映射之前（历史遗留问题）

* 约束schema --><xsd:choice> <xsd:element name="servlet" <xsd:elementname="servlet-mapping"

* javaee 1.3 dtd约束 --> 使用逗号servlet*,servlet-mapping*

7.servlet虚拟路径【☆】（day04）

* url-pattern 的配置，三种分类

* 1 完全匹配路径名：必须使用/开头，其他内容自定义

* 例如：/hello ,/abc/hello

* 2 不完全匹配路径名：必须使用/开头，最后必须使用/*结尾

* 例如：

/* , 所有路径

/abc/* , abc路径之下的所有内容（/abc/demoServlet , /abc/helloServlet）

* 3 扩展名匹配：必须*.开头，字符结尾

* 例如：

*.jsp , 所有的jsp文件

*.do ,struts1扩展名

*.action ，struts2扩展名

* 优先级： 1 > 2 > 3

8 servlet路径总结（day04）

* 注册一个servlet，可以使用多少次？多次

<servlet-name>EndTwoServlet</servlet-name>

<servlet-class>cn.itcast.servlet.EndTwoServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>EndTwoServlet</servlet-name>

<url-pattern>/endTwoServlet</url-pattern>

</servlet-mapping>

<servlet-mapping>

<servlet-name>EndTwoServlet</servlet-name>

<url-pattern>/endTwoServlet2</url-pattern>

</servlet-mapping>

* 等价于

<servlet-mapping>

<servlet-name>EndTwoServlet</servlet-name>

<url-pattern>/endTwoServlet</url-pattern>

<url-pattern>/endTwoServlet2</url-pattern>

</servlet-mapping>

* 一个路径，可以映射几个servlet？完全匹配路径名需要唯一

9. 缺省路径（day04）

* form.html页面，如何执行？

* 执行路径

* web项目的WEB-INF/web.xml文件,查询

* %tomcat%/conf/web.xml文件，查询，没有查询到完全匹配路径，提供一个缺省路径。其他路径都不匹配的情况，将执行的路径。路径必须为："/"

* 源码

<servlet-name>default</servlet-name>

<servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>default</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

*org.apache.catalina.servlets.DefaultServlet tomcat实现的servlet完成功能

* 如果文件存在，将以流形式发送给浏览器

* 如果文件不存在，将发送404错误信息

* web项目的WEB-INF/web.xml文件的配置内容，将覆盖%tomcat%/conf/web.xml文件配置内容

10.ServletContext（day04）

* ServletContext对象，servlet上下文对象。Servlet的管理者Boss

* tomcat在启动时，会为每一个web项目创建对象(开辟内存)，用于管理当前web项目

* ServletContext对象获取引用方式

this.getServletContext() orthis.getServletConfig().getServletContext()

* ServletContext对象创建与销毁

* 创建：tomcat在启动时创建（创建者，创建时间）

* 销毁：tomcat在关闭时销毁

* API

* 管理当前web项目的资源

* 获得真实路径，当前资源在web服务器物理路径：getRealPath(java.lang.String path)【★★】

* 必须/开头

* 获得当前资源在web服务器物理路径对应的流：getResourceAsStream(java.lang.String path) 【★★】

* 扩展内容：

* 获得当前目录下的所有的资源路径：getResourcePaths(java.lang.String path)

* 管理当前对象的内存，管理当前对象的属性(Attribute) -- xxxAttribute【★】

* 将指定对象Object，通过指定的名称name，放置到ServletContext对象属性中：

voidsetAttribute(java.lang.String name, java.lang.Object object)

* 通过给定的名称name获得指定的对象

java.lang.ObjectgetAttribute(java.lang.String name)

* 通过给定的名称name移除指定的对象

voidremoveAttribute(java.lang.String name)

* 总结

* 在不同servlet之间进行数据共享

* 不同用户之间数据共享

* 跨浏览器数据共享

* 不足，如果存放数据过大，长时间暂用内存

* web项目的初始化内容进行管理

* 通过名称获得值：java.lang.String getInitParameter(java.lang.Stringname)

* 获得所有的名称：java.util.Enumeration getInitParameterNames()

* web项目初始化内容，web.xml文件配置

11.servlet初始化方法（day04）

* init() 执行时间，第一次方法时此方法将执行

* web.xml文件的<servlet>标签中，进行配置<load-on-startup>1</load-on-startup>，表示初始化方法将在服务器启动时执行

* 解决问题：当初始化处理时间过长或必须在其他servlet执行之前执行。

* 内容为数字，数字越小，优先级越高，优先启动。

Day05

回顾

* servlet继承关系

* javax.servlet.Servlet接口，javaee规定servlet规范

* class GenericServlet implementsServlet，通用servlet实现，所有都可以使用，service没有实现

*this.getServletConfig().getServletName()

* 实现ServletConfig --> this.getServletName()

* class HttpServlet extendsGenericServlet，与http协议有关

* servlet生命周期

* init(ServletConfig) , 执行1次，执行时间(1 第一次调用 2web.xml配置<load-on-startup>tomcat启动调用)

*service(ServletRequest,ServletResponse) ，一次请求执行1次

* destroy() 服务器正常关闭

* servlet编写流程

* 实现类，继承HttpServlet，并覆写doGet() 或 doPost()

* web.xml配置

<servlet-name>oneServlet

<servlet-class>cn.itcast.servlet.OneServlet

<servlet-mapping>

<servlet-name>oneServlet

<url-pattern>/one

* 测试：http://localhost:8080/day05/one

* 配置路径

* 完全匹配：/abc/one

* 不完全匹配：/abc/*

* 扩展名匹配：*.jsp

* 强转

javax.servlet.http.HttpServletRequestrequest = (...)javax.servlet.ServletRequest;

javax.servlet.http.HttpServletResponsereponse = (...)javax.servlet.ServletResponse;

* ServletContext对象

* 获得路径：ServletContext.getRealPath("/")

* 获得资源流：getResourceAsStream("/")

* 对象属性操作：xxxAttribute

###############################################################################

1.路径【☆】(day05)

* java项目(回顾)

* 相对路径

* 分类

* 字母开头，例如：book.xml

* "./"开头，当前目录，例如：./book.xml。与“字母开头”等价

* "../"开头，当前目录的上一次目录。例如：../book.xml

* 源码：File file = new File("books.xml");

* cmd -- java命令

* 运行：F:\workspaces\20130605\day05_java\bin>javacn.itcast.HelloWorld

* 结果：F:\workspaces\20130605\day05_java\bin\books.xml

* myeclipse运行

* 结果：F:\workspaces\20130605\day05_java\books.xml

* cmd中等价myeclipse

* 设置classpath

* 运行：F:\workspaces\20130605\day05_java>java -cpF:\workspaces\20130605\day05_java\bin cn.itcast.HelloWorld

* 结果：F:\workspaces\20130605\day05_java\books.xml

* 绝对路径：F:\workspaces\20130605\day05_java\books.xml

* web项目：web必须依赖与web服务器

* 相对路径：

* 字母开头：必须保证“当前页面”之前的内容，与“目标页面”在同一个路径下

* 与"./"等价

* "/"开头【★★★】

* 第一种：浏览器发送给服务器：当前web站点(%tomcat%/webapps, http://localhost:8080)

* 注意：%tomcat%/webapps/ROOT , http://localhost:8080/

* 第二种：服务器发送给服务器：当前web项目(%tomcat%/webapps/day05 , http://localhost:8080/day05)

* 注意：不需要填写web项目的名称

* 完整路径（绝对路径）：http://localhost:8080/day05/abc/1.html

2.tomcat请求与响应执行流程分析【阅读excel】(day05)

* tomcat的request实现类，对http协议的“请求”进行封装

* tomcat的response实现类，对http协议的“响应”进行封装

* 创建时间与销毁时间

* 创建：一次请求的开始

* 销毁：一次请求的结束

* request与response成对出现。先存在request，再存在response

3.response(day05)

* 接口：javax.servlet.http.HttpServletResponse, 父接口：javax.servlet.ServletResponse

* 总结：HttpServletResponseresponse = (...)ServletResponse

* http响应格式：响应行、响应头、响应体

* 操作

* 1. 响应行的操作：

* 修改状态码：setStatus(int sc) 【☆】

* SC_OK，200

* SC_NOT_FOUND，404

* SC_NOT_MODIFIED ，304

*SC_MOVED_TEMPORARILY ，302

*SC_INTERNAL_SERVER_ERROR ，500

* 2. 响应头的操作：

* 设置响应头，值为字符串：void setHeader(java.lang.String name, java.lang.Stringvalue) 【☆】

* 设置响应头，值为日期：void setDateHeader(java.lang.String name, long date)--> new Date().getTime()

* 设置响应头，值为整型值：void setIntHeader(java.lang.String name, int value)

* 回顾

* 跳转(重定向)

* 状态码：setStatus(302)

* 响应头：setHeader("location", uri);

* 重定向：重新指定方向

* API：sendRedirect(java.lang.String location) 【★★★】

* 3. 响应体操作： java使用流【★★★★★】

* 字节流：ServletOutputStream getOutputStream()

* 字符流：PrintWriter getWriter()

* 总结

* 所有流最终使用一个方法write(int b)

* getOutputStream() 与 getWriter()两个流不能同时使用

* getOutputStream() 用于处理字节，下载，压缩等

* getWriter() 用于处理字符，与文字有关。处理中文。

* 中文乱码处理

* 在发送中文之前设置编码

* API：response.setContentType("text/html;charset=UTF-8");【★★★】

* text/html，MIME类型，格式：大类型/小类型;参数。charset表示字符集

* text/csscss样式

* 回顾--设置响应头

response.setHeader("content-type","text/html;charset=UTF-8");

4.request(day05)

* 接口：javax.servlet.http.HttpServletRequest，父接口：javax.servlet.ServletRequest

* 强转：HttpServletRequestrequest = (...)ServletRequest

* http请求格式：请求行，请求头，请求体

* 操作

* 请求行的操作：

* 获得请求方法：request.getMethod(); -- GET

* 获得请求资源的路径

* 实例：http://localhost:8080/day05/request/api?username=jack&password=1234

** 获得协议：request.getScheme() -- http

** 获得域名，如果域名不存在，则显示IP：request.getServerName()-- localhost 或者 127.0.0.1

** 获得端口：request.getServerPort() -- 8080

** 获得发布到tomcat的项目名称：request.getContextPath() -- /day05 【★★★】

** 获得所有的请求参数 : request.getQueryString() -- username=jack&password=1234

** 获得servlet路径：request.getServletPath() -- /request/api 【★★★】

* 与路径有关API

*request.getRequestURL() ： http://localhost:8080/day05/request/api

*request.getRequestURI() ：/day05/request/api

* 请求头：

* 获得指定名称的值：java.lang.String getHeader(java.lang.String name)

* 获得时间值：long getDateHeader(java.lang.String name)

* 获得整型值：int getIntHeader(java.lang.String name)

* 请求体：【★★★★★】

* 通过表单提供的name属性获得表单提交的第一个数据：

java.lang.StringgetParameter(java.lang.String name)

* 注意：表单提交的数据都是字符串，或者是null，（没有填写值为空字符串）

* 通过表单提供的name属性获得表单提交的所有数据：

java.lang.String[]getParameterValues(java.lang.String name)

* 获得表单提交的数据：java.util.Map<String,String[]> getParameterMap()

* key，表单中所有的name属性，value，name属性对应的值

* 关系：

*java.util.Map<String,String[]> getParameterMap()

* 获得指定name的所有值：String[] getParameterMap().get(name)

* 获得指定name的第一个值：String getParameterMap().get(name)[0]

* 中文乱码处理【★★】

* 在获得表单数据之前设置post表单提交的数据编码：setCharacterEncoding(java.lang.String env)

* get请求方式的中文乱码处理

* str = new String(str.getBytes("ISO-8859-1") , "UTF-8")

5.修改myeclipse的servlet模板(day05)

* 关闭myeclipse

* 查询java文件

* 1.%myeclipse%/myeclipse.ini --> 查询common文件夹

* 2.Common/plugins/com.genuitec.eclipse.wizards_*.jar

* 3. jar/templates/Servlet.java

* 注意：

java项目 -->jar包

web项目 --> war包

jar包与war包的压缩格式相同，且与zip压缩格式相同

6.ReuqestDispatcher对象(day05)

* 接口：javax.servlet.RequestDispatcher

* 请求调度器，将服务器端的请求分发给其他资源

* 获得方法：

* 通过request对象获得，ServletRequest.getRequestDispatcher(java.lang.String) 【常用】

* 通过ServletContext对象获得，ServletContext.getRequestDispatcher(java.lang.String)，必须使用/开头

* API

* 转发：forward(ServletRequestrequest, ServletResponse response) ，只在浏览器端显示最后一个页面的发送内容【★★★★★】

* 包含：include(ServletRequestrequest, ServletResponse response) ，将所有页面的内容全部显示给浏览器

* request的属性操作：xxxAttribute

* 思考：转发与重定向的对比？？

7.案例【★★★★★必须完成】(day05)

* 1.提供表单html，登录（用户名）

* 2.编写一个servlet处理登录（LoginServlet）

* -1在init()方法中提供数据库的初始化

* 1获得表单提交数据

* 2.servlet提供Map<String,List> key :用户名 value，用户名对应数据

* 3.将获得数据放置request的属性中，使用转发（ShowServlet）显示数据

* 3.提供一个servlet显示数据（ShowServlet）

Day06

回顾

* path路径：

“/开头”：

* 浏览器-->服务器（web站点、必须填写web项目的名称）

* 服务器-->服务器（web项目，不需要项目名称--myeclipse/WebRoot）

* respnse

* 获得流：

* ServletOutputStreamgetOutputStream()

* PrintWriter getWriter()

* 中文乱码

*setContentType("text/html;charset=UTF-8");

* request

* 获得参数

* String getParameter(name)

* String[]getParameterValues(name)

*Map<String,String[]> getParameterMap();

* API路径

* 获得发布web项目名称：getContextPath() --> /day06

* servlet路径：getServletPath() --> /demo/abcServlet

* post中文乱码

*setCharacterEncoding("UTF-8");

* get中文乱码

* newString(str.getBytes("ISO-8859-1") , "UTF-8");

* 转发与重定向

* 转发：服务器向服务器请求资源，并只显示最后一个页面的发送到浏览器的数据

* 给request的属性添加内容：request.setAttribute(name,value)

* 转发：request.getRequestDispatcher("path").forward(request,response);

* 重定向：服务器通知浏览器，重新改变方向

*response.sendRedirect(location)

* 对比：用户操作一次，可以涉及多个页面

* 请求次数

* 转发：1次

* 重定向：2次

* 地址栏的变化

* 转发：地址栏不变

* 重定向：地址栏URL改变

* 是否可以获得request属性中的内容

* 转发：可以获得

* 重定向：不能获得第一个请求中的request属性的数据

* 创建request对象的个数

* 转发：2个，对象克隆，数据共享

* 重定向：2个，创建两个不同的对象，数据不共享

############################################################################

1.JSP入门(day06)

* JSP(Java Server Pages)是以Java语言为基础的动态网页开发技术（生成动态web资源）

* 对比

* servlet：在java程序嵌入html程序

* jsp：在html程序嵌入java程序

* jsp页面的扩展名：*.jsp

* JSP执行流程：参考excel

* JSP与servlet的关系？

* jsp也是一个servlet

* jsp注释：

* 格式：<%-- 注释内容 --%>

* html注释：

* 对比

html注释 java注释 jsp注释

html源码有无无

java源码有有无

jsp源码有有有

* JSP脚本元素：嵌入java程序

* 声明：在jsp页面声明java的方法、成员变量等（jsp程序servlet类的一部分）

* 格式：<%! 声明内容 %>

* 表达式：在jsp页面中嵌入java表达式，并发送到浏览器（jsp程序servlet类中service方法的一条语句）

* 格式：<%= 表达式%>

* 等价于：out.print(表达式);

* 代码片段：在java中方法体的内容（jsp程序servlet类中service方法的一部分）

* 格式：<% 代码片段 %>

* 注意：

* 所有的脚本元素不能嵌套

* 作业：使用jsp脚本元素将99乘法表发送到浏览器。增强：使用table布局

2.思考：两个servelt之间数据共享(day06)

* 如果一次请求：转发，将数据放置到request中

* 使用两次分别请求两个servlet，数据需要共享，如何操作？

* 多次请求一个servlet，数据需要共享，如何操作？

* 将数据放置在request的属性中，数据不共享

* 将数据放置在ServletContext对象。

* 案例：记录每一个人上一次访问时间

* 疑问：如果将数据放置ServletContext对象，所有人都方法，是否可以记录每一个人的上次访问时间？

3.会话(day06)

* 打开浏览器，访问一个站点，访问多次资源，关闭浏览器。整个过程就是一次会话。

* 会话技术

* cookie：浏览器端，保存数据，会话技术

* session：服务器端，保存数据，会话技术

4.cookie技术(day06)

* 类：javax.servlet.http.Cookie

* cookie，服务器可以发送少量的数据给浏览器，进行保存。再次访问时，浏览器将携带cookie信息返回给服务器

* cookie的API

* 发送cookie信息：response.addCookie()

* 创建cookie：new Cookie(name,value)

* 获得所有的cookie：cookie：Cookie[] request.getCookies()

* 注意

* 1 如果没有cookie将返回null

* 2 获得的cookie为当前目录或父目录之下的所有cookie

* 访问路径：http://localhost:8080/day06/a/b/c/servlet

* 获得cookie：

* 当前目录：/day06/a/b/c

* 父目录：

/day06/a/b

/day06/a

/day06

/-->站点

* 注意：http://localhost:8080/day06/a/m 不能访问

* 获得数据；名称,getName()值，getValue

* 持久化cookie，将cookie保存到硬盘

* 设置有效时间：setMaxAge ，单位秒

* 删除cookie

* 将有效时间设置为0

* 注意：如果path路径被修改，需要执行path

* 思路：

* 获得cookie

* 设置参数

* 通过浏览器，进行覆盖

* cookie的路径：

* cookie默认使用的当前servlet的路径：例如,localhost/day06/cookie/，通过cookie文件查看

* 设置路径：setPath

* 常用设置：setPath("/") ,使当前web站点都可以访问到指定的cookie

* 注意：

* cookie 默认情况下为会话级cookie。浏览器关闭之后数据流失。数据保存内存

* 同名，同路径的cookie将会别之后的覆盖

5.cookie综合案例：查看商品浏览记录(day06)

6.session(day06)

* 接口：javax.servlet.http.HttpSession

* session一般情况需要与cookie结合使用，在一次会话中只存在一个session对象

* session获得：HttpServletRequest.getSession()

* 如果request的cookie中没有sessionId，将创建一个新的session

* 例如，http协议request请求头中，JSESSIONID=C2B18200E8FA74A52595C2A56EB85AF7

* 如果request的cookie中存在sessionId，将获得已有的session

* session创建与销毁

* 创建：request不存在相应的session，执行request.getSession()时创建。

* 销毁：

* 1. 当session的过期时将销毁。默认过期时间为30分钟。

* 位置：%tomcat%/conf/web.xml

* 内容：

<session-config>

<session-timeout>30</session-timeout> （单位：分钟，inminutes）

</session-config>

*2.HttpSession.invalidate() , 销毁当前session

HttpSession.setMaxInactiveInterval(intinterval) ，设置当前session的销毁时间，单位，秒inseconds

* 3.非正常关闭服务器

* 注意：正常关闭session将被服务器保存到硬盘中。

* 保存位置：%tomcat%\work\Catalina\localhost\day06/SESSIONS.ser

* API

* isNew()是否是新创建

7. URL 重写(day06)

* 问题：如果cookie失效，session将无法使用。

* 手动方式：将url中追加session的id信息

* 例如：http://localhost:8080/day06/session/destroy.jsp;jsessionid=1F806FA468E0F028484ABE9F7BF0411B

* URL重写

* 如果浏览器禁用了cookie，tomcat自动设置";jsessionid=1F806FA468E0F028484ABE9F7BF0411B",如果没有禁用，则不设置

* API

* java.lang.StringHttpServletResponse.encodeRedirectURL(java.lang.String url)

* java.lang.StringHttpServletResponse.encodeURL(java.lang.String url)

* 唯一的区别：提供URL如果为空字符串显示结果不同。

* 使用API获得重写后的URL，提供现有的URL即可

8.session案例：一次性验证码(day06)

* 验证码（了解）

* 一次性（重点）

* 获得数据时，将数据保存到session

* 使用之后将数据移除session

* 实现

* VerifyCodeServlet：1用户获得验证码时，保存session

* LoginServlet处理登录

* 获得用户输入的验证码

* 获得session中缓存的

*判断session是否有值

* 没有值(已经使用)--表单重复提交

* 值 (没有使用)

* 匹配（使用）

* 相同：填写成功

* 不相同：验证码错误

* 将session删除

9.总结(day06)

* 存在xxxAttribute的对象：ServletCotext/ ServletRequest/ HttpSession (servlet 三个作用域对象)

* 作用域（作用范围）

* ServletContext，Servlet上下文对象，范围一个web项目。所有页面可以共享数据，多次会话

* HttpSession，服务器端会话技术，范围一次会话。整个会话中所有页面数据共享，多次请求。常用实例：将登录用户信息保存到session中

* ServletRequest，请求对象，范围一次请求。一般情况涉及一个页面，如果使用转发可以涉及多个页面。常用实例：转发将内容设置到request

* 选择：范围越小，优先选择。

Day07

回顾

* jsp入门

* jsp执行流程（tomcat将jsp文件处理成了servlet程序。jsp就是servlet）

* jsp脚本元素

* 声明：<%! 声明类型%> --> class Hello{ .... }

* 表达式：<%= 表达式%> --> out.print(表达式);

* 代码片段：<% %> --> service() { .... }

* jsp注释：<%-- jsp注释内容--%>

* 会话技术

* cookie ：服务器通知浏览器保存少量数据，浏览器在用户再次访问时，将携带相应的cookie信息（name和value）

* 创建cookie：new Cookie(name,value)

* 发送cookie：response.addCookie(...)

* 获得cookie：request.getCookies()

* API

* 有效时间：setMaxAge() ,单位秒，如果值为0，表示删除

* 路径：setPath(...) ,如果值为/，表示当前web站点。

* web站点：rul --> http://localhost:8080 ## tomcat --> %tomcat%/webapps

* url -->http://localhost:8080/ %tomcat%/webapps/ROOT （当访问http://localhost:8080路径时，浏览器自动添加/）

* session

* session ：服务器端保存会话级的数据

* 前提：默认情况，结合cookie一起使用

* 获得：request.getSession() --> 创建 | 获得

* 销毁：1.过期时间 2 执行session.invalidate() 3.非正常关闭

* 如果cookie失效，可以进行URL重写解决。response.URLEncode(url)

* 作业：99乘法表(参考：/day07/WebRoot/99cfb.jsp)

####################################################################################################

1.JSP指令(day07)

* 用于指示JSP执行某些步骤，用于指示JSP表现特定行为，用来设定JSP网页的整体配置信息

* 格式：<%@指令名称属性名=属性值 ... %>

* 指令名称分类：page、include、taglib

* page指令(参考：/day07/WebRoot/page.jsp)

* 格式：<%@page属性名=属性值 ... %>

* 编码处理

* pageEncoding属性：当前页面的编码

* contentType属性：jsp页面生成servlet响应给浏览器的编码设置，response.setContentType(...);

* 注意：同个编码一般情况相同

* jsp缓存机制

* buffer属性：当前jsp缓存大小，默认8kb

* autoFlush：设置当前jsp页面的缓存是否自动刷新

* 如果设置为false，将可以参数异常

*java.io.IOException: Error: JSP Buffer overflow，缓存溢出

* jsp错误处理机制(不常用)

* errorPage属性：用于指定错误页面，当前页面如果出项异常，将执行指定的页面

* isErrorPage属性：用于确定是否错误页面。将提供exception内置对象，获得异常信息

* 替代者，web.xml进行“友好页面”的配置

<error-page>

<!- 用于确定处理的错误的状态码 500 404 ->

<error-code>500</error-code>

<!-

用于确定处理的异常的类型

<exception-type>java.lang.RuntimeException</exception-type>

<location>/error.jsp</location>

</error-page>

* 常用的属性

* import属性：导包

* 分别导包：<%--@pageimport="java.util.ArrayList"--%> <%--@pageimport="java.util.List"--%>

* 一次导入多个：使用逗号分隔，<%--@page import="java.util.List,java.util.ArrayList"--%>

* isELIgnored属性：表示是否或略el表达式

* session属性：当前jsp页面是否使用session，默认情况自动使用request.getSession()

* 如果值为false，当前页面session不可使用

* include指令[参考：/day07/WebRoot/include]

* 静态包含：将处理jsp生成servlet之前，将内容合并为一个servlet，再编译，再执行

* 格式：<%@includefile=""%>

* file属性：用于确定被包含的页面

* 应用场景：页面的模块化

* taglib指令[标签，下一天]

* 格式：<%@taglib name=value%>

* 指令总结

* 指令书写的位置建议放在文件的最前面，可以在任意位置

* 指令可以书写多个

2.JSP内置对象(day07)

* 内置对象：jsp可以直接使用的对象。jsp生成一个servlet，servlet提供相应的变量。9种

* 内置对象9种介绍

* page，表示当前类this，一般不使用

* config，servlet配置对象ServletConfig，init(ServletConfig)提供

* application，使用servlet的上下文对象ServletContext， ServletConfig.getServletContext()

* request ,请求对象HttpServletRequest

* response，响应对象HttpServletResponse

* session , 会话session对象，request.getSession()

* out , 进行数据发送浏览器，response.getWriter()

* 类型：JspWriter

* exception , 用于处理整个servlet的异常

* pageContext ，jsp的管理者，JSP的上下文对象PageContext

3.out缓存机制(day07)

* out的类型为JspWriter，底层调用的out = response.getWriter();

但存在自己的缓存，当自己的缓存内容满或刷新后，将数据发送的PrintWriter的缓存中。

4.总结，jsp的4作用域(day07)

* application，就是servlet中的ServletContext。整个web项目（多次会话）

* session，就是servlet中的HttpSession。一次会话（多次请求）

* request，就是servlet中ServletRequest。一次请求（一般一个页面，转发多个页面）

* page，当前页面this。一个页面（标签，页面开始定义内容，结束时候释放）

5.PageContext对象(day07)（参考：/day07/WebRoot/page_context.jsp）

* JSP的管理者，jsp的上下文对象。

* 可以引用其他8个内置对象：getXxx()

* request : getRequest()

* out : getOut()

* 对作用域属性的操作：xxxAttribute

* jsp默认的作用域为：page

* 对默认作用域进行操作：

* java.lang.ObjectgetAttribute(java.lang.String name)

*removeAttribute(java.lang.String name)

*setAttribute(java.lang.String name, java.lang.Object value)

* 对指定作用域属性进行操作：

* java.lang.ObjectgetAttribute(java.lang.String name, int scope)

*removeAttribute(java.lang.String name, int scope)

*setAttribute(java.lang.String name, java.lang.Object value, int scope)

* 作用域：scope的取值

*PageContext.APPLICATION_SCOPE、PageContext.SESSION_SCOPE、PageContext.REQUEST_SCOPE、PageContext.PAGE_SCOPE

* 通过名称查询属性值，依次从page,request, session 和 application 搜索需要的值

* java.lang.ObjectfindAttribute(java.lang.String name)

* 思考：将PageContext对象已参数的形式传给给其他类，此类将可以当成jsp使用。

6.JavaBean(day07)（参考：/day07/src/cn/itcast/domain/Person.java）

* POJO（Plain OldJava Objects）简单的Java对象，实际就是普通JavaBeans

* JavaBean：一个类，具有一个公共的构造无参方法（默认构造），提供相应的getter（isXxx）或setter方法

* javabean的属性：通过属性提供getter或setter方法

* 如果是getter，属性的首字母大写，前加get ，例如：id ，getId()

* 如果是setter，属性的首字母大写，前加set ，例如：id ，setId(...)

* 成员变量：privateString id2;是当前JavaBean的字段

* 注意：默认情况下，字段名称与属性名称相同

7.内省(day07)（参考：/day07/src/cn/itcast/test/IntrospectorTest.java）【了解】

* jdk提供一个工具类，对javabean进行处理

* 类：java.beans.Introspector

* API

* 获得指定字节码对象的javabean描述对象：BeanInfo getBeanInfo(Class<?> beanClass)

* BeanInfo beanInfo =Introspector.getBeanInfo(Person.class)

* BeanInfo获得属性的描述对象：PropertyDescriptor[] getPropertyDescriptors()

* Method getReadMethod() 获得应该用于读取属性值的方法。

* Method getWriteMethod() 获得应该用于写入属性值的方法。

* 注意：内省的底层就是反射技术。

8.jsp动作标签(day07)

* 支持jsp的编辑器，都可以支持jsp的动作标签

* 使用格式：<jsp:标签名称>

* 标签

* 与javabean有关的标签（参考：/day07/WebRoot/javabean.jsp）

* 测试url：http://localhost:8080/day07/javabean.jsp?id=123&name=jack&boss=true

* <jsp:useBean> ：使用标签创建javabean对象，javabean必须有默认构造

* 例如：<jsp:useBean id="person"class="cn.itcast.domain.Person">

* class属性,用于确定javabean的完整路径名

* id属性，给当前的javabean进行命名，将当前javabean对象放置到指定的作用域

* scope属性，用于确定作用域的，默认为page

* 取值范围：page、request、session、application

* <jsp:setProperty> ：设置JavaBean的属性值

* 例如：<jsp:setProperty name="person"property="id" />

* name属性：用于确定作用域的名称

* property属性：用于确定javabean的属性的名称

* 如果property的值为星号(*)，表示表单提交的name值与javabean的属性值进行匹配，并赋值

* param属性：用于确定请求参数的名称，如果与属性名称相同，可以不写

* <jsp:getProperty> ：取得JavaBean的属性值

* 动态包含

<jsp:include> ：请求时包含文件

9.EL (day07)（参考：/day07/WebRoot/el.jsp）

* EL 全名为ExpressionLanguage,表达式语言

* EL和JSTL两种结合将替代jsp脚本元素。

* EL功能

* 获得jsp作用域中的数据

* 获取web开发常用对象

* 执行运算

* 调用Java方法

* 使用格式：${...}

* 语法

* el的内置对象：（11个）

* 与作用域有关：pageScope、requestScope、sessionScope、applicationScope

* jsp上下文对象：pageContext

* 运算符

* 执行运算

. 获得数据

[] 获得数据，获得特殊数据

* 其他

* empty：是否为空，对象为null 或空字符串，集合为0

* 注意：

* 用户自定义数据，必须放置到域中，el才可以操作

* 如果数据不存在，el将返回空字符串

* 面试题：参考：/day07/WebRoot/demo.jsp

<% i = 5 ;%>

<%=i%>

<% int i = 0 ;%>

<% i = 10 ;%>

<% this.i = 20;%>

<%! int i ;%>

<%=i%>

<%=this.i %>

结果为：5 10 20

结果分析：

<% i = 5;%>

<%=i%>

<% int i = 0 ;%>

<% i = 10 ;%>

<% this.i = 20;%>

<%! int i ;%>

<%=i%>

<%=this.i %>

Day08

回顾

* JSP

* JSP脚本元素：

* 声明：<%! ...; %>

* 表达式：<%= ...%>

* 代码片段：<% ...;%>

* JSP的指令

* page <%@page ...%>,对当前jsp页面生成servlet源文件时，继续设置

*include <%@ include file=""%> ,页面可以拆分为多部分，最后拼凑而成。

* taglib <%@ taglib%>标签有关

* JSP的内置对象：9个

* page，config,application, request,response, session,out,exception,pageContext

* PageContext对象

* xxxAttribute(..., intscope) ,PAGE_SCOPE/REQUEST_SCOPE/SESSION_SCOPE/APPLICATION_SCOPE

* findAttrbute(name) 依次从page/request/session/application获得指定名称的内容

* getXxx 可以应用其他的8个内置对象

* JSP4个作用域：

* JSP动作标签：<jsp:xxx/>

* <jsp:useBean> new JavaBean(),放置到作用域

* <jsp:setProperty> 给指定域中的对象的属性添加内容，*表示给所有参数名称与javabean的属性名称相同进行赋值

* <jsp:include/> ,动态包含

* EL

* 格式：${}

* 内置对象：11个（5个）

* EL获得4个作用域的内容：（attribute）：pageScope、requestScope【】，sessionScope，applicationScope

* EL获得jsp的上下文对象: pageContext【】

##############################################################################################

1.EL(参考：/day08/WebRoot/el.jsp) (day08)

* 内置对象：11个（其他6个）

* 请求参数：

* param，获得指定名称参数的第一个内容：request.getParamter(name) ,格式：${param.name} ***

* paramValues，获得指定名称参数的所有内容：String[] request.getParamterValues(name)

* 测试路径：http://localhost:8080/day08/el.jsp?username=jack&username=rose

* 请求头

* header ，获得指定名称请求头第一个信息： request.getHeader(name)

* headerValues，获得指定名称请求头所有信息：request.getHeaders(name)

* 注意：

${header.cookie} 获得请求头中cookie字符串信息，请求头都是字符串

* 其他

* cookie，获得指定的cookie对象【】

${cookie} 获得所有的cookie对象，内存存放在map中，key为cookie的名称，value为cookie对象

${cookie.JSESSIONID}<br/> 获得value的内容，及cookie对象

${cookie.JSESSIONID.value}<br/> 获得cookie的值，cookie的getValue的内容

* 格式：${cookie.自定义名称.value}

* initParam,用于获得web应用的初始化参数，ServletContext.getInitParamter

<context-param>

<param-name>gf</param-name>

<param-value>凤姐</param-value>

</context-param>

* 实例

*${pageContext.request.contextPath} 获得发布到tomcat的项目名称

2.自定义JSP标签(day08)

* 引入：在jsp遍历map （参考：/day08/WebRoot/map.jsp）

* 自定义标签的目的：用去替换jsp脚本。编写一个实现类，接收PageContext对象

* 编写流程

* 1.编写实现类

* 简单标签：SimpleTag 接口

* 传统标签：Tag接口(了解)

* 2.编写配置文件tld，将当前标签库注册给tomcat

* tld是taglib description 的缩写，标签库描述文件。基于xml文档，扩展名为tld

* 注册配置文件是，文件的标识全球必须唯一

* 回顾：schema文档

* 3.引用，使用

* 引用： <%@ taglib uri="" prefix=""%>

* uri:用于确定tld文件的标识

* prefix:给当前标签库的前缀进行命名

* 使用：

* 使用格式：<前缀：标签名/>

* 回顾jsp动作标签：<jsp:xxx/>

* 实现流程

* 1.编写实现类，实现SimpleTag接口

* public class DateTagimplements SimpleTag{

* 2.编写配置文件tld，将当前标签库注册给tomcat

* tomcat将自动加载tld文件

* 3.引用，使用

* 引用： <%@ taglib uri="" prefix=""%>

* uri:用于确定tld文件的标识

* prefix:给当前标签库的前缀进行命名

* 使用：

* 使用格式：<前缀：标签名/>

* 回顾jsp动作标签：<jsp:xxx/>

3.tld文件的位置(day08)

* 必须放置到web项目/WEB-INF目录下，除classes或lib目录。

* 必须放置到web项目/WEB-INF/lib目录中的jar文件里，%jar%/META-INF/*.tld

4.tld配置文件的内容：(day08)

* 配置内容：

<tlib-version>1.0</tlib-version>

<short-name>my</short-name>

<uri>http://www.itcast.cn/lt/mytag</uri>

<tag>

<name>mydate</name>

<tag-class>cn.itcast.tag.DateTag</tag-class>

<body-content>empty</body-content>

</tag>

<tag>

<name>items</name>

</attribute>

* body-content标签的配置：

* empty :表示标签体的内容为空（不允许写标签体）

* scriptless：不支持jsp脚本<%="abc" %>，支持EL表达式${name}作为标签体的内容

* JSP ：此设置只能在Tag接口（传统标签）的实现类中进行配置，支持JSP的所有内容

* tagdependent ：此标签作为内部使用，（不常用）

* 注意：

byte[] 不是Object[]的子类，但是Object的子类。基本类型的数组都会被单独处理

5.JSTL(day08) （参考：/day08/WebRoot/jstl.jsp）

* JSLT：JavaServerPages Standard Tag Library ： jsp标准标签库

* 提供给 JavaWeb 开发人员一个标准通用的标签函数库

* 需要使用JSTL的jar包

* %jstl.zip%/lib/

* jstl.jar : jstl规范，接口

* standard.jar ：apache的实现

* web项目，myeclipse提供jar文件（自带jar文件）

*javax.servlet.jsp.jstl.jar 就是jstl.jar

* jstl-impl.jar 就是standard.jar

* 使用myeclipse发布web项目时，将自动添加两个jar

* 使用介绍

JSTL 前缀名称 URI

核心标签库 c http://java.sun.com/jsp/jstl/core

函数标签 fn http://java.sun.com/jsp/jstl/functions

* 核心标签的标签

* 1 out标签：out将指定的内容输出到浏览器,默认情况将发送的内容进行转义（处理特殊字符）

* value属性：提供输出内容，支持EL表达式

* escapeXml属性：确定内容是否需要转义，默认值为true

* default属性：内容为空值时将显示默认值

* 2 set标签：给指定作用域设置内容,默认作用域为page

* var属性：域中的名称

* value属性：域中的内容

* scope属性：确定作用域，page,request,session,application

* 3 remove标签：移除指定作用域的内容，默认移除所有域中指定名称的内容

* var属性：域的名称

* scope属性：作用域

* 4 if标签：条件语句，条件true，将输出标签体的内容

* test属性：用于确定条件表达式，支持EL。字符串true也可以使用

* 5 choose标签：等价java switch {case ... default ...}

* when标签：等价于case

* otherwise标签：等价于default

* 6 url标签：用于在jsp页面中处理链接，url会自动进行url重写

* value属性：用于确定需要处理的url，不需要填写项目名称

* var属性：将处理的结果放置作用域中，名称为var的值

* 7 foreach标签：增强for循环

* begin:开始值

* end:结束值

* step:步长（自增）

* var：将结果放置到作用域page

* items : 确定集合或数组（确定需要遍历的容器）

6.EL函数(day08)（参考：/day08/WebRoot/el_fn.jsp）

* 引用：<%@taglib uri="http://java.sun.com/jsp/jstl/functions"prefix="fn" %>

* 使用：

* 是否包含： ${fn:contains("abc", "a")} 结果为true

7.BeanUtils(day08)

* apache 的commons组件，对javabean进行数据封装

* 需要jar：

* 核心jar文件：commons-beanutils-1.8.3.jar

* 依赖jar文件：commons-logging-1.1.1.jar

* API

* 给指定的javabean的属性进行赋值

BeanUtils.setProperty(javabean对象, "属性名称",值);

* 特殊类型需要注册转换

* 将字符串与java.util.Date进行执行格式的转换

DateConverter dateConverter= new DateConverter();

dateConverter.setPattern("yyyy-MM-dd"); //确定时间的格式

ConvertUtils.register(dateConverter,Date.class);

* 将表单数据直接封装到指定的Javabean

BeanUtils.populate(JavaBean,request.getParameterMap());

* 要求：表单元素的name属性的值，必须与javabean的属性相同。

8.模式介绍(day08)

* 模式1 ： JSP + JavaBean

* 模式2 ： JSP + Servlet + JavaBean

* MVC：软件设计模式，它是一种分离业务逻辑与显示界面的设计方法

Day09

Day10

day10--day15

* day10: mysql数据库，sql语句

* day11: jdbc java链接数据库入门

* day12: jdbc 事务，数据处理

* day13：DBUtils，连接池，案例：条件查询

* day15：分页、listener监听器、国际化

#############################################################################

1.数据库介绍(day10)

* 数据库管理系统（DBMS，DataBase Management System）：管理数据库的软件

* 数据库（DB、DataBase）：将数据保存到指定的文件中(硬盘，持久化)，按特定的数据结构存储数据。

* 关系性数据库管理系统（RDBMS）

* 关系：二维表，描述是实体与实体之间关系。（实体类似于java中的对象）

* 概念

* 元组（记录）:一行数据

* 属性（字段、列）：一列数据

* 一个列中的数据必须为同一个类型，列存在唯一名称

* 关系数据库分类

* oracle，Oracle公司数据库软件。性能最佳，收费

* db2,IBM公司数据库软件。性能最佳，收费

* ms sql server：是Microsoft公司，不跨平台，收费

*mysql：Oracle公司免费的数据库（mysql，sun）

* 流行的网站构架方式是LAMP（Linux+Apache+MySQL+PHP）

2.mysql安装(day10)

* mysql端口：默认端口3306

* 设置么mysql默认字符集(编码)

* latin1编码：ISO-8859-1

* UTF8编码：UTF-8

* mysql默认账号：root

* 在安装mysql时，只需要设置root密码（需要确认密码）

* %mysql%/my.ini 配置文件

* [mysql]default-character-set=utf8 默认字符集

* [mysqld]

port=3306 端口号

basedir="C:/java/MySQL/MySQLServer 5.5/" 安装目录

datadir="C:/java/MySQL/MySQLServer 5.5/Data/" 数据库存放的目录

3.mysql目录：(day10)

* bin目录：mysql所有执行命令存放目录

* mysql.exe ，链接mysql服务器命令

* mysqld.exe ，mysql 服务启动命令（与 tomcat startup.bat等价）

* data目录：my.ini文件配置目录datadir，数据库存放的目录

* my.ini文件：核心配置文件文件

4.mysql启动与登录(day10)

* mysql安装成功之后，默认为启动状态

* mysql启动

* 手动启动：cmd> mysqld --console

* 注意：窗口关闭之后服务器将关闭

* 启动的window（操作系统）的服务： cmd > net start mysql

* 注意：

* win7 net命令不能直接使用。“已管理员运行cmd”

* 后台启动可以关闭命令窗口

* mysql登录

* 查看帮助：mysql--help

* 格式1：mysql [-hIP] -u用户名 -p[密码]

* 例如：cmd > mysql -h192.168.1.200 -uroot -p1234

* 格式2：mysql --host=IP --user=用户名--password[=密码]

* 例如：cmd > mysql --host=192.168.1.200 --user=root--password=1234

* 常用

* cmd > mysql -uroot-p1234 默认连接自己的数据库，提供密码

* cmd > mysql -uroot -p ，执行必须再次填写密码

* 登录成功

mysql> 提示，之后操作都是sql语句

* mysql服务关闭

* “我的电脑”/“管理” -- 服务（services.msc | 控制面板/管理工具/服务）

* cmd > net stop mysql

5.mysql root账号密码重置(day10)

* 1使用没有权限验证的方式启动mysql服务器： cmd > mysqld --console --skip-grant-tables

* 2使用root登录： cmd > mysql -uroot

* 3使用mysql数据库： mysql > use mysql;

* 4修改user表中的数据

* 4.1 查询所有 : mysql > select * from user; 修改查询命令,使用4.3命令

* 4.2 查询user表的结构：mysql > desc user;

* 4.3 查询指定的内容：mysql > select host,user,password from user; --> 安装版root密码默认为空

* 4.4 修改密码：update user set password = password('1234') wherehost='localhost' and user='root';

6.mysql基本操作命令(day10)

显示当前数据库服务器中的数据库列表： mysql> show databases;

* %mysql%/data/mysql mysql数据库的核心数据文件，不能删除

使用数据库：mysql> use 库名;

显示数据库中的数据表： mysql>showtables;

显示当前所使用的数据库名称：mysql>select database();

显示当前数据库的状态： mysql> status;

显示当前数据库中某表的表结构（DESCRIBE ）： mysql> desc user;

显示所支持的字符集： show character set;

7.sql介绍(day10)

* SQL被称为结构化查询语言(structuredquery language)

* 各个数据库生产厂商，要遵循sql标准同时又开发出自己数据特有的特性

* sql分类：

DDL，数据定义语言：create创建、drop删除、 alter 修改（区分javascript中的alert，提示框）

DML，数据操纵语言：insert录入，update更新，delete删除(truncate)

DQL，数据查询语言：select查询

* 了解：

* DPL事务处理语言（start transaction 开启，commit 提交，rollback回滚）

* DCL数据控制语言（grant 授权 revoke移除权限）

8. DDL数据定义语言(day10)

* 1 数据库的操作，DataBase

* 创建数据库：mysql> create database 数据库名称 [character set 字符集] ;

* 例如：mysql> create database itcast;

* 删除数据库：mysql> drop database 数据库名称;

* mysql> drop databaseitcast;

* 2 表的操作， table

* 创建表： mysql > create table 表名(字段1的描述,...);

* 字段的描述格式：字段名称字段类型

* 字段名称：自定义

* 字段类型：api搜索：data types

* 字符串类型： char(长度) ， varchar(长度)

* char(5)，固定长度的字符串，字符串必须为5个字符。如果设置的内容为abc，将在右侧填充空格 "abc__"

*varchar(5) ，可变长度的字符串，最大允许5个字符串。如果设置的内容为abc，值为 "abc"

* 注意：字符串必须使用引号括住，建议使用单引号

* 数字类型

* int(省略) ，默认长度11，整型

*double(M,D) , 浮点

*M，数字的字符的个数

*D，小数为的位数

* 例如：double(5,2),最大值 999.99

* decimal(M,D) | numeric(M,D) 表示支持所有的数字

* 注意：两个字段的描述之间必须使用逗号，但最后一个字段的描述不能使用逗号

* 例如：

create table user(

idvarchar(32) ,

usernamevarchar(50) ,

passwordvarchar(32)

);

* 删除表：mysql> drop table 表名;

* mysql> drop tableuser;

* 修改表名：mysql> alter table 表名 rename 字段名

* 3 字段的操作：修改表结构（alter table 表名）

* 添加： mysql > alter table 表名 add[column] 字段的描述

* mysql> alter tableusers add column money double(5,2);

* 修改：修改字段的类型或名称

*修改类型：mysql > alter table 表名 change column 旧字段名新字段的描述

* mysql> altertable users change money money int;

* 删除： mysql > alter table 表名 dropcolumn 列名

9、DML数据操纵语言(day10)

* 录入数据： mysql > insert into 表名[(字段名称,...)] values(数据,...);

* 录入一条记录的所有数据

* mysql > insert intousers values('u001','tomasi','jack',18,98);

* mysql > insert intousers(id,firstname,secondname,age,count) values('u002','tomasi','jack',18,98); 【】

* 录入部分数据

* mysql > insert intousers(id,secondname,age) values('u003','jack',18);

* 默认情况如果没有指定数据，值为null

* 更新数据：mysql> update 表名 set 字段名称=值,... [ where sql条件]

* mysql> update users set age =20; 需该所有age的值

* sql条件,一般情况格式：字段=条件值

* mysql> update usersset age = 120 where id='u001';

* 删除数据： mysql > delete from 表名 [where 条件]

* mysql> delete from userswhere id='u003'; 删除指定的数据

* mysql> delete from users; 删除所有的数据，（建议上班之后慎用）

* 比较：mysql>truncate table users; 也可以清空表中的数据

* truncate 性能比delete快。delete一条一条的删除，truncate将表删掉，再创建一个

* delete 不能删除自动增长列中记录数，truncate能重置记录数（约束--自动增长列--auto_increment）

10、DQL 数据查询语言(day10)

* mysql > select 字段,... from 表名 [where 条件]

* 字段别名，格式：字段[as] 别名

* 注意：字段处可以使用*替换，表示所有意思，不建议使用，影响性能

11.中文乱码处理(day10)

* 思路1 ：安装是设置的字符集为，latin1编码：ISO-8859-1

* 创建数据时指定字符集： mysql > create database itcast character set utf8;

* 思路2 ：安装是设置的字符集为，UTF8编码：UTF-8

* 再命令窗口cmd中，设置服务器端的参数：set names gbk;

* 查询字符集：mysql>show variables like '%char%';

12、mysql异常(day10)

* mysql服务没有启动

* 提示：ERROR2003 (HY000): Can't connect to MySQL server on 'localhost' (10061)

* 登录密码不正确

* 提示：ERROR1045 (28000): Access denied for user 'root'@'localhost' (using password: YES)

* 数据库已经存在

* 提示：ERROR1007 (HY000): Can't create database 'itcast'; database exists

* 没有使用数据库

* 提示：ERROR1046 (3D000): No database selected

* 小数位数必须小于等于数字长度

* mysql> alter table users addcolumn money double(5,6);

* 提示：ERROR1427 (42000): For float(M,D), double(M,D) or decimal(M,D), M must be >=D(column 'money').

13.sql文件(day10)

* 用于存放sql语句的文件：*.sql

* 注释： "#注释内容" "-- 注释内容"

* 回顾 javaweb （day03--day09）

* day03 -- tomcat & http

* tomcat 启动： %tomcat%/bin/startup.bat

* tomcat 配置文件

* %tomcat%/conf/server.xml, tomcat 核心配置文件(设置端口，配置虚拟路径，配置虚拟主机，确定默认主机)

* %tomcat%/conf/web.xml ，tomcat管理所有web项目的基本配置文件。优先使用web项目自己的web.xml文件

* tomcat目录

* webapps目录：tomcat管理的所有web项目存放的目录

* work目录：tomcat处理jsp工作目录

* web项目的目录

-- WEB-INF目录，tomcat过滤此目录中的内容，不允许浏览器直接访问

| -- classes，web项目字节码存放的目录

| -- lib，web项目依赖的jar文件存放的目录

| -- web.xml，web项目配置文件（配置servlet，配置全局的初始化参数，配置友好页面，配置欢迎页面）

* http协议：传输的都是字符串。如果是中文，必须编码之后传递

* 请求request：请求行，请求头，请求体

* 请求方式：GET、POST

* get提交的数据有限，且中文会出现乱码，不安全

* post提交，将提交数据放置到请求体中

* 响应response：响应行，响应头，响应体

* 状态码：200,302,304,404,500

* 响应头：referer防盗链，refresh刷新，location重定向，content-type设置编码，content-encoding压缩，content-disposition下载

* day04

* servlet

* 接口：javax.servlet.Servlet

* 生命周期：init(ServletConfig) , service(ServletRequest，ServletResponse) , destroy()

* 自定义servlet 继承javax.servlet.http.HttpServlet (HttpServlet --> GenericServlet -->Servlet)

* 操作

* 初始化操作，覆盖init()方法

* 获得ServletContext对象：this.getServletContext() -->this.getServletConfig().getServletContext()

* web.xml文件

<servlet-name>

<servlet-class>

<servlet-mapping>

<servlet-name>

<url-pattern>

* ServletContext

* 存储数据范围（最大）：xxxAttribute

* 获得web项目中资源路径；servletContext.getRealPath("/...")

* 获得web项目中资源流；servletContext.getResourceAsStream("/...")

* day05

* request

* 处理post中文乱码：request.setCharacterEncoding("");

* 表单数据

* Stringrequest.getParameter(name)

* String[]request.getParameterValues(name)

*Map<String,String[]> request.getParameterMap()

* 常用API

*request.getContextPath() 获得发布到tomcat中的项目名称

*request.getServletPath() 获得servlet的路径名称<servlet-mapping><url-pattern>...

* request作用域（存放数据）：xxxAttribute

* response

* 中文乱码：response.setContentType("text/html;charset=UTF-8");

* 发送数据

* 字节流：ServletOutputStream getOutputSteam()

* 字符流：PrintWriter getWriter()

* 响应头：setHeader(name,value)

* 转发与重定向

* 转发：request.getRequestDispacher(path).forward(request,response);

* 重定向：response.sendRedirect(location)

* day06

* cookie

* 创建：new Cookie(name,value)

* API :setPath("/") ,setMaxAge

* 发送浏览器：response.addCookie(...)

* session

* 获得：HttpSession request.getSession()

* 存储数据：xxxAttribute ，session作用域

* 销毁

* 1 过期，web.xml配置<session-config><seession-timeout>，默认30分钟

* 2 执行api，invalidate()

* 3 非正常关闭服务器

* day07

* JSP

* jsp脚本：<%!%> <%%> <%=%>

* jsp内置对象，9种：page、config、application，request，response，session，out，exception，pageContext

* pageContext对象

* 引用其他8个内容

* 快捷的操作域数据 xxxAttribute(name,value,scope)

* jsp作用域：page,request,session,application

* jsp动作标签：<jsp:userBean <jsp:setProperty> <jsp:include

* jsp引用标签：<%@ taglib uri=""prifix=""%>

* EL

* 内置对象：11个

* 作用域：pageScope,requestScope,sessionScope,applicationScope

* pageContext,

* param,paramValues,

*header,headerValues,

* cookie,initParam

* el函数：${前缀：函数(...)}

* 常用：

${pageContext.request.contextPath}

${cookie.cookie名称.value}

* day08

* 自定义标签

* JSTL

* 核心标签：

* <c:set<c:out <c:remove

* <c:if<c:choose <c:when <c:otherwise

* <c:url

* <c:foreach

* JavaBean

* POJO ,普通java类

* 默认构造

* 提供getter或setter

* getXxxx setXxxx (错误 GetXxx SetXxx)

* day09

* javaee开发模式：

* 模式1： javabean + jsp

* 模式2： javabean + servlet + jsp

* MVC 软件开发模式：Model模型，View视图，Controller控制器

* 数据处理与数据显示相分离

* web三层体系架构

* 表示层（web层）

* 业务逻辑成（service层）

* 持久层（数据访问层，dao层）

Day11

回顾

* 数据库： create | drop database 数据库名称;

* 表： create | drop table 表名(字段描述)

* 字段： altertable 表名 add| drop | change 字段。。

* 录入： insertinto 表名(字段..)values(值)

* 更新： update 表名 set 字段=值 ,...where = 条件

* 查询：selectdistinct 字段 | * from 表1,表2 where 语句条件 groupby 字段 having 分组的条件 orderby 字段 asc|desc;

###########################################################################3

sql语句的位置：day11_data.sql

1.约束【★★★-- 关键字】(day11)

* sql约束，限定表中的数据

* 1 主键约束：

* 关键字：primarykey

* 要求表中被约束的字段中的数据不能重复，且不能为null

* 设置主键约束三种方法

* 1 创建表，声明字段时，直接对当前字段进行约束。

id varchar(32)primary key,

* 2 创建表，声明字段之后，在约束区域进行主键约束

namevarchar(50), -- 之后必须使用逗号

constraint primarykey(id)

* 3 创建表之后，修改表的字段，添加主键约束【】

alter tableprimarykey3 add constraint primary key (id);

* 格式：alter table 表名 add[constraint] primary key [主键唯一名称] (字段1,字段2,...);

* 注意：如果使用了两个字段做为主键，联合主键。两个的值合并在一起唯一 (id1,id2 --> 1,1 --> 1,1不允许 1,2允许的)

* 录入数据

* 删除主键

* alter table 表名 drop primary key;

* 2 唯一约束

* 关键字： unique

* 要求表中被约束的字段中的数据不能重复

* 设置唯一约束三种方法

* 1 创建表，声明字段时，直接对当前字段进行约束。

id varchar(32) unique,

* 2 创建表，声明字段之后，在约束区域进行主约束

name varchar(50), ## 必须填写逗号

constraint unique(id)

* 3 创建表之后，修改表的字段，添加约束【】

alter table unique3add constraint unique(id);

* 格式：alter table 表名 addconstraint [索引号] unique(字段);

* 删除唯一

* alter table 表名 drop index 索引的名称;

* 注意：默认索引号为字段的名称

# 3 非空约束

* 关键字：notnull

* 要求表中被约束的字段中的数据不能为null

* 设置非空约束:创建表，声明字段时，直接对当前字段进行约束。

* id varchar(32) not null,

* 总结：主键 = 唯一 + 非空

# 4 mysql的自动增长列

* 关键字：auto_increment

* 要求表中被约束的字段中的数据自动的添加编号

* 设置自动增长列:创建表，声明字段时，直接对当前字段进行约束。

* id int primary keyauto_increment,

* 注意：

delete from auto_inc; # 删除数据内容，没有重置“自动增长列”记录数

truncate table auto_inc; #删除表再创建，记录数重置

# 外键约束

* 关键字：foreignkey

* 外键就是在从表中添加一个字段，字段中的数据是主表主键的引用。

* 概念

* 主表：1对多关系中1表

* 从表：1对多关系中多表

* 一般情况外键的名称：主表名称_主表的主键

* 注意：

* 外键的类型必须与主键的类型一致

* 外键的值可以为null

2.表与表之间的关系【★★★】(day11)

* 1对多、多对1 【★★★★★】

* 主外键关系，描述1对多关系

* 注意：

* 主表数据不能删除，从表已经引用的数据

* 从表数据不能添加，主表中的数据不存在

* 多对多

* 创建中间表，使多对多变成两个1对多

* 中间表成为两个主表的从表

* 在中间表创建两个字段，分别与两个主表形参1对多关系

* 1对1

* 主表中的主键，与从表中的主键（外键），建立主外键关系

* 主表中的主键，与从表中的外键（唯一约束unique），建立主外键关系

3. 数据库的备份与恢复(day11)

* 备份： cmd --# mysqldump -uroot -p1234 day11 > d:/my.sql

* 格式：mysqldump-u账号 -p密码数据库名称 > 文件的路径

* 恢复： cmd --# mysql -uroot -p1234 back_day11 < d:/my.sql

* 格式：mysql -u账号 -p密码新建创好的数据库名称 < 文件的路径

* 注意：必须手动的创建数据库

4. JDBC(day11)

* JDBC(Java Data Base Connectivity),java数据库连接,通过JDBC规范(接口)直接操作数据

* 位置：jdk ： java.sql javax.sql 包

* 驱动driver：数据库生产厂商提供的可以操作自己数据的程序，jdbc规范的实现类。不需要用户干预实现细节

* 接口：java.sql.Driver。每个驱动程序类必须实现的接口。

* 需要引用jar文件：mysql-connector-java-5.1.22-bin.jar

* JDBC开发流程【★★★--思路，实现CURD】

1.注册驱动

2.获得链接

3.获得语句执行者

4.发送sql语句（执行sql）

5.处理结果

6.释放资源

5.JDBC细节分析(day11)

* 5.1 注册驱动

* 开发代码：Class.forName("com.mysql.jdbc.Driver");

* public classcom.mysql.jdbc.Driver implements java.sql.Driver {

* 源码

static {

java.sql.DriverManager.registerDriver(newDriver());

}

* DriverManager驱动管理工具，管理一组 JDBC 驱动程序的基本服务。

* registerDriver() 注册驱动

*DriverManager.registerDriver(new com.mysql.jdbc.Driver());不建议自己书写

* 驱动架加载两次

* 依赖指定驱动（以后将更改驱动，程序不改变）

* 5.2获得链接

* 开发代码：Connectionconn =DriverManager.getConnection("jdbc:mysql://localhost:3306/day11","root", "1234");

* 接口：java.sql.Connection, 与特定数据库的连接（会话）。

* DriverManager驱动管理工具

* getConnection(String url,String user, String password) ，通过指定的参数获得链接

* url参数：格式，大协议：子协议：子名称

* mysql ##jdbc:mysql://mysql主机名:端口/数据库名称，例如：jdbc:mysql://localhost:3306/day11

* 简写：jdbc:mysql:///day11 ,省略默认值 localhost:3306

* orcale ##jdbc:oracle:thin:@<server>[:<1521>]:<database_name>

* user参数： mysql服务器的登录账号

* password参数：mysql服务器的登录密码

* 5.3 获得语句对象

* 获得语句执行者：Statement createStatement() ，可以指定普通sql语句

* 获得预处理对象：PreparedStatementprepareStatement(String sql) ，可以预先编译sql语句，在设置参数

* 获得存储过程处理对象：CallableStatementprepareCall(String sql) [oracle将涉及]

* 5.4.发送sql语句（执行sql）

* 接口：java.sql.Statement 用于执行静态 SQL 语句并返回它所生成结果的对象。

* boolean execute(Stringsql) , 执行DML (insert update delete) 返回false，执行DQL(select) 返回true

* ResultSetexecuteQuery(String sql) 执行DQL语句，将查询的结果放置ResultSet中

* int executeUpdate(Stringsql) 执行DML语句，当前sql语句影响行数

* xxxx

* 5.5.处理结果

* 接口：java.sql.ResultSet, 表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。

* 5.6.释放资源

* 资源很珍贵，必须释放

6.工具类(day11)

* 获得链接

* 将需要的4个基本配置放置到properties文件中

// 0.1 准备Properties工具对象

Properties props = newProperties();

// 0.2加载配置文件

// ** 通过类加载器获得资源文件 --文件位置src

InputStream is =JdbcUtil.class.getClassLoader().getResourceAsStream("jdbcinfo.properties");

props.load(is);

// 0.3 获得配置信息

String driver =props.getProperty("driver");

String url = props.getProperty("url");

String user =props.getProperty("user");

String password =props.getProperty("password");

* 获得链接

//1注册驱动

Class.forName(driver);

//2获得链接

conn =DriverManager.getConnection(url, user, password);

* 释放资源

* 注意：必须进行非空判断

public static voidcloseResource(Connection conn , Statement st , ResultSet rs){

try {

if(rs != null){

rs.close();

}

} catch (SQLException e) {

e.printStackTrace();

} finally{

try {

if(st !=null){

st.close();

}

} catch(SQLException e) {

e.printStackTrace();

} finally {

try {

if(conn!= null){

conn.close();

}

} catch(SQLException e) {

e.printStackTrace();

}

7.重写day09案例，将数据保存到数据(day11)

* 拷贝jdbcUtil 和 jdbc驱动jar文件

* 创建表放置数据

* 重写dao

8. PreparedStatement对象：预处理对象【★★★--CURD操作--思考CUD】(day11)

* 预先编译sql，用户输入的内容，只是参数的一部分，不作为sql语句进行编译。

* 遍历流程

* 1 提供sql语句，此sql语句中的参数将使用?替换

String sql = "select *from users where username = ?";

* 2 获得预处理对象，必须填写sql语句

psmt =conn.prepareStatement(sql);

* 3 设置参数，将?替换继续的实际参数

psmt.setString(1,username);

* 第一个参数：表示?位置，从1开始

* 第二个参数：实际值

* 4 执行sql

rs = psmt.executeQuery();

Day12

1.JDBC操作(day12)

* 驱动可以不注册

* 可以省略Class.forName(driver);

* 原因：mysql-connector-java-5.1.22-bin.jar/META-INF/services/java.sql.Driver内容com.mysql.jdbc.Driver ，程序将自动加载

* PreparedStatement对象

* sql注入：防止实际参数作为sql语句的一部分。

* 大数据处理

* mysql大数据类型：

* blob ：Binary Large Object，二进制大对象。mysql提供blob(64k),longblob(4G)

* java对象api :

*psmt.setBinaryStream(parameterIndex, x) 二进制数据

*psmt.setBlob(parameterIndex, inputStream) blob对象

* clob ：Character Large Object字符大对象。mysql提供text(64k),longtext(4G)

* 批处理

* Statement对象

* addBatch(Stringsql) 给批处理缓存中，添加sql语句

* clearBatch() 清空缓存

* executeBatch() 将缓存中的sql语句都执行

* PreparedStatement对象

* 获得对象，提供sql

* addBatch() ，将指定的参数添加到批处理缓存

* 时间处理

* Statement对象，字符串的形式处理或mysql提供时间函数now()

* PreparedStatement对象，getDate(java.sql.Date) getTime(java.sql.Time) getTimeStamp(java.sql.TimeStamp)

* newjava.sql.Date(new java.util.Date().getTime())

2.事务(day12)

* 将一组业务作为一个整体，所有的内容要么全部成功，要么全部不成功。

* 事务的特性：ACID

* 原子性：事务不可分割整体

* 一致性：事务前后数据的一致。

* 隔离性：事务的并发访问

* 持久性：事务完成不可改变，永久性

* 事务的隔离性存在问题

* 脏读：一个事务，读到另一个事务没有提交的数据

* 不可重复读：一个事务，读到另一个事务提交的数据（update更新）

* 虚读（幻读）：一个事务，读到另一个事务提交的数据（insert录入）

* 事务操作

* 开启事务

* 事务提交（全部成功）

* 事务回滚（全部不成功）

* 事务的隔离级别

* 读未提交：readuncommitted ,存在所有问题

* 读已提交：readcommitted，解决了脏读问题，其他问题没有解决

* 可重复读：repeatableread ，解决了脏读与不可重复读问题，其他问题没有解决

* 串行化：serializable，等价java同步代码，单线程。解决所有问题

* 数据库默认隔离级别

* mysql的默认值：repeatable read

* oracle的默认值：read committed

* 对比

* 性能： readuncommitted > read committed > repeatable read > serializable

* 安全： readuncommitted < read committed < repeatable read < serializable

* mysql操作

* mysql事务操作

* 开启事务： mysql > start transaction;

* 事务提交（全部成功） mysql > commit;

* 事务回滚（全部不成功） mysql > rollback;

* 查看mysql 的隔离级别

* 第一种方法：mysql> show variables like '%iso%';

+---------------+-----------------+

| Variable_name |Value |

+---------------+-----------------+

| tx_isolation | REPEATABLE-READ |

+---------------+-----------------+

* 第二种方法：mysql > select @@tx_isolation;

* 设置事务方式

* 格式：set session transaction isolation level {readuncommitted | read committed | repeatable read | serializable};

* 通过API，搜索 set transaction 进行查询

* 演示事务的隔离级别

* 读未提交：readuncommitted

* A的隔离级别为read uncommitted

* AB窗口开启事务

* A查询，B更新（没有提交或回滚）

* A再查询(查询到了B没有提交的数据)

* 读已提交：readcommitted

* A的隔离级别read committed

* AB口开启事务

* A查询，B更新，B提交

* A再查询（读到B提交数据）

* 可重复读：repeatableread

* A的隔离级别repeatable read

* AB口开启事务

* A查询，B更新，B提交

* A再查询（A在当前事务中读不到B提交，A读取的数据重复的数据）

* A必须完成当前事务，再查询就可以读到B提交的事务

* 串行化：serializable

* A的隔离级别serializable

* AB口开启事务

* A查询，B更新（等待。。。第一种A完成操作，第二种B等待超时）

3. lost update(day12) （丢失更新）

* AB操作查询(1)，A更新(2), B不知晓A已经操作，继续更新(3)

* 数据库锁机制：

* 悲观锁，数据肯定会丢失。使用数据库锁解决（锁必须放置到事务中才有效）

* 读锁（共享锁）：多个读锁可以在事务对一个表进行读取

* 格式：select .... LOCK IN SHARE MODE

* 写锁（排它锁）：如果当前表已经被写锁占用，就不可以添加读锁

* 格式：select ... FOR UPDATE

* 注意：update语句默认添加写锁

* 乐观锁，数据肯定不会丢失。在表中添加一个字段（时间戳）记录一个唯一表示，用于区分数据是否更新

4.Java事务操作(day12)

* 开启事务：Connection.setAutoCommit(false)，自动提交被取消，需要手动提交

*mysql事务是自动提交

* 提交事务：Connection.commit()

* 回滚事务：Connection.rollback()

* 回滚事务到指定的还原点：rollback(Savepointsavepoint)

* 设置还原点：Savepoint setSavepoint()

* 事务经典代码

Connection conn = null;

try{

//获得链接

//1 开启事务

conn.setAutoCommit(false);

//*****************一组操作(业务)

//2 提交事务

conn.commit();

} catch(Exception e){

//3 回滚事务

conn.rollback();

} finally{

//释放资源

conn.close();

}

* 案例：三层架构完成转账

5.连接池(day12)

* 自定义连接池：close()方法完成将“当前链接归还到连接池”，“装饰设计模式”进行方法增强

* 方法增强三种方式

* 1.继承（需要增强的方法，必须可以new）

* 2.装饰设计模式（5步骤）

* 3.动态代理

* 规范，连接池必须实现javax.sql.DataSource接口

* 连接池实现

* web服务器提供连接池的实现（数据源）

* DBCP，apache提供的第三方开源的连接池

* C3P0，提供的第三方开源的连接池

* DBCP链接池

* 需要jar文件

* 核心jar文件：commons-dbcp-1.4.jar

* 依赖jar文件：commons-pool-1.6.jar

* C3P0连接池

* 需要jar文件

* 核心jar文件：c3p0-0.9.2-pre5.jar

* 依赖jar文件：mchange-commons-java-0.2.3.jar

* 必须在src创建xml文档：c3p0-config.xml

总结

* sql语句

* DDL（数据库，表）

* DML（insert update delete）

* DQL（select）

* 约束

* 表之间的关系（1对多，多对多）

* jdbc

* Statement对象： CURD

* PreparedStatement对象： CURD

* 事务（概念、特性ACID，数据事务的隔离级别） -- 演示可以不练习

* 案例：银行转账demo【】，demo2(ThreadLocal)

* 自定义连接池(了解原理)

* 使用C3P0链接池

Day13

回顾

* PreparedStatement对象

* 防止SQL注入：用户填写的内容作为sql语句一部分。

* 预先编译，将实际内容替换?，再编译，再将实际的内容替换回?。实际参数不再是sql语句语法一部分。只是参数

* 处理时间：setXxx

* setDate(java.sql.Date)

* setTime(java.sql.Time)

*setTimeStamp(java.sql.TimeStamp)

* 都是java.util.Date的子类。newjava.sql.Date(new java.util.Date().getTime)

* 处理大数据

* 字节：BLOB（mysql --> blob , longblob等）

* 字符：CLOB（mysql --> text , longtext等）

* 批处理

* Statement，可以处理多条sql语句，编译多次

* PreparedStatement，只能处理一条sql，编译1次，但可以执行多次

* 事务transaction

* 事务：一组操作，要么成功，要么不成功

* 事务的特性：ACID，原子性、一致性、隔离性、持久性

* 事务并发将问题：脏读、不可重复读、幻读

* 数据库的隔离级别：

* 读未提交 read uncommitted

* 读已提交 read committed

* 可重复读 repeatable read

* 串行化：serializable

* mysql操作

* 开启事务：start transaction; | set @@autocommit = 0 (mysql事务自动提交)

* 事务提交：commit

* 事务回滚：rollback

* jdbc操作

* conn.setAutoCommit(false);

* conn.commit()

* conn.rollback()

* 连接池

* 接口：javax.sql.DataSource(数据源)

* 方法：getConnection()获得链接

* 第三方连接池

* DBCP，apache 连接池开源工具（*.propertis文件）

* C3P0，开源连接池工具（ComboPooledDataSource）

* 设置基本4项

* 使用配置文件：c3p0-config.xml文件 %c3p0.zip%/c3p0-0.9.2-pre5/doc/index.html#c3p0-config.xml

#####################################################################################

Day14

回顾

* DBUtils：JDBC简化工具包

* 核心工具类：QueryRunner

* 默认构造：new QueryRunner() ，获得此对象，但需要手动指定链接

* 参数构造:new QueryRunner(DataSource) ,获得此对象传递数据源，内部维护链接Connection

* DML操作

* update(Connectionconn,String sql , Object ... params) 手动的设置链接，必须手动释放资源

* update(Stringsql,Object... params) 使用参数构造进行dml操作

* DQL操作

* query(Connection conn,String sql,ResultSetHandler handler , Object ... params)手动的设置链接，必须手动释放资源

* query(Stringsql,ResultSetHandler handler , Object ... params) 通过给定参数params，执行sql语句，并将结果封装成指定的handler的类型

* ResultSetHandler结果集处理类的实现类

* BeanListHandler，将数据封装到JavaBean中，再将JavaBean添加到list集合中，将list集合返回

* BeanHandler，将数据封装到JavaBean中，将JavaBean返回

* ScalarHandler，将结果存放到一行一列

* API查询：%commons-dbutils-1.4%\apidocs\index.html

1.带有条件的查询

* 修改查询所有的servlet。带有条件查询，如果没有传递任何条件，进行查询所有操作。

* 修改的目标：

* servlet接受查询条件

* dao过滤提交数据，如果数据为空（null ""），sql将不在添加条件，where 。。。

* 总结：

* 多条件sql处理方便，在sql语句添加 where 1=1 ,之后的条件语句直接填and 。。。

* 多条件为了支持多参数，用时List对参数进行缓存，list是有序的。保证 ? 与参数的对应

2.mysql分页

* 格式：select.... limit 参数1,参数2

* 参数1：查询的索引号，从0开始

* 参数2：查询分页的显示个数

* Page JavaBean

？

3.国际化

* i18n:Internationalization

* properties文件，国际化资源配置文件

* 扩展名：文件名.properties

* 文件名：基名

* 格式：baseName_语言_国家|地区.properties

* baseName自定义

* 例如：

* 中文简体，message_zh_CN.properties

* 中文繁体，message_zh_TW.properties

* 英文，message_en.properties

*位置：src目录 --> WEB-INF/classes/...

* 注意：只支持英文

* Locale类

* Locale 对象表示了特定的地理、政治和文化地区

* 构造方法：Locale(String language, String country)

4.监听器Listener

* 监听原理

* 1 被监听对象（事件源）【】

* 2 事件，（关闭按钮，触发监听）

* 3 监听对象（监听器）【】

* 4 绑定事件【】

* 5 事件对象，让监听对象可以获得被监听对象

总结：

* day13 : day13_customer_update.rar (查询所有，修改)

* day14 : day14_condition.rar (带条件的查询)

* day14 : day14_page.rar (分页分析)

* day14 : day14_page_end.rar(分页使用Page对象，用于封装数据)

* CURD，面向对象（封装）

* day14 : day14_page_final.rar(使用javascript进行表单优化，不建议学)

* 如果，只练习

* Statement对象： CURD

* PreparedStatement对象： CURD

Day15

回顾（JDBC案例应用）

* 条件查询（模糊查询）

* 格式：select... where 条件

* 条件

* 相等字段 = 值

* 匹配字段 like '%值%' 或字段 like '_值_'

* 恒定的条件：where1=1

* 追加条件

* 条件： and 字段 = 值 ?

* 参数：使用List进行缓存（list有序）

* 分页查询

* 不同的数据库分页语句不同

* mysql格式：select .... limit 开始索引startIndex,每页显示的个数pageSize

* 页面可以提供的值：pageSize，pageNum当前页数

* 分页的JavaBean对象

* int pageNum 当前页数(浏览器传递)

* int pageSize 每页显示的个数(浏览器传递，固定值)

* int totalRecord 数据库中总记录数(查询数据库count(1)获得)

* int startIndex 开始索引(计算获得)

* 算法：startIndex = (pageNum - 1) * pageSize

* int totalPage 总页数(计算获得)

* 算法1：totalPage = (totalRecord + pageSize - 1) /pageSize

* 算法2：

if(totalRecord % pageSize == 0 ){

totalPage= totalRecord / pageSize

} else {

totalPage= totalRecord / pageSize + 1 //表示半页

}

* List data 查询数据

* 扩展（动态的显示列表数）

* int start 列表的开始数

* int end 列表的结束数

* 算法

* 1 初始化值 (默认显示10列表)

start= 1;

end = 10;

* 2 处理数据--依据是否有10列表页

if(totalPage <= 10){

end= totalPage;

}else {

//大于10分页数

//* 当前页前显示4页，后显示5页

start= pageNum - 4;

end= pageNum + 5;

//** 处理数据（首页与尾页临界值需要特殊处理）

if(start < 1){

start= 1;

end= 10;

}

if(end> totalPage){

end= totalPage;

start= totalPage - 9;

}

* i18n国际化

* 资源文件：baseName_语言_国家|地区.properties文件

* 默认配置文件：baseName.properties ，其他都不符合，将使用默认

* 解析方式(获得内容)

*ResourceBundler.getBundler(baseName,new Locale("语言","国家")) ，一般语言小写，国家大写

* 其他工具类

* DateFormate时间类

* NumberFormate 数字类（货币、数字、百分比等）

* MessageFormate 消息类 ( "你好{0}")

* listener监听器

* servlet，获得动态资源技术（完成功能，获取资源），能做什么

* listener，监听被监听对象，在做什么

* javaee 共8个

* 3个域对象本身和属性的监听器 6

* 特殊的javabean在session属性的监听器

*javax.servlet.http.HttpSessionBindingListener , 当javabean实现了接口，此javabean被添加到session的属性时。

* voidvalueBound(HttpSessionBindingEvent event) ，添加到属性时触发

* voidvalueUnbound(HttpSessionBindingEvent event) ，从属性中移除时触发

*javax.servlet.http.HttpSessionActivationListener,当javabean实现了接口,

* 此javabean被添加到session的属性，如果服务器正常关闭，将javabean保存文件中，服务器启动再添加到session属性中。

* voidsessionDidActivate(HttpSessionEvent se) 活化，从文件中在读到内存

* voidsessionWillPassivate(HttpSessionEvent se) 钝化，将对象保存文件

* 注意：此javabean，必须实现java.io.Serializable,序列号（内存硬盘转换）

* 不需要再web.xml文件中进行注册

###################################################################################################################

1.Filter 过滤器(day15)

* 访问服务器中的资源，是否允许访问

* 接口：javax.servlet.Filter

* Filter编写流程

* 1实现类 Filter接口

* 2配置 web.xml

* * Filter编写实现

* 1实现类 Filter接口

* public classEncodingFilter implements Filter {

* 2配置 web.xml

* 过滤器的注册，<filter>标签

* 注册的名称：<filter-name>

* 过滤器的实现类：<filter-class>

<filter-name>EncodingFilter</filter-name>

<filter-class>cn.itcast.web.filter.EncodingFilter</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>UTF-8</param-value>

</init-param>

</filter>

* 过滤器映射(使用)，<filter-mapping>

* 使用的过滤器的名称，必须为已经注册的内容，<filter-name>

* 过滤器准备拦截的路径：<url-pattern>

/* 表示拦截所有的路径

<filter-mapping>

<filter-name>EncodingFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

* 初始化内容的读取

* 服务器启动时，将执行初始化方法

public voidinit(FilterConfig filterConfig) throws ServletException {

// 获得web.xml文件中配置的过滤器的初始化参数

this.encoding= filterConfig.getInitParameter("encoding");

System.out.println("init--> " + encoding);

}

* 过滤器的放行语句：chain.doFilter(request,response);

* 建议：编写过滤器时首先先放行

2.Filter过滤路径(day15)

* 完全匹配： /a/demo

* 不完全匹配： /a/*

* 通配符匹配： *.jsp

* Filter 过滤器拦截的servlet的路径

3.filter-mapping中的dispatcher标签(day15)

* 用于配置filter过滤器进行拦截资源的位置

* 取值

* REQUEST，request：当前过滤器对请求进行拦截，默认值为request

* FORWARD，forward：当前过滤器将对转发的内容进行拦截

* INCLUDE，include：当前过滤器将对包含的内容进行拦截

* ERROR，error：当前过滤器将对页面执行"友好页面"将进行拦截 (修改状态码)

* ASYNC，async: 当前过滤器将对servlet发送异步内容时进行拦截 (servlet3.0异步)

* 比较：同步synchronized

4.案例(day15)

* 1 分ip统计网站的访问次数

* 2.1不缓存动态页面!

* 需要添加三个头，支持不同的浏览器。（不同的浏览器对三个响应头的支持程度不同）

response.setHeader("pragma","no-cache");

response.setHeader("cache-control","no-cache");

response.setHeader("expires","0");

* 2.2设置静态web资源的有效日期!

* 3.权限管理

* 细粒度权限管理（daoinsert，update等，与链接关联）[项目涉及]

* 粗粒度权限管理

* 是否登录

* 比较大概权限

* 4.统一POST和GET中文编码问题（后天，4天案例）

* 5.页面静态化

Day16

1.JavaMail(day16)

* 使用java程序发送电子邮件

* 应用场景

* 生日祝福邮件

* 资料订阅

* 用户注册的激活

* 邮件服务器涉及的协议

* SMTP（Simple Mail Transfer Protocol）即简单邮件传输协议, 发送邮件的协议。默认端口：25

* POP3(Post Office Protocol 3)即邮局协议，接受邮件的协议。默认端口:110

* 了解

IMAP (Internet Mail AccessProtocol ) 交互邮件访问协议（interactive mail access protocol）发送邮件的协议

* IMAP协议运行在TCP/IP协议之上，使用的端口是143。

* 它与POP3协议的主要区别是用户可以不用把所有的邮件全部下载，可以通过客户端直接对服务器上的邮件进行操作

* javamail需要jar文件

* 核心文件：mail.jar 来自javamail1_4_5.zip

* 依赖文件：activation.jar来自jaf-1_1_1.zip，用于封装数据（用不到）

* 发送邮件步骤

* 1 获得会话Session

* 2 编写消息Message

* 3 发送消息Transport

* 发送邮件详细步骤

// 0.1 获得会话的基本参数（服务器地址）

Properties props = newProperties();

// ### 确定服务器地址

props.setProperty("mail.host","127.0.0.1"); //smtp.163.com

// ### 确定服务是否需要账号与密码验证

props.setProperty("mail.smtp.auth","true");

// 0.2 设置权限(账号密码)

Authenticator authenticator = newAuthenticator(){

@Override

publicPasswordAuthentication getPasswordAuthentication() {

return newPasswordAuthentication("admin","123456");

}

};

//* 1 获得会话Session

Session session =Session.getDefaultInstance(props, authenticator);

// ### 将发送邮件的信息打印到控制台

session.setDebug(true);

//* 2 编写消息Message

Message message = newMimeMessage(session); //mime类型， text/html

// * 2.1 发件人

message.setFrom(new InternetAddress("admin@lt.cn"));

// * 2.2 收件人（TO 接收人 CC 抄送人 BCC 暗送）

message.setRecipient(RecipientType.TO,new InternetAddress("itcast@lt.cn"));

// * 2.3 主题

message.setSubject("第一个封邮件");

// * 2.4 正文

message.setContent("这是内容", "text/html;charset=UTF-8"); //mime类型

//* 3 发送消息Transport

Transport.send(message);

2.JavaMail案例：(day16)注册登录与激活

* 注册

* 激活

* 登录

3.Base64编码(day16)

编码

BASE64Encoder base64Encoder = newBASE64Encoder();

String username =base64Encoder.encode("username".getBytes())

解码

BASE64Decoder base64Decoder = newBASE64Decoder();

byte[] nameByte =base64Decoder.decodeBuffer("aXRjYXN0X2x0");

4.文件上传/下载(day16)

* 文件实现

* 1，提供表单

* <formmethod="post"

* <formenctype="multipart/form-data"

* enctype 属性规定在发送到服务器之前应该如何对表单数据进行编码

* 属性值

*application/x-www-form-urlencoded 在发送前编码所有字符（默认）

* 【multipart/form-data】不对字符编码。在使用包含文件上传控件的表单时，必须使用该值。

* text/plain 空格转换为 "+" 加号，但不对特殊字符编码。

* <form> <inputtype="file" name="" 上传控件

* 2.服务器端获得上传的数据

* ServletRequest.getInputStream()，获得上传文件的所有内容(获得请求体的所有内容)

* 注意：之后自己不解析上传文件的内容，通过第三方工具

* commons-fileupload

* 上传文件的工具类，apache

* 需要的jar文件

* 核心jar文件：commons-fileupload-1.2.2.jar

* 依赖jar文件：commons-io-2.3.jar

* 上传代码

//1 判断是否支持上传

if(! ServletFileUpload.isMultipartContent(request)){

return ;

}

// 2 获得工厂

DiskFileItemFactory factory = newDiskFileItemFactory();

// * 用于确定临时文件的目录，上传文件大于指定值，工具将产生临时文件，默认情况%tomcat%/temp , *.tmp表示临时文件

factory.setRepository(newFile(this.getServletContext().getRealPath("/temp")));

// * 临时文件的大小临界值设置 (单位，in bytes，字节)

factory.setSizeThreshold(1024 *1024 * 2); //2MB

// 3 获得核心处理类

ServletFileUpload fileUpload = newServletFileUpload(factory);

// * 用于处理上传文件的文件名的中文乱码

fileUpload.setHeaderEncoding("UTF-8");

// 4 解析request

List<FileItem> allFileItems= fileUpload.parseRequest(request);

// 5 遍历

for(FileItem fileItem :allFileItems){

//6 区分

if(fileItem.isFormField()){

// 7 普通

String fieldName =fileItem.getFieldName();

String fieldValue =fileItem.getString("UTF-8"); //解决普通字段中文乱码文件

System.out.println(fieldName+ fieldValue);

} else {

// 8 上传

// 8.1 文件名称

String fileName=fileItem.getName();

// ## 兼容不同的浏览器

// **** ie -->c:/xxx/xx/1.txt

// **** 其他--> 1.txt

fileName =fileName.substring(fileName.lastIndexOf(File.separator) + 1);

// ## 文件名重复

fileName =UUID.randomUUID().toString().replace("-", "") +"_" + fileName;

// 8.2 获得上传文件的内容

InputStream is =fileItem.getInputStream();

// 8.3保存文件

File file = newFile(this.getServletContext().getRealPath("/upload"),fileName);

FileOutputStreamfileOut = new FileOutputStream(file);

byte[] buf = newbyte[1024];

int len = - 1;

while( (len =is.read(buf)) !=-1 ){

fileOut.write(buf,0, len);

}

fileOut.close();

is.close(); //流没有关闭，临时文件不能删除

// 9 删除临时文件

fileItem.delete();

}

* 下载代码

String imageName = "美女图.jpg";

// 1 下载资源

File imageFile = newFile(this.getServletContext().getRealPath("/download"),imageName);

InputStream imageIs = newFileInputStream(imageFile);

// ### 处理中文下载的乱码

imageName = newString(imageName.getBytes("GBK"),"ISO-8859-1");

// ### 通知浏览器发送的数据为下载的数据

response.setHeader("content-disposition","attachment;filename=" + imageName);

// 2 把资源发送浏览器 --流--字节流

OutputStream out =response.getOutputStream();

byte[] buf = new byte[1024];

int len = - 1;

while( (len = imageIs.read(buf))!= -1 ){

out.write(buf, 0, len);

}

out.close();

imageIs.close();

Day17

回顾

* 1.生成动态web资源：servlet/jsp

* MVC模式：数据处理与数据显示相分离（Model模型、View视图、Controller控制器）

* servlet：数据处理

* jsp：数据显示

* 2.浏览器与服务器数据交换

* 浏览器-->服务器

* 表单：<form action="处理程序的路径" method="post/get"enctype="multipart/form-data"

* <inputtype="text|password|radio|checkbox|submit" name="服务器才可以接受数据"

* <selectname=""><option value

* <textarea

* 服务器接收数据

* Stringrequest.getParameter(name)

* String[]request.getParameterValues(name)

*Map<String,String[]> request.getParameterMap() (key:name value:getParameterValues)

* 接收post请求中文乱码问题

*request.setCharacterEncoding("UTF-8");

* 服务器-->浏览器

* 字节流：ServletOutputStream response.getOutPutStream()

* 字符流：PrintWriter getWriter()

* 响应的中文乱码

*response.setContentType("text/html;charset=UTF-8")

* 3.服务器端缓存数据问题（作用域，数据在服务器的作用范围）

* xxxAttribute：setAttribute(String,Object) 、 Object getAttribute(name) 、removeAttribute(name)

* ServletContext，application：一个web项目只有一个对象，服务器启动tomcat将创建此对象，之后使用都引用。所有用户，不同浏览器，数据共享

* HttpSession，session：一次会话，一个用户，单独保存每一个用户的信息。包含多次请求。(使用：保存用户的登录信息，重定向成功页面)

* 重定向：response.sendRedirect(location); 注意：必须填写项目名称，request.getContextPath()

* ServletRequest：一次请求，请求开始tomcat将创建对象，请求结束tomcat销毁对象。默认只能访问一个页面。如果需要访问多个页面需要使用转发

* 转发：request.getRequestDispatcher(path).forward(request,response);

* 4.cookie与session工作原理

* cookie：服务器端创建一个cookie对象，通知给浏览器，使浏览器去处理相应的cookie，当再次访问时，浏览器将携带cookie发送给服务器(自动)

* cookie.setMaxAge(...) , 浏览器将保存数据到硬盘

* cookie.setPath(/) , 浏览器保存是将以指定的路径。请求的路径必须与设置的路径可以进行匹配

* 发送：response.addCookie(cookie)

* session：第一次请求时创建session，并将session的编号id以cookie的形式发送给浏览器。

cookie将自动携带。第二次请从cookie携带的信息中获得需要的session的编号id，并返回相应的session对象。保证一个会话中使用一个session

* request.getSession();

* 5.服务器获得服务器端的资源

*ServletContext.getRealPath(/path),返回tomcat中指定名称的绝对路径。d:/tomcat/...项目名称/demo/1.txt

* 参数：/demo/1.txt，相当于当前的web项目的根。myeclipse-->WebRoot/... 、 tomcat --> webapps/项目名/...

* 注意：WebRoot中的内容将被完全拷贝到"webapps/项目名"目录下

* InputStreamServletContext.getResourceAsStream(/path) 直接获得数据流

* 6.ServletContext对象的获取

* 1.init(ServletConfig)

*ServletConfig.getServletContext()

* 2.GenericServlet缓存了ServletConfig，在servlet中可以

*this.getServletConfig().getServletContext()

* this.getServletContext()

* 3.session提供了获取方法

* HttpSession.getServletContext()

* 4.filter过滤器中的获取,init(FilterConfig)

*FilterConfig.getServletContext()

* 5.servlet 3.0中request提供了获取方法

*ServletRequest.getServletContext()

* JSTL，JSP标准标签库

* 引用：<%@taglib uri="" prefix=""%>

* 格式：<前缀:标签名称

* 种类：<c:out <c:if <c:forEach <c:url

* el,表达式语言

* 获得指定域的内容

*${pageScope|requestScope|sessionScope|applicationScope.name}

* 指定对象方法

*${pageContext.request.contextPath}

* ${cookie.cookie名称.value} -->Map<Cookie名称,Cookie对象> Map<String,Cookie>

* SQL语句

* DDL（创建create、删除drop、修改alter）

* 数据库

* create database

* drop database

* 表

* create table

* drop table

* alter table

* 字段

* alter table (add |drop | change) column

* DML(录入insert、修改update、删除delete)

* insert into 表名(字段,..) values(值,..)

* update 表名 set 字段 = 值, ...where 条件

* delete from 表名 where 条件

* DQL（查询select）

* select distinct 字段|* from 表名

where 查询条件

order by 排序字段 asc|desc

group by 分组字段 having 分组条件

limit 分页的索引,分页的每一显示个数

for update [写锁] | lock in share mode [读锁]

* JDBC 基本4项

* 驱动driver ： com.mysql.jdbc.Driver

* 链接url ：jdbc:mysql://localhost:3306/数据库名称?useUnicode=true&characterEnconding=UTF-8

* 账号user ： mysql默认账号名称为root

* 密码password

* JDBC-Statement

* 获取conn.createStatement()

* 执行

*DML : int st.executeUpdate(sql)

* DQL : ResultSetst.executeQuery(sql)

* 结果集的处理

* 多数据

while(rs.next()){

rs.getXxx(索引 | 字段)

}

* 单数据（最多一条数据）

if(rs.next()){

rs.getXxx(索引 | 字段)

}

* JDBC-PreparedStatement

* 获取： conn.preparedStatement(sql),并且建议sql中的实际参数，被替换为?

* 执行：

* DML : intst.executeUpdate()

* DQL : ResultSetst.executeQuery()

* JDBC事务

* 开启事务：conn.setAutoCommit(false)

* 提交事务：conn.commit()

* 回滚事务：conn.rollback()

* servlet与filter的编写

* servlet

* 实现类：

public classHelloServlet extends HttpServlet{

doPost(request,resonse)

doGet(request,response)

}

* 配置文件web.xml

<servlet-name

<servlet-class

<serlvet-mapping>

<servlet-name

<url-pattern>用于确定访问的路径

* filter

* 实现类

public classHelloFilter implements Filter{

doFilter(ServletRequest,ServletResponse,FilterChain){

//放行

chain.doFilter(request,response);

}

* 配置文件web.xml

<filter-name

<filter-class

<filter-mapping

<filter-name

<url-pattern>用于拦截的路径(符合条件的路径才被拦截)

总页数=（总记录数+每页的记录数-1）/每页的记录数；

Day21

1.泛型类型

* 问题：一个对象，存在多个使用类型（参数，返回值等），必须一致

* 泛型：就是为了解决以上问题而产生的。泛型当成“类型变量”

* 使用反射获得泛型的类型

* 1、继承一个类，并传递泛型的类型

public class UserDaoextends BaseDao<User> {

* 2、父类获得泛型的类型

* 2.1 获得具有泛型信息的父类

ParameterizedTypetype = (ParameterizedType)this.getClass().getGenericSuperclass();

* 2.2 获得实际的类型参数 , Map<Key,Value> 多个，实际参数为数组

beanClass = (Class)type.getActualTypeArguments()[0];

2.Annotation 注解

* 注解：也是一个特殊类（enum枚举）

* 为什么要学习注解？注解用于取代配置文件的。(随着业务的扩展，之后的配置文件将越来越多，项目将难以维护)

* 注解开发流程

* 1、定义注解

* 2、使用注解【重点】

* 3、解析注解

* jdk5.0提供注解

* @Deprecated 表示被修饰的方法已经过时。不建议使用，但可以使用。（缺陷：1安全问题 2新的API取代）用在方法的上面

query(sql,Object[]params,handler) --> query(sql,handler Obj

* @Override 表示被修饰的方法覆盖父类的方法（jdk1.5）,jdk1.6可以表示当前方法实现接口的方法，如果父类没有方法那么就会报错！用在方法的上面

* @SuppressWarnings 表示被修饰的对象，指定的内容编译忽略警告

deprecation ，或略过时弔 SuppressWarnings(“deprecation”)

rawtypes ，忽略类型安全

unused ，忽略不使用

unchecked ，忽略安全检查

null，忽略空指针

all，忽略所有

* 1 定义注解

* 回顾：类class ，接口 interface 枚举 enum

* modifier 修改符 Illegal 非法的

* 定义注解格式：@interface注解名称

* 内容格式：public类型字段() [default 默认值]; 如： public String name(); 内容是键值对的！

* 字段-->赋值：字段[属性 name]、调用：方法anno.name()

* 可以使用的类型：字符串String、字节码对象Class、枚举enum、注解本身Annotation、8个基本类型(int ... 8) ,以上类型对应的一维数组、但是不能使用Integer等。

* 回顾 jdbcMetaData 元数据，数据库的数据。ResultSetMetaData，结果集的元数据，列数，列名，列类型

* 对比：数据源 DataSource，连接池

* 元注解，修饰注解(自定义)的注解(元注解)

* @Retention，用于确定被修饰的注解的，生命周期

@Retention(RetentionPolicy.SOURCE)，被修饰的注解，存放在源码级别，Java文件中。编译器使用

@Retention(RetentionPolicy.CLASS) ，被修饰的注解，存放在字节码级别，class文件中。JVM(虚拟机)使用

@Retention(RetentionPolicy.RUNTIME)，被修饰的注解，存放在内存中。开发人员【】

* @Target，用于确定被修饰的注解的，可以当前注解修饰的位置

*@Target({ElementType.TYPE,ElementType.CONSTRUCTOR,ElementType.FIELD,ElementType.METHOD})

ElementType.TYPE, 当前注解可以修饰“类|接口”等

ElementType.CONSTRUCTOR,当前注解可以修饰“构造函数”等

ElementType.FIELD,当前注解可以修饰“字段”等

ElementType.METHOD，当前注解可以修饰“方法”等

* 2 使用注解

* 使用格式：@注解名称(属性=值)

* 如果属性为数组：

* 值只有一个，格式：属性 = 值

* 值有多个，格式：属性 = {值1,值2...} 如values={“1”，“2”，………}

* 如果属性名称为value

* 值只有一个，格式：值。value属性名可以省略

* 值有多个，格式：{值1,值2...} 。value属性名可以省略

* 但，如果存在多个属性，value不能省略

*@Annotation2_1(value={1,2},name="")

*在定义中使用默认值的话，那么在使用注解的时候就不必填写了

默认值关键字是default

@Annotation_1(date = 34, bool=true,values={"45","6546"}, anno =@Annotation_09(bool = false),value="李四")

public class AnnotationDemo {

public static void main(String[] args) {

}

@ interface Annotation_1{

public String name()default"张三";//默认值

public int date();

public Annotation_09 anno();

public boolean bool();

public String[] values();

public String value();

}

@ interface Annotation_09{

public boolean bool();

}

* 3 解析注解--反射

* 用于确定当前类是否存在注解：Class.isAnnotationPresent(Class<?extends Annotation> annotationClass)

* 获得当前类指定的注解：Class.getAnnotation(Class<A>annotationClass)

* 注解的接口：java.lang.reflect.AnnotatedElement

* 提供API

* getAnnotation(Class<T>annotationClass)

*isAnnotationPresent(Class<? extends Annotation> annotationClass)

* 所有的实现类

* Class, Constructor, Field, Method

* 综合例如：

* 注解定义：

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@interface Annotation3_3{

public Stringusername();

public Stringpassword();

}

* 注解的使用

@Annotation3_3(password ="1234", username = "jack")

public class TestAnno3 {}

* 注解的解析

if(TestAnno3.class.isAnnotationPresent(Annotation3_3.class)){

Annotation3_3 anno33= TestAnno3.class.getAnnotation(Annotation3_3.class);

System.out.println(anno33.username());

System.out.println(anno33.password());

}

* 注意：

* 注解为了取代配置文件，不能完全取代。（web.xml 欢迎页面 <welcome-file-list> 友好页面 <error-page>等）

3.annotation案例

* JDBC获得链接Connection，基本4项：driver、url、user、password

4.Servlet3.0

* servlet版本

* java ee 5.0 --> servlet2.5 / jsp2.1

* java ee 6.0 --> servlet3.0 / jsp2.2

* 回顾servlet2.5经典配置 web.xml

<servlet-name>

<servlet-class>

<servlet-mapping>

<servlet-name>

<url-pattern>

* 地址：路径与实现类关联

* servlet3.0注解

* @WebServlet 配置servlet

* @WebFilter 配置过滤器

* @WebListener 配置监听器

* 注意。web.xml文件

<web-appversion="3.0" metadata-complete="true"> 如果 metadata-complete为true将不自动进行注解的解释，注解失效。默认值为false

* servlet3.0文件上传

* 如果需要使servlet支持上传，必须添加@MultipartConfig

* 将上传文件封装到Part

* 普通的字段：request.getParameter(name)

* 注意：request.getParameter(name)在2.5时不能获得普通字段的内容

* 文件上传

* 页面：<form method="post"enctype="multipart/form-data" > <input type="file" name=""

* servlet：servlet3.0获得上传.(之前使用commons fileupload解析上传文件)

* 处理所有的中文乱码：request.setCharacterEncoding("UTF-8");

* 异步操作

* 首先

* 过滤器支持异步：@WebFilter(value="/*",asyncSupported=true)

* servlet支持异步：@WebServlet(value="/servlet3/async",asyncSupported=true)

* 开启异步的上下文

* AsyncContext async = request.startAsync();

* API

* 获得request：asyncContext.getRequest()

* 获得response：asyncContext.getResponse()

5、代理

* 静态代理，装饰设计模式可以实现 Connection

* 动态代理，程序运行时创建一个代理类

* 工具类java.lang.reflect.Proxy,提供用于创建动态代理类和实例的静态方法

* 用于创建代理对象的实例对象：ObjectnewProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h) 也就是通过newProxyInstance（）方法获得能创建代理对象的实力对象！

* new Object(), 创建的对象为代理对象。

* 参数：

* 1 .ClassLoaderloader，也就是类加载，加载代理类到内存，一般当前类.class.getClassLoader()

* 2.Class<?>[] interfaces,确定代理类，需要生成方法。一般情况应该与被代理对象的方法相同。

* 3.InvocationHandler h ,是代理实例的调用处理程序实现的接口。代理类的每一个方法都将触发处理类的invoke方法

* 需要实现： Object invoke(Object proxy, Method method, Object[]args)

*3.1Object proxy，用于确定代理对象

*3.2Method method，执行的方法

*3.3Object[] args，执行方法的实际参数

6.类加载器ClassLoader

* 类：java.lang.ClassLoader

* 类加载器的分类

* bootstrap 引导类加载器

* 加载rt.jar

*String.class.getClassLoader() 将返回null值，表示加载器为引导类加载器

* ExtClassLoader，扩展类加载器

* 加载：jre/lib/ext

* AppClassLoader，应用类加载

* 加载： WEB-INF\classes WEB-INF\lib

* 获得类加载的方法

类.class.getClassLoader()

* 类加载使用的机制：全盘负责委托机制

* 全盘负责，当前类如果使用了一个没有被加载到内存的类，当前类的类加载将去负责加载

* 委托机制，当前类使用了一个类，会咨询父类是否加载，如果加载将使用

* 演示：运行时将jar添加到引导类加载路径后面

*-Xbootclasspath/a:E:\java\jar\c3p0\c3p0-0.9.2-pre5.jar

* cmd >java -X

* jdk总结：父加载器加载了，子加载器就不加载

* 注意：tomcat 加载jar时，使用的不同机制

* Common 指的是 %tomcat%/lib

* webappx 指的web项目 %tomcat%/webapps/xxx/WEB-INF/lib

* 优先加载webappsx，再使用common

Struts2

1.struts2入门

* 框架：具有一些通用功能的半成品项目。

* struts2 是apache的框架，基于MVC框架的。底层使用的webwork框架

* struts2优点：

* action一次请求，将创建一个action实例。(servlet,单实例，多线程。线程问题：不要编写成员变量)

* 不依赖与servletAPI，可以操作servlet中以前的元素，但又不使用之前的api（解耦）

* 完成了很多功能(封装数据、类型转换、拦截器等)

2 struts2目录介绍

* apps，实例

* %struts%/apps/struts2-blank.war 空白的项目，存放了struts2需要的最少的jar包

* docs ，文档

* lib，所有的jar文件

* src，源码文件

3. struts2开发流程

* 1、创建web项目，导入jar文件 (一共有11个jar文件)

* 2、编写action类(普通类)

* 3、编写jsp页面

* 4、编写struts.xml配置文件要粘贴约束代码！<struts <package name= namespace= extends= <action name= class= <result name= 约束代码在核心包中的struts-2.3.dtd第30行开始

* 5、在web.xml文件中配置过滤器 Ctrl+shift+T查找过滤器的类的路径也是在核心包中的org.apache.struts2.dispatcher.ng.filter 复制路径

4. struts2开发实现--helloworld【★★★★★】

* 1、创建web项目，导入jar文件

* 项目名称：struts2_day01

* jar添加的位置：%day01%/WebRoot/WEB-INF/lib

* 拷贝jar文件：%struts2%\apps\struts2-blank\WEB-INF\lib

* struts2-core-2.3.14.jar,核心jar文件

* xwork-core-2.3.14.jar，webwork的jar文件，struts2基于此jar文件

* ognl-3.0.6.jar:对象图导航语言，相当于jsp中el，比el更强大

* freemarker-2.3.19.jar:Struts 2的UI标签的模板

* 集成文件上传，使用commons-fileupload

* 2、编写action类(普通类)，需要提供execute方法

* 3、编写jsp页面

* 4、编写struts.xml配置文件

* 位置：必须放置在src目录下(开发阶段) 。最终位置 WEB-INF/classes/struts.xml

* 添加约束：struts2-core-2.3.14.jar/struts-2.3.dtd （30行，注释内容中存在）

* 如下

<?xmlversion="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC

"-//ApacheSoftware Foundation//DTD Struts Configuration 2.3//EN"

"http://struts.apache.org/dtds/struts-2.3.dtd">

<packagename="one" namespace="/primer"extends="struts-default" >

<actionname="userAction" class="cn.itcast.action.UserAction">

<resultname="success">/success.jsp</result>

</action>

</package>

</struts>

* 5、在web.xml文件中配置过滤器，配置struts提供的过滤器

* 过滤器的名称：StrutsPrepareAndExecuteFilter

5. struts配置文件们

* 1 default.properties ，struts2常量的默认配置文件【★】

* 位置：struts2-core-2.3.14.jar/org/apache/struts2/default

* 2 struts-default.xml ，为struts2核心配置文件，struts2已经提供好的配置文件【★】

* 位置：struts2-core-2.3.14.jar/struts-default.xml

* 内容：<package name="struts-default"abstract="true">

* 3 struts-plugin.xml ，struts2提供插件机制

* 4 struts.xml ，用户配置的struts的核心文件【★】

* 配置常量可以使用：<struts><constantname="" value=""></constant>

* 5 struts.properties , 与struts.xml等价，但只能配置键值对(常量)，不建议使用

* 6 web.xml文件，配置过滤器时，可以设置初始化参数<init-param></init-param>

* 注意：后面出现的文件中的配置信息，将替换之前文件的内容(内存)

6.struts.xml详解【★★ 多读】

package标签：struts2使用包package机制对action进行管理

* name属性：给当前包启一个名称，给其他包进行继承用。必须唯一

* namespace属性：给当前包进行名称的划分，命名空间。必须/开头。访问的路径的开始

* extends属性：用于继承，可以复用父包中提供的内容。struts提供的默认package的名称为，struts-default

action标签：每一个action类配置信息

* name属性：当前action的名称

* class属性：action的实现类的完整路径名

* method属性：action需要执行的方法的名称。默认值：execute

* 总结：访问路径 = package.namespace + / + action.name

result标签：用于配置action执行结果集信息

* name属性：action返回值

* type属性：用于指定如果处理结果。默认值：转发dispatcher

* 标签体：执行的jsp的路径

* /开头，表示当前web项目的根

* 没有/开头，相对当前页面(/primer/userAction) jsp路径(/primer/success.jsp)

<resultname="r_login" type="dispatcher">success.jsp</result>

7.struts.xml配置默认值

* package.name 必填，唯一

* package.namespace ,默认值/

* package.extends , 必填，最终必须继承struts提供的包，struts-default (struts2-core-2.3.14.jar/struts-default.xml)

* action.name，必填

* action.class , 默认值 com.opensymphony.xwork2.ActionSupport

* 在struts-default.xml设置了默认处理类，<default-class-refclass="com.opensymphony.xwork2.ActionSupport" />

* public String execute() throws Exception {

return"success";

}

* action.method,默认值为execute

* result.name , 默认值为success

* result.type , 默认值为dispatcher (struts-default.xml,提供<result-types><result-typename="dispatcher")

* 默认action

8.struts的常量【★ 看看】

* 配置方式

* 1.struts.xml文件中配置<constant name="常量名称"value="常量值" 【优选】

* 2.struts.properties 提供键值对，常量名称 = 常量值

* 3.web.xml中配置初始化内容

<init-param>

<param-name>常量名称</param-name>

<param-value>常量值</param-value>

</init-param>

* 默认常量配置文件：struts2-core-2.3.14.jar/org/apache/struts2/default.properties

* 常用常量介绍

* 1.全局编码配置：struts.i18n.encoding=UTF-8

* 设置request编码

* 设置模板输出编码，freemarker（*.ftl），velocity（*.vm）

* 2.配置struts2的资源文件的扩展名：struts.action.extension=action,,

* action名称： userAction 或userAction.action

* 3.设置是否为开发模式：struts.devMode= true

* 如果设置true，默认修改了struts的两个其他常量

### -struts.i18n.reload = true 加载国际化资源文件或配置文件

### -struts.configuration.xml.reload = true 自动加载xml配置文件

* 4.设置struts主题：struts.ui.theme=xhtml (struts标签，目的回显)

* xhtml 指 struts2-core-2.3.14.jar/template.xhtml文件夹中的配置信息

* simple 指struts2-core-2.3.14.jar/template.simple文件夹中的配置信息

* 5.与spring整合使用：struts.objectFactory = spring

9 错误总结

* web.xml配置文件，注册过滤器，必须为/*、

* struts.xml文件的名称。错误有，Struts.xml,strust.xml

* 如果tomcat启动时报错，整个web项目所有的资源都是404

* struts.xml文件存在了多个根元素

* 属性名称错误，namepace(正确的为，namespace)

* 使用默认实现错误，struts_default(正确的为，struts-default)

10.Action的编写

* 1 普通类 POJO

* 2 实现接口 Action(xwork2)

* 提供了5个常用的返回值常量(java)

* success ,页面执行成功

* none ，没有内容进行返回。AJAX(异步处理)

* error ，页面出现错误时，使用的返回值

* input，用户输入非法

* login，没有权限，需要登录

* 3 ActionSupport类(数据验证，错误提示，国际化等)【★★】

* action方法

* 必须为公共public，String返回值，非静态，没有参数，方法名称自定义

* 路径访问指定的方法：格式，action配置名称!方法名称

* 例如：/personAction!login

11.struts中操作servletapi

* 1 struts注入servlet对象，提供了可以用于注入的3个接口

* ServletContextAware接口获取ServletContext对象

* ServletRequestAware 接口获取ServletRequest对象，request.getSession()获得session

* ServletResponseAware接口获取ServletResponse对象

* 底层执行原理(了解)

Object servletAction = newServletAction();

if(servletAction instanceofServletContextAware){

ServletContextAwareservletCotnext = (ServletContextAware)servletAction;

servletCotnext.setServletContext(...)

}

* 2 struts提供ServletActionContext对象直接获得3个作用域对象

ServletActionContext.getRequest().setAttribute("bf","龙哥_request");

ServletActionContext.getRequest().getSession().setAttribute("bf","龙哥_session");

ServletActionContext.getServletContext().setAttribute("bf","龙哥_application");

* 3 struts提供ActionContext对象，struts2的action上下文对象【★★★】

* 获得对象：ActionContext.getContext();

* 放置数据，分别提供了3map对象，存放作用域中的属性名和属性值 Map<属性名称,属性值>

ActionContext.getContext().put("itcast","request_传智播客");

ActionContext.getContext().getSession();

ActionContext.getContext().getApplication();

12.结果集的类型

* dispatcher为转发，默认值

* redirectAction，重定向到指定的action

* redirect,重定向到指定的jsp页面

* 综合案例

* 入口：http://localhost:8080/struts2_day01/primer/adminAction_loginUI

* Action 实现 /struts2_day01/src/cn/itcast/action/AdminAction.java

public class AdminActionextends ActionSupport {

//登录UI

public StringloginUI(){

System.out.println("loginUIadmin");

return"loginUI";

}

//登录处理方法

public Stringlogin(){

//将用户信息放置到session

ActionContext.getContext().getSession().put("username","凤姐&龙哥");

return"login";

}

public Stringindex(){

System.out.println("模拟首页");

returnSUCCESS;

}

* struts.xml配置内容

<actionname="adminAction_*" class="cn.itcast.action.AdminAction"method="{1}" >

<result name="loginUI"type="dispatcher">/admin_login.jsp</result>

<resultname="login" type="redirectAction">

<paramname="namespace">/primer</param>

<paramname="actionName">adminAction_index</param>

</result>

<resultname="success"type="redirect">/admin_success.jsp</result>

</action>

* jsp页面

/struts2_day01/WebRoot/admin_login.jsp

/struts2_day01/WebRoot/admin_success.jsp

0 0