整合營銷服務(wù)商
電腦端+手機端+微信端=數(shù)據(jù)同步管理
免費咨詢熱線：
電腦端+手機端+微信端=數(shù)據(jù)同步管理
免費咨詢熱線：
JavaBean是特殊的Java類，使用J ava語言書寫，并且遵守JavaBean API規(guī)范。
接下來給出的是JavaBean與其它Java類相比而言獨一無二的特征：
提供一個默認的無參構(gòu)造函數(shù)。
需要被序列化并且實現(xiàn)了Serializable接口。
可能有一系列可讀寫屬性。
可能有一系列的"getter"或"setter"方法。
JavaBean屬性
一個JavaBean對象的屬性應(yīng)該是可訪問的。這個屬性可以是任意合法的Java數(shù)據(jù)類型，包括自定義Java類。
一個JavaBean對象的屬性可以是可讀寫，或只讀，或只寫。JavaBean對象的屬性通過JavaBean實現(xiàn)類中提供的兩個方法來訪問：
| 方法 | 描述 |
|---|---|
| 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> 標(biāo)簽可以在JSP中聲明一個JavaBean，然后使用。聲明后，JavaBean對象就成了腳本變量，可以通過腳本元素或其他自定義標(biāo)簽來訪問。<jsp:useBean>標(biāo)簽的語法格式如下：
<jsp:useBean id="bean 的名字" scope="bean 的作用域" typeSpec/>
其中，根據(jù)具體情況，scope的值可以是page，request，session或application。id值可任意只要不和同一JSP文件中其它<jsp:useBean>中id值一樣就行了。
接下來給出的是 <jsp:useBean> 標(biāo)簽的一個簡單的用法：
<%@ 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>
它將會產(chǎn)生如下結(jié)果：
日期為：Tue Jun 28 15:22:24 CST 2016
訪問 JavaBean 對象的屬性
在 <jsp:useBean> 標(biāo)簽主體中使用 <jsp:getProperty/> 標(biāo)簽來調(diào)用 getter 方法，使用 <jsp:setProperty/> 標(biāo)簽來調(diào)用 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屬性指的是想要調(diào)用的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>學(xué)生名字:
<jsp:getProperty name="students" property="firstName"/>
</p>
<p>學(xué)生姓氏:
<jsp:getProperty name="students" property="lastName"/>
</p>
<p>學(xué)生年齡:
<jsp:getProperty name="students" property="age"/>
</p>
</body>
</html>
訪問以上 JSP，運行結(jié)果如下：
學(xué)生名字: 小強
學(xué)生姓氏: 王
學(xué)生年齡: 10
如您還有不明白的可以在下面與我留言或是與我探討QQ群308855039，我們一起飛！
培養(yǎng)代碼搬運工哦，想了解更多加:qq:116 159 0055
1、Tip：什么是JSP？
a、JSP全稱是Java Server Pages，它和servle技術(shù)一樣，都是SUN公司定義的一種用于開發(fā)動態(tài)web資源的技術(shù)。JSP/Servlet規(guī)范。JSP實際上就是Servlet。
b、JSP這門技術(shù)的最大的特點在于，寫jsp就像在寫html，但它相比html而言，html只能為用戶提供靜態(tài)數(shù)據(jù)，而Jsp技術(shù)允許在頁面中嵌套java代碼，為用戶提供動態(tài)數(shù)據(jù)。
2、Tip：JSP原理
3、JSP最佳實踐
不管是JSP還是Servlet，雖然都可以用于開發(fā)動態(tài)web資源。但由于這2門技術(shù)各自的特點，在長期的軟件實踐中，人們逐漸把servlet作為web應(yīng)用中的控制器組件來使用，而把JSP技術(shù)作為數(shù)據(jù)顯示模板來使用。
其原因為，程序的數(shù)據(jù)通常要美化后再輸出：
讓JSP既用java代碼產(chǎn)生動態(tài)數(shù)據(jù)，又做美化會導(dǎo)致頁面難以維護。
讓servlet既產(chǎn)生數(shù)據(jù)，又在里面嵌套html代碼美化數(shù)據(jù)，同樣也會導(dǎo)致程序可讀性差，難以維護。
因此最好的辦法就是根據(jù)這兩門技術(shù)的特點，讓它們各自負責(zé)各得，servlet只負責(zé)響應(yīng)請求產(chǎn)生數(shù)據(jù)，并把數(shù)據(jù)通過轉(zhuǎn)發(fā)技術(shù)帶給jsp，數(shù)據(jù)的顯示jsp來做。
4、Tip：JSP語法
JSP模版元素
JSP表達式
JSP腳本片斷
JSP注釋
JSP指令
JSP標(biāo)簽
JSP內(nèi)置對象
如何查找JSP頁面中的錯誤
5、Tip： JSP模版元素
JSP頁面中的HTML內(nèi)容稱之為JSP模版元素。
JSP模版元素定義了網(wǎng)頁的基本骨架，即定義了頁面的結(jié)構(gòu)和外觀。
6、Tip： JSP腳本表達式
JSP腳本表達式（expression）用于將程序數(shù)據(jù)輸出到客戶端
語法：<%= 變量或表達式 %>
舉例：當(dāng)前時間:<%= new java.util.Date() %>
JSP引擎在翻譯腳本表達式時，會將程序數(shù)據(jù)轉(zhuǎn)成字符串，然后在相應(yīng)位置用out.print(…) 將數(shù)據(jù)輸給客戶端。
JSP腳本表達式中的變量或表達式后面不能有分號（;）。
看一下源文件
7、Tip： JSP腳本片斷（1）
JSP腳本片斷（scriptlet）用于在JSP頁面中編寫多行Java代碼。語法：
<%
多行java代碼
%>
注意：JSP腳本片斷中只能出現(xiàn)java代碼，不能出現(xiàn)其它模板元素，JSP引擎在翻譯JSP頁面中，會將JSP腳本片斷中的Java代碼將被原封不動地放到Servlet的_jspService方法中。
JSP腳本片斷中的Java代碼必須嚴(yán)格遵循Java語法，例如，每執(zhí)行語句后面必須用分號（;）結(jié)束。
8、Tip： JSP腳本片斷（2）
在一個JSP頁面中可以有多個腳本片斷，在兩個或多個腳本片斷之間可以嵌入文本、HTML標(biāo)記和其他JSP元素。
舉例：
<%
int x = 10;
out.println(x);
%>
<p>這是JSP頁面文本</p>
<%
int y = 20;
out.println(y);
%>
多個腳本片斷中的代碼可以相互訪問，猶如將所有的代碼放在一對<%%>之中的情況。如：out.println(x);
正規(guī)開發(fā)中的JSP中不應(yīng)出現(xiàn)java腳本：標(biāo)簽封裝
9、Tip： JSP腳本片斷（3）
單個腳本片斷中的Java語句可以是不完整的，但是，多個腳本片斷組合后的結(jié)果必須是完整的Java語句，例如：
<%
for (int i=1; i<5; i++)
{
%>
<H1>www.it315.org</H1>
<%
}
%>
練習(xí)：一張表格，打印100行
10、Tip： JSP聲明
JSP頁面中編寫的所有代碼，默認會翻譯到servlet的service方法中， 而Jsp聲明中的java代碼被翻譯到_jspService方法的外面。語法：
<%！
java代碼
%>
所以，JSP聲明可用于定義JSP頁面轉(zhuǎn)換成的Servlet程序的靜態(tài)代碼塊、成員變量和方法 。
多個靜態(tài)代碼塊、變量和函數(shù)可以定義在一個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頁面中被注釋的內(nèi)容。HTML中的注釋有什么不同，查看源文件解決。
13、Tip： JSP指令
JSP指令（directive）是為JSP引擎而設(shè)計的，它們并不直接產(chǎn)生任何可見輸出，而只是告訴引擎如何處理JSP頁面中的其余部分。在JSP 2.0規(guī)范中共定義了三個指令：
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指令出現(xiàn)在JSP頁面中的什么地方，它作用的都是整個JSP頁面，為了保持程序的可讀性和遵循良好的編程習(xí)慣，page指令最好是放在整個JSP頁面的起始位置。
JSP 2.0規(guī)范中定義的page指令的完整語法：
<%@ page
[ language="java" ]
[ extends="package.class" ]
[ import="{package.class | package.*}, ..." ]
[ session=“true | false” ]//true創(chuàng)建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屬性的設(shè)置值為一路徑（相對或絕對），如果以“/”開頭，表示相對于當(dāng)前WEB應(yīng)用程序的根目錄（注意不是站點根目錄），否則，表示相對于當(dāng)前頁面。
可以在web.xml文件中使用<error-page>元素為整個WEB應(yīng)用程序設(shè)置錯誤處理頁面，其中的<exception-type>子元素指定異常類的完全限定名，<location>元素指定以“/”開頭的錯誤處理頁面的路徑。
如果設(shè)置了某個JSP頁面的errorPage屬性，那么在web.xml文件中設(shè)置的錯誤處理將不對該頁面起作用。
16、Tip：使用page指令解決JSP中文亂碼
JSP程序存在有與Servlet程序完全相同的中文亂碼問題
輸出響應(yīng)正文時出現(xiàn)的中文亂碼問題
讀取瀏覽器傳遞的參數(shù)信息時出現(xiàn)的中文亂碼問題
JSP引擎將JSP頁面翻譯成Servlet源文件時也可能導(dǎo)致中文亂碼問題
JSP引擎將JSP源文件翻譯成的Servlet源文件默認采用ISO8859-1編碼，而JSP開發(fā)人員可以采用各種字符集編碼來編寫JSP源文件，因此，JSP引擎將JSP源文件翻譯成Servlet源文件時，需要進行字符編碼轉(zhuǎn)換。
如果JSP文件中沒有說明它采用的字符集編碼，JSP引擎將把它當(dāng)作默認的ISO8859-1字符集編碼處理。
如何解決JSP引擎翻譯JSP頁面時的中文亂碼問題
通過page指令的contentType屬性說明JSP源文件的字符集編碼
page指令的pageEncoding屬性說明JSP源文件的字符集編碼
17、Tip： include指令
include指令用于引入其它JSP頁面，如果使用include指令引入了其它JSP頁面，那么JSP引擎將把這兩個JSP翻譯成一個servlet。所以include指令引入通常也稱之為靜態(tài)引入。
語法：
<%@ include file=“被包含組件的絕對URL或相對URL"%>
其中的file屬性用于指定被引入文件的路徑。路徑以“/”開頭，表示代表當(dāng)前web應(yīng)用。
細節(jié)：
被引入的文件必須遵循JSP語法。
被引入的文件可以使用任意的擴展名，即使其擴展名是html，JSP引擎也會按照處理jsp頁面的方式處理它里面的內(nèi)容，為了見明知意，JSP規(guī)范建議使用.jspf（JSP fragments）作為靜態(tài)引入文件的擴展名。
由于使用include指令將會涉及到2個JSP頁面，并會把2個JSP翻譯成一個servlet，所以這2個JSP頁面的指令不能沖突（除了pageEncoding和導(dǎo)包除外）。
18、Tip： taglib指令
Taglib指令用于在JSP頁面中導(dǎo)入標(biāo)簽庫，講自定義標(biāo)簽技術(shù)時講。
19、Tip：JSP運行原理和九大隱式對象
每個JSP 頁面在第一次被訪問時，WEB容器都會把請求交給JSP引擎（即一個Java程序）去處理。JSP引擎先將JSP翻譯成一個_jspServlet(實質(zhì)上也是一個servlet) ，然后按照servlet的調(diào)用方式進行調(diào)用。
由于JSP第一次訪問時會翻譯成servlet，所以第一次訪問通常會比較慢，但第二次訪問，JSP引擎如果發(fā)現(xiàn)JSP沒有變化，就不再翻譯，而是直接調(diào)用，所以程序的執(zhí)行效率不會受到影響。
JSP引擎在調(diào)用JSP對應(yīng)的_jspServlet時，會傳遞或創(chuàng)建9個與web開發(fā)相關(guān)的對象供_jspServlet使用。JSP技術(shù)的設(shè)計者為便于開發(fā)人員在編寫JSP頁面時獲得這些web對象的引用，特意定義了9個相應(yīng)的變量，開發(fā)人員在JSP頁面中通過這些變量就可以快速獲得這9大對象的引用。
這9個對象分別是哪些，以及作用也是筆試經(jīng)常考察的知識點。
20、Tip：JSP九大隱式對象
request
response
config
application
exception
Session
page
out
pageContext
21、Tip： out隱式對象
out隱式對象用于向客戶端發(fā)送文本數(shù)據(jù)。
out對象是通過調(diào)用pageContext對象的getOut方法返回的，其作用和用法與ServletResponse.getWriter方法返回的PrintWriter對象非常相似。
JSP頁面中的out隱式對象的類型為JspWriter，JspWriter相當(dāng)于一種帶緩存功能的PrintWriter，設(shè)置JSP頁面的page指令的buffer屬性可以調(diào)整它的緩存大小，甚至關(guān)閉它的緩存。
只有向out對象中寫入了內(nèi)容，且滿足如下任何一個條件時，out對象才去調(diào)用ServletResponse.getWriter方法，并通過該方法返回的PrintWriter對象將out對象的緩沖區(qū)中的內(nèi)容真正寫入到Servlet引擎提供的緩沖區(qū)中：
設(shè)置page指令的buffer屬性關(guān)閉了out對象的緩存功能
out對象的緩沖區(qū)已滿; 整個JSP頁面結(jié)束
22、Tip： out隱式對象的工作原理圖
<% out.println("aaa"); response.getWriter().write("bbb") %>
23、Tip： out隱式對象的注意事項
同時使用out和response.getwriter()輸出數(shù)據(jù)。
用JSP實現(xiàn)文件下載。
24、Tip： pageContext對象
pageContext對象是JSP技術(shù)中最重要的一個對象，它代表JSP頁面的運行環(huán)境，這個對象不僅封裝了對其它8大隱式對象的引用，它自身還是一個域?qū)ο螅梢杂脕肀４鏀?shù)據(jù)。并且，這個對象還封裝了web開發(fā)中經(jīng)常涉及到的一些常用操作，例如引入和跳轉(zhuǎn)其它資源、檢索其它域?qū)ο笾械膶傩缘取?/p>
25、Tip：通過pageContext獲得其他對象
getException方法返回exception隱式對象
getPage方法返回page隱式對象
getRequest方法返回request隱式對象
getResponse方法返回response隱式對象
getServletConfig方法返回config隱式對象
getServletContext方法返回application隱式對象
getSession方法返回session隱式對象
getOut方法返回out隱式對象
pageContext封裝其它8大內(nèi)置對象的意義，思考：如果在編程過程中，把pageContext對象傳遞給一個普通java對象，那么這個java對象將具有什么功能？
25、Tip：pageContext作為域?qū)ο?/strong>
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：引入和跳轉(zhuǎn)到其他資源
PageContext類中定義了一個forward方法和兩個include方法來分別簡化和替代RequestDispatcher.forward方法和include方法。
方法接收的資源如果以“/”開頭， “/”代表當(dāng)前web應(yīng)用。
27、Tip： JSP標(biāo)簽
JSP標(biāo)簽也稱之為Jsp Action(JSP動作)元素，它用于在Jsp頁面中提供業(yè)務(wù)邏輯功能，避免在JSP頁面中直接編寫java代碼，造成jsp頁面難以維護。
28、Tip： JSP常用標(biāo)簽
<jsp:include>標(biāo)簽
<jsp:forward>標(biāo)簽
<jsp:param>標(biāo)簽
28、Tip： <jsp:include>標(biāo)簽
<jsp:include>標(biāo)簽用于把另外一個資源的輸出內(nèi)容插入進當(dāng)前JSP頁面的輸出內(nèi)容之中，這種在JSP頁面執(zhí)行時的引入方式稱之為動態(tài)引入。
語法：
<jsp:include page="relativeURL | <%=expression%>" flush="true|false" />
page屬性用于指定被引入資源的相對路徑，它也可以通過執(zhí)行一個表達式來獲得。
flush屬性指定在插入其他資源的輸出內(nèi)容時，是否先將當(dāng)前JSP頁面的已輸出的內(nèi)容刷新到客戶端。
29、Tip： <jsp:include>與include指令的比較
<jsp:include>標(biāo)簽是動態(tài)引入， <jsp:include>標(biāo)簽涉及到的2個JSP頁面會被翻譯成2個servlet，這2個servlet的內(nèi)容在執(zhí)行時進行合并。
而include指令是靜態(tài)引入，涉及到的2個JSP頁面會被翻譯成一個servlet，其內(nèi)容是在源文件級別進行合并。
不管是<jsp:include>標(biāo)簽，還是include指令，它們都會把兩個JSP頁面內(nèi)容合并輸出，所以這兩個頁面不要出現(xiàn)重復(fù)的HTML全局架構(gòu)標(biāo)簽，
否則輸出給客戶端的內(nèi)容將會是一個格式混亂的HTML文檔。
30、Tip： <jsp:forward>標(biāo)簽
<jsp:forward>標(biāo)簽用于把請求轉(zhuǎn)發(fā)給另外一個資源。
語法：
<jsp:forward page="relativeURL | <%=expression%>" />
page屬性用于指定請求轉(zhuǎn)發(fā)到的資源的相對路徑，它也可以通過執(zhí)行一個表達式來獲得。
31、Tip： <jsp:param>標(biāo)簽
當(dāng)使用<jsp:include>和<jsp:forward>標(biāo)簽引入或?qū)⒄埱筠D(zhuǎn)發(fā)給其它資源時，可以使用<jsp:param>標(biāo)簽向這個資源傳遞參數(shù)。
語法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>標(biāo)簽的name屬性用于指定參數(shù)名，value屬性用于指定參數(shù)值。在<jsp:include>和<jsp:forward>標(biāo)簽中可以使用多個<jsp:param>標(biāo)簽來傳遞多個參數(shù)。
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語法格式有問題，導(dǎo)致其不能被翻譯成Servlet源文件，JSP引擎將提示這類錯誤發(fā)生在JSP頁面中的位置（行和列）以及相關(guān)信息。
JSP頁面中的JSP語法格式?jīng)]有問題，但被翻譯成的Servlet源文件中出現(xiàn)了Java語法問題，導(dǎo)致JSP頁面翻譯成的Servlet源文件不能通過編譯，
JSP引擎也將提示這類錯誤發(fā)生在JSP頁面中的位置（行和列）以及相關(guān)信息。
JSP頁面翻譯成的Servlet程序在運行時出現(xiàn)異常，這與普通Java程序的運行時錯誤完全一樣，Java虛擬機將提示錯誤發(fā)生在Servlet源文件中的位置（行和列）以及相關(guān)信息。
34、Tip：重點
到此為止，web開發(fā)接觸到了4個域?qū)ο?這4個域?qū)ο笫菍W(xué)習(xí)web的重點，也是筆試經(jīng)常考察的知識點
pageContext（稱之為page域）
request（稱之為request域）
session（稱之為session域）
servletContext（稱之為application域）
明確如下問題：
什么是域？
這4個對象的生命周期？
哪種情況下用哪種域?qū)ο蟆?/p>
1、request：如果客戶向服務(wù)器發(fā)請求，產(chǎn)生的數(shù)據(jù)，用戶看完就沒用了，像這樣的數(shù)據(jù)就存在request域,像新聞數(shù)據(jù)，屬于用戶看完就沒用的
2、session：如果客戶向服務(wù)器發(fā)請求，產(chǎn)生的數(shù)據(jù)，用戶用完了等一會兒還有用，像這樣的數(shù)據(jù)就存在session域中，像購物數(shù)據(jù)，用戶需要看到自己購物信息，并且等一會兒，還要用這個購物數(shù)據(jù)結(jié)帳
3、servletContext：如果客戶向服務(wù)器發(fā)請求，產(chǎn)生的數(shù)據(jù)，用戶用完了，還要給其它用戶用，像這樣的數(shù)據(jù)就存在servletContext域中，像聊天數(shù)據(jù)。
、JSP
1、什么是JSP？
JSP(Java Server Pages):是以Java語言為基礎(chǔ)的動態(tài)網(wǎng)頁開發(fā)技術(shù)，
特點：
Servlet特點：在Java源碼中嵌入html源碼
JSP特點：在html源碼中嵌入java代碼
JSP就是Servlet
1、tomcat獲得JSP文件后，先將JSP轉(zhuǎn)成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文件，并將結(jié)果輸出到瀏覽器，
實例:
創(chuàng)建一個jsp。查看其轉(zhuǎn)換后的servlet代碼。
NewFile.jsp
復(fù)制代碼
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
復(fù)制代碼
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
復(fù)制代碼
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的源碼會發(fā)現(xiàn)，生命周期也是有init()方法，service()方法，destory()方法，相當(dāng)于_jspService()方法就是servlet的service()方法的執(zhí)行，所以說JSP也是一個servlet。
我們在JSP寫的所有html代碼，都會被轉(zhuǎn)換為servlet中的out.write(html)代碼來輸出。看圖
小總結(jié)：
對于jsp轉(zhuǎn)換成的servlet源碼，之后我們會在進行詳細分析，現(xiàn)在只需要知道jsp中的內(nèi)容在servlet中被轉(zhuǎn)換成什么了，在哪里被轉(zhuǎn)換了即可。其中_jspService()方法的詳細內(nèi)容下面會講解
注意：jsp 生成java源碼，默認第一次生成，之后直接執(zhí)行，除非內(nèi)容修改，具體點說，由于JSP只會在客戶端第一次請求的時候被編譯，因此第一次請求JSP時會感覺比較慢，而之后的請求因為不會編譯JSP，所以速度就快多了，如果將Tomcat保存的JSP編譯后的class文件刪除，Tomcat也會重新編譯JSP。在開發(fā)Web程序的時候經(jīng)常需要修改JSP,Tomcat能夠自動檢測到JSP程序的改動，如果檢測到JSP源代碼發(fā)生了改動，Tomcat會在下次客戶端請求JSP時重新編譯JSP,而不需要重啟Tomcat，這種自動檢測功能默認是開啟的，檢測改動會消耗少量的時間，在部署web應(yīng)用程序的時候可以在web.xml中將它關(guān)掉。這也就是為什么我們能夠在jsp頁面直接修改內(nèi)容，而不用重新啟動服務(wù)器的原因。
因為JSP就是servlet，那么生命周期也就是跟serlvet一樣。
JSP和servlet有一點區(qū)別就在于：jsp是先部署后編譯，而servlet是先編譯后部署。
二、JSP語法
JSP模版數(shù)據(jù)：
就是JSP中的HTML代碼，它的內(nèi)容給是固定的，無論程序如何運行模版數(shù)據(jù)輸出到客戶端瀏覽器時都不會發(fā)生改變，當(dāng)我們創(chuàng)建一個JSP時，模版就已經(jīng)固定了。
元素：JSP中的java部分，包括腳本(JavaScript，或者java代碼)以及JSP指令(Directive)與JSP標(biāo)簽(Tag)等，元素決定著程序的流程，元素是不會顯示到瀏覽器的。這幾個都會在接下來講解到
JSP腳本：
1、使用<% 編寫java代碼 %>，中間java代碼必須遵循Java語法，
為什么能夠使用out輸出？這里就涉及到了JSP的九大內(nèi)置對象了，后面會講解到，到時候回過頭來在看看這里，就會知道為什么可以使用。
來看看，jsp變?yōu)閟ervlet時的代碼是如何編寫的。
在JSP中JSP指令(后面會講)： <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
這句代碼在servlet就變?yōu)榱藃esponse.setContentType("text/html; charset=UTF-8");//這句代碼的意思就是通知tomcat和瀏覽器都使用UTF-8碼表，并且發(fā)送回瀏覽器的數(shù)據(jù)類型是text/html。這是有JSP指令中畫紅色部分代碼轉(zhuǎn)變的，而指令中的pageEncoding="UTF-8"的意思是JSP轉(zhuǎn)換為Servlet時采用UTF-8碼表編碼，因為可能JSP中包含中文。
對于JSP模版數(shù)據(jù)來說，就原封不動的使用out.write()來輸出到瀏覽器
而對于JSP元素來說，就會變成普通的java代碼，因為在servlet中，就可以直接編寫java代碼。
2、使用<%=xxx %>來輸出結(jié)果
使用<%=result %>來輸出結(jié)果，servlet中就會將其轉(zhuǎn)換為out.print(result)進行輸出。輸出各種類型數(shù)據(jù)：int、double、boolean、String、Object等
3、JSP注釋
<%-- --%> ：jsp注釋，
// ：java單行注釋
/* */ ：Java多行注釋
<!-- --> :這個注釋，會發(fā)送到瀏覽器端的源碼中顯示
注釋分別在servlet中如何顯示的？
JSP注釋不會在servlet文件中顯示，而java注釋則會，但其所有的注釋到了瀏覽器端，都不會出現(xiàn)在源碼中，只有<!-- -->這個注釋會到瀏覽器的網(wǎng)頁源碼中去
4、JSP中申明方法與屬性(全局變量) 使用<%! 方法、屬性%>
這個就不演示了，就是在JSP中編寫方法或者屬性時，使用<%! %>括起來。
5、在JSP中使用if語句，或者使用for循環(huán)，whilt循環(huán)等都可以實現(xiàn)，也就是編寫腳本而已。
三、JSP指令
指令用來申明JSP頁面的一些屬性，比如編碼方式，文檔類型。我們在servlet中也會申明我們使用的編碼方式和響應(yīng)的文檔類型的，而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，因此當(dāng)指明繼承普通類時需要實現(xiàn)Servlet的init、destroy等方法
import 任何包名、類名 引入該JSP中用到的類、包等，import是唯一可以聲明多次的page指令屬性，一個import可以引用uogelei，中間用英文逗號隔開，
如<%@ page import="java.util.List,java.util.ArrayList"%>
session true、false 該JSP內(nèi)是否內(nèi)置Session對象，如果為true，則內(nèi)置Session對象，可直接使用，否則反之，默認為true
autoFlush true，false 是否運行緩存，如果為true，則使用out.println()等方法輸出的字符串并不是立刻到達客戶端服務(wù)器的，而是暫時存到緩存里，緩存了或者程序執(zhí)行完畢或者執(zhí)行out.flush()操作時才到客戶端，默認為true。
buffer none或者數(shù)字KB 指定緩存大小，當(dāng)autoFlush設(shè)為true時有效，例如<%@ page buffer=10kb%>
isThreadSafe true，false 是否線程安全，如果為true，則運行多個線程同時運行該jsp程序，否則只運行一個線程，其余線程等待，默認為false
isErrorPage true，false 指定該頁面是否為錯誤顯示頁面，如果為true，則該JSP內(nèi)置有一個Exception對象exception，可直接使用，否則沒有，默認為false
errorPage 某個JSP頁面的相對路徑 指明一個錯誤頁面，如果該JSP程序拋出一個未捕捉的異常，則轉(zhuǎn)到errorPage指定的頁面，errorPage指定的頁面通常isErrorPage屬性為true，且內(nèi)置的exception對象為未捕捉的異常
contentType 有效的文檔類型 客戶端瀏覽器根據(jù)該屬性判斷文檔類型，例如 HTML格式為text/html、純文本格式為text/plain、JPG圖像為image/jpeg、GIF圖 像為image/gif、WORD文檔為application/msword，該屬性常跟著charset設(shè)置編碼一起，作用是通知服務(wù)器和瀏覽器都使用同一 個碼表
info 任意字符串 指明JSP的信息，該信息可以通過Servlet.getServletInfo()方法獲取到
trimDirective Whitespaces true、false 是否去掉指令前后的空白字符，默認為false
pageEncoding UTF-8,ISO-8859-1等 指定一張碼表來對該JSP頁面進行編碼，include指令
比較簡單，只有一種形式 <%@ include file="relativeURL"%> relativeURL：本應(yīng)用程序內(nèi)另一個JSP文件或者HTML文件的路徑，例如，網(wǎng)址內(nèi)所有頁面均有一個統(tǒng)一風(fēng)格的導(dǎo)航欄和頁腳版權(quán)，那么就可以使用該指令將其包含進來，
特點：include指令會將包含頁面的源代碼添加到使用include指令的頁面中來，然后編譯成class文件，而等下會講到的一個JSP行為，<jsp:include page="relativeURL">作用跟include指令一樣，但是不同的是，include行為是運行時單獨執(zhí)行包含頁面，然后把執(zhí)行的結(jié)果包含到本頁面來，屬于先運行后包含。
taglib指令 JSP支持標(biāo)簽技術(shù)，后面會講到標(biāo)簽的用法，jstl標(biāo)簽庫的使用等，作用：用來指明JSP頁面內(nèi)使用的JSP標(biāo)簽庫，taglib指令有兩個屬性，uri為類庫的地址，prefix為標(biāo)簽的前綴<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
四、JSP行為
前面講了JSP語法，介紹了JSP頁面中的內(nèi)容有哪些，分別有什么作用，就兩個東西，模塊數(shù)據(jù)和元素。其中元素有包括腳本，指令，標(biāo)簽，腳本就是JSP中嵌入java代碼，指令作用就是申明頁面的屬性，那標(biāo)簽是干嘛的，標(biāo)簽分為JSP自帶內(nèi)置的標(biāo)簽，和通過taglib指令來使用JSP標(biāo)簽庫，或者自定義標(biāo)簽。現(xiàn)在我們先來講一些JSP內(nèi)置的標(biāo)簽。
JSP內(nèi)置的標(biāo)簽就被稱為JSP行為(JSP Actions)。只要書寫很少的標(biāo)記代碼就能使用JSP提供的豐富功能，JSP行為其實是對常用的JSP功能的抽象與封裝，可以取代jsp腳本，讓JSP中就少一些嵌入java代碼的地方。
格式：<jsp:elements ｛attribute="value"｝* />
jsp：標(biāo)簽的前綴，說明是jsp內(nèi)置的標(biāo)簽，
elements：行為的名稱，
attribute=value：使用鍵值對來編寫屬性
*：能指定0個或多個屬性對
<jsp:include />行為
include行為用于運行時包含某個文件，如果被包含的文件為JSP程序，則先會執(zhí)行JSP程序，然后在把執(zhí)行的結(jié)果包含進來。 作用是跟include指令一樣的，唯一的區(qū)別就在于，include指令是將被包含的文件的源碼加入到了本JSP程序中，然后在進行編譯，屬于靜態(tài)包含，而include行為只是將被包含的文件的運行結(jié)果包含進自己。屬于動態(tài)包含
Java bean行為
是一組與Java Bean 相關(guān)的行為，包括useBean行為、setProperty行為、getProperty行為等
Java Bean就是普通的Java類，也被稱為POJO，只有私有的屬性與對應(yīng)的getter方法和setter方法，注意其中當(dāng)私有的屬性為boolean類型時，習(xí)慣上一般把getter方法寫成isXxx();而不是getXxx();
useBean行為
<jsp:useBean id="beanObject" class="className" scope="Value"> 作用：在jsp中定義一個java bean對象，
id：指明Java Bean對象的名稱，JSP中可以使用該名稱引用該Java Bean對象，相當(dāng)于給new出來的對象取一個變量名，
class：Java Bean類的全名
scope：該java bean對象的作用范圍，可以寫的就四個，也就是JSP的四大作用域，page、request、session、application
page：只能在當(dāng)前JSP頁面使用，如果不在JSP頁面，那么就會失效
request：這個前面學(xué)過，A頁面請求轉(zhuǎn)發(fā)到B頁面，那么使用的是同一個request，那么A,B頁面都算是request的作用域，也就是通過請求轉(zhuǎn)發(fā)的頁面都是其作 用域
session：該作用域在一個web項目下任何位置應(yīng)該讀訪問的到，只要cookie不關(guān)閉，并且cookie設(shè)置 的訪問路徑為"/"，
application：其實就是Servlet中的servletContext，服務(wù)器下的所有項目都能訪問到。
setProperty行為
<jsp:setProperty name="beanName" property="propertyName" value="">
對Java Bean對象進行屬性的設(shè)置
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
復(fù)制代碼
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
復(fù)制代碼
1 <body>
2 <!-- 創(chuàng)建一個新的javabean對象user,會先判斷在page作用域內(nèi)是否有叫user對象的javabean，如果有則取它，如果沒有則創(chuàng)建新的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變?yōu)閟ervlet后的源代碼，看看我們寫的javabean行為會被轉(zhuǎn)換為何種語句
這里出現(xiàn)了一個JSP九大內(nèi)置對象中的一個，pageContext。現(xiàn)在簡單提一句，pageContext就是JSP頁面的管理者(上下文)，其中的getAttribute(name，scope)方法是獲取指定作用域中的數(shù)據(jù)的，如果getAttribute(name)方法的話，默認是對page作用域進行操作，findAttribute(name)依次從page、request、session、application獲得內(nèi)容。
在第一個紅框中，就代表中我們的useBean行為，其中進行了一次判斷，就是如果在page作用域中找不到user這個對象，那么就創(chuàng)建一個新的，否則就使用找到的這個user對象，
第二個紅框中，代表著我們的setProperty行為，先找到user對象，然后在對其屬性進行賦值
第三個紅框中，代表著我們的getProperty行為，也是先找到user對象，然后在獲取其屬性的值。
注意：對于javabean行為來說，有一個特點的地方，就是當(dāng)請求過來的參數(shù)對應(yīng)javabean的屬性時，可以為其一次性設(shè)置所有的值
<jsp:setProperty name="user" property="*" /> //設(shè)置user的所有屬性，屬性值從request中自動取得，*代表所有屬性。
<jsp:forward />行為
實現(xiàn)請求轉(zhuǎn)發(fā)功能，Servlet中通過request.getRequestDispatcher("someServlet").forward(request,response);而在JSP中也能夠?qū)崿F(xiàn)相同的功能，只不過用的是<jsp:forward />行為，實際上forward行為就是對其進行了封裝。
格式：
<jsp:forward page="someServlet">
<jsp:param name="param1" value="value1"/>
<jsp:param name="param2" value="value2"/>
</jsp:forward>
page:需要跳轉(zhuǎn)到的頁面或者servlet、 <jsp:param/>參數(shù)行為，帶一些參數(shù)過去，name、value是以鍵值對的形式帶過去的
例如：
NewFile.jsp
MyServlet.java
訪問：http://localhost:8080/test01/NewFile.jsp
瀏覽器地址欄沒有改變，說明是請求轉(zhuǎn)發(fā)
NewFile_jsp.java
使用return的好處是執(zhí)行完上面的轉(zhuǎn)發(fā)，就直接return，沒有必要在執(zhí)行下面的代碼了，對參數(shù)使用了URLEncode進行編碼，說明該<jsp:param/>可以直接傳遞中文，但是前提是要設(shè)置request.setCharacterEncoding("UTF-8");為什么這樣做，看上面框起來中的代碼。
<jsp:directive/>行為
directive行為，就相當(dāng)于JSP指令，比如<jsp:directive.page/>相當(dāng)于<%@ page %>指令，等等其它指令是一樣的書寫格式。
五、JSP隱藏的九大內(nèi)置對象和四大作用域
之前那么一大段內(nèi)容，就是為了講解什么是JSP，JSP中的內(nèi)容是怎么樣的，到這里應(yīng)該知道的差不多了， 但我們還要深入了解一些東西，我們知道JSP中的內(nèi)容就只有兩種，模版數(shù)據(jù)，和元素，元素就包括了指令呀，腳本呀，標(biāo)簽(行為)呀，腳本會慢慢被標(biāo)簽全部代替，也就是說JSP中基本上不會嵌入Java代碼，但是我們也知道JSP會轉(zhuǎn)換為servlet，在Servlet中，輸出數(shù)據(jù)時，都需要通過response.getWrite()；但是在JSP中，直接使用out對象進行輸出，為什么呢？這就是因為out為JSP的一個隱藏對象，JSP中內(nèi)置了9個隱藏對象，使得JSP比Servlet使用起來更簡單，更方便，
page、config、application、request、response、session、out、exception、pageContext
page：page對象代表當(dāng)前JSP頁面，是當(dāng)前JSP編譯后的Servlet類的對象。相當(dāng)于this。
config：標(biāo)識Servlet配置，類型：ServletConfig，api跟Servlet中的ServletConfig對象是一樣的，能獲取該servlet的一些配置信息，能夠獲取ServletContext
application：標(biāo)識web應(yīng)用上下文，類型：ServletContext，詳情就看Servlet中的ServletContext的使用
request:請求對象， 類型：httpServletRequest
response:響應(yīng)對象 類型：httpServletResponse
session：表示一次會話，在服務(wù)器端記錄用戶狀信息的技術(shù)
out：輸出響應(yīng)體 類型：JspWriter
exception 表示發(fā)生異常對象，類型 Throwable，在上面我們介紹page指令中的一個errorPage屬性時就有說到他
pageContext：表示 jsp頁面上下文（jsp管理者） 類型：PageContext
標(biāo)記了紅色的對象就是JSP獨有的，其他的都是Servlet中的老東西。
在這個由jsp轉(zhuǎn)換為servlet的文件中，只能看到8個內(nèi)置對象，少了exception對象，因為我們在將page指令時，說過一個isErrorPage屬性，默認是false，被關(guān)閉了，所以其中并沒有exception對象。
JSP的四大作用域：page、request、session、application
這四大作用域，其實就是其九大內(nèi)置對象中的四個，為什么說他們也是JSP的四大作用域呢？因為這四個對象都能存儲數(shù)據(jù)，比如request.setAttribute()注意和request.setParameter()區(qū)分開來，一個是存儲在域中的、一個是請求參數(shù)，session.setAttribute()、application其實就是SerlvetContext，自然也有setAttribute()方法。而page作用域的操作就需要依靠pageContext對象來進行了。在上面我們也有提到JSP的四大作用域，
page作用域：代表變量只能在當(dāng)前頁面上生效
request：代表變量能在一次請求中生效，一次請求可能包含一個頁面，也可能包含多個頁面，比如頁面A請求轉(zhuǎn)發(fā)到頁面B
session：代表變量能在一次會話中生效，基本上就是能在web項目下都有效，session的使用也跟cookie有很大的關(guān)系。一般來說，只要瀏覽器不關(guān)閉，cookie就會一直生效，cookie生效，session的使用就不會受到影響。
application：代表變量能一個應(yīng)用下(多個會話)，在服務(wù)器下的多個項目之間都能夠使用。比如baidu、wenku等共享帳號。
out對象：
類型：JspWriter
jsp 輸出底層使用 response.getWriter()；什么意思呢？這里就要講解一下JSP緩存和Servlet緩存了，輸出的過程是這樣的
JSP頁面轉(zhuǎn)換為Servlet后，使用的out對象是JspWriter類型的，所以是會先將要發(fā)送的數(shù)據(jù)存入JSP輸出緩存中，然后，等JSP輸出緩存滿了在自動刷新到servlet輸出緩存，等serlvet輸出緩存滿了，或者程序結(jié)束了，就會將其輸出到瀏覽器上。除非手動out.flush()。
驗證servlet輸出緩存和JSP輸出緩存和我們上面所說的是正確的。
4、提供作用域常量
pageContext對象：重點
這個功能就比較強大了，比較牛逼，基本上什么他都有，因為是它是JSP頁面的管理者(上下文)，所以JSP中的內(nèi)置對象呀，它統(tǒng)統(tǒng)能夠獲得，下面介紹它的api。
1、獲得其它八大內(nèi)置對象 getXxx()
pageContext.getOut(); //獲得out對象
pageContext.getApplication(); //獲得application對象
等等....
2、對作用域的屬性進行操作(四大作用域)
對默認作用域的屬性進行操作。page
pageContext.getAttribute(name); //獲得page作用域數(shù)據(jù)
pageContext.setAttribute(name,value); //給page作用域設(shè)置內(nèi)容
pageContext.removeAttribute(name); //給page作用域移除內(nèi)容
3、對指定作用域的屬性進行操作
getAttribute(name,scope); //獲得 指定作用域中的數(shù)據(jù)
setAttribute(name,value); //給指定作用域設(shè)置內(nèi)容
removeAttribute(name ,scope) 移除指定作用域的內(nèi)容（page/request/session/application）
4、提供作用域常量
PageContext.PAGE_SCOPE page
PageContext.REQUEST_SCOPE request
PageContext.SESSION_SCOPE response
PageContext.APPLICATION_SCOPE application
5、一次獲得指定名稱內(nèi)容
findAttribute(name); //依次從page、request、session、application 獲得內(nèi)容
response對象：
就是響應(yīng)對象，、如果不了解就看看講解request和response的這一章節(jié)的內(nèi)容
config對象：
類型：ServletConfig
能夠獲取servlet的初始化參數(shù)，獲取servletContext對象，獲取servletName
api詳情請看講解servlet這一章節(jié)
exception異常對象：
包含了異常的信息
使用它，必須結(jié)合page指令中的isErrorPage屬性和errorPage屬性。
exception.jsp 拋異常的一個NullPointException，并且跳轉(zhuǎn)到error.jsp錯誤顯示頁面 errorPage屬性的意思是如果發(fā)生未捕捉到的異常，將會跳轉(zhuǎn)到error.jsp頁面
error.jsp isErrorPage屬性說明該頁面是一個錯誤顯示頁面，則可以使用exception對象
訪問http://localhost:8080/test01/exception.jsp
六、總結(jié)
通過上面一大堆一大堆的學(xué)習(xí)，我們應(yīng)該知道這些東西
1、什么是JSP？
JSP本質(zhì)上就是一個servlet，因為servlet輸出html太麻煩了，所以就有了JSP，JSP就是專門用來書寫html的，當(dāng)然其中也能寫java代碼。
2、JSP的內(nèi)容包括什么？
模版數(shù)據(jù)和元素。其中元素有包括腳本(java代碼)、指令(頁面屬性)、和行為(標(biāo)簽，為了JSP中不嵌入那么多java代碼衍生的)
3、JSP中九大內(nèi)置對象是哪九個？
九大內(nèi)置對象，page、config、appliction、request、response、session、out、exception、pageContext
4、九大內(nèi)置對象和servlet中對象的關(guān)系
page就是jsp轉(zhuǎn)換為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中還有其他兩大塊內(nèi)容
一個是EL表達式，很重要，
另一個是jstl標(biāo)簽庫的使用，也很重要
*請認真填寫需求信息，我們會在24小時內(nèi)與您取得聯(lián)系。
