JSP内置九个对象；pageContext对象;JSP的7个动作指令

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量1.9k 收藏 2
点赞数
分类专栏： jsp与servlet 文章标签： jsp application session include servlet java

http://adminsun.iteye.com/blog/537469

  1. JSP脚本中包含9个内置对象，这9个内置对象都是Servlet API接口的实例，只是JSP规范将它们完成了默认初始化（由JSP页面对应Servlet的_jspService()方法来创建这些实例）。也就是说，它们已经是对象，可以直接使用。9个内置对象依次如下：  
  2.     application：javax.servlet.ServletContext的实例，该实例代表JSP所属的Web应用本身，可用于JSP页面，或者Servlet之间交换信息。常用的方法有getAttribute(String attName)、setAttribute(String attName , String attValue)和getInitParameter(String paramName)等。  
  3.     config：javax.servlet.ServletConfig的实例，该实例代表该JSP的配置信息。常用的方法有getInitParameter(String paramName)和getInitParameternames()等方法。事实上，JSP页面通常无须配置，也就不存在配置信息。因此，该对象更多地在Servlet中有效。  
  4.     exception：java.lang.Throwable的实例，该实例代表其他页面中的异常和错误。只有当页面是错误处理页面，即编译指令page的isErrorPage属性为true时，该对象才可以使用。常用的方法有getMessage()和printStackTrace()等。  
  5.     out：javax.servlet.jsp.JspWriter的实例，该实例代表JSP页面的输出流，用于输出内容，形成HTML页面。  
  6.     page：代表该页面本身，通常没有太大用处。也就是Servlet中的this，其类型就是生成的Servlet类，能用page的地方就可用this。  
  7.     pageContext：javax.servlet.jsp.PageContext的实例，该对象代表该JSP页面上下文，使用该对象可以访问页面中的共享数据。常用的方法有getServletContext()和getServletConfig()等。  
  8.     request：javax.servlet.http:HttpServletRequest的实例，该对象封装了一次请求，客户端的请求参数都被封装在该对象里。这是一个常用的对象，获取客户端请求参数必须使用该对象。常用的方法有getParameter(String paramName)、getParameterValues(String paramName)、setAttribute(String atttName,Object attrValue)、getAttribute(String attrName)和setCharacterEncoding(String env)等。  
  9.     response：javax.servlet.http.HttpServletResponse的实例，代表服务器对客户端的响应。通常很少使用该对象直接响应，而是使用out对象，除非需要生成非字符响应。而response对象常用于重定向，常用的方法有getOutputStream()、sendRedirect(java.lang.String location)等。  
  10.     session：javax.servlet.http.HttpSession的实例，该对象代表一次会话。当客户端浏览器与站点建立连接时，会话开始；当客户端关闭浏览器时，会话结束。常用的方法有：getAttribute(String attrName)、setAttribute(String attrName, Object attrValue)等。  
  1. 使用pageContext可以访问page、request、session、application范围的变量。  
  2. pageContext是PageContext类的实例，它提供了如下两个方法来访问page、request、session、application范围的变量。  
  3.     getAttribute(String name)：取得page范围内的name属性。  
  4.     getAttribute(String name,int scope)：取得指定范围内的name属性，其中scope可以是如下4个值：  
  5.     PageContext.PAGE_SCOPE：对应于page范围。  
  6.     PageContext.REQUEST_SCOPE：对应于request范围。  
  7.     PageContext.SESSION_SCOPE：对应于session范围。  
  8.     PageContext.APPLICATION_SCOPE：对应于application范围。  
  9. 与getAttribute()方法相对应，PageContext也提供了2个对应的setAttribute()方法，用于将指定变量放入page、request、session、application范围内。  
  10. 下面的JSP页面示范了使用pageContext来操作page、request、session、application范围内的变量。  
  11. 程序清单：codes\02\2.9\jspObject\pageContextTest.jsp  
  12. <%@ page contentType="text/html; charset=gb2312" language="java" %>  
  13. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">  
  14. <HTML>  
  15. <HEAD>  
  16. <TITLE>pageContext测试</TITLE>  
  17. </HEAD>  
  18. <BODY>  
  19. <%  
  20. //使用pageContext设置属性，该属性默认在page范围内  
  21. pageContext.setAttribute("page","hello");  
  22. //使用request设置属性，该属性默认在request范围内  
  23. request.setAttribute("request","hello");  
  24. //使用pageContext将属性设置在request范围中  
  25. pageContext.setAttribute("request2","hello"   
  26. , pageContext.REQUEST_SCOPE);  
  27. //使用session将属性设置在session范围中  
  28. session.setAttribute("session","hello");  
  29. //使用pageContext将属性设置在session范围中  
  30. pageContext.setAttribute("session2","hello"   
  31. , pageContext.SESSION_SCOPE);  
  32. //使用application将属性设置在application范围中  
  33. application.setAttribute("app","hello");  
  34. //使用pageContext将属性设置在application范围中  
  35. pageContext.setAttribute("app2","hello"   
  36. , pageContext.APPLICATION_SCOPE);  
  37. //下面获取各属性所在的范围：  
  38. out.println("page变量所在范围：" +   
  39. pageContext.getAttributesScope("page") + "<br>");  
  40. out.println("request变量所在范围：" +  
  41. pageContext.getAttributesScope("request") + "<br>");  
  42. out.println("request2变量所在范围："+  
  43. pageContext.getAttributesScope("request2") + "<br>");  
  44. out.println("session变量所在范围：" +  
  45. pageContext.getAttributesScope("session") + "<br>");  
  46. out.println("session2变量所在范围：" +  
  47. pageContext.getAttributesScope("session2") + "<br>");  
  48. out.println("app变量所在范围：" +  
  49. pageContext.getAttributesScope("app") + "<br>");  
  50. out.println("app2变量所在范围：" +   
  51. pageContext.getAttributesScope("app2") + "<br>");  
  52. %>  
  53. </BODY>  
  54. </HTML>  
  55. 上面页面的粗体字代码使用pageContext将各变量分别放入page、request、session、application范围内，程序的斜体字代码还使用pageContext获取各变量所在的范围。  


  1. JSP动作指令主要有如下7个：  
  2.     jsp:forward：执行页面转向，将请求的处理转发到下一个页面。  
  3.     jsp:param：用于传递参数，必须与其他支持参数的标签一起使用。  
  4.     jsp:include：用于动态引入一个JSP页面。  
  5.     jsp:plugin：用于下载JavaBean或Applet到客户端执行。  
  6.     jsp:useBean：创建一个JavaBean的实例。  
  7.     jsp:setProperty：设置JavaBean实例的属性值。  
  8.     jsp:getProperty：输出JavaBean实例的属性值。  
  9.   
  10. forward指令  
  11. forward指令用于将页面响应转发给另外的页面。既可以转发给静态的HTML页面，也可以转发到动态的JSP页面，或者转发到容器中的Servlet。  
  12. JSP的forward指令的格式如下。  
  13. 对于JSP 1.0，使用如下语法：  
  14. <jsp:forward page="{relativeURL|<%=expression%>}"/>   
  15. 对于JSP 1.1以上，可使用如下语法：  
  16. <jsp:forward page="{relativeURL|<%=expression%>}">  
  17. {<jsp:param.../>}   
  18. </jsp:forward>  
  19. 第二种语法用于在转发时增加额外的请求参数。增加的请求参数的值可以通过HttpServletRequest类的getParameter()方法获取。  
  20. 下面示例页面使用了forward动作指令来转发用户请求。  
  21. 程序清单：codes\02\2.2\jspPrinciple\jsp-forward.jsp  
  22. <%@ page contentType="text/html; charset=gb2312" language="java" %>  
  23. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">  
  24. <HTML>  
  25. <HEAD>  
  26. <TITLE>forward的原始页</TITLE>  
  27. </HEAD>  
  28. <BODY>  
  29. <h3>forward的原始页</h3>  
  30. <jsp:forward page="forward-result.jsp">  
  31. <jsp:param name="age" value="29"/>  
  32. </jsp:forward>  
  33. </BODY>  
  34. </HTML>  
  35. 这个JSP页面非常简单，它包含了简单的title信息，页面中也包含了简单的文本内容，页面的粗体字代码则将客户端请求转发到forward-result.jsp页面，转发请求时增加了一个请求参数：参数名为age，参数值为29。  
  36. 在forward-result.jsp页面中，使用request内置对象（request内置对象是HttpServletRequest的实例，关于request的详细信息参看下一节）来获取增加的请求参数值。  
  37. 程序清单：codes\02\2.2\jspPrinciple\forward-result.jsp  
  38. <%@ page contentType="text/html; charset=gb2312" language="java" %>  
  39. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">  
  40. <HTML>  
  41. <HEAD>  
  42. <TITLE>forward结果页</TITLE>  
  43. </HEAD>  
  44. <BODY>  
  45. <!-- 使用request内置对象获取age参数的值 -->  
  46. <%=request.getParameter("age")%>  
  47. </BODY>  
  48. </HTML>  
  49. 执行forward指令转发请求时，客户端的请求参数不会丢失。看下面表单提交页面的例子，该页面没有任何动态的内容，只是一个静态的表单页，作用是将请求参数提交到jsp-forward.jsp页。  
  50. 程序清单：codes\02\2.2\jspPrinciple\form.jsp  
  51. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">  
  52. <HTML>  
  53. <HEAD>  
  54. <TITLE>提交</TITLE>  
  55. </HEAD>  
  56. <BODY>  
  57. <!-- 表单提交页面 -->  
  58. <form id="login" method="post" action="jsp-forward.jsp">  
  59. <INPUT TYPE="text" NAME="username">  
  60. <INPUT TYPE="submit" value="login">  
  61. </FORM>  
  62. </BODY>  
  63. </HTML>  
  64. 修改forward-result.jsp页，增加输出表单参数的代码，修改后forward-result.jsp页面的代码如下：  
  65. 程序清单：codes\02\2.2\jspPrinciple\forward-result.jsp  
  66. <%@ page contentType="text/html; charset=gb2312" language="java" %>  
  67. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">  
  68. <HTML>  
  69. <HEAD>  
  70. <TITLE>forward结果页</TITLE>  
  71. </HEAD>  
  72. <BODY>  
  73. <!-- 使用request内置对象获取age参数的值 -->  
  74. <%=request.getParameter("age")%>  
  75. <!-- 输出username请求参数的值 -->  
  76. <%=request.getParameter("username")%>  
  77. </BODY>  
  78. </HTML>  
  79. forward-result.jsp页面中不仅可以输出forward指令增加的请求参数，还可以看到表单里username表单域对应的请求参数，这表明执行forward时不会丢失请求参数。  
  80. include指令  
  81. include指令是一个动态include指令，也用于导入某个页面，它不会导入被include页面的编译指令，仅仅将被导入页面的body内容插入本页面。  
  82. 下面是include动作指令的语法格式：  
  83. <jsp:include page="{relativeURL│<%=expression%>}" flush="true"/>   
  84. 或者  
  85. <jsp:include page="{relativeURL│<%=expression%>}" flush="true">   
  86. <jsp:param name="parameterName" value="patameterValue"/>   
  87. </jsp:include>  
  88. flush属性用于指定输出缓存是否转移到被导入文件中。如果指定为true，则包含在被导入文件中；如果指定为false，则包含在原文件中。对于JSP 1.1旧版本，只能设置为false。  
  89. 对于第二种语法格式，则可在被导入页面中加入额外的请求参数。  
  90. 下面页面使用了动态导入语法来导入指定JSP页面。  
  91. 程序清单：codes\02\2.2\jspPrinciple\jsp-include.jsp  
  92. <%@ page contentType="text/html; charset=gb2312" language="java" %>  
  93. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">  
  94. <HTML>  
  95. <HEAD>  
  96. <TITLE>jsp-include测试</TITLE>  
  97. </HEAD>  
  98. <BODY>  
  99. <!-- 使用动态include指令导入页面 -->  
  100. <jsp:include page="scriptlet.jsp" />  
  101. </BODY>  
  102. </HTML>  
  103. 上面页面中粗体字代码使用了动态导入语法来导入了scriptlet.jsp。表面上看，该页面的执行效果与使用静态include导入的页面并没有什么不同。但查看jsp-include.jsp页面生成Servlet的源代码，可以看到如下片段：  
  104. //使用页面输出流，生成HTML标签内容  
  105. out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\ ">\r\n");  
  106. out.write("<HTML>\r\n");  
  107. out.write("<HEAD>\r\n");  
  108. out.write("<TITLE>jsp-include测试</TITLE>\r\n");  
  109. out.write("</HEAD>\r\n");  
  110. out.write("<BODY>\r\n");  
  111. //动态导入，直接引入scriptlet.jsp页面  
  112. org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response,   
  113. "scriptlet.jsp", out);  
  114. out.write("\r\n");  
  115. out.write("</BODY>\r\n");  
  116. out.write("</HTML>\r\n");  
  117. out.write("\r\n");  
  118. 上面代码片段中粗体字代码显示了动态导入的关键：动态导入只是使用一个include方法来插入目标页面的内容，而不是将目标页面完全融入本页面中。  
  119. 归纳起来，静态导入和动态导入有如下两点区别：  
  120.    静态导入是将被导入页面的代码完全融入，两个页面融合成一个整体Servlet；而动态导入则在Servlet中使用include方法来引入被导入页面的内容。  
  121.    静态导入时被导入页面的编译指令会起作用；而动态导入时被导入页面的编译指令则失去作用，只是插入被导入页面的body内容。  
  122. 除此之外，执行include动态指令时，还可增加额外的请求参数，如下面JSP页面所示。  
  123. 程序清单：codes\02\2.2\jspPrinciple\jsp-include2.jsp  
  124. <%@ page contentType="text/html; charset=gb2312" language="java" %>  
  125. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">  
  126. <HTML>  
  127. <HEAD>  
  128. <TITLE>jsp-include测试</TITLE>  
  129. </HEAD>  
  130. <BODY>  
  131. <jsp:include page="forward-result.jsp" >  
  132. <jsp:param name="age" value="32"/>  
  133. </jsp:include>  
  134. </BODY>  
  135. </HTML>  
  136. 在上面的JSP页面中的粗体字代码同样使用jsp:include指令导入页面，而且在jsp:include指令中还使用param指令传入参数，该参数可以在forward-result.jsp页面中使用request对象获取。

