Java Web基础知识总结
文章目录
-------------------------------------在Java中,动态web资源开发技术统称为Javaweb
1. web服务器与Http协议
1. web服务器
Internet上供外界访问的Web资源分为:
• 静态web资源(如html 页面):指web页面中供人们浏览的数据始终是不变。
• 动态web资源:指web页面中供人们浏览的数据是由程序产生的,不同时间点访问web页面看到的内容各不相同。
静态web资源开发技术:Html
常用动态web资源开发技术: JSP/Servlet、ASP、PHP等 ruby python
服务器介绍
大型服务器: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目录结构:
-----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 -----------虚拟目录映射
虚似目录的映射方式有三种
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文件中进行配置
在Host结束前配置
path:它是一个虚拟路径,是我们在浏览器中输入的路径
docBase:它是我们web sit的真实路径
http://localhost/abc/index.html
3.不在server.xml文件中配置
而是直接创建一个abc.xml文件
在这个xml文件中写
将这个文件放入conf\Catalina\localhost
http://localhost/abc/index.html
**3.**生成war文件
war文件是web项目的压缩文件。
要想生成,先将要压缩的内容压缩成zip文件,
然后将后缀改成war就可以,
war文件可以直接在服务器上访问。
关于tomcat-manager
可以在conf/tomcat-users.xml中进行用户信息添加
这样就添加了一个用户
注意,用户权限要是比较大的话,会出现安全问题.
4.Http协议
HTTP是hypertext transfer protocol(超文本传输协议)的简写,它是TCP/IP协议的一个应用层协议,用于定义WEB浏览器与WEB服务器之间交换数据的过程。
示例1
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/"7347-1184876416000"
Last-Modified: Thu, 19 Jul 2007 20:20:16 GMT
Content-Type: text/html
Content-Length: 7347
Date: Thu, 25 Apr 2013 08:06: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">
<head>
<title>Apache Tomcat</title>
<style type="text/css">
..........
示例2
是根据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 (compatible; 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/"7347-1184876416000"
Last-Modified: Thu, 19 Jul 2007 20:20:16 GMT
Content-Type: text/html
Content-Length: 7347
Date: Thu, 25 Apr 2013 08:12: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.超连接 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 (compatible; 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 2000 18:23:51 GMT 与Last-MOdified一起可以控制缓存。
Date: Tue, 11 Jul 2000 18:23:51 GMT
示例1
防盗链程序
referer.htm页面
**
**
*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");*
*} else {*
*// 如果是盗链过来的,对不。骂它一句*
*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 服务器错误
200 正确
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/html; charset=GB2312 响应字符编码
Last-Modified: Tue, 11 Jul 2000 18:23:51 GMT 要与请求中的 If-Modified-Since处理缓存
Refresh: 1;url=http://www.it315.org 自动跳转
Content-Disposition: attachment; filename=aaa.zip (重要) 文件的下载
//下面三个是禁用浏览缓存
Expires: -1
Cache-Control: no-cache
Pragma: no-cache
Connection: close/Keep-Alive
Date: Tue, 11 Jul 2000 18:23:51 GMT
重点
今天可以讲
Location: http://www.it315.org/index.jsp 响应路径(重点)+302
Last-Modified: Tue, 11 Jul 2000 18:23: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: attachment; filename=aaa.zip (重要) 文件的下载
//下面三个是禁用浏览缓存
Expires: -1
Cache-Control: no-cache
Pragma: no-cache
4.启动服务器
5.在浏览器中访问web资源.
2. Servlet
概述:
Servlet是JavaWeb三大组件之一,也是最重要的组件!
Ø 三大组件:Servlet、Filter、Listener
l Servlet是一个我们自定义的Java类,它必须要实现javax.servlet.Servlet接口。
l Servlet是动态资源!
l Servlet必须在web.xml中进行配置后,才能被访问。(把Servlet与一个或多个路径绑定在一起)
实现:
实现Servlet有三种方式:
Ø 实现Servlet接口;
Ø 继承GenericServlet类;
Ø 继承HttpServlet类(最佳选择)。
生命周期:
Servlet接口中一共是5个方法,其中有三个是生命周期方法。
Ø void init(ServletConfig):这个方法会在Servlet被创建后,马上被调用。只会被调用一次!我们可以把一些初始化工作放到这个方法中,如果没有什么初始化工作要做,那么这个方法就空着就可以了。
² Servlet有两个时间点会被创建:一是在第一次被请求时,会被创建;二是Tomcat启动时被创建,默认是第一种,如果希望在tomcat启动时创建,这需要在web.xml中配置。
Ø void destroy():这个方法会在Servlet被销毁之前被调用。如果你有一些需要释放的资源,可以在这个方法中完成,如果没有那么就让这个方法空着。这个方法也只会被调用一次!
² Servlet轻易不会被销毁,通常会在Tomcat关闭时会被销毁。
Ø void service(ServletRequest,ServletResponse):它会在每次被请求时调用!这个方法会被调用0~N次。
Ø String getServletInfo():它不是生命周期方法,也就是说它不会被tomcat调用。它可以由我们自己来调用,但我们一般也不调用它!你可以返回一个对当前Servlet的说明性字符串。
Ø ServletConfig getServletConfig():这个方法返回的是ServletConfig,这个类型与init()方法的参数类型相同。它对应的是web.xml中的配置信息,即
ServletConfig、ServletContext、ServletRequest、ServletResponse
l ServletRequest:封装了请求信息;
l ServletResposne:用于向客户端响应;
l ServletContext:它可以在多个Servlet中共享数据。
l ServletConfig:它与对应!
Ø 在中可以配置,即初始化参数,可以使用ServletConfig的getInitParameter(String),方法的参数是初始化参数名,方法的返回值是初始化参数值。
Ø getInitParameterNames(),该方法返回一个Enumeration对象,即返回所有初始化参数的名称。
Ø String getServletName(),它返回的是元素的值
Ø ServletContext getServletContext(),它可以获取Servlet上下文对象。
GenericServlet
l 它代理了ServletConfig的所有功能。所有使用ServletConfig才能调用的方法,都可以使用GenericServlet的同名方法来完成!
l 不能覆盖父类的init(ServltConfig)方法,因为在父类中该方法内完成了this.config=config,其他的所有ServletConfig的代理方法都使用this.config来完成的。一旦覆盖,那么this.config就是null。
l 如果我们需要做初始化工作,那么可以去覆盖GenericServlet提供的init()方法。
HttpServlet
l 它提供了与http协议相关的一些功能。
l 只需要去覆盖doGet()或doPost()即可。这两个方法,如果没有覆盖,默认是响应405!
Servlet特点
Servlet单例、线程不安全
l Servlet是的单例的。所以一个Servlet对象可能同时处理多个请求;
l Servlet不是线程安全的。
Ø 尽可能不创建成员变量,因为成员变量多个线程会共享!
Ø 如果非要创建,那么创建功能性的,只读!
Servlet的创建时间:第一次被请求、启动创建
* Servlet可以在第一次请求时被创建,还可以在容器启动时被创建。默认是第一次请求时!
* 在添加一个大于等于0的整数
* 如果有多个Servlet在容器启动时创建,那么的值就有用了,创建的顺序使用它的值来排序!
<url-pattern>的配置
l 中可以使用“*”表示所有字符,但它不匹配“/”。它的使用要求:
Ø 它要么在头,要么在尾。不能在中间;
Ø 如果不使用通配符,那么必须使用“/”开头。
l 如果一个访问路径,匹配了多个,那么谁更加明确就匹配谁。
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()方法来获取!
Ø ServletConfig是init()方法的参数,那只能在init()方法中获取了;
Ø GenericServlet代理了ServletConfig的所有方法,而且还提供了getServletConfig(),所以在GenericServlet的子类中可以使用如下方式来获取ServletContext对象:
² this.getServletContext()
² this.getServletConfig().getServletContext()
Ø 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的呢,由ClassLoader完成的!把硬盘上的User.class加载到内存,变成Class对象。
使用它们获取资源流!它们相对类路径(classpath)
request&response 对象
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/texgt;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);
7 重定向
l 重定向:两个请求。
Ø 第一个请求,服务器响应码:302
Ø 第一个请求的响应头有一个Location头,它说明了要重定向的URL;
Ø 第二个请求,浏览器重新向Location头指定的URL发出。
l 重定向:可以重定向到本项目之外的页面。例如可以重定向到百度!
l 重定向:可以重定向到本项目内的其他资源,可以使用相对路径,以“/项目名”开头
l 重定向:会使浏览器的地址栏发生变化!
注意事项:
l 当response为以提交状态,就不能再重定向了!
l 当使用了response的输出流响应后,再重定向。如果没有造成response提交,那么说明数据还在缓冲区中,tomcat会把缓冲区清空,然后重定向。
request
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请求的默认编码:
l 因为编码的设置不能依赖tomcat的配置,所以还是需要我们自己手动转码
Ø String name = request.getParamter(“username”);//使用默认的iso来解码
Ø byte[] bytes = name.getBytes(“iso-8859-1”);//使用iso回退到字节数组
Ø 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 在转发语句之后,其他语句是否会执行?答案是“可以”!
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”,
服务器端路径:
转发:必须使用“/”开头,它相对当前项目,即http://localhost:8080/day10_3
包含:同上;
:同上
ServletContext.getRealPath(“/a.jpg”):它是真对真实路径,相对当前WebRoot
ServletContext.getResourceAsStream():同上
Class.getResourceAsStream():如果使用“/”开头,相对classes,如果不使用“/”,相对当前.class文件所在目录。
ClassLoader. getResourceAsStream():无论使用不使用“/”开头,都相对classes
编码:
URL编码
作用:为了在客户端与服务器之间传递中文!
把中文转换成URL编码:
Ø 首先你需要选择一种字符编码,然后把中文转换成byte[]。
Ø 把每个字节转换成16进制,前面添加上一个“%”。它不能显负号,把得到的byte先加上128,这样-128就是0了。正的127就是255了,它的范围是%00~%FF
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:请求头,客户端发送给服务器端;
Ø 格式:Cookie: a=A; b=B; c=C。即多个Cookie用分号离开;
l Set-Cookie:响应头,服务器端发送给客户端;
Ø 一个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.servlet;
import java.io.IOException;
import java.util.UUID;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 给客户端发送Cookie
* @author Administrator
*
*/
public class AServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;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.servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 获取客户端请求中的Cookie
* @author Administrator
*
*/
public class BServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;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/html;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 localhost127.0.0.1 www.baidu.com127.0.0.1 news.baidu.com
第二步:设置Tomcat虚拟主机
找到server.xml文件,添加元素,内容如下:
第三步:创建A项目,创建AServlet,设置Cookie。
Cookie c = new Cookie(“id”, “baidu”);c.setPath("/");c.setDomain(".baidu.com");c.setMaxAge(60*60);response.addCookie©;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() + “
”;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©;
从客户端请求中获取Cookie
response.setContentType(“text/html;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 + “
”;response.getWriter().print(s);}}
6 显示曾经浏览过的商品
index.jsp
商品列表
ThinkPadLenovo
Apple
HP
SONY
ACER
DELL
您浏览过的商品:<%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 goodSet = new LinkedHashSet(Arrays.asList(arr));goodSet.add(goodName);goods = goodSet.toString();goods = goods.substring(1, goods.length() - 1);} else {goods = goodName;}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:主页,显示当前用户名称,如果没有登录,显示您还没登录;
Servlet:
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对象在一个会话中是相同的,所以都可以获取到用户名!
login.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>login.jsp</title>
</head>
<body>
<h1>login.jsp</h1>
<hr/>
<form action="/day06_4/LoginServlet" method="post">
用户名:<input type="text" name="username" /><br/>
<input type="submit" value="Submit"/>
</form>
</body>
</html>
index1.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>index1.jsp</title>
</head>
<body>
<h1>index1.jsp</h1>
<%
String username = (String)session.getAttribute("username");
if(username == null) {
out.print("您还没有登录!");
} else {
out.print("用户名:" + username);
}
%>
<hr/>
<a href="/day06_4/index2.jsp">index2</a>
</body>
</html>
index2.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>index2.jsp</title>
</head>
<body>
<h1>index2.jsp</h1>
<%
String username = (String)session.getAttribute("username");
if(username == null) {
out.print("您还没有登录!");
} else {
out.print("用户名:" + username);
}
%>
<hr/>
<a href="/day06_4/index1.jsp">index1</a>
</body>
</html>
LoginServlet
public class LoginServlet extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=utf-8");
String username = request.getParameter("username");
if(username.equalsIgnoreCase("itcast")) {
response.getWriter().print("用户名或密码错误!");
} else {
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中覆盖这个配置!
web.xml
30
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的状态为新。
6 URL重写
我们知道session依赖Cookie,那么session为什么依赖Cookie呢?因为服务器需要在每次请求中获取sessionId,然后找到客户端的session对象。那么如果客户端浏览器关闭了Cookie呢?那么session是不是就会不存在了呢?
其实还有一种方法让服务器收到的每个请求中都带有sessioinId,那就是URL重写!在每个页面中的每个链接和表单中都添加名为jSessionId的参数,值为当前sessionid。当用户点击链接或提交表单时也服务器可以通过获取jSessionId这个参数来得到客户端的sessionId,找到sessoin对象。
index.jsp
<body>
<h1>URL重写</h1>
<a href='/day06_5/index.jsp;jsessionid=<%=session.getId() %>' >主页</a>
<form action='/day06_5/index.jsp;jsessionid=<%=session.getId() %>' method="post">
<input type="submit" value="提交"/>
</form>
</body>
也可以使用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="提交"/>
</form>
使用response.encodeURL()更加“智能”,它会判断客户端浏览器是否禁用了Cookie,如果禁用了,那么这个方法在URL后面追加jsessionid,否则不会追加。
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/html;charset=utf-8”%>,它会使“真身”中出现response.setContentType(“text/html;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页面。
a.jsp
<%@ page import="java.util.*" pageEncoding="UTF-8"%>
<%@ page errorPage="b.jsp" %>
<%
if(true)
throw new Exception("哈哈~");
%>
b.jsp
<%@ page pageEncoding="UTF-8"%>
<html>
<body>
<h1>出错啦!</h1>
</body>
</html>
在上面代码中,a.jsp抛出异常后,会请求转发到b.jsp。在浏览器的地址栏中还是a.jsp,因为是请求转发!
而且客户端浏览器收到的响应码为200,表示请求成功!如果希望客户端得到500,那么需要指定b.jsp为错误页面。
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ page isErrorPage="true" %>
<html>
<body>
<h1>出错啦!</h1>
<%=exception.getMessage() %>
</body>
</html>
注意,当isErrorPage为true时,说明当前JSP为错误页面,即专门处理错误的页面。那么这个页面中就可以使用一个内置对象exception了。其他页面是不能使用这个内置对象的!
温馨提示:IE会在状态码为500时,并且响应正文的长度小于等于512B时不给予显示!而是显示“网站无法显示该页面”字样。这时你只需要添加一些响应内容即可,例如上例中的b.jsp中我给出一些内容,IE就可以正常显示了!
2.3.1 web.xml中配置错误页面
不只可以通过JSP的page指令来配置错误页面,还可以在web.xml文件中指定错误页面。这种方式其实与page指令无关,但想来想去还是在这个位置来讲解比较合适!
web.xml
<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>
有两种使用方式:
l 和子元素;
l 和子元素;
其中是指定响应码;指定转发的页面;是指定抛出的异常类型。
在上例中:
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 (了解)
在web.xml页面中配置也可以完成很多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 = null;
HttpSession session = null;
ServletContext application = null;
ServletConfig config = null;
JspWriter out = null;
Object page = this;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
response.setContentType("text/html;charset=UTF-8");
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
从这里开始,才是JSP页面的内容
}…
在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和被包含的JSP合并成一个JSP,然后再编译成一个Servlet。
include动作标签是在运行级别完成的包含,即当前JSP和被包含的JSP都会各自生成Servlet,然后在执行当前JSP的Servlet时完成包含另一个JSP的Servlet。它与RequestDispatcher的include()方法是相同的!
hel.jsp
<body>
<h1>hel.jsp</h1>
<jsp:include page="lo.jsp" />
</body>
lo.jsp
<%
out.println("<h1>lo.jsp</h1>");
%>
其实jsp:include在“真身”中不过是一句方法调用,即调用另一个Servlet而已。
**3 **
forward标签的作用是请求转发!forward标签的作用与RequestDispatcher#forward()方法相同。
hel.jsp
lo.jsp
<%
out.println("<h1>lo.jsp</h1>");
%>
注意,最后客户端只能看到lo.jsp的输出,而看不到hel.jsp的内容。也就是说在hel.jsp中的
hel.jsp
是不会发送到客户端的。 jsp:forward的作用是“别在显示我,去显示它吧!”。**4 **
还可以在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">
<html>
<head>
<title>a.jsp</title>
</head>
<body>
<h1>a.jsp</h1>
<hr/>
<jsp:include page="/b.jsp">
<jsp:param value="zhangSan" name="username"/>
</jsp:include>
</body>
</html>
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>b.jsp</title>
</head>
<body>
<h1>b.jsp</h1>
<hr/>
<%
String username = request.getParameter("username");
out.print("你好:" + username);
%>
</body>
</html>
JavaBean(了解即可,非重要)
1 JavaBean概述
1.1 什么是JavaBean
JavaBean是一种规范,也就是对类的要求。它要求Java类的成员变量提供getter/setter方法,这样的成员变量被称之为JavaBean属性。
JavaBean还要求类必须提供仅有的无参构造器,例如:public User() {…}
User.java
package cn.itcast.domain;
public class User {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = 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 {
private String hello;
public String getUsername() {
return hello;
}
public void setUsername(String username) {
this.hello = username;
}
}
上例中User类中有一个名为username的属性,它是可读可写的属性!而Use类的成员变量名为hello!也就是说JavaBean的属性名取决与方法名称,而不是成员变量的名称。但通常没有人做这么变态的事情。
2 内省
内省的目标是得到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 {
private String username;
private String password;
public User(String username, String password) {
this.username = username;
this.password = password;
}
public User() {
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = 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类:
User.java
package cn.itcast.domain;
public class User {
private String username;
private String password;
public User(String username, String password) {
this.username = username;
this.password = password;
}
public User() {
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String toString() {
return "User [username=" + username + ", password=" + password + "]";
}
}
**4.1 **
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标签的作用是给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”/>
密 码:<jsp:getProperty property=“password” name=“user1”/>
EL(表达式语言)
1 EL概述
1.1 EL的作用
JSP2.0要把html和css分离、要把html和javascript分离、要把Java脚本替换成标签。标签的好处是非Java人员都可以使用。
JSP2.0 – 纯标签页面,即:不包含<% … %>、<%! … %>,以及<%= … %>
EL(Expression Language)是一门表达式语言,它对应<%=…%>。我们知道在JSP中,表达式会被输出,所以EL表达式也会被输出。
1.2 EL的格式
格式:${…}
例如:${1 + 2}
1.3 关闭EL
如果希望整个JSP忽略EL表达式,需要在page指令中指定isELIgnored=”true”。
如果希望忽略某个EL表达式,可以在EL表达式之前添加“\”,例如:${1 + 2}。
1.4 EL运算符
运算符 | 说明 | 范例 | 结果 |
---|---|---|---|
+ | 加 | ${17+5} | 22 |
- | 减 | ${17-5} | 12 |
* | 乘 | ${17*5} | 85 |
/或div | 除 | 17 / 5 或 {17/5}或 17/5或{17 div 5} | 3 |
%或mod | 取余 | KaTeX parse error: Expected '}', got 'EOF' at end of input: {17%5}或{17 mod 5} | 2 |
==或eq | 等于 | 5 = = 5 或 {5==5}或 5==5或{5 eq 5} | true |
!=或ne | 不等于 | 5 ! = 5 或 {5!=5}或 5!=5或{5 ne 5} | false |
<或lt | 小于 | 3 < 5 或 {3<5}或 3<5或{3 lt 5} | true |
>或gt | 大于 | 3 > 5 或 {3>5}或 3>5或{3 gt 5} | false |
<=或le | 小于等于 | 3 < = 5 或 {3<=5}或 3<=5或{3 le 5} | true |
>=或ge | 大于等于 | 3 > = 5 或 {3>=5}或 3>=5或{3 ge 5} | false |
&&或and | 并且 | KaTeX parse error: Expected '}', got '&' at position 6: {true&̲&false}或{true and false} | false |
!或not | 非 | ! t r u e 或 {!true}或 !true或{not true} | false |
||或or | 或者 | t r u e ∥ ∥ f a l s e 或 {true\|\|false}或 true∥∥false或{true or false} | true |
empty | 是否为空 | e m p t y “ ” , 可 以 判 断 字 符 串 、 数 据 、 集 合 的 长 度 是 否 为 0 , 为 0 返 回 t r u e 。 e m p t y 还 可 以 与 n o t 或 ! 一 起 使 用 。 {empty “”},可以判断字符串、数据、集合的长度是否为0,为0返回true。empty还可以与not或!一起使用。 empty“”,可以判断字符串、数据、集合的长度是否为0,为0返回true。empty还可以与not或!一起使用。{not empty “”} | true |
1.5 EL不显示null
当EL表达式的值为null时,会在页面上显示空白,即什么都不显示。
2 EL表达式格式
先来了解一下EL表达式的格式!现在还不能演示它,因为需要学习了EL11个内置对象后才方便显示它。
l 操作List和数组: l i s t [ 0 ] 、 {list[0]}、 list[0]、{arr[0]};
l 操作bean的属性: p e r s o n . n a m e 、 {person.name}、 person.name、{person[‘name’]},对应person.getName()方法;
l 操作Map的值: m a p . k e y 、 {map.key}、 map.key、{map[‘key’]},对应map.get(key)。
3 EL内置对象
EL一共11个内置对象,无需创建即可以使用。这11个内置对象中有10个是Map类型的,最后一个是pageContext对象。
l pageScope
l requestScope
l sessionScope
l applicationScope
l param;
l paramValues;
l header;
l headerValues;
l initParam;
l cookie;
l pageContext;
3.1 域相关内置对象(重点)
域内置对象一共有四个:
l pageScope:${pageScope.name}等同与pageContext.getAttribute(“name”);
l requestScope:${requestScope.name}等同与request.getAttribute(“name”);
l sessionScoep: ${sessionScope.name}等同与session.getAttribute(“name”);
l applicationScope:${applicationScope.name}等同与application.getAttribute(“name”);
如果在域中保存的是JavaBean对象,那么可以使用EL来访问JavaBean属性。因为EL只做读取操作,所以JavaBean一定要提供get方法,而set方法没有要求。
Person.java
public class Person {private String name;private int age;private String sex;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}}
全域查找:${person}表示依次在pageScope、requesScopet、sessionScope、appliationScope四个域中查找名字为person的属性。
3.2 请求参数相关内置对象
param和paramValues这两个内置对象是用来获取请求参数的。
l param:Map<String,String>类型,param对象可以用来获取参数,与request.getParameter()方法相同。
注意,在使用EL获取参数时,如果参数不存在,返回的是空字符串,而不是null。这一点与使用request.getParameter()方法是不同的。
l paramValues:paramValues是Map<String, String[]>类型,当一个参数名,对应多个参数值时可以使用它。
3.3 请求头相关内置对象
header和headerValues是与请求头相关的内置对象:
l header: Map<String,String>类型,用来获取请求头。
l headerValues:headerValues是Map<String,String[]>类型。当一个请求头名称,对应多个值时,使用该对象,这里就不在赘述。
3.4 应用初始化参数相关内置对象
l initParam:initParam是Map<String,String>类型。它对应web.xml文件中的参数。
3.5 Cookie相关内置对象
l cookie:cookie是Map<String,Cookie>类型,其中key是Cookie的名字,而值是Cookie对象本身。
3.6 pageContext对象
pageContext:pageContext是PageContext类型!可以使用pageContext对象调用getXXX()方法,例如pageContext.getRequest(),可以${pageContext.request}。也就是读取JavaBean属性!!!
EL表达式 | 说明 |
---|---|
${pageContext.request.queryString} | pageContext.getRequest().getQueryString(); |
${pageContext.request.requestURL} | pageContext.getRequest().getRequestURL(); |
${pageContext.request.contextPath} | pageContext.getRequest().getContextPath(); |
${pageContext.request.method} | pageContext.getRequest().getMethod(); |
${pageContext.request.protocol} | pageContext.getRequest().getProtocol(); |
${pageContext.request.remoteUser} | pageContext.getRequest().getRemoteUser(); |
${pageContext.request.remoteAddr} | pageContext.getRequest().getRemoteAddr(); |
${pageContext.session.new} | pageContext.getSession().isNew(); |
${pageContext.session.id} | pageContext.getSession().getId(); |
${pageContext.servletContext.serverInfo} | pageContext.getServletContext().getServerInfo(); |
EL函数库
1 什么EL函数库
EL函数库是由第三方对EL的扩展,我们现在学习的EL函数库是由JSTL添加的。JSTL明天再学!
EL函数库就是定义一些有返回值的静态方法。然后通过EL语言来调用它们!当然,不只是JSTL可以定义EL函数库,我们也可以自定义EL函数库。
EL函数库中包含了很多对字符串的操作方法,以及对集合对象的操作。例如:${fn:length(“abc”)}会输出3,即字符串的长度。
2 导入函数库
因为是第三方的东西,所以需要导入。导入需要使用taglib指令!
<%@ taglib prefix=“fn” uri=“http://java.sun.com/jsp/jstl/functions” %>
3 EL函数库介绍
l String toUpperCase(String input):
l String toLowerCase(String input):
l int indexOf(String input, String substring):
l boolean contains(String input, String substring):
l boolean containsIgnoreCase(String input, String substring):
l boolean startsWith(String input, String substring):
l boolean endsWith(String input, String substring):
l String substring(String input, int beginIndex, int endIndex):
l String substringAfter(String input, String substring):
l substringBefore(String input, String substring):
l String escapeXml(String input):”、’、<、>、&
l String trim(String input):
l String replace(String input, String substringBefore, String substringAfter):
l String[] split(String input, String delimiters):
l int length(Object obj):
l String join(String array[], String separator):
<%@taglib prefix=“fn” uri=“http://java.sun.com/jsp/jstl/functions” %>…String[] strs = {“a”, “b”,“c”};List list = new ArrayList();list.add(“a”);pageContext.setAttribute(“arr”, strs);pageContext.setAttribute(“list”, list);%>
f
n
:
l
e
n
g
t
h
(
a
r
r
)
<
b
r
/
>
<
!
−
−
3
−
−
>
{fn:length(arr) }<br/><!--3-->
fn:length(arr)<br/><!−−3−−>{fn:length(list) }
f
n
:
t
o
L
o
w
e
r
C
a
s
e
(
"
H
e
l
l
o
"
)
<
b
r
/
>
<
!
−
−
h
e
l
l
o
−
−
>
{fn:toLowerCase("Hello") }<br/> <!-- hello -->
fn:toLowerCase("Hello")<br/><!−−hello−−>{fn:toUpperCase(“Hello”) }
f
n
:
c
o
n
t
a
i
n
s
(
"
a
b
c
"
,
"
a
"
)
<
b
r
/
>
<
!
−
−
t
r
u
e
−
−
>
{fn:contains("abc", "a")}<br/><!-- true -->
fn:contains("abc","a")<br/><!−−true−−>{fn:containsIgnoreCase(“abc”, “Ab”)}
f
n
:
c
o
n
t
a
i
n
s
(
a
r
r
,
"
a
"
)
<
b
r
/
>
<
!
−
−
t
r
u
e
−
−
>
{fn:contains(arr, "a")}<br/><!-- true -->
fn:contains(arr,"a")<br/><!−−true−−>{fn:containsIgnoreCase(list, “A”)}
f
n
:
e
n
d
s
W
i
t
h
(
"
H
e
l
l
o
.
j
a
v
a
"
,
"
.
j
a
v
a
"
)
<
b
r
/
>
<
!
−
−
t
r
u
e
−
−
>
{fn:endsWith("Hello.java", ".java")}<br/><!-- true -->
fn:endsWith("Hello.java",".java")<br/><!−−true−−>{fn:startsWith(“Hello.java”, “Hell”)}
f
n
:
i
n
d
e
x
O
f
(
"
H
e
l
l
o
−
W
o
r
l
d
"
,
"
−
"
)
<
b
r
/
>
<
!
−
−
5
−
−
>
{fn:indexOf("Hello-World", "-")}<br/><!-- 5 -->
fn:indexOf("Hello−World","−")<br/><!−−5−−>{fn:join(arr, “;”)}
f
n
:
r
e
p
l
a
c
e
(
"
H
e
l
l
o
−
W
o
r
l
d
"
,
"
−
"
,
"
+
"
)
<
b
r
/
>
<
!
−
−
H
e
l
l
o
+
W
o
r
l
d
−
−
>
{fn:replace("Hello-World", "-", "+")}<br/><!-- Hello+World -->
fn:replace("Hello−World","−","+")<br/><!−−Hello+World−−>{fn:join(fn:split(“a;b;c;”, “;”), “-”)}
f
n
:
s
u
b
s
t
r
i
n
g
(
"
0123456789
"
,
6
,
9
)
<
b
r
/
>
<
!
−
−
678
−
−
>
{fn:substring("0123456789", 6, 9)}<br/><!-- 678 -->
fn:substring("0123456789",6,9)<br/><!−−678−−>{fn:substring(“0123456789”, 5, -1)}
f
n
:
s
u
b
s
t
r
i
n
g
A
f
t
e
r
(
"
H
e
l
l
o
−
W
o
r
l
d
"
,
"
−
"
)
<
b
r
/
>
<
!
−
−
W
o
r
l
d
−
−
>
{fn:substringAfter("Hello-World", "-")}<br/><!-- World -->
fn:substringAfter("Hello−World","−")<br/><!−−World−−>{fn:substringBefore(“Hello-World”, “-”)}
f
n
:
t
r
i
m
(
"
a
b
c
"
)
<
b
r
/
>
<
!
−
−
a
b
c
−
−
>
{fn:trim(" a b c ")}<br/><!-- a b c -->
fn:trim("abc")<br/><!−−abc−−>{fn:escapeXml("")}
4 自定义EL函数库
l 写一个类,写一个有返回值的静态方法;
l 编写itcast.tld文件,可以参数fn.tld文件来写,把itcast.tld文件放到/WEB-INF目录下;
l 在页面中添加taglib指令,导入自定义标签库。
ItcastFuncations.java
package cn.itcast.el.funcations;public class ItcastFuncations {public static String test() {return “传智播客自定义EL函数库测试”;}}
itcast.tld(放到classes下)
<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">
<tlib-version>1.0</tlib-version>
<short-name>itcast</short-name>
<uri>http://www.itcast.cn/jsp/functions</uri>
<function>
<name>test</name>
<function-class>cn.itcast.el.funcations.ItcastFuncations</function-class>
<function-signature>String test()</function-signature>
</function>
</taglib>
index.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="itcast" uri="/WEB-INF/itcast.tld" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<body>
<h1>${itcast:test() }</h1>
</body>
</html>
声明:此博文为个人学习笔记,参考了网络资源,如有侵权,请私信告知!