JSP概念
Servlet是j2ee提供的动态资源开发技术，
是以java的程序的形式进行开发，
在java中书写HTML标签是一件十分头疼的事情，
所以人们开发出了JSP，看起来像是HTML一样，
但是通过服务器的编译最终可以生成Servlet
动态网页技术
页面不需要改变->改变数据库数据
jsp = html + java
1、jsp页面中可以写哪些内容
1.html标签
2.css
3.jstl标签库
4.java代码
5.EL表达式
6.javascript
页面会非常乱.java+html+css+js
不容易修改
.jsp --> .java --> .class
翻译
2、jsp是如何工作的以及jsp的特点.
1.jsp页面其实就是一个servlet。
2.jsp页面的运行需要服务器的支持。
3.服务器中的jsp引擎可以帮我们去运行jsp页面。(注意并不是所有服务器都有这样的引擎的.引擎其实就是别人写的支持jsp页面运行的jar包或者代码)
4.jsp页面在运行之前,要经过几个步骤:首先jsp页面要被翻译成.java文件,然后再编译成.class文件,
最后再运行这个.class文件.(创建这个类的对象,调用指定方法_jspService,方法中把页面里面要显示的内容用io流一行行的写给浏览器)
5.jsp翻译成的.java文件中,其实就是写了一个servlet,在这个类中的方法里面,用io流,把jsp页面中的内容一行一行的输出给了浏览器。
因为这是在java类中的方法里面做的事情,所有很多数据我们都可以用变量来表示,同时也可以调用其他类中的方法.
(在这里,jsp动态页面的效果也就体现出来.)
6.运行jsp页面过程中,jsp引擎帮我们去翻译或者编译成的.java文件和.class文件都保存在了tomcat中的work目录里面。
7.通过上述jsp的特点可知,写完一个项目之后,第一次部署运行的时候,整个项目的运行jsp速度会慢一些,因为第一次访问运行jsp的时候,
需要先翻译成.java文件然后再编译成.class文件,最后再运行,这个过程会耗费一些时间,但是第二访问运行的时候就会比较快了.
8.访问项目中的一个jsp页面的时候,服务器首先会检查你所访问的这个jsp页面是否存在,如果不存在,服务器直接给你返回404,
如果存在,服务器会进一步检查有没有和这个jsp页面对应的.class文件,如果有的话就直接运行这个.class,如果没有的话,
则先把这个jsp页面翻译成.java,然后再编译成.class,最后再运行这个.class文件.
9.jsp页面其实就是在html页面中直接写上java代码.但是,在一个jsp页面中,可以没有任何html的代码而只有java代码,
也可以没有任何java代码只有html的代码.
10.servlet能做的事情jsp全能做。
3、jsp中的元素:三大元素
1,脚本元素
<%! 声明 %>
<%= 表达式 %>
<% 脚本 %>
脚本元素 对应在 java文件什么位置
2,指令元素 <%@ 指令 %>
3,动作元素 <jsp:out>:为了避免在jsp中写过多的脚本元素
1) 脚本元素
a) 声明(Declaration):相当于在类中方法外的代码
语法: <%! %> jsp页面任何地方
作用: 在servlet中声明一些成员变量、成员方法和内部类
特点: 声明被翻译进servlet后变成了成员变量、成员方法和内部类
注意: 不能使用表达式和隐含对象-->jsp--9
b) 表达式(Expression):相当于在_jspServlet()方法中的 out.println(表达式);代码
语法: <%= expression %>
作用: 将expression输出到out(输出流)中，expression可以是算术、逻辑、关系表达式、变量、有返回值的方法、jsp中的9种隐含对象。
9种隐含对象:
page pageContext request response session application out config exception
特点: 表达式翻译进servlet后变成了out.print(expression),该代码处于
_jspService()方法中;
注意: expression都一律被转换成字符串后再写到输出流out(JspWriter)中。另外，expression中不能有分号(;)。
c) 脚本(Scriptlet):相当于_jspService(...){脚本}中代码
语法: <% java code %>
作用: 在jsp中嵌入该jsp转化成的_jsp.jsp代码，不能嵌入成员变量、成员方法。
特点: 脚本被翻译进servlet的_jspService()方法中。
2) 指令元素
a) page指令
语法: <%@ page attributeName="attribuerValue"...%>
作用: 利用page指令中的属性可以和容器进行通信，这些属性的设置对整个jsp都有影响。
page指令中的属性:
language="java"
表示当前页面中的编程语言是java,目前这个属性值只能写java
import="package.class,package2.class2"
在当前页面中要引入哪些包下的类.和一般的java import意义一样，用","来隔开,
import="java.util.*"
import="java.util.HashMap,java.sql.Connection"
session="true|false" 默认为true
用来指定当前页面是否支持使用session，如果设置为true，则翻译过来的servlet中将会有对session对象的引用，于是可以直接在jsp中使用session隐式对象。但是这将导致一旦访问jsp就会调用request.getSession()方法，可能导致不必要的空间浪费。如果确定jsp中不需要session可以设为false
buffer="none|8kb|sizekb" 默认为8kb
out隐式对象所使用的缓冲区的大小
autoFlush="true|false" 默认为true
out隐式对象是否自动刷新缓冲区，默认为true，不需要更改
isThreadSafe="true|false" 默认为true
翻译过来的servlet是否实现SingleThreadModel
info="text"
关于jsp页面的信息，定义一个字符串，可以使用getServletInfo()获得
errorPage="b.jsp" 默认忽略
如果页面出错，将要跳转到的页面，除了在jsp中使用此属性指定错误页面外也可以在web.xml中配置整个web应用的错误页面，如果两个都设置则jsp中的此属性起作用
isErrorPage="true|false" 默认为false
表明当前的页面是否为其它页面的errorPage目标，如果设置为true，则可以使用exception对象。反之，如果设置为false，则不可以使用exception对象
extends="package.class"
设置jsp页面被翻译成java文件的时候,java文件中的类要继承那个父类.这个属性不用设置,jsp引擎会给它一个默认的父类去继承的.
isELIgnored="true|false"
指定EL表达式语言是否被忽略，如为true则忽略，反之可以使用EL。
contentType="text/html;charset=UTF-8"
定义response中的内容类型和jsp页面的编码格式，
翻译后变成response.setContentType("text/html;charset=UTF-8")。
pageEncoding="UTF-8"
设置jsp页面文件保存时候所用的编码,实现功能跟contentType="text/html;charset="UTF-8"一致，但是两者若同时设置，jsp页面的编码格式以pageEncoding为准，response中的内容类型和编码格式以contentType为准。
b) include指令 : 静态导入
语法: <%@ include file="url"%>，称为静态导入(静态包含)
作用: 在一个页面中导入另一个页面的内容(这些内容一般不会有变化，如公司的标题和版权等信息)。
特点: 在jsp翻译成servlet后就将被导入的页面内容嵌入到servlet中。
导入时间发生在翻译阶段。
被导入的资源: html、xml、jsp等
优点: 执行效率高
缺点: 当被导入页面的内容发生变化，那么jsp必须要重新被翻译。
c) taglib指令是定义一个标签库以及其自定义标签的前缀.
<%@ taglib uri="" prefix=""%>
指定在jsp中要使用的标签库描述文件(*.tld)的路径
prefix="给标签库取的别名"
uri="标签库的路径"
3) 动作元素(jsp自带的标准标签)
减少在jsp页面编写java代码
jsp基本动作元素：
jsp:attribute 设置动态定义的XML元素属性。
jsp:body 设置动态定义的XML元素内容。
jsp:element 定义动态XML元素
jsp:fallback 回滚，下载失败则显示里面的内容，此标记只能在<jsp:plugin>内部使用
* jsp:forward 把请求转到一个新的页面。该操作允许将请求转发到另一个JSP，Servlet或者静态资源文件。一旦遇上此标记即会停止执行当前的JSP，转而执行被转发的资源。
<jsp:forward page="sucess.jsp">
jsp:getProperty 输出某个JavaBean的属性。此操作是对<jsp:setProperty>操作的补充，它用来访问一个Bean的属性。它访问的属性值将它转化成一个String，然后发送到输出流中。如果属性是一个对象，将调用toString()方法，
<jsp:getProperty name="beanName" property="propertyName">
* jsp:include 在页面被请求的时候引入一个文件。该操作允许在请求的时间内在现成的JSP页面里面包含静态或动态的资源。被访问的对象对JSP write对象的访问权，并且它不能设置头或者Cookie.如果页面输出是缓冲的，那么缓冲区的刷新要俦于包含的刷新。因此它在运行效率上比<%@ include file="include.html"%>要低，但它可以动态增加内容，使用
<jsp:include page="two.jsp" flush="true">
* jsp:param 操作被用来以“名－值”对的形式为其他标签提供附加信息。写一般与<jsp:forward>，<jsp:include>,<jsp:plug>,一起使用。
<jsp:param name="paramName" value="paramValue"/>
jsp:params 表示需要向Applet或Bean传送的参数或值
jsp:plugin 根据浏览器类型为Java插件生成OBJECT或EMBED标记。此操作是用来产生客户端浏览器的特别标签(Object或者embed)，可以使用它来插入Applet或者JavaBean。一般来说<jsp:plugin>元素指定的对象是Applet还是Bean，同样也会指定class的名字，另外还会指定将从哪里下载这个Java插件。
<jsp:plugin type=applet code="efly.testMyApplet.class" codebase=".">
<jsp:params>
<jsp:param name="aParameterName" value="aParameterNameValue"/>
</jsp:params>
<jsp:fallback>
<p>Unable to load applet.</p>
</jsp:fallback>
</jsp:plugin>
解释：
1：type="bean/applet"
2：code="classFileName" 插件执行JAVA类文件的名称。在名称中必须加上扩展名，且此文件必须放在用 codebase属性的目录下。
3：codebase="classFileDirectoryName"这包含插件将运行的JAVA类的目录或指向这个目录的路径。默认为JSP文件的当前路径。
4：name="instanceName" 这是Bean或Applet的实例的名称。使得被同一个JSP文件调用的Bean或Applet之间的通讯成为可能。
5：archive="URIToArchive,……"这是以逗号分隔的路径名列表，是那些用于codebase指定的目录下的类装载器预装载的存档文件所在的路径名。
6：align="botton/top/middle/left/right"图形，对象，Applet的排列方式。
7：height="displayPixels" width="displayPixels" 显示的高宽
8：hspace="leftRightPixels" vspace="topBottomPixels" 左右 上下留下空间大小
9：jreversion="JREVersionNumber | 1.1" 这是Applet或Bean运行时所需的JRE版本
10：nspluginurl="URLToPlugin" 这是Netscape Navigator用户能够使用的JRE下载地址
11：iepluginurl="URLToPlugin" 这是Internet Explorer用户能够使用的JRE下载地址
jsp:setProperty 设置JavaBean的属性。此操作与useBean协作，用来设置Bean的简单属性和索引属性。<jsp:setProperty>标签使用Bean的setXXX()方法。利用它设置属性多种方法。Bean的自省(introspection)用来发现出现的是哪些属性和它们的名字是什么，这些属性是简单的还是索引的，它们有什么类型等，用以下方法使用
<jsp:setProperty name="beanName" property="propertyName" value="propertyValue"/>
jsp:useBean 寻找或者实例化一个JavaBean。此标签用于在JSP页面中创建一个Bean实例，并指定它的名字及作用范围。它保证对象在标签指定的范围内可以使用。
创建：
<jsp:useBean id="shopcar" scope="session" class="com.briup.Carts"/>
<jsp:setProperty name="shopcart" property="*"/>
寻找：
<jsp:useBean id="checking" scope="session" class="com.briup.Checking">
<jsp:setProperty name="checking" property="balance" value="0.0"/>
</jsp:useBean>
scope的取值可以是page/request/session/application 范围依次递增！
相当于代码:
<%
com.briup.Carts shopcar = null;
shopcar = (Carts)pageContext.getAttribute("shopcar");
if(shopcar==null){
shopcar = new Carts();
pageContext.setAttribute("shopcar",shopcar);
}
%>
语法: <jsp:tagName/>
a) 动态导入(动态包含)
语法: <jsp:include page="url" flush="true|false"/> 或者
<jsp:include page="url" flush="true|false">
{<jsp:param …/>}*
</jsp:include>
特点: 动态导入发生在执行阶段，也就是在运行serlvet的时候才动态生成被导入页面的内容，然后嵌入到调用页面，最后将两个页面的内容一起返回给客户端。
注意: 在翻译(.jsp->.java)阶段并没有生成被导入页面的内容。
缺点: 执行效率没有静态导入高
优点: 如果被导入页面的内容发生变化，调用页面不必重新翻译。
b) forward(服务器内部跳转)
语法: <jsp:forward page="url"/>或者
<jsp:forward page="url">
{<jsp:param …/>}*
</jsp:forward>
4、jsp中的注释
a) HTML/XML注释
语法: <!-- content -->
注意: 它只能注释html、xml中的静态内容。不能注释脚本元素、指令元素和动作元素。如果注释，它们还是会被编译执行。
b) 隐藏注释
语法: <%-- content --%>
注意: 它可以注释jsp中所有的内容。
c) 脚本注释
语法: < %
//java code
/**
java code
*/
/*
java code
*/
%>
三种注释的区别:
servlet源文件 客户端页面源文件 浏览器显示
HTML/XML注释 出现 出现 不显示
隐藏注释 不出现 不出现 不显示
脚本注释 出现 不出现 不显示
静态导入: <%@ include %>
特点:-->a_jsp.java会包含两个页面中所有的数据
翻译阶段发生
动态导入: <jsp:include>
特点:a.jsp-->b.jsp-->a_jsp.java不会包含b.jsp的内容
留下一个b.jsp的引用
在代码运行的时候(运行的时候导入)
5) JSP九大隐含对象也叫九大内置对象
JSP容器生成的Servlet类的_jspService()方法中，定义的几个对象我们可以在编写
JSP页面时使用的隐含对象。
page:当前的jsp页面，指针this
pageContext:当前的jsp页面的上下文:容器
request：封装请求的信息
response：封装响应
session：会话
application：指web应用
out：输出流
config ：配置信息
exception：异常信息
在哪里声明?
_jspService()
jsp 三大元素
四大容器: pageCentext : 当前页面
request
session
application
九大内置对象:
page---> this
pageContext --> 当前页面容器
request
response
session
application
out
config
脚本元素
<% %>
<%= 表达式 %>
<%! 声明 %>
指令元素
动作元素
pageContext 对象提供了访问其他隐含对象的方法
getRequest()
getResponse()
getSession()
getServletContext()
JspWriter getOut()
getServletConfig()
Object getPage()
Exception getException()
pageContext还可以用来保存属性，但是只能在当前页面中获取
setAttribute(String name,Object val);
Object getAttribute(String name);
pageContext还可以设置和得到其他范围对象中保存的属性
setAttribute(String name,Object val,int scope);
Object getAttribute(String name,int scope);
removeAttribute(String name,int scope)删除指定范围内名字为name的属性
removeAttribute(String name) 删除所有范围内名字为name的属性
findAttribute(String name) 该方法会按照page,request,session,application
范围顺序搜索指定名字的属性。
PageContext.PAGE_SCOPE 页面范围
PageContext.REQUEST_SCOPE 请求范围
PageContext.SESSION_SCOPE 会话范围
PageContext.APPLICATION_SCOPE 应用程序范围
exception
对象表示了JSP页面运行时产生的异常，该对象只有在错误页面（page指令中指定
isErrorPage=true的页面）中才可以使用。当JSP页面运行发生错误时,JSP容器会
自动调用指定的错误处理页面，如果JSP页面使用errorPage属性定义了错误页面，
那么在web.xml文件中定义的任何错误页面将不会被使用
6) 对象和范围
在JSP中，有4中范围
page范围：--->pageContext
具有page范围的对象被绑定到javax.servlet.jsp.PageContext对象中，在这个
范围中的对象，只能在创建对象的页面中访问。page范围内的对象，在客户端
每次请求JSP页面时创建，在页面向客户端发送回响应或请求被转发到其他资源
后被删除。
request范围
具有request范围的对象被绑定到javax.servlet.http.HttpServletRequest对象
中。在调用forward()方法转向的页面或调用include()方法包含的页面中，都可
以访问这个范围内的对象。
session范围
具有session返回的对象被绑定到javax.servlet.http.HttpSession对象中，JSP
容器为每次会话，创建一个HttpSession对象，在会话期间，可以访问session
范围内的数据
application范围
具有application范围的对象被绑定到javax.servlet.ServletContext中，在web
应用程序运行期间，所有页面都可以访问这个范围内的对象。
JSTL
什么JSTL
第三方标签库，是一个JSP标签集合，需要导入jar包才可以使用。
该标签库可以完成更复杂的功能，比如可以完成遍历集合，条件判断，循环等功能。
根据标签功能，JSTL标签库可分5类：
核心标签库 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
I18N格式化标签库<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
SQL标签库 <%@taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
XML标签库 <%@taglib prefix="xml" uri="http://java.sun.com/jsp/jstl/xml" %>
函数标签库 <%@taglib prefix="functions" uri="http://java.sun.com/jsp/jstl/functions" %>
使用原因：
不希望在jsp页面中出现java逻辑代码。
相关jar包
老版本：
standard.jar 标准jar包，定义规范
jstl.jar 具体实现jar包
新版本：
jstl-1.2.jar
注意：
1）web工程导包需要将包copy到WEB-INF下lib文件夹中。
2）在jsp页面中导入标签库。
如核心标签库的引入：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
核心标签库，可分为四大类
第一类：表达式控制标签
<c:out>：用于在JSP中显示数据，就像<%= ... >
<c:set>： 用于将数据放到容器中(4大容器)
<c:remove>： 用于删除容器中数据
<c:catch>： 用来处理产生错误的异常状况，并且将错误信息储存起来
第二类：流程控制标签
<c:if>：与我们在一般程序中用的if一样
<c:choose>： 本身只当做<c:when>和<c:otherwise>的父标签
<c:when>： <c:choose>的子标签,相当于 else if() 用来判断条件是否成立
<c:otherwise>： <c:choose>的子标签,相当于 else{} 接在<c:when>标签后，当<c:when>标签判断为false时被执行
上面三个标签一起使用相当于 java中:if(){} else if(){}else if(){}else{}
第三类：循环标签
<c:forEach>:基础迭代标签，接受多种集合类型
<c:forTokens>:根据指定的分隔符来分隔内容并迭代输-->split("/")
第四类：URL操作标签
<c:import>： 检索一个绝对或相对 URL，然后将其内容暴露给页面:导入到页面中
<c:import> 任意的uri
<jsp:import> 当前项目下的url
<c:param>： 用来给包含或重定向的页面传递参数
获取的话:从请求中获取
req.getParameter("")
<c:redirect>： 重定向 至一个新的URL.
<c:url>： 使用可选的查询参数来创造一个URL
核心标签详解
1、<c:out> 输出变量到JspWriter输出流中
语法1：<c:out value="result" [escapeXml]="{true|false}" [default="defaultValue"]/>
语法2：<c:out value="result" [escapeXml]="{true|false}">
default value
</c:out>
注意： a)如果result为null，则输出default中的值
a.1)属性default="值" 和标签的文本域默认值 不能同时出现
b)escapeXml：设定是否转换特殊字符(如<、>等一些转义字符)
默认值为true的情况下直接在输出<的，
如果改为false将会进行转义输出“<”等。
例如: <c:out value="${student.address.country}"/>
<c:out value="你好"/>
2、<c:set> 该标签用于在某个范围中设置指定变量，或者设置某个对象的属性
1)设置范围变量
语法1：<c:set var="name" value="attrValue" [scope="page|request|session|application"]/>
注: var指定的值-->属性名、变量名
value指定的值-->属性值、变量值
value可以通过el标签来取到数据，如:value="${user }"
语法2： <c:set var="varName" [scope=""]>
body content
</c:set>
注：var指定的值-->属性名、变量名
body content指定的值-->属性值、变量值
scope指定变量存放的范围，默认为page
等价于:scope.setAttribute("name","attrValue");
2)设置某个特定对象的一个属性
语法1：<c:set target="${target}" property="propertyName" value="propertyValue"/>
注：target:目标对象
propertyName:目标对象属性名
propertyValue:属性值
语法2： <c:set target="${target}" property="propertyName">
body content
</c:set>
注：target:目标对象
propertyName:目标对象属性名
body content:属性值
例子：
<c:set target="${student}" property="name" value="terry"/>
注：把一个值为terry赋值给指定的student对象的name属性，
等价于调用student对象的setter方法。
注意: 1)scope属性不能在这里使用。
eg:<c:set var="name" value="tom" scope="application"></c:set>
3、<c:remove> 在指定scope中根据属性名varName来删除属性值
语法：<c:remove var="varName" [scope="page|...."]/>
等价于 scope.removeAttribute("varName");
注意：如果没有指定scope，那么依次从page、request、session和application范围中
根据该属性名去删除属性值。
eg:<c:remove var="test" scope="application"/>
4、<c:catch> 捕获由嵌套在它里面的代码抛出的异常
语法:<c:catch [var="varName"]>
nested actions
</c:catch>
注：var:用于存放这个异常对象的属性名，
通过它可以输出异常对象的所有信息。
scope：默认为page。
eg:
<c:catch var="e">
<%
int x=10/0;
%>
</c:catch>
<c:out value="${e}"/>
5、<c:if> 判断
语法: <c:if test="condition" var="varName" [scope]>
body content
</c:if>
注： var为存放布尔型变量的属性名
scope为该变量的存放范围。
condition通常为el表达式
eg:
<c:if test="true|false">
条件为真
</c:if>
6、<c:choose> 用于条件选择，它和<c:when>以及<c:otherwise>一起使用
语法: <c:choose>
(<c:when> and <c:otherwise>)
</c:choose>
注意: body体内容只能由以下的元素构成
1) 空格
2) 0个或者多个<when>子标签，
<c:when>必须出现在<c:choose>和<c:ohterwise>之间
3) 0个或者多个<ohterwise>
7、<c:when> 代表了<c:choose>的一个分支
语法: <c:when test="condition">
body content
</c:when>
注意: 必须以<c:choose>作为它的父标签
必须在<c:otherwise>之前出现
8、<c:otherwise> 代表了<c:choose>的最后的选择
语法: <c:otherwise>
body
</c:otherwise>
注意: 必须以<c:choose>作为父标签
必须是<c:choose>的最后分支
9、 <c:forEach>用来迭代集合、数组、枚举或者迭代器(Iterator))
语法1: <c:forEach [var="varName"]
items="collection/array/Enumaration/Iterator"
[varStatus="varStatusName"]
[begin="begin"] [end="end"]
[step="step"]>
body
</c:forEach>
语法2: 迭代固定的次数(做普通的循环输出,类似for循环)
<c:forEach [var="varName"]
[varStatus="varStatusName"]
begin="begin" end="end"
[step="step"]>
body content
</c:forEach>
名字 类型 描述
var String 存放变量(迭代出来的)的属性名(scope为page)
items 任何支持的类型 将要迭代itmes的集合/数组/枚举/Iterator
varStatus String 迭代的状态，可以访问迭代的自身信息,如索引号
begin int items从index[begin]开始迭代
没有指定items从index开始做循环
end int items从index[end]结束
没有指定items从end结束
step int 迭代的步长(>0)
注意：varStatus中有index(索引)，count(循环次数)
,first(是否是第一个位置),last(是否为最后一个位置)
eg:遍历List
<c:forEach items="${list }" var="str" varStatus="index" step="2" begin="1">
${str}-----${index.count }<br>
</c:forEach>
解析：
items="${}"需要遍历的集合
var="str"给遍历到的每个对象取个名字方便使用
varStatus="index"给角标对象取名字-->${index.count}-->注意：从1开始
step="2"步长为2 0__ 1__ 2__ 现在在0位置 然后步长为2 所以到了2号位
begin="1"从集合的几号位置开始读取数据
end="2"取到2号位置
eg:遍历map
<c:forEach items="${map}" var="m" varStatus="index">
${m.key }----${m.value}---${index.count }<p>
</c:forEach>
10、 <c:forTokens>类似java中的StringTokenizer
这个标签专门用于处理TokenString的迭代，
可以指定一个或者多个分隔符号(delimiters)
语法: <c:forTokens items="stringOfTokens"
delims="delimiters"
[var="varName"]
[varStatus="varStatusName"]
[begin="begin"] [end="end"]
[step="step"]>
body content
</c:forTokens>
eg:
<c:forTokens items="briup|briup2|briup3|sssss|"
delims="|" var="a" begin="" end="" step="" varStatus="">
${a }<p>
</c:forTokens>
item:需要被打断的字符串
delims:通过什么打断
var:打断以后的每个字符取个名字方便使用
11、 <c:import>导入一个基于URL的资源，可以把其他静态或动态文件包含到本JSP页面
语法：<c:import url="url" [var="varName"] [scope]>
[<c:param/>]*
</c:import>
var:存放URL资源内容的属性名
scope:存放的范围
区别：
<jsp:include>：只能包含同一个web应用中的文件。
<c:import>可以包含其他web应用中的文件，甚至是网络上的资源。
eg:
<c:import url="2_instruct_head.jsp" var="path" scope="session">
</c:import>
12、 <c:param> 在<c:import>、<c:url>和<c:redirect>中添加请求的参数
语法1: <c:param name="name" value="value"/>
语法2: <c:param name="name">
parameter value
</c:param>
eg:
<c:import url="ServletTest" var="path" scope="request">
<c:param name="hhh">jjj</c:param>
</c:import>
解释：
先使用c:import 跳转到一个servlet然后使用s:param给请求附加数据域加在reqeust的请求体中
13、 <c:url> 用于构造URL，主要用途是URL重写
语法: <c:url value="url" [var="varName"] [scope]>
[<c:param/>]*
</c:url>
注意：1)var:存放重写后的URL的属性名
2)scope:存放的范围
3)若为相对路径，url会被重写
4)若使用绝对路径则url不会重写
5)一般和a连用，如<a href="varName">test</a>
eg:<a href="<c:url value="/jsp/index.htm"/>">TEST</a>
14、 <c:redirect> 把客户的请求重定向到另一个资源
语法: <c:redirect url="url">
[<c:param/>]*
</c:redirect>
注意：1)若为相对路径，url会被重写
2)若使用绝对路径则url不会重写
EL最初是定义在JSTL1.0规范中，在JSP2.0中，EL从JSTL中剥离出来，放到JSP规范中
成为了JSP2.0规范的一部分，并添加了新的特性。在JSP页面中，使用EL可以简化对
变量和对象的访问。
JSP中的表达式语言，使得访问存储在JavaBean中的数据变得非常简单。
它既可以用来创建算术表达式也可以用来创建逻辑表达式。
el表达式内可以使用整型数，浮点数，字符串，常量true、false，还有null。
目的：
通过EL标签取数据和输出信息，
简化代码，不需要使用java来输出。
使用Java代码也可以取数据，但是这样不利于维护JSP。
<c:forEach var="map">
${map.key}
${map.value}
EL详解
形式:${ }
* 作用:从一个范围里面取值或者从一个
${name}
容器
key value
name obj
对象中取值或是向页面输出值.
1.接收客户端参数.
${param.name1 }
2.指定范围并取值
${pageScope.name2 }
${requestScope.name3 }
${sessionScope.name4 }
${applicationScope.name5 }
3.可以不指定范围再去取值
${name}
这时候会按照pageContext request session application这样一个顺序依次的去找有没有一个叫name的值存在,一旦找到了就输出出来,最终没有找到那么就什么都不输出。
${对象.属性}
4.取出一个对象中的属性值.
${requestScope.student.id}
${requestScope.student.name}
${requestScope.student.age}
或者
${student.id}
${student.name}
${student.age}
或者
${student["id"]}
${student["name"]}
${student["age"]}
注意:比如 ${student.id}表示是要调用student对象中的getId方法,至于对象中有没有id属性对这个操作没有任何影响.
如果Student类中一个方法是getAddress,返回一个Address类的对象,Address类中有一个方法getCity,这个时候我们就可以这样写去拿到city属性的值.
${student.address.city}
5.输出字符串
${"hello"}
6.输出运算结果或者boolean表达式
a)算术运算符
+、-、*、/和 %(或 mod)
b)关系运算符
==（或 eq）、!=（或 ne）、<（或 lt）、
>（或 gt）、<=（或 le）和 >=（或 ge）
c)逻辑运算符
&&（或 and）、||（或 or）和 !（或 not）
d)判空运算符 ${empty ""}-->变量name是否为空：${empty name}-->为空就是true
empty
<% String name="";%>
如果为空 --> true
不为空 --> false
${empty ""}
${empty name}
${1+1 }
${(1+2)*3-4+5*3 }
${1<3 }
//为空的话返回true
${empty "" }
${empty "hello" }
//取否 不为空的话返回true
${not empty "hello" }
${! empty "hello" }
${param.score >50 }
${param.score >60?"good":"bad" }
7.输出数组、集合中的元素
${str[0] }<br>
${list[1] }<br>
${map["c"] }<br>
<%
String[] str = {"hello","world"};
List<String> list = new ArrayList<String>();
list.add("zhangsan");
list.add("lisi");
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("a",100);
map.put("b",200);
map.put("c",300);
request.setAttribute("str",str);
request.setAttribute("list",list);
request.setAttribute("map",map);
%>
${str[0] }<br>
${list[1] }<br>
${map["c"] }<br>
8.表达式语言(EL)中定义了一些可以使用的隐含对象:
1) pageContext: jsp页面的上下文，它提供了访问以下对象的方法
a) servletContext
${pageContext.servletContext}
等于
out.println(pageContext.getServletContext())
b) session
${pageContext.session.id}
等于
out.println(pageContext.getSession().getId())
c) request
${pageContext.request}
等于
out.println(pageContext.getRequest())
d) response
${pageContext.response}
等于
out.println(pageContext.getResponse())
------>看看
2) parma: 把请求中的参数和单个值进行映射
${param.name}或者${param["name"]}或者${param['name']}
等于
out.println(request.getParameter("name"))
注意：${param.name}如果获取不到值返回""。
request.getParameter("name")如果获取不到值返回null。
3) paramValues: 把请求中的参数和一个array值进行映射
${paramValues.hobby}或者${paramValues["hobby"]}或者${paramValues['hobby']}
等于
String[] array = request.getParameterValues("hobby")
out.println(array);
4) header: 把请求头中header的字段和单个值映射
${header.referer}
等于
out.println(request.getHeader("referer"));
//获得http request请求头中所有字段名字
Enumeration e =
request.getHeaderNames();
5) headerValues: 把请求头中header的字段和一个枚举进行映射
${headerValues.referer}
等于
Enumeration enum =
request.getHeaders("referer")
out.println(enum);
6) cookie: 把请求中的Cookie和单个值进行映射
Cookie cookie = new Cookie("height","100");
Cookie cookie2 = new Cookie("width","200");
response.addCookie(cookie);
response.addCookie(cookie2);
在服务器端获得从客户端发送过来的cookie:
${cookie.height}: 输出一个Cookie的对象
${cookie.height.name}=${cookie.height.value}
分别输出Cookie的名称和值(height=100)
${cookie.width}: 同上
${cookie.width.name}=${cookie.width.value}: 同上
7) initParam: 把Web应用上下文的初始化参数和单个值进行映射
<context-param>
<param-name>name</param-name>
<param-value>value</param-value>
</context-param>
${initParam.name}
等于
String value = getServletContext()
.getInitParameter("name");
out.println(value);
8) pageScope: 把page范围中的key和value进行映射
pageContext.setAttribute
("name","jack");
${pageScope.name}
等于
out.println
(pageContext.getAttribute("name"));
9) requestScope: 把request范围中的key和value进行映射
request.setAttribute("name","jack");
${requestScope.name}
等于
out.println(request.getAttribute("name"));
10) sessionScope: 把session范围中的key和value进行映射
session.setAttribute("name","jack");
${sessionScope.name}
等于
out.println(session.getAttribute("name"));
11) applicationScope: 把application范围中的key和value进行映射
getServletContext().setAttribute("name","jack");
${applicationScope.name}
等于
out.println(getServletContext().getAttribute("name"));
注意: 如果没有指明任何的范围根据key来查找对应的value，默认从page、request、session和application从小到大的范围开始查找，若找到就不往更大的范围去查找。
例如: ${name} ,分别从page request session
和 application中去查找name的值
(scope.getAttribute("name")),scope为上面四种范围。
补充：
JSTL-fmt标签库
国际化核心标签:<fmt:setLocale>、<fmt:bundle>、<fmt:setBundle>、<fmt:message>、<fmt:param>、<fmt:requestEncoding>
格式化标签:<fmt:timeZone>、<fmt:setTimeZone>、<fmt:formatNumber>、<fmt:parseNumber>、<fmt:formatDate>、<fmt:parseDate>
1.<fmt:parseDate>标签:用于解析日期
属性描述
value:将被解析的字符串
type:解析格式化的类型
pattern:解析格式化模式
var:结果保存变量，类型为 java.lang.Date
scope:变量的作用范围
parseLocale:以本地化的形式来解析字符串，该属性的内容为 String 或 java.util.Locale 类型的实例
timeZone:指定解析格式化日期的时区
2.<fmt:formatNumber>标签:用于格式化数字
属性描述
value:格式化的数字,该数值可以是 String 类型(需要是全数字)或 java.lang.Number 类型的实例
type:格式化的类型,可能值包括:currency（货币）、number（数字）和percent（百分比）
pattern:格式化模式:前缀
var:结果保存变量
scope:变量的作用范围
maxIntegerDigits:指定格式化结果的:小数点前最多保留几位
minIntegerDigits:指定格式化结果的:小数点前保留几位 ,补全
maxFractionDigits:指定格式化结果的:小数点后最多保留几位
minFractionDigits:指定格式化结果的:小数点后最少保留几位 默认是2
如:
结果将被保存在“ money ”变量中，将根据 Locale 环境显示当地的货币格式
<fmt:formatNumber value="1000.888" type="currency" var="money"/>
3.<fmt:bundle> 、 <fmt:setBundle> 标签:用于资源配置文件的数据来源
3.1<fmt:bundle> 标签将资源配置文件绑定于它标签体中的显示
属性描述
basename:资源配置文件的指定，只需要指定文件名而无须扩展名
prefix:前置关键字
如:
资源文件中配置的数据为:
label.backcolor=#FFF
label.fontcolor=#000
则,可以用如下方法取得label的backcolor和fontcolor值:
<fmt:bundle basename="MyResourse" prefix="label.">
<fmt:message key="backcolor" />
<fmt:message key="fontcolor" />
</fmt:bundle>
3.2<fmt:setBundle> 标签则允许将资源配置文件保存为一个变量，在之后的工作可以根据该变量来进行
属性描述 ，二组标签共有的属性
var:<fmt:setBundle> 独有的属性，用于保存资源配置文件为一个变量
scope:变量的作用范围
如:
查找一个名为 applicationMessage_zh_CN.properties 的资源配置文件，来作为显示的 Resource 绑定
<fmt:setBundle basename="applicationMessage" var="applicationBundle"/>
4.<fmt:message> 标签:用于显示资源配置文件信息(该资源文件必须遵循如下格式:1.扩展名必须为properties,2.文件的内容必须依照key = value的格式;3.文件要放到WEB-INF/classes目录下)
属性描述
key:资源配置文件的“键”指定
bundle:若使用 <fmt:setBundle> 保存了资源配置文件，该属性就可以从保存的资源配置文件中进行查找
var:将显示信息保存为一个变量
scope:变量的作用范围
如:
1)用<fmt:setBundle>标签将"applicationMessage"资源配置文件被赋于了变量"applicationBundle"
用<fmt:message>标签显示由<fmt:setBundle>标签保存的资源配置文件中"键"为"passWord"的信息
<fmt:setBundle basename="applicationMessage" var="applicationBundle"/>
<fmt:message key="passWord" bundle="${applicationBundle}" />
2)用<fmt:bundle>标签定义的"applicationAllMessage"资源配置文件作用于其标签体内的显示
用<fmt:message>标签显示"applicationAllMessage"资源配置文件中"键"为"userName"的信息
<fmt:bundle basename="applicationAllMessage">
<fmt:message key="userName" />
</fmt:bundle>
5.<fmt:param 标签:用于参数传递
<fmt:param>标签应该位于 <fmt:message> 标签内，将为该消息标签提供参数值。它只有一个属性value
如：在MyResourse.properties文件中,有一个索引值如下(其中,{0}代表占位符):
Str2=Hi,{0}
则,使用<fmt:param>标签传入值如下:
<fmt:bundle basename="MyResourse">
<fmt:message key="Str2">
<fmt:param value="张三" />
</fmt:message>
</fmt:bundle>
也可以在资源文件中指定参数的类型:
如:在MyResourse.properties文件中,有一个索引值如下:
Str3={0,date}
则,使用<fmt:param>标签传入值如下:
<% request.setAttribute("now",new Date()); %>
<fmt:bundle basename="MyResourse">
<fmt:message key="Str3">
<fmt:param value="${now}" />
</fmt:message>
</fmt:bundle>
6.<fmt:timeZone>、<fmt:setTimeZone>标签:用于设定时区
<fmt:timeZone> 标签将使得在其标签体内的工作可以使用该时区设置
<fmt:setTimeZone> 标签则允许将时区设置保存为一个变量，在之后的工作可以根据该变量来进行
属性描述
value:时区的设置
var:<fmt:setTimeZone> 独有的属性，用于保存时区为一个变量
scope:变量的作用范围
7.<fmt:requestEncoding>标签:用于为请求设置字符编码
它只有一个属性 value ，在该属性中可以定义字符编码。
如：
<fmt:requestEncoding value="GB2312"/>
8.<fmt:parseNumber> 标签:用于解析数字
属性描述
value:将被解析的字符串
type:解析格式化的类型
pattern:解析格式化模式
var:结果保存变量，类型为 java.lang.Number
scope:变量的作用范围
parseLocale:以本地化的形式来解析字符串，该属性的内容应为 String 或 java.util.Locale 类型的实例
如:
将"15%"转换为数字
<fmt:parseNumber value="15%" type="percent" var="num"/>
------------
9.<fmt:formatDate>标签:用于格式化日期
属性描述
value:格式化的日期，该属性的内容应该是 java.util.Date 类型的实例
type:格式化的类型
pattern:格式化模式
var:结果保存变量
scope:变量的作用范围
timeZone:指定格式化日期的时区
10.<fmt:setLocale>标签:用于设置本地化环境
属性描述
value:Locale 环境的指定，可以是 java.util.Locale 或 String 类型的实例
scope:Locale 环境变量的作用范围（可选）
如:
设置本地环境为繁体中文
<fmt:setLocale value="zh_TW"/>
设置本地环境为简体中文
<fmt:setLocale value="zh_CN"/>