Servlet,JSP(5)(JSP隱式對象和語法元素：指令、腳本元素和動做）

時間 2019-12-09

原文原文鏈接

1，JSP

版本：html

Servlet有兩個缺點是沒法克服的：
1，寫在Servlet中的全部HTML標籤必須包含Java字符串，這使得處理HTTP響應報文的工做十分煩瑣；
2，全部的文本和HTML標記是硬編碼，致使即便是表現層的微小變化，如改變背景顏色，也須要從新編譯。

JavaServer Pages（JSP）解決了上述兩個問題。同時，JSP不會取代Servlet，相反，它們具備互補性。

一個JSP頁面不一樣於一個Servlet的另外一個方面是：前者不須要添加註解或在部署描述符中配置映射URL。

補充：java

能夠用標準語法或XML語法編寫JSP。
用XML語法編寫的JSP頁面被稱爲JSP文檔。
但不多用XML語法編寫JSP，不詳述。

JSP頁面本質上是一個Servlet。

JSP頁面在JSP容器中運行，一個Servlet容器一般也是JSP容器。
例如，Tomcat就是一個Servlet/JSP容器。

當一個JSP頁面第一次被請求時，Servlet/JSP容器主要作如下兩件事情：express

（1）轉換JSP頁面到JSP頁面實現類，
該實現類是一個實現javax.servlet.jsp.JspPage接口或子接口javax.servlet.jsp.HttpJspPage的Java類。

JspPage是javax.servlet.Servlet的子接口，這使得每個JSP頁面都是一個Servlet。
該實現類的類名由Servlet/JSP容器生成。若是出現轉換錯誤，則相關錯誤信息將被髮送到客戶端。

（2）若是轉換成功，Servlet/JSP容器隨後編譯該Servlet類，並裝載和實例化該類，像其餘正常的Servlet同樣執行生命週期操做。

ps:總結：apache

jsp頁面轉換爲servlet過程： 1，jsp轉換爲了servlet接口的子接口JspPage的子接口HttpJspPage的java類（即servlet類）。
2，編譯該HttpJspPage類型的servlet。

jsp頁面重複被請求時：json

對於同一個JSP頁面的後續請求，Servlet/JSP容器會先檢查JSP頁面是否被修改過。
若是是，則該JSP頁面會被從新翻譯、編譯並執行。
若是不是，則執行已經在內存中的JSP Servlet。

解決：一個JSP頁面的第一次調用的很耗時問題：api

1，配置應用程序，使全部的JSP頁面在應用程序啓動時被調用，而不是在第一次請求時調用。
2，預編譯JSP頁面，並將其部署爲Servlet。

JSP自帶的API包含4個包：瀏覽器

1，javax.servlet.jsp。
包含用於Servlet/JSP容器將JSP頁面翻譯爲Servlet的核心類和接口。

其中的兩個重要成員是JspPage和HttpJspPage接口。
全部的JSP頁面實現類必須實現JspPage或HttpJspPage接口。
在HTTP環境下，實現HttpJspPage接口是顯而易見的選擇。

2，javax.servlet.jsp.tagext。包括用於開發自定義標籤的類型。
3，javax.el。提供了統一表達式語言的API。
4，javax.servlet.jsp.el。提供了一組必須由Servlet/JSP容器支持，以便在JSP頁面中使用表達式語言的類

jsp api:
https://docs.oracle.com/javaee/7/api/index.html?javax/servlet/jsp/package-summary.html

注意：通常不多直接使用jspAPI,而是讓容器自動調用tomcat

ps:總結：安全

減小jsp第一次請求編譯過程的方式：
1，啓動服務器編譯jsp
2，主動將jsp直接編譯成servlet

2，jsp轉換servlet：

JSP頁面能夠包含模板數據和語法元素。

1，語法元素是一些具備特殊意義的JSP轉換符。
   3個語法元素（指令、腳本元素和動做）

2，除去語法元素外的一切是模板數據。
   模板數據會原樣發送給瀏覽器。
   例如，JSP頁面中的HTML標記和文字都是模板數據。

補充：經常使用模板引擎服務器

JSP ，velocity，freemark

一個名爲welcome.jsp的JSP頁面

<html>
<head><title>Welcome</title></head>
<body>
Welcome
</body>
</html>

welcome.jsp頁面在第一次請求時被翻譯成名爲welcome_jsp的Servlet。

你能夠在Tomcat工做目錄下的子目錄中找到生成的Servlet，
該Servlet繼承自org.apache.jasper. runtime.HttpJspBase，
（這是一個抽象類，
繼承自javax.servlet.http.HttpServlet並實現javax.servlet.jsp.HttpJspPage）

package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
public final class welcome_jsp extends org.apache.jasper.runtime.HttpJspBase
                         implements org.apache.jasper.runtime.JspSourceDependent{

private static final javax.servlet.jsp.JspFactory _jspxFact
                      ory =javax.servlet.jsp.JspFactory.getDefaultFactory();
private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;
private javax.el.ExpressionFactory _el_expressionfactory;
private org.apache.tomcat.InstanceManager _jsp_instancemanager;

public java.util.Map<java.lang.String,java.lang.Long>、getDependants() {
       return _jspx_dependants;
}

public void _jspInit() {
 _el_expressionfactory =_jspxFactory.getJspApplicationContext(getServletConfig().getServletContext())
    .getExpressionFactory();

_jsp_instancemanager =org.apache.jasper.runtime.InstanceManagerFactory
  .getInstanceManager(getServletConfig());
}

public void _jspDestroy() {}

public void _jspService(final javax.servlet.http.HttpServletRequest request, 
     final javax.servlet.http.HttpServletResponse response)
     throws java.io.IOException, javax.servlet.ServletException {

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");
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;

out.write("<html>\n");
out.write("<head><title>Welcome</title></head>\n");
out.write("<body>\n");
out.write("Welcome\n");
out.write("</body>\n");
out.write("</html>");
} catch (java.lang.Throwable t) {
if (!(t instanceof javax.servlet.jsp.SkipPageException)){

   out = _jspx_out;
   if (out != null && out.getBufferSize() != 0)
   try {
      out.clearBuffer();
   } catch (java.io.IOException e) {}

   if (_jspx_page_context != null)
   _jspx_page_context.handlePageException(t);

}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}}}

