JSP

发表回复

 JSP（java server page）



servlet＝java＋html
jsp＝html＋java

1，为什么
servlet，cgi都是服务器端的程序，在其操作的过程中，嵌入大量的html代码，并且要想在服务器端
构建客户端程序将会非常复杂，除此之外html页面代码嵌套在java中维护和更新将会比较麻烦，
另外servlet需要web.xml文件配置才能运行，所以sun推出servlet的轻量级封装jsp来替代servlet以及cgi

2，什么
从本质上讲，jsp是一个servlet，那么jsp是一个服务器端的技术，但是考虑到编程者的感受，
在html页面中嵌套一些脚本以及标签及表达式语言来书写，也就是说编程这可以像书写html一样书写jsp，
并且html的优势将会全部保留，只是在运行之前，jsp要转化成servlet然后被调用



3，jsp的执行流程
（1）客户端发起请求，请求的路径为直接访问webroot下的目录，到达服务器
（2）服务器接受请求进行处理
   a，翻译
   当客户第一次发起请求，jsp将被翻译为一个servlet，当jsp不发生变化的时候，在此请求，此步省略
   b，编译
   翻译之后的servlet服务器还会制动编译，也是在第一次请求的时候
（3）要是没有编译进行编译，然后实例化servlet类，调用servlet的init方法
（4）每当有请求的时候分配一个线程调用service方法
（5）将处理结果返回给服务器
（6）服务器将结果包装在response中在客户端显示

1.jsp的工作原理:<比serlvet多了翻译阶段>
1)翻译阶段:当容器接受到客户端的请求后,先判断被请求的jsp是否存在,
若不存在返回404错误,如存在,将该jsp先翻译成一个Servlet;
2)编译阶段:将Servlet的源文件编译成一个字节码文件,然后由容器将其
装载进虚拟机并构造出一个实例对象(单例);
3)运行阶段:按照Servlet生命周期(init(),service方法,destory())的
过程来运行Servlet.
补充:
1)如果被请求的jsp已经有对应的servlet实例对象,那么直接运行该servlet.
2)如果jsp源文件的内容发生变化,那么要重新将jsp翻译成Servlet,再编译,装载
和实例化对象,最后运行servlet.


 

JSP的内置对象
   
out
 
   request
   
response
   
pageContext ?用的很少

   session
   
application
 ,
   config ?用的很少
   
exception

   Page?用的很少
    
    
4，jsp的优势
（1）将显示和逻辑分离
（2）可以调用java类以及一些第三方或者客户自定义的标签
（3）可以重复使用java组件
（4）当jsp页面发生变化，可以自动的重新翻译以及编译
（5）方便构建富客户端
（6）jsp的平台依赖性，可维护性，可更新性都比较有优势
（7）jsp在整个javaEE中处于核心技术

5，使用servlet和jsp
servlet的优势在于处理复杂的业务逻辑以及资源的互相利用和安全性，如果在jsp中嵌套大量的java代码，将会使jsp比较混乱。

jsp的优势就是发挥html的优势，主要用于显示

6，mvc：
当前web编程最流行的框架，一般和三层架构配合使用

在jsp的架构中，主要保留发挥jsp和servlet各自的优势
model：一般使用javaBean或者pojo类以及数据库操作来充当
view：一般使用jsp处理，主要负责想用户展示数据以及向服务器提交数据
controller：一般是业务处理的部分以及数据的构建部分，servlet处理的机会比较多

ch02：jsp的基本操作
jsp的脚本以及指令

脚本：
1，java脚本
 <%..javaCode..%>
 位于jsp编译成servlet的_jspService方法中
  <% public String name="abc"%>
  <% public void test(){}%>
  <% class Test()
  
  被翻译进serlet的jspService()方法中:
  
2，申明脚本
   <%!声明变量，方法，内部类%>
   jsp中声明的内容都会翻译到servlet里面的实例变量，实例方法以及实例（成员）内部类
   
   被翻译进serlet的jspService()方法之外,并且不能出现表达式<%=%>,隐含对象(request,session......)
   
3，表达式
    <%=调用方法，变量或者初始化类,隐含对象(request,session......)...%>
    翻译成servlet还是位于_JspService方法中并且out.println(表达式获得的值)

    jsp因为其本质为一个servlet，所以线程不安全，控制方式为尽量少在声明里面定义变量或者设置isThreadSafe＝“false“
    
    注意:表达式中不能出现 " ; "(分号)
         被翻译进serlet的jspService()方法中:
         
指令元素
 ------编译指令:---------

1.<%@page ....%>
 主要是对jsp的 一些表示，用于和服务器传递交互信息，直接决定jsp在服务器上运行的情况
 
 1. import
    生成 import声明 语句, 允许多次重复出现；

 import="java.io.*,java.util.*"
 等价于：
 import="java.io.*"  import="java.util.*"

 2. contentType="text/html;charset=utf-8"
    指定响应内容类型;

 3. language="java"
    指定编写动态代码内容的语言，唯一一个可能取值为
    java

 4. extends=""
    指定父类，不建议修改；

 5. isThreadSafe="true|false"
    指示容器是否需要在Servlet源代码上加
    SingleThreadModel, 默认值为 true;

 6. buffer="none|x kb"
    设定 JspWriter 对象缓存大小，默认值为 8kb;

 7. session="true|false"
    是否在 _jspService方法中创建一个 session 名称
    的局部变 量；默认值为 true;

 8. isErrorPage="true|false"
    是否在 _jspService方法中创建一个 exception 名称
    的局部变 量；默认值为 false;   

 9. errorPage=""
    设定错误跳转页面

