整合營銷服務商
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
JavaBean是特殊的Java類，使用J ava語言書寫，并且遵守JavaBean API規范。
接下來給出的是JavaBean與其它Java類相比而言獨一無二的特征：
提供一個默認的無參構造函數。
需要被序列化并且實現了Serializable接口。
可能有一系列可讀寫屬性。
可能有一系列的"getter"或"setter"方法。
JavaBean屬性
一個JavaBean對象的屬性應該是可訪問的。這個屬性可以是任意合法的Java數據類型，包括自定義Java類。
一個JavaBean對象的屬性可以是可讀寫，或只讀，或只寫。JavaBean對象的屬性通過JavaBean實現類中提供的兩個方法來訪問：
| 方法 | 描述 |
|---|---|
| getPropertyName() | 舉例來說，如果屬性的名稱為myName，那么這個方法的名字就要寫成getMyName()來讀取這個屬性。這個方法也稱為訪問器。 |
| setPropertyName() | 舉例來說，如果屬性的名稱為myName，那么這個方法的名字就要寫成setMyName()來寫入這個屬性。這個方法也稱為寫入器。 |
一個只讀的屬性只提供getPropertyName()方法，一個只寫的屬性只提供setPropertyName()方法。
JavaBean 程序示例
這是StudentBean.java文件：
package com.runoob;
public class StudentsBean implements java.io.Serializable
{
private String firstName = null;
private String lastName = null;
private int age = 0;
public StudentsBean() {
}
public String getFirstName(){
return firstName;
}
public String getLastName(){
return lastName;
}
public int getAge(){
return age;
}
public void setFirstName(String firstName){
this.firstName = firstName;
}
public void setLastName(String lastName){
this.lastName = lastName;
}
public void setAge(int age) {
this.age = age;
}
}
編譯 StudentBean.java 文件(最后一個實例會用到):
$ javac StudentsBean.java
編譯后獲得 StudentBean.class 文件，將其拷貝到 <JSP 項目>/WebContent/WEB-INF/classes/com/runoob，如下圖所示:
訪問JavaBean
<jsp:useBean> 標簽可以在JSP中聲明一個JavaBean，然后使用。聲明后，JavaBean對象就成了腳本變量，可以通過腳本元素或其他自定義標簽來訪問。<jsp:useBean>標簽的語法格式如下：
<jsp:useBean id="bean 的名字" scope="bean 的作用域" typeSpec/>
其中，根據具體情況，scope的值可以是page，request，session或application。id值可任意只要不和同一JSP文件中其它<jsp:useBean>中id值一樣就行了。
接下來給出的是 <jsp:useBean> 標簽的一個簡單的用法：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<html>
<head>
<title>useBean 實例</title>
</head>
<body>
<jsp:useBean id="date" class="java.util.Date" />
<p>日期為：<%= date %>
</body>
</html>
它將會產生如下結果：
日期為：Tue Jun 28 15:22:24 CST 2016
訪問 JavaBean 對象的屬性
在 <jsp:useBean> 標簽主體中使用 <jsp:getProperty/> 標簽來調用 getter 方法，使用 <jsp:setProperty/> 標簽來調用 setter 方法，語法格式如下：
<jsp:useBean id="id" class="bean 編譯的類" scope="bean 作用域">
<jsp:setProperty name="bean 的 id" property="屬性名"
value="value"/>
<jsp:getProperty name="bean 的 id" property="屬性名"/>
...........
</jsp:useBean>
name屬性指的是Bean的id屬性。property屬性指的是想要調用的getter或setter方法。
接下來給出使用以上語法進行屬性訪問的一個簡單例子：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<html>
<head>
<title>get 和 set 屬性實例</title>
</head>
<body>
<jsp:useBean id="students"
class="com.runoob.StudentsBean">
<jsp:setProperty name="students" property="firstName"
value="小強"/>
<jsp:setProperty name="students" property="lastName"
value="王"/>
<jsp:setProperty name="students" property="age"
value="10"/>
</jsp:useBean>
<p>學生名字:
<jsp:getProperty name="students" property="firstName"/>
</p>
<p>學生姓氏:
<jsp:getProperty name="students" property="lastName"/>
</p>
<p>學生年齡:
<jsp:getProperty name="students" property="age"/>
</p>
</body>
</html>
訪問以上 JSP，運行結果如下：
學生名字: 小強
學生姓氏: 王
學生年齡: 10
如您還有不明白的可以在下面與我留言或是與我探討QQ群308855039，我們一起飛！
培養代碼搬運工哦，想了解更多加:qq:116 159 0055
1、Tip：什么是JSP？
a、JSP全稱是Java Server Pages，它和servle技術一樣，都是SUN公司定義的一種用于開發動態web資源的技術。JSP/Servlet規范。JSP實際上就是Servlet。
b、JSP這門技術的最大的特點在于，寫jsp就像在寫html，但它相比html而言，html只能為用戶提供靜態數據，而Jsp技術允許在頁面中嵌套java代碼，為用戶提供動態數據。
2、Tip：JSP原理
3、JSP最佳實踐
不管是JSP還是Servlet，雖然都可以用于開發動態web資源。但由于這2門技術各自的特點，在長期的軟件實踐中，人們逐漸把servlet作為web應用中的控制器組件來使用，而把JSP技術作為數據顯示模板來使用。
其原因為，程序的數據通常要美化后再輸出：
讓JSP既用java代碼產生動態數據，又做美化會導致頁面難以維護。
讓servlet既產生數據，又在里面嵌套html代碼美化數據，同樣也會導致程序可讀性差，難以維護。
因此最好的辦法就是根據這兩門技術的特點，讓它們各自負責各得，servlet只負責響應請求產生數據，并把數據通過轉發技術帶給jsp，數據的顯示jsp來做。
4、Tip：JSP語法
JSP模版元素
JSP表達式
JSP腳本片斷
JSP注釋
JSP指令
JSP標簽
JSP內置對象
如何查找JSP頁面中的錯誤
5、Tip： JSP模版元素
JSP頁面中的HTML內容稱之為JSP模版元素。
JSP模版元素定義了網頁的基本骨架，即定義了頁面的結構和外觀。
6、Tip： JSP腳本表達式
JSP腳本表達式（expression）用于將程序數據輸出到客戶端
語法：<%= 變量或表達式 %>
舉例：當前時間:<%= new java.util.Date() %>
JSP引擎在翻譯腳本表達式時，會將程序數據轉成字符串，然后在相應位置用out.print(…) 將數據輸給客戶端。
JSP腳本表達式中的變量或表達式后面不能有分號（;）。
看一下源文件
7、Tip： JSP腳本片斷（1）
JSP腳本片斷（scriptlet）用于在JSP頁面中編寫多行Java代碼。語法：
<%
多行java代碼
%>
注意：JSP腳本片斷中只能出現java代碼，不能出現其它模板元素，JSP引擎在翻譯JSP頁面中，會將JSP腳本片斷中的Java代碼將被原封不動地放到Servlet的_jspService方法中。
JSP腳本片斷中的Java代碼必須嚴格遵循Java語法，例如，每執行語句后面必須用分號（;）結束。
8、Tip： JSP腳本片斷（2）
在一個JSP頁面中可以有多個腳本片斷，在兩個或多個腳本片斷之間可以嵌入文本、HTML標記和其他JSP元素。
舉例：
<%
int x = 10;
out.println(x);
%>
<p>這是JSP頁面文本</p>
<%
int y = 20;
out.println(y);
%>
多個腳本片斷中的代碼可以相互訪問，猶如將所有的代碼放在一對<%%>之中的情況。如：out.println(x);
正規開發中的JSP中不應出現java腳本：標簽封裝
9、Tip： JSP腳本片斷（3）
單個腳本片斷中的Java語句可以是不完整的，但是，多個腳本片斷組合后的結果必須是完整的Java語句，例如：
<%
for (int i=1; i<5; i++)
{
%>
<H1>www.it315.org</H1>
<%
}
%>
練習：一張表格，打印100行
10、Tip： JSP聲明
JSP頁面中編寫的所有代碼，默認會翻譯到servlet的service方法中， 而Jsp聲明中的java代碼被翻譯到_jspService方法的外面。語法：
<%！
java代碼
%>
所以，JSP聲明可用于定義JSP頁面轉換成的Servlet程序的靜態代碼塊、成員變量和方法 。
多個靜態代碼塊、變量和函數可以定義在一個JSP聲明中，也可以分別單獨定義在多個JSP聲明中。
JSP隱式對象的作用范圍僅限于Servlet的_jspService方法，所以在JSP聲明中不能使用這些隱式對象。
11、Tip： JSP聲明?案例
<%!
static
{
System.out.println("loading Servlet!");
}
private int globalVar = 0;
public void jspInit()
{
System.out.println("initializing jsp!");
}
%>
<%!
public void jspDestroy()
{
System.out.println("destroying jsp!");
}
%>
12、Tip： JSP注釋
JSP注釋的格式：
<%-- 注釋信息 --%>
JSP引擎在將JSP頁面翻譯成Servlet程序時，忽略JSP頁面中被注釋的內容。HTML中的注釋有什么不同，查看源文件解決。
13、Tip： JSP指令
JSP指令（directive）是為JSP引擎而設計的，它們并不直接產生任何可見輸出，而只是告訴引擎如何處理JSP頁面中的其余部分。在JSP 2.0規范中共定義了三個指令：
page指令
Include指令
taglib指令
14、Tip： JSP指令簡介
JSP指令的基本語法格式：
<%@ 指令 屬性名="值" %>
舉例：<%@ page contentType="text/html;charset=utf-8"%>
如果一個指令有多個屬性，這多個屬性可以寫在一個指令中，也可以分開寫。
例如：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.util.Date"%>
也可以寫作：
<%@ page contentType="text/html;charset=gb2312" import="java.util.Date"%>
15、Tip： Page指令
page指令用于定義JSP頁面的各種屬性，無論page指令出現在JSP頁面中的什么地方，它作用的都是整個JSP頁面，為了保持程序的可讀性和遵循良好的編程習慣，page指令最好是放在整個JSP頁面的起始位置。
JSP 2.0規范中定義的page指令的完整語法：
<%@ page
[ language="java" ]
[ extends="package.class" ]
[ import="{package.class | package.*}, ..." ]
[ session=“true | false” ]//true創建session對象
[ buffer="none | 8kb | sizekb" ]
[ autoFlush="true | false" ]
[ isThreadSafe=“true | false” ] false才繼承SingleThreadModel接口
[ info="text" ]
[ errorPage="relative_url" ]
[ isErrorPage="true | false" ]
[ contentType="mimeType [ ;charset=characterSet ]" | "text/html ; charset=ISO-8859-1" ]
[ pageEncoding="characterSet | ISO-8859-1" ]
[ isELIgnored="true | false" ]
errorPage屬性的設置值為一路徑（相對或絕對），如果以“/”開頭，表示相對于當前WEB應用程序的根目錄（注意不是站點根目錄），否則，表示相對于當前頁面。
可以在web.xml文件中使用<error-page>元素為整個WEB應用程序設置錯誤處理頁面，其中的<exception-type>子元素指定異常類的完全限定名，<location>元素指定以“/”開頭的錯誤處理頁面的路徑。
如果設置了某個JSP頁面的errorPage屬性，那么在web.xml文件中設置的錯誤處理將不對該頁面起作用。
16、Tip：使用page指令解決JSP中文亂碼
JSP程序存在有與Servlet程序完全相同的中文亂碼問題
輸出響應正文時出現的中文亂碼問題
讀取瀏覽器傳遞的參數信息時出現的中文亂碼問題
JSP引擎將JSP頁面翻譯成Servlet源文件時也可能導致中文亂碼問題
JSP引擎將JSP源文件翻譯成的Servlet源文件默認采用ISO8859-1編碼，而JSP開發人員可以采用各種字符集編碼來編寫JSP源文件，因此，JSP引擎將JSP源文件翻譯成Servlet源文件時，需要進行字符編碼轉換。
如果JSP文件中沒有說明它采用的字符集編碼，JSP引擎將把它當作默認的ISO8859-1字符集編碼處理。
如何解決JSP引擎翻譯JSP頁面時的中文亂碼問題
通過page指令的contentType屬性說明JSP源文件的字符集編碼
page指令的pageEncoding屬性說明JSP源文件的字符集編碼
17、Tip： include指令
include指令用于引入其它JSP頁面，如果使用include指令引入了其它JSP頁面，那么JSP引擎將把這兩個JSP翻譯成一個servlet。所以include指令引入通常也稱之為靜態引入。
語法：
<%@ include file=“被包含組件的絕對URL或相對URL"%>
其中的file屬性用于指定被引入文件的路徑。路徑以“/”開頭，表示代表當前web應用。
細節：
被引入的文件必須遵循JSP語法。
被引入的文件可以使用任意的擴展名，即使其擴展名是html，JSP引擎也會按照處理jsp頁面的方式處理它里面的內容，為了見明知意，JSP規范建議使用.jspf（JSP fragments）作為靜態引入文件的擴展名。
由于使用include指令將會涉及到2個JSP頁面，并會把2個JSP翻譯成一個servlet，所以這2個JSP頁面的指令不能沖突（除了pageEncoding和導包除外）。
18、Tip： taglib指令
Taglib指令用于在JSP頁面中導入標簽庫，講自定義標簽技術時講。
19、Tip：JSP運行原理和九大隱式對象
每個JSP 頁面在第一次被訪問時，WEB容器都會把請求交給JSP引擎（即一個Java程序）去處理。JSP引擎先將JSP翻譯成一個_jspServlet(實質上也是一個servlet) ，然后按照servlet的調用方式進行調用。
由于JSP第一次訪問時會翻譯成servlet，所以第一次訪問通常會比較慢，但第二次訪問，JSP引擎如果發現JSP沒有變化，就不再翻譯，而是直接調用，所以程序的執行效率不會受到影響。
JSP引擎在調用JSP對應的_jspServlet時，會傳遞或創建9個與web開發相關的對象供_jspServlet使用。JSP技術的設計者為便于開發人員在編寫JSP頁面時獲得這些web對象的引用，特意定義了9個相應的變量，開發人員在JSP頁面中通過這些變量就可以快速獲得這9大對象的引用。
這9個對象分別是哪些，以及作用也是筆試經常考察的知識點。
20、Tip：JSP九大隱式對象
request
response
config
application
exception
Session
page
out
pageContext
21、Tip： out隱式對象
out隱式對象用于向客戶端發送文本數據。
out對象是通過調用pageContext對象的getOut方法返回的，其作用和用法與ServletResponse.getWriter方法返回的PrintWriter對象非常相似。
JSP頁面中的out隱式對象的類型為JspWriter，JspWriter相當于一種帶緩存功能的PrintWriter，設置JSP頁面的page指令的buffer屬性可以調整它的緩存大小，甚至關閉它的緩存。
只有向out對象中寫入了內容，且滿足如下任何一個條件時，out對象才去調用ServletResponse.getWriter方法，并通過該方法返回的PrintWriter對象將out對象的緩沖區中的內容真正寫入到Servlet引擎提供的緩沖區中：
設置page指令的buffer屬性關閉了out對象的緩存功能
out對象的緩沖區已滿; 整個JSP頁面結束
22、Tip： out隱式對象的工作原理圖
<% out.println("aaa"); response.getWriter().write("bbb") %>
23、Tip： out隱式對象的注意事項
同時使用out和response.getwriter()輸出數據。
用JSP實現文件下載。
24、Tip： pageContext對象
pageContext對象是JSP技術中最重要的一個對象，它代表JSP頁面的運行環境，這個對象不僅封裝了對其它8大隱式對象的引用，它自身還是一個域對象，可以用來保存數據。并且，這個對象還封裝了web開發中經常涉及到的一些常用操作，例如引入和跳轉其它資源、檢索其它域對象中的屬性等。
25、Tip：通過pageContext獲得其他對象
getException方法返回exception隱式對象
getPage方法返回page隱式對象
getRequest方法返回request隱式對象
getResponse方法返回response隱式對象
getServletConfig方法返回config隱式對象
getServletContext方法返回application隱式對象
getSession方法返回session隱式對象
getOut方法返回out隱式對象
pageContext封裝其它8大內置對象的意義，思考：如果在編程過程中，把pageContext對象傳遞給一個普通java對象，那么這個java對象將具有什么功能？
25、Tip：pageContext作為域對象
pageContext對象的方法
public void setAttribute(java.lang.String name,java.lang.Object value)
public java.lang.Object getAttribute(java.lang.String name)
public void removeAttribute(java.lang.String name)
pageContext對象中還封裝了訪問其它域的方法
public java.lang.Object getAttribute(java.lang.String name,int scope)
public void setAttribute(java.lang.String name, java.lang.Object value,int scope)
public void removeAttribute(java.lang.String name,int scope)
代表各個域的常量
PageContext.APPLICATION_SCOPE
PageContext.SESSION_SCOPE
PageContext.REQUEST_SCOPE
PageContext.PAGE_SCOPE
findAttribute方法 （*重點，查找各個域中的屬性） EL表達式
26、Tip：引入和跳轉到其他資源
PageContext類中定義了一個forward方法和兩個include方法來分別簡化和替代RequestDispatcher.forward方法和include方法。
方法接收的資源如果以“/”開頭， “/”代表當前web應用。
27、Tip： JSP標簽
JSP標簽也稱之為Jsp Action(JSP動作)元素，它用于在Jsp頁面中提供業務邏輯功能，避免在JSP頁面中直接編寫java代碼，造成jsp頁面難以維護。
28、Tip： JSP常用標簽
<jsp:include>標簽
<jsp:forward>標簽
<jsp:param>標簽
28、Tip： <jsp:include>標簽
<jsp:include>標簽用于把另外一個資源的輸出內容插入進當前JSP頁面的輸出內容之中，這種在JSP頁面執行時的引入方式稱之為動態引入。
語法：
<jsp:include page="relativeURL | <%=expression%>" flush="true|false" />
page屬性用于指定被引入資源的相對路徑，它也可以通過執行一個表達式來獲得。
flush屬性指定在插入其他資源的輸出內容時，是否先將當前JSP頁面的已輸出的內容刷新到客戶端。
29、Tip： <jsp:include>與include指令的比較
<jsp:include>標簽是動態引入， <jsp:include>標簽涉及到的2個JSP頁面會被翻譯成2個servlet，這2個servlet的內容在執行時進行合并。
而include指令是靜態引入，涉及到的2個JSP頁面會被翻譯成一個servlet，其內容是在源文件級別進行合并。
不管是<jsp:include>標簽，還是include指令，它們都會把兩個JSP頁面內容合并輸出，所以這兩個頁面不要出現重復的HTML全局架構標簽，
否則輸出給客戶端的內容將會是一個格式混亂的HTML文檔。
30、Tip： <jsp:forward>標簽
<jsp:forward>標簽用于把請求轉發給另外一個資源。
語法：
<jsp:forward page="relativeURL | <%=expression%>" />
page屬性用于指定請求轉發到的資源的相對路徑，它也可以通過執行一個表達式來獲得。
31、Tip： <jsp:param>標簽
當使用<jsp:include>和<jsp:forward>標簽引入或將請求轉發給其它資源時，可以使用<jsp:param>標簽向這個資源傳遞參數。
語法1：
<jsp:include page="relativeURL | <%=expression%>">
<jsp:param name="parameterName" value="parameterValue|<%= expression %>" />
</jsp:include>
語法2：
<jsp:forward page="relativeURL | <%=expression%>">
<jsp:param name="parameterName" value="parameterValue|<%= expression %>" />
</jsp:include>
<jsp:param>標簽的name屬性用于指定參數名，value屬性用于指定參數值。在<jsp:include>和<jsp:forward>標簽中可以使用多個<jsp:param>標簽來傳遞多個參數。
32、Tip：映射JSP
<servlet>
<servlet-name>SimpleJspServlet</servlet-name>
<jsp-file>/jsp/simple.jsp</jsp-file>
<load-on-startup>1</load-on-startup >
</servlet>
……
<servlet-mapping>
<servlet-name>SimpleJspServlet</servlet-name>
<url-pattern>/xxx/yyy.html</url-pattern>
</servlet-mapping>
33、Tip：如何查找JSP頁面中的錯誤
JSP頁面中的JSP語法格式有問題，導致其不能被翻譯成Servlet源文件，JSP引擎將提示這類錯誤發生在JSP頁面中的位置（行和列）以及相關信息。
JSP頁面中的JSP語法格式沒有問題，但被翻譯成的Servlet源文件中出現了Java語法問題，導致JSP頁面翻譯成的Servlet源文件不能通過編譯，
JSP引擎也將提示這類錯誤發生在JSP頁面中的位置（行和列）以及相關信息。
JSP頁面翻譯成的Servlet程序在運行時出現異常，這與普通Java程序的運行時錯誤完全一樣，Java虛擬機將提示錯誤發生在Servlet源文件中的位置（行和列）以及相關信息。
34、Tip：重點
到此為止，web開發接觸到了4個域對象,這4個域對象是學習web的重點，也是筆試經常考察的知識點
pageContext（稱之為page域）
request（稱之為request域）
session（稱之為session域）
servletContext（稱之為application域）
明確如下問題：
什么是域？
這4個對象的生命周期？
哪種情況下用哪種域對象。
1、request：如果客戶向服務器發請求，產生的數據，用戶看完就沒用了，像這樣的數據就存在request域,像新聞數據，屬于用戶看完就沒用的
2、session：如果客戶向服務器發請求，產生的數據，用戶用完了等一會兒還有用，像這樣的數據就存在session域中，像購物數據，用戶需要看到自己購物信息，并且等一會兒，還要用這個購物數據結帳
3、servletContext：如果客戶向服務器發請求，產生的數據，用戶用完了，還要給其它用戶用，像這樣的數據就存在servletContext域中，像聊天數據。
、JSP
1、什么是JSP？
JSP(Java Server Pages):是以Java語言為基礎的動態網頁開發技術，
特點：
Servlet特點：在Java源碼中嵌入html源碼
JSP特點：在html源碼中嵌入java代碼
JSP就是Servlet
1、tomcat獲得JSP文件后，先將JSP轉成servlet，變成xxx.java(servlet源碼)，
D:\java\tomcat7.0\apache-tomcat-7.0.53\apache-tomcat-7.0.53\work\Catalina\localhost\test01\org\apache\jsp
tomcat安裝目錄 引擎 主機 項目 固定包名 這個之下就是存放著jsp變成的servlet文件.java和編譯文件.class
2、tomcat將java文件編譯成class文件
3、tomcat運行class文件，并將結果輸出到瀏覽器，
實例:
創建一個jsp。查看其轉換后的servlet代碼。
NewFile.jsp
復制代碼
1 <%@ page language="java" contentType="text/html; charset=UTF-8"
2 pageEncoding="UTF-8"%>
3 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
4 <html>
5 <head>
6 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
7 <title>Insert title here</title>
8 </head>
9 <body>
10 hahaha
11 </body>
12 </html>NewFile_jsp.java
復制代碼
1 /*
2 * Generated by the Jasper component of Apache Tomcat
3 * Version: Apache Tomcat/7.0.53
4 * Generated at: 2017-02-22 02:09:08 UTC
5 * Note: The last modified time of this file was set to
6 * the last modified time of the source file after
7 * generation to assist with modification tracking.
8 */
9 package org.apache.jsp;
10
11 import javax.servlet.*;
12 import javax.servlet.http.*;
13 import javax.servlet.jsp.*;
14
15 public final class NewFile_jsp extends org.apache.jasper.runtime.HttpJspBase
16 implements org.apache.jasper.runtime.JspSourceDependent {
17
18 private static final javax.servlet.jsp.JspFactory _jspxFactory =
19 javax.servlet.jsp.JspFactory.getDefaultFactory();
20
21 private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;
22
23 private javax.el.ExpressionFactory _el_expressionfactory;
24 private org.apache.tomcat.InstanceManager _jsp_instancemanager;
25
26 public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
27 return _jspx_dependants;
28 }
29
30 public void _jspInit() {
31 _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
32 _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
33 }
34
35 public void _jspDestroy() {
36 }
37
38 public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
39 throws java.io.IOException, javax.servlet.ServletException {
40
41 final javax.servlet.jsp.PageContext pageContext;
42 javax.servlet.http.HttpSession session = null;
43 final javax.servlet.ServletContext application;
44 final javax.servlet.ServletConfig config;
45 javax.servlet.jsp.JspWriter out = null;
46 final java.lang.Object page = this;
47 javax.servlet.jsp.JspWriter _jspx_out = null;
48 javax.servlet.jsp.PageContext _jspx_page_context = null;
49
50
51 try {
52 response.setContentType("text/html; charset=UTF-8");
53 pageContext = _jspxFactory.getPageContext(this, request, response,
54 null, true, 8192, true);
55 _jspx_page_context = pageContext;
56 application = pageContext.getServletContext();
57 config = pageContext.getServletConfig();
58 session = pageContext.getSession();
59 out = pageContext.getOut();
60 _jspx_out = out;
61
62 out.write("\r\n");
63 out.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\r\n");
64 out.write("<html>\r\n");
65 out.write("<head>\r\n");
66 out.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\r\n");
67 out.write("<title>Insert title here</title>\r\n");
68 out.write("</head>\r\n");
69 out.write("<body>\r\n");
70 out.write("\thahaha\r\n");
71 out.write("</body>\r\n");
72 out.write("</html>");
73 } catch (java.lang.Throwable t) {
74 if (!(t instanceof javax.servlet.jsp.SkipPageException)){
75 out = _jspx_out;
76 if (out != null && out.getBufferSize() != 0)
77 try { out.clearBuffer(); } catch (java.io.IOException e) {}
78 if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
79 else throw new ServletException(t);
80 }
81 } finally {
82 _jspxFactory.releasePageContext(_jspx_page_context);
83 }
84 }
85 }可以看到public final class NewFile_jsp extends org.apache.jasper.runtime.HttpJspBase implements org.apache.jasper.runtime.JspSourceDependent
NewFile_jsp.java繼承自HttpJspBase。來看看HttpJspBase的源碼
HttpJspBase.java
復制代碼
1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package org.apache.jasper.runtime;
19
20 import java.io.IOException;
21
22 import javax.servlet.ServletConfig;
23 import javax.servlet.ServletException;
24 import javax.servlet.http.HttpServlet;
25 import javax.servlet.http.HttpServletRequest;
26 import javax.servlet.http.HttpServletResponse;
27 import javax.servlet.jsp.HttpJspPage;
28
29 import org.apache.jasper.compiler.Localizer;
30
31 /**
32 * This is the super class of all JSP-generated servlets.
33 *
34 * @author Anil K. Vijendran
35 */
36 public abstract class HttpJspBase extends HttpServlet implements HttpJspPage {
37
38 private static final long serialVersionUID = 1L;
39
40 protected HttpJspBase() {
41 }
42
43 @Override
44 public final void init(ServletConfig config)
45 throws ServletException
46 {
47 super.init(config);
48 jspInit();
49 _jspInit();
50 }
51
52 @Override
53 public String getServletInfo() {
54 return Localizer.getMessage("jsp.engine.info");
55 }
56
57 @Override
58 public final void destroy() {
59 jspDestroy();
60 _jspDestroy();
61 }
62
63 /**
64 * Entry point into service.
65 */
66 @Override
67 public final void service(HttpServletRequest request, HttpServletResponse response)
68 throws ServletException, IOException
69 {
70 _jspService(request, response);
71 }
72
73 @Override
74 public void jspInit() {
75 }
76
77 public void _jspInit() {
78 }
79
80 @Override
81 public void jspDestroy() {
82 }
83
84 protected void _jspDestroy() {
85 }
86
87 @Override
88 public abstract void _jspService(HttpServletRequest request,
89 HttpServletResponse response)
90 throws ServletException, IOException;
91 }public abstract class HttpJspBase extends HttpServlet implements HttpJspPage
看到了一個熟悉的類，HttpServlet，我們編寫Servlet時就是繼承自該類，這里也是繼承HttpServlet，并且HttpJspBase的源碼會發現，生命周期也是有init()方法，service()方法，destory()方法，相當于_jspService()方法就是servlet的service()方法的執行，所以說JSP也是一個servlet。
我們在JSP寫的所有html代碼，都會被轉換為servlet中的out.write(html)代碼來輸出。看圖
小總結：
對于jsp轉換成的servlet源碼，之后我們會在進行詳細分析，現在只需要知道jsp中的內容在servlet中被轉換成什么了，在哪里被轉換了即可。其中_jspService()方法的詳細內容下面會講解
注意：jsp 生成java源碼，默認第一次生成，之后直接執行，除非內容修改，具體點說，由于JSP只會在客戶端第一次請求的時候被編譯，因此第一次請求JSP時會感覺比較慢，而之后的請求因為不會編譯JSP，所以速度就快多了，如果將Tomcat保存的JSP編譯后的class文件刪除，Tomcat也會重新編譯JSP。在開發Web程序的時候經常需要修改JSP,Tomcat能夠自動檢測到JSP程序的改動，如果檢測到JSP源代碼發生了改動，Tomcat會在下次客戶端請求JSP時重新編譯JSP,而不需要重啟Tomcat，這種自動檢測功能默認是開啟的，檢測改動會消耗少量的時間，在部署web應用程序的時候可以在web.xml中將它關掉。這也就是為什么我們能夠在jsp頁面直接修改內容，而不用重新啟動服務器的原因。
因為JSP就是servlet，那么生命周期也就是跟serlvet一樣。
JSP和servlet有一點區別就在于：jsp是先部署后編譯，而servlet是先編譯后部署。
二、JSP語法
JSP模版數據：
就是JSP中的HTML代碼，它的內容給是固定的，無論程序如何運行模版數據輸出到客戶端瀏覽器時都不會發生改變，當我們創建一個JSP時，模版就已經固定了。
元素：JSP中的java部分，包括腳本(JavaScript，或者java代碼)以及JSP指令(Directive)與JSP標簽(Tag)等，元素決定著程序的流程，元素是不會顯示到瀏覽器的。這幾個都會在接下來講解到
JSP腳本：
1、使用<% 編寫java代碼 %>，中間java代碼必須遵循Java語法，
為什么能夠使用out輸出？這里就涉及到了JSP的九大內置對象了，后面會講解到，到時候回過頭來在看看這里，就會知道為什么可以使用。
來看看，jsp變為servlet時的代碼是如何編寫的。
在JSP中JSP指令(后面會講)： <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
這句代碼在servlet就變為了response.setContentType("text/html; charset=UTF-8");//這句代碼的意思就是通知tomcat和瀏覽器都使用UTF-8碼表，并且發送回瀏覽器的數據類型是text/html。這是有JSP指令中畫紅色部分代碼轉變的，而指令中的pageEncoding="UTF-8"的意思是JSP轉換為Servlet時采用UTF-8碼表編碼，因為可能JSP中包含中文。
對于JSP模版數據來說，就原封不動的使用out.write()來輸出到瀏覽器
而對于JSP元素來說，就會變成普通的java代碼，因為在servlet中，就可以直接編寫java代碼。
2、使用<%=xxx %>來輸出結果
使用<%=result %>來輸出結果，servlet中就會將其轉換為out.print(result)進行輸出。輸出各種類型數據：int、double、boolean、String、Object等
3、JSP注釋
<%-- --%> ：jsp注釋，
// ：java單行注釋
/* */ ：Java多行注釋
<!-- --> :這個注釋，會發送到瀏覽器端的源碼中顯示
注釋分別在servlet中如何顯示的？
JSP注釋不會在servlet文件中顯示，而java注釋則會，但其所有的注釋到了瀏覽器端，都不會出現在源碼中，只有<!-- -->這個注釋會到瀏覽器的網頁源碼中去
4、JSP中申明方法與屬性(全局變量) 使用<%! 方法、屬性%>
這個就不演示了，就是在JSP中編寫方法或者屬性時，使用<%! %>括起來。
5、在JSP中使用if語句，或者使用for循環，whilt循環等都可以實現，也就是編寫腳本而已。
三、JSP指令
指令用來申明JSP頁面的一些屬性，比如編碼方式，文檔類型。我們在servlet中也會申明我們使用的編碼方式和響應的文檔類型的，而JSP就是用指令來申明。上面我們也說到了一條指令，也就是page指令，
JSP指令格式：<%@ directive {attribute=value}* %>
解釋：directive：指令名稱，例如page指令
attribute=value：緊跟指令名稱后面的就是各種屬性，以鍵值對的形式書寫
*：代表后面能跟0個或多個屬性。
例如： page指令：用來聲明JSP頁面的屬性等。
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> page指令，后面跟著三個屬性，分別是language、contentType、pageEncoding。這只是其中的幾個屬性，并沒有寫全，page指令允許的屬性如下表所示
屬性名稱 取值范圍 描述
language java 解釋該JSP文件時采用的語言，一般為java語言，默認為java
extends 任何類的全名 編譯該JSP文件時繼承哪個類，JSP為Servlet，因此當指明繼承普通類時需要實現Servlet的init、destroy等方法
import 任何包名、類名 引入該JSP中用到的類、包等，import是唯一可以聲明多次的page指令屬性，一個import可以引用uogelei，中間用英文逗號隔開，
如<%@ page import="java.util.List,java.util.ArrayList"%>
session true、false 該JSP內是否內置Session對象，如果為true，則內置Session對象，可直接使用，否則反之，默認為true
autoFlush true，false 是否運行緩存，如果為true，則使用out.println()等方法輸出的字符串并不是立刻到達客戶端服務器的，而是暫時存到緩存里，緩存了或者程序執行完畢或者執行out.flush()操作時才到客戶端，默認為true。
buffer none或者數字KB 指定緩存大小，當autoFlush設為true時有效，例如<%@ page buffer=10kb%>
isThreadSafe true，false 是否線程安全，如果為true，則運行多個線程同時運行該jsp程序，否則只運行一個線程，其余線程等待，默認為false
isErrorPage true，false 指定該頁面是否為錯誤顯示頁面，如果為true，則該JSP內置有一個Exception對象exception，可直接使用，否則沒有，默認為false
errorPage 某個JSP頁面的相對路徑 指明一個錯誤頁面，如果該JSP程序拋出一個未捕捉的異常，則轉到errorPage指定的頁面，errorPage指定的頁面通常isErrorPage屬性為true，且內置的exception對象為未捕捉的異常
contentType 有效的文檔類型 客戶端瀏覽器根據該屬性判斷文檔類型，例如 HTML格式為text/html、純文本格式為text/plain、JPG圖像為image/jpeg、GIF圖 像為image/gif、WORD文檔為application/msword，該屬性常跟著charset設置編碼一起，作用是通知服務器和瀏覽器都使用同一 個碼表
info 任意字符串 指明JSP的信息，該信息可以通過Servlet.getServletInfo()方法獲取到
trimDirective Whitespaces true、false 是否去掉指令前后的空白字符，默認為false
pageEncoding UTF-8,ISO-8859-1等 指定一張碼表來對該JSP頁面進行編碼，include指令
比較簡單，只有一種形式 <%@ include file="relativeURL"%> relativeURL：本應用程序內另一個JSP文件或者HTML文件的路徑，例如，網址內所有頁面均有一個統一風格的導航欄和頁腳版權，那么就可以使用該指令將其包含進來，
特點：include指令會將包含頁面的源代碼添加到使用include指令的頁面中來，然后編譯成class文件，而等下會講到的一個JSP行為，<jsp:include page="relativeURL">作用跟include指令一樣，但是不同的是，include行為是運行時單獨執行包含頁面，然后把執行的結果包含到本頁面來，屬于先運行后包含。
taglib指令 JSP支持標簽技術，后面會講到標簽的用法，jstl標簽庫的使用等，作用：用來指明JSP頁面內使用的JSP標簽庫，taglib指令有兩個屬性，uri為類庫的地址，prefix為標簽的前綴<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
四、JSP行為
前面講了JSP語法，介紹了JSP頁面中的內容有哪些，分別有什么作用，就兩個東西，模塊數據和元素。其中元素有包括腳本，指令，標簽，腳本就是JSP中嵌入java代碼，指令作用就是申明頁面的屬性，那標簽是干嘛的，標簽分為JSP自帶內置的標簽，和通過taglib指令來使用JSP標簽庫，或者自定義標簽。現在我們先來講一些JSP內置的標簽。
JSP內置的標簽就被稱為JSP行為(JSP Actions)。只要書寫很少的標記代碼就能使用JSP提供的豐富功能，JSP行為其實是對常用的JSP功能的抽象與封裝，可以取代jsp腳本，讓JSP中就少一些嵌入java代碼的地方。
格式：<jsp:elements ｛attribute="value"｝* />
jsp：標簽的前綴，說明是jsp內置的標簽，
elements：行為的名稱，
attribute=value：使用鍵值對來編寫屬性
*：能指定0個或多個屬性對
<jsp:include />行為
include行為用于運行時包含某個文件，如果被包含的文件為JSP程序，則先會執行JSP程序，然后在把執行的結果包含進來。 作用是跟include指令一樣的，唯一的區別就在于，include指令是將被包含的文件的源碼加入到了本JSP程序中，然后在進行編譯，屬于靜態包含，而include行為只是將被包含的文件的運行結果包含進自己。屬于動態包含
Java bean行為
是一組與Java Bean 相關的行為，包括useBean行為、setProperty行為、getProperty行為等
Java Bean就是普通的Java類，也被稱為POJO，只有私有的屬性與對應的getter方法和setter方法，注意其中當私有的屬性為boolean類型時，習慣上一般把getter方法寫成isXxx();而不是getXxx();
useBean行為
<jsp:useBean id="beanObject" class="className" scope="Value"> 作用：在jsp中定義一個java bean對象，
id：指明Java Bean對象的名稱，JSP中可以使用該名稱引用該Java Bean對象，相當于給new出來的對象取一個變量名，
class：Java Bean類的全名
scope：該java bean對象的作用范圍，可以寫的就四個，也就是JSP的四大作用域，page、request、session、application
page：只能在當前JSP頁面使用，如果不在JSP頁面，那么就會失效
request：這個前面學過，A頁面請求轉發到B頁面，那么使用的是同一個request，那么A,B頁面都算是request的作用域，也就是通過請求轉發的頁面都是其作 用域
session：該作用域在一個web項目下任何位置應該讀訪問的到，只要cookie不關閉，并且cookie設置 的訪問路徑為"/"，
application：其實就是Servlet中的servletContext，服務器下的所有項目都能訪問到。
setProperty行為
<jsp:setProperty name="beanName" property="propertyName" value="">
對Java Bean對象進行屬性的設置
name：java bean對象的名稱，也就是在useBean行為中的id
property：對象中的屬性名，
value：要對其屬性進行賦值的值
getProperty行為
<jsp:getProperty name="beanName" property="propertyName" />
獲取JavaBean對象的某個屬性值
name:java bean 對象的名稱，也就是在useBean行為中的id
property：對象的屬性名
例子： javabean：User.java NewFile.jsp
User.java
復制代碼
1 package a;
2
3 public class User {
4 private int id;
5 private String username;
6 private String password;
7 public int getId() {
8 return id;
9 }
10 public void setId(int id) {
11 this.id = id;
12 }
13 public String getUsername() {
14 return username;
15 }
16 public void setUsername(String username) {
17 this.username = username;
18 }
19 public String getPassword() {
20 return password;
21 }
22 public void setPassword(String password) {
23 this.password = password;
24 }
25
26
27 }NewFile.jsp
復制代碼
1 <body>
2 <!-- 創建一個新的javabean對象user,會先判斷在page作用域內是否有叫user對象的javabean，如果有則取它，如果沒有則創建新的javabean對象 -->
3 <jsp:useBean id="user" class="a.User" scope="page"></jsp:useBean>
4 <!-- 對javabean對象的username進行賦值 -->
5 <jsp:setProperty property="username" name="user" value="wu"/>
6 <!-- 獲取javabean對象的username屬性 -->
7 <jsp:getProperty property="username" name="user"/>
8 </body>可以查看NewFile.jsp變為servlet后的源代碼，看看我們寫的javabean行為會被轉換為何種語句
這里出現了一個JSP九大內置對象中的一個，pageContext。現在簡單提一句，pageContext就是JSP頁面的管理者(上下文)，其中的getAttribute(name，scope)方法是獲取指定作用域中的數據的，如果getAttribute(name)方法的話，默認是對page作用域進行操作，findAttribute(name)依次從page、request、session、application獲得內容。
在第一個紅框中，就代表中我們的useBean行為，其中進行了一次判斷，就是如果在page作用域中找不到user這個對象，那么就創建一個新的，否則就使用找到的這個user對象，
第二個紅框中，代表著我們的setProperty行為，先找到user對象，然后在對其屬性進行賦值
第三個紅框中，代表著我們的getProperty行為，也是先找到user對象，然后在獲取其屬性的值。
注意：對于javabean行為來說，有一個特點的地方，就是當請求過來的參數對應javabean的屬性時，可以為其一次性設置所有的值
<jsp:setProperty name="user" property="*" /> //設置user的所有屬性，屬性值從request中自動取得，*代表所有屬性。
<jsp:forward />行為
實現請求轉發功能，Servlet中通過request.getRequestDispatcher("someServlet").forward(request,response);而在JSP中也能夠實現相同的功能，只不過用的是<jsp:forward />行為，實際上forward行為就是對其進行了封裝。
格式：
<jsp:forward page="someServlet">
<jsp:param name="param1" value="value1"/>
<jsp:param name="param2" value="value2"/>
</jsp:forward>
page:需要跳轉到的頁面或者servlet、 <jsp:param/>參數行為，帶一些參數過去，name、value是以鍵值對的形式帶過去的
例如：
NewFile.jsp
MyServlet.java
訪問：http://localhost:8080/test01/NewFile.jsp
瀏覽器地址欄沒有改變，說明是請求轉發
NewFile_jsp.java
使用return的好處是執行完上面的轉發，就直接return，沒有必要在執行下面的代碼了，對參數使用了URLEncode進行編碼，說明該<jsp:param/>可以直接傳遞中文，但是前提是要設置request.setCharacterEncoding("UTF-8");為什么這樣做，看上面框起來中的代碼。
<jsp:directive/>行為
directive行為，就相當于JSP指令，比如<jsp:directive.page/>相當于<%@ page %>指令，等等其它指令是一樣的書寫格式。
五、JSP隱藏的九大內置對象和四大作用域
之前那么一大段內容，就是為了講解什么是JSP，JSP中的內容是怎么樣的，到這里應該知道的差不多了， 但我們還要深入了解一些東西，我們知道JSP中的內容就只有兩種，模版數據，和元素，元素就包括了指令呀，腳本呀，標簽(行為)呀，腳本會慢慢被標簽全部代替，也就是說JSP中基本上不會嵌入Java代碼，但是我們也知道JSP會轉換為servlet，在Servlet中，輸出數據時，都需要通過response.getWrite()；但是在JSP中，直接使用out對象進行輸出，為什么呢？這就是因為out為JSP的一個隱藏對象，JSP中內置了9個隱藏對象，使得JSP比Servlet使用起來更簡單，更方便，
page、config、application、request、response、session、out、exception、pageContext
page：page對象代表當前JSP頁面，是當前JSP編譯后的Servlet類的對象。相當于this。
config：標識Servlet配置，類型：ServletConfig，api跟Servlet中的ServletConfig對象是一樣的，能獲取該servlet的一些配置信息，能夠獲取ServletContext
application：標識web應用上下文，類型：ServletContext，詳情就看Servlet中的ServletContext的使用
request:請求對象， 類型：httpServletRequest
response:響應對象 類型：httpServletResponse
session：表示一次會話，在服務器端記錄用戶狀信息的技術
out：輸出響應體 類型：JspWriter
exception 表示發生異常對象，類型 Throwable，在上面我們介紹page指令中的一個errorPage屬性時就有說到他
pageContext：表示 jsp頁面上下文（jsp管理者） 類型：PageContext
標記了紅色的對象就是JSP獨有的，其他的都是Servlet中的老東西。
在這個由jsp轉換為servlet的文件中，只能看到8個內置對象，少了exception對象，因為我們在將page指令時，說過一個isErrorPage屬性，默認是false，被關閉了，所以其中并沒有exception對象。
JSP的四大作用域：page、request、session、application
這四大作用域，其實就是其九大內置對象中的四個，為什么說他們也是JSP的四大作用域呢？因為這四個對象都能存儲數據，比如request.setAttribute()注意和request.setParameter()區分開來，一個是存儲在域中的、一個是請求參數，session.setAttribute()、application其實就是SerlvetContext，自然也有setAttribute()方法。而page作用域的操作就需要依靠pageContext對象來進行了。在上面我們也有提到JSP的四大作用域，
page作用域：代表變量只能在當前頁面上生效
request：代表變量能在一次請求中生效，一次請求可能包含一個頁面，也可能包含多個頁面，比如頁面A請求轉發到頁面B
session：代表變量能在一次會話中生效，基本上就是能在web項目下都有效，session的使用也跟cookie有很大的關系。一般來說，只要瀏覽器不關閉，cookie就會一直生效，cookie生效，session的使用就不會受到影響。
application：代表變量能一個應用下(多個會話)，在服務器下的多個項目之間都能夠使用。比如baidu、wenku等共享帳號。
out對象：
類型：JspWriter
jsp 輸出底層使用 response.getWriter()；什么意思呢？這里就要講解一下JSP緩存和Servlet緩存了，輸出的過程是這樣的
JSP頁面轉換為Servlet后，使用的out對象是JspWriter類型的，所以是會先將要發送的數據存入JSP輸出緩存中，然后，等JSP輸出緩存滿了在自動刷新到servlet輸出緩存，等serlvet輸出緩存滿了，或者程序結束了，就會將其輸出到瀏覽器上。除非手動out.flush()。
驗證servlet輸出緩存和JSP輸出緩存和我們上面所說的是正確的。
4、提供作用域常量
pageContext對象：重點
這個功能就比較強大了，比較牛逼，基本上什么他都有，因為是它是JSP頁面的管理者(上下文)，所以JSP中的內置對象呀，它統統能夠獲得，下面介紹它的api。
1、獲得其它八大內置對象 getXxx()
pageContext.getOut(); //獲得out對象
pageContext.getApplication(); //獲得application對象
等等....
2、對作用域的屬性進行操作(四大作用域)
對默認作用域的屬性進行操作。page
pageContext.getAttribute(name); //獲得page作用域數據
pageContext.setAttribute(name,value); //給page作用域設置內容
pageContext.removeAttribute(name); //給page作用域移除內容
3、對指定作用域的屬性進行操作
getAttribute(name,scope); //獲得 指定作用域中的數據
setAttribute(name,value); //給指定作用域設置內容
removeAttribute(name ,scope) 移除指定作用域的內容（page/request/session/application）
4、提供作用域常量
PageContext.PAGE_SCOPE page
PageContext.REQUEST_SCOPE request
PageContext.SESSION_SCOPE response
PageContext.APPLICATION_SCOPE application
5、一次獲得指定名稱內容
findAttribute(name); //依次從page、request、session、application 獲得內容
response對象：
就是響應對象，、如果不了解就看看講解request和response的這一章節的內容
config對象：
類型：ServletConfig
能夠獲取servlet的初始化參數，獲取servletContext對象，獲取servletName
api詳情請看講解servlet這一章節
exception異常對象：
包含了異常的信息
使用它，必須結合page指令中的isErrorPage屬性和errorPage屬性。
exception.jsp 拋異常的一個NullPointException，并且跳轉到error.jsp錯誤顯示頁面 errorPage屬性的意思是如果發生未捕捉到的異常，將會跳轉到error.jsp頁面
error.jsp isErrorPage屬性說明該頁面是一個錯誤顯示頁面，則可以使用exception對象
訪問http://localhost:8080/test01/exception.jsp
六、總結
通過上面一大堆一大堆的學習，我們應該知道這些東西
1、什么是JSP？
JSP本質上就是一個servlet，因為servlet輸出html太麻煩了，所以就有了JSP，JSP就是專門用來書寫html的，當然其中也能寫java代碼。
2、JSP的內容包括什么？
模版數據和元素。其中元素有包括腳本(java代碼)、指令(頁面屬性)、和行為(標簽，為了JSP中不嵌入那么多java代碼衍生的)
3、JSP中九大內置對象是哪九個？
九大內置對象，page、config、appliction、request、response、session、out、exception、pageContext
4、九大內置對象和servlet中對象的關系
page就是jsp轉換為servletservlet對象本身，也就是this
config -- Servlet中的servletConfig
application -- Servlet中的ServletContext
request -- Servlet中的request
response -- Servlet中的response
session -- Servlet中的session
out -- JspWriter
exception -- 異常對象
pageContext -- 表示 jsp頁面上下文（jsp管理者） 類型：PageContext，
其中pageContext對象最牛逼，有了他就擁有了天下，哈哈~
5、JSP中的四大作用域。
page、request、session、application
其中操作page域中屬性需要借助pageContext對象。
6、JSP中還有其他兩大塊內容
一個是EL表達式，很重要，
另一個是jstl標簽庫的使用，也很重要
*請認真填寫需求信息，我們會在24小時內與您取得聯系。