（ps:有點奇怪，爲何有重複的對象引用好比：out 和 _jspx_out ???）

補充：

JSP頁面的主體是_jspService方法。 這個方法被定義在HttpJspPage，並被HttpJspBase的service方法調用。

下面的代碼來自HttpJspBase類：
public final void service(HttpServletRequest request,
HttpServletResponse response) throws ServletException,IOException {
   _jspService(request, response);
}

3，註釋：

JSP支持兩種不一樣的註釋格式：

1）JSP註釋。該註釋記錄頁面中作了什麼。
2）HTML/XHTML註釋。這些註釋將會發送到瀏覽器上。

JSP註釋以「<%--」開始，以「--%>」結束。
下面是一個例子：<%-- retrieve products to display --%>
JSP註釋不會被髮送到瀏覽器端，也不會被嵌套。

HTML/XHTML註釋語法以下：
<!-- [comments here] -->
一個HTML/XHTML註釋不會被容器處理，會原樣發送給瀏覽器。
HTML/XHTML註釋的一個用途是用來肯定JSP頁面自己。
<!-- this is /jsp/store/displayProducts.jspf -->

尤爲是在運行有多個JSP片斷的應用時，會特別有用。
是哪個JSP頁面或片斷產生了相應的HTML片斷。

4，隱式對象

Servlet容器會傳遞幾個對象給它運行的Servlet。

