JSP(java服务器页面)

JSP(java服务器页面)

本质是servlet 底层是java文件 具体内容包含servlet中的内容 并且会输出???  

 

pre标签 预格式化标签 能保留多个空格和tab缩进的位置 (不需要 )

一、介绍

JSP：Java Server Page SUN 公司提供的动态网页编程技术，是 Java Web 服务器端的动态资源。

与html相比，html 只能为用户提供静态数据，而 Jsp 技术允许在页面中嵌套 java 代码，为用户提供动态数据。

相比 servlet 而言，servlet 很难对数据进行排版，而 jsp 除了可以用 java 代码产生动态数据的同时，也很容易对数据进行排版。

不管是 JSP 还是 Servlet，虽然都可以用于开发动态 web 资源。但由于这 2 门技术各自的特点，在长期的软件实践中，人们逐渐把 servlet 作为 web 应用中的控制器组件来使用， 而把 JSP 技术作为数据显示模板来使用。

其实 Jsp 就是一个 Servlet，当我们第一次访问 Jsp 的时候，Jsp 引擎都会将这个 Jsp 翻译 成一个 Servlet，这个文件存放在 Tomcat 中的 work 目录中。

在work中的java文件中能看出jsp本质是servlet

jsp文件最终会被jsp的引擎所编译成一个servlet 通过虚拟机编译成class文件 java中的代码与servlet中的代码很相似只有一些细节不同,

页面效果都是servlet中的service方法一个个的输出的

二、准备工作

1. 配置 Eclipse

这一步不是必须的，当然由于 eclipse 中有写默认的配置项我们觉得不是很完美，比如 字符编码，比如 HTML 的 DOCTYPE，我们可以在新建 JSP 页面之前就先修改为我们需要的。

最后一路保存，关闭即可

2. 新建 JSP 文件

 

新建完成以后的完整代码如下：

三、基础语法

1. 注释 ★

在 JSP 中支持两种注释的语法操作，一种是显示注释，这种注释是允许客户端看见的(浏览器F12翻看源代码能看到或者编译时查看)； 另一种是隐式注释，此种注释是客户端无法看见的

注释语法(三种注释): 

1.显示注释语法：从 HTML 风格继承而来

 

< --- >  ==>  < --- >    

------在jsp中写笔记用法 (转义符)

 

2.隐式注释语法：从 JAVA 风格继承；JSP 自己的注释

// 单行注释

/* 多行注释 */

 

<%-- 这是JSP的注释 --%>

 

注意:平时使用注释最好用快捷键生成 系统会提供最合适的注释

自己用注释可能会出现许多异常错误

2. Scriptlet 脚本小程序 ☆

在 JSP 中最重要的部分就是 Scriptlet（脚本小程序），所有嵌入在 HTML 代码中的 Java 程序都必须使用 Scriptlet 标记出来，

在 JSP 中一共有三种Scriptlet 代码：

1). <% %> ---局部

java 脚本段，可以声明局部变量、编写java语句

代码会生成在编译后的Servlet源码中的service方法体中

 

2). <%! %> ---全局

声明，可以声明全局（成员）变量、方法、类

代码会生成在编译后的Servlet源码的类体中

 

3). <%= %> ---输出

输出表达式，数据 一个变量 或具体内容

代码会生成在编译后的Servlet源码中的service方法体中

 

通过观察解析为 java 文件的 jsp 代码理解三种小脚本 TomCat中的 work文件夹中的java代码

 

示例代码:

1.<% %>

<%

int a = 1;

System.out.println(a);

%>

 

//在编译后的Servlet源码中的service方法体中

int a = 1;

System.out.println(a);

 

2.<%! %> 

<%!

String str = "Hello JSP";

%>

 

//在编译后的Servlet源码的类体中

String str = "Hello JSP";

 

3.<%= %>

<%=a %> <br>

<%=100 %> <br>

<%=request.getMethod() %><br>

 

//在编译后的Servlet源码中的service方法体中

<%=a %>

<%=100 %>

<%=request.getMethod() %>

 

3. JSP 的指令标签 

定义:

JSP 的指令标签用来控制整个 jsp 的行为，就当前 JSP 页面的某些方面对JSP 转换器作出指示。

 

语法:

<%@ 指令名称 属性名="属性值" ...   %>

 

1) page 指令

语法： <%@ page 属性名1="属性值1"  属性名2="属性值2" %>

