JSP详解
主要内容简介：
1. JSP简介
a) 什么是JSP
b) JSP的组成
c) JSP的特点
d) JSP的执行过程
e) JSP的生命周期
2. JSP语法
a) JSP模板元素
b) JSP表达式
c) JSP脚本片段
d) JSP注释
3. JSP指令
a) page指令
b) Include指令
c) taglib指令
4. JSP九大内置(隐式)对象
5.JSP的四个域对象
6. JSP的正确使用方法
7.EL表达式详解（重点）
8.JSP标签（重点）
a) 内置标签（动作标签）：不需要在jsp页面导入标签
b) include指令与include动作标签的区别
c) JSTL标签：需要在jsp页面中导入标签
d) 自定义标签：开发者自定义
一、JSP简介
1.什么是jsp
- JSP全称是Java Server Pages，它和Servle技术一样，都是SUN公司定义的一种用于开发动态web资源的技术
- JSP这门技术的最大的特点在于，写JSP就像写html，但：
相比html而言，（html只能为用户提供静态数据）JSP技术允许在页面中嵌套java代码，为用户提供动态数据。
相比servlet而言，jsp更容易对数据进行排版
2. JSP的组成
JSP使用Java脚本（代码片段），html，还有JSP动态标签构成的组成的
（JSP就是Servlet）
问题：为什么Jsp就是servlet！！！
jsp翻译的java文件：
publicfinal class _01_hello_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {
HttpJspBase类：
public abstract class org.apache.jasper.runtime.HttpJspBase extends javax.servlet.http.HttpServletimplements javax.servlet.jsp.HttpJspPage {
结论： Jsp就是一个servlet程序！！！
servlet的技术可以用在jsp程序中
jsp的技术并不是全部适用于servlet程序！
简单概念图
3. JSP的特点：
1）jsp的运行必须交给tomcat服务器！！！！
tomcat的work目录： tomcat服务器存放jsp运行时的临时文件
2）jsp页面既可以写html代码，也可以写java代码。
（html页面不能写java代码 。而jsp页面可以写java代码）
4. JSP的执行过程
a）浏览器访问JSP页面，tomcat扫描到JSP文件，在%tomcat%/work把jsp文件翻译成java源文件（翻译）
b）Tomcat服务器把java源文件编译成class字节码文件（编译）
c）Tomcat服务器构造该jsp对象
d）Tomcat服务器调用该jsp类中的方法，返回内容显示到浏览器
注意：只在第一次访问时需要 a,b ,c,d四步骤
第二次到n次只需要执行 d步骤。当jsp文件修改或零时文件被删除了需要重新走翻译（a）和编译（b）的过程。
5. JSP的生命周期（重点）
Servlet的生命周期：
1）构造方法（第1次访问）
2）init方法（第1次访问）
3）service方法
4）destroy方法
Jsp的生命周期
1）翻译： jsp->java文件
2）编译： java文件->class文件（servlet程序）
3）构造方法（第1次访问）
4）init方法（第1次访问）：_jspInit()
5）service方法：_jspService()
6）destroy方法：_jspDestroy()
二、JSP语法
1. JSP模板
JSP页面中的HTML内容称之为JSP模版元素。
JSP模版元素定义了网页的基本骨架，即定义了页面的结构和外观。
2. JSP表达式（expression）
语法：<%= 变量或表达式%>
作用：用于将程序数据输出到客户端
<%= “hello world ”%> == <% out.print( “hello world ”); %>注意：
1）表达式的原理其实就是吧语法中的内容翻译成out.print（“内容”）；
通过该方法向浏览器写出内容
2）表达式中不能带分号
3. JSP的脚本（scriptlet）
语法：<% 多行java代码 %>
作用：相当与在JSP翻译的Servlet类中的_jspService方法中写可以执行的代码。
注意：
1）JSP脚本片断中只能出现java代码，不能出现其它模板元素， JSP引擎在翻译JSP页面中，会将JSP脚本片断中的Java代码将被原封不动地放到Servlet的_jspService方法中。
2）JSP脚本片断中的Java代码必须严格遵循Java语法，例如，每执行语句后面必须用分号（;）结束。
3）在一个JSP页面中可以有多个脚本片断，在两个或多个脚本片断之间可以嵌入文本、HTML标记和其他JSP元素。
举例：
<%
int x = 10;
out.println(x);
%>
<p>这是JSP页面文本</p>
<%
int y = 20;
out.println(y+””+x);
%>4）多个脚本片断中的代码可以相互访问，犹如将所有的代码放在一对<%%>之中的情况。如：out.println(x);
5）单个脚本片断中的Java语句可以是不完整的，但是，多个脚本片断组合后的结果必须是完整的Java语句，例如：
<%
for (int i=1; i<5;i++)
{
%>
<H1>helloword</H1>
<%
}
%>
4. JSP的声明
语法：<%! 变量或方法 %>
作用：声明JSP的变量或方法（相当于在JSP翻译的Servlet类中写成员变量或方法）
注意：
1）JSP声明可用于定义JSP页面转换成的Servlet程序的静态代码块、成员变量和方法 。
2）多个静态代码块、变量和函数可以定义在一个JSP声明中，也可以分别单独定义在多个JSP声明中。
3）JSP隐式对象的作用范围仅限于Servlet的_jspService方法，所以在JSP声明中不能使用这些隐式对象。
<%!
static
{
System.out.println("loadingServlet!");
}
private intglobalVar = 0;
public voidjspInit()
{
System.out.println("initializingjsp!");
}
%>
<%!
public voidjspDestroy()
{
System.out.println("destroyingjsp!");
}
%>
5. JSP注释
语法：<%! -- jsp注释 --%>
注意：
1)html的注释会被翻译和执行。而jsp的注释不能被翻译和执行。
2)在JSP声明，脚本，表达式中可以用java的注释
三、JSP三大指令（directive）
概念：JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。在JSP 2.0规范中共定义了三个指令：
page指令
Include指令
taglib指令
JSP指令的基本语法格式：
<%@指令属性名="值" %>
举例：
<%@ pagecontentType="text/html;charset=UTF-8"%>如果一个指令有多个属性，这多个属性可以写在一个指令中，也可以分开写。
例如：
<%@ pagecontentType="text/html;charset=UTF-8"%>
<%@ pageimport="java.util.Date"%>也可以写作：
<%@ pagecontentType="text/html;charset=UTF-8"import="java.util.Date"%>
1. page指令
1）page指令用于定义JSP页面的各种属性，无论page指令出现在JSP页面中的什么地方，它作用的都是整个JSP页面，为了保持程序的可读性和遵循良好的编程习惯，page指令最好是放在整个JSP页面的起始位置。
2）page指令中的各个属性
<%@ page
language="java"
--告诉服务器使用什么动态语言来翻译jsp文件
（当年sun公司想让jsp支持多种语言定义了，后来由于某种原因没有完成，所以只能翻译为java语言）
import="java.util.*"
--告诉服务器java文件使用什么包导入包，多个包之间用逗号分割（建议分开导入包）
pageEncoding="utf-8"
--告诉服务器使用什么编码翻译jsp文件（成java文件）
contentType="text/html;charset=utf-8"
服务器发送浏览器的数据类型和内容编码
注意：在开发工具中，以后只需要设置pageEncoding即可解决中文乱码问题
与异常错误相关的：
errorPage="error.jsp"
isErrorPage="false"
Web.xml中配置全局的错误处理页面：（常用）
<!-- 全局错误处理页面配置 --> <error-page> <!-- 建议500错误使用JSP页面，因为500错误是动态的，不定的所以适合用jsp页面 --> <error-code>500</error-code> <location>/common/500.jsp</location> </error-page> <error-page> <!-- 404错误只有地址错误一种可能所以适合用同一个html页面 --> <error-code>404</error-code> <location>/common/404.html</location> </error-page> |
buffer="8kb"
设置jsp页面缓存大小，因为jsp页面有JSPWriter缓存机制，数据先会写到JSPWriter缓存中，然后一定条件下才会写入页面，所以如果不需要缓存机制 可以设置为 “0kb”
session="true"
是否开启session功能。false，不能用session内置对象；true，可以使用session内置对象。
isELIgnored="false"
是否忽略EL表达式
%>
2. include指令（静态包含）
原理： include指令用于引入其它JSP页面，如果使用include指令引入了其它JSP页面，那么JSP引擎将把这两个JSP翻译成一个servlet。所以include指令引入通常也称之为静态引入。
语法：
<%@ includefile="relativeURL"%>
其中的file属性用于指定被引入文件的相对路径。 file属性的设置值必须使用相对路径，如果以“/”开头，表示相对于当前WEB应用程序的根目录（注意不是站点根目录），否则，表示相对于当前文件。
细节：
被引入的文件必须遵循JSP语法。
被引入的文件可以使用任意的扩展名，即使其扩展名是html，JSP引擎也会按照处理jsp页面的方式处理它里面的内容，为了见明知意，JSP规范建议使用.jspf（JSP fragments）作为静态引入文件的扩展名。
由于使用include指令将会涉及到2个JSP页面，并会把2个JSP翻译成一个servlet，所以这2个JSP页面的指令不能冲突（除了pageEncoding和导包除外）。
（其实就是相当于吧两个JSP中的内容翻译到一个servlet中从生成的jspServlet文件中可以看出其实相当于把所有的信息原封不动的拿了过来。这就有可能导致当定义两个相同名称的变量是会出现错误）
out.write('\r');
out.write('\n');
out.write("\r\n");
out.write("\r\n");
out.write("<!DOCTYPE html PUBLIC\"-//W3C//DTD HTML 4.01 Transitional//EN\"\"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
out.write("<html>\r\n");
out.write("<head>\r\n");
out.write("<metahttp-equiv=\"Content-Type\" content=\"text/html;charset=UTF-8\">\r\n");
out.write("<title>Insert titlehere</title>\r\n");
out.write("</head>\r\n");
out.write("<body>\r\n");
out.write("\tHello ");
out.write("\r\n");
out.write("<!DOCTYPE html PUBLIC\"-//W3C//DTD HTML 4.01 Transitional//EN\"\"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
out.write("<html>\r\n");
out.write("<head>\r\n");
out.write("<metahttp-equiv=\"Content-Type\" content=\"text/html;charset=UTF-8\">\r\n");
out.write("<title>Insert titlehere</title>\r\n");
out.write("</head>\r\n");
out.write("<body>\r\n");
out.write(" world\r\n");
out.write("</body>\r\n");
out.write("</html>");
out.write("\r\n");
out.write("</body>\r\n"); out.write("</html>");网页源代码
3. taglib指令
四、JSP的九大内置（隐式）对象（重点）
1. 什么是内置对象
在jsp开发中，会频繁使用到一些对象例如：
HttpSession
ServletContext,
ServletContext,
HttpServletRequet。
如果我们每次要使用这些对象都要去创建这些对象就会显得有点麻烦，所以sun公司设计jsp时，在jsp页面加载完毕之后就会自动帮开发者创建好这些对象，而开发者只需要直接使用这些对象调用方法即可！，这些创建好的对象就叫内置对象
举例：
servlet:
HttpSessionsession = request.getSession(true); （需要开发者做）
jsp:
tomcat服务器： HttpSession session =request.getSession(true);(不需要开发者做)
开发者做的： session.getId();
2. 九大内置对象
request HttpServletRequest ----|
response HttpServletResponse ----|
session HttpSession ----|--------在servlet中也可以用的五个对象
application ServletcContext ----|
config ServletConfig ----|
exception Throwable (当设置page指令的isErorrPage属性是才可以使用)
page Object(this) (本JSP页面)
out JspWriter （带缓冲的PrintWriter）
pageContext PageContext (使普通Java类可访问WEB资源，自定义标签常用)
内置对象特点:
1. 由JSP规范提供,不用编写者实例化。
2. 通过Web容器实现和管理
3. 所有JSP页面均可使用
4. 只有在脚本元素的表达式或代码段中才可使用(<%=使用内置对象%>或<%使用内置对象%>)
内置对象可分为四类:
1. 输出输入对象:request对象、response对象、out对象
2. 通信控制对象:pageContext对象、session对象、application对象
3. Servlet对象:page对象、config对象
4. 错误处理对象:exception对象
对象常用方法说明:
1.request对象(请求信息 javax.servlet.http.HttpServletrequest)
方法名 | 描述 |
isUserInRole | 判断认证后的用户是否属于某一成员组 |
getAttribute | 获取指定属性的值,如该属性值不存在返回Null |
getAttributeNames | 获取所有属性名的集合 |
getCookies | 获取所有Cookie对象 |
getCharacterEncoding | 获取请求的字符编码方式 |
getContentLength | 返回请求正文的长度,如不确定返回-1 |
getHeader | 获取指定名字报头值 |
getHeaders | 获取指定名字报头的所有值,一个枚举 |
getHeaderNames | 获取所有报头的名字,一个枚举 |
getInputStream | 返回请求输入流,获取请求中的数据 |
getMethod | 获取客户端向服务器端传送数据的方法 |
getParameter | 获取指定名字参数值 |
getParameterNames | 获取所有参数的名字,一个枚举 |
getParameterValues | 获取指定名字参数的所有值 |
getProtocol | 获取客户端向服务器端传送数据的协议名称 |
getQueryString | 获取以get方法向服务器传送的查询字符串 |
getRequestURI | 获取发出请求字符串的客户端地址 |
getRemoteAddr | 获取客户端的IP地址 |
getRemoteHost | 获取客户端的名字 |
getSession | 获取和请求相关的会话 |
getServerName | 获取服务器的名字 |
getServerPath | 获取客户端请求文件的路径 |
getServerPort | 获取服务器的端口号 |
removeAttribute | 删除请求中的一个属性 |
setAttribute | 设置指定名字参数值 |
特点：Request(Javax.servlet.ServletRequest)它包含了有关浏览器请求的信息.通过该对象可以获得请求中的头信息、Cookie和请求参数。
2.response对象(响应 javax.servlet.http.HttpServletResponse)
方法名 | 描述 |
addCookie | 添加一个Cookie对象 |
addHeader | 添加Http文件指定名字头信息 |
containsHeader | 判断指定名字Http文件头信息是否存在 |
encodeURL | 使用sessionid封装URL |
flushBuffer | 强制把当前缓冲区内容发送到客户端 |
getBufferSize | 返回缓冲区大小 |
getOutputStream | 返回到客户端的输出流对象 |
sendError | 向客户端发送错误信息 |
sendRedirect | 把响应发送到另一个位置进行处理 |
setContentType | 设置响应的MIME类型 |
setHeader | 设置指定名字的Http文件头信息 |
特点Response(Javax.servlet.ServletResponse)作为JSP页面处理结果返回给用户的响应存储在该对象中。并提供了设置响应内容、响应头以及重定向的方法(如cookies,头信息等)
3.session对象(会话 javax.servlet.http.HttpSession)
方法名 | 描述 |
getAttribute | 获取指定名字的属性 |
getAttributeNames | 获取session中全部属性名字,一个枚举 |
getCreationTime | 返回session的创建时间 |
getId | 获取会话标识符 |
getLastAccessedTime | 返回最后发送请求的时间 |
getMaxInactiveInterval | 返回session对象的生存时间单位千分之一秒 |
invalidate | 销毁session对象 |
isNew | 每个请求是否会产生新的session对象 |
removeAttribute | 删除指定名字的属性 |
setAttribute | 设定指定名字的属性值 |
4.application对象(应用程序 javax.servlet.ServletContext)
方法名 | 描述 |
getAttribute | 获取应用对象中指定名字的属性值 |
getAttributeNames | 获取应用对象中所有属性的名字,一个枚举 |
getInitParameter | 返回应用对象中指定名字的初始参数值 |
getServletInfo | 返回Servlet编译器中当前版本信息 |
setAttribute | 设置应用对象中指定名字的属性值 |
特点：Application(javax.servle.ServletContext)存储了运行JSP页面的servlet以及在同一应用程序中的任何Web组件的上下文信息。
5.config对象(Servlet的配置信息 javax.servlet.ServletConfig)
方法名 | 描述 |
getServletContext | 返回所执行的Servlet的环境对象 |
getServletName | 返回所执行的Servlet的名字 |
getInitParameter | 返回指定名字的初始参数值 |
getInitParameterNames | 返回该JSP中所有的初始参数名,一个枚举 |
特点：Config(javax.servlet.ServletConfig)该对象用于存取servlet实例的初始化参数。
6.page对象(当前JSP的实例,java.lang.object)
它代表JSP被编译成Servlet,可以使用它来调用Servlet类中所定义的方法
特点：Page(Java.lang.Object)表示当前JSP页面的servlet实例
可以用他来获取整个类中的所有方法和成员变量（反射）
7.out对象(数据流 javax.servlet.jsp.jspWriter)（重点）
方法名 | 描述 |
print或println | 输出数据 |
newLine | 输出换行字符 |
flush | 输出缓冲区数据 |
close | 关闭输出流 |
clear | 清除缓冲区中数据,但不输出到客户端 |
clearBuffer | 清除缓冲区中数据,输出到客户端 |
getBufferSize | 获得缓冲区大小 |
getRemaining | 获得缓冲区中没有被占用的空间 |
isAutoFlush | 是否为自动输出 |
1.用于将内容写入JSP页面实例的输出流中,提供了几个方法使你能用于向浏览器回送输出结果。特点：Out(Javax.servlet.jsp.JspWriter)
2.out对象是通过调用pageContext对象的getOut方法返回的，其作用和用法与ServletResponse.getWriter方法返回的PrintWriter对象非常相似。
3.JSP页面中的out隐式对象的类型为JspWriter，JspWriter相当于一种带缓存功能的PrintWriter，设置JSP页面的page指令的buffer属性可以调整它的缓存大小，甚至关闭它的缓存。
4.只有向out对象中写入了内容，且满足如下任何一个条件时，out对象才去调用ServletResponse.getWriter方法，并通过该方法返回的PrintWriter对象将out对象的缓冲区中的内容真正写入到Servlet引擎提供的缓冲区中：
- 设置page指令的buffer属性关闭了out对象的缓存功能
- out对象的缓冲区已满
- 整个JSP页面结束
out隐式对象工作原理
8.pageContext对象(页面上下文 javax.servlet.jsp.PageContext)
方法名 | 描述 |
forward | 重定向到另一页面或Servlet组件 |
getAttribute | 获取某范围中指定名字的属性值 |
findAttribute | 按范围搜索指定名字的属性，先后查找各个域中的属性 |
removeAttribute | 删除某范围中指定名字的属性 |
setAttribute | 设定某范围中指定名字的属性值 |
getException | 返回当前异常对象 |
getRequest | 返回当前请求对象 |
getResponse | 返回当前响应对象 |
getServletConfig | 返回当前页面的ServletConfig对象 |
getServletContext | 返回所有页面共享的ServletContext对象 |
getSession | 返回当前页面的会话对象 |
常见的用法：
特点： pageContext对象的类型是PageContext，叫jsp的上下文对象
1）可以获取其他八个内置对象
publicclass 01_hello_jsp {
publicvoid _jspService(request,response){
创建内置对象
HttpSessionsession =....;
ServletConfigconfig = ....;
把8个经常使用的内置对象封装到PageContext对象中
PageContextpageContext = 封装；
调用method1方法
method1(pageContext);
}
publicvoid method1(PageContext pageContext){
希望使用内置对象
从PageContext对象中获取其他8个内置对象
JspWriterout =pageContext.getOut();
HttpServletRequestrquest = pageContext.getRequest();
........
}
}
使用场景：在自定义标签的时候，PageContext对象频繁使用到！！！
2）本身是一个域对象
ServletContextcontext域
HttpServletRequet request域
HttpSession session域 --Servlet学习的
PageContext page域 --jsp学习的
作用：保存数据和获取数据，用于共享数据
#保存数据
）默认情况下，保存到page域
pageContext.setAttribute("name");
2）可以向四个域对象保存数据
pageContext.setAttribute("name",域范围常量)
#获取数据
1）默认情况下，从page域获取
pageContext.getAttribute("name")
2）可以从四个域中获取数据
pageContext.getAttribute("name",域范围常量)
等价于
域对象.getAttribute(“name”)
域范围常量:（可以使用pageContext.setAttribute(key,value,域范围常量)来设置添加的数据添加到那个域）
PageContext.PAGE_SCOPE
PageContext.REQUEST_SCOPE
PageContext..SESSION_SCOPE
PageContext.APPLICATION_SCOPE
3）自动在四个域中搜索数据（从作用域最低的域开始找）
pageContext.findAttribute("name");
顺序： page域 ->request域 -> session域- >context域（application域）
4）引入和跳转到其他资源（重点）
PageContext类中定义了一个forward方法和两个include方法来分别简化和替代RequestDispatcher.forward方法和include方法
传递给这些方法的资源路径，如果路径以“/”开头，表示相对于当前WEB应用程序的根目录，否则，表示相对于当前JSP所映射到的访问路径。
9.exception对象(运行时的异常,java.lang.Throwable)
被调用的错误页面的结果,只有在错误页面中才可使用,
即在页面指令中设置:<%@page isErrorPage=“true”%>
Exception(Javax.lang.Throwable)在某个页面抛出异常时,将转发至JSP错误页面,提供此对象是为了在JSP中处理错误。只有在错误页面中才可使用<%@page isErrorPage=“true”%>
Jsp内置对象 | 功能 | 主要方法 |
out | 向客户端输出数据 | print() println() flush() clear() isAutoFlush() getBufferSize() close() ………… |
request | 向客户端请求数据 | getAttributeNames() getCookies() getParameter() getParameterValues() setAttribute() getServletPath() ………….. |
response | 封装了jsp产生的响应,然后被发送到客户端以响应客户的请求 | addCookie() sendRedirect() setContentType() flushBuffer() getBufferSize() getOutputStream() sendError() containsHeader()…………… |
application |
|
|
config | 表示Servlet的配置,当一个Servlet初始化时,容器把某些信息通过此对象传递给这个Servlet | getServletContext() getServletName() getInitParameter() getInitParameterNames()…………… |
page | Jsp实现类的实例,它是jsp本身,通过这个可以对它进行访问 | flush()……… |
pagecontext | 为JSP页面包装页面的上下文。管理对属于JSP中特殊可见部分中己经命名对象的该问 | forward() getAttribute() getException() getRequest() getResponse() getServletConfig() getSession() getServletContext() setAttribute() removeAttribute() findAttribute() …………… |
session | 用来保存每个用户的信息,以便跟踪每个用户的操作状态 | getAttribute() getId() getAttributeNames() getCreateTime() getMaxInactiveInterval() invalidate() isNew() |
exception | 反映运行的异常 | getMessage()………… |
五、JSP的四个域对象
pageContext page域(jsp有效) pageContext.
request request域(一次请求) HttpServletRequest
Session session域(一次会话) HTTPSession
Application Context域(当前web应用) ServletContext
之所以他们是域对象，原因就是他们都内置了map集合，都有setAttribute getAttribute方法。
他们都有自己固定的生命周期和作用域。这四个对象的生命周期(生命周期就是值对象的创建到销毁的期间)。
四个域对象的生命周期：
· page：jsp页面被执行，生命周期开始，jsp页面执行完毕，声明周期结束。
· request:用户发送一个请求，开始，服务器返回响应，请求结束，生命周期结束。
· session:用户打开浏览器访问，创建session(开始),session超时或被声明失效，该对象生命周期结束。
· application：web应用加载的时候创建。Web应用被移除或服务器关闭，对象销毁。[结束]。
注意：
· Page只在当前jsp有效，每次请求分别对应不同的request。
· Request只在当前请求有效，每次请求分别对应不同的request域。
· Session只在一次会话中有效，会话结束就无法取到数据了。
四个域对象在选择的时候，能用范围小的绝不用范围大的：
page:数据只是暂时存在集合，在jsp页面的其他地方要用，用page(页面中自定义的map)。
Request:数据只是做显示的，看完了就没用了。就存request域，请求转发，Servlet产生的处理结果（数据）交给jsp显示，数据转发可以带数据。
Session:数据给用户看完了，一定还要用，会话结束了就没用了。用户登录，用户信息发给客户端看，看完了，一会访问别的页面还要看用户信息。 购物车，购物车成功了，给用户看购物车，待会随时间可以查看购物车。 请求重定向，因为是两次请求，每一次请求的数据，第二次请求还要看。
application:数据给一个用户用完了，别人还要用。聊天室，聊天记录，需要给所有的用户看。 统计网站在线人数，所有看到的应该是一个数。
总结：
1）域对象作用：
保存数据 和 获取数据 ，用于数据共享。
2）域对象方法：
setAttribute("name",Object)保存数据
getAttribute("name") 获取数据
removeAttribute("name")清除数据
3）域对象作用范围：
page域：只能在当前jsp页面中使用（当前页面）
request域：只能在同一个请求中使用（转发）
session域：只能在同一个会话（session对象）中使用（私有的）
context域：只能在同一个web应用中使用。（全局的）
四个域对象在选择的时候，能用范围小的绝不用范围大的。需要定义Map时不如用page，请求Servlet，转发给jsp的数据存request，请求重定向带过去的数据存Session，全局的数据存application。
六、JSP的正确使用方法
Servlet技术： 开发动态资源。是一个java类，最擅长写java代码
jsp技术： 开发动态资源。通过java代码最擅长输出html代码。
（尽量在jsp页面中少写甚至不写java代码。）
各取所长：
在web项目中涉及到逻辑：
1）接收参数 servlet做
2）处理业务逻辑，返回结果 servlet做
3）显示数据到浏览器 jsp做
4）跳转到其他页面 servlet做
servlet+jsp模式
servlet:
1）接收参数
2）处理业务逻辑
3）把结果保存到域对象中
4）跳转到jsp页面
Jsp:
1）从域对象取出数据
2）把数据显示到浏览器
servlet的数据 -> jsp页面
List<Contact> 使用域对象共享数据
七、EL表达式 （Expression Language）
EL表达式的主要作用：
1. 获取（域对象中的）数据：
EL表达式主要用于替换JSP页面中的脚本表达式，以从各种类型的web域中检索java对象、获取数据。(某个web域中的对象，访问javabean的属性、访问list集合、访问map集合、访问数组)
EL既可以用来创建算术表达式也可以用来创建逻辑表达式。在JSPEL表达式内可以使用整型数，浮点数，字符串，常量true、false，还有null。
一个简单的语法
典型的，当您需要在JSP标签中指定一个属性值时，只需要简单地使用字符串即可：
<jsp:setProperty name="box" property="perimeter" value="100"/>
JSP EL允许您指定一个表达式来表示属性值。一个简单的表达式语法如下：
${expr}
其中，expr指的是表达式。在JSPEL中通用的操作符是 . 和 {} 。这两个操作符允许您通过内嵌的JSP对象访问各种各样的JavaBean属性。
举例来说，上面的<jsp:setProperty>标签可以使用表达式语言改写成如下形式：
<jsp:setProperty name="box" property="perimeter"
value="${2*box.width+2*box.height}"/>
当JSP编译器在属性中见到"${}"格式后，它会产生代码来计算这个表达式，并且产生一个替代品来代替表达式的值。
您也可以在标签的模板文本中使用表达式语言。比如<jsp:text>标签简单地将其主体中的文本插入到JSP输出中：
<jsp:text><h1>Hello JSP!</h1></jsp:text>
现在，在<jsp:text>标签主体中使用表达式，就像这样：
<jsp:text>
Box Perimeter is: ${2*box.width + 2*box.height}</jsp:text>
在EL表达式中可以使用圆括号来组织子表达式。比如${(1 + 2) * 3}等于9，但是${1+ (2 * 3)} 等于7。
想要停用对EL表达式的评估的话，需要使用page指令将isELIgnored属性值设为true：
<%@ page isELIgnored ="true|false" %>
这样，EL表达式就会被忽略。若设为false，则容器将会计算EL表达式。
EL中的基础操作符
EL表达式支持大部分Java所提供的算术和逻辑操作符：
操作符 | 描述 |
. | 访问一个Bean属性或者一个映射条目 |
[] 重点 | 访问一个数组或者链表的元素 可以传入带敏感字符的变量名 |
( ) | 组织一个子表达式以改变优先级 |
+ | 加 |
- | 减或负 |
* | 乘 |
/ or div | 除 |
% or mod | 取模 |
== or eq | 测试是否相等 |
!= or ne | 测试是否不等 |
< or lt | 测试是否小于 |
> or gt | 测试是否大于 |
<= or le | 测试是否小于等于 |
>= or ge | 测试是否大于等于 |
&& or and | 测试逻辑与 |
|| or or | 测试逻辑或 |
! or not | 测试取反 |
empty | 测试是否空值 |
el表达式的使用
${变量}
输出普通字符串： ${name}
输出对象属性： ${student.name} 注意： .name 相当于 .getName（）方法
输出List集合： ${list[0].name } 注意： [0] 相当于 get（下标）方法
输出map集合： ${map[key].name} 注意： ［key］相当于get（key）方法
注意：[ ]可在el表达式中输出带敏感字符的变量名${requestScope["Accept-Language"]}
JSP EL中的函数
JSP EL允许您在表达式中使用函数。这些函数必须被定义在自定义标签库中。函数的使用语法如下：
${ns:func(param1, param2, ...)}
ns指的是命名空间（namespace），func指的是函数的名称，param1指的是第一个参数，param2指的是第二个参数，以此类推。比如，有函数fn:length，在JSTL库中定义，可以像下面这样来获取一个字符串的长度：
${fn:length("Get my length")}
要使用任何标签库中的函数，您需要将这些库安装在服务器中，然后使用<taglib>标签在JSP文件中包含这些库。
JSP EL隐含对象
JSP EL支持下表列出的隐含对象：
隐含对象 | 描述 |
pageScope | page 作用域 |
requestScope | request 作用域 |
sessionScope | session 作用域 |
applicationScope | application 作用域 |
param | Request 对象的参数，字符串 |
paramValues | Request对象的参数，字符串集合 |
header | HTTP 信息头，字符串 |
headerValues | HTTP 信息头，字符串集合 |
initParam | 上下文初始化参数 |
cookie | Cookie值 |
pageContext | 当前页面的pageContext可以获取任何域对象 |
您可以在表达式中使用这些对象，就像使用变量一样。接下来会给出几个例子来更好的理解这个概念。
pageContext对象
pageContext对象是JSP中pageContext对象的引用。通过pageContext对象，您可以访问request对象。比如，访问request对象传入的查询字符串，就像这样：
${pageContext.request.queryString}
Scope对象
pageScope，requestScope，sessionScope，applicationScope变量用来访问存储在各个作用域层次的变量。
举例来说，如果您需要显式访问在applicationScope层的box变量，可以这样来访问：applicationScope.box。
param和paramValues对象
param和paramValues对象用来访问参数值，通过使用request.getParameter方法和request.getParameterValues方法。
举例来说，访问一个名为order的参数，可以这样使用表达式：${param.order}，或者${param["order"]}。
接下来的例子表明了如何访问request中的username参数：
<%@ page import="java.io.*,java.util.*" %><%
String title = "Accessing Request Param";
%><html><head><title><% out.print(title); %></title></head><body><center><h1><% out.print(title); %></h1></center><div align="center"><p>${param["username"]}</p></div></body></html>
param对象返回单一的字符串，而paramValues对象则返回一个字符串数组。
header和headerValues对象
header和headerValues对象用来访问信息头，通过使用 request.getHeader方法和request.getHeaders方法。
举例来说，要访问一个名为user-agent的信息头，可以这样使用表达式：${header.user-agent}，或者${header["user-agent"]}。
接下来的例子表明了如何访问user-agent信息头：
<%@ page import="java.io.*,java.util.*" %><%
String title = "User Agent Example";
%><html><head><title><% out.print(title); %></title></head><body><center><h1><% out.print(title); %></h1></center><div align="center"><p>${header["user-agent"]}</p></div></body></html>
八、JSP标签（重点）
1. JSP标签的作用
替换jsp脚本
1）流程判断（if for循环）
2）跳转页面（转发，重定向）
2.JSP标签的分类
1）内置标签（动作标签）：不需要在jsp页面导入标签
2）JSTL标签：需要在jsp页面中导入标签
3）自定义标签：开发者自行定义，需要在jsp页面导入标签
动作标签：
该部分内容引用自菜鸟教程
与JSP指令元素不同的是，JSP动作元素在请求处理阶段起作用。JSP动作元素是用XML语法写成的。
利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。
动作元素只有一种语法，它符合XML标准：
<jsp:action_name attribute="value" />
动作元素基本上都是预定义的函数，JSP规范定义了一系列的标准动作，它用JSP作为前缀，可用的标准动作元素如下：
语法 | 描述 |
jsp:include | 在页面被请求的时候引入一个文件。 |
jsp:useBean | 寻找或者实例化一个JavaBean。 |
jsp:setProperty | 设置JavaBean的属性。 |
jsp:getProperty | 输出某个JavaBean的属性。 |
jsp:forward | 把请求转到一个新的页面。 |
jsp:plugin | 根据浏览器类型为Java插件生成OBJECT或EMBED标记。 |
jsp:element | 定义动态XML元素 |
jsp:attribute | 设置动态定义的XML元素属性。 |
jsp:body | 设置动态定义的XML元素内容。 |
jsp:text | 在JSP页面和文档中使用写入文本的模板 |
常见的属性
所有的动作要素都有两个属性：id属性和scope属性。
· id属性：
id属性是动作元素的唯一标识，可以在JSP页面中引用。动作元素创建的id值可以通过PageContext来调用。
· scope属性：
该属性用于识别动作元素的生命周期。 id属性和scope属性有直接关系，scope属性定义了相关联id对象的寿命。 scope属性有四个可能的值： (a) page, (b)request, (c)session, 和 (d)application。
·
·
<jsp:include>动作元素
<jsp:include>动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。语法格式如下：
<jsp:include page="相对 URL 地址" flush="true" />
前面已经介绍过include指令，它是在JSP文件被转换成Servlet的时候引入文件，而这里的jsp:include动作不同，插入文件的时间是在页面被请求的时候。
以下是include动作相关的属性列表。
属性 | 描述 |
page | 包含在页面中的相对URL地址。 |
flush | 布尔属性，定义在包含资源前是否刷新缓存区。 |
实例
以下我们定义了两个文件 date.jsp 和 main.jsp，代码如下所示：
date.jsp文件代码：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%><p>
今天的日期是: <%= (new java.util.Date()).toLocaleString()%></p>
main.jsp文件代码：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鸟教程(runoob.com)</title></head><body>
<h2>include 动作实例</h2><jsp:include page="date.jsp" flush="true" />
</body></html>
现在将以上两个文件放在服务器的根目录下，访问main.jsp文件。显示结果如下：
include 动作实例
今天的日期是: 2016-6-25 14:08:17
<jsp:useBean>动作元素
jsp:useBean 动作用来加载一个将在JSP页面中使用的JavaBean。
这个功能非常有用，因为它使得我们可以发挥 Java 组件复用的优势。
jsp:useBean动作最简单的语法为：
<jsp:useBean id="name" class="package.class" />
在类载入后，我们既可以通过 jsp:setProperty 和 jsp:getProperty 动作来修改和检索bean的属性。
以下是useBean动作相关的属性列表。
属性 | 描述 |
class | 指定Bean的完整包名。 |
type | 指定将引用该对象变量的类型。 |
beanName | 通过 java.beans.Beans 的 instantiate() 方法指定Bean的名字。 |
在给出具体实例前，让我们先来看下 jsp:setProperty 和 jsp:getProperty 动作元素：
<jsp:setProperty>动作元素
jsp:setProperty用来设置已经实例化的Bean对象的属性，有两种用法。首先，你可以在jsp:useBean元素的外面（后面）使用jsp:setProperty，如下所示：
<jsp:useBean id="myName" ... />
...<jsp:setProperty name="myName" property="someProperty" .../>
此时，不管jsp:useBean是找到了一个现有的Bean，还是新创建了一个Bean实例，jsp:setProperty都会执行。第二种用法是把jsp:setProperty放入jsp:useBean元素的内部，如下所示：
<jsp:useBean id="myName" ... >
...
<jsp:setProperty name="myName" property="someProperty" .../></jsp:useBean>
此时，jsp:setProperty只有在新建Bean实例时才会执行，如果是使用现有实例则不执行jsp:setProperty。
jsp:setProperty动作有下面四个属性,如下表：
属性 | 描述 |
name | name属性是必需的。它表示要设置属性的是哪个Bean。 |
property | property属性是必需的。它表示要设置哪个属性。有一个特殊用法：如果property的值是"*"，表示所有名字和Bean属性名字匹配的请求参数都将被传递给相应的属性set方法。 |
value | value 属性是可选的。该属性用来指定Bean属性的值。字符串数据会在目标类中通过标准的valueOf方法自动转换成数字、boolean、Boolean、 byte、Byte、char、Character。例如，boolean和Boolean类型的属性值（比如"true"）通过 Boolean.valueOf转换，int和Integer类型的属性值（比如"42"）通过Integer.valueOf转换。 value和param不能同时使用，但可以使用其中任意一个。 |
param | param 是可选的。它指定用哪个请求参数作为Bean属性的值。如果当前请求没有参数，则什么事情也不做，系统不会把null传递给Bean属性的set方法。因此，你可以让Bean自己提供默认属性值，只有当请求参数明确指定了新值时才修改默认属性值。 |
<jsp:getProperty>动作元素
jsp:getProperty动作提取指定Bean属性的值，转换成字符串，然后输出。语法格式如下：
<jsp:useBean id="myName" ... />
...<jsp:getProperty name="myName" property="someProperty" .../>
下表是与getProperty相关联的属性：
属性 | 描述 |
name | 要检索的Bean属性名称。Bean必须已定义。 |
property | 表示要提取Bean属性的值 |
实例
以下实例我们使用了Bean:
package com.runoob.main;
public class TestBean {
private String message = "菜鸟教程";
public String getMessage() {
return(message);
}
public void setMessage(String message) {
this.message = message;
}}
编译以上实例文件 TestBean.java ：
$ javac TestBean.java
编译完成后会在当前目录下生成一个 TestBean.class 文件，将该文件拷贝至当前 JSP 项目的 WebContent/WEB-INF/classes/com/runoob/main 下( com/runoob/main 包路径，没有需要手动创建)。
下面是一个 Eclipse 中目录结构图：
下面是一个很简单的例子，它的功能是装载一个Bean，然后设置/读取它的message属性。
现在让我们在main.jsp文件中调用该Bean:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鸟教程(runoob.com)</title></head><body>
<h2>Jsp 使用 JavaBean 实例</h2><jsp:useBean id="test" class="com.runoob.main.TestBean" />
<jsp:setProperty name="test"
property="message"
value="菜鸟教程..." />
<p>输出信息....</p>
<jsp:getProperty name="test" property="message" />
</body></html>
浏览器访问，执行以上文件，输出如下所示：
<jsp:forward>动作元素
jsp:forward动作把请求转到另外的页面。jsp:forward标记只有一个属性page。语法格式如下所示：
<jsp:forward page="相对 URL 地址" />
以下是forward相关联的属性：
属性 | 描述 |
page | page属性包含的是一个相对URL。page的值既可以直接给出，也可以在请求的时候动态计算，可以是一个JSP页面或者一个 Java Servlet. |
实例
以下实例我们使用了两个文件，分别是： date.jsp 和 main.jsp。
date.jsp 文件代码如下：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%><p>
今天的日期是: <%= (new java.util.Date()).toLocaleString()%></p>
main.jsp文件代码：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鸟教程(runoob.com)</title></head><body>
<h2>forward 动作实例</h2><jsp:forward page="date.jsp" /></body></html>
现在将以上两个文件放在服务器的根目录下，访问main.jsp文件。显示结果如下：
今天的日期是: 2016-6-25 14:37:25
<jsp:plugin>动作元素
jsp:plugin动作用来根据浏览器的类型，插入通过Java插件 运行Java Applet所必需的OBJECT或EMBED元素。
如果需要的插件不存在，它会下载插件，然后执行Java组件。 Java组件可以是一个applet或一个JavaBean。
plugin动作有多个对应HTML元素的属性用于格式化Java 组件。param元素可用于向Applet或 Bean 传递参数。
以下是使用plugin 动作元素的典型实例:
<jsp:plugin type="applet" codebase="dirname" code="MyApplet.class"
width="60" height="80">
<jsp:param name="fontcolor" value="red" />
<jsp:param name="background" value="black" />
<jsp:fallback>
Unable to initialize Java Plugin
</jsp:fallback>
</jsp:plugin>
如果你有兴趣可以尝试使用applet来测试jsp:plugin动作元素，<fallback>元素是一个新元素，在组件出现故障的错误是发送给用户错误信息。
<jsp:element> 、 <jsp:attribute>、 <jsp:body>动作元素
<jsp:element> 、 <jsp:attribute>、 <jsp:body>动作元素动态定义XML元素。动态是非常重要的，这就意味着XML元素在编译时是动态生成的而非静态。
以下实例动态定义了XML元素：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鸟教程(runoob.com)</title></head><body><jsp:element name="xmlElement"><jsp:attribute name="xmlElementAttr">
属性值</jsp:attribute><jsp:body>
XML 元素的主体</jsp:body></jsp:element></body></html>
浏览器访问以下页面，输出结果如下所示：
<jsp:text>动作元素
<jsp:text>动作元素允许在JSP页面和文档中使用写入文本的模板，语法格式如下：
<jsp:text>模板数据</jsp:text>
以上文本模板不能包含其他元素，只能只能包含文本和EL表达式（注：EL表达式将在后续章节中介绍）。请注意，在XML文件中，您不能使用表达式如 ${whatever > 0}，因为>符号是非法的。 你可以使用${whatever gt 0}表达式或者嵌入在一个CDATA部分的值。
<jsp:text><![CDATA[<br>]]></jsp:text>
如果你需要在 XHTML 中声明DOCTYPE,必须使用到<jsp:text>动作元素，实例如下：
<jsp:text><![CDATA[<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"DTD/xhtml1-strict.dtd">]]></jsp:text><head><title>jsp:text action</title></head><body>
<books><book><jsp:text>
Welcome to JSP Programming</jsp:text></book></books>
</body></html>
3. include指令和include动作标签的区别
<%@include file = “”%>指令是静态包含
<jsp:include/> 动作标签是动态包含
原理： 包含与被包含的页面先各自翻译成java源文件，然后再运行时合并在一起。
（先翻译再合并），动态包含
1） 语法不同
静态包含语法： <%@incluefile="被包含的页面"%>
动态包含语法： <jsp:includepage="被包含的页面">
2）参数传递不同
静态包含不能向被包含页面传递参数
动态包含可以向被包含页面传递参数
3）原理不同
静态包含： 先合并再翻译
动态包含： 先翻译再合并
4. JSTL标签
1）.JSTL (全名：java standard tag libarary - java标准标签库 )
核心标签库（c标签库）天天用
国际化标签（fmt标签库）
EL函数库（fn函数库）
已经过时的两种
xml标签库（x标签库）
sql标签库（sql标签库）
2) .使用步骤
1）导入jstl支持的jar包（标签背后隐藏的java代码）
注意：使用javaee5.0的项目自动导入jstl支持jar包
2）使用taglib指令导入标签库
<%@tagliburi="tld文件的uri名称"prefix="简写"%>
3）在jsp中使用标签
核心标签库的重点标签：
核心标签是最常用的JSTL标签。引用核心标签库的语法如下：
<%@ taglib prefix="c"
uri="http://java.sun.com/jsp/jstl/core" %>
1.<c:set></c:set>
保存数据：<c:set>标签用于把某一个对象存在指定的域范围内，或者设置Web域中的java.util.Map类型的属性对象或JavaBean类型的属性对象的 属性。
2.<c:outvalue=""></c:out>
获取数据： <c:out> 标签用于输出一段文本内容到pageContext对象当前保存的“out”对象中。
3.<c:iftest=""></c:if>
单条件判断：<c:if test=“”>标签可以构造简单的“if-then”结构的条件表达式
4. <c:choose>
<c:whentest=""></c:when>
<c:otherwise></c:otherwise>
</c:choose>
多条件判断：<c:choose>标签用于指定多个条件选择的组合边界，它必须与<c:when>和<c:otherwise>标签一起使用。使用<c:choose>，<c:when>和<c:otherwise>三个标签，可以构造类似“if-else if-else”的复杂条件判断结构。
5.<c:forEach></c:forEach>
<c:forTokensitems=""delims=""></c:forTokens>
循环数据：<c:forEach>标签用于对一个集合对象中的元素进行循环迭代操作，或者按指定的次数重复迭代执行标签体中的内容。
<c:forTokens>用来浏览一字符串中所有的成员，其成员是由定义符号所分隔的
6.<c:redirect></c:redirect>
重定向：<c:redirect>标签用于实现请求重定向
7.<c:remove>标签
用于删除各种Web域中的属性
8.<c:catch>标签
用于捕获嵌套在标签体中的内容抛出的异常，其语法格式如下：<c:catch [var="varName"]>nestedactions</c:catch>
9.<c:param>标签
在JSP页面进行URL的相关操作时，经常要在URL地址后面附加一些参数。<c:param>标签可以嵌套在<c:import>、<c:url>或<c:redirect>标签内，为这些标签所使用的URL地址附加参数。
10.<c:import>标签,实现include操作
11.<c:url>标签
用于在JSP页面中构造一个URL地址，其主要目的是实现URL重写。URL重写就是将会话标识号以参数形式附加在URL地址后面
格式化标签
JSTL格式化标签用来格式化并输出文本、日期、时间、数字。引用格式化标签库的语法如下：
<%@ taglib prefix="fmt"
uri="http://java.sun.com/jsp/jstl/fmt" %>
标签 | 描述 |
使用指定的格式或精度格式化数字 | |
解析一个代表着数字，货币或百分比的字符串 | |
使用指定的风格或模式格式化日期和时间 | |
解析一个代表着日期或时间的字符串 | |
绑定资源 | |
指定地区 | |
绑定资源 | |
指定时区 | |
指定时区 | |
显示资源配置文件信息 | |
设置request的字符编码 |
JSTL函数
JSTL包含一系列标准函数，大部分是通用的字符串处理函数。引用JSTL函数库的语法如下：
<%@ taglib prefix="fn"
uri="http://java.sun.com/jsp/jstl/functions" %>
函数 | 描述 |
测试输入的字符串是否包含指定的子串 | |
测试输入的字符串是否包含指定的子串，大小写不敏感 | |
测试输入的字符串是否以指定的后缀结尾 | |
跳过可以作为XML标记的字符 | |
返回指定字符串在输入字符串中出现的位置 | |
将数组中的元素合成一个字符串然后输出 | |
返回字符串长度 | |
将输入字符串中指定的位置替换为指定的字符串然后返回 | |
将字符串用指定的分隔符分隔然后组成一个子字符串数组并返回 | |
测试输入字符串是否以指定的前缀开始 | |
返回字符串的子集 | |
返回字符串在指定子串之后的子集 | |
返回字符串在指定子串之前的子集 | |
将字符串中的字符转为小写 | |
将字符串中的字符转为大写 | |
移除首位的空白符 |
EL函数库（fn函数库）的使用：
<%--contains 是否存在一个变量--%>
${fn:contains("aaa","a")}
<%--containsIgnoreCase 是否存在一个变量（忽略大小写）--%>
${fn:containsIgnoreCase("aaa","a")}
<%--fn:endsWith 以什么结尾--%>
${fn:endsWith("bca","a")}
<%--fn:startsWith 以什么结尾--%>
${fn:startsWith("acb","a")}
<%--indexOf 是否存在某个字符或字符串--%>
${fn:indexOf("acb","a")}
<%--length 某个对象的长度（字符长度）--%>
${fn:length("acbAAAA哈哈")}
<%--substring截取某个字符长度返回一个新字符--%>
${fn:substring("acbAAAA哈哈",0,3)}
<%--substringAfter第一次出现a的位置开始截取--%>
${fn:substringAfter("acbAAAA哈哈","a")}
<%--substringBefore最后一个出现‘c’的位置开始截取--%>
${fn:substringBefore("bcbAAcAAa","c")}
<%--toLowerCase转换为小写--%>
${fn:toLowerCase("bcbAAcAAa")}
<%--toUpperCase转换为大写--%>
${fn:toUpperCase("bcbAAcAAa")}
<%--trim转换为大写--%>
${fn:trim(" bcbAAcAAa ")}
<%--split以某个字符切分为一个数组 （数组的类型[Ljava.lang.String;@67cc9a9a）--%>
${fn:split("1,2,3,45,6",",")}
<%--join给每个数组中的元素拼接一个字符--%>
${fn:join((fn:split("1,2,3,45,6",",")),"haha")}
<%-- escapeXml将某个标签已字符串格式输出整个标签 --%>
${fn:escapeXml("<h1>哈哈<h1>")}
<%-- 与c标签库中的out标签中的 c:out标签的escapeXml属性相同 --%>
<c:out escapeXml="true"value="<h1>哈哈<h1>"></c:out>5. 自定义标签：
jsp自定义标签 Tag文件版
1.在WEB-INF/tags/if.tag
<%@taglanguage="java"pageEncoding="UTF-8"%>
<%@attributename="text"required="true"type="java.lang.Boolean"%>
<%
if(text){
%>
<jsp:doBody></jsp:doBody>
<%
}
%>
这里要注意tag文件只能放在如下位置:
1.WEB-INF/tags
2.WEB-INF/tags的子目录
3.WEB-INF/lib中jar包的META-INF/tags
4.WEB-INF/lib中jar包的META-INF/tags下的子目录
5.jar包中的tag文件需要tld
添加jstl.jar与standard.jar到WEB-INF/lib目录,还有一点就是上面标红的部分:不要使用http://java.sun.com/jstl/core这个url,否则会报foreach中的item属性有问题
2.在jsp中的使用
<%@pageimport="java.util.ArrayList"%>
<%@pageimport="java.util.List"%>
<%@ page language="java"contentType="text/html;charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib tagdir="/WEB-INF/tags"prefix="my"%>
<!DOCTYPEhtmlPUBLIC "-//W3C//DTDHTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<metahttp-equiv="Content-Type"content="text/html;charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%--自定义if标签 --%>
<my:iftext="${1==1}">
<%--自定义out标签 --%>
<my:outvalue="<h1>哈哈哈</h1>"></my:out>
</my:if>
</body>
</html>
jsp 自定义标签
jsp标签有两组api
JspTag ->SimpleTag ->SimpleTagSupport
JspTag ->Tag ->IterationTag->BodyTag
第二组是classic的,比较早的使用方式,doStartTag(),doEndTag()有N多返回值的那种,使用起来也确实不方便,今天学到了另一个使用第一组api方式的,让人大快人心,贴码
例子是一个Select的标签,支持动态属性设置
1.编写标签类
publicclass SelectTagHandler extends SimpleTagSupport implements DynamicAttributes {
private static final String ATTR_TEMPLATE = "%s='%s'";
private static final String OPTION_TEMPLATE = "<optionvalue='%1$s'>%1$s</option>";
private List optionsList;
private String name;
private String size;
private Map<String, Object> tagAttrs = new HashMap<String,Object>();
publicvoid setName(String name) {
this.name = name;
}
publicvoid setSize(String size) {
this.size = size;
}
publicvoid setOptionsList(List optionsList) {
this.optionsList = optionsList;
}
@Override
public void doTag() throws JspException, IOException {
PageContext pageContext = (PageContext) getJspContext();
JspWriter out = pageContext.getOut();
out.print("<select ");
out.print(String.format(ATTR_TEMPLATE, "name",this.name));
out.print(String.format(ATTR_TEMPLATE, "size",this.size));
for(String attrName : tagAttrs.keySet()) {
StringattrDefinition = String.format(ATTR_TEMPLATE, attrName,tagAttrs.get(attrName));
out.print(attrDefinition);
}
out.print(">");
for(Object option : this.optionsList) {
StringoptionTag = String.format(OPTION_TEMPLATE, option.toString());
out.println(optionTag);
}
out.println("</select>");
}
@Override
publicvoid setDynamicAttribute(String uri, String name, Object value) throwsJspException {
tagAttrs.put(name,value);
}
}看到没,代码如此的简洁,动态属性配置也十分的方便,不用写N多个setter与getter方法.
2.编写tld文件WebRoot/tld/select.tld
<?xmlversion="1.0" encoding="UTF-8" ?>
<taglibxmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3g.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"
version="2.0">
<tlib-version>1.2</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>Forms Taglib</short-name>
<uri>http://hi.baidu.com/tags/forms</uri>
<description>
An example tab library of replacements for the html form tags.
</description>
<tag>
<name>select</name>
<tag-class>com.baidu.hi.tag.SelectTagHandler</tag-class>
<body-content>empty</body-content>
<attribute>
<name>optionsList</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
<type>java.util.List</type>
</attribute>
<attribute>
<name>name</name>
<required>true</required>
</attribute>
<attribute>
<name>size</name>
<required>true</required>
</attribute>
<dynamic-attributes>true</dynamic-attributes>
</tag>
</taglib>
3.在jsp中的使用
<%@page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ page import="java.util.*" %>
<%@ taglib prefix="formTags" uri="/tld/select.tld"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
<%@page import="java.util.ArrayList"%><html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%
List<String> colorList = new ArrayList<String>();
colorList.add("red");
colorList.add("blue");
colorList.add("white");
request.setAttribute("colorList",colorList);
%>
<form action="" method="post">
<formTags:select name="color" size="1"optionsList="${requestScope.colorList}" style="width:140px"/>
</form>
</body>
</html>
479
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
