1 概念
jsp：java server page java服务器端页面
jsp是动态资源：必须通过web应用服务器解析为静态资源才能响应给客户端
jsp：13种web技术规范之一
动态拼凑页面
深入理解
jsp是动态资源
每个jsp都要被浏览器解析为一个servlt 通过servlet的输出流拼凑和jsp相同效果的静态页面
jsp=html+css+js+jsp标签+java片段
2 原理
每个jsp都要被tomcat解析为一个servlet:jsp的所有内容在servlet中都有对应的代码
servlet要通过response的输出流来拼凑一个和jsp相同效果的页面
案例代码
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%><!-- jsp标签 -->
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP01原理</title>
<style type="text/css">
/*css代码*/
span{
color:red;
font-size:20px;
}
</style>
</head>
<body>
<span>span标签</span><br/><!-- html代码 -->
<script type="text/javascript">
alert("js代码");//js代码
</script>
<!-- java片段1 -->
<%
String message1="java片段1";
%>
<!-- java片段2 -->
<%!
String message2="java片段2";
public String getMessage3(){
return "java片段2333";
}
%>
message1=
<!-- java片段3 -->
<%=message1%><br/> <!-- out.print(message1); -->
message2=
<%=message2%><br/>
message3=
<%=getMessage3()%><br/>
<%--jsp注释 <%=message1%> --%>
<!-- html注释<%=message1%> -->
</body>
</html>
效果
获取此jsp对应的servlet
tomcat发布时会显示此jsp及其servlet的位置：
-Dcatalina.base=C:\Users\Administrator\Desktop\java37workspace\.metadata\.plugins\org.eclipse.wst.server.core\tmp0
C:\Users\Administrator\Desktop\java37workspace\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\work\Catalina\localhost\java37_ee_07_jsp\org\apache\jsp\day01
jsp中java片段的对应关系
- java片段 <%java代码 %> 对应的servlet的service方法体
- java片段<%=数据%> 对应的是servlet的输出流的print方法
- java片段 <%!java代码%> 对应的是servlet的成员
注意：
jsp被解析为servlet
servlet是单例：一个类只有一个对象
单例类中尽量避免定义成员：：线程安全问题
jsp中<%! %>尽量避免使用
总结:
<!--java片段的使用-->
<%System.out.print("一般用于定义局部变量！"); %>
<%="用于在页面打印变量的值"%><br/>
3 jsp指令标签
page指令标签
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%--
JSP的重点
1：原理：jsp要被tomcat解析为servlet 通过servlet的response的响应输出流拼凑一个和jsp相同效果的页面
2：jsp指令标签：给整个jsp页面设置属性
3：jsp动作标签：jsp页面的一些动作：请求转发+请求包含+域属性的增删改查
4：jsp九大内置对象：jsp中已经创建好的 在servlet中常用的9个对象
5：el表达式：替代<%= %> 往页面输出变量的值
6：el的十一大内置对象：el表达式中已经定义好的11个变量
7：jstl表达式：el表达式的扩展
--%>
<%--jsp指令标签：
jsp指令标签的格式： <%@ xxx %>
page指令标签：给当前jsp页面设置属性
--%>
<%@page autoFlush="true" %> <!-- 是否自动刷新response的输出流 -->
<%@page buffer="8kb" %><!-- response输出流的缓冲区大小-->
<%@page contentType="text/html; charset=UTF-8" %><!--
完全等价于：response.setContentType("text/html;charset=utf-8");
1 设置response的字符输出流编码集为utf-8
2 通过设置响应头context-type 来告诉浏览器 通过utf-8解码
-->
<%@page pageEncoding="UTF-8" %><!--
完全等价于：response.setCharacterEncoding("utf-8");
设置response的字符输出流编码集为utf-8
-->
<%-- <%@page extends="java.lang.Object"%>--%><!-- jsp解析成的servlet要继承的父类 -->
<%@page info="作者：苗天宝" %><!--servlet的作者/日期/版本信息 -->
<%@page isELIgnored="false" %><!-- 是否屏蔽el表达式 -->
<%@page isErrorPage="false" %><!-- 当前jsp是否为错误页面 -->
<%@page isThreadSafe="true" %><!-- 是否线程安全 -->
<%@page language="java" %><!--片段使用的语言 -->
<%@page session="true" %><!--是否可用session -->
<%@page trimDirectiveWhitespaces="false" %><!-- 是否去除两边的空格-->
<%@page errorPage="error.jsp" %><!-- 错误页面:当前页面出错 要跳转的目的页面-->
1/0=<%=1%><br/>
<%int age=11;String name="韩梅梅"; %>
<%@page import="java.util.Date"%><!--引入其他包中的类 -->
date=<%=new Date() %><br/>
<%-- jsp注释 --%>
<%--
jsp要被tomcat解析为servlet 通过servlet的response的响应输出流拼凑一个和jsp相同效果的页面
jsp=html+css+js+java片段+jsp标签
--%>
<%int n=1; %><%--设置service的方法体 --%>
<%! int m=1; %><%--设置servlet的成员 --%>
<%=n%><%--通过response的输出流 往页面打印变量的值 --%>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@page isErrorPage="true" %> <!-- 当前页面是错误页面 -->
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>错误页面</title>
</head>
<body>
<h1>看到我 说明你你错了</h1>
${exception.getMessage()}<br/>
</body>
</html>
include指令标签
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>jsp指令标签2：include</h1>
<!-- java片段：：等价于service方法体 -->
<%
int age=11;
String name="韩梅梅";
%>
<%@ include file="a.jsp" %> <!-- 静态包含 -->
<!-- 注意：a.jsp生成对应的servlet 03.jsp和a.jsp的代码先合并 再被tomcat解析为servlet-->
</body>
</html>
name=<%=name%><br/>
age=<%=age%><br/>
taglib指令标签
<%@ taglib prefix="" uri="" %> <!--引入第三方标签库： uri指定标签的路径 prefix指定标签的前缀 -->
4 jsp的动作标签
可以在页面要实现一些指定功能的标签
forward动作标签
<%--
jsp动作标签：在jsp页面实现指定功能的标签
jsp动作标签格式： <jsp:xxx />
--%>
<h1>04.jsp</h1>
<jsp:forward page="01.jsp"/>
<%-- 完全等价于：
<%
request.getRequestDispatcher("01.jsp").forward(request, response);
%>
--%>
include动作标签
<h1>04.jsp</h1>
<%
String pageName="01.jsp";
%>
<jsp:include page="<%=pageName%>">
<jsp:param value="aa_value" name="aa"/>
</jsp:include> <!-- 动态包含：：：请求包含 -->
<%-- 完全等价于：
<%
request.getRequestDispatcher("01.jsp?aa=aa_value").include(request, response);
%>
--%>
静态包含和动态包含的区别
<%--
静态包含和动态包含的区别：
相同之处：都是把两个jsp合并为一个jsp页面
不同之处：
1 标签不同
动态包含：是jsp动作标签： <jsp:include page="xxx" />
静态包含：是jsp指令标签： <%@include file="xxx" />
2 合并时机不同
动态包含： 1.jsp动态包含2.jsp 两个jsp都会被tomcat解析生成两个servlet
两个servlet的输出流合并 共同响应一个静态页面
静态包含：1.jsp静态包含2.jsp 先把2.jsp的代码合并到1.jsp中 tomcat只解析1.jsp
生成一个servlet 只有这一个servlet的输出流来响应一个静态页面 3 被包含的页面名是否可以是变量
动态包含：被包含的页面名可以是变量
<%
String pageName="01.jsp";
%>
<jsp:include page="<%=pageName%>"/>
静态包含：被包含的页面不能是变量
4 是否可以传递参数
静态包含不能传递参数
动态包含可以传递参数(请求参数)：
<jsp:include page="01.jsp">
<jsp:param value="aa_value" name="aa"/>
</jsp:include>
--%>
useBean动作标签
<jsp:useBean id="stu1" class="com.zhiyou100.entity.Student" scope="request"/>
<!-- 给request域中添加一个属性名为stu1 值为一个无参数构造方法创建的Student对象 -->
<%
// 完全等价于：
request.setAttribute("stu1", new Student());
%>
<jsp:setProperty property="sage" value="11" name="stu1" />
<!--给域属性stu1对应的对象的sage属性赋值为11 -->
<%
//完全等价于
Student s2=(Student)request.getAttribute("stu1");
s2.setSage(12);
%>
<%
Student s1=(Student)request.getAttribute("stu1");
%>
stu1=<%=s1%><br/>
sage=<jsp:getProperty property="sage" name="stu1"/><br/>
<!-- 获取域属性stu1的属性sage的值 并通过输出流打印 -->
<%
//完全等价于
Student s3=(Student)request.getAttribute("stu1");
response.getWriter().print(s3.getSage());
%>
5 jsp的九大内置对象
jsp要被解析为servlet：
jsp的九大内置对象：是jsp对应的servlet中定义好的九个常用对象
<%--
九大内置对象：jsp对应的servlet自动创建好的九个对象：方便jsp的直接使用
1：request：HttpServletRequest类型 ：封装与请求相关的所有内容
作用： a: 获取请求参数
b: 获取请求头
c: 作为域对象 实现请求链之间数据共享
d: 请求转发 请求包含
e: 其他功能
2： response：HttpServletResponse类型：封装与响应相关的所有内容
作用：a:设置响应头
b:设置响应体
c:重定向
d:其他功能
3：page：HttpServlet类型：当前servlet对象
4：config：ServletConfig类型： 配置信息：servlet-name url-pattern
5：out： PrintWriter类型： response的打印输出流
6：application：ServletContext类型：上下文对象
7：session：HttpSession： 会话对象
8：pageContext： PageContext：
9：exception： Throwable类型：错误页面捕获到的异常对象
注意：只有当<%@page isErrorPage="true" %>才有exception对象
--%>
<%
out.print(" 项目路径："+request.getContextPath()+"<br/>");
%>
项目路径：<%=request.getContextPath()%><br/>
servlet-name:<%=config.getServletName() %><br/>
page=<%=page%><br/>
this=<%=this%><br/>
<%
application.setAttribute("aa", "aa_application_value");
%>
aa=<%=application.getAttribute("aa") %><br/>
sessionid=<%=session.getId() %><br/>
pageContext对象
<%--
pageContext作用：
1 作为域对象：在当前页面和当前页面引入的标签库中实现数据共享
2 获取其他八个内置对象
3 全域查找
4 代理其他域
--%>
<!-- 1 作为域对象：在当前页面中实现数据共享:
Object getAttribute(String);
void setAttribute(String,Object);
void removeAttribute(String);
-->
<%
pageContext.setAttribute("aa", "aa_pageConetext_value");
%>
aa=<%=pageContext.getAttribute("aa") %><br/>
<!-- 2 获取其他八个内置对象:
xxx getXxxx();
-->
<%=pageContext.getRequest()==request%><br/>
<%=pageContext.getResponse()==response%><br/>
<%=pageContext.getSession()==session%><br/>
<%=pageContext.getServletConfig()==config%><br/>
<%=pageContext.getServletContext()==application%><br/>
<%=pageContext.getOut()==out%><br/>
<%--<%=pageContext.getException()==exception %><br/>--%>
<%=pageContext.getPage()==page%><br/>
<!-- 3 全域查找：
Object findAttribute(String);
-->
<%
//pageContext.setAttribute("bb", "bb_pageContext_value");
//request.setAttribute("bb", "bb_request_value");
//session.setAttribute("bb", "bb_session_value");
application.setAttribute("bb", "bb_application_value");
%>
pageContext.findAttribute("bb")=<%=pageContext.findAttribute("bb") %><br/>
<!-- 4 代理其他域
void setAttribyte(String,Object,int)
Object getAttribyte(String,int)
-->
<%
pageContext.setAttribute("cc", "cc_request", PageContext.REQUEST_SCOPE);
pageContext.setAttribute("dd", "dd_session", PageContext.SESSION_SCOPE);
pageContext.setAttribute("ee", "ee_application", PageContext.APPLICATION_SCOPE);
%>
cc=<%=request.getAttribute("cc")%><br/>
dd=<%=session.getAttribute("dd") %><br/>
ee=<%=application.getAttribute("ee") %><br/>
cc=<%=pageContext.getAttribute("cc", PageContext.REQUEST_SCOPE)%><br/>
dd=<%=pageContext.getAttribute("dd", PageContext.SESSION_SCOPE)%><br/>
ee=<%=pageContext.getAttribute("ee", PageContext.APPLICATION_SCOPE)%><br/>
6 EL表达式
EL（Expression Language） 是为了使JSP写起来更加简单
el格式： ${}
el作用： 替换<%= %> 在页面显示变量的值
el使用场景
<h1>el表达式的使用场景</h1>
<!--使用场景1： 在js中使用 -->
<script type="text/javascript">
var oh1= document.getElementsByTagName("h1")[0];
oh1.innerText=oh1.innerText+"${1+1}";
</script>
<!--使用场景2： 在html中使用 -->
html不能进行运算：1+1=1+1 <br/>
java片段1实现： 1+1=<%=1+1%><br/>
java片段2实现： 1+1=<% out.print(1+1);%><br/>
el表达式实现：1+1=${1+1}<br/>
<!--使用场景3： 在jsp标签中使用 -->
<jsp:useBean id="stu" class="com.zhiyou100.entity.Student" scope="page"/>
<!-- 在pageContext域对象中添加一个域属性 名为stu 值为Student对象 -->
<jsp:setProperty property="sage" name="stu" value="${20+1}"/>
stu.sage=<%=((Student)pageContext.getAttribute("stu")).getSage()%><br/>
el作用
<h1>el表达式作用</h1>
<!-- 作用1：基本运算 ：
运算符：+、-、*、/(div)、%(mod)
比较符： > (gt)、 >=(ge)、 <(lt)、 <=(le)、 ==(eq)、 !=(ne)
空判断：empty 、 not empty
三元符： boolean?a:b
-->
5/2=${5/2},5/2=${5 div 2}<br/>
5%2=${5%2},5/2=${5 mod 2}<br/>
<%request.setAttribute("a", 3);%>
1>2 = ${1>2},1>2 =${1 gt 2}<br/>
1>=2 = ${1>=2},1>=2 =${1 ge 2}<br/>
1==2 = ${1==2} , 1==2 = ${1 eq 2}<br/>
1!=2 = ${1!=2} , 1!=2 = ${1 ne 2}<br/>
0 是否为空=${empty 0}<br/>
0 是不是不为空=${not empty 0}<br/>
1 是否为空=${empty 1}<br/>
"" 是否为空=${empty ""}<br/>
' ' 是否为空=${empty ' '}<br/>
'a' 是否为空=${empty 'a'}<br/>
null 是否为空=${empty null}<br/>
1>2?"好":"坏" = ${1>2?"好":"坏"}<br/>
<!-- 作用2：操作域对象中的属性-->
<%
pageContext.setAttribute("bb", "bb_pageContext_value");
request.setAttribute("bb", "bb_request_value");
session.setAttribute("bb", "bb_session_value");
application.setAttribute("bb", "bb_application_value");
%>
<!-- 全域查找 -->
bb=${bb}<br/><!-- bb=bb_pageContext_value -->
bb=<%=pageContext.findAttribute("bb")%>
<!-- 获取指定域对象的属性 -->
pageScope.bb=${pageScope.bb}<!-- 获取pageContext域中的bb属性 --><br/>
requestScope.bb=${requestScope.bb}<!-- 获取request域中的bb属性 --><br/>
sessionScope.bb=${sessionScope.bb}<!-- 获取session域中的bb属性 --><br/>
applicationScope.bb=${applicationScope.bb}<!-- 获取application域中的bb属性 --><br/>
<!-- 作用3：对象导航：OGNL -->
<!--
对象导航图语言（Object Graph Navigation Language），简称OGNL，是应用于Java中的一个开源的表达式语言（Expression Language），
作用是对数据进行访问，它拥有类型转换、访问对象方法、操作集合对象等功能。
解析：如果一个对象a拥有getXxx方法 就可以在el中通过a.xxx来调用此方法
-->
<jsp:useBean id="stu2" class="com.zhiyou100.entity.Student" scope="page"/>
<jsp:setProperty property="sage" name="stu2" value="12"/>
<jsp:setProperty property="sid" name="stu2" value="10012"/>
<jsp:setProperty property="sname" name="stu2" value="韩梅梅"/>
<jsp:setProperty property="score" name="stu2" value="89.9"/>
stu2=${pageScope.stu2}<br/>
stu2.sage=${pageScope.stu2.sage}<br/>
stu2.sname=${pageScope.stu2.sname}<br/>
stu2.sex=${pageScope.stu2.sex}<br/><!-- 只要对象拥有方法getXxx即可 -->
stu2.sage=<%=((Student)pageContext.getAttribute("stu2")).getSage()%><br/>
<!-- 作用4：操作集合/数组 -->
<%
List<Student> list=new ArrayList<>();
list.add(new Student(10011,"韩梅梅",12,14f));
list.add(new Student(10012,"韩庚",22,24f));
list.add(new Student(10013,"韩信",32,34f));
list.add(new Student(10014,"韩非子",42,44f));
request.setAttribute("list", list);
%>
list[0]=${requestScope.list[0]}<br/>
list[1].sname=${requestScope.list[1].sname}<br/>
list[2].sage=${requestScope.list[2].sage}<br/>
list[3].score+3=${requestScope.list[3].score+3}<br/>
<%int a;int b=3; %>
<%--a=<%=a%><br/> --%>
b=${b}<br/><!-- el表达式获取的变量必须是域属性 el获取的变量如果不存在 不会报错 -->
el的十一大内置对象
<%
添加域属性
pageContext.setAttribute("b", "b_pageContext_value");
request.setAttribute("b", "b_request_value");
session.setAttribute("b", "b_session_value");
application.setAttribute("b", "b_application_value");
添加cookie
response.addCookie(new Cookie("c1","c1_value"));
response.addCookie(new Cookie("c2","c2_value"));
%>
<!-- el的十一大内置对象：在el表达式中 可以直接使用的11个对象 -->
<!-- 1-4:域对象
pageScope:pageContext域对象
requestScope:request域对象
sessionScope:session域对象
applicationScope:application域对象
-->
pageScope.b=${pageScope.b}
requestScope.b=${requestScope.b}
sessionScope.b=${sessionScope.b}
applicationScope.b=${applicationScope.b}
<!-- 注意：request和requestScope的区别 -->
requestScope是request的一部分
<!-- 5-6:获取请求参数
param:获取单值请求参数
paramValues:获取多值请求参数
http://localhost:8080/java-web-ts/a.jsp?name=jjy&enjoy=lq&enjoy=zq&enjoy=pq
-->
请求参数：name=${param.name}
请求参数：enjoy=${paramValues.enjoy[0]}、${paramValues.enjoy[1]}、${paramValues.enjoy[2]}
<!-- 7-8:获取请求头
header:获取单值请求头
headerValues:获取多值请求头
-->
请求头：Accept=${header.Accept}
请求头：Host=${header.Host}
请求头：User-Agent=${header['User-Agent']}
<!-- 9:获取cookie -->
cookie c1:${cookie.c1.name}=${cookie.c1.value}
<!-- 10: 获取项目的初始化参数：
initParameter
在web.xml中配置的项目的初始化参数
<context-param>
<param-name>encodingName</param-name>
<param-value>UTF-8</param-value>
</context-param>
-->
<%
String charset=request.getServletContext().getInitParameter("encodingName");
%>
charset=<%=charset%>
charset=${charset}
charset=${initParam.encodingName}
<!-- 11: pageContext:pageContext对象 -->
项目路径:${pageContext.request.contextPath}
7 jstl表达式
概念
JSTL（Java server pages standarded tag library，即JSP标准标签库）
它主要提供给Java Web开发人员一个标准通用的标签库，
开发人员可以利用这些标签取代JSP页面上的Java代码，从而提高程序的可读性，降低程序的维护难度。
JSP=html+css+js+java片段+jsp标签
html代码中嵌套java片段：：可读性差：：学习成本高：：维护难度高
jstl的作用：通过定义的标签 来替代jsp中的java片段：
对el表达式的扩展
使用
JSTL使用
1：导入jar包：jstl-1.2.jar+standard-1.1.2.jar
把jar放入WEB-INF/lib下 并bulid path
2：通过jsp的taglib指令标签 引入此标签库
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="f" uri="http://java.sun.com/jsp/jstl/functions"%>
prefix:指定前缀
uri:指定标签库的路径
3: 在/WEB-INF下引入依赖的tld文件
c.tld
fn.tld
分类
jstl标签库分类：
1 core库：核心库：实现流程控制和属性的增删改查 最常用的
2 fmt库：格式化库：实现数据的格式化 不常用
3 functions库：字符串方法库：字符串相关的方法 不太常用
4 sql库：操作数据库：不使用
5 xml库：xml解析：不使用
functions标签库
<!-- functions标签库 字符串方法库 -->
<%
request.setAttribute("str", "abcdefghijklMSBCDDABCabc");
%>
str=${str}
str的字符串长度=${fn:length(str)}
str是否包含abc=${fn:contains(str,"abc")}
str是否以abc开头=${fn:startsWith(str,"abc")}
str是否以abc结尾=${fn:endsWith(str,"abc")}
str替换所有的a为0=${fn:replace(str,"a","0")}
str第一次出现a=${fn:indexOf(str,"a")}
str剪切子串=${fn:substring(str,1,5)}
str切割=${fn:split(str,"a")[0]}
str转化为大写=${fn:toUpperCase(str)}
str转化为小写=${fn:toLowerCase(str)}
fmt标签库
<!-- fmt标签库 实现数据的格式化 -->
<%
request.setAttribute("date", new Date());
%>
date=${date}<br/>
date=<fmt:formatDate pattern="yyyy-MM-dd HH:mm:ss" value="${date}" /><br/>
jsp和servlet的分工
jsp和servlet的分工
jsp:提供表单获取数据+响应数据显示
servlet:接受数据+处理数据(服务数据库)+资源跳转
core标签库
<!-- url标签 实现流程控制和属性的增删改查 -->
<!-- url作用1：设置域属性：(值前面加项目路径) -->
<c:url scope="request" var="path" value="/1.txt"/>
代码：path=${requestScope.path}
结果：path=/forum/1.txt
<!-- url作用2：在路径前面补全项目名称 -->
<a href="<c:url value='/jsp/1.jsp'/>">请求1.jsp</a>
结果：http://localhost:8080/forum/jsp/1.jsp
等价：<a href="${pageContext.request.contextPath}/jsp/1.jsp">请求1.jsp</a>
<!-- set标签：作用：往指定域中添加属性：不指定域 默认是pageContext域 -->
<c:set scope="request" var="a" value="a_1"/>
结果：a=a_1
a=${requestScope.a}：从request域中取出了a
结果：a=a_1
<!--out标签：作用：输出变量的值：default指定默认值：escapeXml是否避免解析数据 -->
a=<c:out value="${requestScope.a}" default="a_0" />
结果：a=a_1 域中有值输出域中的值
1+1=<c:out value="${1+1}" />
结果：1+1=2
b=<c:out value="${requestScope.b}" default="b_0" />
结果：b=b_0 域中无值输出默认的值
<c:set var="cc" value="<script type='text/javascript'>alert;</script>" />
cc=<c:out value="${cc}" escapeXml="true"/>
结果：cc=<script type='text/javascript'>alert;</script>
<!-- remove标签 -->
<c:remove var="a" scope="page"/>：删除所有page域中的a属性
<c:remove var="a"/>：删除所有域中的a属性
<!-- if标签 单分支 -->
<c:set scope="page" var="sex" value="男"/>
<c:if test="${pageScope.sex equal '男'}">
男生
</c:if>
<c:if test="${pageScope.sex notequal '男'}">
不是男生
</c:if><br/>
<!-- choose标签 多分支 -->
<c:set var="score" value="18"/>
<c:choose>
<c:when test="${score lt 60 }">
分数=${score},不及格！<br/>
</c:when>
<c:when test="${score lt 70 }">
分数=${score},及格！<br/>
</c:when>
<c:when test="${score lt 80 }">
分数=${score},良好！<br/>
</c:when>
<c:otherwise>
分数=${score},优秀！<br/>
</c:otherwise>
</c:choose>
结果：分数=18,不及格！
<!-- forEach标签：-->
<!-- forEach作用1：在pageContext中添加一个域属性i;i从1跑到20 每次+2-->
<c:forEach begin="1" end="20" step="2" var="i">
i=${pageScope.i}<br/>
</c:forEach>
<!-- forEach作用2：items指定要遍历的集合：var给遍历的集合中的元素起个名字：varStatus记录遍历状态的对象(index属性获取的是遍历的索引)-->
<c:forEach items="${requestScope.list}" var="stu" varStatus="vs">
<!-- vs记录变量状态的对象：index属性记录变量顺序：从0开始 -->
<%
List<Student> list=new ArrayList<>();
list.add(new Student(10011,"韩梅梅",12,14f));
list.add(new Student(10012,"韩庚",22,24f));
list.add(new Student(10013,"韩信",32,34f));
list.add(new Student(10014,"韩非子",42,44f));
request.setAttribute("list", list);
%>
${vs.index+1}
${stu.sid}
${stu.sname}
${stu.sage}
${stu.score}
</c:forEach>
<!-- forEach：九九乘法表-->
<c:forEach begin="1" end="9" step="1" var="i">
<c:forEach begin="1" end="9" var="j">
<c:choose>
<c:when test="${i>=j}">
${i}*${j}=${i*j}
</c:when>
<c:otherwise>
</c:otherwise>
</c:forEach>
</c:forEach>
<!-- redirect标签:重定向 -->
<%
<c:redirect url="1.jsp"/>
%>