language：当前语言，目前只支持java

contentType :设置响应类型及编码格式

pageEncoding:编码格式。

import 属性，用来引入其他包(只有该属性可以被设置多次)

(和 java 中 import 语句作用相同)

isErrorPage：是否是处理错误的页面，默认是false；  

(如果设置true表示当前页面是用来处理报错的；一般与errorPage 一起使用)

errorPage：报错时跳转的页面

JSP的编码取决于contentType属性中的charset的值

(如果charset未设置，则使用pageEncoding的值，若两者都未设置， 使用默认编码ISO-8859-1)

 

其他描述:

1.输入错误 此时变成下载

<%@ page contentType="text/html;charset=UTF-8"%>

<%@ page contentType="test/html;charset=UTF-8"%>

 

 

2.文件字符编码

contentType 主要的功能是用来设置 MIME(页面响应类型)，而

charset="UTF-8" 指定了编码，利用 pageEncoding="UTF-8"也能指定编码，前者更常用。在 JSP 中，如果 charset 存在，那么 JSP 的编码由 charset 决定，如果不存在则由 pageEncoding 来决定，如果都不存在，则使用默认 ISO-8859-1 编码。

顺序: contentType中charset ==>  pageEncoding ==> 默认

 

3.导包

page 指令中存在 import 属性，所以导包就可以正确使用了，在整个 page 指令的属性中， 只有 import 语句可以多次出现，其他属性都只能设置一次。能导包意味着可以直接在 jsp 中 链接数据库。

<%@page import="java.util.*" import="java.io.*" %>

可以合为一句

<%@page import="java.util.* ,java.io.*" %>

2) include 静态包含 ★★

说明:将一个页面包含在另一个页面中

 

静态包含就是将内容进行了直接的替换，就好比程序中定义的变量一样 是在 servlet 引擎转译时，就把此文件内容包含了进去（两个文件的源代码整合到一起， 全部放到_jspService 方法中），所以只生成了一个 servlet，所以两个页面不能有同名的变量。

 

语法：<%@include file="要包含的页面路径" %>

 

1、静态包含就是将内容进行了直接的替换

2、只会生成一个源码文件

3、不能有同名变量

 

特点：

优点: 运行效率高一点点

缺点: 耦合度高，不够灵活

 

路径:

<%@ include file="要包含的文件路径"%>相对路径

EX:

<%@include file="include.jsp"%>

或

<%@include file="include.html"%>

 

 

3) taglib 导入标签库

<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

 

当使用到第三方标签库时需要通过 taglib 标签进行导入。

JSTL 中有细致描述

4. JSP 动作标签 

动作标签，它们被编译成执行某个操作的 Java 代码，例如访问某个 Java 对象，或者调用某个方法。JSP 容器有自己支持的标准动作。除标准动作之外，还可以创建指定的标签， 用来执行某些操作。这些 jsp 的动作标签，与 html 提供的标签有本质的区别:

 

* 动作标签是由 tomcat(服务器)来解释执行！

与 java 代码一样，都是在服 务器端执行

* html 由浏览器来执行！

 

语法：

 

include动态包含 ★★★

相当于方法的调用，会生成两个源码文件，可以出现同名变量。降低耦合度。

TomCat中 work文件夹 里面查看

 

1).语法：★★★

 

I: 无参include动态包含语法:

<jsp:include page="要包含的页面或资源路径">

 

II:有参include动态包含语法:

<jsp:include page="" flush="true">

<jsp:param name="" value=""/>

 

2).参数:★★★

动态包含可以传递参数

value属性支持表达式

name属性不支持表达式

<%=request.getParameter("name参数名")%>

//通过name参数名获取 参数值

 

 

flush:

在同一个 JSP 中，如果不断 include 自己（源文件），在逻辑上会形成死循环。若默认情况下，服务器会等待该文件被读到底端，然后才输出到客户端，并且销毁该次访问的 request 和 response。而当把flush 属性赋为真值时，在缓存累积了一定数据时，服务器会先提供一部分数据给浏览器，并等待后续内容。

 

结论:在简单页面中，该属性不纳入考虑，而在页面包含大量数据时，为缩短客户端延迟，可将一部分内容先行输出。该属性在 Servlet 中也有对应的应用。

 

 

3).注意：

动态包含双标签之间不能写任何内容，包括空格和 换行。（除非确认要使用参数，否则报错！）

 

