EL和JSTL核心技术
EL表达式(熟悉)---------------------------
基本概念:
EL(Expression Language)表达式提供了在JSP中简化表达式的方法,可以方便地访问各种数据并输出
主要功能:
依次访问pageContext、request、session和application作用域对象存储的数据
获取请求参数值
访问Bean对象的属性
访问集合中的数据
输出简单的运算结果
访问内置对象的数据:
访问方式:
<%=request.getAttribute("varName")%>
用EL实现: ${ varName }
<%-- 单纯不在单纯之间的空格是不算的,所以可以${ varName },以及${varName} --%>
执行流程:
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现从内置对象中获取数据并打印</title>
</head>
<body>
<%
/*pageContext.setAttribute("name1", "pageContext对象中的属性值:zhangfei");
request.setAttribute("name2", "request对象中的属性值:guanyu");
session.setAttribute("name3", "session对象中的属性值:liubei");
application.setAttribute("name4", "session对象中的属性值:zhaoyun");*/
//pageContext.setAttribute("name", "pageContext对象中的属性值:zhangfei");
//request.setAttribute("name", "request对象中的属性值:guanyu");
//session.setAttribute("name", "session对象中的属性值:liubei");
application.setAttribute("name", "session对象中的属性值:zhaoyun");
%>
<%-- 使用JSP中原始方式获取数据和打印 --%>
<%--<%= "name1的数值为:" + pageContext.getAttribute("name1") %><br/> <%– zhangfei
–%>
<%= "name2的数值为:" + request.getAttribute("name2") %><br/> <%– guanyu –%>
<%= "name3的数值为:" + session.getAttribute("name3") %><br/> <%– liubei –%>
<%= "name4的数值为:" + application.getAttribute("name4") %><br/> <%– zhaoyun
–%>--%>
<%-- 使用EL表达式实现获取数据和打印 --%>
<%--<h1>name1的数值为:${name1}</h1><br/>
name2的数值为:${name2}<br/>
name3的数值为:${name3}<br/>
name4的数值为:${name4}<br/>--%>
<h1>name的数值为:${name}</h1><br/>
<%-- 结果从范围依次查找,从小到大
即pageContext到application一路找getAttribute方法找过去,找到了,则不找了,即取找到的值,--%>
</body>
</html>
访问请求参数的数据:
在EL之前使用下列方式访问请求参数的数据
request.getParameter(name)
request.getParameterValues(name)
在EL中使用下列方式访问请求参数的数据
param:接收的参数只有一个值
paramValues:接受的参数有多个值
<!-- 获取指定参数的数值 -->
${param.name}
<!-- 获取指定参数中指定下标的数值 -->
${paramValues.hobby[0]}
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现一个简单页面负责向JSP页面传递参数</title>
</head>
<body>
<form action="el_param.jsp" method="post">
姓名:<input type="text" name="name"/><br/>
爱好:<input type="checkbox" name="hobby" value="唱歌"/>唱歌<br/>
<input type="checkbox" name="hobby" value="跳舞"/>跳舞<br/>
<input type="checkbox" name="hobby" value="学习"/>学习<br/>
<input type="submit" value="提交"/><br/>
</form>
</body>
</html>
<%@ page import="java.util.Arrays" %><%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现请求参数数值的获取</title>
</head>
<body>
<%
request.setCharacterEncoding("utf-8");
//注意:jsp变成java与转译的编码格式有关,而这里是设置request的编码格式(post)
%>
<%-- 使用JSP语法中的原始方式获取请求参数值 --%>
<%--<%= "姓名是:" + request.getParameter("name") %><br/>
<%= "爱好是:" + Arrays.toString(request.getParameterValues("hobby")) %><br/>--%>
<%-- 使用EL表达式中的方式获取请求参数值 --%>
姓名是:${param.name}<br/>
爱好是:${Arrays.toString(paramValues.hobby)}<br/>
爱好是:${paramValues.hobby[0]}<br/>
<%-- param相当于找getParamter的对应参数化的值
即param.name ==> request.getParameter("name")--%>
<%-- paramValues相当于找getParamterValues的对应参数化的值
即paramValues.hobby[0] ==> request.getParameterValues("name")[0]--%>
</body>
</html>
访问Bean对象的属性:
访问方式:
<%@ page import="com.lagou.demo01.Person" %><%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现Bean对象中属性的获取和打印</title>
</head>
<body>
<%-- 使用JSP语法规则中的原始方式实现对象的创建和设置以及输出 --%>
<%
Person person = new Person();
person.setName("zhangfei");
person.setAge(30);
pageContext.setAttribute("person", person);
pageContext.setAttribute("var1", "name");
pageContext.setAttribute("var2", "age");
%>
<%--<%= "获取到的姓名为:" + person.getName() %><br/>
<%= "获取到的年龄为:" + person.getAge() %><br/>--%>
<%-- 使用EL表达式实现属性的获取和打印 --%>
<%--获取到的姓名是:${person.name}<br/>
获取到的年龄是:${person.age}<br/>--%>
<%-- 另外一种写法 --%>
<%--${person["name"]}<br/>
${person["age"]}<br/>--%>
<%-- 测试一下动态取值的效果 --%>
获取到的姓名是:${person.name}<br>
${person["age"]}<br/>
<%-- 相当于下面的get方法,但是只会默认调用对应的getxxx方法,且xxx首字母大小写忽略
但是[]形式可以放特殊的符号,如点,而有些需要使用点的会报错,如param,所以最好使用[]
--%>
获取到的年龄是:<%=person.getAge()%><br/>
动态取值的结果为:${person[var1]}
<%-- 相当于person[对应对象.getAttribute("var1")],这里是person["name"]
其中对应对象.getAttribute("var1")也是依次查找范围的值,即pageContext到application的getAttribute方法的值
找到,就取值,然后不找了
--%>
${person.getAge()}<%-- 也可以这样,底层判断是否为方法,是,则调用结果
即就是${30},这样,变成了值放入了,在EL表达式里,{}里面都会变成字符串,即不会当场调用
直接的输出${person},就是自动调用toString方法
--%>
</body>
</html>
主要区别:
当要存取的属性名中包含一些特殊字符,如: . 或 ,等并非字母或数字的符号,就一定要使用 [ ]而不是.的方式
使用[]的方式可以动态取值,具体方式如下:
<% request.setAttribute("prop","age");%>
<!-- 相当于表达式中写一个变量 -->
${ user[prop] }
访问集合中的数据:
<!-- student为ArrayList类型的对象 -->
${student[0].name},取出类,然后取出name
<%@ page import="java.util.LinkedList" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.HashMap" %>
<%@ page import="java.util.Map" %><%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现集合中数据内容的获取和打印</title>
</head>
<body>
<%
// 准备一个List集合并添加数据内容
List<String> list = new LinkedList<>();
list.add("two");
list.add("one");
list.add("three");
// 将整个集合放入指定的内置对象中
pageContext.setAttribute("list", list);
// 准备一个Map集合并添加数据
Map<String, Integer> map = new HashMap<>();
map.put("one", 1);
map.put("two", 2);
map.put("th.ree", 3);
// 将整个集合放入指定的内置对象中
pageContext.setAttribute("map", map);
%>
<%-- 使用EL表达式实现集合中数据内容的获取 --%>
集合中下标为0的元素是:${list[0]}<br/> <%-- two 相当于下面的方式--%>
${list.get(0)}<br>
集合中下标为1的元素是:${list[1]}<br/> <%-- one --%>
集合中下标为2的元素是:${list[2]}<br/> <%-- three --%>
<hr/>
<%-- 使用EL表达式实现Map集合中数据内容的获取 不支持下标 --%>
整个Map集合中的元素有:${map}<br/> <%-- 直接输出所有数据,且是数组的形式--%>
获取带有特殊字符key对应的数值为:${map["th.ree"]}<br/> <%-- 3 相当于map的get方法
集合没有动态的,但类有
--%>
</body>
</html>
常用的内置对象:
上面的作用域用来明确要求取那个范围的值,而不用依次取了,用法如下
常用的运算符:
常用的算术运算符:
常用的关系运算符:
常用的逻辑运算符:
条件运算符:
验证运算符:
< % @ page import = "java.util.List" % >
< % @ page import = "java.util.LinkedList" % >
< % @ page import = "java.util.Arrays" % > < % --
Created by IntelliJ IDEA .
-- % >
< % @ page contentType= "text/html;charset=UTF-8" language= "java" % >
< html>
< head>
< title> 实现常用运算符的使用< / title>
< / head>
< body>
< %
request. setAttribute ( "ia" , 5 ) ;
request. setAttribute ( "ib" , 2 ) ;
request. setAttribute ( "b1" , true ) ;
request. setAttribute ( "b2" , false ) ;
% >
< % -- 实现上述所有操作数的获取和打印 -- % >
ia的数值为:${ ia} < br/ > < % -- 5 -- % >
ib的数值为:${ ib} < br/ > < % -- 2 -- % >
b1的数值为:${ b1} < br/ > < % -- true -- % >
b2的数值为:${ b2} < br/ > < % -- false -- % >
< hr/ >
< % -- 实现算术运算符的使用 -- % >
ia+ ib的结果为:${ ia+ ib} < br/ > < % -- 7 -- % >
ia- ib的结果为:${ ia- ib} < br/ > < % -- 3 -- % >
ia* ib的结果为:${ ia* ib} < br/ > < % -- 10 -- % >
ia/ ib的结果为:${ ia/ ib} < br/ > < % -- 2.5 与java不同,这里会保留小数点,底层操作保留-- % >
ia% ib的结果为:${ ia% ib} < br/ > < % -- 1 -- % >
< hr/ >
< % -- 实现关系运算符的使用 -- % >
ia大于ib的结果为:${ ia > ib} < br/ > < % -- true -- % >
ia大于等于ib的结果为:${ ia >= ib} < br/ > < % -- true -- % >
ia< ib的结果为:${ ia < ib} < br/ > < % -- false 注意:由于< 是一个开始标签的符号,会与其他特殊符号发生响应
所以不能这样写,如
< 和:, :如果是: 那么可以,因为是一个标识,但若是:( 中文冒号) ,则会报错,不是一个标识
这时最好分开,即< 和:,这样就不会当成开始标签的一体了
- % >
ia小于等于ib的结果为:${ ia <= ib} < br/ > < % -- false -- % >
ia等于ib的结果为:${ ia == ib} < br/ > < % -- false -- % >
ia不等于ib的结果为:${ ia != ib} < br/ > < % -- true -- % >
< hr/ >
< % -- 实现逻辑运算符的使用 -- % >
b1并且b2的结果为:${ b1 && b2} < br/ > < % -- false -- % >
b1或者b2的结果为:${ b1 || b2} < br/ > < % -- true -- % >
b1取反的结果为:${ ! b1 } < br/ > < % -- false -- % >
b2取反的结果为:${ ! b2 } < br/ > < % -- true -- % >
< hr/ >
< %
String str1 = null ;
String str2 = "" ;
String str3 = "hello" ;
List < Integer > list1 = new LinkedList < > ( ) ;
List < Integer > list2 = Arrays . asList ( 11 , 22 , 33 , 44 , 55 ) ;
request. setAttribute ( "str1" , str1) ;
request. setAttribute ( "str2" , str2) ;
request. setAttribute ( "str3" , str3) ;
request. setAttribute ( "list1" , list1) ;
request. setAttribute ( "list2" , list2) ;
% >
< % -- 实现条件运算符和验证运算符的使用 -- % >
ia和ib之间的最大值为:${ ia> ib? ia: ib} < br/ >
判断是否为空的结果是:${ empty str1} < br/ > < % -- true -- % >
判断是否为空的结果是:${ empty str2} < br/ > < % -- true -- % >
判断是否为空的结果是:${ empty str3} < br/ > < % -- false -- % >
判断是否为空的结果是:${ empty list1} < br/ > < % -- true -- % >
判断是否为空的结果是:${ empty list2} < br/ > < % -- false
没设置对应对象值,返回空,即null
-- % >
< / body>
< / html>
JSTL标签(熟悉):
基本概念:
JSTL( JSP Standard Tag Library ) 被称为JSP标准标签库
开发人员可以利用这些标签取代JSP页面上的Java代码,从而提高程序的可读性,降低程序的维护难度
使用方式:
下载JSTL的jar包并添加到项目中,下载地址为:https://tomcat.apache.org/download-taglibs.cgi
shift+左键,可以选择多个文件,一个一个点
在JSP页面中使用taglib指定引入jstl标签库,方式为:
<!--
prefix属性用于指定库前缀,每个指定库都有默认值
默认值可以改变,但改变后,对应标签名就用改变的,否则不起作用,即相当于没写
若是两个相同的指定库,那么prefix一样的话,虽然报错,但也会起作用,即不影响
不一样的话,那么可以使用两个不同的标签来操作同样的结果,如
<c:out value="${1}"></c:out>
<b:out value="${1}"></b:out>
输出的都是1
若是两个不同库的话,那么prefix不一样,则互不影响
prefix一样,则会报错,且是运行后报错,不起作用,即影响
-->
<!-- uri属性用于指定库的标识 -->
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
常用核心标签:
输出标签:
<c:out></c:out> 用来将指定内容输出的标签
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现out输出标签的使用</title>
</head>
<body>
<c:out value="Hello World"></c:out>
<c:out value="ss"></c:out>
<%--
//虽然上面是输出value的值,但其实还是底层的操作,进行输出的
就如我们<%符号类似,底层操作,但输出的还是out.write方法输出
--%>
</body>
</html>
设置标签:
<c:set></c:set> 用来设置属性范围值的标签
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现set标签的使用</title>
</head>
<body>
<%-- 表示设置一个名字为name的属性,对应的数值为zhangfei,有效范围为:page --%>
<%-- pageContext.setAttibute("name", "zhangfei") --%>
<c:set var="name" value="zhangfei" scope="page"></c:set>
<%-- 使用out标签打印出来 --%>
<c:out value="${name}"></c:out>
<%-- EL表达式可以写在字符串里面进行解释,而普通的直接值或者变量,在字符串里会变成字符串
只所以这样,是因为${}符号会被识别,然后操作信息,而单纯的字符串不会
所以这就是为什么要有EL表达式的原因了,是为了在字符串里进行操作
--%>
<hr/>
<%-- 设置一个对象的属性值并打印出来 --%>
<jsp:useBean id="person" class="com.lagou.demo01.Person" scope="page"></jsp:useBean>
<c:set property="name" value="guanyu" target="${person}"></c:set>
<c:set property="age" value="35" target="${person}"></c:set>
<%-- target指定向谁设置,若没有,则就是创建变量,无论是什么操作,基本上scope都默认page
若不同范围,则不会操作,且会报错,因为会判断该范围内是否有指定对象存在,不存在则报错
因为无论怎么操作,都是放入对应范围对象里面的,即对应的setAttribute方法里,取值也是对应getAttribute方法
底层如此操作,因为地址是相同的,所以是这里设置了,地址值发生改变
--%>
<%-- 类似于jsp:setProperty ,即<jsp:setProperty name="person" property="name" value="guanyu"/>
其中name变成了target,都是指定对方,实际上就是指定对象,因为直接输出${person}时,返回toString方法
而使用target则得到了该引用,与name得到一样,但双方都不可以使用各自的获得对象的方式
这是jstl的一种方式
其中property使用的是对应setxxx方法,xxx的首字母不忽略大小写
--%>
<c:out value="${person.name}"></c:out>
<c:out value="${person.age}"></c:out>
<%-- EL表达式一般是操作变量,对于类来说底层操作对应变量的get方法
使用[]也是,但需要是字符串,
而对于[]来说,集合的话,单集合,如List,则是数组形式,也可以使用对应方法
双集合,如map,则是字符串形式,也可以使用对应方法
上面的各种形式,方法不限制,只是EL表达式简写了一些操作而已,上面普通的操作不会报错,各有各的简写
之后若[]里不是字符串的话,就是操作范围key,获得对应的值,但集合不可这样操作
则使用范围的操作
或者依次得到
单纯的直接写操作范围key,那么就是对应的值,这是简写形式
由于会识别${},即可以在字符串里操作,且可以除底层操作外,做另外的操作,将他看成一个数值
即可以对他进行操作,如变为数组输出
单纯的符合${}的,实际上是输出的,因为没有赋值,在字符串里一般赋值给别人
在使用El表达式时,首先要符合El表达式的操作,才可进行简化,否则相当于没写一样
上面El表达式是因为符号的原因才被进行字符串里的操作
所以<%=%>也可以写进字符串里面,都通过符号进行操作,底层操作时,消除两边引号进行赋值
且<%=%>里写El表达式时,会报错
EL表达式里写<%=%>,也会报错,不可嵌套,因为他们互不识别对方
其中<%=%>是可以操作直接定义的变量的,因为底层直接消除引号写入
而El表达式不可,因为,底层他并没有获得直接变量的传参,即没有定义变量的值
只有写入的参数总值
在jstl里无论什么操作在底层都是_jspx_meth_c_005fforEach_005f1(_jspx_page_context)
所以的内容都传入了,所以中间的操作都是由这个方法和参数决定的
可以理解为EL表达式就是直接获得其他存放好的东西的简化,如set存放,类存放,集合存放
--%>
</body>
</html>
删除标签:
<c:remove></c:remove> 用来删除指定数据的标签
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现remove标签的使用</title>
</head>
<body>
<%-- 设置一个属性值并打印 --%>
<c:set var="name" value="liubei" scope="page"></c:set>
<c:out value="${name}"></c:out>
<hr/>
<%-- 删除这个属性值后再次打印 --%>
<c:remove var="name" scope="page"></c:remove>
<c:out value="${name}" default="无名"></c:out>
<%-- 当没有值时,default的值就是该值,即默认为无名--%>
</body>
</html>
单条件判断标签:
<c:if test ="EL条件表达式">
满足条件执行
</c:if >
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现if标签的使用</title>
</head>
<body>
<%-- 设置一个变量以及对应的数值 --%>
<c:set var="age" value="17" scope="page"></c:set>
<c:out value="${age}"></c:out>
<hr/>
<%-- 判断该年龄是否成年,若成年则提示已经成年了 --%>
<c:if test="${age >= 18}"> <%-- 当然true也可以,只是EL表达式可以在字符串里进行操作--%>
<c:out value="已经成年了!"></c:out>
</c:if>
<c:if test="${age<18}">
<c:out value="没有成年"></c:out>
<c:if test="${age>16}">
<c:out value="不错"></c:out>
</c:if>
</c:if>
</body>
</html>
由于上面的" c:if ",只能嵌套,当嵌套多次的话,没有层次感,所以就有了多条件判断的标签
多条件判断标签:
<c:choose >
<c:when test =“EL表达式”>
满足条件执行
</c:when>
…
<c:otherwise>
不满足上述when条件时执行
</c:otherwise>
</c:choose >
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现choose标签的使用</title>
</head>
<body>
<%-- 设置一个变量代表考试的成绩并指定数值 --%>
<c:set var="score" value="59" scope="page"></c:set>
<c:out value="${score}"></c:out>
<hr/>
<%-- 进行多条件判断和处理 --%>
<c:choose>
<c:when test="${score > 60}">
<c:out value="成绩不错,继续加油哦!"></c:out>
</c:when>
<c:when test="${score == 60}">
<c:out value="60分万岁,多一份浪费!"></c:out>
</c:when>
<c:otherwise>
<c:out value="革命尚未成功,同志仍需努力!"></c:out>
</c:otherwise>
</c:choose>
<%-- 从上到下,当有一个when成立,则后面的都不执行,即跳出
且choose里面只能包含when和otherwise标签,其他的无论是标签还是直接值都不可以
否则报错,但不管他们里面的标签和值
当when都没有成立时,就执行otherwise标签的内容,且otherwise标签只能有一个,否则报错
当然,这两个标签里也可以嵌套多条件标签等等,因为这个内容由你操作
--%>
</body>
</html>
循环标签:
<c:forEach var="循环变量" items="集合">
…
</c:forEach>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现循环标签的使用</title>
</head>
<body>
<%
// 准备一个数组并初始化
String[] sArr = {"11", "22", "33", "44", "55"};
pageContext.setAttribute("sArr", sArr);
%>
<%-- 使用循环标签遍历数组中的所有元素 --%>
<c:forEach var="ts" items="${sArr}">
<c:out value="${ts}"></c:out>
</c:forEach>
<hr/>
<%-- 跳跃性遍历 间隔为2 也就是跳过一个遍历一个 --%>
<c:forEach var="ts" items="${sArr}" step="2">
<c:out value="${ts}"></c:out>
</c:forEach>
<hr/>
<%-- 指定起始和结尾位置 从下标1开始到3结束,包含1和3--%>
<c:forEach var="ts" items="${sArr}" begin="1" end="3">
<c:out value="${ts}"></c:out>
</c:forEach>
<%--
其中var得到的是数组的值,所以可以直接" ${值} "输出
而begin则是开始的位置,end结束的位置,开始和结束都包括,他们代表着下标
step则是下标加多少的意思,如下标为1,那么下次直接为3,若加的下标超过总下标,那么跳出循环,默认加1
开始不加,当循环一次再加
--%>
</body>
</html>
常用函数标签:
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现常用函数标签的使用</title>
</head>
<body>
<%
pageContext.setAttribute("var", "Hello World!");
%>
原始字符串为:${var}<br/> <%-- HelloWorld --%>
判断该字符串是否包含指定字符串的结果为:${fn:contains(var, "Hello")}<br/> <%-- true --%>
将字符串中所有字符转换为大写的结果为:${fn:toUpperCase(var)}<br/> <%-- HELLO WORLD!--%>
将字符串中所有字符转换为小写的结果为:${fn:toLowerCase(var)}<br/> <%-- hello world!--%>
</body>
</html>
常用格式化标签:
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page import="java.util.Date" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现格式标签的使用</title>
</head>
<body>
<%
// 获取当前系统时间
Date date = new Date();
pageContext.setAttribute("date", date);
%>
当前系统时间为:${date}
<hr/>
<fmt:formatDate value="${date}" pattern="yyyy-MM-dd HH:mm:ss"></fmt:formatDate>
<%-- 这里是先得值,过滤后,在得值,输出的是最后的值,即value变化两次--%>
</body>
</html>
自定义标签:
如果上面几个标签不能满足需求,程序员也可以自定义标签,步骤如下:
编写标签类继承SimpleTagSupport类或TagSupport类并重写doTag方法或doStartTag方法
package com. lagou. demo01 ;
import javax. servlet. jsp. JspException ;
import javax. servlet. jsp. JspWriter ;
import javax. servlet. jsp. tagext. SimpleTagSupport ;
import java. io. IOException ;
public class HelloTag extends SimpleTagSupport {
private String name;
public String getName ( ) {
return name;
}
public void setName ( String name) {
this . name = name;
}
@Override
public void doTag ( ) throws JspException , IOException {
JspWriter out = this . getJspContext ( ) . getOut ( ) ;
out. write ( "自定义标签哦!" + name) ;
out. close ( ) ;
}
}
定义标签库文件(tld标签库文件)并配置标签说明文件到到WEB-INF下:
<?xml version="1.0" encoding="UTF-8"?>
< taglib xmlns = " http://java.sun.com/xml/ns/javaee"
xmlns: xsi= " http://www.w3.org/2001/XMLSchema-instance"
xsi: schemaLocation= " http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-
jsptaglibrary_2_1.xsd"
version = " 2.1" >
< tlib-version> 1.0</ tlib-version>
< short-name> my</ short-name>
< uri> http://lagou.com</ uri>
< tag>
< name> hello</ name>
< tag-class> com.lagou.demo01.HelloTag</ tag-class>
< body-content> empty</ body-content>
< attribute>
< name> name</ name>
< required> true</ required>
</ attribute>
</ tag>
</ taglib>
<%@ taglib prefix="my" uri="http://lagou.com" %>
<%--
Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>实现自定义标签的使用</title>
</head>
<body>
<my:hello name="zhangfei"/> <%-- 调用xml中指定类的指定方法--%>
</body>
</html>
在JSP中添加taglib指令引入标签库使用:
<%@ taglib prefix="hello" uri="http://lagou.com" %>
这样以后就可以自定义标签来操作了