君记否
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JSP JSP语法 JSP注释 JSP指令 JSP九大内置对象 pageContext域对象 JSP动作标签
ID_九流
07-10 478
（1）jsp概述1.1 什么是jspjsp（java Server Pages）是JavaWeb服务端的动态资源，它与html作用是相同的 显示数据和获取数据1.2 jsp的组成JSP=html+Java脚本（代码片段）+JSP动态资源（2）JSP语法2.1 jsp脚本jsp脚本就是Java代码片段 分为三种&lt;%...%&gt; java语句 在标签当中可以定义Java语句 翻译后的Java...
JSP 内置对象
weixin_45743799的博客
01-14 970
JSP中一共预先定义了9个这样的对象，分别为：request、response、session、application、out、pagecontext、config、page、exception 1、request对象 　　request 对象是 javax.servlet.httpServletRequest类型的对象。 该对象代表了客户端的请求信息，主要用于接受通过HTTP协议传送到服务器的数...
JSP的9个内置对象之pageContext对象
qq_34342083的博客
12-31 4508
这个对象代表页面上下文，该对象主要用于访问JSP之间的共享数据。使用pageContext可以访问page，request，session，application范围内的变量。一，用什么方法获取page，request，session，application范围的变量？ pageContext是PageContext类的实例，它提供了如下两个方法来访问page，request，session，ap
javaweb基础之jsp八大内置对象
qq_41720578的博客
05-13 1385
一、out对象 out对象用于向浏览器输出数据，其常用方法是print（），该方法用于在页面中显示字符串信息。 <% out.print("<span id='nav_user'>欢迎用户登录</span>"); %> 二、request对象 request对象中包含了浏览器请求的相关信息。 常用方法： 1、getParameter(String name) return:String 作用:根据页面表单组件获取页面提交数据。 2、getPa
JSP的page指令
佟强
10-09 1955
              JSP中的page指令 佟强 2008.10.9        page指令用来定义JSP文件中的全局属性。一个JSP页面可以包含多个page指令，除了import属性外，其它属性只能出现一次。        [language="java"]        [import="{package.class|package.*},..."]        [c
java jsp内置对象,jsp九个内置对象详解
weixin_29100927的博客
03-13 469
JSP有九个内置对象(又叫隐含对象)，不需要预先声明就可以在脚本代码和表达式中随意使用1.总结介绍#对象名称对象介绍1out用于向客户端，浏览器输出数据。2request封装了来自客户端、浏览器的各种信息。3response封装了服务器的响应信息。4exception封装了jsp程序执行过程中发生的异常和错误信息。5config封装了应用程序的配置信息。6page指向了当前jsp程序本身。7ses...
JSP 九大内置对象及四个作用域详解
热门推荐
梦和远方的博客
01-18 3万+
JSP中一共预先定义了9个内置对象：内置对象，又叫做隐含对象，不需要预先声明就可以在脚本代码和表达式中随意使用 request、response、session、application、out、pagecontext、config、page、exception request 请求对象　 类型 javax.servlet.ServletRequest...
jsp九个内置对象 六个基本动作 三个指令元素
03-29
### JSP九个内置对象 六个基本动作 三个指令元素 #### 四种属性范围 在JSP中，有四种不同的属性范围，这些范围决定了属性的生命周期与可见性： 1. **Page Scope (页面作用域)**：仅在一个JSP页面内有效。一旦该...
JSP的九个内置对象及四个作用域
04-02
JSP 九个内置对象及四个作用域 JSP（Java Server Pages）是一种基于Java的服务器端脚本语言，用于生成动态网页。在JSP中，九个内置对象是指不需要预先声明就可以在脚本代码和表达式中使用的对象，这些对象都是javax...
JSP内置对象之域对象和JSP指令
03-06
### JSP内置对象之域对象和JSP指令详解 #### JSP内置对象之域对象 在JSP技术中，有几种内置对象被称为“域对象”，它们用于存储数据，并且具有不同的作用范围。这些域对象包括`pageContext`、`request`、`session`...
jsp内置对象及方法详细介绍
10-27
下面将详细说明这9个JSP内置对象及其作用域和方法。 1. request对象 request对象代表了客户端的请求，其类型为javax.servlet.http.HttpServletRequest。它是客户端与服务器交互时，所发出的HTTP请求信息的封装。...
浅析JSP的9大内置对象和4大作用域对象
10-22
此外，JSP页面还允许开发者通过page指令和taglib指令等自定义指令来增强页面的功能和可维护性，这些指令虽然不是内置对象，但在JSP页面的开发中也占据重要的位置。 总之，深入理解和熟练运用JSP的内置对象和作用域...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 420
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 776
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 561
@Transactional中使用线程锁导致了锁失效与解决方案
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 256
android apk 加固后的地图加载异常及重新签名
Java学习_18_Stream流
qq_41136689的博客
08-23 1011
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 114
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
微服务框架
Founder_Xiao_Xin的博客
08-20 791
在分布式系统中，服务可能失败导致雪崩，Hystrix 是防雪崩利器，具有服务降级、服务熔断、服务隔离、监控等防止雪崩的技术。服务降级：接口调用失败调用本地方法返回空。服务熔断：接口调用失败进入熔断方法返回错误信息。服务隔离：隔离服务之间相互影响。服务监控：记录服务调用的运行指标。在分布式系统中，一个业务因跨越不同数据库或不同微服务而包含多个子事务，要求所有子事务同时成功或失败，这就是分布式事务。例如某电商系统下单操作，需请求订单服务、账户服务、库存服务。
JSP内置对象详解：request、response、session等
理解并熟练运用这九种内置对象是每个JSP开发者必备的技能，它们构成了JSP基础功能的核心，并且与Servlet API紧密关联，使得开发者能够更高效地编写Web应用程序。通过结合这些对象，开发者可以轻松地处理用户请求、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值