EL和JSTL核心技术
EL表达式（熟悉）---------------------------
<%=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>
<!-- 获取指定参数的数值 -->
${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>
<%@ 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 > = new LinkedList < > ( ) ;
List < Integer > = 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>
<!--
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: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>
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 ( ) ;
}
}
<?xml version="1.0" encoding="UTF-8"?>
< taglibxmlns = " 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> </ tlib-version> < short-name> </ short-name> < uri> </ uri> < tag> < name> </ name> < tag-class> </ tag-class> < body-content> </ body-content> < attribute> < name> </ name> < required> </ 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>
<%@ taglib prefix="hello" uri="http://lagou.com" %>
本文详细介绍了EL（Expression Language）和JSTL（JSP Standard Tag Library）的核心技术，包括EL的基本概念、主要功能、访问Bean对象属性、集合数据以及常用的内置对象和运算符。同时，展示了JSTL的输出、设置、删除标签以及条件判断和循环标签的使用。通过实例演示了如何在JSP中简化表达式和提高程序可读性，降低了维护难度。
97
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