2.include指令(静态包含)(编译阶段)
    在编译阶段,将两一个jsp的全部内容放置到要包含的地方
    <%@include file=""%>
   静态包含的特点:
   
    1. 文件路径是否支持脚本元素?
    <% String path="copyright.html";%>
    <%@ include file="<%=path%>"%>
    不支持

    2. 是否允许传参?
    <%@ include file="copyright.jsp?n=10"%>
    不允许
    3.包含阶段
      在编译阶段
    4.使用的是同一个request请求
    5.编译后生成一个java文件
    
------动作指令:---------(jsp自带的标准标签)

.include动作(动态包含)(在运行期间的包含)
 
 1. <jsp:include page=""/>

   1. 文件路径是否支持脚本元素?
    支持

   2. 是否允许传参?
       允许
   3.包含时期:
       运行期间
   4.编译后生成两个java文件包含和被包含各一个,被包含的类对象,只有当被访问时才包含
   
4.page属性:<%@ page attribute="value"....%>
1).language="java"定义要使用的语言，目前只能是java
2).import="package.class,package2.class2"和一般的java import意义一样，用","来隔开
3).contentType="text/html;charset="UTF-8"定义页面显示的MIME类型和jsp页面的编码
4).session="true|false" 默认为true指定一个Http的session中这个页面是否参与
5).buffer="none|8kb|sizekb" 默认为8kb指定到客户端输出流的缓冲模式，
如果是none则不缓冲，如果指定数值，那么输出就用不小于这个值的缓冲区进行缓冲。
6).autoFlush="true|false" 默认为true,当缓冲区满时,到客户端的输出被刷新false 当缓冲
区满时，出现运行异常，表示缓冲溢出
7).isThreadSafe="true|false" 默认为true用来设置jsp文件是否能支持多线程的使用。
如为true，那么一个jsp能够同时处理多个用户的请求，反之，一个jsp只能一次处理一个请求。
8).info="text"关于jsp页面的信息，定义一个字符串，可以使用getServletInfo()获得
9).errorPage="relativeURL" 默认忽略定义此页面出现异常时调用的页面
10).isErrorPage="true|false" 默认为false表明当前的页面是否为其它页面的errorPage
目标，如果设置为true，则可以使用exception对象。反之，如果设置为false，则不可以使用
exception对象
11).extends="package.class"指定jsp对应的servlet类继承某个父类
12).isELIgored="true|false" 指定EL表达式语言是否被忽略，如为true则忽略，
反之可以使用EL。默认由web.xml描述文件的版本确定，servlet2.3以前版本被忽略。
13).pageEncoding="type"定义jsp页面的字符编码，跟charset实现的功能一致
14).pageEncoding="iso8859-1" 优先级不如contentType("text/html;charset=utf-8");



 2. <jsp:forward page=""/>
    服务器内部跳转
   
 jsp:注释:
   1. html.xml注释方式:
      <!-- -->
      注释内容会出现在Servlet和客户端浏览器代码中,但是不会显示
      可以注释jsp所有内容
   2.scriptet(脚本)注释:
      <%
       //注释内容
       /*
       *注释内容
       */
      %>
      注释的内容会出现在Servlet代码中,但是不会出现在客户端
      
   3.隐藏注释:
     <%-- --%>
     注释的内容既不会出现在Servlet中也不会出现在客户端代码中
    
    
   


--------ch04:可重用组件 javaBean-----------
-------组件：---------


1. 程序员自行编写；
2. 调用Java API;
3. 实现特定功能，可被 重复使用 的
    一个类或多个类;

1，组件
对于一些比较低级的，并且比较常用的业务进行简单的封装，为复杂的程序调用提供帮助的java类的集合

常见的为普通的javaBean和企业级的javaBean

eg：
分页操作使用javaBean控制维护页码信息

2，什么是javaBean
（1）实现序列化接口
（2）有无参构造器，主要目的是方便容器或者调用灵活的构建
（3）必须含有属性并且提供get，set方法
（4）可以实现简单的数据库控制逻辑
 (5) 可以加入一些简单的事件处理代码
 
 注:后两个才是jsp中JavaBean真正的用处

分为只读，只写以及可读可写的javaBean
对于普通属性，必须使用setXXX，getXXX，XXX表示属性名且第一个字母大写

3. 分类:
  1.按所处的位置分类:
    1.可显示的:
      运行在客户端(如处理swing组件的JavaBean)
    2.不可显示的:
       运行在服务器后台的处理业务逻辑,数据控制的javabean
  
  2.按照功能:
     1.处理业务逻辑
         处理逻辑,数据控制,访问
     2.不处理业务逻辑:
         仅仅又来封装信息就像pojo类;
 
