JSP——Java Server Pages

時間 2019-11-07

標籤 jsp java server pages 欄目 JSP 简体版

原文原文鏈接

1. 簡介

1. Jsp技術：Jsp是一種 html代碼+ Java代碼 + Jsp頁面代碼的技術，並且其不用像Servlet哪樣須要配置訪問路徑。css

2. Jsp執行原理：第一次訪問服務器web項目中的jsp頁面時，會首先把jsp頁面翻譯成爲一個標準Servlet，也就是 .java 的文件，而後將這個java文件編譯生成字節碼文件，而後再執行。html

3. Jsp中Java代碼的編寫：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屬性能夠屢次出現，具體經常使用屬性以下：web

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="" %>，具體經常使用屬性以下apache

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. 內置對象用法：tomcat

request:表示HttpServletRequest對象服務器
response:表示HttpServletResponse對象cookie
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") }

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。