例如，能夠經過Servlet的service方法拿到HttpServletRequest和HttpServletResponse對象，
以及能夠經過init方法訪問到ServletConfig對象。
能夠經過調用HttpServletRequest對象的getSession方法訪問到HttpSession對象。

JSP隱式對象（9個）：

對象                        類型
request         javax.servlet.http.HttpServletRequest
response        javax.servlet.http.HttpServletResponse
out             javax.servlet.jsp.JspWriter
session         javax.servlet.http.HttpSession
application     javax.servlet.ServletContext
config          javax.servlet.ServletConfig
pageContext     javax.servlet.jsp.PageContext
page            javax.servlet.jsp.HttpJspPage （表示當前頁面，通常用不到）
exception       java.lang.Throwable

4.1，request

該隱式對象表明Servlet/JSP容器傳遞給Servlet服務方法的HttpServlet Request對象。

<%
String userName = request.getParameter("userName");
%>

4.2，pageContext

pageContext用於javax.servlet.jsp.PageContext。
它提供了有用的上下文信息，並經過其自說明的方法來訪問各類Servlet相關對象，
如getRequest、getResponse、getServletContext、getServletConfig和getSession。
但在腳本中不是很是有用的，由於能夠更直接地經過隱式對象來訪問request、response、session和application。

PageContext中提供了另外一組有趣的方法：
用於獲取和設置屬性的方法，即getAttribute方法和setAttribute方法。

屬性值可被存儲在4個範圍之一：
頁面、請求、會話和應用程序。
頁面範圍是最小範圍，這裏存儲的屬性只在同一個JSP頁面可用。
請求範圍是指當前的ServletRequest中。
會話範圍指當前的HttpSession中。
應用程序範圍指應用的ServletContext中。

PageContext的setAttribute方法簽名以下：
public abstract void setAttribute(java.lang.String name, java.lang.Object value, int scope)
其中，scope的取值範圍爲PageContext對象的最終靜態int值：
PAGE_SCOPE、REQUEST_ SCOPE、SESSION_SCOPE和APPLICATION_SCOPE。

若要保存一個屬性到頁面範圍，能夠直接使用setAttribute重載方法：
public abstract void setAttribute(java.lang.String name, java.lang.Object value)

以下腳本將一個屬性保存到ServletRequest中：
<%
//product is a Java object
pageContext.setAttribute("product", product,PageContext.REQUEST_SCOPE);
%>


一樣效果的Java代碼以下:
<%
request.setAttribute("product", product);
%>

4.3，out

隱式對象out引用了一個javax.servlet.jsp.JspWriter對象，
這相似於你在調用HttpServlet Response的getWriter方法時獲得java.io.PrintWriter。
能夠經過調用它的print方法將消息發送到瀏覽器。
例如：
out.println("Welcome");

隱式對象的例子

implicitObjects.jsp頁面
<%@page import="java.util.Enumeration"%>
<html>
<head><title>JSP Implicit Objects</title></head>
<body>
<b>Http headers:</b><br/>
<%
for (Enumeration<String> e = request.getHeaderNames();
e.hasMoreElements(); ){
String header = e.nextElement();
out.println(header + ": " + request.getHeader(header) +
"<br/>");
}
%>
<hr/>
<%
out.println("Buffer size: " + response.getBufferSize() +
"<br/>");
out.println("Session id: " + session.getId() + "<br/>");
out.println("Servlet name: " + config.getServletName() +
"<br/>");
out.println("Server info: " + application.getServerInfo());
%>
</body>
</html>

View Code

該頁面產生了以下內容：
Http headers:
host: localhost:8080
user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_5_8)
AppleWebKit/534.50.2 (KHTML, like Gecko) Version/5.0.6
Safari/533.22.3
accept:text/html,application/xhtml+xml,application/xml;q=0.9,*/
*;q=0.8
accept-language: en-us
accept-encoding: gzip, deflate
connection: keep-alive
Buffer size: 8192
Session id: 561DDD085ADD99FC03F70BDEE87AAF4D
Servlet name: jsp
Server info: Apache Tomcat/7.0.14