EX:1

<jsp:include page="include.html">jsp:include>

<%

String a = "hello.jsp";

%>

<jsp:include page="<%=a%>">jsp:include>

EX2:

 page="hello.jsp" flush="true">

<jsp:param name="name" value="zhangsan"/>

<%=request.getParameter("name")%>

 

 

 

4).具体描述:

include 动作用于动态地包含另一个资源，它可以包含另一个 JSP 页面、一个 Servlet 或 者一个静态的 HTML 页面。

使用包含操作，可以将一些重复的代码包含进来继续使用，从正常的页面组

成来看，有时可能分为几个区域。而其中的一些区域可能是一直不需要改变的，

改变的就其中的一个具体内容区域。现在有两种方法可以实现上述功能。

 

方法一：在每个 JSP 页面（HTML）都包含工具栏、头部信息、尾部信息、

具体内容

方法二：将工具栏、头部信息、尾部信息都分成各个独立的文件，以后使用

的时候直接 导入进来   --- (动态包含)

 

很明显，第二种方法比第一种更好，第一种会存在很多重复的代码，并且修

改很不方便，在 JSP 中如果要想实现包含的操作，有两种做法：静态包含、动

态包含，静态包含使用 include 指令即可，动态包含则需要使用 include 动作标签。

动态包含在代码的编译阶段，包含和被包含部分是两个独立的部分，只有当

运行时，才会动态包含进来，好比方法的调用。

 

注意：有些对象在 JSP 中能够直接使用，可以通过观察.java 代码知道。目前我们只需要知道 request,response,session,application 可以直接使用即可。

5. 九大内置对象

4大域对象 + 2输出对象 + 配置对象 + 页面本身对象 + 异常对象

通过解析后的 jsp 文件查看即可

 

(1-4) 4大域对象 1到4 作用范围依次增大

 

1.pageContext 域对象 (当前页面)

pageContext 对象的作用是取得任何范围的参数，通过它可以获取 JSP页面的 out. request. reponse. session. application 等对象。

pageContext 对象的创建和初始化都是由容器来完成的，在 JSP 页面中可以直接使用 pageContext 对象。

 

2.request 域对象 (一次请求)

request 对象是 javax.servlet.httpServletRequest 类型的对象。 该对象代表了客户端的请求信息，主要用于接受通过 HTTP 协议传送到服务器的数据。（包括头信息. 系统信息. 请求方式以及请求参数等）。request 对象的作用域为一次请求。

 

3.session 域对象 (一次会话)

session 对象是由服务器自动创建的与用户请求相关的对象。服务器为每个用户都生成一个 session 对象，用于保存该用户的信息，跟踪用户的操作状态。

session 对象内部使用 Map 类来保存数据，因此保存数据的格式为

“Key/value”。 session 对象的 value 可以是复杂的对象类型，而不仅仅局限于字符串类型。

 

4.application 域对象 (当前web应用)

application 对象可将信息保存在服务器中，直到服务器关闭，否则

application 对象中保存的信息会在整个应用中都有效。与 session 对象相比，application 对象生命周期更长，类似于系统的“全局变量”。

 

5.response 输出对象

response 代表的是对客户端的响应，主要是将 JSP 容器处理过的对象传回到客户端。response 对象也具有作用域，它只在 JSP 页面内有效。

 

6.out 输出对象

out 对象用于在 Web 浏览器内输出信息，并且管理应用服务器上的输出缓冲区。

在使用 out 对象输出数据时，可以对数据缓冲区进行操作，及时清除缓冲区中的残余数据，为其他的输出让出缓冲空间。待数据输出完毕后，要及时关闭输出流。

 

7.config 配置对象 (配置信息)

config 对象的主要作用是取得服务器的配置信息。通过 pageConext 对象的 getServletConfig() 方法可以获取一个 config 对象。

当一个 Servlet 初始化时，容器把某些信息通过 config 对象传递给这个Servlet。

开发者可以在 web.xml 文件中为应用程序环境中的 Servlet 程序和 JSP 页面提供初始化参数。

 

8.page 对象 (JSP页面本身)

page 对象代表 JSP 本身，只有在 JSP 页面内才是合法的。 page 隐含对

象本质上包含当前 Servlet 接口引用的变量，类似于 Java 编程中的 this 指针。

9.exception 对象(异常)