4.使用JavaBean的目的:
   1. 用来封装业务逻辑,数据访问逻辑
   2.封装jsp的一些脚本,实现jsp的可重用
   3.作为一个可重用的组件
 
 值对象:  以数据为驱动
 域对象:  以业务逻辑为驱动
 
  
5，使用
<jsp:useBean id="" class="" scope="" type="" beanName="">

id:表示在作用域对象中放入的key值，javaBean的引用
class：表示javaBean的名称
scope：表示javaBean的存储范围，默认的范围为pageContext，表示只在当前页面有效
type：表示javaBean的引用类型
beanName：表示bean的引用，如果不设置，默认使用id的值
<jsp:useBean id="list" class="java.util.ArrayList" scope="session">
<jsp:setProperty name="" property="" value="" param=""/>
name:必须和useBean的id一致，表示类对象引用
property：表示获取的属性，注意bean类里面一定要由getXXX方法
param：表示页面表单的name属性的值，用于SetXXX（value)的value
value：表示给属性赋常量值，有此属性，form表单的数据将不会赋予对象
----------------------------------
-------------------------------------------------


<jsp:userBean id="store" class="bean.BookStore" scope="application"/>

id:
   1. 用来指向JavaBean对象的局部变量名称；
    User user=new User();
   
      2. 某个作用域中属性名称
    session.setAttribute("user",user);

class:
   
             1. JavaBean对象的完整类名,一定要显示指定包名称;可独
    立于type使用;

type:
    
    1. id所指向JavaBean对象所声明的对象类型,
    可以和class内容相同，也可以为其接口、父类型;
  User user=new User();
|type idclass

  List  list=new ArrayList();
|             |                 |
        type       id             class

scope:
JavaBean对象所存放的作用范围，有四个可能取值：
page|request|session|application
--------------------------------->
默认值为 page,即在当前页面有效;

        1. page:     PageContext.getRequest();
2. request: HttpServletRequest
3. session:   HttpSession
4. application: ServletContext


beanName:
    用来指定JavaBean对象反序列化时类型的名称; 必须配合
e="user" property="name"/>

name：和useBean一致

property：表示获取的属性，注意bean类里面一定要由getXXX方法

另见神游笔记:p95



------------------------------------
jsp＋servlet＋架构书写应用程序

jsp中调用servlet，只要使用路径就可以激发
<img src="">

   
   type使用；

WebRoot
    |
    --- beanTest.jsp

http://localhost:8888/jsp_jd0908/beanTest.jsp

<jsp:useBean id=""
                       class=""
                       scope=""/>
<jsp:setProperty name="" property="passwd"
                                            param="pwd"/>
<jsp:getProperty name="" property=""/>

ng.jsp?guess= ->   ""
ng.jsp ->   null

scope=""

1. page:     PageContext.getRequest();
2. request: HttpServletRequest
3. session:   HttpSession
4. application: ServletContext

setAttribute(String,Object);
Object getAttribute(String);
removeAttribute(String);

http://localhost:8888/jsp_test/el.jsp?a=10&b=20

/jsp_test:  Context Path -> request.getContextPath();

/el.jsp:      Servlet Path  -> 
request.getServletPath();

a=10&b=20: Query String ->
request.getQueryString();

<%@page isELIgnored="false"%>