View Code

注意，在默認狀況下，JSP編譯器會將JSP頁面的內容類型設爲text/html。

若是要使用不一樣的類型，則須要經過調用response.setContentType()或者使用頁面指令來設置內容類型。
例如，下面就是將內容類型設置爲text/json：
response.setContentType("text/json");

5，指令

指令是JSP語法元素的第一種類型。
它們指示JSP轉換器如何翻譯JSP頁面爲Servlet。
JSP 2.2定義了多個指令，但page和include最重要，其餘 taglib、tag、attribute以及variable。

5.1，page指令

可使用page指令來控制JSP轉換器轉換當前JSP頁面的某些方面。
例如，能夠告訴JSP用於轉換隱式對象out的緩衝器的大小、內容類型，以及須要導入的Java類型，等等。

page指令的語法以下：

<%@ page attribute1="value1" attribute2="value2" ... %>
 @和page間的空格不是必須的，attribute一、attribute2等是page指令的屬性。

以下是page指令屬性列表：

import：定義一個或多個本頁面中將被導入和使用的java類型。
例如：import="java.util.List"將導入List接口。
可使用通配符「*」來引入整個包，相似import="java.util.*"。
能夠經過在兩個類型間加入「,」分隔符來導入多個類型，如
import="java.util.ArrayList、java.util.Calendar、java.io.PrintWriter"。
此外，JSP默認導入以下包：java.lang、javax.servlet、javax.servlet.http、javax.servlet.jsp。

session：值爲True，本頁面加入會話管理；值爲False則相反。
默認值爲True，訪問該頁面時，若當前不存在javax.servlet.http.HttpSession實例，則會建立一個。

buffer：以KB爲單位，定義隱式對象out的緩衝大小。
必須以KB後綴結尾。
默認大小爲8KB或更大（取決於JSP容器）。
該值能夠爲none，這意味着沒有緩衝，全部數據將直接寫入PrintWriter。

autoFlush：默認值爲True。 若值爲True，則當輸出緩衝滿時會自寫入輸出流。
而值爲False，則僅當調用隱式對象的flush方法時，纔會寫入輸出流。所以，若緩衝溢出，則會拋出異常。

isThreadSafe：定義該頁面的線程安全級別。 不推薦使用 JSP 參數，由於使用該參數後，會生成一些Servlet容器已過時的代碼。

info：返回調用容器生成的Servlet類的getServletInfo方法的結果。

errorPage：定義當出錯時用來處理錯誤的頁面。
isErrorPage：標識本頁是一個錯誤處理頁面。
contentType：定義本頁面隱式對象response的內容類型，默認是text/html。

