JSP詳解
主要内容簡介：
1. JSP簡介
a) 什麼是JSP
b) JSP的組成
c) JSP的特點
d) JSP的執行過程
e) JSP的生命周期
2. JSP文法
a) JSP模闆元素
b) JSP表達式
c) JSP腳本片段
d) JSP注釋
3. JSP指令
a) page指令
b) Include指令
c) taglib指令
4. JSP九大内置(隐式)對象
5.JSP的四個域對象
6. JSP的正确使用方法
7.EL表達式詳解（重點）
8.JSP标簽（重點）
a) 内置标簽（動作标簽）：不需要在jsp頁面導入标簽
b) include指令與include動作标簽的差別
c) JSTL标簽：需要在jsp頁面中導入标簽
d) 自定義标簽：開發者自定義
一、JSP簡介
1.什麼是jsp
- JSP全稱是Java Server Pages，它和Servle技術一樣，都是SUN公司定義的一種用于開發動态web資源的技術
- JSP這門技術的最大的特點在于，寫JSP就像寫html，但：
相比html而言，（html隻能為使用者提供靜态資料）JSP技術允許在頁面中嵌套java代碼，為使用者提供動态資料。
相比servlet而言，jsp更容易對資料進行排版
2. JSP的組成
JSP使用Java腳本（代碼片段），html，還有JSP動态标簽構成的組成的
（JSP就是Servlet）
問題：為什麼Jsp就是servlet！！！
jsp翻譯的java檔案：
publicfinal class _01_hello_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {
HttpJspBase類：
public abstract class org.apache.jasper.runtime.HttpJspBase
結論： Jsp就是一個servlet程式！！！
servlet的技術可以用在jsp程式中
jsp的技術并不是全部适用于servlet程式！
簡單概念圖
3. JSP的特點：
1）jsp的運作必須交給tomcat伺服器！！！！
tomcat的work目錄： tomcat伺服器存放jsp運作時的臨時檔案
2）jsp頁面既可以寫html代碼，也可以寫java代碼。
（html頁面不能寫java代碼 。而jsp頁面可以寫java代碼）
4. JSP的執行過程
a）浏覽器通路JSP頁面，tomcat掃描到JSP檔案，在%tomcat%/work把jsp檔案翻譯成java源檔案（翻譯）
b）Tomcat伺服器把java源檔案編譯成class位元組碼檔案（編譯）
c）Tomcat伺服器構造該jsp對象
d）Tomcat伺服器調用該jsp類中的方法，傳回内容顯示到浏覽器
注意：隻在第一次通路時需要 a,b ,c,d四步驟
第二次到n次隻需要執行 d步驟。當jsp檔案修改或零時檔案被删除了需要重新走翻譯（a）和編譯（b）的過程。
5. JSP的生命周期（重點）
Servlet的生命周期：
1）構造方法（第1次通路）
2）init方法（第1次通路）
3）service方法
4）destroy方法
Jsp的生命周期
1）翻譯： jsp->java檔案
2）編譯： java檔案->class檔案（servlet程式）
3）構造方法（第1次通路）
4）init方法（第1次通路）：_jspInit()
5）service方法：_jspService()
6）destroy方法：_jspDestroy()
二、JSP文法
1. JSP模闆
JSP頁面中的HTML内容稱之為JSP模版元素。
JSP模版元素定義了網頁的基本骨架，即定義了頁面的結構和外觀。
2. JSP表達式（expression）
文法：<%= 變量或表達式%>
作用：用于将程式資料輸出到用戶端
<%= “hello world ”%> == <% out.print( “hello world ”); %>
注意：
1）表達式的原理其實就是吧文法中的内容翻譯成out.print（“内容”）；
通過該方法向浏覽器寫出内容
2）表達式中不能帶分号
3. JSP的腳本（scriptlet）
文法：<% 多行java代碼 %>
作用：相當與在JSP翻譯的Servlet類中的_jspService方法中寫可以執行的代碼。
注意：
1）JSP腳本片斷中隻能出現java代碼，不能出現其它模闆元素， JSP引擎在翻譯JSP頁面中，會将JSP腳本片斷中的Java代碼将被原封不動地放到Servlet的_jspService方法中。
2）JSP腳本片斷中的Java代碼必須嚴格遵循Java文法，例如，每執行語句後面必須用分号（;）結束。
3）在一個JSP頁面中可以有多個腳本片斷，在兩個或多個腳本片斷之間可以嵌入文本、HTML标記和其他JSP元素。
舉例：
<%
int x = 10;
out.println(x);
%>
<p>這是JSP頁面文本</p>
<%
int y = 20;
out.println(y+””+x);
%>
4）多個腳本片斷中的代碼可以互相通路，猶如将所有的代碼放在一對<%%>之中的情況。如：out.println(x);
5）單個腳本片斷中的Java語句可以是不完整的，但是，多個腳本片斷組合後的結果必須是完整的Java語句，例如：
<%
for (int i=1; i<5;i++)
{
%>
<H1>helloword</H1>
<%
}
%>
4. JSP的聲明
文法：<%! 變量或方法 %>
作用：聲明JSP的變量或方法（相當于在JSP翻譯的Servlet類中寫成員變量或方法）
注意：
1）JSP聲明可用于定義JSP頁面轉換成的Servlet程式的靜态代碼塊、成員變量和方法 。
2）多個靜态代碼塊、變量和函數可以定義在一個JSP聲明中，也可以分别單獨定義在多個JSP聲明中。
3）JSP隐式對象的作用範圍僅限于Servlet的_jspService方法，是以在JSP聲明中不能使用這些隐式對象。
<%!
static
{
System.out.println("loadingServlet!");
}
private intglobalVar = 0;
public voidjspInit()
{
System.out.println("initializingjsp!");
}
%>
<%!
public voidjspDestroy()
{
System.out.println("destroyingjsp!");
}
%>
5. JSP注釋
文法：<%! -- jsp注釋 --%>
注意：
1)html的注釋會被翻譯和執行。而jsp的注釋不能被翻譯和執行。
2)在JSP聲明，腳本，表達式中可以用java的注釋
三、JSP三大指令（directive）
概念：JSP指令（directive）是為JSP引擎而設計的，它們并不直接産生任何可見輸出，而隻是告訴引擎如何處理JSP頁面中的其餘部分。在JSP 2.0規範中共定義了三個指令：
page指令
Include指令
taglib指令
JSP指令的基本文法格式：
<%@指令屬性名="值" %>
舉例：
<%@ pagecontentType="text/html;charset=UTF-8"%>
如果一個指令有多個屬性，這多個屬性可以寫在一個指令中，也可以分開寫。
例如：
<%@ pagecontentType="text/html;charset=UTF-8"%>
<%@ pageimport="java.util.Date"%>
也可以寫作：
<%@ pagecontentType="text/html;charset=UTF-8"import="java.util.Date"%>
1. page指令
1）page指令用于定義JSP頁面的各種屬性，無論page指令出現在JSP頁面中的什麼地方，它作用的都是整個JSP頁面，為了保持程式的可讀性和遵循良好的程式設計習慣，page指令最好是放在整個JSP頁面的起始位置。
2）page指令中的各個屬性
<%@ page
language="java"
--告訴伺服器使用什麼動态語言來翻譯jsp檔案
（當年sun公司想讓jsp支援多種語言定義了，後來由于某種原因沒有完成，是以隻能翻譯為java語言）
import="java.util.*"
--告訴伺服器java檔案使用什麼包導入包，多個包之間用逗号分割（建議分開導入包）
pageEncoding="utf-8"
--告訴伺服器使用什麼編碼翻譯jsp檔案（成java檔案）
contentType="text/html;charset=utf-8"
伺服器發送浏覽器的資料類型和内容編碼
注意：在開發工具中，以後隻需要設定pageEncoding即可解決中文亂碼問題
與異常錯誤相關的：
errorPage="error.jsp"
isErrorPage="false"
Web.xml中配置全局的錯誤處理頁面：（常用）
| <!-- 全局錯誤處理頁面配置 --> <error-page> <!-- 建議500錯誤使用JSP頁面，因為500錯誤是動态的，不定的是以适合用jsp頁面 --> <error-code>500</error-code> <location>/common/500.jsp</location> </error-page> <error-page> <!-- 404錯誤隻有位址錯誤一種可能是以适合用同一個html頁面 --> <error-code>404</error-code> <location>/common/404.html</location> </error-page> |
buffer="8kb"
設定jsp頁面緩存大小，因為jsp頁面有JSPWriter緩存機制，資料先會寫到JSPWriter緩存中，然後一定條件下才會寫入頁面，是以如果不需要緩存機制 可以設定為 “0kb”
session="true"
是否開啟session功能。false，不能用session内置對象；true，可以使用session内置對象。
isELIgnored="false"
是否忽略EL表達式
%>
2. include指令（靜态包含）
原理： include指令用于引入其它JSP頁面，如果使用include指令引入了其它JSP頁面，那麼JSP引擎将把這兩個JSP翻譯成一個servlet。是以include指令引入通常也稱之為靜态引入。
文法：
<%@ includefile="relativeURL"%>
其中的file屬性用于指定被引入檔案的相對路徑。 file屬性的設定值必須使用相對路徑，如果以“/”開頭，表示相對于目前WEB應用程式的根目錄（注意不是站點根目錄），否則，表示相對于目前檔案。
細節：
被引入的檔案必須遵循JSP文法。
被引入的檔案可以使用任意的擴充名，即使其擴充名是html，JSP引擎也會按照處理jsp頁面的方式處理它裡面的内容，為了見明知意，JSP規範建議使用.jspf（JSP fragments）作為靜态引入檔案的擴充名。
由于使用include指令将會涉及到2個JSP頁面，并會把2個JSP翻譯成一個servlet，是以這2個JSP頁面的指令不能沖突（除了pageEncoding和導包除外）。
（其實就是相當于吧兩個JSP中的内容翻譯到一個servlet中從生成的jspServlet檔案中可以看出其實相當于把所有的資訊原封不動的拿了過來。這就有可能導緻當定義兩個相同名稱的變量是會出現錯誤）
out.write('\r');
out.write('\n');
out.write("\r\n");
out.write("\r\n");
out.write("<!DOCTYPE html PUBLIC\"-//W3C//DTD HTML 4.01 Transitional//EN\"\"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
out.write("<html>\r\n");
out.write("<head>\r\n");
out.write("<metahttp-equiv=\"Content-Type\" content=\"text/html;charset=UTF-8\">\r\n");
out.write("<title>Insert titlehere</title>\r\n");
out.write("</head>\r\n");
out.write("<body>\r\n");
out.write("\tHello ");
out.write("\r\n");
out.write("<!DOCTYPE html PUBLIC\"-//W3C//DTD HTML 4.01 Transitional//EN\"\"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
out.write("<html>\r\n");
out.write("<head>\r\n");
out.write("<metahttp-equiv=\"Content-Type\" content=\"text/html;charset=UTF-8\">\r\n");
out.write("<title>Insert titlehere</title>\r\n");
out.write("</head>\r\n");
out.write("<body>\r\n");
out.write(" world\r\n");
out.write("</body>\r\n");
out.write("</html>");
out.write("\r\n");
out.write("</body>\r\n"); out.write("</html>");
網頁源代碼
3. taglib指令
四、JSP的九大内置（隐式）對象（重點）
1. 什麼是内置對象
在jsp開發中，會頻繁使用到一些對象例如：
HttpSession
ServletContext,
ServletContext,
HttpServletRequet。
如果我們每次要使用這些對象都要去建立這些對象就會顯得有點麻煩，是以sun公司設計jsp時，在jsp頁面加載完畢之後就會自動幫開發者建立好這些對象，而開發者隻需要直接使用這些對象調用方法即可！，這些建立好的對象就叫内置對象
舉例：
servlet:
HttpSessionsession = request.getSession(true); （需要開發者做）
jsp:
tomcat伺服器： HttpSession session =request.getSession(true);(不需要開發者做)
開發者做的： session.getId();
2. 九大内置對象
request HttpServletRequest ----|
response HttpServletResponse ----|
session HttpSession ----|--------在servlet中也可以用的五個對象
application ServletcContext ----|
config ServletConfig ----|
exception Throwable (當設定page指令的isErorrPage屬性是才可以使用)
page Object(this) (本JSP頁面)
out JspWriter （帶緩沖的PrintWriter）
pageContext PageContext (使普通Java類可通路WEB資源，自定義标簽常用)
内置對象特點:
1. 由JSP規範提供,不用編寫者執行個體化。
2. 通過Web容器實作和管理
3. 所有JSP頁面均可使用
4. 隻有在腳本元素的表達式或代碼段中才可使用(<%=使用内置對象%>或<%使用内置對象%>)
内置對象可分為四類:
1. 輸出輸入對象:request對象、response對象、out對象
2. 通信控制對象:pageContext對象、session對象、application對象
3. Servlet對象:page對象、config對象
4. 錯誤處理對象:exception對象
對象常用方法說明:
1.request對象(請求資訊 javax.servlet.http.HttpServletrequest)
| 方法名 | 描述 |
| isUserInRole | 判斷認證後的使用者是否屬于某一成員組 |
| getAttribute | 擷取指定屬性的值,如該屬性值不存在傳回Null |
| getAttributeNames | 擷取所有屬性名的集合 |
| getCookies | 擷取所有Cookie對象 |
| getCharacterEncoding | 擷取請求的字元編碼方式 |
| getContentLength | 傳回請求正文的長度,如不确定傳回-1 |
| getHeader | 擷取指定名字報頭值 |
| getHeaders | 擷取指定名字報頭的所有值,一個枚舉 |
| getHeaderNames | 擷取所有報頭的名字,一個枚舉 |
| getInputStream | 傳回請求輸入流,擷取請求中的資料 |
| getMethod | 擷取用戶端向伺服器端傳送資料的方法 |
| getParameter | 擷取指定名字參數值 |
| getParameterNames | 擷取所有參數的名字,一個枚舉 |
| getParameterValues | 擷取指定名字參數的所有值 |
| getProtocol | 擷取用戶端向伺服器端傳送資料的協定名稱 |
| getQueryString | 擷取以get方法向伺服器傳送的查詢字元串 |
| getRequestURI | 擷取送出請求字元串的用戶端位址 |
| getRemoteAddr | 擷取用戶端的IP位址 |
| getRemoteHost | 擷取用戶端的名字 |
| getSession | 擷取和請求相關的會話 |
| getServerName | 擷取伺服器的名字 |
| getServerPath | 擷取用戶端請求檔案的路徑 |
| getServerPort | 擷取伺服器的端口号 |
| removeAttribute | 删除請求中的一個屬性 |
| setAttribute | 設定指定名字參數值 |
特點：Request(Javax.servlet.ServletRequest)它包含了有關浏覽器請求的資訊.通過該對象可以獲得請求中的頭資訊、Cookie和請求參數。
2.response對象(響應 javax.servlet.http.HttpServletResponse)
| 方法名 | 描述 |
| addCookie | 添加一個Cookie對象 |
| addHeader | 添加Http檔案指定名字頭資訊 |
| containsHeader | 判斷指定名字Http檔案頭資訊是否存在 |
| encodeURL | 使用sessionid封裝URL |
| flushBuffer | 強制把目前緩沖區内容發送到用戶端 |
| getBufferSize | 傳回緩沖區大小 |
| getOutputStream | 傳回到用戶端的輸出流對象 |
| sendError | 向用戶端發送錯誤資訊 |
| sendRedirect | 把響應發送到另一個位置進行處理 |
| setContentType | 設定響應的MIME類型 |
| setHeader | 設定指定名字的Http檔案頭資訊 |
特點Response(Javax.servlet.ServletResponse)作為JSP頁面處理結果傳回給使用者的響應存儲在該對象中。并提供了設定響應内容、響應頭以及重定向的方法(如cookies,頭資訊等)
3.session對象(會話 javax.servlet.http.HttpSession)
| 方法名 | 描述 |
| getAttribute | 擷取指定名字的屬性 |
| getAttributeNames | 擷取session中全部屬性名字,一個枚舉 |
| getCreationTime | 傳回session的建立時間 |
| getId | 擷取會話辨別符 |
| getLastAccessedTime | 傳回最後發送請求的時間 |
| getMaxInactiveInterval | 傳回session對象的生存時間機關千分之一秒 |
| invalidate | 銷毀session對象 |
| isNew | 每個請求是否會産生新的session對象 |
| removeAttribute | 删除指定名字的屬性 |
| setAttribute | 設定指定名字的屬性值 |
特點： Session ( javax.servlet.http.HttpSession )會話對象存儲有關此會話的資訊,也可以将屬性賦給一個會話,每個屬性都有名稱和值。會話對象主要用于存儲和檢索屬性值。
4.application對象(應用程式 javax.servlet.ServletContext)
| 方法名 | 描述 |
| getAttribute | 擷取應用對象中指定名字的屬性值 |
| getAttributeNames | 擷取應用對象中所有屬性的名字,一個枚舉 |
| getInitParameter | 傳回應用對象中指定名字的初始參數值 |
| getServletInfo | 傳回Servlet編譯器中目前版本資訊 |
| setAttribute | 設定應用對象中指定名字的屬性值 |
特點：Application(javax.servle.ServletContext)存儲了運作JSP頁面的servlet以及在同一應用程式中的任何Web元件的上下文資訊。
5.config對象(Servlet的配置資訊 javax.servlet.ServletConfig)
| 方法名 | 描述 |
| getServletContext | 傳回所執行的Servlet的環境對象 |
| getServletName | 傳回所執行的Servlet的名字 |
| getInitParameter | 傳回指定名字的初始參數值 |
| getInitParameterNames | 傳回該JSP中所有的初始參數名,一個枚舉 |
特點：Config(javax.servlet.ServletConfig)該對象用于存取servlet執行個體的初始化參數。
6.page對象(目前JSP的執行個體,java.lang.object)
它代表JSP被編譯成Servlet,可以使用它來調用Servlet類中所定義的方法
特點：Page(Java.lang.Object)表示目前JSP頁面的servlet執行個體
可以用他來擷取整個類中的所有方法和成員變量（反射）
7.out對象(資料流 javax.servlet.jsp.jspWriter)（重點）
| 方法名 | 描述 |
| print或println | 輸出資料 |
| newLine | 輸出換行字元 |
| flush | 輸出緩沖區資料 |
| close | 關閉輸出流 |
| clear | 清除緩沖區中資料,但不輸出到用戶端 |
| clearBuffer | 清除緩沖區中資料,輸出到用戶端 |
| getBufferSize | 獲得緩沖區大小 |
| getRemaining | 獲得緩沖區中沒有被占用的空間 |
| isAutoFlush | 是否為自動輸出 |
1.用于将内容寫入JSP頁面執行個體的輸出流中,提供了幾個方法使你能用于向浏覽器回送輸出結果。特點：Out(Javax.servlet.jsp.JspWriter)
2.out對象是通過調用pageContext對象的getOut方法傳回的，其作用和用法與ServletResponse.getWriter方法傳回的PrintWriter對象非常相似。
3.JSP頁面中的out隐式對象的類型為JspWriter，JspWriter相當于一種帶緩存功能的PrintWriter，設定JSP頁面的page指令的buffer屬性可以調整它的緩存大小，甚至關閉它的緩存。
4.隻有向out對象中寫入了内容，且滿足如下任何一個條件時，out對象才去調用ServletResponse.getWriter方法，并通過該方法傳回的PrintWriter對象将out對象的緩沖區中的内容真正寫入到Servlet引擎提供的緩沖區中：
- 設定page指令的buffer屬性關閉了out對象的緩存功能
- out對象的緩沖區已滿
- 整個JSP頁面結束
out隐式對象工作原理
8.pageContext對象(頁面上下文 javax.servlet.jsp.PageContext)
| 方法名 | 描述 |
| forward | 重定向到另一頁面或Servlet元件 |
| getAttribute | 擷取某範圍中指定名字的屬性值 |
| findAttribute | 按範圍搜尋指定名字的屬性，先後查找各個域中的屬性 |
| removeAttribute | 删除某範圍中指定名字的屬性 |
| setAttribute | 設定某範圍中指定名字的屬性值 |
| getException | 傳回目前異常對象 |
| getRequest | 傳回目前請求對象 |
| getResponse | 傳回目前響應對象 |
| getServletConfig | 傳回目前頁面的ServletConfig對象 |
| getServletContext | 傳回所有頁面共享的ServletContext對象 |
| getSession | 傳回目前頁面的會話對象 |
常見的用法：
特點： pageContext對象的類型是PageContext，叫jsp的上下文對象
1）可以擷取其他八個内置對象
publicclass 01_hello_jsp {
publicvoid _jspService(request,response){
建立内置對象
HttpSessionsession =....;
ServletConfigconfig = ....;
把8個經常使用的内置對象封裝到PageContext對象中
PageContextpageContext = 封裝；
調用method1方法
method1(pageContext);
}
publicvoid method1(PageContext pageContext){
希望使用内置對象
從PageContext對象中擷取其他8個内置對象
JspWriterout =pageContext.getOut();
HttpServletRequestrquest = pageContext.getRequest();
........
}
}
使用場景：在自定義标簽的時候，PageContext對象頻繁使用到！！！
2）本身是一個域對象
ServletContextcontext域
HttpServletRequet request域
HttpSession session域 --Servlet學習的
PageContext page域 --jsp學習的
作用：儲存資料和擷取資料，用于共享資料
#儲存資料
）預設情況下，儲存到page域
pageContext.setAttribute("name");
2）可以向四個域對象儲存資料
pageContext.setAttribute("name",域範圍常量)
#擷取資料
1）預設情況下，從page域擷取
pageContext.getAttribute("name")
2）可以從四個域中擷取資料
pageContext.getAttribute("name",域範圍常量)
等價于
域對象.getAttribute(“name”)
域範圍常量:（可以使用pageContext.setAttribute(key,value,域範圍常量)來設定添加的資料添加到那個域）
PageContext.PAGE_SCOPE
PageContext.REQUEST_SCOPE
PageContext..SESSION_SCOPE
PageContext.APPLICATION_SCOPE
3）自動在四個域中搜尋資料（從作用域最低的域開始找）
pageContext.findAttribute("name");
順序： page域 ->request域 -> session域- >context域（application域）
4）引入和跳轉到其他資源（重點）
PageContext類中定義了一個forward方法和兩個include方法來分别簡化和替代RequestDispatcher.forward方法和include方法
傳遞給這些方法的資源路徑，如果路徑以“/”開頭，表示相對于目前WEB應用程式的根目錄，否則，表示相對于目前JSP所映射到的通路路徑。
9.exception對象(運作時的異常,java.lang.Throwable)
被調用的錯誤頁面的結果,隻有在錯誤頁面中才可使用,
即在頁面指令中設定:<%@page isErrorPage=“true”%>
Exception(Javax.lang.Throwable)在某個頁面抛出異常時,将轉發至JSP錯誤頁面,提供此對象是為了在JSP中處理錯誤。隻有在錯誤頁面中才可使用<%@page isErrorPage=“true”%>
| Jsp内置對象 | 功能 | 主要方法 |
| out | 向用戶端輸出資料 | print() println() flush() clear() isAutoFlush() getBufferSize() close() ………… |
| request | 向用戶端請求資料 | getAttributeNames() getCookies() getParameter() getParameterValues() setAttribute() getServletPath() ………….. |
| response | 封裝了jsp産生的響應,然後被發送到用戶端以響應客戶的請求 | addCookie() sendRedirect() setContentType() flushBuffer() getBufferSize() getOutputStream() sendError() containsHeader()…………… |
| application | ||
| config | 表示Servlet的配置,當一個Servlet初始化時,容器把某些資訊通過此對象傳遞給這個Servlet | getServletContext() getServletName() getInitParameter() getInitParameterNames()…………… |
| page | Jsp實作類的執行個體,它是jsp本身,通過這個可以對它進行通路 | flush()……… |
| pagecontext | 為JSP頁面包裝頁面的上下文。管理對屬于JSP中特殊可見部分中己經命名對象的該問 | forward() getAttribute() getException() getRequest() getResponse() getServletConfig() getSession() getServletContext() setAttribute() removeAttribute() findAttribute() …………… |
| session | 用來儲存每個使用者的資訊,以便跟蹤每個使用者的操作狀态 | getAttribute() getId() getAttributeNames() getCreateTime() getMaxInactiveInterval() invalidate() isNew() |
| exception | 反映運作的異常 | getMessage()………… |
五、JSP的四個域對象
pageContext page域(jsp有效) pageContext.
request request域(一次請求) HttpServletRequest
Session session域(一次會話) HTTPSession
Application Context域(目前web應用) ServletContext
之是以他們是域對象，原因就是他們都内置了map集合，都有setAttribute getAttribute方法。
他們都有自己固定的生命周期和作用域。這四個對象的生命周期(生命周期就是值對象的建立到銷毀的期間)。
四個域對象的生命周期：
· page：jsp頁面被執行，生命周期開始，jsp頁面執行完畢，聲明周期結束。
· request:使用者發送一個請求，開始，伺服器傳回響應，請求結束，生命周期結束。
· session:使用者打開浏覽器通路，建立session(開始),session逾時或被聲明失效，該對象生命周期結束。
· application：web應用加載的時候建立。Web應用被移除或伺服器關閉，對象銷毀。[結束]。
注意：
· Page隻在目前jsp有效，每次請求分别對應不同的request。
· Request隻在目前請求有效，每次請求分别對應不同的request域。
· Session隻在一次會話中有效，會話結束就無法取到資料了。
四個域對象在選擇的時候，能用範圍小的絕不用範圍大的：
page:資料隻是暫時存在集合，在jsp頁面的其他地方要用，用page(頁面中自定義的map)。
Request:資料隻是做顯示的，看完了就沒用了。就存request域，請求轉發，Servlet産生的處理結果（資料）交給jsp顯示，資料轉發可以帶資料。
Session:資料給使用者看完了，一定還要用，會話結束了就沒用了。使用者登入，使用者資訊發給用戶端看，看完了，一會通路别的頁面還要看使用者資訊。 購物車，購物車成功了，給使用者看購物車，待會随時間可以檢視購物車。 請求重定向，因為是兩次請求，每一次請求的資料，第二次請求還要看。
application:資料給一個使用者用完了，别人還要用。聊天室，聊天記錄，需要給所有的使用者看。 統計網站線上人數，所有看到的應該是一個數。
總結：
1）域對象作用：
儲存資料 和 擷取資料 ，用于資料共享。
2）域對象方法：
setAttribute("name",Object)儲存資料
getAttribute("name") 擷取資料
removeAttribute("name")清除資料
3）域對象作用範圍：
page域：隻能在目前jsp頁面中使用（目前頁面）
request域：隻能在同一個請求中使用（轉發）
session域：隻能在同一個會話（session對象）中使用（私有的）
context域：隻能在同一個web應用中使用。（全局的）
四個域對象在選擇的時候，能用範圍小的絕不用範圍大的。需要定義Map時不如用page，請求Servlet，轉發給jsp的資料存request，請求重定向帶過去的資料存Session，全局的資料存application。
六、JSP的正确使用方法
Servlet技術： 開發動态資源。是一個java類，最擅長寫java代碼
jsp技術： 開發動态資源。通過java代碼最擅長輸出html代碼。
（盡量在jsp頁面中少寫甚至不寫java代碼。）
各取所長：
在web項目中涉及到邏輯：
1）接收參數 servlet做
2）處理業務邏輯，傳回結果 servlet做
3）顯示資料到浏覽器 jsp做
4）跳轉到其他頁面 servlet做
servlet+jsp模式
servlet:
1）接收參數
2）處理業務邏輯
3）把結果儲存到域對象中
4）跳轉到jsp頁面
Jsp:
1）從域對象取出資料
2）把資料顯示到浏覽器
servlet的資料 -> jsp頁面
List<Contact> 使用域對象共享資料
七、EL表達式 （Expression Language）
EL表達式的主要作用：
1. 擷取（域對象中的）資料：
EL表達式主要用于替換JSP頁面中的腳本表達式，以從各種類型的web域中檢索java對象、擷取資料。(某個web域中的對象，通路javabean的屬性、通路list集合、通路map集合、通路數組)
EL既可以用來建立算術表達式也可以用來建立邏輯表達式。在JSPEL表達式内可以使用整型數，浮點數，字元串，常量true、false，還有null。
一個簡單的文法
典型的，當您需要在JSP标簽中指定一個屬性值時，隻需要簡單地使用字元串即可：
<jsp:setProperty name="box" property="perimeter" value="100"/> JSP EL允許您指定一個表達式來表示屬性值。一個簡單的表達式文法如下：
${expr} 其中，expr指的是表達式。在JSPEL中通用的操作符是 . 和 {} 。這兩個操作符允許您通過内嵌的JSP對象通路各種各樣的JavaBean屬性。
舉例來說，上面的<jsp:setProperty>标簽可以使用表達式語言改寫成如下形式：
value="${2*box.width+2*box.height}"/> 當JSP編譯器在屬性中見到"${}"格式後，它會産生代碼來計算這個表達式，并且産生一個替代品來代替表達式的值。
您也可以在标簽的模闆文本中使用表達式語言。比如<jsp:text>标簽簡單地将其主體中的文本插入到JSP輸出中：
<jsp:text><h1>Hello JSP!</h1></jsp:text> 現在，在<jsp:text>标簽主體中使用表達式，就像這樣：
<jsp:text> Box Perimeter is: ${2*box.width + 2*box.height}</jsp:text> 在EL表達式中可以使用圓括号來組織子表達式。比如${(1 + 2) * 3}等于9，但是${1+ (2 * 3)} 等于7。
想要停用對EL表達式的評估的話，需要使用page指令将isELIgnored屬性值設為true：
<%@ page isELIgnored ="true|false" %> 這樣，EL表達式就會被忽略。若設為false，則容器将會計算EL表達式。
EL中的基礎操作符
EL表達式支援大部分Java所提供的算術和邏輯操作符：
| 操作符 | 描述 |
| . | 通路一個Bean屬性或者一個映射條目 |
| [] 重點 | 通路一個數組或者連結清單的元素 可以傳入帶敏感字元的變量名 |
| ( ) | 組織一個子表達式以改變優先級 |
| + | 加 |
| - | 減或負 |
| * | 乘 |
| / or div | 除 |
| % or mod | 取模 |
| == or eq | 測試是否相等 |
| != or ne | 測試是否不等 |
| < or lt | 測試是否小于 |
| > or gt | 測試是否大于 |
| <= or le | 測試是否小于等于 |
| >= or ge | 測試是否大于等于 |
| && or and | 測試邏輯與 |
| || or or | 測試邏輯或 |
| ! or not | 測試取反 |
| empty | 測試是否空值 |
el表達式的使用
${變量}
輸出普通字元串： ${name}
輸出對象屬性： ${student.name} 注意： .name 相當于 .getName（）方法
輸出List集合： ${list[0].name } 注意： [0] 相當于 get（下标）方法
輸出map集合： ${map[key].name} 注意： ［key］相當于get（key）方法
注意：[ ]可在el表達式中輸出帶敏感字元的變量名${requestScope["Accept-Language"]}
JSP EL中的函數
JSP EL允許您在表達式中使用函數。這些函數必須被定義在自定義标簽庫中。函數的使用文法如下：
${ns:func(param1, param2, ...)} ns指的是命名空間（namespace），func指的是函數的名稱，param1指的是第一個參數，param2指的是第二個參數，以此類推。比如，有函數fn:length，在JSTL庫中定義，可以像下面這樣來擷取一個字元串的長度：
${fn:length("Get my length")} 要使用任何标簽庫中的函數，您需要将這些庫安裝在伺服器中，然後使用<taglib>标簽在JSP檔案中包含這些庫。
JSP EL隐含對象
JSP EL支援下表列出的隐含對象：
| 隐含對象 | 描述 |
| pageScope | page 作用域 |
| requestScope | request 作用域 |
| sessionScope | session 作用域 |
| applicationScope | application 作用域 |
| param | Request 對象的參數，字元串 |
| paramValues | Request對象的參數，字元串集合 |
| header | HTTP 資訊頭，字元串 |
| headerValues | HTTP 資訊頭，字元串集合 |
| initParam | 上下文初始化參數 |
| cookie | Cookie值 |
| pageContext | 目前頁面的pageContext可以擷取任何域對象 |
您可以在表達式中使用這些對象，就像使用變量一樣。接下來會給出幾個例子來更好的了解這個概念。
pageContext對象
pageContext對象是JSP中pageContext對象的引用。通過pageContext對象，您可以通路request對象。比如，通路request對象傳入的查詢字元串，就像這樣：
${pageContext.request.queryString} Scope對象
pageScope，requestScope，sessionScope，applicationScope變量用來通路存儲在各個作用域層次的變量。
舉例來說，如果您需要顯式通路在applicationScope層的box變量，可以這樣來通路：applicationScope.box。
param和paramValues對象
param和paramValues對象用來通路參數值，通過使用request.getParameter方法和request.getParameterValues方法。
舉例來說，通路一個名為order的參數，可以這樣使用表達式：${param.order}，或者${param["order"]}。
接下來的例子表明了如何通路request中的username參數：
<%@ page import="java.io.*,java.util.*" %><% String title = "Accessing Request Param"; %><html><head><title><% out.print(title); %></title></head><body><center><h1><% out.print(title); %></h1></center><div align="center"><p>${param["username"]}</p></div></body></html> param對象傳回單一的字元串，而paramValues對象則傳回一個字元串數組。
header和headerValues對象
header和headerValues對象用來通路資訊頭，通過使用 request.getHeader方法和request.getHeaders方法。
舉例來說，要通路一個名為user-agent的資訊頭，可以這樣使用表達式：${header.user-agent}，或者${header["user-agent"]}。
接下來的例子表明了如何通路user-agent資訊頭：
<%@ page import="java.io.*,java.util.*" %><% String title = "User Agent Example"; %><html><head><title><% out.print(title); %></title></head><body><center><h1><% out.print(title); %></h1></center><div align="center"><p>${header["user-agent"]}</p></div></body></html> 八、JSP标簽（重點）
1. JSP标簽的作用
替換jsp腳本
1）流程判斷（if for循環）
2）跳轉頁面（轉發，重定向）
2.JSP标簽的分類
1）内置标簽（動作标簽）：不需要在jsp頁面導入标簽
2）JSTL标簽：需要在jsp頁面中導入标簽
3）自定義标簽：開發者自行定義，需要在jsp頁面導入标簽
動作标簽：
該部分内容引用自菜鳥教程
與JSP指令元素不同的是，JSP動作元素在請求處理階段起作用。JSP動作元素是用XML文法寫成的。
利用JSP動作可以動态地插入檔案、重用JavaBean元件、把使用者重定向到另外的頁面、為Java插件生成HTML代碼。
動作元素隻有一種文法，它符合XML标準：
<jsp:action_name attribute="value" /> 動作元素基本上都是預定義的函數，JSP規範定義了一系列的标準動作，它用JSP作為字首，可用的标準動作元素如下：
| 文法 | 描述 |
| jsp:include | 在頁面被請求的時候引入一個檔案。 |
| jsp:useBean | 尋找或者執行個體化一個JavaBean。 |
| jsp:setProperty | 設定JavaBean的屬性。 |
| jsp:getProperty | 輸出某個JavaBean的屬性。 |
| jsp:forward | 把請求轉到一個新的頁面。 |
| jsp:plugin | 根據浏覽器類型為Java插件生成OBJECT或EMBED标記。 |
| jsp:element | 定義動态XML元素 |
| jsp:attribute | 設定動态定義的XML元素屬性。 |
| jsp:body | 設定動态定義的XML元素内容。 |
| jsp:text | 在JSP頁面和文檔中使用寫入文本的模闆 |
常見的屬性
所有的動作要素都有兩個屬性：id屬性和scope屬性。
· id屬性：
id屬性是動作元素的唯一辨別，可以在JSP頁面中引用。動作元素建立的id值可以通過PageContext來調用。
· scope屬性：
該屬性用于識别動作元素的生命周期。 id屬性和scope屬性有直接關系，scope屬性定義了相關聯id對象的壽命。 scope屬性有四個可能的值： (a) page, (b)request, (c)session, 和 (d)application。
·
·
<jsp:include>動作元素
<jsp:include>動作元素用來包含靜态和動态的檔案。該動作把指定檔案插入正在生成的頁面。文法格式如下：
<jsp:include page="相對 URL 位址" flush="true" /> 前面已經介紹過include指令，它是在JSP檔案被轉換成Servlet的時候引入檔案，而這裡的jsp:include動作不同，插入檔案的時間是在頁面被請求的時候。
以下是include動作相關的屬性清單。
| 屬性 | 描述 |
| page | 包含在頁面中的相對URL位址。 |
| flush | 布爾屬性，定義在包含資源前是否重新整理緩存區。 |
執行個體
以下我們定義了兩個檔案 date.jsp 和 main.jsp，代碼如下所示：
date.jsp檔案代碼：
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><p> 今天的日期是: <%= (new java.util.Date()).toLocaleString()%></p> main.jsp檔案代碼：
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鳥教程(runoob.com)</title></head><body> <h2>include 動作執行個體</h2><jsp:include page="date.jsp" flush="true" /> </body></html> 現在将以上兩個檔案放在伺服器的根目錄下，通路main.jsp檔案。顯示結果如下：
include 動作執行個體 今天的日期是: 2016-6-25 14:08:17 <jsp:useBean>動作元素
jsp:useBean 動作用來加載一個将在JSP頁面中使用的JavaBean。
這個功能非常有用，因為它使得我們可以發揮 Java 元件複用的優勢。
jsp:useBean動作最簡單的文法為：
<jsp:useBean id="name" class="package.class" /> 在類載入後，我們既可以通過 jsp:setProperty 和 jsp:getProperty 動作來修改和檢索bean的屬性。
以下是useBean動作相關的屬性清單。
| 屬性 | 描述 |
| class | 指定Bean的完整包名。 |
| type | 指定将引用該對象變量的類型。 |
| beanName | 通過 java.beans.Beans 的 instantiate() 方法指定Bean的名字。 |
在給出具體執行個體前，讓我們先來看下 jsp:setProperty 和 jsp:getProperty 動作元素：
<jsp:setProperty>動作元素
jsp:setProperty用來設定已經執行個體化的Bean對象的屬性，有兩種用法。首先，你可以在jsp:useBean元素的外面（後面）使用jsp:setProperty，如下所示：
<jsp:useBean id="myName" ... /> ...<jsp:setProperty name="myName" property="someProperty" .../> 此時，不管jsp:useBean是找到了一個現有的Bean，還是新建立了一個Bean執行個體，jsp:setProperty都會執行。第二種用法是把jsp:setProperty放入jsp:useBean元素的内部，如下所示：
<jsp:useBean id="myName" ... > ... <jsp:setProperty name="myName" property="someProperty" .../></jsp:useBean> 此時，jsp:setProperty隻有在建立Bean執行個體時才會執行，如果是使用現有執行個體則不執行jsp:setProperty。
jsp:setProperty動作有下面四個屬性,如下表：
| 屬性 | 描述 |
| name | name屬性是必需的。它表示要設定屬性的是哪個Bean。 |
| property | property屬性是必需的。它表示要設定哪個屬性。有一個特殊用法：如果property的值是"*"，表示所有名字和Bean屬性名字比對的請求參數都将被傳遞給相應的屬性set方法。 |
| value | value 屬性是可選的。該屬性用來指定Bean屬性的值。字元串資料會在目标類中通過标準的valueOf方法自動轉換成數字、boolean、Boolean、 byte、Byte、char、Character。例如，boolean和Boolean類型的屬性值（比如"true"）通過 Boolean.valueOf轉換，int和Integer類型的屬性值（比如"42"）通過Integer.valueOf轉換。 value和param不能同時使用，但可以使用其中任意一個。 |
| param | param 是可選的。它指定用哪個請求參數作為Bean屬性的值。如果目前請求沒有參數，則什麼事情也不做，系統不會把null傳遞給Bean屬性的set方法。是以，你可以讓Bean自己提供預設屬性值，隻有當請求參數明确指定了新值時才修改預設屬性值。 |
<jsp:getProperty>動作元素
jsp:getProperty動作提取指定Bean屬性的值，轉換成字元串，然後輸出。文法格式如下：
<jsp:useBean id="myName" ... /> ...<jsp:getProperty name="myName" property="someProperty" .../> 下表是與getProperty相關聯的屬性：
| 屬性 | 描述 |
| name | 要檢索的Bean屬性名稱。Bean必須已定義。 |
| property | 表示要提取Bean屬性的值 |
執行個體
以下執行個體我們使用了Bean:
package com.runoob.main; public class TestBean { private String message = "菜鳥教程"; public String getMessage() { return(message); } public void setMessage(String message) { this.message = message; }} 編譯以上執行個體檔案 TestBean.java ：
$ javac TestBean.java 編譯完成後會在目前目錄下生成一個 TestBean.class 檔案，将該檔案拷貝至目前 JSP 項目的 WebContent/WEB-INF/classes/com/runoob/main 下( com/runoob/main 包路徑，沒有需要手動建立)。
下面是一個 Eclipse 中目錄結構圖：
下面是一個很簡單的例子，它的功能是裝載一個Bean，然後設定/讀取它的message屬性。
現在讓我們在main.jsp檔案中調用該Bean:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鳥教程(runoob.com)</title></head><body> <h2>Jsp 使用 JavaBean 執行個體</h2><jsp:useBean id="test" class="com.runoob.main.TestBean" /> value="菜鳥教程..." /> <p>輸出資訊....</p> <jsp:getProperty name="test" property="message" /> </body></html> 浏覽器通路，執行以上檔案，輸出如下所示：
<jsp:forward>動作元素
jsp:forward動作把請求轉到另外的頁面。jsp:forward标記隻有一個屬性page。文法格式如下所示：
<jsp:forward page="相對 URL 位址" /> 以下是forward相關聯的屬性：
| 屬性 | 描述 |
| page | page屬性包含的是一個相對URL。page的值既可以直接給出，也可以在請求的時候動态計算，可以是一個JSP頁面或者一個 Java Servlet. |
執行個體
以下執行個體我們使用了兩個檔案，分别是： date.jsp 和 main.jsp。
date.jsp 檔案代碼如下：
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><p> 今天的日期是: <%= (new java.util.Date()).toLocaleString()%></p> main.jsp檔案代碼：
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鳥教程(runoob.com)</title></head><body> <h2>forward 動作執行個體</h2><jsp:forward page="date.jsp" /></body></html> 現在将以上兩個檔案放在伺服器的根目錄下，通路main.jsp檔案。顯示結果如下：
今天的日期是: 2016-6-25 14:37:25 <jsp:plugin>動作元素
jsp:plugin動作用來根據浏覽器的類型，插入通過Java插件 運作Java Applet所必需的OBJECT或EMBED元素。
如果需要的插件不存在，它會下載下傳插件，然後執行Java元件。 Java元件可以是一個applet或一個JavaBean。
plugin動作有多個對應HTML元素的屬性用于格式化Java 元件。param元素可用于向Applet或 Bean 傳遞參數。
以下是使用plugin 動作元素的典型執行個體:
<jsp:plugin type="applet" codebase="dirname" code="MyApplet.class" width="60" height="80"> <jsp:param name="fontcolor" value="red" /> <jsp:param name="background" value="black" /> <jsp:fallback> Unable to initialize Java Plugin </jsp:fallback> </jsp:plugin> 如果你有興趣可以嘗試使用applet來測試jsp:plugin動作元素，<fallback>元素是一個新元素，在元件出現故障的錯誤是發送給使用者錯誤資訊。
<jsp:element> 、 <jsp:attribute>、 <jsp:body>動作元素
<jsp:element> 、 <jsp:attribute>、 <jsp:body>動作元素動态定義XML元素。動态是非常重要的，這就意味着XML元素在編譯時是動态生成的而非靜态。
以下執行個體動态定義了XML元素：
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="utf-8"><title>菜鳥教程(runoob.com)</title></head><body><jsp:element name="xmlElement"><jsp:attribute name="xmlElementAttr"> 屬性值</jsp:attribute><jsp:body> XML 元素的主體</jsp:body></jsp:element></body></html> 浏覽器通路以下頁面，輸出結果如下所示：
<jsp:text>動作元素
<jsp:text>動作元素允許在JSP頁面和文檔中使用寫入文本的模闆，文法格式如下：
<jsp:text>模闆資料</jsp:text> 以上文本模闆不能包含其他元素，隻能隻能包含文本和EL表達式（注：EL表達式将在後續章節中介紹）。請注意，在XML檔案中，您不能使用表達式如 ${whatever > 0}，因為>符号是非法的。 你可以使用${whatever gt 0}表達式或者嵌入在一個CDATA部分的值。
<jsp:text><![CDATA[<br>]]></jsp:text> 如果你需要在 XHTML 中聲明DOCTYPE,必須使用到<jsp:text>動作元素，執行個體如下：
<jsp:text><![CDATA[<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "DTD/xhtml1-strict.dtd">]]></jsp:text><head><title>jsp:text action</title></head><body> <books><book><jsp:text> Welcome to JSP Programming</jsp:text></book></books> </body></html> 3. include指令和include動作标簽的差別
<%@include file = “”%>指令是靜态包含
<jsp:include/> 動作标簽是動态包含
原理： 包含與被包含的頁面先各自翻譯成java源檔案，然後再運作時合并在一起。
（先翻譯再合并），動态包含
1） 文法不同
靜态包含文法： <%@incluefile="被包含的頁面"%>
動态包含文法： <jsp:includepage="被包含的頁面">
2）參數傳遞不同
靜态包含不能向被包含頁面傳遞參數
動态包含可以向被包含頁面傳遞參數
3）原理不同
靜态包含： 先合并再翻譯
動态包含： 先翻譯再合并
4. JSTL标簽
1）.JSTL (全名：java standard tag libarary - java标準标簽庫 )
核心标簽庫（c标簽庫）天天用
國際化标簽（fmt标簽庫）
EL函數庫（fn函數庫）
已經過時的兩種
xml标簽庫（x标簽庫）
sql标簽庫（sql标簽庫）
2) .使用步驟
1）導入jstl支援的jar包（标簽背後隐藏的java代碼）
注意：使用javaee5.0的項目自動導入jstl支援jar包
2）使用taglib指令導入标簽庫
<%@tagliburi="tld檔案的uri名稱"prefix="簡寫"%>
3）在jsp中使用标簽
核心标簽庫的重點标簽：
核心标簽是最常用的JSTL标簽。引用核心标簽庫的文法如下：
uri="http://java.sun.com/jsp/jstl/core" %> 1.<c:set></c:set>
儲存資料：<c:set>标簽用于把某一個對象存在指定的域範圍内，或者設定Web域中的java.util.Map類型的屬性對象或JavaBean類型的屬性對象的 屬性。
2.<c:outvalue=""></c:out>
擷取資料： <c:out> 标簽用于輸出一段文本内容到pageContext對象目前儲存的“out”對象中。
3.<c:iftest=""></c:if>
單條件判斷：<c:if test=“”>标簽可以構造簡單的“if-then”結構的條件表達式
4. <c:choose>
<c:whentest=""></c:when>
<c:otherwise></c:otherwise>
</c:choose>
多條件判斷：<c:choose>标簽用于指定多個條件選擇的組合邊界，它必須與<c:when>和<c:otherwise>标簽一起使用。使用<c:choose>，<c:when>和<c:otherwise>三個标簽，可以構造類似“if-else if-else”的複雜條件判斷結構。
5.<c:forEach></c:forEach>
<c:forTokensitems=""delims=""></c:forTokens>
循環資料：<c:forEach>标簽用于對一個集合對象中的元素進行循環疊代操作，或者按指定的次數重複疊代執行标簽體中的内容。
<c:forTokens>用來浏覽一字元串中所有的成員，其成員是由定義符号所分隔的
6.<c:redirect></c:redirect>
重定向：<c:redirect>标簽用于實作請求重定向
7.<c:remove>标簽
用于删除各種Web域中的屬性
8.<c:catch>标簽
用于捕獲嵌套在标簽體中的内容抛出的異常，其文法格式如下：<c:catch [var="varName"]>nestedactions</c:catch>
9.<c:param>标簽
在JSP頁面進行URL的相關操作時，經常要在URL位址後面附加一些參數。<c:param>标簽可以嵌套在<c:import>、<c:url>或<c:redirect>标簽内，為這些标簽所使用的URL位址附加參數。
10.<c:import>标簽,實作include操作
11.<c:url>标簽
用于在JSP頁面中構造一個URL位址，其主要目的是實作URL重寫。URL重寫就是将會話辨別号以參數形式附加在URL位址後面
格式化标簽
JSTL格式化标簽用來格式化并輸出文本、日期、時間、數字。引用格式化标簽庫的文法如下：
uri="http://java.sun.com/jsp/jstl/fmt" %> | 标簽 | 描述 |
| <fmt:formatNumber> | 使用指定的格式或精度格式化數字 |
| <fmt:parseNumber> | 解析一個代表着數字，貨币或百分比的字元串 |
| <fmt:formatDate> | 使用指定的風格或模式格式化日期和時間 |
| <fmt:parseDate> | 解析一個代表着日期或時間的字元串 |
| <fmt:bundle> | 綁定資源 |
| <fmt:setLocale> | 指定地區 |
| <fmt:setBundle> | 綁定資源 |
| <fmt:timeZone> | 指定時區 |
| <fmt:setTimeZone> | 指定時區 |
| <fmt:message> | 顯示資源配置檔案資訊 |
| <fmt:requestEncoding> | 設定request的字元編碼 |
JSTL函數
JSTL包含一系列标準函數，大部分是通用的字元串處理函數。引用JSTL函數庫的文法如下：
uri="http://java.sun.com/jsp/jstl/functions" %> | 函數 | 描述 |
| fn:contains() | 測試輸入的字元串是否包含指定的子串 |
| fn:containsIgnoreCase() | 測試輸入的字元串是否包含指定的子串，大小寫不敏感 |
| fn:endsWith() | 測試輸入的字元串是否以指定的字尾結尾 |
| fn:escapeXml() | 跳過可以作為XML标記的字元 |
| fn:indexOf() | 傳回指定字元串在輸入字元串中出現的位置 |
| fn:join() | 将數組中的元素合成一個字元串然後輸出 |
| fn:length() | 傳回字元串長度 |
| fn:replace() | 将輸入字元串中指定的位置替換為指定的字元串然後傳回 |
| fn:split() | 将字元串用指定的分隔符分隔然後組成一個子字元串數組并傳回 |
| fn:startsWith() | 測試輸入字元串是否以指定的字首開始 |
| fn:substring() | 傳回字元串的子集 |
| fn:substringAfter() | 傳回字元串在指定子串之後的子集 |
| fn:substringBefore() | 傳回字元串在指定子串之前的子集 |
| fn:toLowerCase() | 将字元串中的字元轉為小寫 |
| fn:toUpperCase() | 将字元串中的字元轉為大寫 |
| fn:trim() | 移除首位的空白符 |
EL函數庫（fn函數庫）的使用：
<%--contains 是否存在一個變量--%>
${fn:contains("aaa","a")}
<%--containsIgnoreCase 是否存在一個變量（忽略大小寫）--%>
${fn:containsIgnoreCase("aaa","a")}
<%--fn:endsWith 以什麼結尾--%>
${fn:endsWith("bca","a")}
<%--fn:startsWith 以什麼結尾--%>
${fn:startsWith("acb","a")}
<%--indexOf 是否存在某個字元或字元串--%>
${fn:indexOf("acb","a")}
<%--length 某個對象的長度（字元長度）--%>
${fn:length("acbAAAA哈哈")}
<%--substring截取某個字元長度傳回一個新字元--%>
${fn:substring("acbAAAA哈哈",0,3)}
<%--substringAfter第一次出現a的位置開始截取--%>
${fn:substringAfter("acbAAAA哈哈","a")}
<%--substringBefore最後一個出現‘c’的位置開始截取--%>
${fn:substringBefore("bcbAAcAAa","c")}
<%--toLowerCase轉換為小寫--%>
${fn:toLowerCase("bcbAAcAAa")}
<%--toUpperCase轉換為大寫--%>
${fn:toUpperCase("bcbAAcAAa")}
<%--trim轉換為大寫--%>
${fn:trim(" bcbAAcAAa ")}
<%--split以某個字元切分為一個數組 （數組的類型[Ljava.lang.String;@67cc9a9a）--%>
${fn:split("1,2,3,45,6",",")}
<%--join給每個數組中的元素拼接一個字元--%>
${fn:join((fn:split("1,2,3,45,6",",")),"haha")}
<%-- escapeXml将某個标簽已字元串格式輸出整個标簽 --%>
${fn:escapeXml("<h1>哈哈<h1>")}
<%-- 與c标簽庫中的out标簽中的 c:out标簽的escapeXml屬性相同 --%>
<c:out escapeXml="true"value="<h1>哈哈<h1>"></c:out>
5. 自定義标簽：
jsp自定義标簽 Tag檔案版
1.在WEB-INF/tags/if.tag
<%@taglanguage="java"pageEncoding="UTF-8"%>
<%@attributename="text"required="true"type="java.lang.Boolean"%>
<%
if(text){
%>
<jsp:doBody></jsp:doBody>
<%
}
%>
這裡要注意tag檔案隻能放在如下位置:
1.WEB-INF/tags
2.WEB-INF/tags的子目錄
3.WEB-INF/lib中jar包的META-INF/tags
4.WEB-INF/lib中jar包的META-INF/tags下的子目錄
5.jar包中的tag檔案需要tld
添加jstl.jar與standard.jar到WEB-INF/lib目錄,還有一點就是上面标紅的部分:不要使用http://java.sun.com/jstl/core這個url,否則會報foreach中的item屬性有問題
2.在jsp中的使用
<%@pageimport="java.util.ArrayList"%>
<%@pageimport="java.util.List"%>
<%@ page language="java"contentType="text/html;charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib tagdir="/WEB-INF/tags"prefix="my"%>
<!DOCTYPEhtmlPUBLIC "-//W3C//DTDHTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<metahttp-equiv="Content-Type"content="text/html;charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%--自定義if标簽 --%>
<my:iftext="${1==1}">
<%--自定義out标簽 --%>
<my:outvalue="<h1>哈哈哈</h1>"></my:out>
</my:if>
</body>
</html>
jsp 自定義标簽
jsp标簽有兩組api
JspTag ->SimpleTag ->SimpleTagSupport
JspTag ->Tag ->IterationTag->BodyTag
第二組是classic的,比較早的使用方式,doStartTag(),doEndTag()有N多傳回值的那種,使用起來也确實不友善,今天學到了另一個使用第一組api方式的,讓人大快人心,貼碼
例子是一個Select的标簽,支援動态屬性設定
1.編寫标簽類
publicclass SelectTagHandler extends SimpleTagSupport implements DynamicAttributes {
private static final String ATTR_TEMPLATE = "%s='%s'";
private static final String OPTION_TEMPLATE = "<optionvalue='%1$s'>%1$s</option>";
private List optionsList;
private String name;
private String size;
private Map<String, Object> tagAttrs = new HashMap<String,Object>();
publicvoid setName(String name) {
this.name = name;
}
publicvoid setSize(String size) {
this.size = size;
}
publicvoid setOptionsList(List optionsList) {
this.optionsList = optionsList;
}
@Override
public void doTag() throws JspException, IOException {
PageContext pageContext = (PageContext) getJspContext();
JspWriter out = pageContext.getOut();
out.print("<select ");
out.print(String.format(ATTR_TEMPLATE, "name",this.name));
out.print(String.format(ATTR_TEMPLATE, "size",this.size));
for(String attrName : tagAttrs.keySet()) {
StringattrDefinition = String.format(ATTR_TEMPLATE, attrName,tagAttrs.get(attrName));
out.print(attrDefinition);
}
out.print(">");
for(Object option : this.optionsList) {
StringoptionTag = String.format(OPTION_TEMPLATE, option.toString());
out.println(optionTag);
}
out.println("</select>");
}
@Override
publicvoid setDynamicAttribute(String uri, String name, Object value) throwsJspException {
tagAttrs.put(name,value);
}
}
看到沒,代碼如此的簡潔,動态屬性配置也十分的友善,不用寫N多個setter與getter方法.
2.編寫tld檔案WebRoot/tld/select.tld
<?xmlversion="1.0" encoding="UTF-8" ?>
<taglibxmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3g.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"
version="2.0">
<tlib-version>1.2</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>Forms Taglib</short-name>
<uri>http://hi.baidu.com/tags/forms</uri>
<description>
An example tab library of replacements for the html form tags.
</description>
<tag>
<name>select</name>
<tag-class>com.baidu.hi.tag.SelectTagHandler</tag-class>
<body-content>empty</body-content>
<attribute>
<name>optionsList</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
<type>java.util.List</type>
</attribute>
<attribute>
<name>name</name>
<required>true</required>
</attribute>
<attribute>
<name>size</name>
<required>true</required>
</attribute>
<dynamic-attributes>true</dynamic-attributes>
</tag>
</taglib>
3.在jsp中的使用
<%@page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ page import="java.util.*" %>
<%@ taglib prefix="formTags" uri="/tld/select.tld"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
<%@page import="java.util.ArrayList"%><html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%
List<String> colorList = new ArrayList<String>();
colorList.add("red");
colorList.add("blue");
colorList.add("white");
request.setAttribute("colorList",colorList);
%>
<form action="" method="post">
<formTags:select name="color" size="1"optionsList="${requestScope.colorList}" style="width:140px"/>
</form>
</body>
</html>