[Java面试三]JavaWeb基础知识总结.
时间： 01:34:20
&&&& 阅读：328
&&&& 评论：
&&&& 收藏：0
标签：1.web服务器与HTTP协议
l WEB，在英语中web即表示网页的意思，它用于表示Internet主机上供外界访问的资源。
l Internet上供外界访问的Web资源分为：
& 静态web资源（如html 页面）：指web页面中供人们浏览的数据始终是不变。
& 动态web资源：指web页面中供人们浏览的数据是由程序产生的，不同时间点访问web页面看到的内容各不相同。
l 静态web资源开发技术
l 常用动态web资源开发技术：
& JSP/Servlet、ASP、PHP等& ruby& python
& 在Java中，动态web资源开发技术统称为Javaweb，我们课程的重点也是教大家如何使用Java技术开发动态的web资源，即动态web页面。
但是我们做java开发，不是做网页。
网络上的资源分为两种
早期:静态页面&& html实现。&& 观看
现在:动态页面&& php asp jsp& 交互.
lamp =linux +apache+ mysql+php-----&个人网关或小型企业首选
asp现在没人用，但是网络上遗留下来的比较多。miscrosoft的技术
.net技术。
jsp---&java去做网页所使用的技术。jsp本质上就是servlet
使用jsp开发成本高。
BS====&浏览器+服务器&& 只要有浏览器就可以
CS-----&客户端+服务器.& 必须的在客户端安装程序.
现在基本上开发的都是BS程序
BS怎样通信:
必须有请求有响应。
有一次请求就应该具有一次响应，它们是成对出现的。
服务器介绍
大型服务器：websphere(IBM),weblogic(Oracle) J2EE容器 －
支持EJB (EnterPrice Java Bean (企业级的javabean)) & Spring
weblogic BEA公司产品，被Oracle收购，全面支持JavaEE规范，收费软件，企业中非常主流的服务器 -------- 网络上文档非常全面
WebSphere 文档非常少，IBM公司产品，价格昂贵，全面支持JavaEE 规范
Tomcat- apache，开源的。Servlet容器。
tomcat 开源小型web服务器 ，完全免费，主要用于中小型web项目，只支持Servlet和JSP 等少量javaee规范 ，Apache公司jakarta 一个子项目
Jboss & hibernate公司开发。不是开源免费。J2EE容器
Tomcat安装
注意路径中不要包含空格与中文。
&O 安装步骤
1、tomcat.apache.org 下载tomcat安装程序
Tomcat7安装程序 ---- zip免安装版
2、解压tomcat
3、配置环境变量 JAVA_HOME 指向JDK安装目录& D:\Program Files\Java\jdk1.6.0_21
*CATALINA_HOME指定tomcat安装目录
4、双击tomcat/bin/startup.bat
5、在浏览器中 输入 localhost:8080 访问tomcat主页了
&O 注意问题：
启动黑色不能关闭
1、CATALINA_HOME 指定tomcat安装位置 --- 可以不配置
2、JAVA_HOME 指定JDK安装目录，不要配置bin目录，不要在结尾加;
3、端口被占用
netstat -ano 查看占用端口进程pid
任务管理器 查看---选择列 显示pid -- 根据pid结束进程
* 有些进程无法关系（系统服务 --- 必须结束服务） win7 自带 World wide web publish IIS服务 默认占用端口80
* xp 安装apache服务器后，会占用80 端口 ，关闭apache服务
通过运行 services.msc 打开服务窗口 关闭相应服务
tomcatc目录结构
-----bin&&& 它里面装入的是可执行的命令 如 startup.bat
-----conf&&& 它里面是一个相关的配置文件，我们可以在里面进行例如端口，用户信息的配置
&Connector port="80" protocol="HTTP/1.1"
&&&&&&&&&&&&&& connectionTimeout="20000"
&&&&&&&&&&&&&& redirectPort="8443" /&
-----lib&&&& tomcat类库。
-----logs&&& tomcat 日志文件
-----temp&&& 临时文件
-----webapps& 它里面放的是的 web site(web项目)
-----work&&&& 存放的是页面(例如 jsp)转换成的.class文件。
2.创建网站，将网站发布到tomcat服务器上
创建网站根目录
在根目录下 创建静态web资源和动态web资源
& ---- *.html *.css *.js 图片 音频 视频 、*.jsp
& ---- WEB-INF目录 存放java程序和配置文件
&&&&&&&&& --- classes 存放.class文件
&&&&&&&&& --- lib 存放.jar 文件
&&&&&&&&& --- web.xml 网站核心配置文件
*** 如果静态网站可以不存在 WEB-INF目录的 ，WEB-INF目录，客户端无法直接访问（在服务器内存通过程序访问）
将网站发布到tomcat -----------虚拟目录映射
虚似目录的映射方式有三种
1.在开发中应用的比较多& 直接在webapps下创建一个自己的web site就可以.
步骤 1.在webapps下创建一个myweb目录
&&&& 2.在myweb下创建WEB-INF目录，在这个目录下创建web.xml
&&&& 3.将web.xml文件中的xml声明与根元素声明在其它的web site中copy过来。
&&&& 4.在myweb下创建一个index.html文件
&&&& 5.启动tomcat
&&&& 6.在浏览器中输入& http://localhost/myweb/index.html
以下两种方式，可以将web site不放置在tomcat/webapps下，可以任意放置
2.在server.xml文件中进行配置
&Context path="/abc"& docBase="C:\myweb1"/&
&& &/Host&
在Host结束前配置
path：它是一个虚拟路径，是我们在浏览器中输入的路径
docBase：它是我们web sit的真实路径
http://localhost/abc/index.html
3.不在server.xml文件中配置
而是直接创建一个abc.xml文件
在这个xml文件中写
&Context path=""& docBase="C:\myweb1"/&
将这个文件放入conf\Catalina\localhost
&&& http://localhost/abc/index.html
3.生成war文件
war文件是web项目的压缩文件。
要想生成，先将要压缩的内容压缩成zip文件，
然后将后缀改成war就可以，
war文件可以直接在服务器上访问。
关于tomcat-manager
可以在conf/tomcat-users.xml中进行用户信息添加
&role rolename="manager"/&
&user username="xxx" password="xx" roles="manager"/&
这样就添加了一个用户
注意，用户权限要是比较大的话，会出现安全问题.
4.虚拟主机
做自己的一个http://www.baidu.com
1.访问一个网站的过程
http://www.baidu.com
http&& 协议
www& 服务器
.baidu.com 域名& IP
1.上网将baidu首页下载下来
2.做一个自己的web& site 首页就是下载下来的页面。
& 别忘记创建WEB-INF在它下面的web.xml文件中
&& &welcome-file-list&
&welcome-file&index.html&/welcome-file&
&/welcome-file-list&
这句话的作用是默认访问页面是index.html
3.在tomcat中的conf文件夹下的server.xml中修改
&Host name="www.baidu.com"& appBase="c:\baidu"
&&& unpackWARs="true" autoDeploy="true"
&&& xmlValidation="false" xmlNamespaceAware="false"&
&Context path="" docBase="c:\baidu"/&
4.在windows/system32/drivers/etc/hosts中添加
127.0.0.1&& www.baidu.com
&&& 目的是当访问www.baidu.com时其实访问的是本机。
5.打开浏览器在地址栏中输入www.baidu.com
& 这时其时访问的是我们自己
& web site中的页面。
5.使用myeclipse创建web project与tomcat集成
我们在myeclipse中创建web project有一个WebRoot目录。
但是我们发布到tomcat中没有这个，它其时就是我们工程的名称.
1.创建web工程
2.在eclipse中配置tomcat服务器
window/属性/myeclipse/service中配置自己的tomcat目录.
注意到tomcat根目录就可以了。不要到bin中。
如果不好使用，看一些jdk是否配置.
1. 将webproject部署到tomcat中
6.HTTP协议
HTTP是hypertext transfer protocol（超文本传输协议）的简写，它是TCP/IP协议的一个应用层协议，用于定义WEB浏览器与WEB服务器之间交换数据的过程。
HTTP协议是学习JavaWEB开发的基石，不深入了解HTTP协议，就不能说掌握了WEB开发，更无法管理和维护一些复杂的WEB站点。
telnet怎样使用
&& 1.telnet localhost 8080
&& 2 ctrl+]
&& 3.按回车
&& 注意 在里面写错的内容不能修改
&& GET& /index.html HTTP/1.1
&& host:localhost
&& 4.要敲两次回车
HTTP/1.0版本只能保持一次会话
HTTP/1.1版本可能保持多次会话.
&& 是根据telnet得到的响应信息
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
ETag: W/"416000"
Last-Modified: Thu, 19 Jul :16 GMT
Content-Type: text/html
Content-Length: 7347
Date: Thu, 25 Apr :53 GMT
Connection: close
&?xml version="1.0" encoding="ISO-8859-1"?&
&!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
&& "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"&
&html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"&
&&& &title&Apache Tomcat&/title&
&&& &style type="text/css"&
..........
是根据httpwatch得到的请求信息与响应信息
&&&&&&& GET / HTTP/1.1
Accept: application/x-shockwave-flash, image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*
Accept-Language: zh-cn
User-Agent: Mozilla/4.0 ( MSIE 8.0; Windows NT 5.1; Trident/4.0)
Accept-Encoding: gzip, deflate
Host: localhost
Connection: Keep-Alive
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
ETag: W/"416000"
Last-Modified: Thu, 19 Jul :16 GMT
Content-Type: text/html
Content-Length: 7347
Date: Thu, 25 Apr :57 GMT
&?xml version="1.0" encoding="ISO-8859-1"?&
&!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
&& "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"&
&html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang
请求信息详解
GET /books/java.html HTTP/1.1&& ----------&请求行
Get是请求方式&&& /books/java.html 请求资源&& HTTp/1.1协议版本
POST与GET的区别
1.什么样是GET 请求&&& 1)直接在地址栏输入& 2.超连接 &a&&/a&& 3.form表单中method=get
什么样是POSt请求&& form表单中method=POST
2.以get方式提交请求时，在请求行中会将提交信息直接带过去
格式 /day03_1/login?username=tom&password=123
以post方式提交时，信息会在正文中。
POST /day03_1/login HTTP/1.1
Accept: application/x-shockwave-flash, image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*
Referer: http://localhost/day03_1/login.html
Accept-Language: zh-cn
User-Agent: Mozilla/4.0 ( MSIE 8.0; Windows NT 5.1; Trident/4.0)
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
Host: localhost
Content-Length: 25
Connection: Keep-Alive
Cache-Control: no-cache
username=tom&password=123
3. get方式最多能提交1kb
&& post可以提交大数据，做上传时必须是post
Accept: */*&&& 允许访问mime类型,类型都在tomcat 的conf/web.xml文件中定义了。
&&&&&&&&&&&&&&& 这个需要知道，因为做下载时要知道mime类型
Accept-Language: en-us 客户端的语言
Connection: Keep-Alive 持续连接
Host: localhost&& 客户端访问资源
Referer: http://localhost/links.asp (重点)& 防盗链。&
User-Agent: Mozilla/4.0&&&& 得到浏览器版本 避免兼容问题
Accept-Charset: ISO-8859-1&& 客户端字符编码集
Accept-Encoding: gzip, deflate&&& gzip是压缩编码.
If-Modified-Since: Tue, 11 Jul :51 GMT& 与Last-MOdified一起可以控制缓存。
Date: Tue, 11 Jul :51 GMT
防盗链程序
referer.htm页面
&a href="referer"&referer&/a&
RefererServlet类似
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String msg = request.getHeader("Referer");
if (msg != null && "http://localhost/day03_1/referer.html".equals(msg)) {
// 如果你是正常访问,我们给其一个友好信息
response.getWriter().write("hello");
// 如果是盗链过来的，对不。骂它一句
response.getWriter().write("fuck...");
URL url = new URL("http://localhost/day03_1/referer"); //得到一个url
URLConnection con = url.openConnection();&& //访问这个url，并获得连接对象
con.addRequestProperty("Referer",
"http://localhost/day03_1/referer.html");
InputStream is = con.getInputStream(); // 读取服务器返回的信息.
byte[] b = new byte[1024];
int len = is.read(b);
System.out.println(new String(b, 0, len));
http协议响应
HTTP/1.1 200 OK 响应状态行
HTTP/1.1& 200& OK
1xx 什么都没做直接返回
2xx 成功返回
3xx 做了一些事情，没有全部完成。&
4xx 客户端错误
5xx 服务器错误
302& 重定向
304& 页面没有改变
404& 未找到页面
500& 服务器出错.
Location: http://www.it315.org/index.jsp&& 响应路径(重点)+302
Server:apache tomcat
Content-Encoding: gzip&& 响应编码& gzip 压缩
Content-Length: 80&&& 响应长度
Content-Language: zh-cn&& 响应语言
Content-Type: text/ charset=GB2312& 响应字符编码
Last-Modified: Tue, 11 Jul :51 GMT&& 要与请求中的 If-Modified-Since处理缓存
Refresh: 1;url=http://www.it315.org&&& 自动跳转
Content-Disposition: filename=aaa.zip (重要) 文件的下载
//下面三个是禁用浏览缓存
Expires: -1
Cache-Control: no-cache&
Pragma: no-cache&&
Connection: close/Keep-Alive&&
Date: Tue, 11 Jul :51 GMT
今天可以讲
Location: http://www.it315.org/index.jsp&& 响应路径(重点)+302
Last-Modified: Tue, 11 Jul :51 GMT&& 要与请求中的 If-Modified-Since处理缓存
Refresh: 1;url=http://www.it315.org&&& 自动跳转
我们在得到响应信息，经常得到的是压缩后的。
1.服务器配置方式
tomcat配置实现压缩
80端口没有配置& 00:00:00.000 0.228 7553 GET 200 text/html http://localhost/
8080端口配置&&& 00:00:00.000 0.027 2715 GET 200 text/html http://localhost:8080/
&Connector port="8080" protocol="HTTP/1.1"
&&&&&& connectionTimeout="20000"
&&&&&& redirectPort="8443" compressableMimeType="text/html,text/xml,text/plain" compression="on"/&
2.通过我们编程实现.(后面会讲)
Content-Disposition: filename=aaa.zip (重要) 文件的下载
//下面三个是禁用浏览缓存
Expires: -1
Cache-Control: no-cache&
Pragma: no-cache&&
4.启动服务器
5.在浏览器中访问web资源.
什么是Servlet
l Servlet是一个功能，如果你希望你的项目功能多一些，那就要多写一此Servlet；
l Servlet是JavaWeb三大组件之一，也是最重要的组件！
&O 三大组件：Servlet、Filter、Listener
l Servlet是一个我们自定义的Java类，它必须要实现javax.servlet.Servlet接口。
l Servlet是动态资源！
l Servlet必须在web.xml中进行配置后，才能被访问。（把Servlet与一个或多个路径绑定在一起）
如何实现Servlet
l 实现Servlet有三种方式：
&O 实现Servlet接口；
&O 继承GenericServlet类；
&O 继承HttpServlet类（最佳选择）。
3 Servlet的helloworld项目
3.1 手动完成
3.2 MyEclipse完成
4 Servlet的生命周期
4.1 生命周期相关方法
l Servlet接口中一共是5个方法，其中有三个是生命周期方法。
&O void init(ServletConfig)：这个方法会在Servlet被创建后，马上被调用。只会被调用一次！我们可以把一些初始化工作放到这个方法中，如果没有什么初始化工作要做，那么这个方法就空着就可以了。
² Servlet有两个时间点会被创建：一是在第一次被请求时，会被创建；二是Tomcat启动时被创建，默认是第一种，如果希望在tomcat启动时创建，这需要在web.xml中配置。
&O void destroy()：这个方法会在Servlet被销毁之前被调用。如果你有一些需要释放的资源，可以在这个方法中完成，如果没有那么就让这个方法空着。这个方法也只会被调用一次！
² Servlet轻易不会被销毁，通常会在Tomcat关闭时会被销毁。
&O void service(ServletRequest,ServletResponse)：它会在每次被请求时调用！这个方法会被调用0~N次。
&O String getServletInfo()：它不是生命周期方法，也就是说它不会被tomcat调用。它可以由我们自己来调用，但我们一般也不调用它！你可以返回一个对当前Servlet的说明性字符串。
&O ServletConfig getServletConfig()：这个方法返回的是ServletConfig，这个类型与init()方法的参数类型相同。它对应的是web.xml中的配置信息，即&servlet&
4.2 ServletConfig、ServletContext、ServletRequest、ServletResponse
l ServletRequest：封装了请求信息；
l ServletResposne：用于向客户端响应；
l ServletContext：它可以在多个Servlet中共享数据。
l ServletConfig：它与&servlet&对应！
&O 在&servlet&中可以配置&init-param&，即初始化参数，可以使用ServletConfig的getInitParameter(String)，方法的参数是初始化参数名，方法的返回值是初始化参数值。
&O getInitParameterNames()，该方法返回一个Enumeration对象，即返回所有初始化参数的名称。
&O String getServletName()，它返回的是&servlet-name&元素的值
&O ServletContext getServletContext()，它可以获取Servlet上下文对象。
5 GenericServlet
l 它代理了ServletConfig的所有功能。所有使用ServletConfig才能调用的方法，都可以使用GenericServlet的同名方法来完成！
l 不能覆盖父类的init(ServltConfig)方法，因为在父类中该方法内完成了this.config=config，其他的所有ServletConfig的代理方法都使用this.config来完成的。一旦覆盖，那么this.config就是null。
l 如果我们需要做初始化工作，那么可以去覆盖GenericServlet提供的init()方法。
6 HttpServlet
l 它提供了与http协议相关的一些功能。
l 只需要去覆盖doGet()或doPost()即可。这两个方法，如果没有覆盖，默认是响应405！
7 Servlet细节
7.1 Servlet单例、线程不案例
l Servlet是的单例的。所以一个Servlet对象可能同时处理多个请求；
l Servlet不是线程安全的。
&O 尽可能不创建成员变量，因为成员变量多个线程会共享！
&O 如果非要创建，那么创建功能性的，只读！
7.2 Servlet的创建时间：第一次被请求、启动创建
* Servlet可以在第一次请求时被创建，还可以在容器启动时被创建。默认是第一次请求时！
& * 在&servlet&添加一个&load-on-startup&大于等于0的整数&/load-on-startup&
* 如果有多个Servlet在容器启动时创建，那么&load-on-startup&的值就有用了，创建的顺序使用它的值来排序！
7.3 &url-pattern&的配置
l &url-pattern&中可以使用&*&表示所有字符，但它不匹配&/&。它的使用要求：
&O 它要么在头，要么在尾。不能在中间；
&O 如果不使用通配符，那么必须使用&/&开头。
l 如果一个访问路径，匹配了多个&url-pattern&，那么谁更加明确就匹配谁。
7.4 web.xml的继承
l 每个项目都有一个web.xml，但tomcat下也有一个web.xml，在${CATALINA_HOME}\conf\web.xml
l conf\web.xml是所有项目的web.xml父文件，父文件中的内容等于同写在子文件中。
ServletContext
Servlet三大域对象：
l ServletContext：范围最大，应用范围！
l HttpSession ：会话范围！
l HttpServletRequest：请求范围！
域对象之一
域对象都有存取功能：
setAttribute(&attrName&, attrValue );//put
Object attrValue = getAttribute(&attrName&);//get
removeAttribute(&attrName&);//remove
1 ServletContext的作用
l 存取域属性，ServletContext是一个域对象；
l 可以用来获取应用初始化参数；
l 获取资源
ServletContext的生命周期
l ServletContext在容器启动时就被创建了；
l ServletContext在容器关闭时才会死！
l 一个项目只有一个ServletContext对象。
3 获取ServletContext
l 通过ServletConfig的getServletContext()方法来获取！
&O ServletConfig是init()方法的参数，那只能在init()方法中获取了；
&O GenericServlet代理了ServletConfig的所有方法，而且还提供了getServletConfig()，所以在GenericServlet的子类中可以使用如下方式来获取ServletContext对象：
² this.getServletContext()
² this.getServletConfig().getServletContext()
&O HttpSession也有这个方法，session.getServletContext()。
4 域对象：ServletContext
l void setAttribute(String name, Object value)：存储属性；
l Object getAttribute(String name)：获取属性；
l void removeAttribute(String name)：移除属性；
l Enumeration getAttributeNames()：获取所有属性名称；
5 获取初始化参数
一个 项目不只是可以配置servlet的初始化参数，还可以配置应用初始化参数
下面就是在web.xml中配置应用的初始化参数，这些参数需要使用ServletContext来获取
&context-param&
&param-name&p1&/param-name&
&param-value&v1&/param-value&
&/context-param&
&context-param&
&param-name&p2&/param-name&
&param-value&v2&/param-value&
&/context-param&
l String getInitParameter(String name)：通过参数名获取参数值；
l Enumeration getInitParameterNames()：获取所有参数的名称；
6 获取资源
l 获取真实路径：getRealPath(String path)：路径必须以&/&开头！它相对当前项目所在路径的。
l 获取指定路径下的所有资源路径：Set set = sc.getResourcePaths(&/xxx&)
l 获取资源流：InputStream in = sc.getResourceAsStream(&/xxx&)
7 Class和ClassLoader获取资源
User.class如何变成Class&User&的呢，由ClassLoader完成的！把硬盘上的User.class加载到内存，变成Class对象。
使用它们获取资源流！它们相对类路径（classpath）
request&response 对象
1. response简介
l response的类型为HttpServletResponse，它是Servlet的service()方法的参数。
l 当客户端发出请求时，tomcat会创建request和rsponse来调用Servlet的service()方法，每次请求都会创建新的request和response。
l response是用来向客户端完成响应。
2 response的两个流，用来响应正文
l response.getWriter() ，返回值为PrintWriter，用响应字符数据。
l response.getOutputStream()，返回值为ServletOutputStream，用来响应字节数据。
l 在一个请求范围内，这两个流不能同时使用！不然会输出非法状态异常。
3 response字符流的编码问题
l response的字符流默认使用ISO-8859-1编码，可以使用response.setCharaceterEncoding(&utf-8&)来设置编码；
l 浏览器在没有得到Content-Type头时，会使用GBK来解读字符串，当如果你设置了Content-Type，会使用你指定编码来解读字符串。response.setContentType(&html/charset=utf-8&);
4 response字符流的缓冲区
l response字符流缓冲区大小为8KB；
l 可以调用response.getWriter().flush()方法完成刷新，这会把当前缓冲区中的数据发送给客户端。
l 当response一旦开始了发送，那么response的内部会有一个提交状态为true。可以调用response的isCommitted()方法来查看当前的提交状态。
5 自动刷新
l 有一个响应头：Refresh，它的作用是在指定的时间后，自动重定向到指定路径。例如：response.setHeader(&Refresh&, &5;URL=http://www.baidu.com&);，表示在5秒后自动跳转到百度。
6 设置状态码
l response.sendError(404, &没找到您访问的资源&)
l response.sendStatus(302);
l 重定向：两个请求。
&O 第一个请求，服务器响应码：302
&O 第一个请求的响应头有一个Location头，它说明了要重定向的URL；
&O 第二个请求，浏览器重新向Location头指定的URL发出。
l 重定向：可以重定向到本项目之外的页面。例如可以重定向到百度！
l 重定向：可以重定向到本项目内的其他资源，可以使用相对路径，以&/项目名&开头
l 重定向：会使浏览器的地址栏发生变化！
注意事项：
l 当response为以提交状态，就不能再重定向了！
l 当使用了response的输出流响应后，再重定向。如果没有造成response提交，那么说明数据还在缓冲区中，tomcat会把缓冲区清空，然后重定向。
post请求方式
l 有主体（正文）
l 有Content-Type，表示主体的类型，默认值为application/x-www-form-urlencoded；
2 request功能：
l 可以获取请求方式：String getMethod()
l 可以获取请求头：String getHeader(String name)
l 可以获取请求参数（包含主体或路径后面的参数）：String getParameter(String name)
3 请求编码
l 地址栏的参数是GBK的；
l 在页面中点击链接或提交表单，参数都由当前页面的编码来决定，而页面的编码由当初服务器响应的编码来决定。
l 服务器请求form.html，服务器响应utf-8的页面给浏览器，然后在form.html页面上点击链接和提交表单发送的参数都是utf-8。
l 如果服务器的所有页面都是utf-8的，那么只要不在浏览器的地址栏中给出中文，那么其他的参数都是utf-8的。
l 服务器默认使用ISO-8859-1来解读请求数据。(tomcat7以前是这个编码)
l 可以使用request.setCharacterEncoding(&utf-8&)设置编码来解读请求参数。这个方法只对请求主体有效，而GET请求没有主体。说白了就是只对POST请求有效！
l 设置Tomcat 其中GET请求的默认编码：
&&& &Connector port="8080" protocol="HTTP/1.1"
&&&&&&&&&&&&&& connectionTimeout="20000"
&&&&&&&&&&&&&& redirectPort="8443" URIEncoding="UTF-8"/&
l 因为编码的设置不能依赖tomcat的配置，所以还是需要我们自己手动转码
&O String name = request.getParamter(&username&);//使用默认的iso来解码
&O byte[] bytes = name.getBytes(&iso-8859-1&);//使用iso回退到字节数组
&O name = new String(bytes, &utf-8&);//重新使用utf-8来解码
4 获取参数（详细）
l *String getParameter(String name) ：通过参数名称获取参数值！
l String[] getParameterValues(String name)：通过参数名称获取多个参数值！一般复选框会出现一个名称多个值的情况。
l *Map&String,String[]& getParameterMap()：获取所有参数，封装到Map中，基参数名为key，参数值为value。
l Enumeration getParameterNames()：获取所有参数的名称
5& request是Servlet三大域对象之
l void setAttribute(String name,Object value)
l Object getAttribute(String name)
l void removeAttribute(String name)
request 的存储范围：整个请求链！如果一个请求经过了多个Servlet，那么这些Servlet可以共享request域！
6 request获取头信息
l String getHeader(String name)：通过头名称，获取头信息；
l Enumeration getHeaderNames() ：获取所有头的名称；
l Enumeration getHeaders(String name)：通过头名称，获取多个头信息；
l int getIntHeader(String name)：通过头名称，获取头信息，本方法再把String的头信息转换成int类型。
7 reuqest的请求转发
如何请求转发
l 一个请求内经过多个资源（Servlet，还有jsp，而且经常是jsp）
l 请求转发需要使用RequestDispatcher的forward(HttpServletRequest,HttpServletResponse)
l RequestDispatcher rd = request.getRequestDispatcher(&/BServlet&);//参数是要转发的目标
l rd.forward(request,response);//转发到BServlet
其实你可以理解成在一个Servlet中，调用另一个Servlet的service()方法。
请求转发的注意事项
l 在第一个Servlet中可以使用request域保存数据，在第二个Servlet中可以使用request域获取数据。因为这两个Servlet共享同一个request对象。
l 在转发语句之后，其他语句是否会执行？答案是&可以&！
l 不能在一个Servlet中即重定向，又转发。
请求转发与重定向比较
l 请求转发后，地址栏中的地址不变！重定向变
l 请求转发是一个请求，重定向是两个请求；
l 请求转发可以共享request域，而重定向因为是两个请求，所以不能共享request。
l 一个请求，只有一个请求方式！所以转发后还是原来的请求方式，如果一开始发出的是GET，那么整个请求都是GET！重定向不同，因为是多个请求，第一个无论是什么方式，第二个请求都是GET。
l 请转转发只能是本项目中的资源，而重定向可以其他项目。
如果要转发，就不要输出
l 如果输出到缓冲区的数据，没有提交，那么在转发时，缓冲区会被清空，如果已经提交，那么在转发时抛出异常。这一点与重定向相同！
l 留头不留体：在第一个Servlet中设置头没问题，会保留到下一个Servlet。如果在第一个Servlet中输出数据，即设置响应体，那么如果没有提交，就被清空，如果已提交，就出异常。
8 请求包含
请求包含：
l RequestDispatcher rd = request.getRequestDispatcher(&/BServlet&);
l rd.include(request,response);
留头又留体！
客户端路径：
1. 超链接：href=&/项目名/&&
2. 表单：action=&/项目名/&&
3. response.sendRedirect(&/项目名/&&);
如果客户端路径，没有已&/项目名&开头，那么相对的是当前页面所在路径。
例如：http://localhost:8080/day10_3/a.html，当前页面所在路径是http://localhost:8080/day10_3/
以&/&开头的客户端路径相对&http://localhost:8080&，&a href=&/hello/AServlet&&
服务器端路径：
转发：必须使用&/&开头，它相对当前项目，即http://localhost:8080/day10_3
包含：同上；
&url-pattern&：同上
ServletContext.getRealPath(&/a.jpg&)：它是真对真实路径，相对当前WebRoot
ServletContext.getResourceAsStream()：同上
Class.getResourceAsStream()：如果使用&/&开头，相对classes，如果不使用&/&，相对当前.class文件所在目录。
ClassLoader. getResourceAsStream()：无论使用不使用&/&开头，都相对classes
作用：为了在客户端与服务器之间传递中文！
把中文转换成URL编码：
&O 首先你需要选择一种字符编码，然后把中文转换成byte[]。
&O 把每个字节转换成16进制，前面添加上一个&%&。它不能显负号，把得到的byte先加上128，这样-128就是0了。正的127就是255了，它的范围是%00~%FF
会话跟踪技术Cookie &session
1 什么是会话跟踪技术
我们需要先了解一下什么是会话！可以把会话理解为客户端与服务器之间的一次会晤，在一次会晤中可能会包含多次请求和响应。例如你给10086打个电话，你就是客户端，而10086服务人员就是服务器了。从双方接通电话那一刻起，会话就开始了，到某一方挂断电话表示会话结束。在通话过程中，你会向10086发出多个请求，那么这多个请求都在一个会话中。
在JavaWeb中，客户向某一服务器发出第一个请求开始，会话就开始了，直到客户关闭了浏览器会话结束。
在一个会话的多个请求中共享数据，这就是会话跟踪技术。例如在一个会话中的请求如下：
l 请求银行主页；
l 请求登录（请求参数是用户名和密码）；
l 请求转账（请求参数与转账相关的数据）；
l 请求信誉卡还款（请求参数与还款相关的数据）。
在这上会话中当前用户信息必须在这个会话中共享的，因为登录的是张三，那么在转账和还款时一定是相对张三的转账和还款！这就说明我们必须在一个会话过程中有共享数据的能力。
2 会话路径技术使用Cookie或session完成
我们知道HTTP协议是无状态协议，也就是说每个请求都是独立的！无法记录前一次请求的状态。但HTTP协议中可以使用Cookie来完成会话跟踪！
在JavaWeb中，使用session来完成会话跟踪，session底层依赖Cookie技术。
1 Cookie概述
1.1 什么叫Cookie
Cookie翻译成中文是小甜点，小饼干的意思。在HTTP中它表示服务器送给客户端浏览器的小甜点。其实Cookie就是一个键和一个值构成的，随着服务器端的响应发送给客户端浏览器。然后客户端浏览器会把Cookie保存起来，当下一次再访问服务器时把Cookie再发送给服务器。
Cookie是由服务器创建，然后通过响应发送给客户端的一个键值对。客户端会保存Cookie，并会标注出Cookie的来源（哪个服务器的Cookie）。当客户端向服务器发出请求时会把所有这个服务器Cookie包含在请求中发送给服务器，这样服务器就可以识别客户端了！
1.2 Cookie规范
l Cookie大小上限为4KB；
l 一个服务器最多在客户端浏览器上保存20个Cookie；
l 一个浏览器最多保存300个Cookie；
上面的数据只是HTTP的Cookie规范，但在浏览器大战的今天，一些浏览器为了打败对手，为了展现自己的能力起见，可能对Cookie规范&扩展&了一些，例如每个Cookie的大小为8KB，最多可保存500个Cookie等！但也不会出现把你硬盘占满的可能！
注意，不同浏览器之间是不共享Cookie的。也就是说在你使用IE访问服务器时，服务器会把Cookie发给IE，然后由IE保存起来，当你在使用FireFox访问服务器时，不可能把IE保存的Cookie发送给服务器。
1.3 Cookie与HTTP头
Cookie是通过HTTP请求和响应头在客户端和服务器端传递的：
l Cookie：请求头，客户端发送给服务器端；
&O 格式：Cookie: a=A; b=B; c=C。即多个Cookie用分号离开；
l Set-Cookie：响应头，服务器端发送给客户端；
&O 一个Cookie对象一个Set-Cookie：
Set-Cookie: a=A
Set-Cookie: b=B
Set-Cookie: c=C
1.4 Cookie的覆盖
如果服务器端发送重复的Cookie那么会覆盖原有的Cookie，例如客户端的第一个请求服务器端发送的Cookie是：Set-Cookie: a=A；第二请求服务器端发送的是：Set-Cookie: a=AA，那么客户端只留下一个Cookie，即：a=AA。
1.5 Cookie第一例
我们这个案例是，客户端访问AServlet，AServlet在响应中添加Cookie，浏览器会自动保存Cookie。然后客户端访问BServlet，这时浏览器会自动在请求中带上Cookie，BServlet获取请求中的Cookie打印出来。
AServlet.java
package cn.itcast.
import java.io.IOE
import java.util.UUID;
import javax.servlet.ServletE
import javax.servlet.http.C
import javax.servlet.http.HttpS
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
* 给客户端发送Cookie
* @author Administrator
public class AServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/charset=utf-8");
String id = UUID.randomUUID().toString();//生成一个随机字符串
Cookie cookie = new Cookie("id", id);//创建Cookie对象，指定名字和值
response.addCookie(cookie);//在响应中添加Cookie对象
response.getWriter().print("已经给你发送了ID");
BServlet.java
package cn.itcast.
import java.io.IOE
import javax.servlet.ServletE
import javax.servlet.http.C
import javax.servlet.http.HttpS
import javax.servlet.http.HttpServletR
import javax.servlet.http.HttpServletR
* 获取客户端请求中的Cookie
* @author Administrator
public class BServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/charset=utf-8");
Cookie[] cs = request.getCookies();//获取请求中的Cookie
if(cs != null) {//如果请求中存在Cookie
for(Cookie c : cs) {//遍历所有Cookie
if(c.getName().equals("id")) {//获取Cookie名字，如果Cookie名字是id
response.getWriter().print("您的ID是：" + c.getValue());//打印Cookie值
2 Cookie的生命
2.1 什么是Cookie的生命
Cookie不只是有name和value，Cookie还是生命。所谓生命就是Cookie在客户端的有效时间，可以通过setMaxAge(int)来设置Cookie的有效时间。
l cookie.setMaxAge(-1)：cookie的maxAge属性的默认值就是-1，表示只在浏览器内存中存活。一旦关闭浏览器窗口，那么cookie就会消失。
l cookie.setMaxAge(60*60)：表示cookie对象可存活1小时。当生命大于0时，浏览器会把Cookie保存到硬盘上，就算关闭浏览器，就算重启客户端电脑，cookie也会存活1小时；
l cookie.setMaxAge(0)：cookie生命等于0是一个特殊的值，它表示cookie被作废！也就是说，如果原来浏览器已经保存了这个Cookie，那么可以通过Cookie的setMaxAge(0)来删除这个Cookie。无论是在浏览器内存中，还是在客户端硬盘上都会删除这个Cookie。
2.2 浏览器查看Cookie
下面是浏览器查看Cookie的方式：
l IE查看Cookie文件的路径：C:\Documents and Settings\Administrator\Cookies；
l FireFox查看Cooke：
l Google查看Cookie：
2.3 案例：显示上次访问时间
l 创建Cookie，名为lasttime，值为当前时间，添加到response中；
l 在AServlet中获取请求中名为lasttime的Cookie；
l 如果不存在输出&您是第一次访问本站&，如果存在输出&您上一次访问本站的时间是xxx&；
AServlet.java
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/charset=utf-8");
Cookie cookie = new Cookie("lasttime", new Date().toString());
cookie.setMaxAge(60 * 60);
response.addCookie(cookie);
Cookie[] cs = request.getCookies();
String s = "您是首次访问本站！";
if(cs != null) {
for(Cookie c : cs) {
if(c.getName().equals("lasttime")) {
s = "您上次的访问时间是：" + c.getValue();
response.getWriter().print(s);
3 Cookie的path
3.1 什么是Cookie的路径
现在有WEB应用A，向客户端发送了10个Cookie，这就说明客户端无论访问应用A的哪个Servlet都会把这10个Cookie包含在请求中！但是也许只有AServlet需要读取请求中的Cookie，而其他Servlet根本就不会获取请求中的Cookie。这说明客户端浏览器有时发送这些Cookie是多余的！
可以通过设置Cookie的path来指定浏览器，在访问什么样的路径时，包含什么样的Cookie。
3.2 Cookie路径与请求路径的关系
下面我们来看看Cookie路径的作用：
下面是客户端浏览器保存的3个Cookie的路径：
a: /cookietest；
b: /cookietest/servlet；
c: /cookietest/jsp；
下面是浏览器请求的URL：
A: http://localhost:8080/cookietest/AServlet；
B: http://localhost:8080/cookietest/servlet/BServlet；
C: http://localhost:8080/cookietest/jsp/CServlet；
l 请求A时，会在请求中包含a；
l 请求B时，会在请求中包含a、b；
l 请求C时，会在请求中包含a、c；
也就是说，请求路径如果包含了Cookie路径，那么会在请求中包含这个Cookie，否则不会请求中不会包含这个Cookie。
l A请求的URL包含了&/cookietest&，所以会在请求中包含路径为&/cookietest&的Cookie；
l B请求的URL包含了&/cookietest&，以及&/cookietest/servlet&，所以请求中包含路径为&/cookietest&和&/cookietest/servlet&两个Cookie；
l B请求的URL包含了&/cookietest&，以及&/cookietest/jsp&，所以请求中包含路径为&/cookietest&和&/cookietest/jsp&两个Cookie；
3.3 设置Cookie的路径
设置Cookie的路径需要使用setPath()方法，例如：
cookie.setPath(&/cookietest/servlet&);
如果没有设置Cookie的路径，那么Cookie路径的默认值当前访问资源所在路径，例如：
l 访问http://localhost:8080/cookietest/AServlet时添加的Cookie默认路径为/cookietest；
l 访问http://localhost:8080/cookietest/servlet/BServlet时添加的Cookie默认路径为/cookietest/servlet；
l 访问http://localhost:8080/cookietest/jsp/BServlet时添加的Cookie默认路径为/cookietest/jsp；
4 Cookie的domain
Cookie的domain属性可以让网站中二级域共享Cookie，次要！
百度你是了解的对吧！
http://www.baidu.com
http://zhidao.baidu.com
http://news.baidu.com
http://tieba.baidu.com
现在我希望在这些主机之间共享Cookie（例如在www.baidu.com中响应的cookie，可以在news.baidu.com请求中包含）。很明显，现在不是路径的问题了，而是主机的问题，即域名的问题。处理这一问题其实很简单，只需要下面两步：
l 设置Cookie的path为&/&：c.setPath(&/&)；
l 设置Cookie的domain为&.baidu.com&：c.setDomain(&.baidu.com&)。
当domain为&.baidu.com&时，无论前缀是什么，都会共享Cookie的。但是现在我们需要设置两个虚拟主机：www.baidu.com和news.baidu.com。
第一步：设置windows的DNS路径解析
找到C:\WINDOWS\system32\drivers\etc\hosts文件，添加如下内容
127.0.0.1&&&&&& localhost
127.0.0.1&&&&&& www.baidu.com
127.0.0.1&&&&&& news.baidu.com
第二步：设置Tomcat虚拟主机
找到server.xml文件，添加&Host&元素，内容如下：
&&&&& &Host name="www.baidu.com"& appBase="F:\webapps\www"
&&&&&&&&&&& unpackWARs="true" autoDeploy="true"
&&&&&&&&&&& xmlValidation="false" xmlNamespaceAware="false"/&
&&&&& &Host name="news.baidu.com"& appBase="F:\webapps\news"
&&&&&&&&&&& unpackWARs="true" autoDeploy="true"
&&&&&&&&&&& xmlValidation="false" xmlNamespaceAware="false"/&
第三步：创建A项目，创建AServlet，设置Cookie。
Cookie c = new Cookie("id", "baidu");
c.setPath("/");
c.setDomain(".baidu.com");
c.setMaxAge(60*60);
response.addCookie(c);
response.getWriter().print("OK");
把A项目的WebRoot目录复制到F:\webapps\www目录下，并把WebRoot目录的名字修改为ROOT。
第四步：创建B项目，创建BServlet，获取Cookie，并打印出来。
Cookie[] cs = request.getCookies();
if(cs != null) {
for(Cookie c : cs) {
String s = c.getName() + ": " + c.getValue() + "&br/&";
response.getWriter().print(s);
把B项目的WebRoot目录复制到F:\webapps\news目录下，并把WebRoot目录的名字修改为ROOT。
第五步：访问www.baidu.com\AServlet，然后再访问news.baidu.com\BServlet。
5 Cookie中保存中文
Cookie的name和value都不能使用中文，如果希望在Cookie中使用中文，那么需要先对中文进行URL编码，然后把编码后的字符串放到Cookie中。
向客户端响应中添加Cookie
String name = URLEncoder.encode("姓名", "UTF-8");
String value = URLEncoder.encode("张三", "UTF-8");
Cookie c = new Cookie(name, value);
c.setMaxAge(3600);
response.addCookie(c);
从客户端请求中获取Cookie
response.setContentType("text/charset=utf-8");
Cookie[] cs = request.getCookies();
if(cs != null) {
for(Cookie c : cs) {
String name = URLDecoder.decode(c.getName(), "UTF-8");
String value = URLDecoder.decode(c.getValue(), "UTF-8");
String s = name + ": " + value + "&br/&";
response.getWriter().print(s);
6 显示曾经浏览过的商品
&h1&商品列表&/h1&
&a href="/day06_3/GoodServlet?name=ThinkPad"&ThinkPad&/a&&br/&
&a href="/day06_3/GoodServlet?name=Lenovo"&Lenovo&/a&&br/&
&a href="/day06_3/GoodServlet?name=Apple"&Apple&/a&&br/&
&a href="/day06_3/GoodServlet?name=HP"&HP&/a&&br/&
&a href="/day06_3/GoodServlet?name=SONY"&SONY&/a&&br/&
&a href="/day06_3/GoodServlet?name=ACER"&ACER&/a&&br/&
&a href="/day06_3/GoodServlet?name=DELL"&DELL&/a&&br/&
&&& 您浏览过的商品：
Cookie[] cs = request.getCookies();
if(cs != null) {
for(Cookie c : cs) {
if(c.getName().equals("goods")) {
out.print(c.getValue());
GoodServlet
public class GoodServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String goodName = request.getParameter("name");
String goods = CookieUtils.getCookValue(request, "goods");
if(goods != null) {
String[] arr = goods.split(", ");
Set&String& goodSet = new LinkedHashSet(Arrays.asList(arr));
goodSet.add(goodName);
goods = goodSet.toString();
goods = goods.substring(1, goods.length() - 1);
goods = goodN
Cookie cookie = new Cookie("goods", goods);
cookie.setMaxAge(1 * 60 * 60 * 24);
response.addCookie(cookie);
response.sendRedirect("/day06_3/index.jsp");
CookieUtils
public class CookieUtils {
public static String getCookValue(HttpServletRequest request, String name) {
Cookie[] cs = request.getCookies();
if(cs == null) {
return null;
for(Cookie c : cs) {
if(c.getName().equals(name)) {
return c.getValue();
return null;
HttpSession
HttpSession概述
1.1 什么是HttpSesssion
javax.servlet.http.HttpSession接口表示一个会话，我们可以把一个会话内需要共享的数据保存到HttSession对象中！
1.2 获取HttpSession对象
l HttpSession request.getSesssion()：如果当前会话已经有了session对象那么直接返回，如果当前会话还不存在会话，那么创建session并返回；
l HttpSession request.getSession(boolean)：当参数为true时，与requeset.getSession()相同。如果参数为false，那么如果当前会话中存在session则返回，不存在返回null；
1.3 HttpSession是域对象
我们已经学习过HttpServletRequest、ServletContext，它们都是域对象，现在我们又学习了一个HttpSession，它也是域对象。它们三个是Servlet中可以使用的域对象，而JSP中可以多使用一个域对象，明天我们再讲解JSP的第四个域对象。
l HttpServletRequest：一个请求创建一个request对象，所以在同一个请求中可以共享request，例如一个请求从AServlet转发到BServlet，那么AServlet和BServlet可以共享request域中的数据；
l ServletContext：一个应用只创建一个ServletContext对象，所以在ServletContext中的数据可以在整个应用中共享，只要不启动服务器，那么ServletContext中的数据就可以共享；
l HttpSession：一个会话创建一个HttpSession对象，同一会话中的多个请求中可以共享session中的数据；
下载是session的域方法：
l void setAttribute(String name, Object value)：用来存储一个对象，也可以称之为存储一个域属性，例如：session.setAttribute(&xxx&, &XXX&)，在session中保存了一个域属性，域属性名称为xxx，域属性的值为XXX。请注意，如果多次调用该方法，并且使用相同的name，那么会覆盖上一次的值，这一特性与Map相同；
l Object getAttribute(String name)：用来获取session中的数据，当前在获取之前需要先去存储才行，例如：String value = (String) session.getAttribute(&xxx&);，获取名为xxx的域属性；
l void removeAttribute(String name)：用来移除HttpSession中的域属性，如果参数name指定的域属性不存在，那么本方法什么都不做；
l Enumeration getAttributeNames()：获取所有域属性的名称；
2 登录案例
需要的页面：
l login.jsp：登录页面，提供登录表单；
l index1.jsp：主页，显示当前用户名称，如果没有登录，显示您还没登录；
l index2.jsp：主页，显示当前用户名称，如果没有登录，显示您还没登录；
l LoginServlet：在login.jsp页面提交表单时，请求本Servlet。在本Servlet中获取用户名、密码进行校验，如果用户名、密码错误，显示&用户名或密码错误&，如果正确保存用户名session中，然后重定向到index1.jsp；
当用户没有登录时访问index1.jsp或index2.jsp，显示&您还没有登录&。如果用户在login.jsp登录成功后到达index1.jsp页面会显示当前用户名，而且不用再次登录去访问index2.jsp也会显示用户名。因为多次请求在一个会话范围，index1.jsp和index2.jsp都会到session中获取用户名，session对象在一个会话中是相同的，所以都可以获取到用户名！
&%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%&
&!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&
&title&login.jsp&/title&
&h1&login.jsp&/h1&
&form action="/day06_4/LoginServlet" method="post"&
用户名：&input type="text" name="username" /&&br/&
&input type="submit" value="Submit"/&
index1.jsp
&%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%&
&!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&
&title&index1.jsp&/title&
&h1&index1.jsp&/h1&
String username = (String)session.getAttribute("username");
if(username == null) {
out.print("您还没有登录！");
out.print("用户名：" + username);
&a href="/day06_4/index2.jsp"&index2&/a&
index2.jsp
&%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%&
&!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&
&title&index2.jsp&/title&
&h1&index2.jsp&/h1&
String username = (String)session.getAttribute("username");
if(username == null) {
out.print("您还没有登录！");
out.print("用户名：" + username);
&a href="/day06_4/index1.jsp"&index1&/a&
LoginServlet
public class LoginServlet extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setCharacterEncoding("utf-8");
response.setContentType("text/charset=utf-8");
String username = request.getParameter("username");
if(username.equalsIgnoreCase("itcast")) {
response.getWriter().print("用户名或密码错误！");
HttpSession session = request.getSession();
session.setAttribute("username", username);
response.sendRedirect("/day06_4/index1.jsp");
3 session的实现原理
session底层是依赖Cookie的！我们来理解一下session的原理吧！
当我首次去银行时，因为还没有账号，所以需要开一个账号，我获得的是银行卡，而银行这边的数据库中留下了我的账号，我的钱是保存在银行的账号中，而我带走的是我的卡号。
当我再次去银行时，只需要带上我的卡，而无需再次开一个账号了。只要带上我的卡，那么我在银行操作的一定是我的账号！
当首次使用session时，服务器端要创建session，session是保存在服务器端，而给客户端的session的id（一个cookie中保存了sessionId）。客户端带走的是sessionId，而数据是保存在session中。
当客户端再次访问服务器时，在请求中会带上sessionId，而服务器会通过sessionId找到对应的session，而无需再创建新的session。
4 session与浏览器
session保存在服务器，而sessionId通过Cookie发送给客户端，但这个Cookie的生命不-1，即只在浏览器内存中存在，也就是说如果用户关闭了浏览器，那么这个Cookie就丢失了。
当用户再次打开浏览器访问服务器时，就不会有sessionId发送给服务器，那么服务器会认为你没有session，所以服务器会创建一个session，并在响应中把sessionId中到Cookie中发送给客户端。
你可能会说，那原来的session对象会怎样？当一个session长时间没人使用的话，服务器会把session删除了！这个时长在Tomcat中配置是30分钟，可以在${CATALANA}/conf/web.xml找到这个配置，当然你也可以在自己的web.xml中覆盖这个配置！
&&& &session-config&
&&&&&&& &session-timeout&30&/session-timeout&
&&& &/session-config&
session失效时间也说明一个问题！如果你打开网站的一个页面开始长时间不动，超出了30分钟后，再去点击链接或提交表单时你会发现，你的session已经丢失了！
5 session其他常用API
l String getId()：获取sessionId；
l int getMaxInactiveInterval()：获取session可以的最大不活动时间（秒），默认为30分钟。当session在30分钟内没有使用，那么Tomcat会在session池中移除这个session；
l void setMaxInactiveInterval(int interval)：设置session允许的最大不活动时间（秒），如果设置为1秒，那么只要session在1秒内不被使用，那么session就会被移除；
l long getCreationTime()：返回session的创建时间，返回值为当前时间的毫秒值；
l long getLastAccessedTime()：返回session的最后活动时间，返回值为当前时间的毫秒值；
l void invalidate()：让session失效！调用这个方法会被session失效，当session失效后，客户端再次请求，服务器会给客户端创建一个新的session，并在响应中给客户端新session的sessionId；
l boolean isNew()：查看session是否为新。当客户端第一次请求时，服务器为客户端创建session，但这时服务器还没有响应客户端，也就是还没有把sessionId响应给客户端时，这时session的状态为新。
我们知道session依赖Cookie，那么session为什么依赖Cookie呢？因为服务器需要在每次请求中获取sessionId，然后找到客户端的session对象。那么如果客户端浏览器关闭了Cookie呢？那么session是不是就会不存在了呢？
其实还有一种方法让服务器收到的每个请求中都带有sessioinId，那就是URL重写！在每个页面中的每个链接和表单中都添加名为jSessionId的参数，值为当前sessionid。当用户点击链接或提交表单时也服务器可以通过获取jSessionId这个参数来得到客户端的sessionId，找到sessoin对象。
&h1&URL重写&/h1&
&a href=‘/day06_5/index.jsessionid=&%=session.getId() %&‘ &主页&/a&
&form action=‘/day06_5/index.jsessionid=&%=session.getId() %&‘ method="post"&
&input type="submit" value="提交"/&
也可以使用response.encodeURL()对每个请求的URL处理，这个方法会自动追加jsessionid参数，与上面我们手动添加是一样的效果。
&a href=‘&%=response.encodeURL("/day06_5/index.jsp") %&‘ &主页&/a&
&form action=‘&%=response.encodeURL("/day06_5/index.jsp") %&‘ method="post"&
&input type="submit" value="提交"/&
使用response.encodeURL()更加&智能&，它会判断客户端浏览器是否禁用了Cookie，如果禁用了，那么这个方法在URL后面追加jsessionid，否则不会追加。
案例：一次性图片验证码
1 验证码有啥用
在我们注册时，如果没有验证码的话，我们可以使用URLConnection来写一段代码发出注册请求。甚至可以使用while(true)来注册！那么服务器就废了！
验证码可以去识别发出请求的是人还是程序！当然，如果聪明的程序可以去分析验证码图片！但分析图片也不是一件容易的事，因为一般验证码图片都会带有干扰线，人都看不清，那么程序一定分析不出来。
2 VerifyCode类
现在我们已经有了cn.itcast.utils.VerifyCode类，这个类可以生成验证码图片！下面来看一个小例子。
public void fun1() throws IOException {
// 创建验证码类
VerifyCode vc = new VerifyCode();
// 获取随机图片
BufferedImage image = vc.getImage();
// 获取刚刚生成的随机图片上的文本
String text = vc.getText();
System.out.println(text);
// 保存图片
FileOutputStream out = new FileOutputStream("F:/xxx.jpg");
VerifyCode.output(image, out);
3 在页面中显示动态图片
我们需要写一个VerifyCodeServlet，在这个Servlet中我们生成动态图片，然后它图片写入到response.getOutputStream()流中！然后让页面的&img&元素指定这个VerifyCodServlet即可。
VerifyCodeServlet
public class VerifyCodeServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
VerifyCode vc = new VerifyCode();
BufferedImage image = vc.getImage();
String text = vc.getText();
System.out.println("text:" + text);
VerifyCode.output(image, response.getOutputStream());
&script type="text/javascript"&
function _change() {
var imgEle = document.getElementById("vCode");
imgEle.src = "/day06_6/VerifyCodeServlet?" + new Date().getTime();
&h1&验证码&/h1&
&img id="vCode" src="/day06_6/VerifyCodeServlet"/&
&a href="javascript:_change()"&看不清，换一张&/a&
4 在注册页面中使用验证码
&form action="/day06_6/RegistServlet" method="post"&
用户名：&input type="text" name="username"/&&br/&
验证码：&input type="text" name="code" size="3"/&
&img id="vCode" src="/day06_6/VerifyCodeServlet"/&
&a href="javascript:_change()"&看不清，换一张&/a&
&input type="submit" value="Submit"/&
5 RegistServlet
修改VerifyCodeServlet
public class VerifyCodeServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
VerifyCode vc = new VerifyCode();
BufferedImage image = vc.getImage();
request.getSession().setAttribute("vCode", vc.getText());
VerifyCode.output(image, response.getOutputStream());
RegistServlet
public class RegistServlet extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setCharacterEncoding("utf-8");
response.setContentType("text/charset=utf-8");
String username = request.getParameter("username");
String vCode = request.getParameter("code");
String sessionVerifyCode = (String)request.getSession().getAttribute("vCode");
if(vCode.equalsIgnoreCase(sessionVerifyCode)) {
response.getWriter().print(username + ", 恭喜！注册成功！");
response.getWriter().print("验证码错误！");
6 总结验证码案例
l VerifyCodeServlet：
&O 生成验证码：VerifyCode vc = new VerifyCode(); BufferedImage image = vc.getImage()；
&O 在session中保存验证码文本：request.getSession.getAttribute(&vCode&, vc.getText())；
&O 把验证码输出到页面：VerifyCode.output(image, response.getOutputStream)；
l regist.jsp：
&O 表单中包含username和code字段；
&O 在表单中给出&img&指向VerifyCodeServlet，用来在页面中显示验证码图片；
&O 提供&看不清，换一张&链接，指向_change()函数；
&O 提交到RegistServlet；
l RegistServlet：
&O 获取表单中的username和code；
&O 获取session中的vCode；
&O 比较code和vCode是否相同；
&O 相同说明用户输入的验证码正确，否则输入验证码错误。
Jsp&el表达式
JSP指令概述
JSP指令的格式：&%@指令名 attr1=&& attr2=&& %&，一般都会把JSP指令放到JSP文件的最上方，但这不是必须的。
JSP中有三大指令：page、include、taglib，最为常用，也最为复杂的就是page指令了。
2 page指令
page指令是最为常用的指定，也是属性最多的属性！
page指令没有必须属性，都是可选属性。例如&%@page %&，没有给出任何属性也是可以的！
在JSP页面中，任何指令都可以重复出现！
&%@ page language=&java&%&
&%@ page import=&java.util.*&%&
&%@ page pageEncoding=&utf-8&%&
这也是可以的！
2.1 page指令的pageEncoding和contentType（重点）
pageEncoding指定当前JSP页面的编码！这个编码是给服务器看的，服务器需要知道当前JSP使用的编码，不然服务器无法正确把JSP编译成java文件。所以这个编码只需要与真实的页面编码一致即可！在MyEclipse中，在JSP文件上点击右键，选择属性就可以看到当前JSP页面的编码了。
contentType属性与response.setContentType()方法的作用相同！它会完成两项工作，一是设置响应字符流的编码，二是设置content-type响应头。例如：&%@ contentType=&text/charset=utf-8&%&，它会使&真身&中出现response.setContentType(&text/charset=utf-8&)。
无论是page指令的pageEncoding还是contentType，它们的默认值都是ISO-8859-1，我们知道ISO-8859-1是无法显示中文的，所以JSP页面中存在中文的话，一定要设置这两个属性。
其实pageEncoding和contentType这两个属性的关系很&暧昧&：
l 当设置了pageEncoding，而没设置contentType时： contentType的默认值为pageEncoding；
l 当设置了contentType，而没设置pageEncoding时： pageEncoding的默认值与contentType；
也就是说，当pageEncoding和contentType只出现一个时，那么另一个的值与出现的值相同。如果两个都不出现，那么两个属性的值都是ISO-8859-1。所以通过我们至少设置它们两个其中一个！
2.2 page指令的import属性
import是page指令中一个很特别的属性！
import属性值对应&真身&中的import语句。
import属性值可以使逗号：&%@page import=&java.net.*,java.util.*,java.sql.*&%&
import属性是唯一可以重复出现的属性：
&%@page import=&java.util.*& import=&java.net.*& import=&java.sql.*&%&
但是，我们一般会使用多个page指令来导入多个包：
&%@ page import=&java.util.*&%&
&%@ page import=&java.net.*&%&
&%@ page import=&java.text.*&%&
2.3 page指令的errorPage和isErrorPage
我们知道，在一个JSP页面出错后，Tomcat会响应给用户错误信息（500页面）！如果你不希望Tomcat给用户输出错误信息，那么可以使用page指令的errorPage来指定自己的错误页！也就是自定义错误页面，例如：&%@page errorPage=&xxx.jsp&%&。这时，在当前JSP页面出现错误时，会请求转发到xxx.jsp页面。
&%@ page import="java.util.*" pageEncoding="UTF-8"%&
&%@ page errorPage="b.jsp" %&
throw new Exception("哈哈~");
&%@ page pageEncoding="UTF-8"%&
&h1&出错啦！&/h1&
在上面代码中，a.jsp抛出异常后，会请求转发到b.jsp。在浏览器的地址栏中还是a.jsp，因为是请求转发！
而且客户端浏览器收到的响应码为200，表示请求成功！如果希望客户端得到500，那么需要指定b.jsp为错误页面。
&%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%&
&%@ page isErrorPage="true" %&
&h1&出错啦！&/h1&
&%=exception.getMessage() %&
注意，当isErrorPage为true时，说明当前JSP为错误页面，即专门处理错误的页面。那么这个页面中就可以使用一个内置对象exception了。其他页面是不能使用这个内置对象的！
温馨提示：IE会在状态码为500时，并且响应正文的长度小于等于512B时不给予显示！而是显示&网站无法显示该页面&字样。这时你只需要添加一些响应内容即可，例如上例中的b.jsp中我给出一些内容，IE就可以正常显示了！
2.3.1 web.xml中配置错误页面
不只可以通过JSP的page指令来配置错误页面，还可以在web.xml文件中指定错误页面。这种方式其实与page指令无关，但想来想去还是在这个位置来讲解比较合适！
&error-page&
&error-code&404&/error-code&
&location&/error404.jsp&/location&
&/error-page&
&error-page&
&error-code&500&/error-code&
&location&/error500.jsp&/location&
&/error-page&
&error-page&
&exception-type&java.lang.RuntimeException&/exception-type&
&location&/error.jsp&/location&
&/error-page&
&error-page&有两种使用方式：
l &error-code&和&location&子元素；
l &exception-type&和&location&子元素；
其中&error-code&是指定响应码；&location&指定转发的页面；&exception-type&是指定抛出的异常类型。
在上例中：
l 当出现404时，会跳转到error404.jsp页面；
l 当出现RuntimeException异常时，会跳转到error.jsp页面；
l 当出现非RuntimeException的异常时，会跳转到error500.jsp页面。
这种方式会在控制台看到异常信息！而使用page指令时不会在控制台打印异常信息。
2.4 page指令的autFlush和buffer(不重要)
buffer表示当前JSP的输出流（out隐藏对象）的缓冲区大小，默认为8kb。
authFlush表示在out对象的缓冲区满时如果处理！当authFlush为true时，表示缓冲区满时把缓冲区数据输出到客户端；当authFlush为false时，表示缓冲区满时，抛出异常。authFlush的默认值为true。
这两个属性一般我们也不会去特意设置，都是保留默认值！
2.5 page指令的isELIgnored
后面我们会讲解EL表达式语言，page指令的isElIgnored属性表示当前JSP页面是否忽略EL表达式，默认值为false，表示不忽略（即支持）。
2.6 page指令的其他属性(更不重要)
l language：只能是Java，这个属性可以看出JSP最初设计时的野心！希望JSP可以转换成其他语言！但是，到现在JSP也只能转换成Java代码；
l info：JSP说明性信息；
l isThreadSafe：默认为false，为true时，JSP生成的Servlet会去实现一个过时的标记接口SingleThreadModel，这时JSP就只能处理单线程的访问；
l session：默认为true，表示当前JSP页面可以使用session对象，如果为false表示当前JSP页面不能使用session对象；
l extends：指定当前JSP页面生成的Servlet的父类；
2.7 &jsp-config&（了解）
在web.xml页面中配置&jsp-config&也可以完成很多page指定的功能！
&jsp-config&
&jsp-property-group&
&url-pattern&*.jsp&/url-pattern&
&el-ignored&true&/el-ignored&
&page-encoding&UTF-8&/page-encoding&
&scripting-invalid&true&/scripting-invalid&
&/jsp-property-group&
&/jsp-config&
3 include指令
include指令表示静态包含！即目的是把多个JSP合并成一个JSP文件！
include指令只有一个属性：file，指定要包含的页面，例如：&%@include file=&b.jsp&%&。
静态包含：当hel.jsp页面包含了lo.jsp页面后，在编译hel.jsp页面时，需要把hel.jsp和lo.jsp页面合并成一个文件，然后再编译成Servlet（Java文件）。
很明显，在ol.jsp中在使用username变量，而这个变量在hel.jsp中定义的，所以只有这两个JSP文件合并后才能使用。通过include指定完成对它们的合并！
4 taglib指令
这个指令需要在学习了自定义标签后才会使用，现在只能做了了解而已！
在JSP页面中使用第三方的标签库时，需要使用taglib指令来&导包&。例如：
&%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %&
其中prefix表示标签的前缀，这个名称可以随便起。uri是由第三方标签库定义的，所以你需要知道第三方定义的uri。
JSP九大内置对象
1 什么是JSP九大内置对象
在JSP中无需创建就可以使用的9个对象，它们是：
l out（JspWriter）：等同与response.getWriter()，用来向客户端发送文本数据；
l config（ServletConfig）：对应&真身&中的ServletConfig；
l page（当前JSP的真身类型）：当前JSP页面的&this&，即当前对象；
l pageContext（PageContext）：页面上下文对象，它是最后一个没讲的域对象；
l exception（Throwable）：只有在错误页面中可以使用这个对象；
l request（HttpServletRequest）：即HttpServletRequest类的对象；
l response（HttpServletResponse）：即HttpServletResponse类的对象；
l application（ServletContext）：即ServletContext类的对象；
l session（HttpSession）：即HttpSession类的对象，不是每个JSP页面中都可以使用，如果在某个JSP页面中设置&%@page session=&false&%&，说明这个页面不能使用session。
在这9个对象中有很多是极少会被使用的，例如：config、page、exception基本不会使用。
在这9个对象中有两个对象不是每个JSP页面都可以使用的：exception、session。
在这9个对象中有很多前面已经学过的对象：out、request、response、application、session、config。
2 通过&真身&来对照JSP
我们知道JSP页面的内容出现在&真身&的_jspService()方法中，而在_jspService()方法开头部分已经创建了9大内置对象。
& public void _jspService(HttpServletRequest request, HttpServletResponse response)
&&&&&&& throws java.io.IOException, ServletException {
&&& PageContext pageContext =
&&& HttpSession session =
&&& ServletContext application =
&&& ServletConfig config =
&&& JspWriter out =
&&& Object page =
&&& JspWriter _jspx_out =
&&& PageContext _jspx_page_context =
&&&&& response.setContentType("text/charset=UTF-8");
&&&&& pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
&&&&& _jspx_page_context = pageC
&&&&& application = pageContext.getServletContext();
&&&&& config = pageContext.getServletConfig();
&&&&& session = pageContext.getSession();
&&&&& out = pageContext.getOut();
&&&&& _jspx_out =
从这里开始，才是JSP页面的内容
3 pageContext对象
在JavaWeb中一共四个域对象，其中Servlet中可以使用的是request、session、application三个对象，而在JSP中可以使用pageContext、request、session、application四个域对象。
pageContext 对象是PageContext类型，它的主要功能有：
l 域对象功能；
l 代理其它域对象功能；
l 获取其他内置对象；
3.1 域对象功能
pageContext也是域对象，它的范围是当前页面。它的范围也是四个域对象中最小的！
l void setAttribute(String name, Object value)；
l Object getAttrbiute(String name, Object value)；
l void removeAttribute(String name, Object value)；
3.2 代理其它域对象功能
还可以使用pageContext来代理其它3个域对象的功能，也就是说可以使用pageContext向request、session、application对象中存取数据，例如：
&&& pageContext.setAttribute("x", "X");
pageContext.setAttribute("x", "XX", PageContext.REQUEST_SCOPE);
&&& pageContext.setAttribute("x", "XXX", PageContext.SESSION_SCOPE);
&&& pageContext.setAttribute("x", "XXXX", PageContext.APPLICATION_SCOPE);
l void setAttribute(String name, Object value, int scope)：在指定范围中添加数据；
l Object getAttribute(String name, int scope)：获取指定范围的数据；
l void removeAttribute(String name, int scope)：移除指定范围的数据；
l Object findAttribute(String name)：依次在page、request、session、application范围查找名称为name的数据，如果找到就停止查找。这说明在这个范围内有相同名称的数据，那么page范围的优先级最高！
3.3 获取其他内置对象
一个pageContext对象等于所有内置对象，即1个当9个。这是因为可以使用pageContext对象获取其它8个内置对象：
l JspWriter getOut()：获取out内置对象；
l ServletConfig getServletConfig()：获取config内置对象；
l Object getPage()：获取page内置对象；
l ServletRequest getRequest()：获取request内置对象；
l ServletResponse getResponse()：获取response内置对象；
l HttpSession getSession()：获取session内置对象；
l ServletContext getServletContext()：获取application内置对象；
l Exception getException()：获取exception内置对象；
JSP动作标签
1 JSP动作标签概述
动作标签的作用是用来简化Java脚本的！
JSP动作标签是JavaWeb内置的动作标签，它们是已经定义好的动作标签，我们可以拿来直接使用。
如果JSP动作标签不够用时，还可以使用自定义标签（今天不讲）。JavaWeb一共提供了20个JSP动作标签，但有很多基本没有用，这里只介绍一些有坐标的动作标签。
JSP动作标签的格式：&jsp:标签名 &&
2 &jsp:include&
&jsp:include&标签的作用是用来包含其它JSP页面的！你可能会说，前面已经学习了include指令了，它们是否相同呢？虽然它们都是用来包含其它JSP页面的，但它们的实现的级别是不同的！
include指令是在编译级别完成的包含，即把当前JSP和被包含的JSP合并成一个JSP，然后再编译成一个Servlet。
include动作标签是在运行级别完成的包含，即当前JSP和被包含的JSP都会各自生成Servlet，然后在执行当前JSP的Servlet时完成包含另一个JSP的Servlet。它与RequestDispatcher的include()方法是相同的！
&h1&hel.jsp&/h1&
&jsp:include page="lo.jsp" /&
out.println("&h1&lo.jsp&/h1&");
其实&jsp:include&在&真身&中不过是一句方法调用，即调用另一个Servlet而已。
3 &jsp:forward&
forward标签的作用是请求转发！forward标签的作用与RequestDispatcher#forward()方法相同。
out.println("&h1&lo.jsp&/h1&");
注意，最后客户端只能看到lo.jsp的输出，而看不到hel.jsp的内容。也就是说在hel.jsp中的&h1&hel.jsp&/h1&是不会发送到客户端的。&jsp:forward&的作用是&别在显示我，去显示它吧！&。
4 &jsp:param&
还可以在&jsp:include&和&jsp:forward&标签中使用&jsp:param&子标签，它是用来传递参数的。下面用&jsp:include&来举例说明&jsp:param&的使用。
&%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%&
&!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&
&title&a.jsp&/title&
&h1&a.jsp&/h1&
&jsp:include page="/b.jsp"&
&jsp:param value="zhangSan" name="username"/&
&/jsp:include&
&%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%&
&!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"&
&title&b.jsp&/title&
&h1&b.jsp&/h1&
String username = request.getParameter("username");
out.print("你好：" + username);
JavaBean（了解即可，非重要）
1 JavaBean概述
1.1 什么是JavaBean
JavaBean是一种规范，也就是对类的要求。它要求Java类的成员变量提供getter/setter方法，这样的成员变量被称之为JavaBean属性。
JavaBean还要求类必须提供仅有的无参构造器，例如：public User() {&}
package cn.itcast.
public class User {
public String getUsername() {
public void setUsername(String username) {
this.username =
public String getPassword() {
public void setPassword(String password) {
this.password =
1.2 JavaBean属性
JavaBean属性是具有getter/setter方法的成员变量。
l 也可以只提供getter方法，这样的属性叫只读属性；
l 也可以只提供setter方法，这样的属性叫只写属性；
l 如果属性类型为boolean类型，那么读方法的格式可以是get或is。例如名为abc的boolean类型的属性，它的读方法可以是getAbc()，也可以是isAbc()；
JavaBean属性名要求：前两个字母要么都大写，要么都小写：
public class User {
private String iD;
private String ID;
private String qQ;
private String QQ;
JavaBean可能存在属性，但不存在这个成员变量，例如：
public class User {
public String getUsername() {
return "zhangSan";
上例中User类有一个名为username的只读属性！但User类并没有username这个成员变量！
还可以并变态一点：
public class User {
public String getUsername() {
public void setUsername(String username) {
this.hello =
上例中User类中有一个名为username的属性，它是可读可写的属性！而Use类的成员变量名为hello！也就是说JavaBean的属性名取决与方法名称，而不是成员变量的名称。但通常没有人做这么变态的事情。
内省的目标是得到JavaBean属性的读、写方法的反射对象，通过反射对JavaBean属性进行操作的一组API。例如User类有名为username的JavaBean属性，通过两个Method对象（一个是getUsenrmae()，一个是setUsername()）来操作User对象。
如果你还不能理解内省是什么，那么我们通过一个问题来了解内省的作用。现在我们有一个Map，内容如下：
Map&String,String& map = new HashMap&String,String&();
map.put("username", "admin");
map.put("password", "admin123");
public class User {
public User(String username, String password) {
this.username =
this.password =
public User() {
public String getUsername() {
public void setUsername(String username) {
this.username =
public String getPassword() {
public void setPassword(String password) {
this.password =
public String toString() {
return "User [username=" + username + ", password=" + password + "]";
现在需要把map的数据封装到一个User对象中！User类有两个JavaBean属性，一个叫username，另一个叫password。
你可能想到的是反射，通过map的key来查找User类的Field！这么做是没有问题的，但我们要知道类的成员变量是私有的，虽然也可以通过反射去访问类的私有的成员变量，但我们也要清楚反射访问私有的东西是有&危险&的，所以还是建议通过getUsername和setUsername来访问JavaBean属性。
2.1 内省之获取BeanInfo
我们这里不想去对JavaBean规范做过多的介绍，所以也就不在多介绍BeanInfo的&出身&了。你只需要知道如何得到它，以及BeanInfo有什么。
通过java.beans.Introspector的getBeanInfo()方法来获取java.beans.BeanInfo实例。
BeanInfo beanInfo = Introspector.getBeanInfo(User.class);
2.2 得到所有属性描述符（PropertyDescriptor）
通过BeanInfo可以得到这个类的所有JavaBean属性的PropertyDescriptor对象。然后就可以通过PropertyDescriptor对象得到这个属性的getter/setter方法的Method对象了。
PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
每个PropertyDescriptor对象对应一个JavaBean属性：
l String getName()：获取JavaBean属性名称；
l Method getReadMethod：获取属性的读方法；
l Method getWriteMethod：获取属性的写方法。
2.3 完成Map数据封装到User对象中
public void fun1() throws Exception {
Map&String,String& map = new HashMap&String,String&();
map.put("username", "admin");
map.put("password", "admin123");
BeanInfo beanInfo = Introspector.getBeanInfo(User.class);
PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
User user = new User();
for(PropertyDescriptor pd : pds) {
String name = pd.getName();
String value = map.get(name);
if(value != null) {
Method writeMethod = pd.getWriteMethod();
writeMethod.invoke(user, value);
System.out.println(user);
3 commons-beanutils
提到内省，不能不提commons-beanutils这个工具。它底层使用了内省，对内省进行了大量的简化！
使用beanutils需要的jar包：
l commons-beanutils.jar；
l commons-logging.jar；
3.1 设置JavaBean属性
User user = new User();
BeanUtils.setProperty(user, "username", "admin");
BeanUtils.setProperty(user, "password", "admin123");
System.out.println(user);
3.2 获取JavaBean属性
User user = new User("admin", "admin123");
String username = BeanUtils.getProperty(user, "username");
String password = BeanUtils.getProperty(user, "password");
System.out.println("username=" + username + ", password=" + password);
3.3 封装Map数据到JavaBean对象中
Map&String,String& map = new HashMap&String,String&();
map.put("username", "admin");
map.put("password", "admin123");
User user = new User();
BeanUtils.populate(user, map);
System.out.println(user);
4 JSP与JavaBean相关的动作标签
在JSP中与JavaBean相关的标签有：
l &jsp:useBean&：创建JavaBean对象；
l &jsp:setProperty&：设置JavaBean属性；
l &jsp:getProperty&：获取JavaBean属性；
我们需要先创建一个JavaBean类：
package cn.itcast.
public class User {
public User(String username, String password) {
this.username =
this.password =
public User() {
public String getUsername() {
public void setUsername(String username) {
this.username =
public String getPassword() {
public void setPassword(String password) {
this.password =
public String toString() {
return "User [username=" + username + ", password=" + password + "]";
4.1 &jsp:useBean&
&jsp:useBean&标签的作用是创建JavaBean对象：
l 在当前JSP页面创建JavaBean对象；
l 把创建的JavaBean对象保存到域对象中；
&jsp:useBean id="user1" class="cn.itcast.domain.User" /&
上面代码表示在当前JSP页面中创建User类型的对象，并且把它保存到page域中了。下面我们把&jsp:useBean&标签翻译成Java代码：
cn.itcast.domain.User user1 = new cn.itcast.domain.User();
pageContext.setAttribute("user1", user1);
这说明我们可以在JSP页面中完成下面的操作：
&jsp:useBean id="user1" class="cn.itcast.domain.User" /&
&%=user1 %&
out.println(pageContext.getAttribute("user1"));
&jsp:useBean&标签默认是把JavaBean对象保存到page域，还可以通过scope标签属性来指定保存的范围：
&jsp:useBean id="user1" class="cn.itcast.domain.User" scope="page"/&
&jsp:useBean id="user2" class="cn.itcast.domain.User" scope="request"/&
&jsp:useBean id="user3" class="cn.itcast.domain.User" scope="session"/&
&jsp:useBean id="user4" class="cn.itcast.domain.User" scope="applicatioin"/&
&jsp:useBean&标签其实不一定会创建对象！！！其实它会先在指定范围中查找这个对象，如果对象不存在才会创建，我们需要重新对它进行翻译：
&jsp:useBean id="user4" class="cn.itcast.domain.User" scope="applicatioin"/&
cn.itcast.domain.User user4 = (cn.itcast.domain.User)application.getAttribute("user4");
if(user4 == null) {
user4 = new cn.itcast.domain.User();
application.setAttribute("user4", user4);
4.2 &jsp:setProperty&和&jsp:getProperty&
&jsp:setProperty&标签的作用是给JavaBean设置属性值，而&jsp:getProperty&是用来获取属性值。在使用它们之前需要先创建JavaBean：
&jsp:useBean id="user1" class="cn.itcast.domain.User" /&
&jsp:setProperty property="username" name="user1" value="admin"/&
&jsp:setProperty property="password" name="user1" value="admin123"/&
用户名：&jsp:getProperty property="username" name="user1"/&&br/&
密 码：&jsp:getProperty property="passwor