exception 对象的作用是显示异常信息，只有在包含 isErrorPage="true" 的页面中才可以被使用，在一般的 JSP 页面中使用该对象将无法编译 JSP 文件。

没有isErrorPage="true" 的页面 IDE无法使用exception

excepation 对象和 Java 的所有对象一样，都具有系统提供的继承结构。

exception 对象几乎定义了所有异常情况。

如果在 JSP 页面中出现没有捕获到的异常，就会生成 exception 对象，并把 exception 对象传送到在 page 指令中设定的错误页面中，然后在错误页面中处理相应的 exception 对象。

 

<%=exception.getMessage()%>

 

jsp内置对象out和response.getWriter()的区别:

两者的主要区别：
1.内置对象out的类型是JspWriter；
response.getWrite()返回的类型是PrintWriter；
out和response.getWriter的类不一样，一个是JspWriter，另一个是java.io.PrintWriter。

2. 获取方式不同：
JspWriter是JSP的内置对象，直接使用即可，对象名out是保留字，也只能通过out来调用其相关方法。
　　此外还可以通过内置对象pageContext.getOut();获得；
PrintWriter则是在用的时候需要通过内置对象response.getWriter();获得
3.执行原理不同:
JspWriter相当于一个带缓存功能的printWriter，它不是直接将数据输出到页面，
　　而是将数据刷新到response的缓冲区后再输出，
response.getWriter直接输出数据（response.print()），所以（out.print）只能在其后输出。 
4. JspWriter的print()方法会抛出IOException；而PrintWriter则不会

5.out为jsp的内置对象，刷新jsp页面，自动初始化获得out对象，所以使用out对象是需要刷新页面的，

  而response.getWriter()响应信息通过out对象输出到网页上，当响应结束时它自动被关闭，与jsp页面无关，无需刷新页面
6.out的print()方法和println()方法在缓冲区溢出并且没有自动刷新时候会产生ioexception，
  而response.getWrite()方法的print和println中都是抑制ioexception异常的，不会有ioexception 
  out.println(""); 方法并不能也页面布局换行，只能领html代码换行，
  要实现页面布局换行可以：out.println("
");

 

四、EL 表达式

1. EL 语法

${key}  key代表的是存在域对象中的键

 

1).el表达式一般操作的是 域对象 或 字面量，不能操作变量。

 

2).取值范围：(递增)

从小范围开始找，找到即止，如果都未找到，返回空字符串。

page、request、session、application

 

3).获取域对象范围的值 (...Scope)

pageScope、requestScope、sessionScope、applicatonScope

 

注：获取JavaBean中的属性时，属性需要提供get方法

 

EL（Expression Language） 是为了使 JSP 写起来更加简单。表达式语言的灵感来自于 ECMAScript 和 XPath 表达式语言，它提供了在 JSP 中简化表达式的方法，让 Jsp 的代码更加简化。

语法结构非常简单： ${expressio}

EL 表达式一般操作的都是域对象中的数据，操作不了局部变量。域对象的

概念在JSP中一共有四个：pageContext, request, session, application；范围依次是，本页面，一次请求， 一次会话，整个应用程序。而 EL 默认的查找方式为从小到大查找，找到即可。当域对象全 找完了还未找到则返回空字符串" "。

当需要指定从某个特定的域对象中查找数据时可以使用四个域对象对应的

空间对象，分别是：

pageScope, requestScope, sessionScope, applicationScope。

2. EL 运算

使用 EL 表达式可以用来判断集合中是否有元素${empty list}

1) 访问List

<%

List<String> list = new ArrayList<String>();

list.add("aaa");

list.add("bbb");

list.add("ccc");

request.setAttribute("list", list);

%>

${empty list}<br />

${list[1] }<br />

 

结果:

false 
bbb 

 

2) 访问 map

这里使用到了 el 的另一种取值方式[""]

 

<%

Map map = new HashMap();

map.put("aaa", "111");

map.put("bbb", 2222);

map.put("ccc-a", 333);

request.setAttribute("map", map);

%>

${empty map}<br />

${map.aaa }<br />

${map["bbb"]}<br />

${map["ccc-a"]}

 

结果:

false

111 
2222 
333

 

3) 做+、-、*、/(也可以使用 div 来表示)、%、==

 

<%

String a = "aaa";

String b = "aaa";

 

int c = 24;

int d = 2;

request.setAttribute("d", d);

%>

 

<%=a == b%>

