JSP——Java Server Pages
2018-09-13 19:26
513 查看
1. 简介
1. Jsp技术：Jsp是一种 html代码+ Java代码 + Jsp页面代码的技术，而且其不用像Servlet哪样需要配置访问路径。2. Jsp执行原理：第一次访问服务器web项目中的jsp页面时，会首先把jsp页面翻译成为一个标准Servlet，也就是 .java 的文件，然后将这个java文件编译生成字节码文件，然后再执行。
3. Jsp中Java代码的编写：
通过 <%! %>来定义成员变量或方法，但是成员变量会因为多线程而出现错误情况，所以不常用该脚本元素定义成员变量。
通过<%= %>来将Java代码中的常量或者变量输出到html页面，不能加分号 ";"
通过<% %>定义局部变量，或者编写代码，但是不能定义方法。
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'test1.jsp' starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<body>
<%--定义局部变量a,b,c --%>
<% int a=10;%>
<% int b=10;%>
<% int c=a+b;%>
<%= "c=" %>
<% out.println(c); %>
<br>
<%--输出3行3列的表格 --%>
<table cellspacing="0" cellpadding="0" border="1">
<% for(int i=1;i<=3;i++){%>
<tr>
<% for(int x=1;x<=3;x++){%>
<td>
<%=i+","+x %>
</td>
<%}%>
</tr>
<%}%>
</table>
<%--构造LinkedList实例对象并添加元素，然后输出 --%>
<% LinkedList<Integer> list=new LinkedList<Integer>();
for(int i=0;i<=10;i++){
list.add(i);
}
%>
<%=list.toString() %></br>
<%--输出当前时间信息 --%>
<% Date now=new Date();%>
<%="当前时间：北京时间" %>
<%=now.toLocaleString() %>
</body>
</html>2. Jsp指令元素
2.1 page指令
1. page指令用于设置Jsp文件属性，形式为<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>，其中可以使用一个属性，也可以使用多个属性，但是只有import属性可以多次出现，具体常用属性如下：language:将当前页面翻译成java语言，不用设置为默认
session:设置是否开启session，即是否能够直接使用session对象，默认为true,<%@ page session="true" %>
import:用于导包，可以出现多次。<%@ page import="java.util.*" %>
extends:当前jsp文件会被翻译成一个java文件，所以可以指定继承的类,要写全限定名。
buffer:设置输出的缓冲区大小，默认8kb，<%@ page buffer="8k"%>
autoFlush:缓冲区满了是否刷新，如果满了不刷新则抛出异常，默认为true，<%@ page autoFlush="true"%>
isErrorPage:当前jsp文件是否为其他页面的errorPage属性的目标页面，默认为false；可以在web.xml文件中配置全局发生的错误对应的处理页面，即请求服务器时发生的对应的错误码，都会跳转至该页面，需要添加配置代码
<error-page> <error-code>404</error-code> <location>/jsp/error.jsp</location> </error-page>
errorPage:当此页面发生错误时，指定一个isErrorPage属性值为true的jsp页面作为跳转页面来反映错误
isELIgnored:是否忽略EL表达式，默认为false
contentType:设置浏览器打开jsp中html页面的编码格式
pageEncoding:设置当前页面的编码格式，用于jsp文件翻译成.java代码时
2.2 include指令
1. 用于页面包含，可以将某些公共页面片段提取出来，用的时候在加入进行组合，指令形式如<%@ include file="" %>，具体常用属性如下file属性:所包含文件的地址，是服务器端地址，属于静态包含（即在翻译成.java代码文件之前，先将所有代码按照引入的位置和顺序进行添加，然后再翻译称为一个完整的.java文件，再编译称为字节码文件）
2.3 taglib指令
3. Jsp内置对象
1. 在 tomcat服务器目录路径+\work\Catalina\localhost\+项目名+\org\apache\jsp\+jsp文件目录下的jsp文件对应的翻译过来的java代码文件，打开这个java代码文件，我们可以发现一系列的jsp内置对象。内置对象可以在java代码块内直接使用，而exception对象只有isErrorPage属性为true的页面内才能使用比如路径为D:\apache-tomcat-8.5.24\work\Catalina\localhost\Servlet\org\apache\jsp\jsp\test1_jsp.java,打开后代码为
package org.apache.jsp.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.*;
public final class test1_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent,
org.apache.jasper.runtime.JspSourceImports {
//删除部分代码，下面的就是jsp中的内置对象
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;
} 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);
}
}
}2. 内置对象用法：
request:表示HttpServletRequest对象
response:表示HttpServletResponse对象
session:表示HttpSession对象
application:表示ServletContext对象，也就是整个web应用
out:表示JspWriter对象，和response.getWriter()一样，都用于向返回客户端的html页面输出数据。但JspWriter与response.getWriter()得到的字符输出流对象肯定不是同一个，JspWriter会将输出的数据先保存在自己的缓冲区中，然后再将缓冲区中的数据发送到response.getWriter()中，再向页面写出，因为只有response.getWriter()才能向页面输出数据。
pageContext:表示PageContext对象，该对象可以获取另外的8个对象，且此对象也是jsp中独有的一个域对象，但其中的数据只能在本页面生效，并且可以向其他的域对象中存取值。方法如下
pageContext.setAttribute(String name,Object value, int scope)：将一个属性值，存储到request、session、application三个域对象内，比如 pageContext.setAttribute("name", "vn", pageContext.APPLICATION_SCOPE)，就是将属性存储在application域内，其他两个域对象范围用 REQUEST_SCOPE，SESSION_SCOPE 表示，对于PAGE_SCOPE就表示pageContext域对象。
pageContext.getAttribute(name, scope)：指定在某个域对象范围内获取属性。比如pageContext.getAttribute("name", pageContext.REQUEST_SCOPE)
pageContext.setAttribute(String name,Object value)：向pageContext域对象内存储属性值。
pageContext.getAttribute(name)：从pageContext域对象内获取属性值。
pageContext.findAttribute(name)：先从pageContext对象自身内部查找属性，然后依次从request、session、application三个域对象中获取属性，找到之后就会返回属性值，不会继续查找。
page:Object（代表当前Servlet对象的Object类型引用）
config:表示ServletConfig对象
exception:表示Throwable对象
JSP中的4个域对象访问范围（由小到大）：
pageContext：仅当前jsp页面范围，通过该域可得到其他所有域中的值，默认从自身存储的数据中开始查找，然后范围有小到大访问其他域
request：请求范围，在请求生效的范围中均可访问其中的值
session：整个会话范围
application：整个web应用范围
4. Jsp常用标签
1. <jsp:forward page="url"></jsp:forward>：转发标签，实现转发功能。page属性指转发到哪个页面上去，转发的路径的写法和Servlet中一样，写服务器绝对路径（不包含包含项目名称）2. <jsp:param value="" name=""/>：转发时传递参数，需要被包括在jsp:forward 标签之内。name 指参数的名称， value代表参数的值
3. <jsp:include page=""></jsp:include>：动态包含（和静态包含结果是一样的，原理是不一样的），page属性指被包含的页面的路径，动态包含会在源码的文件下，对每个jsp都生成了.java和.class的文件。
4. 在Jsp中封装数据所使用的标签：通过这些标签可以实例化一个类的对象，通常可以将请求中携带的参数，通过其属性名也就是name与类的属性名称进行对比，相同名称的将会进行自动注入。假如现在有一个请求被一个jsp页面接受到，请求里包括了两个请求参数，分别是
name="vn"&password="123"，而有一个用于封装数据的标准JavaBean规范的类如下
package servlet.JSP;
/**
* @ClassName:User
* @Description:一个符合JavaBean规范的数据封装工具类，其必须满足三大规范
* 必须有无参构造器
* 实例变量必须是私有的，对外不可见
* 对于每个实例变量都必须有一个public修饰的get与set方法，来实现外界对实例变量的读写
* @author:
* @date:2018年9月11日
*/
public class User {
private String name;
private String password;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}jsp页面可以使用 <jsp:useBean id="" class="" scope="" beanName="" type=""></jsp:useBean> 标签用来自动生成一个指定的类的对象：
class属性指定实例化的类的全限定名
scope属性指定这个对象存储在那个域对象的范围内（域对象范围从小到大依次是page —>request —>session —>application）
id属性可以视为该User对象的引用，通过这个id，又可以使用 <jsp:setProperty property="" name="" param="" value=""/> 标签与<jsp:getProperty property="" name="u"/> 标签来对该对象的属性进行读写，如下
<jsp:useBean id="u" class="servlet.JSP.User" scope="request"></jsp:useBean> <jsp:getProperty property="name" name="u"/> <jsp:setProperty property="name" name="u" param="name" value="uzi"/>
<jsp:getProperty property="" name=""/>：
name 属性的值指向已创建的对象的id，也就是<jsp:useBean>中id属性
property 属性指定的值用来指定获取所对应对象中的属性的值。
<jsp:setProperty property="" name="" param="" value=""/> ：
param属性的值指的是在数据封装类中的对应类的属性的set方法中的参数名
value就是参数的值，通过这个标签就可以设置对象的属性值，另外，value的属性值也可以是<jsp:useBean>标签中id属性指定的值。
param与value属性可以忽略不写，当请求中带有请求参数时，会通过参数的属性名与类的属性名称进行对比，相同名称的将会把请求参数中的值自动注入进入指定对象，param与value属性用于手动设置对象属性值。
property值指定需要注入值的对象的属性，当对象的属性过多时，可以写 * 来表示所有属性的值都需要注入。
name属性值指向已创建的对象的id，也就是<jsp:useBean>中id属性。
5. java内省技术
1. 内省技术的简单使用import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.MethodDescriptor;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.junit.Test;
/**
* @ClassName:TestIntrospector
* @Description:Java内省技术，其底层通过反射技术实现。主要的类为Introspector
* @author:
* @date:2018年9月11日
*/
public class TestIntrospector {
@Test
public void testIntrospector() throws IntrospectionException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
User user=new User();
//测试内省,获取User这个JavaBean类的信息
BeanInfo info=Introspector.getBeanInfo(user.getClass());
//获取这个JavaBean类的所有属性信息
PropertyDescriptor[] pros= info.getPropertyDescriptors();
for(PropertyDescriptor p:pros){
if(!"class".equals(p.getName())){
System.out.println(p.getName());//获取属性名
Method method1=p.getWriteMethod();//获取该属性的写入方法，也就是set方法
method1.invoke(user, "vn");//调用每个属性的set方法
}
}
for(PropertyDescriptor p:pros){
if(!"class".equals(p.getName())){
System.out.println(p.getName());//获取属性名
Method method2=p.getReadMethod();//获取该属性的读取方法，也就是get方法
System.out.println(method2.invoke(user, null));//调用每个属性的读取方法，并输出
}
}
//获取这个JavaBean类的所有方法信息
MethodDescriptor[] meths=info.getMethodDescriptors();
for(MethodDescriptor m:meths){
System.out.println(m.getName());//获取方法名
Method method=m.getMethod();//转换为反射中的Method类
}
}
}2. 通过内省技术在一个Servlet类里实现数据封装：
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class UserServlet
*/
@WebServlet("/UserServlet")
public class UserServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
Map<String, String[]> parameter = request.getParameterMap();
User user=new User();
try {
populate(user,parameter);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException
| IntrospectionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static void populate(Object o,Map<String, String[]> map) throws IntrospectionException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
//获取数据封装类型信息
BeanInfo info=Introspector.getBeanInfo(o.getClass());
//获取类中所有属性的信息
PropertyDescriptor[] pds=info.getPropertyDescriptors();
for(PropertyDescriptor p:pds){
if(!"class".equals(p) && map.containsKey(p.getName())){
Method m=p.getWriteMethod();
m.invoke(o, map.get(p.getName())[0]);
}
}
}3. 使用BeanUtils工具类来封装数据到一个对象中：
public class TestBeanUtils {
@Test
/**
* @Title:testBeanUtils
* @Description:BeanUtils的简单使用,首先需要导入commons-logging和commons-beanutils两个jar包
* @author:
* @date:
* @param:
* @return:void
* @throws InvocationTargetException
* @throws IllegalAccessException
* @throws:
*/
public void testBeanUtils() throws IllegalAccessException, InvocationTargetException{
User user=new User();
//模拟从请求中取得的参数Map
Map<String, String[]> map=new HashMap<String, String[]>(10);
String[] s1={"vn"};
String[] s2={"12345"};
map.put("name", s1);
map.put("password", s2);
//使用工具类封装数据,将数据封装到user对象中
BeanUtils.populate(user, map);
//查看是否封装成功
System.out.println(user.getName());
System.out.println(user.getPassword());
}
}4. 编写代码，实现将字符串转换为自己想要的数据类型（以将字符串转换为日期类型数据为例）：
首先需要编写一个转换器类，并实现接口Converter，然后实现Converter接口中的convert方法来完成数据转换逻辑。
然后将这个转换器类注册到BeanUtils工具类中，就可以实现数据封装到对象中时，可以将日期格式的字符串数据转换为日期数据类型。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.commons.beanutils.Converter;
public class StringToDateConverter implements Converter{
/**
* @Title:convert
* @Description:将字符串转为日期类型
* @param c
* @param o 需要被转换的数据
* @return
* @see org.apache.commons.beanutils.Converter#convert(java.lang.Class, java.lang.Object)
*/
@Override
public Object convert(Class c, Object o) {
String str=(String)o;
SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd");//字符串格式指定
Date date=null;
try {
date=f.parse(str);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return date;
}
}
//编写一个包含Date类型属性的JavaBean
import java.util.Date;
public class Birthday{
Date birth;
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
}
//测试数据封装
public class TestBeanUtils {
@Test
public void testMyConverter() throws IllegalAccessException, InvocationTargetException{
//将自己的转换器注册到ConvertUtils中，第一个参数是自己编写的转换器的实例对象，第二个参数是数据
//转换的目标类型，当把数据封装到某一个对象的时候，如果对象中有Date类的属性，就会使用该转换器
ConvertUtils.register(new StringToDateConverter(), Date.class);
Birthday day=new Birthday();
Map<String, String[]> map=new HashMap<String, String[]>();
String[] s=new String[]{"1997-10-24"};
map.put("birth", s);
BeanUtils.populate(day, map);
System.out.println(day.getBirth().toString());
}
}6. Jsp中的EL表达式
Jsp内置的一种表达式，EL表达式可以获取数据、执行运算、获取web开发常用对象、调用Java方法四个用途。语法形式为： ${ 表达式内容 }
1. 获取域对象中的属性值：从四个域中取属性值，默认从范围最小的域中开始取值，即顺序为：pageContext->request->session->application
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'demo5.jsp' starting page</title>
</head>
<% pageContext.setAttribute("username", "1");
request.setAttribute("username", "2");
session.setAttribute("username", "3");
application.setAttribute("username", "4");
%>
<body>
<h5>
${username}
<!-- 从四个域中取属性值，默认从范围最小的域中开始取值，即顺序为：pageContext->request->session->application -->
</h5>
<div>存取数组：<br/>
<%
int[] arr={1,2,3,4};
pageContext.setAttribute("arr", arr);
%>
<p>${ arr[0] }</p>
</div>
<div>存取集合：<br/>
<%
List<String> list=new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
pageContext.setAttribute("list", list);
%>
<p>${ list[0] }</p>
</div>
<div>存取Map集合：<br/>
<%
Map<String,String> map=new HashMap<String,String>();
map.put("1", "1");
map.put("2", "2");
map.put("3", "3");
map.put("a.a", "4");
map.put("a", "a");
pageContext.setAttribute("map", map);
%>
<p>${ map.a }</p>
<p>${ map["1"] }</p>
<p>${ map["a.a"] }</p><!-- 特殊字符使用中括号 -->
</div>
</body>
</html>2. EL表达式常用的部分内部隐藏对象:
pageContext：表示jsp页面中的pageContext对象
pageScope:代表page域中用于保存属性的Map对象
requestScope：代表request域中用于保存属性的Map对象
sessionScope：代表session域中用于保存属性的Map对象
applicationScope：代表application域中用于保存属性的Map对象
param:表示一个保存了所有请求参数的Map对象，这个Map对象就保存了所有请求参数的键值对，通过参数名称返回的是一个String
paramValues:表示一个保存了所有请求参数的Map对象，通过参数名返回的是一个String[]，适用于一个参数名对应一个参数值数组的请求
header：表示一个保存了所有请求头键值对的Map对象，通过请求头名称返回的是一个String
headerValues：表示一个保存了所有请求头键值对的Map对象，通过请求头名称返回的是一个String[]
cookie：表示请求中的所有cookie键值对，如 ${ cookie.last} 表示获取cookie中名为last的cookie对象；${ cookie.last.key}表示获取last这个cookie的名称，也就是 last ；${ cookie.last.value}表示获取名为last的cookie对象的值。
3. EL表达式支持运算：加减乘除，关系运算，逻辑运算：
<div>EL表达式支持运算：加减乘除，关系运算，逻辑运算<br/>
<%pageContext.setAttribute("n1", 10);
request.setAttribute("n2", 20);
session.setAttribute("n3", 30);
application.setAttribute("n4", 40);
%>
<p>
<!-- ${n1 }就相当于 ${ pageContext.n1 } -->
${n1 }+${n2 }=${n1+n2 }
${n1==n2 }或${n1 eq n2 }
${true && true }
</p>
</div>7. JSTL标签
7.1 JSTL标签的使用
1. 引入JSTL核心标签库：<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%><%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<%--JSTL标签库：jstl，即jsp内置标签，其运行在服务器中并与html标签区分，用于简化标签，去掉<%%> --%>
<%--引入JSTL标签库： --%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'demo6.jsp' starting page</title>
</head>
<%pageContext.setAttribute("n", 10); %>
<body>
<div>
<c:if test="${n==10 }">
<p>test=true</p>
</c:if>
<c:choose></c:choose>
</div>
</body>
</html>2. 使用方法：<c:标签名 属性>输出内容（可以是HTML标签）</c:标签名>
3. 常用标签库：
核心标签库（core，也就是<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>）
另一个是 fn.tld，是EL函数库。
7.2 JSTL核心标签库
1. <c:out value="" default="" escapeXml="true"></c:out>：用于查找jsp四个域对象中的属性，并输出值value属性写EL表达式或者任意字符串，对于普通字符串不会做任何处理
如果value中的字符串写的是HTML标签的字符串，比如 "<div></div> "，则可以通过escapeXml属性来设置是否将该HTML标签字符串输出到页面时转换为HTML标签，默认为true表示不执行，false表示执行转换，会直接输出到页面中
default属性表示当value中的属性值无效时，或未设置value属性时，则默认输出这个字符串。支持EL表达式，属性类型为String
2. <c:set property="" scope="" value="" target="" var=""></c:set>：用于设置jsp四个域对象中存储属性，也可以向JavaBean或Map对象中设置属性
var表示属性名，不支持EL表达式，属性类型为String
value表示属性值，支持EL表达式，属性类型为Object
scope表示存储在那个域对象中，包括page、request、session、application四个，不支持EL表达式，属性类型为String
target用于指定要设置属性值的JavaBean对象，支持EL表达式，属性类型为Object
property用于指定要设置的属性，支持EL表达式，属性类型为String
3. <c:remove var="" scope=""/>：用于删除域对象中的属性
var表示属性名，不支持EL表达式，属性类型为String
scope表示指定删除的属性在那个域对象中，包括page、request、session、application四个，不支持EL表达式，属性类型为String
4. <c:catch var=""></c:catch>：用于捕获发生的异常，var属性表示如果发生了异常，就把异常信息保存到var指定的变量中。
5. <c:if test="" scope="" var=""></c:if>：用于判断，标签间可以写当判断为true时，则输出JSTL标签间的内容，可以是HTML标签
test属性必须出现，其值应该为true或false，支持EL表达式
var指定一个变量存储test属性中计算后的值，也就是说只会为true或false
scope表示var指定变量存储在哪个域变量中。
6. <c:choose><c:when test=""></c:when><c:otherwise></c:otherwise></c:choose>：也用于判断，相当于if-else语句
7. <c:forEach items="" begin="" end="" step="" var="" varStatus=""></c:forEach>：用于遍历数组或迭代数据集合
items表示要被遍历的数组对象或者是集合（Map与List），支持EL表达式
begin表示从第几个元素开始遍历，最小值为1
end表示遍历到第几个元素结束
step指定一个变量来表示下一次遍历会遍历到第 begin+=step 个元素
var指定一个变量表示当前被遍历到的元素
varStatus表示循环遍历的过程中产生的信息，比如
index下标值
count计数器
判断是否有第一个
判断是否有最后一个
8. <c:url context="" scope="" value="" var=""></c:url>：与提交的地址相关，比如超链接等
value指定要构造的url值，支持EL表达式，String类型的值
var指定将url值保存到jsp域对象中属性名称
scope指定将url值保存到那个jsp域对象中
context指定项目路径，url值是请求路径，context+value就是一个完整的路径，可以不指定，默认当前的web项目路径
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<%--JSTL标签库：jstl，即jsp内置标签，其运行在服务器中并与html标签区分，用于简化标签，去掉<%%> --%>
<%--引入JSTL标签库： --%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'demo6.jsp' starting page</title>
</head>
<%pageContext.setAttribute("n", 10); %>
<body>
<!-- JSTL核心标签库中的out标签,用于查找jsp四个域对象中的属性，并输出值 -->
<div>
<c:out value="${n}" default="查找失败"></c:out>
<c:out value="<a href='http://www.baidu.com'>百度</a>" escapeXml="false"></c:out>
</div>
<!-- set标签,用于向jsp四个域对象中存储更改属性,也可以向JavaBean或Map对象中设置属性 -->
<div>
<c:set property="" scope="session" value="vn" target="" var="name"></c:set>
<c:out value="${name }"></c:out>
</div>
<!-- remove标签,用于向jsp四个域对象中存储属性 -->
<div>
<c:remove var="n" scope=""/>
</div>
<!-- catch标签,用于捕获发生的异常 -->
<div>
<c:catch var="e">
<%!int a=10/0; %>
</c:catch>
<c:out value="${e.message }"></c:out>
</div>
<!-- if标签 ,用于判断条件-->
<div>
<c:if test="${n==10 }" scope="session" var="flag">
<p>test=true</p>
</c:if>
<c:out value="${i }"></c:out>
</div>
<!-- choose标签 ,用于判断条件-->
<c:choose>
<c:when test="${i }">
条件为true
</c:when>
<c:when test="${i == null }">
条件为空
</c:when>
<c:otherwise>
条件为false
</c:otherwise>
</c:choose>
<!-- forEach标签，用于遍历数组或迭代数据集合 -->
<div>
<%!
int[] arr={1,23,4,5,12};
List<Integer> list=new ArrayList<Integer>();
list.add(2);
list.add(4);
list.add(52);
list.add(22);
request.setAttribute("list", list);
%>
<!-- 相当于增强for循环 ，即 for(int i:list){} -->
<c:forEach items="${list }" var="i">
<c:out value="${i }"></c:out>
</c:forEach>
<!-- 普通for循环 ，即 for(int i=0;i<10;i++){} -->
<c:forEach items="${list }" var="i" begin="1" end="3" step="1" varStatus="status">
<c:out value="${i }"></c:out>
<c:out value="${step }"></c:out>
<c:out value="${status.count }"></c:out>
</c:forEach>
</div>
<!-- url标签，value中的路径可以不写项目名-->
<div>
<c:url value="/jsp/demo5.jsp"></c:url>
</div>
</body>
</html>8. EL函数库
1. EL函数：用来操作字符串，需要引入<%@taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>2. 用法：
<!-- EL 函数标签 -->
<%pageContext.setAttribute("str", "abcdefg"); %>
${fn:contains(str,"ab") }
${fn:indexOf(str,"c") }
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- JSP（Java Server Pages）总结
- JSP(Java Server Pages)动态网页开发技术1
- JSP（Java Server Pages)
- JSP（Java Server Pages）
- JSP--Java server Pages
- js入门(js（JavaScript）和jsp（Java Server Pages）的区别)
- JavaServer Pages(JSP)和微软Active Server Pages技术比较
- JSP——Java Server Pages（java服务器页面）
- JSP（Java Server Pages）内置对象
- JSP-Java Server Pages（Java服务器页面）<一>
- Java Server Pages---初识JSP
- JSP(JavaServer Pages)
- JSP--初识Java Server Pages
- JSP 2.0 真是BT阿!不过看起来挺方便的.(Developing Web Applications With JavaServer Pages 2.0)
- Servlet、JavaServer Pages(JSP) 技术
- JSP简介（java server pages）
- JSP（Java Server Pages）——内置对象request+Cookie
- Java Server Pages（JSP）概述
- JSP--Java Server Pages
- JSP(JavaServer Pages)不是Java Script(JS)