1. JSP简介
1.1. 什么是JSP?
JSP(Java Server Pages):是以Java语言为基础的动态网页开发技术
1.2. JSP特点
- Servlet特点:在Java源码中嵌入html源码
- JSP特点:在html源码中嵌入java代码
1.3. JSP就是servlet
- tomcat获得JSP文件后,先将JSP转成servlet,变成xxx_jsp.java(servlet源码)
转换后的Java文件及class类文件存放在
Tomcat安装目录\work\catalina\localhost\项目名\org\apache\jsp文件夹下。 - tomcat将java文件编译成class文件
- tomcat运行class文件,并将结果输出到浏览器
1.4. 示例讲解JSP的生命周期
1.4.1. 创建一个xxx.jsp文件
创建一个NewFile.jsp文件
1 <%@ page language="java" contentType="text/html; charset=UTF-8"
2 pageEncoding="UTF-8"%>
3 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
4 <html>
5 <head>
6 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
7 <title>Insert title here</title>
8 </head>
9 <body>
10 hahaha
11 </body>
12 </html>
1.4.2. 查看xxx_jsp.java文件
查看上一步NewFile.jsp的页面实现类
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 }
在第15行可以看到public final class NewFile_jsp extends org.apache.jasper.runtime.HttpJspBase implements org.apache.jasper.runtime.JspSourceDependent
代码片段,说明NewFile_jsp.java继承自HttpJspBase。
下面看看HttpJspBase的源码:
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 }
在第36行可以看到public abstract class HttpJspBase extends HttpServlet implements HttpJspPage
,看到了一个熟悉的类,HttpServlet,我们编写Servlet时就是继承自该类,这里也是继承HttpServlet,并且HttpJspBase的源码会发现,生命周期也是有init()方法,service()方法,destory()方法,相当于_jspService()方法就是servlet的service()方法的执行,所以说JSP也是一个servlet。
1.4.3. JSP生命周期阶段
阶段名称 | 说明 |
---|---|
页面转换 | 对页面解析并创建一个包含对应servlet的java源文件 |
页面编译 | 对Java源文件编译 |
加载和创建实例 | 将编译后的类加载到容器中,并创建一个servlet实例 |
调用jspInit() | 调用其他方法之前调用该方法初始化 |
调用_jspServce() | 对每个请求调用一次该方法 |
调用jspDestory() | 当Servlet容器决定停止Servlet服务时调用该方法 |
1.4.4. 注意
jsp生成java源码,由于JSP只会在客户端第一次请求的时候被编译,因此第一次请求JSP时会感觉比较慢,而之后的请求因为不会编译JSP,所以速度就快多了,如果将Tomcat保存的JSP编译后的class文件删除,Tomcat也会重新编译JSP。在开发Web程序的时候经常需要修改JSP,Tomcat能够自动检测到JSP程序的改动,如果检测到JSP源代码发生了改动,Tomcat会在下次客户端请求JSP时重新编译JSP,而不需要重启Tomcat,这种自动检测功能默认是开启的,检测改动会消耗少量的时间,在部署web应用程序的时候可以在web.xml中将它关掉。这也就是为什么我们能够在jsp页面直接修改内容,而不用重新启动服务器的原因。
因为JSP就是servlet,那么生命周期也就是跟serlvet一样。
JSP和servlet有一点区别就在于:jsp是先部署后编译,而servlet是先编译后部署。
2. JSP模板元素
就是JSP中的HTML代码,它的内容是固定的,无论程序如何运行模版数据输出到客户端浏览器时都不会发生改变,当我们创建一个JSP时,模版就已经固定了。
2.1. 元素
JSP中的java部分,包括脚本(JavaScript,或者java代码)以及JSP指令(Directive)与JSP标签(Tag)等,元素决定着程序的流程,元素是不会显示到浏览器的。这几个都会在接下来讲解到
3. JSP脚本元素
JSP页面中有三种脚本元素:声明、小脚本和表达式。
3.1. JSP声明
声明用来在JSP页面中声明变量和定义方法,声明标签为:“<%! Java代码 %>”;可以包含任意数量的核发的Java声明语句。
例子:
<%!
LocalDate date = null;
double r = 0;
double getArea(double r){
return r*r*Math.PI;
}
%>
声明的变量仅在页面第一次载入时有容器初始化一次,初始化后在后面的请求中一直保持该值。
3.2. JSP小脚本
小脚本是嵌入在JSP页面中的Java代码段。小脚本标签为:“<% 编写Java代码 %>”;Java代码必须遵循Java语法。
为什么能够使用out输出?这里就涉及到了JSP的九大内置对象了,后面会讲解到,到时候回过头来在看看这里,就会知道为什么可以使用。
来看看,jsp变为servlet时的代码是如何编写的。
在JSP中JSP指令(后面会讲):
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
这句代码在servlet就变为了
response.setContentType("text/html; charset=UTF-8");
//这句代码的意思就是通知tomcat和浏览器都使用UTF-8码表,并且发送回浏览器的数据类型是text/html。这是有JSP指令中画红色部分代码转变的,而指令中的pageEncoding="UTF-8"的意思是JSP转换为Servlet时采用UTF-8码表编码,因为可能JSP中包含中文。
对于JSP模版数据来说,就原封不动的使用out.write()来输出到浏览器。而对于JSP元素来说,就会变成普通的java代码,因为在servlet中,就可以直接编写java代码。
3.2.1. 注意
小脚本中的代码转换为_jspService()方法中的一部分,所以不能在小脚本中声明方法,因为在Java语言中不能在方法中定义方法。
3.3. JSP表达式
表达式的形式:“<%= result %>”
使用<%=result %>来输出结果,servlet中就会将其转换为out.print(result)进行输出。输出各种类型数据:int、double、boolean、String、Object等。
4. JSP指令
指令用来申明JSP页面的一些属性,比如编码方式,文档类型。我们在servlet中也会申明我们使用的编码方式和响应的文档类型的,而JSP就是用指令来申明。上面我们也说到了一条指令,也就是page指令。
JSP指令格式:<%@ directive {attribute=value}* %>
解释:
directive:指令名称,例如page指令
attribute=value:紧跟指令名称后面的就是各种属性,以键值对的形式书写
*:代表后面能跟0个或多个属性。
4.1. page指令
page指令用于告诉容器关于JSP页面的总体特征,改指令适用于整个转换单元而不仅仅是它所声明的页面。
4.1.1. page指令常用属性
属性名 | 说明 | 默认值 |
---|---|---|
import | 导入在JSP页面中使用的Java类和接口,其间用逗号分隔 | java.lang.; javax.servlet.; |
contentType | 指定输出的内容类型和字符集 | text/html;charest=IOS-8859-1 |
pageEncoding | 指定JSP文件的字符编码 | IOS-8859-1 |
session | 用布尔值指定JSP页面是否参加HTTP会话 | true |
errorPage | 用一个布尔值指定当前JSP页面是否用来处理错误 | false |
language | 指定容器支持的脚本语言 | java |
extends | 任何合法地实现了javax.servlet.jsp.JspPage接口的Java类 | 与实现有关 |
buffer | 指定输出缓冲区的大小 | 与实现有关 |
autoFlush | 指定是否当缓冲区满时自动刷新 | true |
info | 关于JSP页面的任何文本信息 | 与实现有关 |
isThreadSafe | 指定页面是否同时为多个请求服务 | true |
isElIgnored | 指定是否在此转换单元中对EL表达式求值 | 若web.xml采用Servlet格式,默认值为true |
4.2. include指令
4.2.1. 简介
比较简单,只有一种形式 <%@ include file="relativeURL"%>
。
file是include指令唯一的属性,它是指被包含的文件。
relativeURL:文件使用相对路径指定,相对路径或者以斜杠(/)开头,是相对于web应用程序文档根目录的路径,或者不以斜杠开头,他是相对于当前JSP文件的路径。例如,网址内所有页面均有一个统一风格的导航栏和页脚版权,那么就可以使用该指令将其包含进来。
由于被包含的JSP页面的代码称为主页面代码的一部门,因此,每个页面都可以访问另一个页面中定义的变量。他们也共享所有的隐含变量。
4.2.2. 特点
include指令会将包含页面的源代码添加到使用include指令的页面中来,然后编译成class文件,而等下会讲到的一个JSP行为,<jsp:include page="relativeURL">
作用跟include指令一样,但是不同的是,include行为是运行时单独执行包含页面,然后把执行的结果包含到本页面来,属于先运行后包含。
4.2.3. 静态包含的限制
- 在转换阶段不进行任何处理,这意味着file属性值不能是请求时表达式,一次下面的使用是非法的。
<%! String pageURL = "copyright.html"; %>
<%@ include file="<%= pageURL %>" %>
- 不能通过file属性值向被包含的页面传递任何参数,因为请求参数是请求的一个属性,他在转换阶段没有任何意义。下面例子中的file属性值是非法的。
<%@ include file="other.jsp?name=Hacker" %>
4.3. taglib指令
JSP支持标签技术,后面会讲到标签的用法,jstl标签库的使用等。
作用:用来指明JSP页面内使用的JSP标签库,taglib指令有两个属性,uri为类库的地址,prefix为标签的前缀。
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
5. JSP动作
5.1. 动态包含:include动作
5.1.1. 简介
动态包含是通过JSP标准动作<jsp:include>实现的。动态包含是在请求时将另一个页面的输出包含到主页面的输出中。
标准格式如下:
<jsp:include page="relativeURL" flush="true|false" />
其中:page属性是必需的,地址必须是相对URL,并指向任何静态或动态web组件。可选flush属性是指在将控制转向被包含页面之前是否刷新主页面。flush属性的默认值为false。
page属性的值可以是请求时表达式,例如:
<%! String pageURL="other.jsp"; %>
<jsp:include page="<%= pageURL %>" />
使用<jsp:include>动作的工作方式:
在功能上<jsp:include>动作的语义与RequestDispatcher接口的include()的语义相同,,因此,在servlet中实现包含使用下面代码:
RequestDispatcher rd = request.getRequestDispatcher("other.jsp");
rd.include(request,response);
5.1.2. 两种结构
- 结构一:
<% pageContext.include("other.jsp"); %>
- 结构二:
<jsp:include file="other.jsp" fluse="true" />
5.1.3. 两种传递参数的方式
- 使用<jsp:include>传递参数
<jsp:include page="somePage.jsp">
<jsp:param name="name1" value="<%= someExpr1 %>" />
<jsp:param name="name2" value="<%= someExpr2 %>" />
</jsp:incliude>
- 与动态包含的组件共享对象
被包含的页面是单独执行的,因此他们不能共享在主页面中定义的变量和方法。然而,他们处理的请求对象是相同的,因此可以共享属于请求作用域的对象。
5.2. forward动作
使用<jsp:forward>动作把请求转发到其他组件,然后由转发到的组件把响应发送给客户。
该动作的格式为:
<jsp:forward page="relativeURL" />
page属性的值为转发到的组件的相对URL,它可以使用请求时属性表达式。
在功能上<jsp:forward>的语义与RequestDispatcher接口的forward()的语义相同,因此在servlet中实现请求转发使用下面代码:
RequestDispatcher rd = request.getRequestDispatcher("other.jsp");
rd.forward(request,response);
page:需要跳转到的页面或者servlet、<jsp:param/>参数行为,带一些参数过去,name、value是以键值对的形式带过去的。
<jsp:forward page="someServlet">
<jsp:param name="param1" value="value1"/>
<jsp:param name="param2" value="value2"/>
</jsp:forward>
6. JavaBeans
6.1. JavaBeans规范
JavaBeans是用Java语言定义的类,这种类的设计需要遵循JavaBeans规范的有关约定。
要想作为JavaBeans使用,Java类需要满足下面三个条件:
- JavaBeans应该是public类,且具有无参数的public构造方法。
- JavaBeans类的成员变量一般称为属性(property)。每个属性访问权限一般定义为private。
- 每个属性通常定义两个public方法,一个是访问方法(getter),另一个是修改方法(setter)。
可以通过JSP标准动作<jsp:useBean>创建类的一个实例,JavaBeans类的实例一般称为一个bean。
6.2. JavaBeans优点
- 在JSP页面中使用JavaBeans可使代码更简洁。
- JavaBeans有助于增强代码的可重用性。
- 可以充分利用该语言面向对象的特征。
6.3. <jsp:useBean>动作
6.3.1. 简介
<jsp:useBean>动作用来在指定的作用域中查找或创建一个bean实例。一般格式如下:
<jsp:useBean id="beanName"
scope="page|request|session|application"
{
class="package.class" | type="package.class" | class="package.class" type="package.class"
}
{ /> | >其他元素</jsp:useBean> }
6.3.2. 属性说明
- id属性用来唯一表示一个bean实例。id属性是必需的。在JSP页面实现类中,id的值被作为Java语言的变量,因此可以在JSP页面的表达式和小脚本中使用该变量。
- scope属性指定bean实例的作用域。scope属性是可选的,默认值为page作用域。
- class属性指定创建bean实例的Java类。如果指定的作用域中找不到一个现存的bean实例,将使用class属性指定的类创建一个bean实例。
- type属性指定有id属性声明的变量的类型,由于该变量是在请求时指向实际的bean实例,其类型必须与bean类的类型相同或者是其超类型。(class和type至少指定一个或两个同时指定)。
6.4. <jsp:setProperty>动作
6.4.1 简介
<jsp:setProperty>动作用来给bean实例的属性赋值,格式如下:
<jsp:setProperty name="beanName"
{
property="propertyName" value="{String | <%= expression %>}" |
property="propertyName" [param="paramName"] |
property="*"
}
/>
6.4.2. 属性说明
- name属性用来表示一个bean实例,该实例必须是前面使用<jsp:useBean>动作声明的,并且name属性值必须与<jsp:useBean>动作中指定的一个id属性值相同,该属性是必需的。
- property属性指定要设置值的bean实例的属性,容器将根据指定的bean的属性调用适当的setXxx(),因此该属性也是必需的。
- value属性为bean的属性指定新值,该属性值可以直接接受请求时属性表达式。
- param属性指定请求属性名,如果请求中包含指定的参数,那么使用该参数值来设置bean的属性值。
- value属性和param属性都是可选的并且不能同时使用。这两个属性都没有指定,容器将查找与属性同名的请求参数。
6.5. <jsp:getProperty>动作
6.5.1. 简介
<jsp:getProperty>动作检索并向输出流中打印bean的属性值
<jsp:getProperty name="beanName" property="propertyName">
6.5.2. 属性说明
- name属性指定bean实例名
- property属性指定要输出的属性名
- 两个属性都是必需的。
6.6. JavaBeans示例
6.6.1. 创建一个User类
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 }
6.6.2. 使用上述动作
1 <body>
2 <!-- 创建一个新的javabean对象user,会先判断在page作用域内是否有叫user对象的javabean,如果有则取它,如果没有则创建新的javabean对象 -->
3 <jsp:useBean id="user" class="a.User" scope="page"></jsp:useBean>
4 <!-- 对javabean对象的username进行赋值 -->
5 <jsp:setProperty property="username" name="user" value="wu"/>
6 <!-- 获取javabean对象的username属性 -->
7 <jsp:getProperty property="username" name="user"/>
8 </body>
6.6.3. 查看生成的源代码
可以查看NewFile.jsp变为servlet后的源代码,看看我们写的javabean行为会被转换为何种语句
这里出现了一个JSP九大内置对象中的一个,pageContext。现在简单提一句,pageContext就是JSP页面的管理者(上下文),其中的getAttribute(name,scope)方法是获取指定作用域中的数据的,如果getAttribute(name)方法的话,默认是对page作用域进行操作,findAttribute(name)依次从page、request、session、application获得内容。
在第一个红框中,就代表中我们的useBean行为,其中进行了一次判断,就是如果在page作用域中找不到user这个对象,那么就创建一个新的,否则就使用找到的这个user对象,
第二个红框中,代表着我们的setProperty行为,先找到user对象,然后在对其属性进行赋值
第三个红框中,代表着我们的getProperty行为,也是先找到user对象,然后在获取其属性的值。
注意:对于javabean行为来说,有一个特点的地方,就是当请求过来的参数对应javabean的属性时,可以为其一次性设置所有的值:<jsp:setProperty name="user" property="*" />
//设置user的所有属性,属性值从request中自动取得,*代表所有属性。
7. 九大内置对象
九大内置对象只能在JSP的JSP小脚本和JSP表达式中使用。
隐含变量 | 类或接口 | 说明 |
---|---|---|
application | javax.servlet.ServletContext接口 | 引用web应用程序上下文 |
session | javax.servlet.http.HttpSession接口 | 引用用户会话 |
request | javax.servlet.http.HttpServletRequest接口 | 引用页面的当前请求对象 |
response | javax.servlet.http.HttpServletResponse接口 | 用来向客户发送一个响应 |
out | javax.servlet.jsp.JspWrite类 | 引用页面输出流 |
page | java.lang.Object类 | 引用页面的servlet实例。是当前JSP编译后的Servlet类的对象。相当于this。 |
pageContext | javax.servlet.jsp.PageContext类 | 引用页面上下文 |
config | javax.Servlet.ServletConfig接口 | 引用servlet的配置对象 |
exception | java.lang.Throwable类 | 用来处理错误 |
标记了红色的对象就是JSP独有的,其他的都是Servlet中的东西。
在这个由jsp转换为servlet的文件中,只能看到8个内置对象,少了exception对象,因为我们在将page指令时,说过一个isErrorPage属性,默认是false,被关闭了,所以其中并没有exception对象。
8. 四大作用域对象
在JSP页面中有4个作用域对象,他们的类型分别是ServletContext、HttpSession、HttpServletRequest和PageContext,这4个作用域分别称为应用(application)作用域、会话(session)作用域、请求(request)作用域和页面(page)作用域。
作用域名 | 对应的对象 | 存在性和可访问性 |
---|---|---|
应用作用域 | application | 在整个web应用程序有效 |
会话作用域 | session | 在一个用户会话范围内有效 |
请求作用域 | request | 在用户的请求和转发的请求内有效 |
页面作用域 | pageContext | 只在当前的页面(转换单元)内有效 |
8.1. pageContext对象
JSP页面的管理者(上下文),所以JSP中的内置对象呀,它统统能够获得,下面介绍它的api。
- 获得其它八大内置对象 getXxx()
pageContext.getOut(); //获得out对象
pageContext.getApplication(); //获得application对象
等等… - 对作用域的属性进行操作(四大作用域)
对默认作用域的属性进行操作。page
pageContext.getAttribute(name); //获得page作用域数据
pageContext.setAttribute(name,value); //给page作用域设置内容
pageContext.removeAttribute(name); //给page作用域移除内容 - 对指定作用域的属性进行操作
getAttribute(name,scope); //获得 指定作用域中的数据
setAttribute(name,value); //给指定作用域设置内容
removeAttribute(name ,scope) 移除指定作用域的内容 (page/request/session/application) - 提供作用域常量
PageContext.PAGE_SCOPE page
PageContext.REQUEST_SCOPE request
PageContext.SESSION_SCOPE response
PageContext.APPLICATION_SCOPE application - 一次获得指定名称内容
findAttribute(name); //依次从page、request、session、application 获得内容
9. 总结
- 什么是JSP?
JSP本质上就是一个servlet,因为servlet输出html太麻烦了,所以就有了JSP,JSP就是专门用来书写html的,当然其中也能写java代码。 - JSP的内容包括什么?
模版数据和元素。其中元素有包括脚本(java代码)、指令(页面属性)、和行为(标签,为了JSP中不嵌入那么多java代码衍生的) - JSP中九大内置对象是哪九个?
九大内置对象,page、config、appliction、request、response、session、out、exception、pageContext - 九大内置对象和servlet中对象的关系
page就是jsp转换为servletservlet对象本身,也就是this
config – Servlet中的servletConfig
application – Servlet中的ServletContext
request – Servlet中的request
response – Servlet中的response
session – Servlet中的session
out – JspWriter
exception – 异常对象
pageContext – 表示 jsp页面上下文(jsp管理者) 类型:PageContext,
其中pageContext对象最牛逼,有了他就拥有了天下,哈哈~ - JSP中的四大作用域。
page、request、session、application
其中操作page域中属性需要借助pageContext对象。