javaweb第一天
1、 junit测试框架
Arrsert. assertEquals(long execpted，long actual) 测试两个long类型的值 execpted 与actual 是否相等， 相等返回true，否则返回false；
2、 泛型类型的转换
1、 泛型的实际类型参数不具备继承关系、
2、 泛型的作用：
jdk5.0之前，将对象保存到集合中，对象会失去他自己特有的信息，在从集合中取出该集合时，程序员必须手动的强制类型转换，这样不免在给程序带来安全性的问题，但是泛型的出现使得程序员在编码时可以限制集合中的处理类型，从而把运行时的可能发生的问题，转变为编译时的问题，以此提高程序的可读性和安全性。
结论：通过限制集合中的处理类型，使得程序更具可读性和安全性
3、 自定义泛型方法 public <T> void doMethod( T t );
注意：在泛型方法中只有对象类型才能作为实际参数
3、枚举类
1、java中声明的枚举类，都是java.lang.Enum的实例
2、枚举类中的构造方法默认只能是private的，
为什么枚举类中的构造方法默认只能是private呢？ 答：因为使用枚举给变量赋值时，他必须是规定的范围的枚举值，既然是规定范围的，那么就不能让外界new 出一个对象。
3、枚举类中声明的每一个枚举值都是枚举类的一个实例对象
4、枚举中常用的方法： 1、name() 获得枚举对象的名字 2、ordinal() 获得枚举的下标 3、valueof (String name) 将一字符串转变成枚举 4、values() 返回枚举数组，用于遍历枚举数组
4、反射
1、反射就是将java的各个成分映射成java类。使用反射需要使用到以下一个API：
Class 、onstructor、Field、Method
2、使用发射的要领就是需要先得到类的字节码对象，得到了字节码对象就得到了类身
上的所有的一切，有了字节码，利用反射就可以操作类，给类的成员变量赋值，调用类的
方法等。
3、使用反射得到泛型的实际参数类型，比如：List<Date> 需要获得Date的实际类型
4、如何得到字节码： 1、类名.class 2、对象名.class 3、Class.forName(“包名.类名”);
5、Class.forName()方法的作用：他首先查看内存之中有没有某个类的字节码，若没有，
则创建一份字节码，若有，则加载字节码到内存之中，并封装成Class对象
5、内省---javabean
1、什么是javabean？ 答：javabean就是遵循一定编写规则的特殊java类，规则有： 1、必须提供一个公共的午餐的构造方法
2、必须具有的属性都是private的
3、必须提供get和set方法供外界操作和访问该javabean的属性，方法名一定是
set和get后要紧跟属性名，属性名的第一个字母要大些
2、使用BeanUtils工具包操作javabean
1、常用的方法：
1、BeanUtils.popluate(Object bean, Map properties)
2、BeanUtils.setPoperty(Object bean, String name, Object value)
3、BeanUtils.copybean(Object dest, Object src)
2、使用BeanUtils时，有些复杂类型，BeanUtils不能自动将值设置到javabean
中，必须手动注册一个转换器
ConvertUtils. register(Converter converter, Class clazz)
converter: 表示注册的自定义的类型转换器
clazz: 就是要将别类型转换成clazz字节码代表的类的类型
细节：
1、 Math.random() 生成0-1的小数,包含0, 不包含1
2、 在拆箱, 装箱方法调用时,原则:使用jdk5.0与jdk1.4的结果相同
3、 通过查看API知道，使用反射，若是调用getConstructor()方法不能生成一个对象，因为不
是public的， getConstructor()方法只能是针对public修饰的若是硬要生成一个对象，那
么应该是使用getDeclaredConstructor()方法。
javaweb 第二天
1、xml
1、什么是xml？
答：xml是可扩展标记语言
2、xml有那写特点？ 答：xml类似于html, 但是xml中没有预定义的标签，最初设计是用来传输数据的。 3、xml的应用在哪里？ 答：1、存储和传输复杂关系模型数据 2、作为配置文件 <?xml version="1.0" encoding=“utf-8” standalone=”yes” ?> encoding:表示文档编码 2、xml文档声明
standalone: 说明文档是否独立 （文档如果依赖别的文档就是不独立）
3、 XML元素指XML文件中出现的标签
4、对于XML标签中出现的所有空格和换行，XML解析程序都会当作标签内容进行处理
5、CDATA区
在编写xml时，有些内容不想让解析程序执行， 须当做原始内容处理，那么将该数据放大CDATA区中 <![CDATA[ 数据 ]]> 例如：<![CDATA[ <itcast>
</itcast>
]]>
6、DTD约束
1、xml文档为什么要引入约束？ 答: 因为xml是可扩展的标记语言，在xml中没有预定义标签，那么程序员就可以随意书写xml的标签，这样在开发中就没有统一使用标准，这样的就会造成xml文档中的标签混乱。所以引入约束，指定xml中可以使用那些标签，不可以使用那些标签。这样就统一了使用标准。
2、DTD与xml三种关联的方式 1、使用内部DTD 2、使用外部DTD 若关联的dtd文件在本地则使用： <!DOCTYPE 根元素 SYSTEM “dtd文件的URL” > 3、使用公共DTD 若关联的是一个公共的dtd文件则使用：
<!DOCTYPE 根元素 PUBLIC “dtd名称” “dtd文件的URL” > 3、元素（Element）的定义
4、元素（Element）内容的定义
5、属性（ATTLIST）定义
属性类型中常用有：CDATA， 表示属性值为字符型数据
属性的约束有四种：#REQUIRED 表示属性是必须的，#IMPLIED 表示可以忽略的， #FIXED 表示只能是规定的值， Defaultvalue 表示默认值
7、Schema约束
1、schema的使用例子
2、schema文件不用指定约束他的约束文档在哪
答：schema也是一个xml文档，为什么使用schema文档不用指定他的约束文档在哪里？
因为他所使用的约束文档是一个著名的约束文档，不用指定。
8、DOM与SAX解析xml文档的原理与优缺点? DOM解析xml的原理：将xml一次性装在到内存之中，以树状形式存贮，占用的内存比较大 优点：对xml的crud速度快 缺点：不合适解析大的xml文档 优点：适合解析比较大的文件 缺点: 不适合对xml文件的crud 3、在使用schmea约束文档时，schmea文件中的targetNamespace与要约束的xml文档中声明的命名空间要相同， 因为targetNamspace是自己定义的元素来自哪个命名空间 SAX解析xml原理：逐行解析xml 9、在工程中文件的位置， 路径问题????
答：myeclipse下默认是从工程名下加载
10、在DOM解析中，所有的元素、属性、文本都是节点，都是Node的子类
11、DTD的数据类型
PCDATA是元素的标签体的数据类型
javaweb第四天
1、 web通信详解
2、 配置虚拟目录
在server.xml中的<Host>标签中配置<Context>标签 CDATA是属性的数据的类型
例如：<Context path=”/” docBase=”c:\itcast”>
4、配置虚拟主机案例
输入 不要访问百度，而是访问本地的首页index.jsp
javaweb第五天
1、 servlet的生命周期 ？
2、线程与进程的区别 ？
3、缺省servlet
当servlet的映射路径为 “/ ”时，那么该servlet就成了当前web应用下的缺省servlet，
但访问tomcat中的静态页面或图片时，实际上访问的就是tomcat中的缺省的servlet
org.apache.catalina.servlets.DefaultServlet 为tomcat中缺省servlet
4、 在servlet初始化时，建议不要覆盖init(ServletConfig config), 只需覆盖无参的init()
5、 获得ServletContext对象两种方法：
servletConfig.getServletContext()
this.getServletContext()
6、 web工程中读取文件的两种方法
第二篇：JavaWeb大总结 51200字
day01
XML的主要内容
1、XML的作用
2、XML语法
3、DTD的约束
4、用Java语言编写XML数据解析器
JAXP DOM4J
5、Xpath
6、Schema约束
7、Eclipse的基本使用
8、JUnit单元测试
9、Debug调试
一、XML的作用
描述数据，传输数据
二、XML的语法
1、声明
作用：标识文档是一个xml文档，必须出现在第一行（不能再注释的后面，空格也不行） 属性： encoding：保存在磁盘上的文件编码要与声明的编码一致。默认编码是UTF-8
2、元素
必须有开始和结束标签
一个xml文档必须且只能有一个根标签
必须合理嵌套
xml不会忽略标签中的空格和回车换行
元素(标签)的名称可以包含字母、数字、减号、下划线和英文句点（区分大小写）
3、属性
属性值一定要用引号(单引号或双引号)引起来
4、注释
<!--这是注释-->
5、CDATA区
作用：把标签当做普通文本内容
语法：<!CDATA[<a/>]]>
三、DTD约束
1、格式良好的XML：遵循XML语法的XML
有效的XML：遵循约束文档的XML
2、作用：约束XML的书写规范
3、DTD的语法细节
3.1DTD的定义 可以将DTD的内容单独定义到一个文档中。但此文档保存时必须使用UTF-8 可以将DTD定义在XML文档中（没有编码要求） <!DOCTYPE 根元素名称 [ ]> DTD定义的内容
3.2DTD（DTD作为单独文件存在）在xml中的引入 a、DTD文档在本地 <!DOCTYPE 根元素 SYSTEM "DTD的存放路径">
b、DTD在公共网络上 <!DOCTYPE 根元素 PUBLIC "DTD文档的名称" "DTD的URL">
3.3定义元素 语法：<!ELEMENT 元素名称 使用规则> 使用规则： (#PCDATA):标签的主体内容为普通字符串 EMPTY：用于指示元素的主体为空。 (子元素)：标签中含有其他的子元素 子元素的细节：
出现次数：
描述子元素的出现次数 +:至少一次 *:0次、一次或多次 ?:0次或一次 什么都不带：必须一次且只能一次 出现的顺序： 如果各子元素用逗号分开，必须按照顺序出现 如果各子元素用|分开，任选其一
3.4定义元素属性 语法：<!ATTLIST 元素名 属性名1 属性类型 设置说明 属性名2 属性类型 设置说明 > 语法细节： 属性类型：
CDATA：表示属性的取值为普通的文本字符串
ENUMERATED (DTD没有此关键字)：表示枚举，只能从枚举列表中任选其一，如(鸡肉|牛肉|猪肉|鱼肉)
ID:表示属性的取值不能重复 设置说明： #REQUIRED：表示该属性必须出现 #IMPLIED：表示该属性可有可无 #FIXED:表示属性的取值为一个固定值。语法：#FIXED "固定值" 直接值：表示属性的取值为该默认值
3.5定义实体 作用：用一个名字引用一段内容 引用实体： 概念：在DTD中定义，在XML中使用 语法：<!ENTITY 实体名称 “实体内容”> 在xml中进行引用：&实体名称; 参数实体： 概念：在DTD中定义，在DTD中使用 语法：<!ENTITY % 实体名称 “实体内容”> 引用方式（注意是在DTD中使用）：%实体名称;
day02
一、Schema
1、Schema本身就是一个XML文件
2、Schema一般会将定义的约束绑定到一个名称空间上
targetNamespace=""
二、根据Schema约束编写XML实例文档
1、<?xml version="1.0"?>
2、根元素是谁？
查看Schema文档，第一个element就定义了根元素 <?xml version="1.0"?> <书架> </书架>
3、书架来自哪个名称空间
</书架> 查看Schema文档，根元素中的targetNamesapce就是定义的名称空间 在xml文档中，可以使用xmlns来声明名称空间 <?xml version="1.0"?> <书架 xmlns:heima="">
4、引入的名称空间与哪个xsd文件对应呢？
</书架> 使用schemaLocation来指定该名称空间所对应的xsd文件 <?xml version="1.0"?> <书架 xmlns:heima="" schemaLocation=" book.xsd">
5、schemaLocation又来自哪个空间呢？
他所在的名称空间为一个固定值：/2001/XMLSchema-instance
<?xml version="1.0"?> <书架 xmlns:heima="" xmlns:xsi="/2001/XMLSchema-instance" xsi:schemaLocation=" book.xsd">
</书架>
6、对于来自的标签，都要加上heima名称空间
</heima:书> <?xml version="1.0"?> <heima:书架 xmlns:heima="" xmlns:xsi="/2001/XMLSchema-instance" xsi:schemaLocation=" book.xsd"> <heima:书> </heima:书架>
day03
一、Web资源
1、静态资源和动态资源
2、资源要想外界通过网络进行访问，必须安装服务器软件（就是一个网络服务程序）
3、常见的JavaWeb的服务器
WebLogic：支持JavaEE规范。收费
WebSphere AS：支持JavaEE规范。收费
Jboss AS：支持JavaEE规范。免费
Tomcat：支持JSP/Servlet规范。免费（Jsp/Servlet规范是JavaEE规范中的一种） 注：Servelt容器。web服务器
实现了什么规范的服务器，一般称之为什么容器。
4、启动常见的问题
4.1需要配置JAVA_HOME环境变量，执行你的JDK的安装目录(适用于解压版本)
4.2端口被占用了：
解决办法：更改为其他的端口
C:\apache-tomcat-6.0.32\conf\server.xml文件。搜索8080，更改为其他端口
把占用8080端口的应用干掉。
4.3Catalina_home环境变量，指向Tomcat的安装目录（不建议大家配置该环境变量）
4.4中文目录和有空格的目录问题
二、Tomcat
1、目录结构
CATALINA_HOME：代表Tomcat的安装目录
bin：存放Tomcat的一些启动和关闭脚本
conf：非常重要。配置Tomcat行为的配置文件
lib：存放Tomcat运行所需的jar包（包含Servet-api.jar--SUN公司Servlet规范）
logs：Tomcat的日志
webapps：Tomcat所管理的WEB应用所在的目录（默认的）。该目录中有几个文件夹，就代表有几个应用
work：工作目录
三、JavaWeb应用
1、标准的JavaWeb应用目录结构（SUN公司有规定）
应用名称
|----静态资源html、css、js（分目录去存放） |----WEB-INF:必须有，固定写法（存放在该目录中的资源无法被外界访问） |----classes目录：存放java编译后的字节码文件。必须有且是固定写法 |----lib：存放应用所需的jar包 |----web.xml：当前应用的配置文件。必须有，固定写法
2、Tomcat既可以作为普通的web应用服务器，还可以作为Servlet容器
3、
Tomcat的lib子目录：存放的JAR文件不仅能被Tomcat访问，还能被所有在Tomcat中发布的JavaWeb应用访问。
JavaWeb应用的lib子目录：存放的JAR文件只能被当前JavaWeb应用访问。
4、发布JavaWeb应用
开放式目录发布方式：把应用拷贝到webapps目录下
war包发布方式：把javaweb应用中的资源打成war包。再将war拷贝到webapps目录下 进入应用所在的目录
jar -cvf MySite.war .
四、Tomcat的配置文件server.xml
Server:代表一台服务器
Service：可以由多个Service。代表对外提供的服务
Engine：引擎。一个服务只有一个引擎
Connector：外部访问的连接。多个连接器共用一个引擎
Host：代表一个虚拟主机（网站）。
Context：代表一个网站中的应用
五、配置虚拟目录（应用）
1、server.xml文件，在Host元素中增加<Context/>元素
属性：path：指示用户访问的路径
docBase：应用所在磁盘上的绝对路径
注：修改了server.xml文件，必须重新启动Tomcat，才会生效（这种配置虚拟目录的方式不建议大家使用）
2、在conf/[enginename]/[hostname]/建立一个xml文件，该文件名就是访问路径
在该文件中添加<Context docBase="D:\heima8\MySite"/>（由于文件名就是path，path属性不用配置了）
建议大家使用的一种方式
六、配置JavaWeb的某个应用：web.xml
1、配置某个应用的默认主页：修改web.xml
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file> <welcome-file>index.jsp</welcome-file>
</welcome-file-list>
2、配置某个网站的默认应用
在conf/[enginename]/[hostname]/建立一个xml文件，文件名取名为ROOT.xml（需要重启） 在该文件中添加<Context docBase="D:\heima8\MySite"/>
访问：http://localhost:8080 此时会访问默认应用的默认主页
3、端口号改为默认端口号80
修改server.xml配置文件，把8080改为80（前提是80没有被占用）
七、配置虚拟主机
修改server.xml文件，增加Host元素
name：虚拟主机的名称
appBase：该虚拟主机的各应用所在的目录
八、HTTP协议
1、请求行
GET /demo1/index.html HTTP/1.1
GET：请求方式
不指定请求方式，默认是GET方式。比如：直接输入请求地址；点击超级链接
如要使用POST方式，需要借助于form表单的method属性
利用GET方式传递请求数据
/demo1/index.html?username=aaaaa&password=123（不建议使用，不安全，有大小限制） 利用POST方式传递请求数据
传递的数据出现在正文部分。没有大小限制，安全。（建议使用的）
/demo1/index.html：请求资源
HTTP/1.1：使用的协议
2、响应行
HTTP/1.1 200 OK
HTTP/1.1：使用的协议
200：响应码
OK：对响应码的描述
3、常用响应码
200(正常)
表示一切正常，返回的是正常请求结果
302/307(临时重定向)
指出被请求的文档已被临时移动到别处，此文档的新的URL在Location响应头中给出。 304(未修改)
表示客户机缓存的版本是最新的，客户机可以继续使用它，无需到服务器请求。 404(找不到)
服务器上不存在客户机所请求的资源。
500(服务器内部错误)
服务器端的程序发生错误
day04
一、HTTP协议请求消息头
Accept：浏览器可接受的MIME类型
（MIME类型与文件系统中的文件类型的对应关系可以查看CATALINA_HOME/conf/web.xml） Accept-Charset: 浏览器通过这个头告诉服务器，它支持哪种字符集
Accept-Encoding:浏览器能够进行解码的数据编码方式，比如gzip
Accept-Language:浏览器所希望的语言种类，当服务器能够提供一种以上的语言版本时要用到。 可以在浏览器中进行设置。
Host:初始URL中的主机和端口
Referer:取值为，用户所访问的当前页面之前的那个页面的URL（防盗链）
Content-Type：客户端向服务器端提交的数据的MIME类型
Content-Length:表示请求消息正文的长度
二、HTTP协议响应消息头
Location：指示新的资源的位置
Server:apache tomcat指示服务器的类型
Content-Encoding: gzip服务器发送的数据采用的编码类型
Content-Length: 80 告诉浏览器正文的长度
Content-Language: zh-cn服务发送的文本的语言
Content-Type: text/html; charset=GB2312（正文所使用的编码）服务器发送的内容的MIME类型 Refresh: 1;url=指示客户端刷新频率。单位是秒
Content-Disposition: attachment; filename=aaa.zip指示客户端下载文件
Set-Cookie:SS=Q0=5Lb_nQ; path=/search服务器端发送的Cookie
Expires: -1 控制客户端不要缓存
Cache-Control: no-cache (1.1) 控制客户端不要缓存
Pragma: no-cache (1.0)控制客户端不要缓存
三、Servlet的编写过程
1、 编写一个类（classes目录下）实现javax.servlet.Servlet接口
2、编译自定义的Servlet类。进入classes目录，执行
javac -d . HelloServlet.java
由于Servlet相关的类不在jdk中，因此应先设置classpath
set classpath=%classpath%;C:\apache-tomcat-6.0.32\lib\servlet-api.jar
3、配置Servlet，修改web.xml文件，增加以下内容
<servlet>
<servlet-name>HelloServlet</servlet-name><!--Servlet的名称-->
<servlet-class>com.itheima.HelloServlet</servlet-class><!--Servlet对应的类--> </servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/HelloServlet</url-pattern><!--访问该Servlet的URL路径--> </servlet-mapping>
4、将应用部署到Tomcat中
5、访问http://localhost:8080/hello/HelloServlet就是执行该Servlet
四、Servlet规范
1、含有两个类包
javax.servlet:协议无关的Servlet相关类
javax.servlet.http:与HTTP协议有关的Servlet相关类
2、当编写Servlet选择通过继承HttpServlet的方式时，不要覆盖掉service方法 原因：HttpServlet覆盖了service方法，提供了一些针对不同请求方式的处理方法 正确做法：覆盖掉do**方法
五、Servlet的映射
可以使用通配符*
使用通配符有两种固定的写法：
1、*.扩展名（前面没有/）
2、以"/"开头，以"/*"结尾
3、如果一个Servlet的映射url路径为"/"，那么该Servlet称之为缺省Servlet
4、所有的请求都是交给Servlet去处理的。如果用户请求的资源的URL路径在当前web应用的web.xml中没有找到匹配时，都是交由默认Servlet去处理的(CATALINA_HOME/conf/web.xml中有定义)
六、Servlet的生命周期
1、Servlet在默认情况下，在第一次被访问到时，才会由容器创建他的实例
2、针对用户的每次访问，service都会被调用一次
3、Servlet对象被销毁时，才会执行Destory方法
4、如果想Servlet在Tomcat启动时就被实例化，怎么做？
<servlet>
<servlet-name>ServletDemo4</servlet-name>
<servlet-class>com.itheima.servlet.ServletDemo4</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
load-on-startup：主体内容为一个自然整数
七、Servlet的Service方法
是多线程来调用的，会有线程安全（访问共同资源时）问题
1、使用同步
2、使用对象池。即在Tomcat中创建多个Servlet对象来进行服务
实现SingleThreadModel接口
3、尽量把变量定义成局部变量（*）
八、ServletConfig对象
代表Servlet的参数配置,设置初始化参数，可以使用ServletConfig来查看
config.getInitParameter("name");或config.getInitParameterNames;
<init-param>
<param-name>name</param-name> <param-value>jack</param-value>
</init-param>
九、ServletContext：
作用：代表整个JavaWeb应用，可以理解为当前web应用的总管
随着应用的启动而创建，随着应用的停止而销毁
1、实现Servlet之间的数据共享
ServletContext也是一个域对象（Map容器）
setAttribute(String name,Object obj):向容器中绑定对象
getAttribute(String name):从容器中获取某个对象
removeAttribute(String name):从容器中删除某个对象
getAttributeNames()：获取容器中的所有名称
2、配置全局参数web.xml
<context-param>
<param-name>encoding</param-name> <param-value>UTF-8</param-value>
</context-param>
ServletContext.getInitParameter(String name):获取参数取值
十、读取配置文件
1、利用ResourceBundle读取properties配置文件。只能读取classes目录下的
2、ServletContext读取任意位置的资源。getRealPath("/")/代表当前web应用
3、利用类加载器加载配置文件。只能读取classes目录下的（不适合加载特别大的配置文件） 十一、修改MyEclipse自动生成的Servlet的模板
1、8.5：搜索com.genuitec.eclipse.wizards_8.5.0.me201003052220.jar
找到templates/Servlet.java，这就是模板文件（注意备份）
2、6.6：搜索Servlet.java即可
day05
一、Response对象应用
1、向客户端输出中文字符
1.1以字节为单位 a、response.getOutputStream().write("中国".getBytes()):按照本地编码发送数据 b、response.getOutputStream().write("中国".getBytes("UTF-8")):会出现乱码问题 解决：通知客户端编码方式 方式一、response.setHeader("Content-Type","text/html;charset=UTF-8");
方式二、response.getOutputStream("<meta http-equiv='Content-Type'
content='text/html;charset=UTF-8'>".getBytes());
方式三、response.setContentType("text/html;charset=UTF-8"); 1.2以字符为单位 response.getWriter().write("中国"); 以字符为单位发送数据时，默认编码是ISO-8859-1，因此会出现乱码问题 解决： 方式一：响应对象输出数据时，指定编码：response.setCharacterEncoding("UTF-8"); 还要通知客户端编码方式：response.setContentType("text/html;charset=UTF-8"); 方式二：response.setContentType("text/html;charset=UTF-8");这一句的作用就相当于方式一的两句的作用。
总结：
response.setContentType: 字节流：只通知客户端解码码表 字符流：输出时查的码表；通知客户端解码码表
二、生成随机验证码
1、BufferedImage：代表一副内存图片
2、Graphics：代表画笔
3、ImageIO：输出内存图片
三、Response的细节
getOutputStream和getWriter这两个方法互相排斥，调用了其中的任何一个方法后，就不能再调用另一方法
response的流对象，容器会自动检查是否已经关闭，如果没有关闭，容器会给你关闭
四、Request对象
1、浏览器是什么编码就以什么编码传送数据
2、request.setCharacterEncoding(“UTF-8”);//POST有效
3、new String(username.getBytes(“ISO-8859-1”),“UTF-8”);//GET方式
4、可以通过修改Tomcat的 server.xml中连接器，来解决get请求中的中文乱码问题 <Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" URIEncoding="UTF-8"/>
注：不建议大家使用。严重依赖服务器
五、request对象同时也是一个域对象
六、RequestDispatcher对象
作用：转发 包含
request和ServletContext都能得到该对象的引用
区别如下：
ServletContext获取RequestDispatcher：path必须是绝对路径。“/”就代表了当前的web应用
HttpServeltRequest获取RequestDispatcher：path既可以是相对路径也可以是绝对路径。以"/"表示绝对路径
request.getContextPath()：获取当前应用的路径
1、转发前，源组件向response中写的任何内容都无效（源组件--->目标组件。目标组件呈现结果）
2、被包含组件所设置的所有头信息都无效(目标组件结果--->源组件。源组件呈现结果)
七、重定向细节
sendRedirect(String location)方法的参数，如果以“/”开头，表示相对于当前服务器根路径的URL。以“http"//”开头，表示一个完整路径。
day06
一、什么是会话
用户开启一个浏览器，访问很多页面，关闭浏览器，这个过程称之为一个会话过程。（如同打电话）
二、用户的数据保存问题
三、两种解决技术
1、Cookie：客户端技术
1.1Cookie的特点 cookie的组成：key=value。 cookie的属性： comment：注释 path：路径。默认path /day06/servlet/ cookie的path：/day06/servlet/ 请求路径：/day06/Servlet1(不能访问到cookie) cookie的path：/day06
请求路径：/day06/Servlet1(能访问到cookie) cookie的path：/day06 请求路径：/day06/servet/Servlet1(能访问到cookie) domain：域。。不设置有默认域 localhost age：存活时间（秒）：如果不设置该属性。存活时间就是浏览器进程。默认值是0 可以通过设置age为0的方式来删除cookie 注：path要一致，写回cookie version：版本号 向客户端写cookie：HttpServletResponse.addCookie 服务器端获取客户端提交的cookie：HttpServletRequest.getCookies() 客户端针对一个网站，最多保存20个cookie 客户端最多能存300个cookie 每一个cookie的大小不能超过4Kb
2、Session：服务器端技术
2.1Session的特点
a、默认情况下（IE7-）：开启一个浏览器进程就相当于开启了一次新会话 ：由一个窗口触发另外一个窗口，这2个窗口属于同一个会话
：开启一个新tab窗口，与之前打开的窗口也属于同一个会话
b、HttpSession对象是在服务器端。针对每一个用户的每一次会话请求都会创建一个新的session对象。
服务器是如何知道那个session对象是哪个用户的呢？
HttpSession对象有一个唯一的ID。它把该ID以cookie的形式写给了客户端。
JSESSIONID=sessionid
该cookie的默认存活时间是：浏览器进程。默认的path 当前的应用名称/day06
MD5加密
要使用到MessageDigest类，这是一个抽象类，通过getInstance("MD5")方法获得对象，参数为加密算法。
然后对象调用digest方法，参数为一个字符数组，返回的结果也是一个字符数组，被称为数据指纹。
这里还要用到Base64编码原理，BASE64Encoder base=new BASE64Encoder(),使用encode方法编码。
day07
一、客户端禁用Cookie
（如果通过Http://localhost访问，虽然禁用了cookie，但对于该地址不起作用）
1、http://192.168.1.250来访问，由于禁用了Cookie，所以Session不起作用了
2、禁用Cookie之后，会话还有效
解决办法：URL重写(对用到的所有URL地址都得重写)
response.encodeRedirectURL(java.lang.String url)
response.encodeURL(java.lang.String url)
重写前：http://127.0.0.1:8080/day07/servlet/ShowCartServlet
重写后：http://127.0.0.1:8080/day07/servlet/ShowCartServlet;JSESSIONID=9832749832
注：如果检测到客户端没有禁用Cookie，重写方法就不会给你加上JSESSIONID
二、HttpSession对象的失效时间
1、浏览器关闭是结束一次会话。HttpSession对象没有被销毁。
session 对象默认被销毁的时间是30分钟
2、修改默认的失效时间（至少1分钟）
<session-config>
<session-timeout>1</session-timeout><!--单位是分钟-->
</session-config>
三、Session对象的持久化
1、运行时会出现的问题
a、内存中的Session对象太多
b、服务器端的应用重新启动了。对用户的购物车不应该产生影响
2、都在session的状态图中
request.getSession():客户端没有对应的session对象，创建session对象
客户端有对应的session对象，获取session对象。
reqeust.getSession(false):只获取。如果客户端没有对应的session对象，返回null
四、IE浏览器各种版本何时才会开启新会话
IE:
通过一个窗口的超链接开启的另一个窗口属于同一次会话。
开启新的浏览器进程，属不属于同一次会话呢？
IE7-（含）：不是同一次会话；IE8+（含）属于同一次会话。
开启新的Tab页：属于同一次会话。
IE8+以上版本：如果要在不同的窗口中使用不同的会话，“文件”/"新建会话"
五、JSP语法
更改JSP的模板：JSP模板文件是*.vtl。在Servlet.java的附近
JSP开发最佳实践：
Servelt作为控制器：处理业务逻辑，封装数据，转发给JSP去显示。用户所有的请求都请求的是Servlet
JSP作为显示
1、JSP模版元素
JSP页面中的HTML内容称之为JSP模版元素
2、JSP表达式
作用：将变量或表达式的结果输出界面上
语法:<%= 变量或表达式%>
注意：后面没有分号
3、JSP脚本片段
作用：用于在JSP页面中编写多行Java代码
语法：<%
语句1;
语句2;
%>
语句会原封不动的出现在对应的Servlet的service中
4、JSP声明：
作用：定义成员变量、方法
语法：<%!
java代码
%>
5、JSP注释
语法：<%--
这是JSP的注释
--%>
注意：虽然与html的注释<!---->起到的作用都是让用户看不到，但是实质上有很大区别 HTML的注释：翻译时不会忽略，生成结果后，被注释掉了
Java注释：不翻译。
6、JSP指令
page include taglib
作用：是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分
语法：<%@指令名称 属性="值"%>
page指令
属性：
language:指示jsp中使用的脚本语言。默认值是java，目前只支持java脚本
extends：指示jsp对应的Servlet的父类。不要修改
*import：导入jsp中使用到的其他类包
自动导入以下包：
java.lang.* javax.servlet.* javax.servlet.http.* javax.servlet.jsp.*
在一个属性中导入多个包：<%@page import="java.util.Date,java.util.Calendar"%>
*session：是否创建HttpSession对象。默认值是true
buffer：none|8kb|自定义（kb）缓冲区。默认值是8kb，不建议大家修改
autoFlush：自动刷新JspWriter的缓存。默认值是true。不建议修改
isThreadSafe：true|false。默认值是true（不安全）。改为false才是安全的（让jsp对应的servlet实现SingleThreadModel）不建议修改
*errorPage:处理出错的页面的url（错误页面的消息提示要多些，不然不会出现结果） web.xml:
<error-page>
<exception-type>java.lang.Exception</exception-type> <location>/error.jsp</location>
</error-page>
*isErrorPage：true|false。指示是不是错误处理页面。是否产生exception对象
*contentType="mimeType;charset=UTF-8":等同于response.setContentType();
*pageEncoding:通知引擎在翻译jsp--》Servlet时使用的编码
*isELIgnored：是否忽略EL表达式true|false。默认值false。true是忽略EL表达式
include指令：
作用：包含（静态包含）
语法：<%@ include file=“被包含组件的绝对URL或相对URL"%>
/代表当前应用：绝对路径
动态包含：<jsp:include/>jsp的动作：动态包含
taglib指令：
<%@taglib uri="" prefix=""%>
uri：引入的标签的URL
prefix：使用时的前缀
7、JSP九大内置对象
JSP中的9大隐式对象：指JSP对应的Servlet中的service方法中的局部变量。在编写java脚本时，直接可以拿来用。
request：HttpServletRequest
response：HttpServletResponse
session：HttpSession（jsp页面的page指令的session为true）
application：ServletContext
config：ServletConfig
page：当前Servlet对象
exception：代表异常对象（jsp页面的page指令的isErrorPage为true）
out：JspWriter（response.getWriter）
pageContext：PageContext
1、获取其他8大隐式对象（JSP的自定义标签开发）
2、存取对象到某个域范围中
8、jsp的动作元素
a、<jsp:include/>：包含（动态包含）。尽量用静态包含
b、<jsp:forward/>:转发。支持表达式<%=%>
c、<jsp:param/>:传请求参数
如何查找JSP页面中的错误
六、四大域对象
page：PageContext ：当前页面：当前对象
request：HttpServletRequest 一次请求范围
session：HttpSession 一次会话范围
application：ServletContext 整个web应用范围
七、URL地址的写法
1、相对路径:不以"/"开头
2、绝对路径 "/"
/day06/servlet /servlet 要不要加项目名称（地址是不是给服务器端程序用的，如果是，不需要加项目名称。地址如果是给客户端用的，要加项目名称）
ServletContext.getRealPath(url): 不要
request.getRequestDispather(url): 不要
<jsp:forward page="url"/> 不要
response.sendRedirect(url): 要
form action="url": 要
<a href="url"/>: 要
<img src="url"/> 要
day08
一、JavaBean在JavaEE开发中的作用：封装数据
在需求分析中，那些表示实际生活的对象和抽象的对象，都用JavaBean来描述
JavaBean基本的书写规范
1、有默认的构造方法
2、所有的字段都是私有的。字段名称如果只有一个单词的话，全部小写。多个单词的话，从第2个单词开始单词首字母大写，其余小写
3、提供public类型的getter和setter方法。比如字段name,getName setName
4、一般情况下，JavaBean最好实现Serializable接口
二、Jsp中使用JavaBean
1、Jsp中提供了3个操作JavaBean的动作元素
1.1<jsp:useBean>:用于在JSP页面中查找或实例化一个JavaBean组件 属性：
id：实例化的Bean的名称
class：实例化的类的全名 scope：实例的存放范围。page|request|session|application(默认page) 注：如果该动作元素包含主体内容，只有在实例化Bean对象时才会执行 1.2<jsp:setProperty>:用于在JSP页面中设置一个JavaBean组件的属性 属性： name：bean实例的名称：useBean中的id property：属性名称。可以使用通配符*.前提请求参数名称与属性名称一致 value：设置的值 param：对应的请求参数名 1.3<jsp:getProperty>:用于在JSP页面中获取一个JavaBean组件的属性
property:属性名称 name：bean实例的名称：useBean中的id
三、开发模式
1、模型1：Jsp+JavaBean
只适合开发业务逻辑非常简单的业务系统。（Demo）
BigDecimal：进行精确运算的
2、模型2：MVC（Model+View+Controler）
M：JavaBean
V：JSP
C：Servlet
目前遵循一种开发模式
四、EL表达式：消除jsp中的java脚本
1、EL：消除表达式：语法${EL表达式}
1.1获取数据：替换<%=%> ${p}:p是域对象中的某个名称。取p这个名称对应的对象
1.2执行运算 1.3获取web开发常用对象(11大隐式对象) pageContext：代表PageContext对象本身。其他隐式对象表示的都是一个Map
pageScope：代表PageContext范围的那个域Map
requestScope:
sessionScope:
applicationScope:
param:封装了单一请求参数值的Map.key:是请求参数名；value：请求参数值
paramValues：封装了多个同名请求参数的Map。key：是请求参数名；value：请求参数值数组
header：表示一个保存了所有http请求头字段的Map对象
headerValues:返回string[]数组.
cookie:表示一个保存了cookie的Map。key：cookie中的name；value：cookie对象本身 initParam：表示一个保存了全局配置参数（对应web.xml中的<Context-param/>）的Map。key：参数名；value：参数值。
1.4访问Java方法：静态方法（EL调用静态方法，定义EL函数） 1、定义一个静态方法 2、在WEB-INF目录下建立一个扩展名为tld的xml文件 3、在tld文件中对要调用的静态方法进行描述 <?xml version="1.0" encoding="UTF-8"?> <taglib xmlns="/xml/ns/j2ee" xmlns:xsi="/2001/XMLSchema-instance"
xsi:schemaLocation="/xml/ns/j2ee /xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0"> <description>examples.</description> <tlib-version>1.0</tlib-version> <short-name>myfn</short-name> <uri>/jsp/myfn</uri> <function> <description>toUppercase</description> <name>toUpperCase</name> <function-class>com.heima.domain.Demo1</function-class> <function-signature>java.lang.String toUpperCase( java.lang.String )</function-signature> </function> <function> <description>string lenth</description> <name>length</name>
<function-class>com.heima.domain.Demo1</function-class> <function-signature>int length( java.lang.String )</function-signature> </function>
</taglib>
4、在JSP中使用 先利用taglib指令导入tld函数库 ${myfn:length("aaa")}
2、标签：消除java脚本
五、JSTL：apache弄的一套jsp标准的tld
1、JSTL core：核心标签库 c 1.0(不支持EL) 1.0_rt(支持EL) 1.1(支持EL)
2、JSTL i8n：国际化标签库 fmt
3、JSTL xml：操作xml的标签库
4、JSTL sql：操作数据库的标签库 x sql
5、JSTL function：EL函数库 fn 用户操作String
搭建开发环境：jstl.jar standard.jar
六、标签的使用
1、JSTL core：if 判断
test：必须有。内部返回一个boolean var：将test的运行结果进行保存 scope：指定var的变量保存的范围。page|request|session|application page
2、JSTL core：foreach 遍历
items:代表要遍历的数组或集合 var：保存当前遍历的对象到page范围内 begin：开始序号 end：结束序号
step：步长 varStatus：代表一个对象 getCount():int getIndex():int getFirst():boolean getLast():boolean
day11
SQL语句
shell>>window命令
mysql>>MySQL命令
一、数据库简介
1、SQL：Structured Query Language (结构化查询语言)
工业标准。
MySQL:支持标准的SQL。在此基础上进行了扩展。方言
Oracle：支持标准的SQL。在此基础上进行了扩展。方言。PLSQL
2、验证安装是否成功
shell>>mysql -u root -p
显示所有的数据库
mysql>>SHOW DATABASES; //查看数据库
除了test，其他两个不要乱动
二、DDL：数据定义语言 Data Definition Language 针对数据库及表本身的结构
CREATE创建 ALTER修改 DROP删除
----------------------------------------------------------------------
创建一个名称为mydb1的数据库。
查看数据库的创建细节
创建一个使用utf8字符集的mydb2数据库。
创建一个使用gbk字符集，并带校对规则的mydb3数据库。
mysql>>CREATE DATABASE mydb3 CHARACTER SET gbk COLLATE gbk_chinese_ci; utf8_general_ci mysql>>CREATE DATABASE mydb1 CHARACTER SET utf8; mysql>>SHOW CREATE DATABASE mydb1; mysql>>CREATE DATABASE mydb1;
删除前面创建的mydb3数据库
查看服务器中的数据库，并把其中某一个库mydb2的字符集修改为gbk;
备份数据库：只会备份数据库中的表结构和表数据
选择test数据库
备份test数据库到文件中
恢复数据库:备份时不会备份数据库名本身
方式一：
mysql>>CREATE DATABASE test; shell>>mysqldump -u root -psorry test>c:/test.sql mysql>>USE test; mysql>>ALTER DATABASE mydb2 CHARACTER SET gbk; mysql>>DROP DATABASE mydb3;
mysql>>USE test; mysql>>SOURCE c:/test.sql;
方式二：
mysql>>CREATE DATABASE test; shell>>mysql -u root -psorry test<c:/test.sql
*********************************************************************
创建一个员工表
mysql>>CREATE TABLE employee (id int,name varchar(100),gender varchar(10),birthday date,entry_date date,job varchar(100),salary float(8,2),resume text);
查看数据库中的表格
查看表结构
在上面员工表的基本上增加一个image列。
修改job列，使其长度为60。
删除gender列。
表名改为user。
查看表的创建信息
mysql>>SHOW CREATE TABLE user; mysql>>RENAME TABLE employee TO user; mysql>>ALTER TABLE employee DROP gender; mysql>>ALTER TABLE employee CHANGE job job varchar(60); mysql>>ALTER TABLE employee ADD image BLOB; mysql>>DESC employee; mysql>>SHOW TABLES;
修改表的字符集为utf-8
列名name修改为username
mysql>>ALTER TABLE user CHANGE name username varchar(100); mysql>>ALTER TABLE user CHARACTER SET utf8;
----------------------------------------------------------------------
三、DML：数据操作语言 Data Manipulation Language 针对表中的记录的
INSERT增加 DELETE 删除 UPDATE 更改
----------------------------------------------------------------------
日期和字符串类型的值：应该用单引号引起来。
向user表中插入三条数据
mysql>>INSERT INTO user (id,username,birthday,entry_date,job,salary) VALUES (1,'liumingyue','1990-09-08','2012-10-15','CEO',10000.00);建议使用
mysql>>INSERT INTO user VALUES (2,'wangguili','1992-09-08','2012-10-15','CTO',9000.00); 查看表中的所有记录
mysql>>SELECT * FROM user;
插入中文数据
mysql>>INSERT INTO user (id,username,birthday,entry_date,job,salary) VALUES (3,'位丹丹','1993-09-08','2012-10-15','CMO',9000.00);
编码有关
数据库的编码：
mysql>>SHOW VARIABLES LIKE 'character%';
character_set_client:是客户端使用的字符集。
character_set_connection:是连接数据库的字符集设置类型，如果程序没有指明连接数据库使用的字符集类型就按照服务器端默认的字符集设置。
character_set_database:是数据库服务器中某个库使用的字符集设定，如果建库时没有指明，将使用服务器安装时指定的字符集设置。
character_set_results:是数据库给客户端返回时使用的字符集设定，如果没有指明，使用服务器默认的字符集。
character_set_server:是服务器安装时指定的默认字符集设定
character_set_system:是数据库系统使用的字符集设定。
告知数据库服务器，客户端传递数据用的编码
mysql>>SET character_set_client=gbk;
查看中文数据时的乱码问题
mysql>>SET character_set_results=gbk;
将所有员工薪水修改为20000元。
mysql>>UPDATE user SET salary=20000;
将姓名为’wangguili’的员工薪水修改为30000元。
mysql>>UPDATE user SET salary=30000 WHERE username='wangguili';
将姓名为’liumingyue’的员工薪水修改为40000元,job改为UFO。
mysql>>UPDATE user SET salary=40000,job='UFO' WHERE username='liumingyue';
将位丹丹的薪水在原有基础上增加1000元。
mysql>>UPDATE user SET salary=salary+10000 WHERE username='位丹丹';
删除表中名称为’位丹丹’的记录。
mysql>>DELETE FROM user WHERE username='位丹丹';
删除表中所有记录。
mysql>>DELETE FROM user; 删除效率低。一条一条地删除。
使用truncate删除表中记录
mysql>>TRUNCATE user; 删除效率高。摧毁整张表格，然后重新建立表结构。
----------------------------------------------------------------------
四、DQL：数据查询语言 Data Query Language
SELECT查询
----------------------------------------------------------------------
查询表中所有学生的信息。
mysql>>SELECT id,name,chinese,math,english FROM student;
mysql>>SELECT * FROM student; //不建议使用
查询表中所有学生的姓名和对应的英语成绩。
mysql>>SELECT name,english FROM student;
过滤表中重复数据。
mysql>>SELECT DISTINCT english FROM student;
在所有学生语文分数上加10分特长分。
mysql>>SELECT name,chinese+10 FROM student;
统计每个学生的总分。
mysql>>SELECT name,(chinese+english+math) FROM student;
使用别名表示学生分数。
mysql>>SELECT name AS 姓名,(chinese+english+math) 总分 FROM student;
查询姓名为wu的学生成绩
mysql>>SELECT * FROM student WHERE name='王五';
查询英语成绩大于90分的同学
mysql>>SELECT * FROM student WHERE english>90;
查询总分大于200分的所有同学
mysql>>SELECT name,(chinese+english+math) FROM student WHERE (chinese+english+math)>200; 查询英语分数在 80－90之间的同学。
mysql>>SELECT * FROM student WHERE english BETWEEN 80 AND 90; (含80和90) 查询数学分数为89,90,91的同学。
mysql>>SELECT * FROM student WHERE math IN (89,90,91);
查询所有姓李的学生成绩。
mysql>>SELECT * FROM student WHERE name LIKE '李%';
查询数学分>80，语文分>80的同学。
mysql>>SELECT * FROM student WHERE math>80 AND chinese>80;
对数学成绩排序后输出。
mysql>>SELECT * FROM student ORDER BY math; //默认是升序
对总分排序后输出，然后再按从高到低的顺序输出
mysql>>SELECT name,(chinese+english+math) FROM student ORDER BY (chinese+english+math) DESC;
对姓李的学生总成绩排序输出
mysql>>SELECT name,(chinese+english+math) FROM student WHERE name LIKE '李%' ORDER BY (chinese+english+math);
统计一个班级共有多少学生？
mysql>>SELECT COUNT(*) FROM student;
统计数学成绩大于等于90的学生有多少个？
mysql>>SELECT COUNT(*) FROM student WHERE math>=90;
统计总分大于250的人数有多少？
mysql>>SELECT COUNT(*) FROM student WHERE (chinese+english+math)>250;
统计一个班级数学总成绩？
mysql>>SELECT SUM(math) FROM student;
统计一个班级语文、英语、数学各科的总成绩
mysql>>SELECT SUM(math),SUM(chinese),SUM(english) FROM student;
统计一个班级语文、英语、数学的成绩总和
mysql>>SELECT SUM(math+chinese+english) FROM student;
统计一个班级语文成绩平均分
mysql>>SELECT SUM(chinese)/COUNT(*) FROM student;
求一个班级数学平均分？
mysql>>SELECT AVG(math) FROM student;
求一个班级总分平均分
mysql>>SELECT AVG(math+chinese+english) FROM student;
求班级语文最高分和最低分（数值范围在统计中特别有用）
mysql>>SELECT MAX(chinese) FROM student;
特别注意：用关键字作为表名，要使用``（Esc按键下面）包围起来。
对订单表中商品归类后，显示每一类商品的总价
mysql>>SELECT id,product,price,SUM(price) FROM orders GROUP BY product;
查询购买了几类商品，并且每类总价大于100的商品
mysql>>SELECT id,product,SUM(price) FROM orders GROUP BY product HAVING SUM(price)>100; ----------------------------------------------------------------------
（选修）DCL：数据控制语言
GRANT授权
五、约束
1、定义主键约束
主键：唯一标识一条记录。必须输入且唯一。
逻辑主键：与业务无关 id
业务主键：与业务有关
PRIMARY KEY定义主键
2、主键自动增长：不是所有的数据库都支持.实际开发中，主键最好由自己的应用程序维护。 MySql: auto_increment
3、非空约束：NOT NULL
4、唯一约束：UNIQUE
CREATE TABLE employee(
id int PRIMARY KEY auto_increment, gender varchar(10) not null, username varchar(100) UNIQUE not null
);
INSERT INTO employee (gender,username) VALUES('male','admin');
六、多表标准设计
1、一对多或多对一
CREATE TABLE department(
);
CREATE TABLE employee(
);
2、多对多
CREATE TABLE teacher(
);
CREATE TABLE student(
);
CREATE TABLE teacher_student(
t_id int, s_id int, id int primary key auto_increment, name varchar(100), grade varchar(10) id int primary key auto_increment, name varchar(100), salary float(8,2) id int primary key auto_increment, name varchar(100), salary float(8,2), dept_id int, CONSTRAINT dept_id_fk FOREIGN KEY(dept_id) REFERENCES department(id) id int primary key auto_increment, name varchar(100)
); PRIMARY KEY(t_id,s_id), CONSTRAINT t_id_fk FOREIGN KEY(t_id) REFERENCES teacher(id), CONSTRAINT s_id_fk FOREIGN KEY(s_id) REFERENCES student(id)
3、一对一
CREATE TABLE person(
);
CREATE TABLE idcard(
); id int primary key auto_increment, num varchar(100), CONSTRAINT p_id_fk FOREIGN KEY(id) REFERENCES person(id) id int primary key auto_increment, name varchar(100)
day12
一、JDBC概述
JDBC：Java DataBase Connectivity
JDBC相关的接口是SUN公司制定，属于JavaEE技术的一种
存在于JDK中java.sql.*和javax.sql.*及子包下
*二、JDBC的编写步骤：入门案例
前提：拷贝数据库的驱动到构建路径中
//注册驱动
//获取与数据库的链接:程序所有与数据库打交道的东东都是基于该链接的 //得到能发送SQL语句的对象
//如果执行的是查询，得到查询的结果对象
//遍历结果
//释放占用的资源
*三、JDBC编码过程中的主要接口详解
DriverManager：注册驱动，获取链接
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
缺点：
1、严重依赖具体的驱动 2、驱动程序会注册2遍
推荐方式：Class.forName("com.mysql.jdbc.Driver");
注意：
链接数据库使用url： 不同数据库的url是不同的，具体查看数据库文档 相同数据库的不同版本url也可能是不同的，具体查看数据库文档
Connection：代表数据库的链接
它用于代表数据库的链接，Collection是数据库编程中最重要的一个对象，客户端与数据库所有交互都是通过connection对象完成的
createStatement()：创建向数据库发送sql的statement对象。
Statement：发送SQL语句
ResultSet rs = executeQuery(String sql) ：用于向数据发送查询语句。sql只能是DQL
int num = executeUpdate(String sql)：用于向数据库发送 DML.返回的是影响到的行数 boolean b = execute(String sql)：用于向数据库发送任意sql语句。返回true，说明sql语句有返回的查询结果集。false，没有结果集返回
ResultSet：封装了查询结果。
实际开发是把表中的记录封装到JavaBean中。 提供了很多取对应类型的值的方法。关键记住Java中的类型与数据库中的类型的对应关系
*四、如何释放资源
写到finally中
if(rs!=null){
}
if(stmt!=null){
}
if(conn!=null){
} try{ conn.close(); try{ stmt.close(); try{ rs.close(); }catch (SQLException e) { } rs = null; e.printStackTrace();//后台记录异常信息 }catch (SQLException e) { } stmt = null; e.printStackTrace(); }catch (SQLException e) { } conn = null; e.printStackTrace();
(动手练习)五、用JDBC对某张表格进行CRUD
(动手练习)六、改写原来的用户注册和登陆案例。 *SQL注入问题
*PreparedStatement
优点： 1、支持SQL预编译。 2、采用占位符?形式替代sql语句中的参数 3、预防SQL注入。
(动手练习)七、客户管理系统：JavaWeb--》CRUD
day13
一、客户系统修改、删除写完
二、大数据分页
方式一: 每页显示10条 MySQL： SELECT * FROM customer LIMIT m,n; m:开始记录的索引。从0开始 n：取多少条 第1页： SELECT * FROM customer LIMIT 0,10; 第2页： SELECT * FROM customer LIMIT 10,10;
总共多少页： 总数据%10==0?总数据/10:总数据/10+1 页码和每页开始的索引的关系： Dao: 1、查询总记录数 2、查询分页数据 每页开始的索引=(页码-1)*每页显示的条数 Service： /** * 根据用户要查看的页码返回封装了分页数据的page对象 * @param pageNum * @return */ Page findPageRecords(int currentPage); Servlet： JSP： 只能收到客户端传递的页码，没传说明要看第1页 request.setAttribute("page",page);
方式二: QueryResult PageInfo PageBean 具体看分页图
三、抽出公用的分页代码
四、大数据的存取：大文本和大二进制
五、SQL批处理
Statement：内部有一个List缓存
addBatch(String sql)
executeBatch()：执行批处理
clearBatch():清空缓存
六、获取自动生成的记录主键
七、JDBC如何调用存储过程 如何用JDBC调用已有的存储过程
CallableStatement：用户存储过程的接口
八、事务入门
MySQL：事务有关的语句
start transaction;开启事务
rollback;//回滚事务
commit;//提交事务，事务的结束
Connection与事务有关的方法：
setAutoCommit(false)
rollback()
commit()
setSavePoint()
day14
一、事务的特性
? 原子性（Atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。 ? 一致性（Consistency）
事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
? 隔离性（Isolation）
事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
? 持久性（Durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。
二、事务的隔离级别
1、如果不考虑事务间的隔离性，那将会出现以下问题：
READ UNCOMMITTED:该级别脏读、不可重复读、虚读都有可能放生。 READ COMMITTED:该级别能防止脏读，不可重复读、虚读都有可能放生。 REPEATABLE READ:该级别能防止脏读、不可重复读，虚读都有可能放生。 SERIALIZABLE:该级别能防止脏读、不可重复读、虚读。（有性能问题） 脏读：一个线程开启了事务，操作中读到了另外一个线程事务未提交的数据 不可重复读：针对表中的某条记录，前后读到的结果不一致。 虚读（幻读）：针对表中的记录，前后读到的记录数量不一致。
2、JDBC更改事务的隔离级别
Connection.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);//一定要在开启事务前设置隔离级别
三、数据库链接池原理
四、如何编写标准的数据库链接池（数据源） 包装设计模式
基于接口的动态代理
1、更改一个已有类的原有方法的代码行为，有以下三种方式：
a、继承：目前不可取 b、包装设计模式： 1、建立一个类，实现与被包装对象相同的接口（或者继承被包装对象） 2、定义一个私有变量，记住原有对象（被包装对象） 3、定义构造方法，传入被包装对象的引用 4、对于要更改的方法，改写就是了 5、对于不需要更改的方法，调用原有对象的。 c、动态代理 1、基于接口的动态代理：
2、基于子类的动态代理：Hibernate、Spring。 CGLIB 被增强对象必须是public，且不是final的。
五、2个开源的数据源
? DBCP 是 Apache 软件基金组织下的开源连接池实现，使用DBCP数据源，应用程序应在系统
中增加如下两个 jar 文件：
? Commons-dbcp.jar：连接池的实现
? Commons-pool.jar：连接池实现的依赖库
? Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使
用，也可由应用程序独立使用。
C3P0:
六、Tomcat如何管理数据源
1、TOmcat就是用的DBCP作为数据源的
2、使用Tomcat中的数据源
a、把数据库的驱动拷贝到Tomcat\lib目录下 b、在应用的META-INF目录下建立一个名为context.xml文件，内容如下： <Context> <Resource name="jdbc/day14" auth="Container" type="javax.sql.DataSource"
maxActive="100" maxIdle="30" maxWait="10000"
username="root" password="sorry" driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/day14"/>
</Context> c、在页面或类中（Tomcat管理的类）中，通过以下代码获取DataSource对象 Context initContext = new InitialContext(); DataSource ds = (DataSource)initContext.lookup("java:/comp/env/jdbc/day14"); Connection conn = ds.getConnection();
象。 JNDI：Java Naming and Directory Interface Java命名和目录服务 API都在jdk中的javax.naming.*包中。 JNDI想象成一个大Map<String,Object>:key：一个字符串，标识对象的名称。value:一个对
七、获取数据库的元数据（不做框架，无用）
1、什么叫元数据
数据库、表、列的定义信息
2、
Connection.getMetaData()
? DataBaseMetaData对象
? getURL()：返回一个String类对象，代表数据库的URL。 ? getUserName()：返回连接当前数据库管理系统的用户名。 ? getDatabaseProductName()：返回数据库的产品名称。
? getDatabaseProductVersion()：返回数据库的版本号。
? getDriverName()：返回驱动驱动程序的名称。
? getDriverVersion()：返回驱动程序的版本号。
? isReadOnly()：返回一个boolean值，指示数据库是否只允许读操作。
PreparedStatement . getParameterMetaData()
? 获得代表PreparedStatement元数据的ParameterMetaData对象。 ? Select * from user where name=? And password=?
? ParameterMetaData对象
? getParameterCount()
? 获得指定参数的个数
? getParameterType(int param)
? 获得指定参数的sql类型（驱动可能不支持）
ResultSet. getMetaData()
? 获得代表ResultSet对象元数据的ResultSetMetaData对象。
? ResultSetMetaData对象
? getColumnCount()
? 返回resultset对象的列数
? getColumnName(int column)
? 获得指定列的名称
? getColumnTypeName(int column)
? 获得指定列的类型 java.sql.Types
八、编写一个JDBC框架
反射 策略设计模式
day15
一、继续QueryRunner：批处理。大数据处理
二、DBUtils中的结果处理器
三、跨Dao的事务管理：实际开发中该如何编写这块代码 Dao层不能牵扯任何业务逻辑。
业务逻辑一定放在service层进行处理。
四、ThreadLocal
五、使用DBUtils进行多表CRUD。
1、一对多、多对一
六、MyBatis入门
day16
一、自定义标签的作用
1、标签的作用：替代JSP中Java脚本
2、自定标签技术数据JSP技术的一种
二、入门案例：自定义标签的开发步骤
1、编写一个类，实现Tag接口。
javax.servlet.jsp.tagext.Tag：
常量：
int EVAL_BODY_INCLUDE:给doStartTag用的。处理主体内容 int SKIP_BODY:给doStartTag用的。忽略主体内容
int EVAL_PAGE:给doEndTag用的。还要处理结束标签后面的JSP内容 int SKIP_PAGE:给doEndTag用的。忽略结束标签后面的JSP内容 方法：（绝大部分都是容器调用的）
int doEndTag():遇到结束标签时就执行此方法中的代码
int doStartTag():遇到开始标签时就执行此方法中的代码
Tag getParent():程序员看需求来使用
void release():释放当前标签对象占用的资源
void setPageContext(PageContext pc):在调用处理开始和结束标签代码之前被容器调用。会传入当前页面的上下文PageContext
void setParent(Tag t):传递该标签的父标签，如果没有，传入null
-------------------------------------------------------------------
package com.itheima.tag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.TagSupport;
public class ShowRemoteIpTag extends TagSupport {
} public int doStartTag() throws JspException { } String remoteIp = pageContext.getRequest().getRemoteAddr(); try { pageContext.getOut().print(remoteIp); } catch (IOException e) { } return super.doStartTag(); e.printStackTrace();
2、在WEB-INF目录下建立一个扩展名为tld的xml文件（从Tomcat中拷贝一个）
<?xml version="1.0" encoding="UTF-8"?>
<taglib xmlns="/xml/ns/j2ee"
xmlns:xsi="/2001/XMLSchema-instance"
xsi:schemaLocation="/xml/ns/j2ee /xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">
<tlib-version>1.0</tlib-version>
<short-name>itheima</short-name>
<uri>/jsp/tag</uri>
<tag>
<description>Show remote ip address</description>
<name>showRemoteIp</name>
<tag-class>com.itheima.tag.ShowRemoteIpTag</tag-class> <body-content>empty</body-content>
</tag>
</taglib>
3、在web.xml中对tld中的uri和tld的位置进行对应（可选的，前提是tld文件放在WEB-INF目录下）
<jsp-config>
<taglib> <taglib-uri>/jsp/tag</taglib-uri> <taglib-location>/WEB-INF/itheima.tld</taglib-location> </taglib>
</jsp-config>
4、在JSP中使用
<%@ taglib uri="/jsp/tag" prefix="itheima"%>
<itheima:showRemoteIp/>
三、传统标签的执行原理
传统标签类的生命周期与Servlet的一样。
四、标签的扩展功能（4个）
控制jsp页面某一部分内容是否执行。
控制整个jsp页面是否执行。
控制jsp页面内容重复执行。
----------------------------------------------
IterationTag：增加重复执行主体内容的功能。
常量：
int EVAL_BODY_AGAIN：
方法：
int doAfterBody()：由容器调用。
调用时机：处理主体内容时。执行该方法的前提，doStartTag必须返回EVAL_BODY_INCLUDE 该方法能返回的值：
Tag.SKIP_BODY:结束该方法进入结束标签处理方法。
IterationTag.EVAL_BODY_AGAIN:继续执行自己
-------------------------------------------------
修改页面内容输出。如何获取主体内容。
BodyTag：增加了获取主体内容的功能
常量：
int EVAL_BODY_BUFFERED：
给doStartTag()用的，只有返回该参数，以下2个方法才会由容器执行。
方法：
void doInitBody()：由容器调用。
void setBodyContent(BodyContent b)：由容器调用。把标签的主体内容传进来。参数b就代表了主体内容 b.getString()拿到主体内容。
五、JSP中的标签主要类或接口的继承体系
六、简单标签及执行原理
1、SimpleTag中的方法：
void doTag()：容器调用。处理标签。不分开始和结束
JspTag getParent() ：程序员自己调用。获取父标签
void setJspBody(JspFragment jspBody)：容器调用。传入当前标签的主体内容 void setJspContext(JspContext pc)：容器调用。传入当前页面的上下文。 void setParent(JspTag parent)：容器调用。设置父标签，如果有的话。
七、tld配置文件主要元素
taglib:根元素
short-name:JSP引用该tld中标签的前缀 uri：与xml中schema名称空间的作用一样的 tag：用于描述一个标签 name：标签名称 tag-class:标签的实现类，写全名 body-content:指示标签的主体内容类型 可选值： empty：没有主体内容 JSP：传统标签使用。可以是任何内容。即jsp文件中能写什么，主体内容就能写什么。
<%%>
scriptless:给简单标签使用。主体内容不能是java脚本。即不能出现 tagdepentend:原封不动的作为主体内容出现 attribute：定义该标签的属性
name：属性名称。对应标签处理类的setter方法。 required：该属性是否是必须的。true|false rtexprvalue:该属性的值是否支持表达式。true|false function：定义EL函数
八、实际开发案例
九、JSTL中core剩余标签 JSTL：Java Standard Taglibary 标准的标签库 五大部分：
Core:核心
Fmt:格式化（I18N国际化）
Xml：操作XML的（简单）
Sql：操作数据库的（简单）
Function：EL函数
day17
一、JSTL核心：下
<c:param> name value c:param能自动对中文数据进行url编码 <c:import> url
<c:url> value var scope c:url自动对url进行重写 <c:forTokens>items delims var 分割字符串
二、国际化概念
1、格式化固定文本 资源文件： 资源文件名_语言_国家.properties
语言：一般是2位小写字母构成。http://www.loc.gov/standards/iso639-2/englangn.html。 国家:一般是2位大写字母构成。http://www.iso.ch/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html。
语言和国家参考：ISO的规范 资源文件名---》基名 native2ascii.exe 将中文变成unicode编码
2、格式化日期时间 DateFormat:抽象类 样式： SHORT:12-11-8 上午10:44 MEDIUM:2012-11-8 10:44:25 DEFAULT:MEDIUM LONG:20xx年11月8日 上午10时44分08秒 FULL:20xx年11月8日 星期四 上午10时42分53秒 CST 把Date类型转换为String进行显示 String format(Date date) 把String转换成Date类型 Date parse(String str)
3、数字的格式化:Integer Float---->Number NumberFormat:抽象类 getCurrencyInstance() :货币 getPercentInstance() ：百分比格式 getIntegerInstance() :整数。阿拉伯数字世界通用 getNumberInstance() ：数字
把Number转换成String 把String转换成Number
4、批量格式化 MessageFormat
三、JSTL中的Fmt标签
四、过滤器的作用
1、对访问的资源进行拦截。类似“保安”
2、可以对请求、响应对象进行一些预处理。
五、过滤器的执行流程和开发步骤
1、编写步骤：
a、编写一个类，实现Filter接口
public class Demo1Filter implements Filter {
public void doFilter(ServletRequest request, ServletResponse response, } //过滤器初始化 public void init(FilterConfig filterConfig) throws ServletException { FilterChain chain) throws IOException, ServletException { System.out.println("Demo1Filter执行过滤了");
}
} } //过滤器销毁 public void destroy() {
b、在web.xml中进行配置，要拦截哪些资源
<filter> <filter-name>Demo1Filter</filter-name> <filter-class>com.itheima.filter.Demo1Filter</filter-class> </filter> <filter-mapping> <filter-name>Demo1Filter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
注:多个过滤器，是按照filter-mapping在web.xml中的先后顺序依次进行过滤的
2、过滤器是容器应用启动时就实例化了。且驻留内存。
六、简单案例：
1、解决form表单post提交方式的中文请求参数 2、控制所有动态资源不要缓存 3、控制静态资源缓存时间 4、实现用户的自动登录
七、过滤器高级配置
<dispatcher>
指定过滤器所拦截的资源被 Servlet 容器调用的方式，可以是REQUEST,INCLUDE,FORWARD和ERROR之一，默认REQUEST。用户可以设置多个<dispatcher> 子元素用来指定 Filter 对资源的多种调用方式进行拦截。
八、回顾包装设计模式
增强BufferedReader类中的readLine方法，加上行号。
九、过滤器高级案例
1、解决post、get中文请求参数乱码 2、过滤脏话 3、过滤html中特殊标记 4、全站压缩
day18
一、过滤器案例
1、过滤脏话 2、过滤html中特殊标记 3、全站压缩
二、综合案例：权限管理系统
拷贝jar包： jstl.jar standard.jar mysqldriver.jar commons-dbcp.jar commons-pool.jar
day19
一、文件上传的原理
1、文件上传的前提：
a、表单form：method取值必须是post；enctype取值必须是multipart/form-data(指示正文内容是使用MIME协议进行描述的)
b、必须提供<input type="file" name="f1"/>
小提示：
enctype="application/x-www-form-urlencoded"
正文中的内容：
username=admin&password=123
2、如果表单的enctype="multipart/form-data"，那么传统的request.getParameter(String param)方式就失效了。
3、enctype="multipart/form-data"描述正文的方式如下：
-----------------------------7dc167160938
Content-Disposition: form-data; name="username"
admin
-----------------------------7dc167160938
Content-Disposition: form-data; name="f1"; filename="C:\Documents and Settings\鐜嬫槶鐝絓妗岄潰\a.txt"
Content-Type: text/plain MIME类型
aaaaa
-----------------------------7dc167160938
Content-Disposition: form-data; name="f2"; filename="C:\Documents and Settings\鐜嬫槶鐝絓妗岄潰\b.txt"
Content-Type: text/plain
bbbbb
-----------------------------7dc167160938--
二、利用第三方组件进行文件上传入门
//得到DiskFileItemFactory：设置临时目录和缓存大小。可以使用默认的
//得到ServletFileUpload:文件上传组件（正文解析器）
//判断用户的表单是否是multipart/form-data类型的
//是：解析request，得到List<FileItem>
//判断FileItem：普通字段，打印出来；上传字段，把文件存到某个目录中
三、文件上传时要考虑的九大问题
1、上传文件名的中文乱码和表单数据的中文乱码（传统的设置编码无效）
a、普通字段的中文值： FileItem.getString("UTF-8"); b、文件名中文： 方式一：request.setCharacterEncoding("UTF-8"); 方式二：upload.setHeaderEncoding("UTF-8");
2、如何保证服务器的安全
把上传的文件放到用户无法直接访问到的地方。WEB-INF
3、多次上传同名文件的覆盖
把文件进行改名：保证文件名唯一。
方式一：
System.currentMill()+"_"+a.txt(乐观)
方式二：
UUID.randomUUID().toString()+"_"+a.txt
4、如何防止同一目录下文件太多的问题:分开目录分别存储 images 方式一：(乐观)
2012-11-11/a.txt把每天上传的文件放到一个日期的文件夹中
方式二：利用HashCode算法打散存储文件夹
images/dir1/dir2/a.txt
hashCode算法：
&0xf
0000 0000 0000 0000 0000 0000 0000 1111 ------------------------------------------------- 0000 0000 0000 0000 0000 0000 0000 1010 0110 0111 1010 1111 0101 0001 1100 1010
转换为整数：0~15 16个
>>4
0000 0000 0000 0000 0000 0000 0000 1100 ------------------------------------------------------------------- 0110 0111 1010 1111 0101 0001 1100 1010 &0xf0 0000 0000 0000 0000 0000 0000 1111 0000 ------------------------------------------------- 0000 0000 0000 0000 0000 0000 1100 0000
转换为整数：0~15 16个
-------------------------------------------------------------------
5、上传文件的大小控制(单个文件和总大小)，及如何友好提示用户 单个文件大小控制：
upload.setFileSizeMax(7 * 1024 * 1024); 提示：抓异常 FileUploadBase.FileSizeLimitExceededException
总文件大小控制：
upload.setSizeMax(10*1024*1024); 提示：抓异常 FileUploadBase.SizeLimitExceededException
6、超出10k的文件的临时文件的处理
fileupload默认情况下不会删除超过10K的临时文件。
手工删除： FileItem.delete();一定要在流关闭后再删除。
7、限制上传文件的类型
方式一：通过判断文件名的扩展名来限制文件上传的类型（不严格）
方式二：获取上传的文件的MIME类型，做限制和过滤
String type = item.getContentType();
if(!type.startsWith("image/"))
continue;
8、监听文件的上传进度
upload.setProgressListener(new ProgressListener() {
public void update(long pBytesRead, long pContentLength, int pItems) { //应该把该数据通过异步方式传给界面上：JavaScript XMLHttpRequest System.out.println("读到了：" +pBytesRead+",文件大小："+pContentLength+",第几项:"+pItems);
}); }
9、用户没有选择文件上传时的问题
if(fileName==null||"".equals(fileName.trim()))
continue;
四、文件的下载
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException { request.setCharacterEncoding("UTF-8"); response.setContentType("text/html;charset=UTF-8"); OutputStream out = response.getOutputStream(); String filename = request.getParameter("filename");//UUID文件名 if(filename==null||"".equals(filename.trim())){ } filename = new String(filename.getBytes("ISO-8859-1"),"UTF-8"); //算该文件的存放目录 String realPath = makeDirs(getServletContext().getRealPath("/WEB- out.write("文件不存在或者已经被删除".getBytes("UTF-8")); return; INF/images"), filename);
InputStream in = new FileInputStream(realPath+"\\"+filename); String oldName = filename.substring(filename.indexOf("_")+1); response.setHeader("Content-Disposition",
"attachment;filename="+URLEncoder.encode(oldName, "UTF-8"));
}
private String makeDirs(String storePath, String fileName) {
int hashCode = fileName.hashCode(); int dir1 = hashCode & 0xf;// 取hash吗的最低4位 产生16个随机 int dir2 = (hashCode & 0xf0) >> 4;// 取hash吗的5~8位 产生16个随机 int len = -1; byte b[] = new byte[1024]; while((len=in.read(b))!=-1){ } in.close(); out.write(b, 0, len);
} String path = storePath + "\\" + dir1 + "\\" + dir2; File file = new File(path); if (!file.exists()) file.mkdirs(); return path;
五、HTML的DOM编程：动态添加上传输入域
<body>
<form action="${pageContext.request.contextPath}/servlet/UploadServlet3" method="post" enctype="multipart/form-data">
收件人：<input type="text" name="to"/><br/>
主题： <input type="text" name="subject"/><br/>
附件:<a href="javascript:addAttachment()">添加附件</a>
<div id="d1"></div>
<br/><input type="submit" value="发送"/>
</form>
<script type="text/javascript">
function addAttachment(){
var divObj = document.getElementById("d1"); divObj.innerHTML = divObj.innerHTML+"<div><input type='file' name='f1'/><input type='button' onclick='remove(this)' value='删除'/></div>"; }
function remove(aObj){
var divObj = aObj.parentNode; divObj.parentNode.removeChild(divObj);
}
</script>
</body>
六、监听、事件源、事件（观察者设计模式）
七、Servlet规范中的8大监听器
1、如何注册监听器到事件源上
web.xml
<listener>
<listener-class>com.itheima.listener.ServletContextListenerDemo</listener-class> </listener>
2、8大监听器
监听对象：ServletContext、HttpSession、ServletRequest
-------------------------------------3个监听器，主要监听他们的创建和销毁
ServletContextListener
HttpSessionListener
ServletRequestListener
监听对象：ServletContext、HttpSession、ServletRequest的域（Map）
-------------------------------------3个监听器，主要监听他们的域中的变化：添加、替换了、删除了 ServletContextAttributeListener
HttpSessionAttributeListener：实现在线踢人案例。
ServletRequestAttributeListener
public void attributeAdded(ServletContextAttributeEvent scab) {
域中来了新同志
}
public void attributeRemoved(ServletContextAttributeEvent scab) {
同志牺牲了
}
public void attributeReplaced(ServletContextAttributeEvent scab) {
某个同志被替换了
}
感知型监听器：2个。不需要注册监听器。
HttpSessionActivationListener：感知自己何时被钝化、何时被活化。
HttpSessionBindingListener：感知自己何时被HttpSession绑了和解绑了
day20
一、JavaWeb大总结
day01~day19每天学习了哪些东东。
二、邮件的概念
三、邮件的用得到的协议
SMTP、POP、MIME(描述邮件内容的协议)
1、SMTP：Simple Message Transport Protocol发送邮件使用的协议。使用的端口是25
2、POP: Post Office Protocol接收邮件使用的协议。使用的端口是110
四、手工发送和接受邮件：Telnent
1、手工发邮件
itheima14@163.com向itheima14@163.com发送邮件。
telnet 25
//以下是SMTP协议规定的内容
ehlo xxx //向服务器打招呼
auth login //请求认证
aXRoZWltYTE0 //用户名：需要Base64编码
aWFtc29ycnk= //密码：需要Base64编码
mail from:<itheima14@163.com> //发件人邮箱
rcpt to:<itheima14@163.com> //收件人邮箱
data //标识邮件内容的开始
from:itheima14@163.com
to:itheima14@163.com
subject:test subject
xxxxxaaaaaayyyyyy
sdfdsfdsfds
. //邮件内容结束
quit //推出telnet命令
2、手工收邮件：POP
telnet 110
user itheima14
pass iamsorry
stat //返回邮箱的统计信息
list //返回某一封邮件的统计信息
retr //取某一封邮件的内容
五、RFC822规范。利用其漏洞冒充别人发邮件。 规定了邮件内容的格式：
头和正文：中间用空行分隔
冒充别人发邮件：
telnet localhost 25
ehlo xxx
auth login
bWluZ3l1ZQ==
MTIz
mail from:<mingyue@itheima.com>
rcpt to:<zhangxiao@itheima.com>
data
from:fengjie@itheima.com
to:zhangxiao@itheima.com
subject:亲爱打
今天晚上软件园小树林见。记得一定要0点哦。不见不散。你不要回复了，我的手机也没有电了，你直接去既可以了。
.
quit
六、如何创建邮件：JavaMail API
1、拷贝jar包：
mail.jar jaf.jar(Java Activation Framework)(JDK6+自带了) a、创建只有文本的邮件 b、创建既有文本又有图片的邮件。邮件中每一部分用BodyPart--->MimeBodyPart 两部分有关系：描述他们之间的关系related. 用Multipart描述各部分间的关系。 -----------------888ca Content-Type:text/html this is a <img src="cid:mm"/> beautiful girl. -----------------888ca Content-Type:images/jpg Content-ID:mm
skfdsjfdsfdslkfs -----------------888ca-- c、最复杂的邮件：既有文本，文本中嵌入图片，还有附件的邮件
七、邮件的中文乱码
文本内容中的中文
MimeBodyPart text = new MimeBodyPart();
text.setContent("这是美女aaa<img src='cid:mm'/>aaa", "text/html;charset=UTF-8");
附件文件名中的中文
attachment.setFileName(MimeUtility.encodeText(dh.getName()));
八、发送邮件
public static void main(String[] args) throws Exception {
Properties props = new Properties(); props.setProperty("mail.transport.protocol", "smtp"); props.setProperty("mail.host", ""); props.setProperty("mail.smtp.auth", "true"); Session session = Session.getDefaultInstance(props); session.setDebug(true); Transport ts = session.getTransport(); ts.connect("itheima14","iamsorry"); MimeMessage message = new MimeMessage(session); message.setFrom(new InternetAddress("itheima14@163.com")); message.setRecipients(Message.RecipientType.TO, "itheima14@163.com"); message.setSubject("这是一封只有文本的邮件"); message.setText("cccccccccccccccccccccc"); message.saveChanges(); ts.sendMessage(message, message.getAllRecipients()); ts.close();
day21
一、Tomcat管理javax.mail.Session
1、把JavaMail的jar包：mail.jar jaf.jar(jdk6-不含)拷贝到Tomcat\lib目录中
2、在应用的META-INF目录中，增加一个名为context.xml文件，并增加以下内容：
<?xml version="1.0" encoding="UTF-8"?>
<Context>
<Resource name="mail/Session" auth="Container"
type="javax.mail.Session"
mail.smtp.host="localhost"/>
</Context>
3、当容器启动时就会在JNDI容器中注册javax.mail.Session对象
我们只需要通过JNDI的API获取该对象的引用即可：
Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
Session session = (Session) envCtx.lookup("mail/Session");
注意：字节码有可能冲突。干掉应用中的mail.jar即可。
二、案例：用户注册发送激活验证码
1、搭建开发环境
jstl.jar standard.jar beanutils.jar commons-logging.jar mysqldriver.jar dbutils.jar dbcp.jar pool.jar mail.jar activation.jar(jaf)
三、考试
四、注解
1、注解的作用是什么？
替代配置文件的。
有了注解后，即使没有配置文件，也可以指挥程序运行。
2、JDK中有的基本注解
@Override：确实是重写了父类方法, 该注解只能用于方法
@Deprecated: 用于表示某个程序元素(类, 方法等)已过时
@SuppressWarnings: 抑制编译器警告
3、定义注解的语法：
class SomeClass定义类
@interface SomeAnnotation定义注解
4、定义注解中的属性：
类型只能是：8种基本类型、String、Class、注解类型、枚举类型及以上类型的一维数组。 定义属性的默认值：
String name() default "";
特殊属性：
注解中的属性名称为value的。在使用时直接传入值即可。
注解中的属性名称为value数组。在使用时直接传入值即可，传一个用"",多个{"",""}。
5、元注解：给注解用的注解称为元注解
@Retention：指示该注解存在的范围是什么？SOURCE、CLASS、RUNTIME @Target：指示能把该注解用到哪里？
五、Servlet3.0常用新特性。（Eclipse indigo）
1、Servlet3.0规范要运行在Tomcat7+,JDK6+
六、试题讲解
day22
一、Servlet3.0中的监听有关的注解和文件上传
二、综合案例：网上书店
1、立项：
项目的开发步骤：
1、需求分析：项目经理 需求规格说明书。
2、概要设计：确定主要的功能模块。采用的技术架构。人员。 概要设计说明书
3、详细设计：某一个小功能的具体设计。 详细设计说明书
4、程序设计
5、内测：aplpha 测试报告
6、公测：beta1 测试报告 客户签字。
7、正式版V1.0-release(GA)
8、试运行一个月
9、免费维护期：一年。 10%
编码步骤：
1、建立应用，拷贝jar包，建立类的目录
mysqldriver.jar
commons-dbcp.jar commons-pool.jar DbUtils.jar jstl.jar standard.jar Beanutils.jar commons-logging.jar commons-fileupload.jar commons-io.jar junit.jar
2、分类模块
create database day22; use day22; create table category( ); id varchar(100) primary key, name varchar(100) not null unique, description varchar(255)
3、图书模块
create table book( id varchar(100) primary key, name varchar(100) not null unique, author varchar(100) not null, price float(8,2) not null, description varchar(255), imagepath varchar(100),
); category_id varchar(100), constraint category_id_fk foreign key (category_id) references category(id)
day23
＋ 更多类似范文┣ JavaWeb总结 1400字
┣ java web总结 5900字
┣ java web认知(球球总结) 2400字
┣ java web 与jsp课程总结 1500字
┣ 更多javaweb总结