pageEncoding：定義本頁面的字符編碼，默認是ISO-8859-1。
isELIgnored：配置是否忽略EL表達式。EL是Expression Language的縮寫。
language：定義本頁面的腳本語言類型，默認是Java，這在JSP 2.2中是惟一的合法值。
extends：定義JSP實現類要繼承的父類。這個屬性的使用場景很是罕見，僅在很是特殊理由下使用。
deferredSyntaxAllowedAsLiteral：定義是否解析字符串中出現「#{」符號，默認是False。
                                「{# 」是一個表達式語言的起始符號。
trimDirectiveWhitespaces：定義是否不輸出多餘的空格/空行，默認是False。

5.2，include指令

可使用include指令將其餘文件中的內容包含到當前JSP頁面。
一個頁面中能夠有多個include指令。
若存在一個內容會在多個不一樣頁面中使用或一個頁面不一樣位置使用的場景，則將該內容模塊化到一個include文件很是有用。

include指令的語法以下：

<%@ include file="url"%>

其中，@和include間的空格不是必須的，URL爲被包含文件的相對路徑，
若URL以一個斜槓（/）開始，則該URL爲文件在服務器上的絕對路徑，不然爲當前JSP頁面的相對路徑。

JSP轉換器處理include指令時，將指令替換爲指令所包含文件的內容。
換句話說，若是編寫在清單3.4的copyright.jspf文件，以及主文件清單3.5的main.jsp頁面：

清單3.4　copyright.jspf文件
<hr/>
&copy;2015 BrainySoftware
<hr/>

清單3.5　main.jsp頁面
<html>
<head><title>Including a file</title></head>
<body>
This is the included content: <hr/>
<%@ include file="copyright.jspf"%>
</body>
</html>

則在main.jsp頁面中應用include指令和以下頁面的效果是同樣的：
<html>
<head><title>Including a file</title></head>
<body>
This is the included content: <hr/>
<hr/>
&copy；2015 BrainySoftware
<hr/>
</body>
</html>

如上示例中，爲保證include指令能正常工做，copyright.jspf文件必須同main.jsp位於相同的目錄。
按照慣例，以JSPF爲擴展名的文件表明JSP fragement。
雖然JSP fragement如今被稱爲JSP segment，但爲保證一致性，JSPF後綴名依然被保留。

View Code

注意，include指令也能夠包含靜態HTML文件。

6，腳本元素

一個腳本程序是一個Java代碼塊，以<%符號開始，以%>符號結束。

使用腳本程序（scriptletTest.jsp）

<%@page import="java.util.Enumeration"%>
<html>
<head><title>Scriptlet example</title></head>
<body>
<b>Http headers:</b><br/>
<%-- first scriptlet --%>
<%
　　for (Enumeration<String> e = request.getHeaderNames();
　　　　　　　e.hasMoreElements(); ){
　　　　　String header = e.nextElement();
　　　　　out.println(header + ": " + request.getHeader(header) +
　　　　　　　　　　"<br/>");
　　}
　　String message = "Thank you.";
%>
<hr/>
<%-- second scriptlet --%>
<%
　　out.println(message);
%>
</body>
</html>

定義在一個腳本程序中的變量能夠被其後續的腳本程序使用。

1)表達式(ps:輸出返回值)

每一個表達式都會被JSP容器執行，並使用隱式對象out的打印方法輸出結果。
表達式以「<%=」開始，並以「%>」結束。

Today is <%=java.util.Calendar.getInstance().getTime()%>

注意，表達式無須分號結尾。

JSP容器首先執行java.util.Calendar.getInstance().getTime()，並將計算結果傳遞給out.print()，
這與以下腳本程序的效果同樣：
Today is
<%
out.print(java.util.Calendar.getInstance().getTime());
%>

2）聲明（即全局成員）

能夠聲明能在JSP頁面中使用的變量和方法。
聲明以「<%！」開始，並以「%>」結束。

declarationTest.jsp聲明瞭一個getTodaysDate的方法

<%!
public String getTodaysDate() {
return new java.util.Date();
}
%>
<html>
<head><title>Declarations</title></head>
<body>
Today is <%=getTodaysDate()%>
</body>
</html>

在JSP頁面中，一個聲明能夠出如今任何地方，而且一個頁面能夠有多個聲明。

可使用聲明來重寫JSP頁面，實現類的init和destroy方法

經過聲明jspInit方法，來重寫init方法。
經過聲明jspDestroy方法，來重寫destory方法。

這兩種方法說明以下：
jspInit。這種方法相似於 javax.servlet.Servlet 的 init方法。
JSP 頁面在初始化時調用jspInit。
不一樣於init方法，jspInit沒有參數。
還能夠經過隱式對象config訪問ServletConfig對象。
jspDestroy。這種方法相似於Servlet的destroy方法，在JSP頁面將被銷燬時調用。

lifeCycle.jsp頁面演示瞭如何重寫jspInit和jspDestroy

<%!
public void jspInit() {
System.out.println("jspInit ...");
}
public void jspDestroy() {
System.out.println("jspDestroy ...");
}
%>
<html>
<head><title>jspInit and jspDestroy</title></head>
<body>
Overriding jspInit and jspDestroy
</body>
</html>

