JS基础-摩杜云开发者社区

jsp基础

jsp是java server page的简称,它是为了解决html不能处理动态内容,servlet处理静态内容又很麻烦的一种新的技术.

jsp可以认为是静态内容与java代码的一个混合体,带来了方便,也会导致过多的java与静态内容混合在一起,也并不是一种好的开发方式.

jsp的组成成分

一个jsp页面,内部有如下组成部分:

指令(directive)
脚本元素

小脚本(scriptlet)<% %>
jsp表达式 <%= %>
声明

动作(action)
jsp注释
静态内容

html
css
javascript

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>jsp demo</h1>
<%= new java.util.Date() %>
</body>
</html>

jsp的运行原理

转译与编译

jsp的处理,首先需要经过转译(translation),就是把jsp翻译成java代码,此java代码就是一个servlet,接着进行编译,就是把转译的结果编译成class文件.jsp比servlet就多了一个转译的步骤

在tomcat的work目录下,可以看到转译的结果.

转译是由tomcat的jasper引擎来完成的,比如上面的jsp文件转译之后的结果如下:

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/8.5.30
 * Generated at: 2019-06-05 02:33:33 UTC
 * Note: The last modified time of this file was set to
 *       the last modified time of the source file after
 *       generation to assist with modification tracking.
 */
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