${param.hobby}
String s=request.getParameter("hobby");
${param
String[] sa=request.getParameterValues("hobby");

ArrayList list=request.getAttribute("list");
if(list==null)
list=new ArrayList();

  
<jsp:getProperty nam


     userBean
if(id==null)
    new Object();
    request.setAttribute(id,obj);


-------------el表达式：----------------
类似于<%=>脚本的一种语言，可以嵌套在jsp中，从jstl1.0开始使用
1，语法
  $()
  $(name)
  $(param.name)
  $(person.age)
  $(person.address.city)
  $(1+1)
  $(true&&false)
  $(list.get())

2，出现的位置
  (1)jsp标签中
     <jsp:include page="$(..)">
  (2)可以出现在jsp的任何空白的位置
 （3）可以出现在函数调用的参数
 
3，处理的对象或者操作
（1）基本的类型（int float String null ...）
（2）使用运算符
 (3)使用关系操作
（3）使用逻辑操作
（4）empty：表示判断对象为null或者empty
eg：String a=null; String a="";
（6）混合使用操作符号
（7）使用函数
（8）可以操作内置对象


 例:
<%@ page pageEncoding="UTF-8"%>
<jsp:useBean id="user" class="com.bean.User" scope="request"></jsp:useBean>
<jsp:useBean id="list" class="java.util.ArrayList" scope="page"></jsp:useBean>
<html>
  <body>
    <h1>EL使用测试</h1>
    <h3>表示字面值</h3>
    boolean: ${true}<br>
    String: ${"Hello World!" }<br>
    Number: ${1 }<br>
    <h3>操作符</h3>
    1+1=${1+1 }<br>
    1>1？${1>1 }<br>
    request作用范围是否存在user名称的对象？<br>
    ${(!empty user)?"存在!":"不存在！" }<br>
    ${pageContext.request.contextPath }<br>
    ${pageContext.request.servletPath }<br>
   ${pageContext.request.queryString }<br>
   ${pageScope.list }<br>
   ${list }<br>
   ${requestScope.user }<br>
   ${page.user }<br>
   ${user }
   ${param.n1 }+${param.n2 }=${param.n1+param.n2 }
   ${header }
  </body>
</html>





--------,内置对象的作用域-------------
在jsp的编程中，el表达式获得对象或者参数的值的时候，在本页面默认的就是从指定作用域中获得，对于跨页面，只要作用域支持，默认都可以省略xxxScope（sessionScope，applicationScope）来调用


jstl标签：jsp的标签库
为什么
对于一些常见的业务操作，以及编程的基本操作，比如循环，判断...对于编程者来说，每次处理同样的业务会显得比较枯燥，所以jsp集合html以及web应用的特点按照一定的规范，将其封装，对于使用jsp的开发者，只需要传入相应的参数即可实现数据的处理

使用taglib指令导入相应的标签库--->查看jar文件是否存在-->直接调用

构建Student的集合
然后遍历，将属性以table的形式显示

--------------JSTL： -----------


1. 标记库
    作用：和JavaBean功能类似，试图减少JSP中Java代
             码,实现代码重用.但功能更强大；

2. JSTL(标准的标记库)
    SUN公司制定的标记库;

3. 标记库的组成；
    1）标记处理类：    Java代码；
    
    2）标记库描述文件:  描述了标记处理类在JSP中访问的
         (.tld)               . 标记名称；
                                . 允许传递的属性名称；

    3)  JSP访问：   使用类似于<html>标记形式
         
         a. 引入标记库描述文件

             <%@taglib uri="标记库描述文件路径"
                              prefix="标记库描述文件别名"%>

             i.  直接使用路径
                 /WEB-INF/c.tld
                 <%@taglib uri="/WEB-INF/c.tld"...%>
             ii. 在 web.xml 中的逻辑名称
                 web.xml
                 --------------------------------------
                 <taglib>
                   <taglib-uri>/c.tld</taglib-uri>
                   <taglib-location>/WEB-INF/c.tld
                   </taglib-location>
                 </taglib>

                 <%@taglib uri="/c.tld"...%>
             iii.<%@taglib uri="http://java.sun.com/jsp/jstl/core"%>

--------Map遍历：-----------

1. 先获得所有键形成的Set
    Set ks=map.keySet();
    for(Object k:ks) {
          Object v=map.get(k);
    }
2.  获得所有值形成的Collection
     Collection vc=map.values();
     for(Object v: vc) {

     }
3. 获得键值对(Map.Entry)形成的Set
    Set es=map.entrySet();
    for(Object o: es) {
         Map.Entry e=(Map.Entry)o;
         Object k=e.getKey();
         Object v=e.getValue();
    }

线程安全问题：

1. 多线程;                          -> synchronized
2. 访问相同的实例变量或静态变量；  -> 局部变量
从而引起变量值产生冲突；

int x=10;

         Thread 1 Thread 2
------------------------ -------------
t1          x++;    //11
t2                                      x++;   //11
t3      print(x);  //12
t4

error.jsp
m.jsp?n=a


------------------


  第九章 Java Server Page Tag Libraries(JSTL)