lifeCycle.jsp頁面會被轉換成以下Servlet：

package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
public final class lifeCycle_jsp extends org.apache.jasper.runtime.HttpJspBase
        implements org.apache.jasper.runtime.JspSourceDependent
{
public void jspInit() {
System.out.println("jspInit ...");
}

public void jspDestroy() {
System.out.println("jspDestroy ...");
}

private static final javax.servlet.jsp.JspFactory _jspxFact
                     ory =javax.servlet.jsp.JspFactory.getDefaultFactory();
private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;
private javax.el.ExpressionFactory _el_expressionfactory;
private org.apache.tomcat.InstanceManager _jsp_instancemanager;
public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
      return _jspx_dependants;
}

public void _jspInit() {
_el_expressionfactory =_jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).
    getExpressionFactory();
_jsp_instancemanager =
     org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
}

public void _jspDestroy() {
}

public void _jspService(final javax.servlet.http.HttpServletRequest request, final
    javax.servlet.http.HttpServletResponse response)throws java.io.IOException,
        javax.servlet.ServletException {
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");
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;
out.write("\n");
out.write("<html>\n");
out.write("<head><title>jspInit and jspDestroy" +
           "</title></head>\n");
out.write("<body>\n");
out.write("Overriding jspInit and jspDestroy\n");
out.write("</body>\n");
out.write("</html>");
} catch (java.lang.Throwable t) {
if (!(t instanceof
javax.servlet.jsp.SkipPageException)){
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
try {
out.clearBuffer();
} catch (java.io.IOException e) {
}
if (_jspx_page_context != null)
_jspx_page_context.handlePageException(t);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context)
;}}}

注意生成的Servlet類中的jspInit和jspDestroy方法。
如今能夠用以下URL訪問lifeCycle.jsp:

http://localhost:8080/app03a/lifeCycle.jsp

第一次訪問頁面時，能夠在控制檯上看到「jspInit...」，
以及在Servlet/JSP容器關閉時看到「jspDestory...」。

3)禁用腳本元素

隨着JSP 2.0對錶達式語言的增強，
推薦：在JSP頁面中用EL訪問服務器端對象且不寫Java代碼。
所以，從JSP 2.0起，
能夠經過在部署描述符中的<jsp-property-group>定義一個scripting-invalid元素，來禁用腳本元素。

<jsp-property-group>
<url-pattern>*.jsp</url-pattern>
<scripting-invalid>true</scripting-invalid>
</jsp-property-group>

7，動做

動做是第三種類型的語法元素，它們被轉換成Java代碼來執行操做，如訪問一個Java對象或調用方法。

本節僅討論全部JSP容器支持的標準動做。
除標準外，還能夠建立自定義標籤執行某些操做。

7.1，useBean

useBean將建立一個關聯Java對象的腳本變量。
這是早期分離的表示層和業務邏輯的手段。
隨着其餘技術的發展，如自定義標籤和表達語言，如今不多使用useBean方式。

useBeanTest.jsp頁面是一個示例，
它建立一個java.util.Date實例，並賦值給名爲today的腳本變量，而後在表達式中使用。

useBeanTest.jsp頁面
<html>
<head>
<title>useBean</title>
</head>
<body>
<jsp:useBean id="today" class="java.util.Date"/>
<%=today%>
</body>
</html>

在Tomcat中，上述代碼會被轉換爲以下代碼：

java.util.Date today = null;
today = (java.util.Date) _jspx_page_context.
        getAttribute("today",javax.servlet.jsp.PageContext.REQUEST_SCOPE);

if (today == null) {
today = new java.util.Date();
_jspx_page_context.setAttribute("today", today,javax.servlet.jsp.PageContext.REQUEST_SCOPE);
}

7.2，setProperty和getProperty

setProperty動做可對一個Java對象設置屬性，而getProperty則會輸出Java對象的一個屬性。