${c div 2}<br>

${d div 2}

结果:

true

0.0

1.0

 

注意：String 也使用==比较

 

<%

request.setAttribute("a", 10);

request.setAttribute("b", 10);

%>

 

<h2>${a+b }h2>

<h2>${a==b }h2>

 

<%

request.setAttribute("a", "aaaa");

request.setAttribute("b", "aaaa");

%>

<h2>${a==b }h2>

 

结果:

20

true

true

 

示例代码:

<%@page import="java.util.HashMap"%>

<%@page import="java.util.Map"%>

<%@page import="java.util.ArrayList"%>

<%@page import="java.util.List"%>

<%@page import="com.xxx.model.User"%>

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

DOCTYPE html >

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>EL表达式title>

head>

<body>

 

<%

pageContext.setAttribute("uname", "zhangsan");

request.setAttribute("uname", "lisi");

session.setAttribute("uname", "wangwu");

application.setAttribute("uname", "zhaoliu");

 

// 定义JavaBean对象

User user = new User();

user.setUserName("admin");

user.setUserPwd("123456");

request.setAttribute("myUser", user);

 

String a = "Hello";

 

// 域对象存空值

request.setAttribute("str1", "");

request.setAttribute("str2", null);

request.setAttribute("str3", "Hello");

 

 

%>

 

<h4>EL表达式取值h4>

获取指定名称的域对象：${uname } <br/>

获取session作用域的值：${sessionScope.uname } <br/>

获取JavaBean对象：${myUser }<br/>

获取JavaBean对象的属性：${myUser.userName } ----- ${myUser.getUserName() } <br/>

获取普通变量名（取不到）：${a }<br/>

获取字面量的值：${1 }<br/>

 

**************************************************************

EL表达式取值

获取指定名称的域对象：zhangsan 
获取session作用域的值：wangwu 
获取JavaBean对象：com.xxx.model.User@1f3de637
获取JavaBean对象的属性：admin ----- admin 
获取普通变量名（取不到）：
获取字面量的值：1

**************************************************************

 

 

<h4>EL使用字符串方法h4>

获取字符串中是指定字符的下标：${uname.indexOf("a") }<br/>

字符串截取：${uname.substring(0,2) }<br/>

 

**************************************************************

 

EL使用字符串方法

获取字符串中是指定字符的下标：2
字符串截取：zh

**************************************************************

 

 

<h4>EL表达式判断为空   ${empty 域变量  }h4>

判断空字符串：${empty str1  } <br/>

判断null：${empty str2  } <br/>

判断字符串：${empty str3  } <br/>

判断字符串：${str3 != null && str3 != ""  } <br/>

**************************************************************

EL表达式判断为空 true

判断空字符串：true 
判断null：true 
判断字符串：false 
判断字符串：true 

**************************************************************

<%

//集合

List list1 = new ArrayList<>();

list1.add("aaa");

list1.add("bbb");

list1.add("ccc");

List list2 = new ArrayList<>();

List list3 = null;

request.setAttribute("list1", list1);

request.setAttribute("list2", list2);

request.setAttribute("list3", list3);

 

 

List userList = new ArrayList<>();

userList.add(user);

request.setAttribute("userList", userList);

%>

<h4>EL操作集合h4>

判断集合不为空：${!empty list1 } <br/>

判断集合为空：${empty list1 }  -- ${empty list2 }  -- ${empty list3 } <br/>

获取集合的值：${list1[0] }<br/>

获取集合中对象的属性：${userList[0].userName }<br/>

获取集合的长度：${userList.size() }<br/>

**************************************************************

EL操作集合

判断集合不为空：true 
判断集合为空：false -- true -- true 
获取集合的值：aaa
获取集合中对象的属性：admin
获取集合的长度：1

EL操作Map

**************************************************************

 

<%

Map map = new HashMap<>();

map.put("uname","zhansgan");

map.put("uage",18);

map.put("usex",true);

request.setAttribute("map", map);

%>

<h4>EL操作Maph4>

判断map是否为空：${empty map }<br/>

获取map对象：${map }<br/>

获取map中指定的key对应的value：${map.uname }  --  ${map["uage"] }

**************************************************************

EL操作Map

判断map是否为空：false
获取map对象：{uname=zhansgan, usex=true, uage=18}
获取map中指定的key对应的value：zhansgan -- 18

**************************************************************

 

<%