public final class d_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private static final java.util.Set<java.lang.String> _jspx_imports_packages;

  private static final java.util.Set<java.lang.String> _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = null;
  }

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public java.util.Set<java.lang.String> getPackageImports() {
    return _jspx_imports_packages;
  }

  public java.util.Set<java.lang.String> getClassImports() {
    return _jspx_imports_classes;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
      throws java.io.IOException, javax.servlet.ServletException {

    final java.lang.String _jspx_method = request.getMethod();
    if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
      response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET POST or HEAD");
      return;
    }

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.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;

      out.write("\n");
      out.write("<!DOCTYPE html>\n");
      out.write("<html>\n");
      out.write("<head>\n");
      out.write("<meta charset=\"UTF-8\">\n");
      out.write("<title>Insert title here</title>\n");
      out.write("</head>\n");
      out.write("<body>\n");
      out.print( new java.util.Date() );
      out.write("\n");
      out.write("</body>\n");
      out.write("</html>");
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

生命周期

整个生命周期与servlet类似,除了多了一个转译与编译过程以外

转译与编译
init
service
destroy

JSP的指令元素

jsp指令主要用来给jasper引擎提供一些信息,以便正确的进行转译与编译工作,比如告诉jasper引擎导入的包有哪些.主要的指令有3个

page指令
include指令
taglib指令

指令的语法格式是:<%@ 指令名属性名=属性值 %>,同一个指令可以出现多次,比如page指令.

page指令

此指令是jsp必不可少的一个指令,用来告诉引擎此页面中的代码的语言是什么,响应的类型,字符编码等.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

此指令的一个常用的属性是import,用来导入其它的类,比如下面:

<%@page import="java.util.*"%>
<%@page import="java.util.Date"%>

include指令

include指令是用来把其它的文件包含进来,类似于剪切,粘贴,所以jasper引擎在转译阶段,把被包含的文件与当前文件当成一个整体来处理.

tablib指令

标记库指令,是用来使用标准标签库以及其它第三方标签库的一个指令.后续jstl章节会用到.

jsp脚本元素

jsp的脚本元素主要就是用来编写java代码的,主要分为3个部分:

声明:用来声明一些变量,方法,类等
小脚本:java的代码块,以前在方法里可以写的代码就可以放在这里
表达式: java的表达式书写的地方.

声明

语法格式:<%! %>,一般用来声明变量,方法,比如:

int a = 5;
List<Student> students = new ArrayList<Student>();

小脚本(scriptlet)

语法格式:<% %> ,这里用来编写代码块,比如:

<%
for(int i=0;i<3;i++){
  System.out.print(i);
}
%>

注意:这里是java代码块,只能编写java代码,不能出现html的代码片段

表达式

语法格式:<%= %>,主要用来把java表达式的值显示在最终的响应中,比如:

<%= 1 + 2 %>

上面的代码就会把3显示在浏览器中.下面的代码就会把1.jpg替换掉表达式,这样一个图片就显示出来了.

<%! String imgPath = "1.jpg" %>

<img src='<%= imgPath %>'/>

有了小脚本与表达式之后,就可以结合两者做出java与html混合的效果,比如下面的代码就做出了一个无需列表

<ul>
  <%
  for(int i = 0; i<3;i++){
    %>
    <li><%= i %></li>
  <%}
  %>
</ul>

jsp动作元素

jsp动作是用xml的语法格式来控制引擎的一些行为,你可以动态插入一个文件,重用bean组件,进行转发等.其语法格式是:<jsp:动作名 />

forward

转发动作会终止当前的页面的输出并转发请求到其它的资源,比如静态html页面,jsp页面或者servlet

<jsp:forward pag="b.jsp"></jsp:forward>

如果在此动作之前或之后有一些内容,比如

<h1>前</h1>
<jsp:forward pag="b.jsp"></jsp:forward>
<%= new java.util.Date() %>

上面的h1会被直接丢弃,转发动作之后的表达式根本不会得到执行.只会把b.jsp的响应内容返回给浏览器.

param

转发指令如果要传递数据给目标页面就可以添加子动作param,使用方式如下:

<jsp:forward pag="b.jsp">
 <jsp:param value="111" name="a"/>
</jsp:forward>

注意: jsp:param动作传递参数的方式是通过查询字符串实现的,而不是通过往请求作用域来传递数据的.

在b.jsp中想取得传递过来的数据可以通过下面的方式实现

<%= request.getParameter("a") %>

上面的request是jsp的隐式对象.

include

此动作用来插入其它页面到当前页面中,语法格式如下:

<jsp:include page = "页面地址" />

不像include指令,此动作是当前页面被请求时才会执行插入文件的动作行为,而指令是在转译阶段就处理了.

include指令有以下几个特点:

运行时,只有一个servlet
在父页面中声明的变量可以被被包含的页面访问
被包含页面不需要单独编译为一个独立的servlet,所以一般被包含页面是代码片段,不是一个完整的jsp
在老的容器实现中,被包含页面没有更改并不会影响父页面,除非父页面有更改.
由于被包含进行是内联到父页面的service方法,可能导致service方法代码文件很大,某些容器在超过64k的时候可能编译出错

include动作特点如下:

如果父页面与被包含页面都是servlet(jsp)的话,父页面与被包含的页面在运行时是两个独立的servlet
通过动作,页面可以条件化的被包含进来.但指令不能做到
父页面脚本变量不能被被包含页面访问到

https://stackoverflow.com/questions/14580120/whats-the-difference-between-including-files-with-jsp-include-directive-jsp-in

bean action

java bean

JavaBean是特殊的Java类，使用java语言书写，并且遵守JavaBean API规范。

接下来给出的是JavaBean与其它Java类相比而言独一无二的特征：

提供一个默认的无参构造函数。
需要被序列化并且实现了Serializable接口。
可能有一系列可读写属性。
可能有一系列的"getter"或"setter"方法。

useBean

此指令的基本用法如下:

<jsp:useBean id="first" class="com.Student"></jsp:useBean>

此指令的作用就是创建一个对象或者在作用域里查找名字为first(id属性指定的值)的对象.在作用域里找不到时就会创建一个新的对象

上面的代码在经过转译之后,在生成的servlet代码的_jspService方法中的代码如下:

com.Student first = null;
      first = (com.Student) _jspx_page_context.getAttribute("first", javax.servlet.jsp.PageContext.PAGE_SCOPE);
      if (first == null){
        first = new com.Student();
        _jspx_page_context.setAttribute("first", first, javax.servlet.jsp.PageContext.PAGE_SCOPE);
      }

利用useBean创建对象之后就可以使用此对象了.比如:

<%-- 下面输出是空的,因为name没赋值-->
<%= first.getName() %>

setProperty

setProperty指令的基本用法如下:

<jsp:setProperty name="first" property="name" value="cj"/>

上面指令说明如下:

其中name属性的值first是useBean指令id属性的值,以表明需要对哪个bean进行属性设置
property属性的值,指的是所操作bean 的属性名
value属性的值就是给bean的属性的赋值

在使用setProperty指令之前,其所操作的bean必须已经存在.

此指令有两种用法,一种是在userBean指令的外部使用,比如:

<jsp:useBean id="first" class="com.Student"></jsp:useBean>

<jsp:setProperty name="first" property="name" value="cj"/>

放在外部这种用法,不管bean是从作用域查找到的还是直接新实例化的都会给属性赋值.

第二种用法是把setProperty指令放置在useBean内部,比如:

<jsp:useBean id="first" class="com.Student">
 <jsp:setProperty name="first" property="id" value="100"/>
</jsp:useBean>

这种用法只有在bean对象是新实例化对象的时候才会给属性赋值,如果从作用域找到了bean对象,那么就不会给属性赋值.

param

除了通过value这种形式给bean的属性直接赋值外,还可以利用param属性来赋值,但这两个不能同时使用,只能用其一或者两者都不用,两者都不用时,是靠内省机制来赋值(就是把请求参数中的名字与bean属性同名的属性,通过内省的方式自动赋值)

利用param给bean的属性赋值时,其实是读取请求参数(parameter)的数据赋值给bean的属性,比如下面的代码:

<jsp:useBean id="first" class="com.Student">
 <jsp:setProperty name="first" property="id" value="100"/>
</jsp:useBean>

<jsp:setProperty name="first" property="name" param="nameP"/>

当你通过查询字符串传递数据或者表单提交数据到此jsp时,如果有nameP名字的参数,那么就会把值赋值给bean的name属性,比如你请求地址为:

http://localhost:8080/jspdemo/ch02/bean.jsp?nameP=abc

那么就会把abc赋值给Student这个bean的name属性

也可以把setProperty指令的property属性的值设置为*,表示通过内省形式把请求参数的值都自动赋值给同名的bean属性上.

getProperty

此指令用来读取一个指定bean的指定属性的值,并把其转换为字符串,并插入到最终的输出中响应给浏览器端.使用方式如下:

<jsp:getProperty property="name" name="first"/>

JSP内置对象

JSP内置对象也称之为jsp隐式对象,是容器给每个jsp页面自动提供的,而不需要我们手动的去声明.这些预定义的对象名直接就可以在jsp页面中使用.内置对象有如下9个

对象名	类	主要作用
out	JspWriter	用它生成响应
request	HttpServletRequest	请求对象
response	HttpServletResponse	响应对象
page	当前页转译之后的对象自己	this的别称
pageContext	PageContext	页面上下文对象
session	HttpSession	请求关联的会话对象
application	ServletContext	Servlet的上下文对象
config	ServletConfig	此页关联的配置对象
exception	Throwable	异常对象,在页面是错误处理页并且有异常产生时才能使用

所有的这些隐式对象在转译生成的java文件中都可以看到

out

此对象的类型是JspWriter，功能与Servlet类中常用的PrintWriter类似,两种有很多方法的名字与作用都是差不多的.比如下面的代码

out.print("hello")

JspWriter相比PrintWriter多了缓冲(buffer)的处理以及其方法抛出的是IOException

通过把page指令的buffered属性设置为true可以关闭缓冲的处理

request

这点与servlet一样,每次浏览器端发起一个请求时都会由容器创建一个HttpServletRequest类型的对象以代表请求.

通过请求信息可以得到从浏览器传过来的信息,比如cookie,查询参数,请求方法,表单数据.http头信息等.

response

这点与servlet一样,每次浏览器端发起一个请求时都会由容器创建一个HttpServletResponse类型的对象,通过此对象服务端可以生成响应给浏览器端.

page

此对象就是当前jsp转译之后的servlet对象的引用.其实就是this的别称.

pageContext

此对象是PageContext类型的对象,通过此对象可以得到很多有用的信息,比如请求对象,响应对象等.

此对象也定义了几个有用的字段,比如:

PAGE_SCOPE
REQUEST_SCOPE
SESSION_SCOPE
APPLICATION_SCOPE

此对象也提供了查找属性值的方法findAttribute,此方法会沿着作用域查找数据.

此对象也是页面作用域存放数据所在的地方.

session

会话对象用来跟踪多次请求间的会话信息.解决了Http协议无状态特性的问题.

application

是ServletContext对象,整个web应用只有一个这样的实例,存放在里面的信息整个项目的所有jsp与servlet都可以访问

config

这是一个ServletConfig类型的对象,代表jsp或servlet的配置信息,通过他可以读取初始化参数.

exception

此对象就是之前页面抛出的异常对象的引用.此对象只有在错误页面时才能使用.

错误页面是把通过page指令的isErrorPage属性设置为true来实现.比如下面的页面main.jsp页面的代码如下,其中通过errorPage属性指定了错误处理页面myerror.jsp

<%@ page errorPage = "myerror.jsp" %>
<html>
   <head>
      <title>Error Handling Example</title>
   </head> 
   <body>
      <%
         int x = 1;      
         if (x == 1) {
            throw new RuntimeException("Error condition!!!");
         }
      %>
   </body>
</html>

myerror.jsp页面的代码如下:

<%@ page isErrorPage = "true" %>

<html>
   <head>
      <title>Show Error Page</title>
   </head>
   
   <body>
      <p>jsp发生错误了</p>
      <pre><% exception.printStackTrace(response.getWriter()); %></pre>
   </body>
</html>

作用域

jsp的作用域指的是存放数据作用的范围,类似于servlet的作用域.servlet作用域有3个,分别是请求作用域,会话作用域,应用程序作用域.jsp除了上面的作用域之外还多了一个页面作用域.几个作用域的含义如下:

PAGE_SCOPE:page作用域中存放的数据只在当前页有效,转发到别的页面后数据就读取不到了.
REQUEST_SCOPE:请求作用域中存放的数据,只在这一个请求周期中有效,转发到别的页面数据仍然可以读取到,但重定向到别的页面或发起新的请求就读取不到数据了.
SESSION_SCOPE:会话作用域中存放的数据在当前会话有效,会话超时或清空后会话中的数据就读取不到了.
APPLICATION_SCOPE:应用程序作用域中存放的数据在整个应用程序声明周期中有效.容器关闭后就读取不到数据了

比如下面的代码分别在4个作用域中存放了数据,但采用的是同样名字a

pageContext.setAttribute("a", "page a"); //page作用域
 request.setAttribute("a", "request a");  //request作用域
 session.setAttribute("a", "session a");  //session作用域
 application.setAttribute("a", "app a");  //application作用域

可以通过下面的方法来读取作用域中的数据

<%= pageContext.findAttribute("a") %>

<%= pageContext.getAttribute("a", pageContext.REQUEST_SCOPE) %>

其中findAttribute方法会自动沿着page->request->session->application作用域的顺序查找数据,只要找到就停止往上查找.如果4个作用域中都找不到就返回null

getAttribute方法可以通过指定在哪个具体的作用域中查找,找到就返回,找不到就返回null,不会沿着作用域的顺序查找数据.

当然,你也可以直接用相应的对象读取作用域中的数据,比如下面的代码就直接读取会话中的数据

session.getAttribute("a")

EL表达式

JSP的EL是JSP Expression Language的简称,称之为表达式语言,它可以简化我们对bean,内置对象,作用域中数据的访问,它也支持算术运算与逻辑运算.在JSP EL表达式内可以使用整型数，浮点数，字符串，常量true、false，还有null。

基本语法

el表达式的基本格式是:${expr} expr就是表达式,比如:${4+5}就是一个简单的算术表达式.

当JSP编译器在属性中见到"${}"格式后，它会产生代码来计算这个表达式，并且产生一个替代品来代替表达式的值。

你也可以在标签的模板文本中使用表达式语言,比如:

<h1>${4+5}</h1>

你也可以用来给html的元素的属性赋值

<input type="text" value="${4+5}" name="op"/>

禁用el表达式

通过把page指令的isElIgnored属性设置为true就表示忽略el表达式,这样el表达式就不生效了.

基本操作符

操作符	描述
.	访问一个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中的隐式对象

JSP EL支持下表列出的隐含对象,你可以在表达式中使用这些对象，就像使用变量一样。

隐含对象	描述
pageScope	page 作用域
requestScope	request 作用域
sessionScope	session 作用域
applicationScope	application 作用域
param	Request 对象的参数，字符串
paramValues	Request对象的参数，字符串集合
header	HTTP 信息头，字符串
headerValues	HTTP 信息头，字符串集合
initParam	上下文初始化参数
cookie	Cookie值
pageContext	当前页面的pageContext

pageContext

作用域对象

param与paramValues对象

header与 headerValues

JSP EL中的函数

JSP EL允许您在表达式中使用函数。这些函数必须被定义在自定义标签库中。函数的使用语法如下：

${ns:func(param1, param2, ...)}

ns指的是命名空间（namespace），func指的是函数的名称，param1指的是第一个参数，param2指的是第二个参数，以此类推。比如，有函数fn:length，在JSTL库中定义，可以像下面这样来获取一个字符串的长度：

${fn:length("Get my length")}

要使用任何标签库中的函数，您需要将这些库安装在服务器中，然后使用<taglib>标签在JSP文件中包含这些库。

JSTL

JSTL(JSP Standard Tag Library)是一个实现web应用程序中常见的通用功能的定制标签库集.JSTL的最终目标是帮助简化JSP开发人员的工作.让编写JSP页面就像编写html一样,因为页面开发人员并不一定熟悉java语言.

根据JSTL标签提供的功能,可以分为5个类别

核心标签
格式化标签
SQL标签
xml标签
JSTL函数

基本使用

JSTL是一个标准规范,apache提供了实现,apache的实现是使用最多的实现.现在JSTL的规范的最新版本是1.2,在https://tomcat.apache.org/taglibs/standard/网址可以下载Apache对规范的实现的最新版1.2.3版本.想正常使用JSTL 1.2的话,4个jar文件只需要下载impl与Spec即可.

JS基础_html

Spec:是规范相关的API

Impl是规范的核心实现

EL是对JSTL1.0的兼容支持实现

Compat:是使用的EL的容器实现

如果只用jstl 1.2 只需要 impl与Spec

当然为了简单起见,你也可以直接到网址https://mvnrepository.com/artifact/javax.servlet/jstl/1.2下载一个JSTL的jar文件即可.此jar里面是对apache实现的一个包装

使用JSTL的基本步骤如下:

把JSTL的相关jar文件放在WEB-INF/lib目录下
在JSP页面中通过taglib指令引用某一个标签库,比如核心标签库

JSTL的主要版本有1.1与1.2这两个,由于JSTL 1.1已经过时，Apache已将其置于存档中。如果您正在运行Servlet 2.5兼容容器并且web.xml声明为至少Servlet 2.5，那么您应该能够使用新的JSTL 1.2。

JS基础_html_02

jstl jar文件简介:https://stackoverflow.com/questions/39953734/what-are-jstl-mandatory-jars

核心标签库

想使用核心标签库的话,jsp中标签库引用的指令写法如下:

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

在eclipse中输入时是有智能提示的,不需要记忆,这些tld文件在jar的META-INF里

tld文件指的是Tag Library Description,此文件是对所有标记以及处理类的描述文件

核心标签库主要有如下标签:

标签	描述
c:out	用于在JSP中显示数据，就像<%= ... >
c:set	用于保存数据
c:remove	用于删除数据
c:catch	用来处理产生错误的异常状况，并且将错误信息储存起来
c:if	与我们在一般程序中用的if一样
c:choose	本身只当做<c:when>和<c:otherwise>的父标签
c:when	<c:choose>的子标签，用来判断条件是否成立
c:otherwise	<c:choose>的子标签，接在<c:when>标签后，当<c:when>标签判断为false时被执行
c:import	检索一个绝对或相对 URL，然后将其内容暴露给页面
c:forEach	基础迭代标签，接受多种集合类型
c:forTokens	根据指定的分隔符来分隔内容并迭代输出
c:param	用来给包含或重定向的页面传递参数
c:redirect	重定向至一个新的URL.
c:url	使用可选的查询参数来创造一个URL

out

<c:out>标签用来显示一个表达式的结果，与<%= %>作用相似，它们的区别就是<c:out>标签可以直接通过"."操作符来访问属性。

举例来说，如果想要访问customer.address.street，只需要这样写：<c:out value="customer.address.street">。

<c:out value="student.name"/>

set

<c:set>标签用于设置变量值和对象属性。

<c:set>标签就是jsp:setProperty行为标签的孪生兄弟。

这个标签之所以很有用呢，是因为它会计算表达式的值，然后使用计算结果来设置 JavaBean 对象或 java.util.Map 对象的值。

<c:set>标签有如下属性：

属性	描述	是否必要	默认值
value	要存储的值	否	主体的内容
target	要修改的属性所属的对象	否	无
property	要修改的属性	否	无
var	存储信息的变量	否	无
scope	var属性的作用域	否	Page

if

<c:if>标签判断表达式的值，如果表达式的值为 true 则执行其主体内容。

<c:if>标签有如下属性：

属性	描述	是否必要	默认值
test	条件	是	无
var	用于存储条件结果的变量	否	无
scope	var属性的作用域	否	page

<c:set var="salary"  value="${2000*2}"/>
<c:if test="${salary > 2000}">
   <p>我的工资为: <c:out value="${salary}"/><p>
</c:if>

forEach

这些标签封装了Java中的for，while，do-while循环。

相比而言，<c:forEach>标签是更加通用的标签，因为它迭代一个集合中的对象。

<c:forEach>标签有如下属性：

属性	描述	是否必要	默认值
items	要被循环的信息	否	无
begin	开始的元素（0=第一个元素，1=第二个元素）	否	0
end	最后一个元素（0=第一个元素，1=第二个元素）	否	Last element
step	每一次迭代的步长	否	1
var	代表当前条目的变量名称	否	无
varStatus	代表循环状态的变量名称	否	无

<c:forEach var="i" begin="1" end="5">
   Item <c:out value="${i}"/><p>
</c:forEach>

下面的例子中,使用了varStatus属性,此属性是LoopTagStatus类型的对象,通过此对象可以得到一些有用的信息,比如当前循环的索引,第一个元素的索引,最后一个元素的索引等.

<%
 List<Student> students = new ArrayList();
 Student s1 = new Student();
 s1.setId(1);
 s1.setName("a");
 students.add(s1);

 Student s2 = new Student();
 s2.setId(2);
 s2.setName("b");
 students.add(s2);

 Student s3 = new Student();
 s3.setId(3);
 s3.setName("c");
 students.add(s3);
 pageContext.setAttribute("students", students);
%>

<c:forEach items="${students }" var="s" varStatus="status">
 <c:if test="${status.index%2==0 }">
  <h1>${s.name }</h1>
 </c:if>
</c:forEach>

格式化标签库

JSTL格式化标签用来格式化并输出文本、日期、时间、数字。引用格式化标签库的语法如下

<%@ taglib prefix="fmt" 
           uri="http://java.sun.com/jsp/jstl/fmt" %>

标签	描述
fmt:formatNumber	使用指定的格式或精度格式化数字
fmt:parseNumber	解析一个代表着数字，货币或百分比的字符串
fmt:formatDate	使用指定的风格或模式格式化日期和时间
fmt:parseDate	解析一个代表着日期或时间的字符串
fmt:bundle	绑定资源
fmt:setLocale	指定地区
fmt:setBundle	绑定资源
fmt:timeZone	指定时区
fmt:setTimeZone	指定时区
fmt:message	显示资源配置文件信息
fmt:requestEncoding	设置request的字符编码

formatNumber

formatNumber标签用户格式化数字,常见用法如下:

<fmt:formatNumber value="1000.88" type="currency" />

formatDate

此标签用于格式化日期数据,常见的用法如下:

<fmt:formatDate value="<%= new Date() %>" pattern ="yyyy-MM-dd"/>

函数标签库

JSTL包含一系列标准函数，大部分是通用的字符串处理函数。引用JSTL函数库的语法如下：

<%@ taglib prefix="fn" 
           uri="http://java.sun.com/jsp/jstl/functions" %>

函数标签库有如下一些:

函数	描述
fn:contains()	测试输入的字符串是否包含指定的子串
fn:containsIgnoreCase()	测试输入的字符串是否包含指定的子串，大小写不敏感
fn:endsWith()	测试输入的字符串是否以指定的后缀结尾
fn:escapeXml()	跳过可以作为XML标记的字符
fn:indexOf()	返回指定字符串在输入字符串中出现的位置
fn:join()	将数组中的元素合成一个字符串然后输出
fn:length()	返回字符串长度
fn:replace()	将输入字符串中指定的位置替换为指定的字符串然后返回
fn:split()	将字符串用指定的分隔符分隔然后组成一个子字符串数组并返回
fn:startsWith()	测试输入字符串是否以指定的前缀开始
fn:substring()	返回字符串的子集
fn:substringAfter()	返回字符串在指定子串之后的子集
fn:substringBefore()	返回字符串在指定子串之前的子集
fn:toLowerCase()	将字符串中的字符转为小写
fn:toUpperCase()	将字符串中的字符转为大写
fn:trim()	移除首尾的空白符

join

fn:join()函数将一个数组中的所有元素使用指定的分隔符来连接成一个字符串。

<c:set var="string1" value="a b c"/>
<c:set var="string2" value="${fn:split(string1, ' ')}" />
<c:set var="string3" value="${fn:join(string2, '-')}" />

<p>字符串为 : ${string3}</p>