1、JSTL：SUN公司制定的一套标准的标记库
2、具体用法：
一. <c:out>
作用：显示数据的内容，就像是<%=scripting-language%>一样;
语法：1) 没有本体(body)内容
<c:out value="value" [escapeXml="{true|false}"] [default="defaultValue"]/>
2) 有本体(body)内容
<c:out value="value" [escapeXml="{true|false}"]>
default value
</c:out>
属性：1) value: 需要显示出来的值；
2) default: 如果value的值为null, 则显示default的值;
3) escapeXml: 是否转换特殊字符, 如：< 转换成&nbsp, 默认情况下其值为true;
Null和错误处理：
假若value为null, 会显示default的值，假若没有设定default的值，则会显示
一个空的字符串;
范例：<c:out value="Hello JSP 2.0!!"/> <!--在网页上显示Hello JSP2.0!!-->
<c:out value="${3+5}"/> <!--在网页上显示8;-->
<c:out value="${param.data}" default="No Data"/>
<c:out value="<p>有特殊字符</p>"/>
<c:out value="<p>有特殊字符</p>" escapeXml="false"/>
二. <c:set>
作用：将变量储存至JSP范围中或是JavaBean的属性中;
语法：1) 在value的值储存至范围为scope的varName变量之中
<c:set value="value" var="varName" [scope="{page|request|session|
application}"]/>
2) 在本体内容的值储存至范围为scope的varName变量之中
<c:set var="varName" [scope="{page|request|session|application}"]>
...本体内容
</c:set>
3) 将value的值储存至target对象的属性中
JavaEE@xuxiang 248
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
<c:set value="value" target="target" property="propertyName"/>
4) 将本体内容的数据储存至target对象的属性中
<c:set target="target" property="propertyName">
...本体内容
</c:set>
属性：1) value: 要被储存的值；
2) var : 欲存入的变量名称; 不能使用表达式来表示;
3) scope: var变量的JSP范围，默认值是page; 不能使用表达式来表示;
4) target:为一JavaBean或java.util.Map对象;
5) property: 指定target对象的属性;
范例：<c:set var="number" scope="request" value="${1+1}"/>
<c:set var="number" scope="session">
${3+5}
</c:set>
<c:set var="number" scope="request" value="${param.number}"/>
<c:set target="${user}" property="name" value="${param.Username}"/>
三. <c:remove>
作用：移除变量;
语法：<c:remove var="varName" [scope="{page|request|session|application}"]/>
属性：1) var : 欲移除的变量名称; 不能使用表达式来表示;
2) scope: var变量的JSP范围，默认值是page; 不能使用表达式来表示;
四. <c:catch>
作用：处理产生错误的异常状况，并且将错误信息储存至varName变量中。
语法：<c:catch [var="varName"]>
...欲抓取错误的部分
</c:catch>
属性：1) var: 用来储存错误信息的变量;
五. <c:if>
作用：和一般在程序中使用的if一样。
语法：1) 没有本体内容(body)
<c:if test="testCondition" var="varName" [scope="{page|request|session|
application}"]/>
2) 有本体内容(body)
JavaEE@xuxiang 249
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
<c:if test="testCondition" [var="varName"] [scope="{page|request|session|
application}"]>
本体内容
</c:if>
属性：1) test: 如果表达式的结果为true, 则执行本体内容，false相反
2) var : 用来储存test运算后的结果，即true或false;
3) scope: var变量的JSP范围
六. <c:forEach>
作用：循环控制，它可以将集合中的成员循序浏览一遍， 当条件符合时，就会持
续重复执行<c:forEach>的本体内容。
语法：1) 迭代集合对象之所有成员
<c:forEach [var="varName"] items="collection" [varStatus="varStatusName"]
[begin="begin"] [end="end"] [step="step"]>
本体内容
</c:forEach>
2) 迭代指定的次数
<c:forEach [var="varName"] [varStatus="varStatusName"] begin="begin"
end="end" [step="step"]>
本体内容
</c:forEach>
属性：1) var : 用来存放现在指到的成员
2) items : 被迭代的集合对象
3) varStatus: 用来存放现在指到的相关成员信息, 它有四个属性：
index: 现在指到成员的索引；
count: 总共指到成员的总数；
first: 现在指到的成员是否为第一个成员；
last: 现在指到的成员是否为最后一个成员；
(见c_forEach5.jsp)
4) begin: 开始的位置;
5) end : 结束的位置;
6) step : 每次迭代的间隔数;
注意：1) varName的范围只存在<c:forEach>...</c:forEach>的本体中，如果超出了本
体，则不能再取得varName的值。
<c:forEach items=${atts}" var="item">
</c:forEach>

${item}<br>
${item}则不会显示item的内容
演示一下：<c:forEach>配套List, Set以及Map时使用的情景。
七. <c:import>
作用：把其它静态或动态文件包含至本身JSP网页。和<jsp:include>相比，它能包
含不同web application或者是其他网站的文件。
语法：1) <c:import url="url" [context="context"] [var="varName"] [scope="{page|
request|session|application}"]
[charEncoding="charEncoding"]>
本体内容
</c:import>
2) <c:import url="url" [context="context"] varReader="varReaderName"
[charEncoding="charEncoding"]>
本体内容
</c:import>
属性：1) url: 一文件被包含的地址;
2) context: 相同container下，其他web站点必须以"/"开头;
3) var : 储存被包含的文件的内容(以String类型存入)。
当var属性存在的时候，被包含的文件内容导入后不会输出在
网页上，而是以String的形式
4) scope : var变量的JSP范围;
5) charEncoding: 被包含文件之内容的编码格式;
6) varReader : 储存被包含的文件的内容(以Reader类型存入)
示例: 1) <c:import url="http://java.sun.com"/>
2) <c:import url="ftp://202.168.0.202/data.txt"/> <!--支持ftp协议-->
3) <c:import url="Hello.jsp"/>
4) <c:import url="images/hello.txt"/>
5) <c:import url="/jsp/index.html" context="/others"/>
导入同一个服务器下others应用下的jsp/index.html文件内容,
注意：
a. 被包含的web站点必须在server.xml中定义过;
b. <context>的crossContext属性值必须为true。这样，others应用下的文
件
才可以被其他web站点调用。

<context path="/others" docBase="others" crossContext="true"
reloadable="true"/>
...
八. <c:url>
作用：用来产生URL, 以前我们必须使用相对地址或是绝对地址去取得需要的图文
件或文件，现在我们可以直接利用<c:url>从Web站点的角度来设定需要的图文件或文件的
地址。
语法：1) <c:url value="value" [context="context"] [var="varName"]
[scope="{page|request|session|application}"]/>
2) <c:url value="value" [context="context"] [var="varName"]
[scope="{page|request|session|application}"]>
<c:param>标签
</c:url>
属性：1) value; 执行的URL;
2) context: 相同container下，其他web站台必须以"/"开头;
3) var: 储存被包含文件的内容(以String类型存入)
4) scope: var变量的JSP范围
示例：1) <c:url value="http://www.javaw.cn">
<c:param name="param" value="value"/>
</c:url>
执行结果产生一个网址为：http://www.javaw.cn?param=value
2) <a href="
<c:url value="http://www.javaw.cn">
<c:param name="param" value="value"/>
</c:url>Java技术论坛
</a>
执行结果产生一个网址为：<a
href="http://www.javaw.cn?param=value">Java技术论坛</a>
3) <img src="<c:url value="/images/code.gif"/>"/>
执行结果产生一个网址为：<img src="/应用名称/images/code.gif"/>
九. <c:redirect>
作用：将客户端的请求从一个JSP网页导向到其他文件
语法：1) 没有本体内容