request.setAttribute("num1", 10);

request.setAttribute("num2", 2);

 

request.setAttribute("aa", "aaa");

request.setAttribute("ab", "aaa");

request.setAttribute("ac", "bbb");

 

%>

<h4>EL运算h4>

加法：${num1 + num2 } <br/>

减法：${num1 - num2 }<br/>

乘法：${num1 * num2 }<br/>

除法：${num1 / num2 } -- ${num1 div num2 }<br/>

大小比较：${num1 > num2 }  -- ${num1 >10 } --- ${(num1+num2) <= 10 }<br/>

等值比较：${aa == ab } -- ${aa eq ac }<br/>

${(num1+num2) > 10 && aa == ab }<br/>

${(num1+num2) > 10 || aa == ab }<br/>

 

<%

// 通过pageContext对象设置指定域范围的值

pageContext.setAttribute("userName", "Lisa", PageContext.REQUEST_SCOPE);

 

String userName = (String) pageContext.getAttribute("userName", PageContext.REQUEST_SCOPE);

 

System.out.println(userName);

 

%>

**************************************************************

EL运算

加法：12 
减法：8
乘法：20
除法：5.0 -- 5.0
大小比较：true -- false --- false
等值比较：true -- false
true
true

**************************************************************

body>

html>

 

五、JSP 内置对象总结

掌握内置对象的主要作用

掌握九个内置对象及其对应类型

在 JSP 之中，已经专门为用户的使用提供了许多的内置对象，所谓的内置对象主要是指所有的对象不用由用户自己进行对象的实例化操作，而可以直接进行使用

例如，之前的 request, 有一个接收参数的方法：public String getParameter(String paramName),实际上对于 request 本身就是一个内置对象

WEB 容器为用户准备好了这些个内置对象

1) JSP 中有九个内置对象

2) JSP 内置对象四种属性范围（重点）

目标

⑴掌握属性的操作方法

⑵掌握 JSP 中的四种属性范围的作用

⑶掌握 pageContext 对象设置四种属性范围的方法

四种属性范围

在JSP中提供了四种属性的保存范围，所谓的属性保存范围，指的就是一个设置的对象，可以再多少个页面中保存并可以继续使用

page 范围 àpageContext : 只在一个页面中保存属性，跳转之后无效

request 范围 àrequest : 只在一次请求中保存，服务器跳转后依然有效

session 范围 àsession : 在一次会话范围中，无论何种跳转都可以使用，但是新开浏览器无法使用

application 范围 àapplication : 在整个服务器上保存，所有用户都可以用

属性都有的操作方法

验证各个属性范围的特点

page: 本页面取得服务器端跳转（）后无效

request : 服务器跳转（）有效，客户端跳转（超链接）无效

如果是客户端跳转，则相当于发出了两次请求，那么第一次的请求将不存在了

如果希望不管是客户端还是服务器跳转，都可以保存的话，就需要继续扩大范围。

session : 无论客户端还是服务器端都可以取得，但是现在重新开启一个新的浏览器，则无法取得之前设置的 session 了，因为每一个 session 只保存在当前的浏览器当中，并在相关的页面取得。

对于服务器而言，每一个连接到它的客户端都是一个 session

如果想要让属性设置一次之后，不管是否是新的浏览器打开都能取得则可以使用

application

application : 所有的 application 属性直接保存在服务器上，所有的用户(每一个 session)都可以直接访问取得

只要是通过 application 设置的属性，则所有的 session 都可以取得，表示公共的内容，但是如果此时服务器重启了，则无法取得了，因为关闭服务器后，所有的属性都消失了，所以需要重新设置。

使用哪个范围呢？在合理范围尽可能小

page 范围

page 范围是通过 pageContext 对象设置的，之前研究过的 page 属性范围中使用的是pageContext 进行属性设置的，但是从 javax.servlet.jsp.PageContext 类中可以发现，有以下的一种设置属性的方法：

public void setAttribute(String name, Object value, int scope)

在 PageContext 类中存在四个表示属性范围的常量，可以直接通过这些常量指定 scope:

pageContext.PAGE_SCOPE

pageContext.REQUEST_SCOPE

pageContext.SESSION_SCOPE

pageContext.APPLICATION_SCOPE

在其它页面取值时，需要指定对应的作用域，或者通过 EL 表达式

<%=pageContext.getAttribute("a",pageContext.SESSION_SCOPE) %>