getSetPropertyTest.jsp展現如何設置和輸出定義在Employee類實例的firstName屬性。

Employee類
package app03a;
public class Employee {
private String id;
private String firstName;
private String lastName;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}

getSetPropertyTest.jsp頁面 <html>
<head>
<title>getProperty and setProperty</title>
</head>
<body>
<jsp:useBean id="employee" class="app03a.Employee"/>
<jsp:setProperty name="employee" property="firstName" value="Abigail"/>
First Name: 
<jsp:getProperty name="employee" property="firstName"/>
</body>
</html>

7.3，include

include動做用來動態地引入另外一個資源。
能夠引入另外一個JSP頁面，也能夠引入一個Servlet或一個靜態的HTML頁面。

jspIncludeTest.jsp頁面使用include動做來引入menu.jsp頁面。

jspIncludeTest.jsp頁面
<html>
<head>
<title>Include action</title>
</head>
<body>
<jsp:include page="jspf/menu.jsp">
<jsp:param name="text" value="How are you?"/>
</jsp:include>
</body>
</html>

include指令和include動做區別：

對於include指令，資源引入發生在頁面轉換時，即當JSP容器將頁面轉換爲生成的Servlet時。

而對於include動做，資源引入發生在請求頁面時。
所以，使用include動做是能夠傳遞參數的，而include指令不支持。

第二個不一樣是，include指令對引入的文件擴展名不作特殊要求。

但對於include動做，若引入的文件需以JSP頁面處理，則其文件擴展名必須是JSP。
若使用.jspf爲擴展名，則該頁面被看成靜態文件。

7.4，forward

forward將當前頁面轉向到其餘資源。

下面代碼將從當前頁轉向到login.jsp頁面：

<jsp:forward page="jspf/login.jsp">
<jsp:param name="text" value="Please login"/>
</jsp:forward>

8，錯誤處理

JSP提供了很好的錯誤處理能力。
除了在Java代碼中可使用try語句，還能夠指定一個特殊頁面。
當應用頁面遇到未捕獲的異常時，用戶將看到一個精心設計的網頁解釋發生了什麼，而不是一個用戶沒法理解的錯誤信息。

page指令的isErrorPage屬性（屬性值必須爲True）來標識一個JSP頁面是錯誤頁面

<%@page isErrorPage="true"%>
<html>
<head><title>Error</title></head>
<body>
An error has occurred. <br/>
Error message:
<%
out.println(exception.toString());
%>
</body>
</html>

其餘須要防止未捕獲的異常的頁面使用page指令的errorPage屬性來指向錯誤處理頁面。

buggy.jsp頁面就使用了錯誤處理程序。
buggy.jsp頁面
<%@page errorPage="errorHandler.jsp"%>
Deliberately throw an exception
<%
Integer.parseInt("Throw me");
%>

運行的buggy.jsp頁面會拋出一個異常，不會看到由Servlet/JSP容器生成錯誤消息。
相反，會看到errorHandler.jsp頁面的內容。

ps:總結：3個語法元素：指令、腳本元素和動做

指令:至關於一種配置的參數
腳本:至關於拼接進入java類
動做:至關於方法的佔位符

Servlet,JSP(5)(JSP隱式對象和語法元素：指令、腳 本元素和動做）

1，JSP

2，jsp轉換servlet：

JSP頁面能夠包含模板數據和語法元素。

3，註釋：

4，隱式對象

4.1，request

4.2，pageContext

4.3，out

隱式對象的例子

5，指令

5.1，page指令

5.2，include指令

6，腳本元素

1)表達式(ps:輸出返回值)

2）聲明（即全局成員）

3)禁用腳本元素

7，動做

7.1，useBean

7.2，setProperty和getProperty

7.3，include

include指令和include動做區別：

7.4，forward

8，錯誤處理

Servlet,JSP(5)(JSP隱式對象和語法元素：指令、腳本元素和動做）