Java-Jsp基础教程
介紹
學習JSP 基礎教程前 必須會 java Servlet 或者SSM
什么是Java Server Pages?
JSP全稱Java Server Pages，是一種動態網頁開發技術。它使用JSP標簽在HTML網頁中插入Java代碼。標簽通常以<%開頭以%>結束。
JSP是一種Java servlet，主要用于實現Java web應用程序的用戶界面部分。網頁開發者們通過結合HTML代碼、XHTML代碼、XML元素以及嵌入JSP操作和命令來編寫JSP。
JSP通過網頁表單獲取用戶輸入數據、訪問數據庫及其他數據源，然后動態地創建網頁。
JSP標簽有多種功能，比如訪問數據庫、記錄用戶選擇信息、訪問JavaBeans組件等，還可以在不同的網頁中傳遞控制信息和共享信息
為什么使用JSP？
JSP程序與CGI程序有著相似的功能，但和CGI程序相比，JSP程序有如下優勢：
- 性能更加優越，因為JSP可以直接在HTML網頁中動態嵌入元素而不需要單獨引用CGI文件。
- 服務器調用的是已經編譯好的JSP文件，而不像CGI/Perl那樣必須先載入解釋器和目標腳本。
- JSP基于Java Servlets API，因此，JSP擁有各種強大的企業級Java API，包括JDBC，JNDI，EJB，JAXP等等。
- JSP頁面可以與處理業務邏輯的servlets一起使用，這種模式被Java servlet 模板引擎所支持。
最后，JSP是Java EE不可或缺的一部分，是一個完整的企業級應用平臺。這意味著JSP可以用最簡單的方式來實現最復雜的應用。
JSP的優勢
以下列出了使用JSP帶來的其他好處：
-
與ASP相比：JSP有兩大優勢。首先，動態部分用Java編寫，而不是VB或其他MS專用語言，所以更加強大與易用。第二點就是JSP易于移植到非MS平臺上。
-
與純 Servlets相比：JSP可以很方便的編寫或者修改HTML網頁而不用去面對大量的println語句。
-
與SSI相比：SSI無法使用表單數據、無法進行數據庫鏈接。
-
與JavaScript相比：雖然JavaScript可以在客戶端動態生成HTML，但是很難與服務器交互，因此不能提供復雜的服務，比如訪問數據庫和圖像處理等等。
-
與靜態HTML相比：靜態HTML不包含動態信息。
我們將會帶您一步一步地來搭建JSP運行環境，這需要有一定的Java基礎。
JSP 開發環境搭建
需要配置 java JDK
需要配置 Tomcat 來解析 JSP頁面到到游覽器
以上都配置過了 那么我們來使用IDEA可和Tomcat關聯
以上不會可以在我博客里找對應的文章學
創建一個名字java_Web 的 Maven Web的項目
進入java_Web項目->點擊Run—EDit Configurations…
2.點擊左側“+”號，找到Tomcat Server—Local
然后 apply -> ok
點擊 綠色三角 運行Tomcat
如果發現 Tomcat 啟動不了或者啟動了 什么反應都沒有 那么去 http://boke.huitoushian.cn/posts/55324.html 找為什么 基本上百分之95的問題都能解決 剩下百分之5就是你自己作死 亂改 出現的未知問題 這個 唯一辦法卸載Tomcat 從新安裝
JSP處理過程
以下步驟表明了Web服務器是如何使用JSP來創建網頁的：
- 就像其他普通的網頁一樣，您的瀏覽器發送一個HTTP請求給服務器。
- Web服務器識別出這是一個對JSP網頁的請求，并且將該請求傳遞給JSP引擎。通過使用URL或者.jsp文件來完成。
- JSP引擎從磁盤中載入JSP文件，然后將它們轉化為servlet。這種轉化只是簡單地將所有模板文本改用println()語句，并且將所有的JSP元素轉化成Java代碼。
- JSP引擎將servlet編譯成可執行類，并且將原始請求傳遞給servlet引擎。
- Web服務器的某組件將會調用servlet引擎，然后載入并執行servlet類。在執行過程中，servlet產生HTML格式的輸出并將其內嵌于HTTP response中上交給Web服務器。
- Web服務器以靜態HTML網頁的形式將HTTP response返回到您的瀏覽器中。
- 最終，Web瀏覽器處理HTTP response中動態產生的HTML網頁，就好像在處理靜態網頁一樣。
一般情況下，JSP引擎會檢查JSP文件對應的servlet是否已經存在，并且檢查JSP文件的修改日期是否早于servlet。如果JSP文件的修改日期早于對應的servlet，那么容器就可以確定JSP文件沒有被修改過并且servlet有效。這使得整個流程與其他腳本語言（比如PHP）相比要高效快捷一些。
總的來說，JSP網頁就是用另一種方式來編寫servlet而不用成為Java編程高手。除了解釋階段外，JSP網頁幾乎可以被當成一個普通的servlet來對待。
JSP 生命周期
理解JSP底層功能的關鍵就是去理解它們所遵守的生命周期。
JSP生命周期就是從創建到銷毀的整個過程，類似于servlet生命周期，區別在于JSP生命周期還包括將JSP文件編譯成servlet。
以下是JSP生命周期中所走過的幾個階段：
- 編譯階段：
servlet容器編譯servlet源文件，生成servlet類
- 初始化階段：
加載與JSP對應的servlet類，創建其實例，并調用它的初始化方法
- 執行階段：
調用與JSP對應的servlet實例的服務方法
- 銷毀階段：
調用與JSP對應的servlet實例的銷毀方法，然后銷毀servlet實例
很明顯，JSP生命周期的四個主要階段和servlet生命周期非常相似
JSP編譯階段
當瀏覽器請求JSP頁面時，JSP引擎會首先去檢查是否需要編譯這個文件。如果這個文件沒有被編譯過，或者在上次編譯后被更改過，則編譯這個JSP文件。
編譯的過程包括三個步驟：
- 解析JSP文件。
- 將JSP文件轉為servlet。
- 編譯servlet。
JSP初始化階段
容器載入JSP文件后，它會在為請求提供任何服務前調用jspInit()方法。如果您需要執行自定義的JSP初始化任務，復寫jspInit()方法就行了，就像下面這樣：
public void jspInit(){// 初始化代碼 }般來講程序只初始化一次，servlet也是如此。通常情況下您可以在jspInit()方法中初始化數據庫連接、打開文件和創建查詢表。
JSP執行階段
這一階段描述了JSP生命周期中一切與請求相關的交互行為，直到被銷毀。
當JSP網頁完成初始化后，JSP引擎將會調用_jspService()方法。
_jspService()方法需要一個HttpServletRequest對象和一個HttpServletResponse對象作為它的參數，就像下面這樣：
void _jspService(HttpServletRequest request,HttpServletResponse response) {// 服務端處理代碼 }_jspService()方法在每個request中被調用一次并且負責產生與之相對應的response，并且它還負責產生所有7個HTTP方法的回應，比如GET、POST、DELETE等等。
JSP銷毀階段
JSP生命周期的銷毀階段描述了當一個JSP網頁從容器中被移除時所發生的一切。
jspDestroy()方法在JSP中等價于servlet中的銷毀方法。當您需要執行任何清理工作時復寫jspDestroy()方法，比如釋放數據庫連接或者關閉文件夾等等。
jspDestroy()方法的格式如下：
public void jspDestroy() {// 清理代碼 }案例
創建一個index.jsp 將下面的 代碼 復制到 jsp頁面中 然后運行Tomcat
訪問http://localhost:8081/java_Web/index.jsp 看看 控制臺打印效果 已經頁面顯示的內容
<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%> <html> <head> <title>life.jsp</title> </head> <body><%! private int initVar=0;private int serviceVar=0;private int destroyVar=0; %><%!public void jspInit(){initVar++;System.out.println("jspInit(): JSP被初始化了"+initVar+"次");}public void jspDestroy(){destroyVar++;System.out.println("jspDestroy(): JSP被銷毀了"+destroyVar+"次");} %><%serviceVar++;System.out.println("_jspService(): JSP共響應了"+serviceVar+"次請求");String content1="初始化次數 : "+initVar;String content2="響應客戶請求次數 : "+serviceVar;String content3="銷毀次數 : "+destroyVar; %> <h1>w3cschool教程 JSP 測試實例</h1> <p><%=content1 %></p> <p><%=content2 %></p> <p><%=content3 %></p></body> </html>頁面顯示
IDEA 控制臺
jspInit(): JSP被初始化了1次
_jspService(): JSP共響應了1次請求
然后你在關閉Tomcat 試試
IDEA 控制臺
jspDestroy(): JSP被銷毀了1次
Disconnected from server
不要去糾結 到底 怎么使用 這些都不重要 因為基本不會怎么使用這些 當然你想使用就使用當我沒說
JSP 語法
一下只是講解 jsp 中的 語法 而詳細教程在 后面會慢慢道來
腳本程序
腳本程序 可以包含任意量的Java語句、變量、方法或表達式，只要它們在腳本中是正確的代碼。
就好比 java中的 public class className{ 內容… }
腳本程序的語法格式：
<% 代碼片段 %>任何文本、HTML標簽、JSP元素必須寫在腳本程序的外面。
下面給出一個示例
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %> <html> <head><title>hello</title> </head> <body>Hello World!<br/> <%out.println("你的 IP 地址 是 " + "<h1>" + request.getRemoteAddr() + "</h1>"); %></body> </html>out.println 和 out.print 就是內容輸出到頁面中 會解析 HTML標簽的 把他當成java中的System.out,println()就行了
這里順帶解決一個常見的問題 如果你將上面的代碼復制到IDEA 中發現 代碼都爆紅
出現這個原因是沒有導入 Tomcat 到項目里
解決辦法:
然后apply -> 0k 保存就行 稍等一下 你就發現 不報錯了 能找到這些代碼了
然后我們運行 Tomcat 訪問 http://localhost:8081/java_Web/index.jsp
遇到了request.getRemoteAddr()獲取的值為0:0:0:0:0:0:0:1，這是為什么呢，照道理講，應該是127.0.0.1才對，為什么這個獲取的值變成了ipv6了呢，而且我發現這種情況只有在服務器和客戶端都在同一臺電腦上才會出現 所以 不用管它 自己明白就行
JSP聲明
一個聲明語句可以聲明一個或多個變量、方法，供后面的Java代碼使用。在JSP文件中，您必須先聲明這些變量和方法然后才能使用它們。
就好比 java中 類里聲明成員變量
JSP聲明的語法格式：
<%! 變量 %>示例:
<%@ page import="javafx.scene.shape.Circle" %> <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %> <html> <head><title>hello</title> </head> <body><%! int i = 1; %> <%! int a, b=2, c; %> <%! Circle cle = new Circle(2.0); %> <%out.println(i+"<br/>");out.println(a+"_"+b+"_"+c+"<br/>");out.println(cle); %> </body> </html>JSP表達式
一個JSP表達式中包含的腳本語言表達式，先被轉化成String，然后插入到表達式出現的地方。
由于表達式的值會被轉化成String，所以您可以在一個文本行中使用表達式而不用去管它是否是HTML標簽。
表達式元素中可以包含任何符合Java語言規范的表達式，但是不能使用分號來結束表達式。
也就相當于就一條java語句 但是必須有輸出內容 就好比是java 中的 String a=123; 等號右邊必須有內容
JSP表達式的語法格式：
<%= 表達式 %>示例：
將當前時間戳 轉換為時間字符串
Today's date: <%= (new java.util.Date()).toLocaleString()%>頁面顯示
Today’s date: 2020-11-17 22:54:08
JSP注釋
JSP注釋主要有兩個作用：為代碼作注釋以及將某段代碼注釋掉。 該注釋在網頁中不會被顯示-
JSP注釋的語法格式：
<%-- 這里可以填寫 JSP 注釋 --%>不同情況下使用注釋的語法規則：
| <%-- 注釋 --%> | JSP注釋，注釋內容不會被發送至瀏覽器甚至不會被編譯 |
| <!-- 注釋 --> | HTML注釋，通過瀏覽器查看網頁源代碼時可以看見注釋內容 |
JSP指令
JSP指令用來設置整個JSP頁面相關的屬性，如網頁的編碼方式和腳本語言。
JSP指令語法格式：
<%@ directive attribute="value" %>指令可以有很多個屬性，它們以鍵值對的形式存在，并用逗號隔開。
JSP中的三種指令標簽：
| <%@ page … %> | 定義網頁依賴屬性，比如腳本語言、error頁面、緩存需求等等 |
| <%@ include … %> | 包含其他文件 |
| <%@ taglib … %> | 引入標簽庫的定義 |
<%@ page %>指令
Page指令為容器提供當前頁面的使用說明。一個JSP頁面可以包含多個page指令。
Page指令的語法格式：
<%@ page attribute="value" %>屬性
下表列出與Page指令相關的屬性：
| buffer | 指定out對象使用緩沖區的大小 |
| autoFlush | 控制out對象的 緩存區 |
| contentType | 指定當前JSP頁面的MIME類型和字符編碼 |
| errorPage | 指定當JSP頁面發生異常時需要轉向的錯誤處理頁面 |
| isErrorPage | 指定當前頁面是否可以作為另一個JSP頁面的錯誤處理頁面 |
| extends | 指定servlet從哪一個類繼承 |
| import | 導入要使用的Java類 |
| info | 定義JSP頁面的描述信息 |
| isThreadSafe | 指定對JSP頁面的訪問是否為線程安全 |
| language | 定義JSP頁面所用的腳本語言，默認是Java |
| session | 指定JSP頁面是否使用session |
| isELIgnored | 指定是否執行EL表達式 (默認true) |
| isScriptingEnabled | 確定腳本元素能否被使用 |
| pageEncoding | 當前頁面的編碼格式 |
列:
<%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %><%@ Include %>指令
JSP可以通過include指令來包含其他文件。被包含的文件可以是JSP文件、HTML文件或文本文件。包含的文件就好像是該JSP文件的一部分，會被同時編譯執行。最后會被整合 成一個 Servlet .class
注意: 使用 include 指令是以靜態方式包含文件 簡單來說就是合二為一 ,原封不動地附加到當前文件中 所以要避免重復的代碼 和變量 等邏輯。
例如:里面不要包含<html> <body> … 這樣的標簽，因為是把源代碼原封不動的附加過來，所以會與當前的jsp中的這樣的標簽重復導致出錯。
但是也是有好處的 就是 js 和jsp … 變量方法等共享 你可以在 Include指令 后面修改包含頁面內 變量的內容 從而改變包含頁面的狀態
為了避嫌 html 和jsp 中文亂碼的情況 在項目的web.xml中添加
<jsp-config><jsp-property-group><url-pattern>*.html</url-pattern><url-pattern>*.jsp</url-pattern><page-encoding>UTF-8</page-encoding></jsp-property-group></jsp-config>Include指令的語法格式如下：
<%@ include file="url" %>創建一個index1.html
<h1>index1.html O(∩_∩)O哈哈~</h1>創建一個index1.jsp
<h1>index1.jsp O(∩_∩)O哈哈~</h1>創建一個index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %> <html> <head><title>index</title> </head> <body> <%@ include file="index1.html" %> <%@ include file="index1.jsp" %> <h1>index.jsp</h1></body> </html>頁面顯示
<%@ Taglib %>指令
在JSP頁面中使用第三方的標簽庫時，需要使用taglib指令來“導包”
Taglib指令的語法：
<%@ taglib uri="uri" prefix="prefixOfTag" %>uri屬性確定標簽庫的位置，prefix屬性指定標簽庫的前綴。
比如引入JSTL標簽庫
<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c"%>然后我們就可以在當前頁面使用JSTL語法了
JSP行為
JSP行為標簽使用XML語法結構來控制servlet引擎。它能夠動態插入一個文件，重用JavaBean組件，引導用戶去另一個頁面，為Java插件產生相關的HTML等等。
行為標簽只有一種語法格式，它嚴格遵守XML標準：
<jsp:action_name attribute="value" />行為標簽基本上是一些預先就定義好的函數，下表羅列出了一些可用的JSP行為標簽：
| jsp:include | 用于在當前頁面中包含靜態或動態資源 |
| jsp:useBean | 尋找和初始化一個JavaBean組件 |
| jsp:setProperty | 設置 JavaBean組件的值 配合 jsp:useBean使用 |
| jsp:getProperty | 輸出某個JavaBean的屬性。 配合 jsp:useBean 使用 |
| jsp:forward | 把請求轉到一個新的頁面 (轉發) |
至于其他的行為 就沒什么卵用了 這里就不 在寫了
<jsp:include>行為元素
<jsp:include>行為元素用來包含靜態和動態的文件。該行為把指定文件插入正在生成的頁面。語法格式如下：
<jsp:include page="URL" flush="true" />前面已經介紹過include指令，就相當于兩個文件內容 合二為一 生成一個.class文件，
而這里的jsp:include動作不同， 相當于生成 二個.class文件 他們內容 互不相關 不會有 標簽 變量…沖突問題 但是都會顯示在同一個頁面中 因為 當我們請求 原文jsp文件的時候 他內部就會請求 包含的jsp文件 也就是 插入文件的時間是在頁面被請求的時候。
以下是include動作相關的屬性列表。
| page | 包含在頁面中的相對URL地址。 |
| flush | 布爾屬性，定義在包含資源前是否刷新緩存區。 |
列:
創建index1.html
<!DOCTYPE html> <html lang="en"> <head><meta charset="UTF-8"><title>Title</title> </head> <body> <h1>index1.html ^_^</h1> </body> </html>創建index1.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head><title>Title</title> </head> <body> <h1> index1.jsp ^_^</h1> </body> </html>創建index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %> <html> <head><title>index</title> </head> <body><jsp:include page="index1.html" flush="true" /> <jsp:include page="index1.jsp" flush="true" /><h1>index.jsp</h1></body> </html>頁面顯示:
<jsp:useBean>行為元素
jsp:useBean動作用來裝載一個將在JSP頁面中使用的JavaBean。
這個功能非常有用，因為它使得我們既可以發揮Java組件重用的優勢， 但是必須準守 JavaBean API 規范
必須是 無慘構造 有get set 方法 需要被序列化并且實現了 Serializable 接口
jsp:useBean動作最簡單的語法為：
<jsp:useBean id="對象名稱" class="類的包路徑" />至于其他屬性 沒什么卵用 就別浪費時間研究了
在類載入后 相當于new 對象 id就是對象的名稱，我們既可以通過 jsp:setProperty 和 jsp:getProperty 動作來修改和獲取bean的屬性。
演示:
public class TestBean {private String message = "No message specified";public String getMessage() {return(message);}public void setMessage(String message) {this.message = message;} }然后重啟Tomcat 會自動編譯 TestBean 成TestBean.class 之后我們在jsp頁面才能使用,否則會報錯
然后在index.jsp頁面使用下面代碼
<center><h2>Using JavaBeans in JSP</h2><jsp:useBean id="test" class="co.boke.test.TestBean" /><jsp:getProperty name="test" property="message" /><br/><jsp:setProperty name="test" property="message" value="Hello"/><jsp:getProperty name="test" property="message" /></center><jsp:forward> 行為元素
jsp:forward動作把請求轉到另外的頁面。jsp:forward標記只有一個屬性page。語法格式如下所示：
<jsp:forward page="URL" />page屬性包含的是一個相對URL。page的值既可以直接給出，也可以在請求的時候動態計算，可以是一個JSP頁面或者一個 Java Servlet.
比如:
創建index1.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head><title>Title</title> </head> <body><p>Today's date: <%= (new java.util.Date()).toLocaleString()%> </p></body> </html>創建index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %> <html> <head><title>index</title> </head> <body><%! int num = 2; %><% if (num == 2) {%> <jsp:forward page="index1.jsp"/> <% } %></body> </html>if 滿足條件 轉發請求 到 index1.jsp頁面
JSP9大內置對象和4大作用域以及Cookie
JSP支持九個自動定義的變量，江湖人稱隱含對象。這九個隱含對象的簡介見下表：
| request(請求) | 用于向客戶端發送和獲取數據 作用范圍一次請求 |
| response(響應) | 用于響應客戶端請求 比如設置 響應頭 狀態碼 … |
| out(輸出) | 用于把結果輸出至網頁上 比如 out.println() |
| session(會話) | 用于向客戶端發送和獲取數據 作用范圍是一次會話 |
| application(應用程序) | 用于向客戶端發送和獲取數據 作用范圍是將Tomcat服務關閉 |
| config(配置對象) | 代表當前JSP 配置信息, 但JSP 頁面通常無須配置,因此也就不存在配置信息 很少使用 |
| pageContext(頁面上下文對象) | 可以訪問頁面中所有作用域 以及一些頁面屬性 和設置 |
| page(頁面對象) | 用于向客戶端發送和獲取數據 作用范圍 類似于java的 this 表示當前頁面 |
| Exception(異常對象) | 表示jsp頁面運行時產生的異常和報錯信息 該對象只有在錯誤頁面<%@ page 指令中設置isErrorPage 為true 的頁面 中才能使用 很少使用 |
| Cookie(小型文本文件) | 這個就是將數據以鍵值對形式 保存在當前游覽器的Cookie里 也就是本地電腦里 可以通過游覽器查看到 |
四大作用域是: page, request , session , application
和servlet 的9個內置對象 用法一樣 我們就不啰嗦了
然后還有一個特殊對象Cookie 這個就不陌生把
接下來我們把 page , request , response , session , application , pageContext, Cookie 這7大常用的對象 詳細講一遍
至于其他的 反正我基本沒怎么用過
這里注意: Servler 和jsp 都是一樣的 可以互通 但是為了方便 我們 就使用2個 jsp頁面來演示上面的方法
page(當前頁)
四大作用域之一page
page 對象是為了執行當前頁面應答請求而設置的 Servlet 類的實體，即顯示 JSP 頁面自身，與類的 this 指針類似，使用它來調用 Servlet 類中所定義的方法，只有在本頁面內才是合法的。它是 java.lang.Object 類的實例，對于開發 JSP 比較有用。表 1 列出了 page 對象常用的方法。
| class getClass() | 返回當前 Object 的類 |
| int hashCode | 返回 Object 的 hash 代碼 |
| String toString | 把 Object 對象轉換成 String 類的對象 |
| boolean equals(Object obj) | 比較對象和指定的對象是否相等 |
| void copy (Object obj) | 把對象拷貝到指定的對象中 |
| Object clone() | 復制對象(克隆對象) |
創建index.jsp
<%Object obj;obj=null; %>返回當前頁面所在類：<%=page.getClass()%> <br> 返回當前頁面的 hash 代碼：<%=page.hashCode()%> <br> 轉換成 String 類的對象：<%=page.toString()%> <br> 比較1：<%=page.equals(obj) %> <br> 比較2：<%=page.equals(this) %>頁面顯示
返回當前頁面所在類：class org.apache.jsp.index_jsp 返回當前頁面的 hash 代碼：1772279684 轉換成 String 類的對象：org.apache.jsp.index_jsp@69a2d784 比較1：false 比較2：truerequest (轉發)
四大作用域之一request
客戶端可通過 HTML 表單或在網頁地址后面提供參數的方法提交數據，然后通過 request 對象的相關方法來獲取這些數據。request 對象封裝了客戶端的請求信息，包括用戶提交的信息以及客戶端的一些信息，服務端通過 request 對象可以了解到客戶端的需求，然后做出響應。
request 對象是 HttpServletRequest(接口)的實例。請求信息的內容包括請求的標題頭(Header)信息(如瀏覽器的版本信息語言和編碼方式等)，請求的方式(如 HTTP 的 GET 方法、POST 方法等)，請求的參數名稱、參數值和客戶端的主機名稱等。
request 對象提供了一些方法，主要用來處理客戶端瀏覽器提交的請求中的各項參數和選項。表 1 列出了 request 對象常用的方法。下面介紹 request 對象的應用。
什么是轉發?
比如頁面1 轉發到頁面2 那么頁面2在轉發到頁面3 此時頁面3 將不能獲取到頁面1 的內容
大部分的方法 都是獲取信息 get
| String getParameter(String name) | 返回指定name的值 多個name 只能獲取第一個 |
| String[] getParameterValues(String name) | 獲取 獲取一組name相同的數據 返回的是數組 |
| Map<String,String[]> request.getParameterMap(); | 將前端傳來的數據 封裝到map中 |
| Enumeration getParameterNames() | 返回請求中所有參數的名稱集合 |
| void setAttribute(String,Object) | 存儲此請求中的屬性 |
| Object getAttribute(String name) | 返回指定屬性的屬性值 |
| Enumeration getAttributeNames() | 返回request對象的所有屬性名稱的集合 |
| void setCharacterEncoding(String charset) | 設置請求的字符編碼方式 可以用于解決中文亂碼問題 |
| String getRemoteAddr() | 返回發送此請求的客戶端IP地址 |
| String getRequestURI() | 返回發送此請求的URI |
| String getServletPath() | 返回所請求的servlet路徑 |
| String request.getContextPath() | 獲取當前web(虛擬目錄) 如果沒有那么就空 |
| Cookie[] getCookies() | 返回客戶端所有的Cookie的數組 |
| String getMethod() | 得到客戶機請求方式 比如 GET,，POST，或PUT |
| String getRequestedSessionId() | 返回request的session ID |
| boolean isSecure() | 返回request是否使用了加密通道，比如HTTPS |
| voie request.getRequestDispatcher(path).forward(request,response); | 將請求轉發給指定頁面 |
| String request.getHeader(String key) | 獲取游覽器的請求頭信息 |
還有很多方法這里 就不一 一列出來了 以上方法都夠你吃一壺的了 而且常用的就幾個下面我會演示的
出現請求的數據是 中文亂碼的情況
比如: 頁面1 給頁面2 轉發數據 頁面2出現中文亂碼了 那么在頁面2開頭位置加上下面代碼
<%//設置請求的字符編碼方式 utf-8request.setCharacterEncoding("utf-8"); %>轉發-參數獲取和設置
演示下面方法的用法
常用語 2個不同頁面之間的傳值
-
void request.setAttribute (String,Object)
-
Object request.getAttribute (String,Object)
-
Enumeration<String> getAttributeNames()
-
void request.getRequestDispatcher(path).forward(request,response);
創建 index.jsp
<% request.setAttribute("Name","HuAnmin"); //設置request值 request.setAttribute("Pass","123"); request.getRequestDispatcher("index1.jsp").forward(request,response); // 將request 轉發 %>創建index1.jsp
<%//設置 請求 和響應 的格式都是 utf-8request.setCharacterEncoding("utf-8"); %><%-- 獲取轉發來的request內的值--%>姓名:<%=request.getAttribute("Name")%><br> 你的密碼是:<%=request.getAttribute("Pass")%><br><br>所有的request里的key和value<br> <%Enumeration<String> attributeNames = request.getAttributeNames();while(attributeNames.hasMoreElements()){String name=attributeNames.nextElement(); //獲取 name 名稱if(name.contains("javax.servlet.forward")){ //過濾掉不用的信息continue;}String value=(String) request.getAttribute(name); //通過name 獲取值out.print(name + "=" + value+"<br/>");}%>轉發到 index1.jsp頁面顯示
姓名:HuAnmin 你的密碼是:123所有的request里的key和value Pass=123 Name=HuAnminurl參數和表單name獲取
演示下面方法的用法
常用于 url參數 和 表單提交的數據
-
String getParameter(String name) 如果是多個name那么只獲取第一個
-
String[] getParameterValues(String name)
-
Enumeration getParameterNames()
創建 index.jsp
<form action="index1.jsp" method="post">賬戶:<input type="text" name="UserName" value="HuAnmin" placeholder="請輸入你的賬戶"><br>密碼:<input type="text" name="PassWord" value="123" placeholder="請輸入你的密碼"><br>愛好:<input type="checkbox" name="AiHao" value="游泳" checked="checked">游泳<input type="checkbox" name="AiHao" value="跑步" checked="checked">跑步<input type="checkbox" name="AiHao" value="跳遠">跳遠<br><input type="submit" value="點擊"> </form><a href="index1.jsp?UserName=ABC&&PassWord=123&&AiHao=上網&&AiHao=打代碼">GET Parameter</a>創建index1.jsp
<%-- 獲取表單 或 url參數 的值--%><%//設置 請求 和響應 的格式都是 utf-8request.setCharacterEncoding("utf-8"); %> 賬戶:<%=request.getParameter("UserName")%><br> 密碼:<%=request.getParameter("PassWord")%><br> 愛好: <%= Arrays.toString(request.getParameterValues("AiHao"))%> <br><br> 全部參數 <br> <%Enumeration<String> attributeNames = request.getParameterNames();while(attributeNames.hasMoreElements()){String name=attributeNames.nextElement(); //獲取 name 名稱String value=request.getParameter(name); //通過name 獲取值out.print(name + "=" + value+"<br/>");}%>表單提交到 index1.jsp頁面顯示
賬戶:HuAnmin 密碼:123 愛好: [游泳, 跑步]全部參數 UserName=HuAnmin PassWord=123 AiHao=游泳點超鏈接 index1.jsp頁面顯示
賬戶:ABC 密碼:123 愛好: [上網, 打代碼]全部參數 UserName=ABC PassWord=123 AiHao=上網url參數獲取和表單name 之Map映射實體類
演示下面方法的用法
url參數 和表單name 常用于 映射javaBean 因為如果表單太大的話 我們自己 手動映射實體類太慢了
要求必須 表單或者url 的key 的名稱 和 實體類的 成員變量名一致 并且 實體類實現get set 方法
- Map<String,String[]> request.getParameterMap();
需要的jar
鏈接：https://pan.baidu.com/s/18x2eJyr3qaBEgom1Uvpmcw
提取碼：1234
復制這段內容后打開百度網盤手機App，操作更方便哦–來自百度網盤超級會員V4的分享
或者在pom.xml中添加Maven
<dependency><groupId>commons-beanutils</groupId><artifactId>commons-beanutils</artifactId><version>1.9.3</version></dependency>二選一
創建一個MyUser 實體類
public class MyUser {private String name;private String pass;private String aiHao;// 自己補充 get set toString}創建index.jsp
<form action="index1.jsp" method="post">賬戶:<input type="text" name="name" value="HuAnmin" placeholder="請輸入你的賬戶"><br>密碼:<input type="text" name="pass" value="123" placeholder="請輸入你的密碼"><br>愛好:<input type="checkbox" name="aiHao" value="游泳" checked="checked">游泳<input type="checkbox" name="aiHao" value="跑步" checked="checked">跑步<input type="checkbox" name="aiHao" value="跳遠">跳遠<br><input type="submit" value="點擊"> </form>創建index1.jsp
<%//設置 請求 和響應 的格式都是 utf-8request.setCharacterEncoding("utf-8"); %>--------普通用法--------<br> <%Map<String,String[]> name1=request.getParameterMap();out.println("賬戶"+name1.get("name")[0]+"<br/>");out.println("密碼"+name1.get("pass")[0]+"<br/>");out.println("愛好"+ Arrays.toString(name1.get("aiHao")) +"<br/>");%>-------------映射實體類-------------<br> <%Map<String, String[]> parameterMap = request.getParameterMap();MyUser user=new MyUser(); //是這個包 import org.apache.commons.beanutils.BeanUtils;try {BeanUtils.populate(user,parameterMap); //將map對象中的值 按照key的名稱和對象內的成員名稱進行映射 (必須提供set 和get)} catch (IllegalAccessException | InvocationTargetException e) {e.printStackTrace();}out.println(user); //打印實體類 %>表單提交到 index1.jsp頁面顯示
--------普通用法-------- 賬戶HuAnmin 密碼123 愛好[游泳, 跑步] -------------映射實體類------------- MyUser{name='HuAnmin', pass='123', aiHao='游泳'}轉發常用內置參數獲取
演示下面方法的用法
-
String request.getServletPath()
-
String request.getRequestURI()
-
String request. getRemoteAddr()
-
String request.getContextPath()
-
String request.getMethod()
-
String request. isSecure()
-
String getRequestedSessionId()
創建index.jsp
<% request.getRequestDispatcher("/index1.jsp").forward(request,response); %>創建index1.jsp
<%//設置 請求 和響應 的格式都是 utf-8request.setCharacterEncoding("utf-8"); %><%out.println("請求的servlet路徑"+request.getServletPath()+"<br>");out.println("請求的URI: "+request.getRequestURI()+"<br>");out.println("客戶端IP地址:"+request.getRemoteAddr()+"<br>");out.println("虛擬路徑: "+request.getContextPath()+"<br>");out.println("請求方式: "+request.getMethod()+"<br>");out.println("是否使用了加密通道(HTTPS): "+request. isSecure()+"<br>");out.println("返回請求的session ID : "+request. getRequestedSessionId()+"<br>"); %>轉發到 index1.jsp頁面顯示
請求的servlet路徑/index1.jsp 請求的URI: /java_Web/index1.jsp 客戶端IP地址:0:0:0:0:0:0:0:1 虛擬路徑: /java_Web 請求方式: GET 是否使用了加密通道(HTTPS): false 返回請求的session ID : 71720FDE92375A2DDAD3BFC10D2A0DC7獲取游覽器的請求頭信息
演示下面方法的用法
用的不多 因為一般都是設置而不是獲取
- String request.getHeader(String key)
| Accept | 指定瀏覽器或其他客戶端可以處理的MIME類型。它的值通常為 image/png 或 image/jpeg |
| Accept-Charset | 指定瀏覽器要使用的字符集。比如 ISO-8859-1 |
| Accept-Encoding | 指定編碼類型。它的值通常為 gzip 或compress |
| Accept-Language | 指定客戶端首選語言，servlet會優先返回以當前語言構成的結果集，如果servlet支持這種語言的話。比如 en，en-us，ru等等 |
| Authorization | 在訪問受密碼保護的網頁時識別不同的用戶 |
| Connection | 表明客戶端是否可以處理HTTP持久連接。持久連接允許客戶端或瀏覽器在一個請求中獲取多個文件。Keep-Alive 表示啟用持久連接 |
| Content-Length | 僅適用于POST請求，表示 POST 數據的字節數 |
| Cookie | 返回先前發送給瀏覽器的cookies |
| Host | 指出原始URL中的主機名和端口號 |
| If-Modified-Since | 表明只有當網頁在指定的日期被修改后客戶端才需要這個網頁。 服務器發送304碼給客戶端，表示沒有更新的資源 |
| If-Unmodified-Since | 與If-Modified-Since相反， 只有文檔在指定日期后仍未被修改過，操作才會成功 |
| Referer | 標志著所引用頁面的URL。比如，如果你在頁面1，然后點了個鏈接至頁面2，那么頁面1的URL就會包含在瀏覽器請求頁面2的信息頭中 |
| User-Agent | 用來區分不同瀏覽器或客戶端發送的請求，并對不同類型的瀏覽器返回不同的內容 |
創建index.jsp
Header: <%=request.getHeader("Host")%><br> Header: <%=request.getHeader("Accept")%><br> Header: <%=request.getHeader("Cookie")%><br> Header: localhost:8081 Header: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8 Header: JSESSIONID=71720FDE92375A2DDAD3BFC10D2A0DC7response(請求)
Response響應對象主要將JSP容器處理后的結果傳回到客戶端?？梢酝ㄟ^response變量設置HTTP的狀態和向客戶端發送數據，如Cookie、HTTP文件頭信息等。
response對象的常用方法
| String encodeRedirectURL(String url) | 對sendRedirect()方法使用的URL進行編碼 |
| String encodeURL(String url) | 將URL編碼，回傳包含Session ID的URL |
| boolean containsHeader(String name) | 返回指定的響應頭是否存在 |
| boolean isCommitted() | 返回響應是否已經提交到客戶端 |
| void addCookie(Cookie cookie) | 添加指定的cookie至響應中 |
| void addDateHeader(String name, long date) | 添加指定名稱的響應頭和日期值 |
| void addHeader(String name, String value) | 添加指定名稱的響應頭和值 |
| void addIntHeader(String name, int value) | 添加指定名稱的響應頭和int值 |
| void flushBuffer() | 將任何緩存中的內容寫入客戶端 |
| void reset() | 清除任何緩存中的任何數據，包括狀態碼和各種響應頭 |
| void resetBuffer() | 清除基本的緩存數據，不包括響應頭和狀態碼 |
| void sendError(int sc) | 使用指定的狀態碼向客戶端發送一個出錯響應，然后清除緩存 |
| void sendError(int sc, String msg) | 使用指定的狀態碼和消息向客戶端發送一個出錯響應 |
| void sendRedirect(String location) | 使用指定的URL向客戶端發送一個臨時的間接響應 |
| void setBufferSize(int size) | 設置響應體的緩存區大小 |
| void setCharacterEncoding(String charset) | 指定響應的編碼集（MIME字符集），例如UTF-8 |
| void setContentLength(int len) | 指定HTTP servlets中響應的內容的長度，此方法用來設置 HTTP Content-Length 信息頭 |
| void setContentType(String type) | 設置響應的內容的類型，如果響應還未被提交的話 |
| void setDateHeader(String name, long date) | 使用指定名稱和值設置響應頭的名稱和內容 |
| void setHeader(String name, String value) | 使用指定名稱和值設置響應頭的名稱和內容 |
| void setIntHeader(String name, int value) | 使用指定名稱和值設置響應頭的名稱和內容 |
| void setLocale(Locale loc) | 設置響應的語言環境，如果響應尚未被提交的話 |
| void setStatus(int sc) | 設置響應的狀態碼 |
動態設置響應的類型
利用 <%@ page %> 指令設置發送到客戶端文檔響應報頭的 MIME 類型和字符編碼，
如<%@ page contentType=“text/html;charset=utf-8”%>，它表示當用戶訪問該頁面時，JSP 引擎將按照 contentType 的屬性值即 text/html(網頁)做出反應。
如果要動態改變這個屬性值來響應客戶，就需要使用 response 對象的 setContentType(String s) 方法。語法格式如下：
response.setContentType("MIME");MIME 可以為 :
-
text/css :客戶端瀏覽器按CSS格式進行解析文檔
-
text/xml :客戶端瀏覽器按XML格式進行解析文檔
-
text/html : (網頁)
-
image/jpeg png jpg … 客戶端瀏覽器按指定格式進行解析文檔
-
image/gif gif動畫
-
video/mp4 mp4 視頻
-
text/plain 文本
-
application/zip 壓縮
-
application/pdf pdf 文檔
-
text/json json字符串
-
application/x-msexcel(Excel 文件)
-
application/msword(Word 文件)
-
…
可能大家看不懂到底有什么樣 我這樣告訴你 用處大這呢
下面是一個 小 的案例將后臺圖片 顯示在網頁上 常用于二維碼掃描
<%response.setCharacterEncoding("utf-8");response.setContentType("image/jpg"); //修改當前頁面為long startTime = System.currentTimeMillis();ServletContext application1 = request.getServletContext();//填寫 相對路徑 String ap=application1.getRealPath("img/test.jpg");try (FileInputStream fis1=new FileInputStream(ap);BufferedInputStream fis=new BufferedInputStream(fis1);ServletOutputStream outputStream = response.getOutputStream();){byte[] data=new byte[4096];int len;while( (len=fis.read(data) )!= -1) {outputStream.write(data,0,len);//寫入數據}} catch (IOException e) {e.printStackTrace();return;}long endTime = System.currentTimeMillis();System.out.println("緩沖字節流復制視頻花費時間為：" + (endTime - startTime)); %>你在運行看看效果
重定向網頁
在某些情況下，當響應客戶時，需要將客戶引導至另一個頁面，例如，當客戶輸入正確的登錄信息時，就需要被引導到登錄成功頁面，否則被引導到錯誤顯示頁面。此時，可以使用 response 的 sendRedirect(URL) 方法將客戶請求重定向到一個不同的頁面。
這里注意: 是重定向 而不是轉發 重定向后上一個頁面的數據將丟失
效果等同于 html 中的 <a href=“” >標簽
例如，將客戶請求重定向到 login.jsp 頁面的代碼如下：
response.sendRedirect("login.jsp");錯誤狀態
| 100 | Continue | 只有一部分請求被服務器接收，但只要沒被服務器拒絕，客戶端就會延續這個請求 |
| 101 | Switching Protocols | 服務器交換機協議 |
| 200 | OK | 請求被確認 |
| 201 | Created | 請求已完成，新的資源被創建 |
| 202 | Accepted | 請求被接受，但未處理完 |
| 203 | Non-authoritative Information | |
| 204 | No Content | |
| 205 | Reset Content | |
| 206 | Partial Content | |
| 300 | Multiple Choices | 一個超鏈接表，用戶可以選擇一個超鏈接并訪問，最大支持5個超鏈接 |
| 301 | Moved Permanently | 被請求的頁面已經移動到了新的URL下 |
| 302 | Found | 被請求的頁面暫時性地移動到了新的URL下 |
| 303 | See Other | 被請求的頁面可以在一個不同的URL下找到 |
| 304 | Not Modified | |
| 305 | Use Proxy | |
| 306 | Unused | 已經不再使用此狀態碼，但狀態碼被保留 |
| 307 | Temporary Redirect | 被請求的頁面暫時性地移動到了新的URL下 |
| 400 | Bad Request | 服務器無法識別請求 |
| 401 | Unauthorized | 被請求的頁面需要用戶名和密碼 |
| 402 | Payment Required | 目前還不能使用此狀態碼 |
| 403 | Forbidden | 禁止訪問所請求的頁面 |
| 404 | Not Found | 服務器無法找到所請求的頁面 |
| 405 | Method Not Allowed | 請求中所指定的方法不被允許 |
| 406 | Not Acceptable | 服務器只能創建一個客戶端無法接受的響應 |
| 407 | Proxy Authentication Required | 在請求被服務前必須認證一個代理服務器 |
| 408 | Request Timeout | 請求時間超過了服務器所能等待的時間，連接被斷開 |
| 409 | Conflict | 請求有矛盾的地方 |
| 410 | Gone | 被請求的頁面不再可用 |
| 411 | Length Required | "Content-Length"沒有被定義，服務器拒絕接受請求 |
| 412 | Precondition Failed | 請求的前提條件被服務器評估為false |
| 413 | Request Entity Too Large | 因為請求的實體太大，服務器拒絕接受請求 |
| 414 | Request-url Too Long | 服務器拒絕接受請求，因為URL太長。多出現在把"POST"請求轉換為"GET"請求時所附帶的大量查詢信息 |
| 415 | Unsupported Media Type | 服務器拒絕接受請求，因為媒體類型不被支持 |
| 417 | Expectation Failed | |
| 500 | Internal Server Error | 請求不完整，服務器遇見了出乎意料的狀況 |
| 501 | Not Implemented | 請求不完整，服務器不提供所需要的功能 |
| 502 | Bad Gateway | 請求不完整，服務器從上游服務器接受了一個無效的響應 |
| 503 | Service Unavailable | 請求不完整，服務器暫時重啟或關閉 |
| 504 | Gateway Timeout | 網關超時 |
| 505 | HTTP Version Not Supported | 服務器不支持所指定的HTTP版本 |
在 JSP 頁面中，使用 response 對象中的 sendError() 方法指明一個錯誤狀態。該方法接收一個錯誤以及一條可選的錯誤消息，該消息將內容主體返回給客戶。
例如，代碼 response.sendError(500"請求頁面存在錯誤") 將客戶請求重定向到一個在內容主體上包含出錯消息的出錯頁面。
創建index.jsp
<form name="forml" method="post" action="index1.jsp">用戶名：<input name="user" type="text" /> <br>密 碼：<input name="pwd" type="text" /> <br><input type="submit" value="提交" /><input type="reset" value="重置" /> </form>創建index1.jsp
<%request.setCharacterEncoding("utf-8");String user=request.getParameter("user");String pwd=request.getParameter("pwd");if(user.equals("admin")&&pwd.equals("123"))//判斷賬戶密碼{response.sendRedirect("jsp/ok.jsp");}else{response.sendError(500,"請輸入正確的用戶和密碼!");} %>創建/jsp/ok.jsp
<h1>登錄成功</h1>當登錄失敗后
設置響應頭
常用的響應頭:
| Allow | 指定服務器支持的request方法（GET，POST等等） |
| Cache-Control | 指定響應文檔能夠被安全緩存的情況。通常取值為 public**，**private 或no-cache 等等。 Public意味著文檔可緩存，Private意味著文檔只為單用戶服務并且只能使用私有緩存。No-cache 意味著文檔不被緩存。 |
| Connection | 命令瀏覽器是否要使用持久的HTTP連接。close****值 命令瀏覽器不使用持久HTTP連接，而keep-alive 意味著使用持久化連接。 |
| Content-Disposition | 讓瀏覽器要求用戶將響應以給定的名稱存儲在磁盤中 |
| Content-Encoding | 指定傳輸時頁面的編碼規則 |
| Content-Language | 表述文檔所使用的語言，比如en， en-us,，ru等等 |
| Content-Length | 表明響應的字節數。只有在瀏覽器使用持久化 (keep-alive) HTTP 連接時才有用 |
| Content-Type | 表明文檔使用的MIME類型 |
| Expires | 指明啥時候過期并從緩存中移除 |
| Last-Modified | 指明文檔最后修改時間?？蛻舳丝梢?緩存文檔并且在后續的請求中提供一個 If-Modified-Since請求頭 |
| Location | 在300秒內，包含所有的有一個狀態碼的響應地址，瀏覽器會自動重連然后檢索新文檔 |
| Refresh | 指明瀏覽器每隔多久請求更新一次頁面。 |
| Retry-After | 與503 (Service Unavailable)一起使用來告訴用戶多久后請求將會得到響應 |
| Set-Cookie | 指明當前頁面對應的cookie |
response 對象的 setHeader() 方法用于設置指定名字的 HTTP 文件頭的值，如果該值已經存在，則新值會覆蓋舊值。最常用的一個頭信息是 refresh，用于設置刷新或者跳轉。
實現頁面一秒鐘刷新一次，設置語句如下:
response.setHeader("refresh","1");實現頁面定時跳轉，如 2 秒鐘后自動跳轉到URL所指的頁面，設置語句如下
response.setHeader("refresh","3;jsp/ok.jsp") ;例：用 response 對象自動刷新客戶頁面，實現秒表的功能，代碼如下：
<h2> response 對象設置頁面自動刷新</h2> <font size="5" color=blue> 數字時鐘 </font> <br> <br> <font size="3" color=blue> 現在時刻：<br><%response.setHeader("refresh","1");//每秒刷新一次頁面int y,m,d,h,mm,s;Calendar c=Calendar.getInstance();y=c.get(Calendar.YEAR); //年m=c.get(Calendar.MONTH)+1; //月d=c.get(Calendar.DAY_OF_MONTH); //日h=c.get(Calendar.HOUR); //時（HOUR：十二小時制：HOUR_OF_DAY：十二四小時制）mm=c.get(Calendar.MINUTE); //分s=c.get(Calendar.SECOND); //分out.println(y+"年"+m+"月"+d+"日"+h+"時"+mm+"分"+s+"秒");%> </font>轉發和重定向的區別
轉發 就是將頁面a 的數據轉發到頁面b( 處理后發現我好像處理不了) 然后可以在次使用轉發 將a頁面數據 轉發到頁面c(進行處理)
url 不變 還是a頁面的地址
(注意 轉發 不能訪問 項目之外 的資源 比如百度等等)
重定向 是將請求的url和狀態碼302返回給跳轉前的頁面然后讓他進行重新跳轉 url 變為 跳轉的url
也就是說重定向一次就會發送兩次請求
(重定向 可以訪問 項目之外的 資源 比如: https://www.baidu.com/)
也就是將頁面重請求新的頁面 url地址更換 和a標簽 一樣
不能進行上一個頁面數據的共享 因為url都變了 request作用域也就沒有了 所以request里的數據也就沒了
session(會話)
四大作用域之一session 數據是保存在服務端的
客戶與服務器之間的通信是通過 HTTP 協議完成的。HTTP 是一種無狀態的協議，當客戶向服務器發出請求，服務器接收請求并返回響應后，該連接就被關閉了。此時，服務器端不保留連接的有關信息，要想記住客戶的連接信息，可以使用 JSP 提供的 session 對象。
用戶登錄網站時，系統將為其生成一個獨一無二的 session 對象，用以記錄該用戶的個人信息。一旦用戶退出網站，那么，所對應的 session 對象將被注銷。session 對象可以綁定若干個用戶信息或者 JSP 對象，不同的 session 對象的同名變量是不會相互干擾的。
當用戶首次訪問服務器上的一個 JSP 頁面時，JSP 引擎便產生一個 session 對象，同時分配一個 String 類型的 ID 號，JSP 引擎同時將這個 ID 號發送到客戶端，存放在 Cookie 中，這樣，session 對象和客戶端之間就建立了一一對應的關系。
當用戶再次訪問該服務器的其他頁面時，不再分配給用戶新的 session 對象，直到用戶關閉瀏覽器，或者在一定時間(系統默認在 30 分鐘內，但可在編寫程序時，修改這個時間限定值或者顯式地結束一個會話)客戶端不向服務器發出應答請求，服務器端就會取消該用戶的 session 對象，與用戶的會話對應關系消失。當用戶重新打開瀏覽器，再次連接到該服務器時，服務器為該用戶再創建一個新的 session 對象。
session 對象保存的是每個用戶專用的私有信息，可以是與客戶端有關的，也可以是一般信息，可以根據需要設定相應的內容，并且所保存的信息在當前 session 屬性范圍內是共享的。
簡單來說:
session 的生命周期 就是本頁面的處理結果 在所有頁面關閉前都有效 也就是把游覽器關了(超過有效期 和總時間) 也會失效
也就跟打電話一樣 只要電話不斷就一直有效 而電話就是游覽器 但是會有時間限制默認30分鐘 沒有重定向 和 轉發的限制
不同游覽器之間數據不通用 因為每個會話的sessionid不同
session對象的常用方法:
| Object getAttribute(String name) | 獲取指定名字的屬性 |
| Enumeration getAttributeName() | 獲取 session 中全部屬性的名字，一個枚舉 |
| long getCreationTime() | 返回 session 的創建時間，單位：毫秒 |
| public String getld() | 返回創建 session 時 JSP 引擎為它設置的唯一 ID 號 |
| long getLastAccessedTime() | 返回此 session 中客戶端最近一次請求的時間。由 1970-01-01算起，單位是毫秒。使用這個方法，可以判斷某個用戶在站點上一共停留了多長時間 |
| int getMaxInactiveInterval() | 返回兩次請求間隔多長時間 session 被銷毀(單位：秒) |
| void setMaxlnactivelnterval(int interval) | 設置兩次請求間隔多長時間 session 被銷毀(單位：秒) |
| void invalidate() | 銷毀 session 對象 |
| boolean isNew() | 判斷請求是否會產生新的 session 對象 |
| void removeAttxibute(String name) | 刪除指定名字的屬性 |
| void setAttribute(String name,String value) | 設定指定名字的屬性值 |
使用 session 對象在不同的 JSP 文件(整個客戶會話過程，即 session scope)中保存屬性信息，比如用戶名、驗證信息等，最為典型的應用是實現網上商店購物車的信息存儲。下面重點介紹 session 對象的應用。
創建及獲取客戶會話屬性
JSP 頁面可以將任何對象作為屬性來保存。使用 setAttribute() 方法設置指定名稱的屬性，并將其存儲在 session 對象中，使用 getAttribute() 方法獲取與指定名字 name 相聯系的屬性。語法格式如下：
session.setAttribute(String name,String value); //參數name為屬性名稱，value為屬性值 session.getAttribute(String name); //參數 name 為屬性名稱例: 用 session 對象創建及獲取會話屬性。通過 session 對象的 setAttribute() 方法，將數據保存在 session 對象中，并通過 getAttribute() 方法取得數據的值，代碼如下：
創建index.jsp
<body>session 的創建時間：<%=new Date(session.getCreationTime()).toLocaleString() %> <br>session 的 ID 號：<%=session.getId() %> <br> <hr>當前時間：<%=new Date().toLocaleString( ) %> <br>該 session 是新創建的嗎？：<%=session.isNew()?"是":"否" %> <br> <hr>當前時間：<%=new Date().toLocaleString( ) %> <br><% session.setAttribute("info","您好，我們正在使用 session 對象傳遞數據！"); %>已向 Session 中保存數據，請單擊下面的鏈接將頁面重定向到 idnex1.jsp<a href="index1.jsp"> 請按這里</a> </body>創建index1.jsp
獲取 session 中的數據為：<br> <%=session.getAttribute("info")%>從會話中移除指定的對象
JSP 頁面可以將任何已經保存的對象部分或者全部移除。使用 removeAttribute() 方法，將指定名稱的對象移除，也就是說，從這個會話刪除與指定名稱綁定的對象。使用 invalidate() 方法，可以將會話中的全部內容刪除。語法格式如下：
session.removeAttribute(String name); //參數name為session對象的屬性名，代表要移除的對象名 session.invalidate(); //把保存的所有對象全部刪除在上面的案例中將index1.jsp改造
移除 session 中的數據后：<br> <%session.removeAttribute("info");if(session.getAttribute("info")==null){out.println("session 對象 info 已經不存在");}else{out.println(session.getAttribute("info"));};%>index1.jsp顯示
移除 session 中的數據后： session 對象 info 已經不存在設置會話時限
當某一客戶與 Web 應用程序之間處于非活動狀態時，并不以顯式的方式通知服務器，所以，在 Servlet 程序或 JSP 文件中，做超時設置是確?？蛻魰捊K止的唯一方法。
Servlet 程序容器設置一個超時時長，當客戶非活動的時間超出時長的大小時，JSP 容器將使 session 對象無效，并撤銷所有屬性的綁定，這樣，就清除了客戶申請的資源，從而實現了會話生命周期的管理。
session 用于管理會話生命周期的方法有 getLastAccessedTime()、getMaxInactiveInterval() 和 setMaxInactiveInterval(int interval)。
例: 為 session 對象設置會話時限。首先輸出 session 對象默認的有效時間，然后設置為 5 分鐘，并輸出新設置的有效時間。代碼如下：
<body>session 對象默認的有效時間：<%=session.getMaxInactiveInterval()%>秒<br><%session.setMaxInactiveInterval(60*5); //設置session的有效時間為5分鐘%>已經將 session 有效時間修改為：<%=session.getMaxInactiveInterval()%>秒<br> </body>頁面顯示
session 對象默認的有效時間：1800秒 已經將 session 有效時間修改為：300秒設置總默認會話時間
原本默認為30分鐘 也就是 1800秒
在配置文件web.xml里 添加
<session-config><session-timeout>60</session-timeout></session-config>然后使用下面的代碼看看
session 對象默認的有效時間：<%=session.getMaxInactiveInterval()%>秒<br>頁面顯示
session 對象默認的有效時間：3600秒設置
application(應用程序)
四大作用域之一application 數據保存在服務器里
JSP application 對象用于保存應用程序的公用數據，服務器啟動并自動創建 application 對象后，只要沒有關閉服務器，application 對象就一直存在，所有用戶共享 application 對象。
不同游覽之間都能 獲取 到application 內的值 因為值是保存在服務器上的 沒有session那樣的限制 需要sessionid
類似于系統的全局變量 也就是application里儲存的值 是可以被多個頁面同時調用的
application 對象的常用方法。
| getAttribute( String arg) | 獲取 application 對象中含有關鍵字的對象 |
| getAttributeNames() | 獲取 application 對象的所有參數名字 |
| getMajorVersion() | 獲取服務器支持 Servlet 的主版本號 |
| getMinorVersion() | 獲取服務器支持 Servlet 的從版本號 |
| removeAttribute(java.lang.String name) | 根據名字刪除 application 對象的參數 |
| setAttribute(String key,Object obj) | 將參數 Object 指定的對象 obj 添加到 application 對象中，并 為添加的對象指定一個索引關鍵字 |
例: 利用 application 對象查找 Servlet 有關的屬性信息，包括 Servlet 的引擎名、版本號、服務器支持的 Servlet API 的最大和最小版本號、指定資源的路徑等。代碼如下：
創建idnex.jsp
<body> JSP（SERVLET）引擎名及版本號: <%=application.getServerInfo()%><br> 服務器支持的 Server API 的最大版本號: <%=application.getMajorVersion ()%><br> 服務器支持的 Server API 的最小版本號: <%=application.getMinorVersion ()%><br> 指定資源（文件及目錄）的 URL 路徑: <%=application.getResource("index.jsp")%><br> 返回 index.jsp 虛擬路徑的真實路徑:<br> <%=application.getRealPath("index.jsp")%> </body>頁面顯示
JSP（SERVLET）引擎名及版本號: Apache Tomcat/9.0.29 服務器支持的 Server API 的最大版本號: 4 服務器支持的 Server API 的最小版本號: 0 指定資源（文件及目錄）的 URL 路徑: file:/C:/Users/12841/IdeaProjects/java-Web/target/java-Web/index.jsp 返回 index.jsp 虛擬路徑的真實路徑: C:\Users\12841\IdeaProjects\java-Web\target\java-Web\index.jsp管理應用程序屬性
application 對象與 session 對象相同，都可以設置屬性。但是，兩個屬性的有效范圍是不同的。
在 session 對象中，設置的屬性只在當前客戶的會話范圍(session scope)有效，客戶超過預期時間不發送請求時，session 對象將被回收。
在 application 對象中設置的屬性在整個應用程序范圍(application scope)都有效。即使所有的用戶都不發送請求，只要不關閉應用服務器，在其中設置的屬性也是有效的。
列: 用 application 對象的 setAttribute() 和 getAttribute() 方法 實現網頁計數器功能(記錄網站的訪問量)，代碼如下：
<%int n=0;if(application.getAttribute("num")==null)n=1;else{String str=application.getAttribute("num").toString();//getAttribute("num")返回的是Object類型n=Integer.valueOf(str).intValue()+1;}application.setAttribute("num",n);out.println("您好,您是第"+application.getAttribute("num")+"位訪問客戶！"); %>然后你刷新頁面看看效果
您好,您是第3位訪問客戶！out對象(輸出)
out 對象是一個輸出流，用來向客戶端輸出數據，可以是各種數據類型的內容，同時，它還可以管理應用服務器上的輸出緩沖區，緩沖區的默認值是 8KB，可以通過頁面指令 page 來改變默認大小。
out 對象是一個繼承自抽象類 javax.servlet.jsp.JspWriter 的實例，在實際應用中，out 對象會通過 JSP 容器變換為 java.io.PrintWriter 類的對象。
在使用 out 對象輸出數據時，可以對數據緩沖區進行操作，及時清除緩沖區中的殘余數據，為其他的輸出讓出緩沖空間。數據輸出完畢后要及時關閉輸出流。下面介紹 out 對象的應用。
out 對象常用的方法
| void print(各種數據類型) | 將指定類型的數據輸出到 HTTP 流，不換行 |
| void println(各種數據類型) | 將指定類型的數據輸出到 HTTP 流，并輸出一個換行符 |
| void newline | 輸出換行字符 |
向客戶端輸出數據
在使用 print() 或 println() 方法向客戶端輸出時，由于客戶端是瀏覽器，因此可以使用 HTML 中的一些標記控制輸出格式。例如：
<%out.println("<font color=red>Hello </font>"); %>管理輸出緩沖區
默認情況下，服務端要輸出到客戶端的內容不直接寫到客戶端，而是先寫到一個輸出緩沖區中。使用 out 對象的 getBufferSize() 方法取得當前緩沖區的大小(單位是 KB)，用 getRemaining() 方法取得當前使用后還剩余的緩沖區的大小(單位是 KB)。
JSP 只有在下面三種情況下，才會把緩沖區的內容輸出到客戶端。
? 該 JSP 網頁已完成信息的輸出。
? 輸出緩沖區己滿
? JSP 中調用了 out.flush() 或 response.flushBuffer()。
另外，調用 out 對象的 clear() 方法，可以清除緩沖區的內容，類似于重置響應流，以便重新開始操作。如果響應已經提交，則會產生 IOException 異常。此外，另一種方法 clearBuffer() 可以清除緩沖區“當前”內容，而且即使內容已經提交給客戶端，也能夠訪問該方法。
例: 用 out 對象管理輸出緩沖區，代碼如下：
<%out.println("使用out對象管理輸出緩沖區:<br>");%> <br> 緩沖大小：<%=out.getBufferSize()%> <br> 剩余緩存大小：<%=out.getRemaining()%> <br> 是否自動刷新：<%=out.isAutoFlush()%> <br>通過改變println 來觀察變化
pageContext對象(頁面上下文對象)
pageContext 是頁面上下文對象，這個特殊的對象提供了 JSP 程序執行時所需要用到的所有屬性和方法，如 session、application、config、out 等對象的屬性，也就是說，它可以訪問本頁所有的 session，也可以取本頁所在的 application 的某一屬性值，它相當于頁面中所有其他對象功能的集合，可以用它訪問本頁中所有的其他對象。
pageContext 對象是 javax.servlet:jsp.pageContext 類的一個實例，它的創建和初始化都是由容器來完成的，JSP 頁面里可以直接使用 pageContext 對象的句柄，pageContext 對象的 getXxx()、setXxx() 和 findXxx() 方法可以根據不同的對象范圍實現對這些對象的管理。列出了 pageContext 對象的常用方法:
| void forward(String relativeUrlPath) | 把頁面轉發到另一個頁面或者 Servlet 組件上 |
| Exception getException() | 返回當前頁的 Exception 對象 |
| ServletRequest getRequest() | 返回當前頁的 request 對象 |
| ServletResponse getResponse() | 返回當前頁的 response 對象 |
| ServletConfig getServletConfig() | 返回當前頁的 ServletConfig 對象 |
| HttpSession getSession() | 返回當前頁的 session 對象 |
| Object getPage() | 返回當前頁的 page 對象 |
| ServletContext getServletContext() | 返回當前頁的 application 對象 |
| public Object getAttribute(String name) | 獲取屬性值 |
| Object getAttribute(String name,int scope) | 在指定的范圍內獲取屬性值 |
| void setAttribute(String name,Object attribute) | 設置屬性及屬性值 |
| void setAttribute(String name,Object obj,int scope) | 在指定范圍內設置屬性及屬性值 |
| void removeAttribute(String name) | 刪除某屬性 |
| void removeAttribute(String name,int scope) | 在指定范圍內刪除某屬性 |
| void invalidate() | 返回 servletContext 對象，全部銷毀 |
pageContext 對象的主要作用是提供一個單一界面，以管理各種公開對象(如 session、application、config、request、response 等)，提供一個單一的 API 來管理對象和屬性。
通過 pageContext 對象取得不同范圍的屬性值，代碼如下：
<body> <%request.setAttribute("info","value of request scope");session.setAttribute("info","value of request scope");application.setAttribute("info","value of application scope"); %> 利用 pageContext 取出以下范圍內各值(方法一)：<br> request 設定的值：<%=pageContext.getRequest().getAttribute("info") %> <br> session 設定的值：<%=pageContext.getSession().getAttribute("info") %> <br> application 設的值：<%=pageContext.getServletContext().getAttribute("info") %> <hr> 利用pageContext取出以下范圍內各值(方法二)：<br> 范圍1(page)內的值：<%=pageContext.getAttribute("info",1) %> <br> 范圍2(request)內的值：<%=pageContext.getAttribute("info",2) %> <br> 范圍3(session)內的值：<%=pageContext.getAttribute("info",3) %> <br> 范圍4(application)內的值：<%=pageContext.getAttribute("info",4) %> <hr> 利用 pageContext 修改或刪除某個范圍內的值：<br> 修改 request 設定的值： <% pageContext.setAttribute("info","value of request scope is modified by pageContext",2); %> <br> 修改后:<%=pageContext.getRequest().getAttribute("info") %> <br> 刪除: session 設定的值：<br> <% pageContext.removeAttribute("info"); %> 刪除后:<%=session.getAttribute("info") %> </body>頁面顯示
利用 pageContext 取出以下范圍內各值(方法一)： request 設定的值：value of request scope session 設定的值：value of request scope application 設的值：value of application scope 利用pageContext取出以下范圍內各值(方法二)： 范圍1(page)內的值：null 范圍2(request)內的值：value of request scope 范圍3(session)內的值：value of request scope 范圍4(application)內的值：value of application scope 利用 pageContext 修改或刪除某個范圍內的值： 修改 request 設定的值： 修改后:value of request scope is modified by pageContext 刪除: session 設定的值： 刪除后:nullconfig對象(配置對象)
當一個 Servlet 初始化時，容器把某些信息通過此對象傳遞給這個 Servlet，這些信息包括 Servlet 初始化時所要用到的參數(通過屬性名和屬性值構成)以及服務器的有關信息，config 對象的應用范圍是本頁。
開發者可以在 web.xml 文件中為應用程序環境中的 Servlet 程序和 JSP 頁面提供初始化參數
config對象的常用方法
| ServletContext getServletContext() | 返回所執行的 Servlet 的環境對象 |
| String getServletName() | 返回所執行的 Servlet 的名字 |
| String getInitParameter(String name) | 返回指定名字的初始參數值 |
| Enumeration getlnitParameterName() | 返回該 JSP 中所有初始參數名，一個枚舉 |
列:
在web.xml中添加如下參數
<servlet><!--指定servlet的名字--><servlet-name>config_index</servlet-name><!--指定哪一個JSP頁面配置成Servlet--><jsp-file>/index.jsp</jsp-file><!--配置名為name的參數，值為yeeku--><init-param><param-name>name</param-name><param-value>yeeku</param-value></init-param><!--配置名為age的參數，值為30--><init-param><param-name>age</param-name><param-value>30</param-value></init-param></servlet><servlet-mapping><!--指定將config Servlet配置到/config路徑--><servlet-name>config_index</servlet-name><url-pattern>/index.jsp</url-pattern></servlet-mapping>創建/index.jsp
<%=config.getServletName()%><br> <!-- 輸出該JSP中名為name的參數配置信息 --> name配置參數的值：<%=config.getInitParameter("name")%><br/> <!-- 輸出該JSP中名為age的參數配置信息 --> age配置參數的值：<%=config.getInitParameter("age")%> config_index name配置參數的值：yeeku age配置參數的值：30exception(異常處理)
當編寫JSP程序的時候，程序員可能會遺漏一些BUG，這些BUG可能會出現在程序的任何地方。JSP代碼中通常有以下幾類異常:
- 檢查型異常:檢查型異常就是一個典型的用戶錯誤或者一個程序員無法預見的錯誤。舉例來說，如果一個文件將要被打開，但是無法找到這個文件，則一個異常被拋出。這些異常不能在編譯期被簡單地忽略。
- 運行時異常:一個運行時異?？赡芤呀洷怀绦騿T避免，這種異常在編譯期將會被忽略。
- 錯誤:錯誤不是異常，但問題是它超出了用戶或者程序員的控制范圍。錯誤通常會在代碼中被忽略，您幾乎不能拿它怎么樣。舉例來說，棧溢出錯誤。這些錯誤都會在編譯期被忽略。
Throwable類中一些重要的方法:
| String getMessage() | 返回異常的信息 |
| String toString() | 返回類名+異常信息 |
| void printStackTrace() | 將異常棧軌跡輸出至System.err 控制臺里 |
JSP提供了可選項來為每個JSP頁面指定錯誤頁面。無論何時頁面拋出了異常，JSP容器都會自動地調用錯誤頁面。
接下來的例子為index.jsp指定了一個發生錯誤的頁面。使用<%@page errorPage=“XXXXX”%>指令指定一個錯誤頁面。
創建index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %> <%@ page errorPage="error.jsp" %> <html> <head><title>index</title> </head> <body> <%int i=1/0;System.out.println(i); %> </body> </html>創建error.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <%--指定當前頁面為錯誤頁面--%> <%@ page isErrorPage="true" %> <html> <head><title>Title</title> </head> <body> <h1>發生錯誤了</h1><%String message = exception.getMessage();out.println("異常消息::"+message); %> </body> </html>當頁面index.jsp發生錯誤自動跳轉到error.jsp中
Cookies處理
Cookies是存儲在客戶機的文本文件，它們保存了大量軌跡信息。在servlet技術基礎上，JSP顯然能夠提供對HTTP cookies的支持。
通常有三個步驟來識別回頭客：
● 服務器腳本發送一系列cookies至瀏覽器。比如名字，年齡，ID號碼等等。
● 瀏覽器在本地機中存儲這些信息，以備不時之需。
● 當下一次瀏覽器發送任何請求至服務器時，它會同時將這些cookies信息發送給服務器，然后服務器使用這些信息來識別用戶或者干些其它事情。
Cookie剖析
Cookies通常在HTTP信息頭中設置(雖然JavaScript能夠直接在瀏覽器中設置cookies)。在JSP中，設置一個cookie需要發送如下的信息頭給服務器
HTTP/1.1 200 OK Date: Fri, 04 Feb 2000 21:03:38 GMT Server: Apache/1.3.9 (UNIX) PHP/4.0b3 Set-Cookie: name=xyz; expires=Friday, 04-Feb-07 22:03:38 GMT; path=/; domain=tutorialspoint.com Connection: close Content-Type: text/html正如您所見，Set-Cookie信息頭包含一個鍵值對，一個GMT(格林尼治標準)時間，一個路徑，一個域名。鍵值對會被編碼為URL。有效期域是個指令，告訴瀏覽器在什么時候之后就可以清除這個cookie。
如果瀏覽器被配置成可存儲cookies，那么它將會保存這些信息直到過期。如果用戶訪問的任何頁面匹配了cookie中的路徑和域名，那么瀏覽器將會重新將這個cookie發回給服務器。瀏覽器端的信息頭長得就像下面這樣：
GET / HTTP/1.0 Connection: Keep-Alive User-Agent: Mozilla/4.6 (X11; I; Linux 2.2.6-15apmac ppc) Host: zink.demon.co.uk:1126 Accept: image/gif, */* Accept-Encoding: gzip Accept-Language: en Accept-Charset: iso-8859-1,*,utf-8 Cookie: name=xyzCookie對象中常用的方法：
| public void setDomain(String pattern) | 設置cookie的域名，比如w3cschool.cn |
| public String getDomain() | 獲取cookie的域名，比如w3cschool.cn |
| public void setMaxAge(int expiry) | 設置cookie有效期，以秒為單位，默認有效期為當前session的存活時間 |
| public int getMaxAge() | 獲取cookie有效期，以秒為單位，默認為-1 ，表明cookie會活到瀏覽器關閉為止 |
| public String getName() | 返回 cookie的名稱，名稱創建后將不能被修改 |
| public void setValue(String newValue) | 設置 cookie的值 |
| public String getValue() | 獲取cookie的值 |
| public void setPath(String uri) | 設置cookie 的路徑，默認為當前頁面目錄下的所有URL，還有此目錄下的所有子目錄 |
| public String getPath() | 獲取cookie 的路徑 |
| public void setSecure(boolean flag) | 指明cookie是否要加密傳輸 |
| public void setComment(String purpose) | 設置注釋描述 cookie的目的。當瀏覽器將cookie展現給用戶時，注釋將會變得非常有用 |
| public String getComment() | 返回描述cookie目的的注釋，若沒有則返回null |
使用JSP設置Cookies
使用JSP設置cookie包含三個步驟：
(1)創建一個Cookie對象： 調用Cookie的構造函數，使用一個cookie名稱和值做參數，它們都是字符串。
Cookie cookie = new Cookie("key","value");請務必牢記，名稱和值中都不能包含空格或者如這些的字符： [ ] ( ) = , " / ? @ : ;
(2)設置訪問cookie的路徑 一般都為/ (也就是當前項目下所有頁面都能訪問)
設置cookie訪問路徑 只有此路徑下頁面才能訪問 如果不設置默認為當前調用cookie頁面的路徑
cookie.setPath("/");(3) 設置有效期：調用setMaxAge()函數表明cookie在多長時間(以秒為單位)內有效。下面的操作將有效期設為了24小時=1天。
如果為 0 Cookie將被刪除
cookie.setMaxAge(60*60*24);(4) 將cookie發送至HTTP響應頭中：調用response.addCookie()函數來向HTTP響應頭中添加cookies。
response.addCookie(cookie);設置Cookie
創建index.jsp
<%// 為 name 和 age設置cookieCookie name = new Cookie("name", "huanmin");Cookie age = new Cookie("pass","123");name.setPath("/"); age.setPath("/");// 設置cookie過期時間為24小時。name.setMaxAge(60*60*24);age.setMaxAge(60*60*24);// 在響應頭部添加cookieresponse.addCookie( name );response.addCookie( age ); %>設置完我們可以打開火狐游覽器 F12
獲取Cookie
創建index1.jsp
<%Cookie cookie = null;Cookie[] cookies = null;// 獲取cookies的數據,是一個數組cookies = request.getCookies();if( cookies != null ){for (int i = 0; i < cookies.length; i++){cookie = cookies[i];if (cookie.getName().equals("name")){out.print("name : " + cookie.getName( ) + ", ");out.print("Value: " + cookie.getValue( )+" <br/>");}if (cookie.getName().equals("pass")){out.print("name : " + cookie.getName( ) + ", ");out.print("Value: " + cookie.getValue( )+" <br/>");}}}else{out.println("<h2>No cookies founds</h2>");} %>頁面顯示
name : name, Value: huanmin name : pass, Value: 123刪除Cookies
刪除cookie原理就是讓cookie內對象的有效期為0就會自動被刪除
刪除cookie內的全部數據
<%Cookie[] cookie1=request.getCookies();for(int i=0;i<cookie1.length;i++){cookie1[i].setMaxAge(0);cookie1[i].setPath("/");//必須加上否則刪除失敗response.addCookie(cookie1[i]);} %>刪除指定Cookie
<%//獲取cookue對象Cookie[] cookie=request.getCookies();if(cookie!=null){ //判斷對象是否有值for(int i=0;i<cookie.length;i++){//獲取集合中 的對象 值if(cookie[i].getName().equals("name")){cookie[i].setMaxAge(0);cookie[i].setPath("/");response.addCookie(cookie[i]);}if(cookie[i].getName().equals("pass")){cookie[i].setMaxAge(0);cookie[i].setPath("/");response.addCookie(cookie[i]);}out.print(cookie[i].getValue());}}%>cookie與session區別
cookie 是保存在客戶端可以長期保存(自定義) 而session是保存在服務器中 結束訪問就會銷毀數據
cookie保存的是String類型的 而session保存的是一個地址對象Object
cookie 一般保存不重要的信息 比如: 免登陸 ,驗證令牌 等
因為是存儲在用戶電腦上可控制性不強 (可以加密)
session 是保存在服務器中 訪問結束就會刪除 訪問信息 比較安全 無法被第三方 訪問到
控制流語句
JSP提供對Java語言的全面支持。您可以在JSP程序中使用Java API甚至建立Java代碼塊，包括判斷語句和循環語句等等。
和java 語法一樣 就是需要使用<% %> 將代碼包裹起來才能使用
判斷語句
If…else塊，請看下面這個例子：
<%! int day = 3; %> <% if (day == 1 | day == 7) { %> <p> Today is weekend</p> <% } else { %> <p> Today is not weekend</p> <% } %>頁面顯示
Today is not weekend
if else if 這個就不用說了吧 照葫蘆畫瓢 總會吧
<%! int day = 3; %><% if (day == 1 | day == 7) { %> <p> Today is weekend</p> <% } else if(day==3){ %> <p> Today is not weekend</p> <% } else {%> <p> NO</p> <%} %>現在來看看switch…case塊，與if…else塊有很大的不同，它使用out.println() 來輸出到頁面上，并且整個都裝在腳本程序的標簽中，就像下面這樣：
<%! int day = 3; %><% switch(day) { case 0: out.println("It\'s Sunday."); break; case 1: out.println("It\'s Monday."); break; case 2: out.println("It\'s Tuesday."); break; case 3: out.println("It\'s Wednesday."); break; case 4: out.println("It\'s Thursday."); break; case 5: out.println("It\'s Friday."); break; default: out.println("It's Saturday."); } %>頁面顯示
It’s Wednesday.
循環語句
在JSP程序中可以使用Java的三個基本循環類型：for，while，和 do…while。
讓我們來看看for循環的例子：
<%! int fontSize; %><%for ( fontSize = 1; fontSize <= 3; fontSize++){ %> <font color="green" size="<%= fontSize %>">JSP Tutorial</font><br /> <%}%>將上例改用while循環來寫：
<%! int fontSize; %><%fontSize=1;while ( fontSize <= 3){ %> <font color="green" size="<%= fontSize %>">JSP Tutorial </font><br /> <%fontSize++;%> <%}%>JSP運算符
JSP支持所有Java邏輯和算術運算符。
下表羅列出了JSP常見運算符，優先級從高到底：
| 后綴 | () [] . (點運算符) | 左到右 |
| 一元 | ++ - - ! ~ | 右到左 |
| 可乘性 | * / % | 左到右 |
| 可加性 | + - | 左到右 |
| 移位 | >> >>> << | 左到右 |
| 關系 | > >= < <= | 左到右 |
| 相等/不等 | == != | 左到右 |
| 位與 | & | 左到右 |
| 位異或 | ^ | 左到右 |
| 位或 | | | 左到右 |
| 邏輯與 | && | 左到右 |
| 邏輯或 | || | 左到右 |
| 條件判斷 | ?: | 右到左 |
| 賦值 | = += -= *= /= %= >>= <<= &= ^= |= | 右到左 |
| 逗號 | , | 左到右 |
JSP常量
與Java中的一樣 使用final 關鍵字 不可以被修改
比如:
<%! final int FONTSIZE=15; %> <%! final String FINAL="常亮"; %>JSP開發模式
必須明白java三層框架 然后在來看 jsp必須知道jsp的幾種開發模式
JSP 程序開發模式包括 JSP 編程、JSP+JavaBean 編程、JSP+JavaBean+Servlet 編程、MVC 模式。
單純的JSP編程
在 JSP 編程模式下，通過應用 JSP 中的腳本標志，可以直接在 JSP 頁面中實現各種功能。雖然這種模式很容易實現，但是，其缺點也非常明顯。因為將大部分的 Java 代碼與 HTML 代碼混淆在一起，會給程序的維護和調試帶來很多困難，而且難以理清完整的程序結構。
這就好比規劃管理一個大型企業，如果將負責不同任務的所有員工都安排在一起工作，勢必會造成公司秩序混亂、不易管理等許多隱患。所以說，單純的 JSP 頁面編程模式是無法應用到大型、中型甚至小型的 JSP Web 應用程序開發中的。
JSP+JavaBean 編程
JSP+JavaBean 編程模式是 JSP 程序開發經典設計模式之一，適合小型或中型網站的開發。利用 JavaBean 技術，可以很容易地完成一些業務邏輯上的操作，例如數據庫的連接、用戶登錄與注銷等。
JavaBean 是一個遵循了一定規則的 Java 類，在程序的開發中，將要進行的業務邏輯封裝到這個類中，在 JSP 頁面中，通過動作標簽來調用這個類，從而執行這個業務邏輯。此時的 JSP 除了負責部分流程的控制外，主要用來進行頁面的顯示，而 JavaBean 則負責業務邏輯的處理。
可以看出，JSP+JavaBean 設計模式具有一個比較清晰的程序結構，在 JSP 技術的起步階段，該模式曾被廣泛應用。
如下:表示該模式對客戶端的請求進行處理的過程，相關的說明如下。
1.用戶通過客戶端瀏覽器請求服務器。
2.服務器接收用戶請求后調用 JSP 頁面。
3.在 JSP 頁面中調用 JavaBean。
4.在 JavaBean 中連接及操作數據庫，或實現其他業務邏輯。
5.JavaBean 將執行的結果返回 JSP+ 頁面。
6.服務器讀取 JSP 頁面中的內容(將頁面中的靜態內容與動態內容相結合)。
7.服務器將最終的結果返回給客戶端瀏覽器進行顯示。
結構演示:
明白的人自然就懂 不明白的永遠都不明白
總結: jsp(既當爹又當媽) +javaBean(就只干數據訪問層)
現在基本都沒人用這模式 除非你是自己開發
JSP+JavaBean+Servlet 編程
JSP+JavaBean 設計模式雖然已經對網站的業務邏輯和顯示頁面進行了分離，但這種模式下的 JSP 不但要控制程序中的大部分流程，而且還要負責頁面的顯示，所以仍然不是一種理想的設計模式。
在 JSP+JavaBean 設計模式的基礎上加入 Servlet 來實現程序中的控制層，是一個很好的選擇。在這種模式中，由 Servlet 來執行業務邏輯并負責程序的流程控制，JavaBean 組件實現業務邏輯，充當模型的角色，JSP 用于頁面的顯示?？梢钥闯?#xff0c;這種模式使得程序中的層次關系更明顯，各組件的分工也非常明確。下圖表示該模式對客戶端的請求進行處理的過程。
各步驟的說明如下:
1.用戶通過客戶端瀏覽器請求服務器。
2.服務器接收用戶請求后調用 Servlet。
3.Servlet 根據用戶請求調用 JavaBean 處理業務。
4.在 JavaBean 中連接及操作數據庫，或實現其他業務邏輯。
5.JavaBean 將結果返回 Servlet，在 Servlet 中將結果保存到請求對象中。
6.由 Servlet 轉發請求到 JSP 頁面。
7.服務器讀取 JSP 頁面中的內容(將頁面中的靜態內容與動態內容結合)。
8.服務器將最終的結果返回給客戶端瀏覽器進行顯示。
結構演示:
總結:jsp(只負責顯示數據) + JavaBean(數據訪問處理) +Servlet(對要顯示的數據進行整合 不用在jsp頁面在處理了)
但 JSP+JavaBean+Servlet 模式同樣也存在缺點。
因為一個請求(功能) 就要對應一個Servlet 如果100個請求呢1000個呢 那么又會出現多少個Servlet呢? 這就會造成邏輯混亂 類堆積 維護比較難
當然有解決辦法 就是使用MVC模式
MVC 模式
MVC(Model-View-Controller，模型-視圖-控制器)是一種程序設計概念，它同時適用于簡單的和復雜的程序。使用該模式，可將待開發的應用程序分解為三個獨立的部分：模型、視圖和控制器。
提出這種設計模式主要是因為應用程序中用來完成任務的代碼(模型，也稱為“業務邏輯”)通常是程序中相對穩定的部分，并且會被重復使用，而程序與用戶進行交互的頁面(視圖)，卻是經常改變的。
如果因需要更新頁面而不得不對業務邏輯代碼進行改動，或者要在不同的模塊中應用相同的功能時重復地編寫業務邏輯代碼，不僅會降低整體程序開發的進程，而且會使程序變得難以維護。因此將業務邏輯代碼與外觀呈現分離，將會更容易地根據需求的改變來改進程序。MVC 模式的模型如圖 所示。
Model(模型)：MVC 模式中的 Model(模型)指的是業務邏輯的代碼，是應用程序中真正用來完成任務的部分。
View(視圖)：視圖實際上就是程序與用戶進行交互的界面，用戶可以看到它的存在。視圖可以具備一定的功能，并應遵守對其所做的約束。在視圖中，不應包含對數據處理的代碼，即業務邏輯代碼。
Controller(控制器)：控制器主要用于控制用戶請求并做出響應。它根據用戶的請求，選擇模型或修改模型，并決定返回什么樣的視圖。
雖然用來實現 MVC 設計模式的技術可能都是相同的，但各公司都有自己的 MVC 架構。也就是說，這些公司用來實現自己的 MVC 架構所應用的技術可能都是 JSP、Servlet 與 JavaBean，但它們的流程及設計卻是不同的，所以工程師需要花更多的時間去了解。
從項目開發的觀點上來說，因為需要設計 MVC 各對象之間的數據交換格式與方法，所以在系統的設計上需要花費更多的時間。
但是現在市面上有很多成熟的MVC創建可以選擇一個實現了 MVC 模式的現成的框架，在此框架的基礎上進行開發，能夠大大節省開發時間，會取得事半功倍的效果。目前，已有很多可以使用的現成的 MVC 框架，例如 Struts SSM 框架。
我這里給你展示一個我之前做的SSM項目結構圖
總結:jsp(只負責顯示數據) + JavaBean(數據訪問處理) +controller(對要顯示的數據進行整合 不用在jsp頁面在處理了)
controller 和servlet 感覺上是不是差不多 但是呢實際上 controller底層還是servlet
就是對servlet進行一層封裝 過濾… 當訪問 controller成功后 將結果給servlet 而已
只不過springmvc幫助你做好了url和method的映射了（注解實現），不需要你自己在web.xml一個servlet和一個method去配置了
國際化開發
下表列舉出了Locale對象中比較重要的方法，用于檢測request對象的地區，語言，和區域。所有這些方法都會在瀏覽器中顯示國家名稱和語言名稱：
| String getCountry() | 返回國家/地區碼的英文大寫，或 ISO 3166 2-letter 格式的區域 |
| String getDisplayCountry() | 返回要顯示給用戶的國家名稱 |
| String getLanguage() | 返回語言碼的英文小寫，或ISO 639 格式的區域 |
| String getDisplayLanguage() | 返回要給用戶看的語言名稱 |
| String getISO3Country() | 返回國家名稱的3字母縮寫 |
| String getISO3Language() | 返回語言名稱的3字母縮寫 |
實例演示
這個例子告訴我們如何在JSP中顯示語言和國家：
<body> <center><h1>Detecting Locale</h1> </center><%//獲取客戶端本地化信息 Locale locale = request.getLocale(); //語言區域 比如 中文有中文簡體(zh-CN)和繁體(zh-TW).. String language = locale.getLanguage();//語言: 中文(zh) 英文(en) ... String country = locale.getCountry(); //國家 %><p align="center"><% out.println("國家 : " + country + "<br />");out.println("語言 : " + language + "<br />");out.println("語言區域 : " + locale + "<br />");%> </p></body>語言切換
JSP可以使用西歐語言來輸出一個頁面，比如英語，西班牙語，德語，法語，意大利語等等。由此可見，設置Content-Language信息頭來正確顯示所有字符是很重要的。 如果不知道每個國家語言縮寫 在百度上搜索 :各國語言縮寫表
http://www.mamicode.com/info-detail-2692661.html 也可以參考這個網站
en 英語
zh 中文
自動識別切換語言案例:
<%@ page import="java.util.Locale" %> <%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %> <html> <head><title>index</title> </head> <body><%String re_language = request.getParameter("Language");//獲取客戶端本地化信息Locale locale = request.getLocale();String langua = locale.getLanguage(); //自動識別獲取你的語言if(re_language!=null){application.setAttribute("Language",re_language); //設置頁面語言}else{application.setAttribute("Language",langua); //設置頁面默認語言}// 設置請求頭內的 Content-Language(當前頁面的語言)response.setHeader("Content-Language", (String) application.getAttribute("Language"));//獲取當前響應頭里的 語言String language= response.getHeader("Content-Language"); %><label for="Language"></label> <select id="Language"><% if("en".equals(language )){ %><option selected="selected" value="en">English</option><%}else{%><option value="en">English</option><%}%><% if("zh".equals(language)){ %><option selected="selected" value="zh">中文</option><%}else{%><option value="zh">中文</option><%}%></select><center><h1><%if("en".equals(language)){out.print("The current language is : English");}else if("zh".equals(language)){out.print("當前語言是: 中文");}%></h1> </center> <div align="center"><%if(language.equals("en")){%>Hello World!<%}%><%if(language.equals("zh")){%>你好 世界!<%}%> </div><script>//下拉框 變化 從而變化 頁面語言var Language=document.getElementById("Language");Language.οnchange=function(){let value = Language.value;location.href="http://localhost:8081/java_Web/"+"?Language="+value;} </script></body> </html>自動識別并格式化時間為當前地區的時間字符串格式
<%@ page import="java.text.DateFormat" %> <%@ page import="java.util.Date" %> <%@ page import="java.util.Locale" %> <%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %> <html> <head><title>index</title> </head> <body> <%//獲取客戶端本地化信息Locale locale = request.getLocale(); //獲取你是哪個 語言_區域//設置 格式 時間為你國家的 時間字符串格式String date = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.SHORT, locale).format(new Date( ));%> <div align="center"><p>Local Date: <% out.print(date); %></p> </div></body> </html>自動格式格式貨幣 為當前地區的貨幣格式
<%@ page import="java.text.NumberFormat" %> <%@ page import="java.util.Locale" %> <%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %><%Locale locale = request.getLocale( );NumberFormat nft = NumberFormat.getCurrencyInstance(locale); //自動格式格式 貨幣為當前地區的貨幣格式%> <html> <head><title></title> </head> <body><div align="center"><p>格式化的貨幣:<%String formattedCurr = nft.format(1000000);//格式化out.print(formattedCurr);%></p> </div> </body> </html>自動格式百分比 為當前地區格式的百分比格式
<%@ page import="java.text.NumberFormat" %> <%@ page import="java.util.Locale" %> <%@ page language="java" contentType="text/html; charset=UTF-8" isELIgnored="true" pageEncoding="UTF-8" %><% Locale locale = request.getLocale( ); NumberFormat nft = NumberFormat.getPercentInstance(locale);//自動格式百分比 為當前地區格式的百分比格式 %> <html> <head><title></title> </head> <body> <div align="center"><p>格式化的百分比:<%String formattedPerc = nft.format(0.51); //格式化out.print(formattedPerc);%></p> </div> </body> </html>到這里 基本上所有JSP的 基礎教程完事 但是jsp學習之旅并沒有結束 我們還有如下知識沒有掌握
EL , JSTL 使用 jsp連接數據庫 ,jsp過濾器 xml數據處理,自定義jsp的標簽
可以看出來這些內容 其實就是 讓你開發jsp的時候更加方便
點贊 -收藏-關注-便于以后復習和收到最新內容 有其他問題在評論區討論-或者私信我-收到會在第一時間回復 如有侵權，請私信聯系我 感謝,配合,希望我的努力對你有幫助^_^總結
以上是生活随笔為你收集整理的Java-Jsp基础教程的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 工作112:vue路由跳转错误：Erro
- 下一篇： java web程序设计郭_Java W