<c:redirect url="url" [context="context"]/>
2) 本体内容代表查询字符串参数
<c:redirect url="url" [context="context"]>
<c:param>
</c:redirect>
属性：1) url: 导向的目标地址;
2) context: 相同container下，其他web站点必须以"/"开头
示例：<c:redirect url="http://localhost:8080">
<c:param name="param" value="value"/>
</c:redirect>
十. <fmt:setLocale>
作用：设定用户的语言区地区。
语法：<fmt:setLocale value="local" [variant="variant"]
[scope="{page|request|session|application}"]/>
属性：1) value: 地区代码。其中最少要有两个字母的语言代码，如：zh、en, 然后也
可以再加上两个字母的国家和地区代码，如：US, TW, 两者可以由"-"或"_"
相连接起来，例如：zh_TW, zh_CN, en, en_US. 假若value为null
时，则使用执行中的默认地域(locale)
2) varient: 供货商或浏览器的规格，例：WIN代表Windows, Mac代表
Macintosh.
3) scope: 地区设定的套用范围;
十一. <fmt:requestEncoding>
作用：设定字符串编码，功能和ServletRequest.setCharacterEncoding()相同;
语法: <fmt:requestEncoding [value="charseName"]/>
属性：1) value: 字符串编码,当我们设定value为GB2312时，表示将所有传送过来
的字符串皆用GB2312编码处理，如果没有设定value属性，则它将会自动去寻找
合适的编码方式。
十二. <fmt:message>
作用：从指定的资源中把特定关键字中的值抓取出来;
语法：1) <fmt:message key="messageKey" [bundle="resourceBundle"]
[var="varName"] [scope="{page|request|session|application}"]/>
2) <fmt:message key="meesageKey" [bundle="resourceBundle"]
[var="varName"] [scope="{page|request|session|application}"]>
JavaEE@xuxiang 253
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
<fmt:param>
</fmt:message>
3) <fmt:message key="meesageKey" [bundle="resourceBundle"]
[var="varName"] [scope="{page|request|session|application}"]>
索引
(<fmt:param>标签)
</fmt:message>
属性： 1) key: 索引;
2) bundle: 使用的数据来源;
3) var: 用来储存国际化信息;
4) scope: var变量的JSP范围;
十三. <fmt:param>
作用：动态设定数据来源中抓出内容的参数；
语法：1) 通过value属性设定参数值
<fmt:param value="messageParameter"/>
2) 通过本体内容设定参数值
<fmt:param>
本体内容
</fmt:param>
示例：1) Str3=today is {0, date}
其中{0,date}表示为一个动态变量, 0代表第一个动态变量；date代表该动
态变量的类型。
十四. <fmt:bundle>
作用：设定本体内容的数据来源;
语法：<fmt:bundle basename="basename" [prefix="prefix"]>
本体内容
</fmt:bundle>
属性：1) basename: 要使用的资源名称，如果我们的properties文件为
Resource.properties, 那么
basename的值为Resource. basename的值千万不可有任何文件
类型。
2) prefix: 设定前置关键字。
例：当properties中内容如下：
requestinfo.label.method=Method:
JavaEE@xuxiang 254
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
requestinfo.label.requesturi=Request URI:
那么我们可以写成如下方式将其内容显示出来：
<fmt:bundle basename="Resource" prefix="requestinfo.label.">
<fmt:message key="method"/>
<fmt:message key="requesturi"/>
</fmt:bundle>
十五.<fmt:setBundle>
作用：设定默认的数据来源，或者也可以将它设定到属性范围中.
语法：<fmt:setBundle basename="basename" [var="varName"]
[scope="{page|request|session|application}"] />
属性：1) basename: 要使用的资源名称;
2) var : 储存资源的名称;
3) scope : var变量的JSP范围;
说明：basename设定要使用的数据源， 和<fmt:bundle>用法相同。如果没有设定var
时，那么设定好的数据来源
将会变成默认的数据来源，让在同一网页或同一属性范围中<fmt:message>都可
以直接默认使用此数据来
源。相反，如果设定var时，那么将会把此数据来源存入varName中，当
<fmt:message>要使用时，必须使
用bundle这个属性来指定。如：
<fmt:setBundle baseName="Resource" var="resource" scope="session"/>
<fmt:message key="str1" bundle="${resouce}"/>
如没有设定var时，则只须写成如下：
<fmt:setBundle baseName="Resource"/>
<fmt:message key="str1"/>
一般<fmt:bundle>和<fmt:setBundle>都可以搭配<fmt:setLocale>使用，当我们有
多种语言的数据业来
源时，可以将文件名取成Resource_zh_TW.properties, Resource_en.properties和
Resouce.properties
当我们将区域设定为zh_TW, 那么使用<fmt:setBundle>或<fmt:bundle>时，将会
默认读取 Resource_zh_TW.properties资源文件，如果<fmt:setLocale>设定为en
时，那么会默认抓取 Resource_en.properties来使用，最后如果设定的区域没有
符合的文件名，将使用Resource.properties 来当做数据来源, 见fmt_i18n.jsp.
十六.<fmt:formatNumber>
JavaEE@xuxiang 255
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
作用：依据设定的区域将数字改为适当的格式。
语法：<fmt:formatNumber value="numbericValue" [type="{number|currency|percent}"]
示例：<fmt:formatNumber value="123" type="currency"/> 显示为 $123
十七.<fmt:parseNumber>
作用：将字符串类型的数字、货币或百分比，都转为数字类型。
语法：<fmt:parseNumber value="numericValue" [type="{number|currency|percent}"]
[pattern="customerPattern"]
.../>
示例：<fmt:parseNumber value="500,800"/>显示为: 500800
<fmt:parseNumber value="$5000" type="currency"/> 显示为：5000
十八.<fmt:formatDate>
作用：格式化日期，时间
语法：<fmt:formatDate value="date" [type="{time|date|both}"]
[dateStyle="{default|short|medium|long|full}"]
[timeStyle="{default|short|medium|long|full}"]
/>
示例：<jsp:useBean id="now" class="java.util.Date"/>
<fmt:formatDate value="${now}"/>
十九.<fmt:parseDate>
作用：将字符串类型的时间或日期都转为日期时间类型；
语法：<fmt:parseDate value="date"
示例：<fmt:parseDate value="2003/2/17"/>
二十. <fmt:setTimeZone>
作用：设定默认时区或是将时区储存至属性范围中,方便以后使用
语法：<fmt:setTimeZone value="timeZone" [var="varName"]
[scope="{page|request|session|application}"]/>
属性：1) value: 使用的时区：可以为EST, CST, MST和PST，为null时，则默认为
GMT时区。
示例：<fmt:setTimeZone value="PST" scope="session"/>
二十一.<fmt:timeZone>
作用：设定暂时的时区;
JavaEE@xuxiang 256
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
语法：<fmt:timeZone value="timeZone">
本体内容
</fmt:timeZone>
示例：<fmt:timeZone value="PST">
<fmt:formatDate.../>
<fmt:formatDate.../>
...
</fmt:timeZone>
二十二.<sql:setDataSource>
作用：用来设定数据来源(DataSource)
语法：1) 直接使用已存在的数据来源
<sql:setDataSource dataSource="dataSource"
[var="varName"]
[scope="{page|request|session|application}"]/>
2) 使用JDBC方式，建立数据库联机
<sql:setDataSource url="jdbcUrl"
driver="driverClassName"
user="userName"
password="password"
[var="varName"]
[scope="{page|request|session|application}"]/>
示例：1) <sql:setDataSource dataSource="java:comp/env/jdbc/mysql"/>
2) <sql:setDataSource
dataSource="jdbc:mysql://localhost/test,com.mysql.jdbc.Driver,root,"/>
dataSource="url,driver,user,password"
3) <sql:setDataSource url="jdbc:mysql://localhost/test"
driver="com.mysql.jdbc.Driver"
user="root"
password=""/>
二十三.<sql:query>
作用：查询数据库的数据.
语法：1) 没有本体内容
<sql:query sql="sqlQuery" var="varName"
[scope="{page|request|session|application}"]
JavaEE@xuxiang 257
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
[dataSource="dataSource"]
[maxRows="maxRows"]
[startRow="startRow"]/>
2) 本体内容为查询指令
<sql:query sql="sqlQuery" var="varName"
[scope="{page|request|session|application}"]
[dataSource="dataSource"]
[maxRows="maxRows"]
[startRow="startRow"]>
...
sqlQuery
...
</sql>
属性：1) sql: SQL语句(select);
2) dataSource: 数据来源;
3) maxRows: 设定最多可暂存的数据笔数;
4) startRow: 设定数据从第几笔开始, 以0为第一笔数据;
5) var: 储存查询结果, 必须的;
6) scope: var变量的JSP范围;
查询结果存放在指定名称的属性中后，可以通过以下属性访问查询结果：
rows: 以字段名称当做索引的查询结果；
rowsByIndex: 以数字当作索引的查询结果；
columnNames: 字段名称;
rowCount: 查询到的数据笔数;
limitedByMaxRows: 取出最大数据笔数的限制;
二十四.<sql:update>
作用：执行修改操作(update,delete,create table均可)
语法：1)没有本体内容
<sql:update sql="sqlUpdate" [var="varName"]
[scope="{page|request|session|application}"]
[dataSource="dataSource"]/>
2)本体内容为查询指令
<sql:update sql="sqlUpdate" [var="varName"]
[scope="{page|request|session|application}"]
JavaEE@xuxiang 258
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
[dataSource="dataSource"]>
...
sqlUpdate
...
</sql:query>
属性：1) sql: SQL语法(update,insert,delete...)
2) dataSource: 数据来源;
3) var: 储存改变的数据笔数;
4) scope: var变量的JSP范围;
二十五. <sql:transaction>
作用：提供事务支持，保证多个数据操作的完整性. <sql:transaction>主要是将所有必
须同时执行的交易放在它的本体内容中，当本体内容有错误发生时，将
不会执行任何一个SQL语句，所以可保障交易机制的安全性。
语法：<sql:transaction [dataSource="dataSource"]
[isolation="{read_committed|read_uncommitted|repeatable|serializable}"]>
<sql:query>or<sql:update>
</sql:transaction>
二十六. <x:parse>
作用：解析xml文件;
语法：1) <x:parse doc="XMLDocument"
[var="var' [scope="{page|request|session|application}"]
.../>
2) <x:parse [var="var' [scope="{page|request|session|application}"]
...>
欲被解析的XML文件
</x:parse>
属性：1) doc: xml文件;
2) var: 储存解析后的XML文件
3) scope: var变量的JSP范围
示例：1) <c:import var="sample" url="http://www.javaw.cn/web.xml"/>
<x:parse doc="${sample}" var="sampleXml"/>
2) <x:parse doc="${sample}" var="sampleXml">
<c:import url="http://www.javaw.cn/web.xml"/>
</x:parse>
JavaEE@xuxiang 259
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
二十七.<x:out>
作用：取出XML中的字符串.
语法：<x:out select="XPathExpression" [escapeXml="{true|false}"]/>
属性：1) select: XPath语句;
2) escapeXml: 是否转换特殊字符;
示例：<x:parse var="sampleXml">
<item>
<name>car</name>
<price>10000</price>
</item>
</x:parse>
显示<name>的内容，
1) <x:out select="$sampleXml//name"/>
2) <x:out select="$sampleXml/item/name"/>
二十八.<x:set>
作用：取出XML中的字符串, 储存至属性范围中
语法：<x:set select="XPathExpression" var="var" [scope="{page|request|session|
application}"]/>
属性：1) select: XPath语句;
2) var: 将从XML文件中取得的内容储存至varName中;
3) scope: var变量的JSP范围;
示例：<x:parse var="sampleXml">
<item>
<name>car</name>
<price>10000</price>
</item>
</x:parse>
显示<name>的内容，
1) <x:out select="$sampleXml//name"/>
2) <x:out select="$sampleXml/item/name"/>
三十. fn:contains()
作用：判断某字符串是否在一字符串之中;
语法：${fn:contains(string, substring)} => boolean
JavaEE@xuxiang 260
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
属性：1) string: 原输入的字符串;
2) substring: 测试用的字符串;
3) Result: 回传string是否包含substring. 若有，则回传true; 若无，则回传
false;
三十一. fn:containsIgnoreCase()
作用：判断某字符串是否在已有字符串之中，并忽略其大小写;
语法：${fn:containsIgnoreCase(string, substring)} => boolean
三十二. fn:startsWith(string, prefix)
作用：判断一字符串是否以某一字符串为开头;
语法：${fn:startsWith(string, prefix)} => boolean
三十三. fn:endsWith(string, suffix)
作用：判断一字符串是否以某一字符串为结尾;
语法：${fn:endsWith(string, suffix)} => boolean
三十四. fn:escapeXml(String)
作用：用来转换转义符，例如：将<,>,',"和&转换成&lt;,&gt;,&#039;,&#034;和&amp;
语法: ${fn:escapeXml(String) => String
三十五. fn:indexOf(string, substring)
作用：回传某字符串到一字符串第一次吻合的位置;
语法: ${fn:indexOf(string, substring)} => int
三十六. fn:split(string, delimiters)
作用：将字符串分离成一字符串数组;
语法: ${fn:split(string, delimiters)} => string[]
三十七. fn:join(array, separator)
作用：将数组中的全部元素以指定字符串作为连接符，回传结合后的字符串;
语法: ${fn:join(array, separator)} => string
三十八. fn:replace(inputString, beforeSubstring, afterSubstring)
作用：将字符串中的某些子字符串用另一字符串取代;
语法: ${fn:replace(inputString, beforeSubstring, aterSubstring)} => string
属性：1) inputString: 原输入的字符串;
JavaEE@xuxiang 261
Java/JavaEE学习笔记Jonny xuxiang5612@sina.com
2) beforeString: 要替换的字符串;
3) afterSubstring: 替换成为的字符串;
三十九. fn:trim(string)
作用：去除字符串的前后空白;
语法: ${fn:trim(string)}
四十. fn:substring(string, beginIndex, endIndex)
作用：抽取字符串中的某一子字符串;
语法: ${fn:substring(string, beginIndex, endIndex)} => string
四十一. fn:substringAfter(string, substring)
作用：抽取字符串中某子字符串之后的字符串;
语法：${fn:substringAfter(string, substring)} => string
属性：1) string: 原输入的字符串;
2) substring: 某子字符串;
四十二. fn:substringBefore(string, substring)
作用：抽取字符串中某子字符串之前的字符串;
语法：${fn:substringBefore(string, substring)} => string
属性：1) string: 原输入的字符串;
2) substring: 某子字符串;
四十三. fn:toLowerCase(string)
作用：转换为小写字符;
语法：${fn:toLowerCase(string)} => string