Jsp知识点：九大对象，四大作用域，七大动作指令，三大编译指令，转发与重定向等

小鱼儿 2022-06-06 12:10 283阅读 0赞

**jsp九大内置对象:**

**分别为：**

**request，response，session，page，application，out，pageContext，config，exception**

**四大作用域：request，session，page，application**

**![Image 1][]![Image 1][]![Center][]**

**1>out 向客户端输出数据,字节流.如out.print(" dgaweyr");  
   
2>request 接收客户端的http请求.  
String getParameter(String name):得到表单参数名name的值.  
String\[\] getParameterValues(String name):(得到String\[\]复选框时常用).  
setAttribute(String name,Object obj):设置属性名为name,属性值为obj.  
getAttribute(String name);得到属性值.  
   
3>response:封装jsp产生的回应,然后发送到客户端以响应客户的请求.重定向跳转任意界面.(服务器跳转)  
addCookie(Cookie cookie):  
sendRedirect("/wel.jsp"):跳转到指定页面  
   
4>session:用于保存用户信息,跟踪用户行为,当前打开的浏览器内,多个页面共享数据. session对象指的是客户端与服务器的一次会话,从客户连到服务器的一个WebApplication开始,直到客户端与服务器断开连接为止.它是HttpSession类的实例.  
setAttribute(String name,Object obj):设置属性名为name,属性值为obj.  
getAttribute(String name):得到属性值.  
   
5>application对象:实现了用户间数据的共享,可存放全局变量.它开始于服务器的启动,直到服务器的关闭,在此期间,此对象将一直存在;这样在用户的前后连接或不同用户之间的连接中,可以对此对象的同一属性进行操作;在任何地方对此对象属性的操作,都将影响到其他用户对此的访问.服务器的启动和关闭决定了application对象的生命.它是ServletContext类的实例.  
   
session,application,request的区别:  
一个项目中session尽量少用几个,因为过多的session会影响程序的执行效率.它主要用于保存登录信息(用户信息,权限,资源)即频繁使用的信息.  
application: 用于多个浏览器之间共享数据,多个用户共享该对象,可以做计数器.它的用法与session完全一样.  
数据范围:  
application(服务器关闭时失效)>session(浏览器关闭时失效)>request(只能用于两个跳转页面之间)  
   
6>page对象代表jsp这个实体本身,即当前页面有效.相当于java中的this.  
数据范围:page<session<application  
   
7>.exception:代表运行时的异常.  
在会发生异常的页面加入指令:<%@ page errorPage="处理错误的页面.jsp"%>  
在处理异常的页面写入:<%@ page isErrorPage="true"%>  
   
8>.pageContext对象 pageContext对象提供了对JSP页面内所有的对象及名字空间的访问,也就是说他可以访问到本页所在的SESSION,也可以取本页面所在的application的某一属性值,他相当于页面中所有功能的集大成者,它的本类名也叫pageContext.  
   
9>.config jsp对应的servlet的配置,可以得到web.xml中的初使化参数.  
   
jsp七大动作:  
一:include 动态包含(分别编译):  
用jsp:include动作实现<jsp: include page="included.jsp" flush="true" />  
它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。flush属性: 用true ，表示页面可刷新。默认为false;  
   
二:useBean动作(jsp页面使用javaBean的第二种方式):  
<jsp:useBean id="对象名" class="包名.类名" scope="作用范围(request/page/application/session)"/>  
作用域默认为page(本页面有效).  
三:getProperty动作(name为useBean动作中的id).  
从对象中取出属性值：<jsp:getProperty name="javaBean对象" property="javaBean对象属性名" />  
四:setProperty动作(name为useBean动作中的id):  
为对象设置属性值：<jsp:setProperty name="javaBean对象" property="javaBean对象属性名" value=http://www.hake.cc/kf/201109/"值"/>  
为对象设置属性值:<jsp:setProperty property="javaBean对象属性名" name="javaBean对象" param="username"/>  
(param="username" 相当于 value=http://www.hake.cc/kf/201109/<%=request.getParameter("username")%>)  
   
五:param动作(传递参数)):  
到达跳转页面可以通过 request.getParameter(“参数名”)方式取出参数值  
<jsp:include page="转向页面的url" >  
           <jsp:param   name="参数名1" value=http://www.hake.cc/kf/201109/"参数值1">**

** **

**<jsp:param   name="参数名2" value=http://www.hake.cc/kf/201109/"参数值2">  
           ...........  
 </jsp:include>  
或:  
<jsp:forward page="转向页面的url" >  
           <jsp:param   name="参数名1" value=http://www.hake.cc/kf/201109/"参数值1">  
           <jsp:param   name="参数名2" value=http://www.hake.cc/kf/201109/"参数值2">  
           ...........  
</jsp:forward>  
   
六:forward动作:  
跳转页面:<jsp:forward page="login.jsp" />  
   
七:plugin动作:<jsp:plugin>:用于指定在客户端运行的插件  
   
JSP三大指令之:  
一:page指令:  
1.指定页面编码.例:  
<%@ page language="java" contentType="text/html;charset=gbk" pageEncoding="gbk" %>  
2.导入包,例:  
<%@ page import="java.util.\*,java.text.\*" %>.  
二:include 指令  
静态包含(统一编译):<%@ include file="included.jsp"%>  
   
三：taglib  
   
三．Jsp中的静态包含与动态包含  
动态include(<jsp: include page="included.jsp"/>)  
静态include(<%@ include file="included.jsp"%>)  
1. 静态include的结果是把其他jsp引入当前jsp,两者合为一体,可以达到数据的共享即可以说是统一编译的,而  
动态include的结构是两者独立的,直到输出时才合并即为分别编译的.  
2.动态include的jsp文件独立性很强,是一个单独的jsp文件,需要使用的对象,页面设置,都由自己创建,而静态include纯粹是把代码写在外面的一种共享方法,所有的变量都是可以和include它的主文件共享,两者高度紧密结合,不能 有变量同名的冲突.而页面设置也可以借用主文件的.  
3.动态包含总是检查被包含页面的变化,静态包含不一定检查被包含页面的变化.  
4.动态包含可带参数,静态包含不能带参数.如(<jsp: include page="included.jsp">放入参数</jsp:include>);**

**转载网址：[http://blog.csdn.net/u010897406/article/details/49618413][http_blog.csdn.net_u010897406_article_details_49618413]**

**动作指令与编译指令不同，编译指令时通知servlet引擎的处理消息，而动作指令只是运行时的动作。编译指令在将JSP编译成Servlet时起作用，而处理指令通常可替换成JSP脚本，它只是JSP脚本的标准化写法。**

**（1）JSP：forward  执行页面转向，将请求的处理转发到下一个页面。**

**（2）JSP：param  用于传递参数，必须与其他支持参数的标签一起使用**

**（3）JSP：include  用于动态引入一个JSP页面**

**（4）JSP：plugin 用于下载JavaBean或者Applet到客户端执行**

**  (5)   JSP：useBean 创建一个Javabean实例**

**（6)  JSP：setProperty  设置JavaBean实例的属性值**

**（7）JSP：getProperty  获取JavaBean实例的属性值**

**（一）forward指令**

**       用于将页面相应转发到另外的页面，既可以转发到静态的html页面，也可以转发到动态的JSP页面，或者转发到容器中的Servlet。动态指令只需直接<>中使用指令，静态则是<%%>,动态指令均是成对出现的。**

**    JSP的forward指令格式如下：**

**      对于JSP1.0语法为：<JSP:forward page="\{relativeURL|<%=expression%>\}"/>   **

**      对于JSP1.1以上规范，语法为：<JSP:forward page="\{relativeURL|<%=expression%>\}">**

**                                                                            \{<JSP:param·······/>\}**

**                                                             </JSP:forward>  **

**   这种语法用于在转发时增加额外的请求参数。增加的请求参数的值可以通过HttpServletRequest类的getParameter（）方法获取。执行forward指令时，用户请求的地址依然没有发生改变，仍然是一次请求，但页面内容完全变为被forward目标页的内容。执行forward指令转发请求时，客户端的请求参数不会丢失。**

**（二）include指令**

**       include指令时一个动态include指令，也用于包含某一个页面，它不会导入被include页面的编译指令，仅仅被导入页面的body内容插入页面。**

**      <jsp:include page="\{relativeURL|<%=expression%>\}" flush="true">**

**               <jsp:param name="parameterName" value="parameterValue"/>**

**    <jsp:include/>**

**     flush属性用于指定输出缓存是否转移到被导入文件中，如果指定为true，则包含在被导入文件；如果指定为false，则包含在原文件中。对于JSP1.1旧版本中，只能设置为false。**

**注：include静态：编译指令 -----两个JSP页面融合成一个servlet**

**       include动态：动作指令------在servlet中使用include引入被导入页面的内容**

**    静态导入页面被导入页面的编译指令必须一致，否则会出错，动态则只包含body部分。**

**（三）userBean，setProperty，getProperty指令**

**这三个指令都是与JavaBean相关的指令，其中userBean指令用于在JSP页面中初始化一个java实例，setProperty指令用于为JavaBean实例的属性设置值；getProperty指令用于输出JavaBean实例的属性。如果多个JSP页面中需要重复使用的某段代码，我们可以把这段代码定义为java类的方法，然后多个JSP页面调用该方法即可，这样可以达到较好的代码复用。**

**userBean的语法格式如下**

**  <jsp:userBean id="name" class="classname" scope="page|request|session|application"/>**

**其中，id属性是JavaBean的实例名，class属性确定JavaBean的实现类。scope属性用于指定JavaBean实例的作用范围。**

**setProperty的语法格式**

** <jsp:setProperty name="BeanName" property="propertyName"   value="propertyValue"/>**

**其中，name属性是要确定JavaBean的实例名，property属性要确定设置属性的属性名，value属性时要确定属性名对应的值。**

**getProperty的语法格式**

**<jsp:getProperty  name="BeanName" name="propertyName"/>**

**其中，name属性时要确定JavaBean的实例名，name属性是指定要获取的属性名对应的值。**

**注：使用userBean标签时，除在页面脚本中创建了JavaBean实例之外，该标签还会将该JavaBean实例放入指定scope中，所以我们还需要在脚本中将JavaBean放入指定的scope中，所下面的代码所示：**

**pageContext.setAttribute("beanName",beanName)**

**request.setAtttibutr("beanName",beanName)**

**session.setAttribute("beanName",beanName)**

**application.setAttribute("beanName",beanName)**

**(四)plugin指令**

** plugin指令主要用于下载服务器端的JavaBean或Applet到到客户端执行，由于程序在客户端执行，因此客户端必须安装虚拟机。**

**（五）param指令**

**param用于设置参数值，这个指令本身不能单独使用，因此单独的param指令没有实际意义，param指令可以与以下指令结合使用**

**jsp：include  jsp：forward   jsp：plugin**

**转载网址：[http://blog.csdn.net/vltic/article/details/7648961][http_blog.csdn.net_vltic_article_details_7648961]**

**请求转发：request.getRequestDispatcher(URL地址).forward(request, response)**

**原理：**

1.  **客户端发送请求，Servlet1做出处理。**
2.  **Servlet1调用sendReadirect()方法，将请求转发给Servlet2来处理请求，为客户端服务。 **
3.  **Servlet2对客户端浏览器做出响应。**

**![23235026-612ffe1780cd430694c949b3ac22377f.jpg][]**

**请求转发允许把请求转发给同一应用程序中的其他Web组件。这种技术通常用于Web应用控制层的Servlet流程控制器，它检查HTTP请求数据，并将请求转发到合适的目标组件，目标组件执行具体的请求处理具体的请求处理操作，并生成响应结果。**

**Servlet类使用javax.servlet.RequestDispatcher.forward()方法来转发它所收到的HTTP请求。转发目标组件将处理该请求并生成响应结果，或者将请求继续转发到另一个组件。最初请求的ServletRequest和ServletResponse对象被传递给转发目标组件，这使得目标组件可以访问整个请求上下文。值得注意的是，只能把请求转发给同一Web应用中的组件，而不能转发给其他Web应用的组件。**

**在JSP页面中，可以使用<jsp:forward>标签来转发请求。例如： <jsp:forward page="hello.jsp">**

**对于请求转发，转发的源组件和目标组件共享request范围内的共享数据。**

** **

**重定向：response.sendRedirect(URL地址)**

**原理：**

1.  **客户端发送请求，Servlet1做出处理。  **
2.  **Servlet1调用sendReadirect()方法，将客户端的请求重新定位到Servlet2。  **
3.  **客户端浏览器访问Servlet2。**
4.  **Servlet2对客户端浏览器做出响应。**

**![23235045-5555c08fa5f24846aef6cff52dc967d1.jpg][]**

** **

**Web组件可以将请求重定向到任一URL，而不仅仅是同一应用中的URL。**

**重定向的源组件和目标组件之间不共用同一个HttpServletRequest对象，因此不能共享request范围内的共享数据。**

**HttpServletResponse的sendRedirect()方法向浏览器返回包含重定向的信息，浏览器根据这一信息迅速发出一个新HTTP请求，请求访问重定向目标组件。**

** **

**包含**

**包含关系允许一个Web组件聚集来自同一个应用中其他Web组件的输出数据，并使用被聚集的数据来创建响应结果。这种技术通常用于模板处理器，它可以控制网页的布局。模板中每个页面区域的内容来自不同的URL，从而组成单个页面。这种技术能够为应用程序提供一致的外观和感觉。包含关系的源组件和目标组件共用同一个HttpServletRequest对象，因此它们共享request范围内的共享数据。**

**![24000130-a3adce566c8a480aab7e3946473efe81.jpg][]**

** **

**转发、重定向的区别：**

1.  **Request Dispatcher.forward()是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；服务器内部转发，请求转发，整个过程处于同一个请求当中。**
2.  **response.sendRedirect()则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。不在同一个请求。重定向，实际上客户端会向服务器端发送两个请求。**
3.  **forward（）更加高效，在可以满足需要时，尽量使用RequestDispatcher.forward()方法。**
4.  **RequestDispatcher是通过调用HttpServletRequest对象的getRequestDispatcher()方法得到的，是属于请求对象的方法。**
5.  **sendRedirect()是HttpServletResponse对象的方法，即响应对象的方法，既然调用了响应对象的方法，那就表明整个请求过程已经结束了，服务器开始向客户端返回执行的结果。**

**（1）RequestDispatcher.forward方法只能将请求转发给同一个WEB应用中的组件；而HttpServletResponse.sendRedirect 方法不仅可以重定向到当前应用程序中的其他资源，还可以重定向到同一个站点上的其他应用程序中的资源，甚至是使用绝对URL重定向到其他站点的资源。如果传递给HttpServletResponse.sendRedirect 方法的相对URL以“/”开头，它是相对于整个WEB站点的根目录；如果创建RequestDispatcher对象时指定的相对URL以“/”开头，它是相对于当前WEB应用程序的根目录。**

**（2）调用HttpServletResponse.sendRedirect方法重定向的访问过程结束后，浏览器地址栏中显示的URL会发生改变，由初始的URL地址变成重定向的目标URL；而调用RequestDispatcher.forward 方法的请求转发过程结束后，浏览器地址栏保持初始的URL地址不变。**

**（3）HttpServletResponse.sendRedirect方法对浏览器的请求直接作出响应，响应的结果就是告诉浏览器去重新发出对另外一个URL的 访问请求，这个过程好比有个绰号叫“浏览器”的人写信找张三借钱，张三回信说没有钱，让“浏览器”去找李四借，并将李四现在的通信地址告诉给了“浏览器”。于是，“浏览器”又按张三提供通信地址给李四写信借钱，李四收到信后就把钱汇给了“浏览器”。可见，“浏览器”一共发出了两封信和收到了两次回复， “浏览器”也知道他借到的钱出自李四之手。RequestDispatcher.forward方 法在服务器端内部将请求转发给另外一个资源，浏览器只知道发出了请求并得到了响应结果，并不知道在服务器程序内部发生了转发行为。这个过程好比绰号叫“浏览器”的人写信找张三借钱，张三没有钱，于是张三找李四借了一些钱，甚至还可以加上自己的一些钱，然后再将这些钱汇给了“浏览器”。可见，“浏览器”只发 出了一封信和收到了一次回复，他只知道从张三那里借到了钱，并不知道有一部分钱出自李四之手。**

**（4）RequestDispatcher.forward方法的调用者与被调用者之间共享相同的request对象和response对象，它们属于同一个访问请求和响应过程；而HttpServletResponse.sendRedirect（）方法调用者与被调用者使用各自的request对象和response对象，它们属于两个独立的访问请求和响应过程。对于同一个WEB应用程序的内部资源之间的跳转，特别是跳转之前要对请求进行一些前期预处理，并要使用HttpServletRequest.setAttribute方法传递预处理结果，那就应该使用RequestDispatcher.forward方法。不同WEB应用程序之间的重定向，特别是要重定向到另外一个WEB站点上的资源的情况，都应该使用HttpServletResponse.sendRedirect方法。**

**（5）无论是RequestDispatcher.forward方法，还是HttpServletResponse.sendRedirect方法，在调用它们之前，都不能有内容已经被实际输出到了客户端。如果缓冲区中已经有了一些内容，这些内容将被从缓冲区中清除。**

** **

**其它资料：http://www.2cto.com/kf/201109/105650.html**

**转载网址：[http://www.cnblogs.com/xuekyo/archive/2013/02/23/2923885.html][http_www.cnblogs.com_xuekyo_archive_2013_02_23_2923885.html]**

**一、隐含对象   
 1.什么是隐含对象(9个)？  
   ————JSP中的隐含对象:不用我们手工去创建的对象  
   类型                    对象名            功能  
   ---------------------------------------------------------------------  
   JspWriter              out              往浏览器写内容  
   HttpServletRequest     request          Http请求对象.  
   HttpServletResponse    response         Http响应对象  
   PageContext            pageContext      JSP的页面上下文  
   HttpSession            session          会话对象  
   ServletContext         application      应用上下文  
   ServletConfig          config           JSP的ServletConfig  
   Object                 page             页面实现类的对象(例如：this)   
   Exception              exception        含有指令<%@page isErrorPage="true"%>  
    
 2.范围对象  
   其中，有4个是范围对象： pageContext,request,session,application  
   对应<jsp:useBean/>指令的scope分别是：page,reqeust,session,application  
   也就是说，指定不同scope的bean对象(Java Bean)会被绑定到不同的范围对象中  
   // 选择范围对象的原则：作用域的范围越小越好；因为作用域小的生命周期短，有利于性能提高。  
   例如：<jsp:useBean id="stu" class="vo.Student" scope="page"/>  
   表示stu对象被绑定到javax.servlet.jsp.PageContext对象(pageContext)中，其等价的代码  
   <%    Student stu = pageContext.getAttribute("stu");  
         if(stu==null) \{  
          stu=new Student();  
          pageContext.setAttribute("stu",stu);  
   \}%>  
    
   1)pageContext对象：  
     每一个jsp页面对应着一个pageContext。一般地，在实际应用中，主要是使用它来存取属性。  
     另外，pageContext对象能够存取其他隐含对象。  
    a.pageContext对象存取其他隐含对象属性的方法，此时需要指定范围的参数。  
      Object getAttribute(String name, int scope)  
      Enumeration getAttributeNamesInScope(int scope)  
      void removeAttribute(String name, int scope)  
      void setAttribute(String name, Object value, int scope)  
     其中，范围参数有四个，分别代表四种范围：  
      PAGE\_SCOPE、REQUEST\_SCOPE、SESSION\_SCOPE、APPLICATION\_SCOPE  
    b.PageContext对象取得其他隐含对象的方法  
      Exception getException()           回传目前网页的异常，不过此网页要为error page，  
      JspWriter getOut()                 回传目前网页的输出流，例如：out  
      Object getPage()                   回传目前网页的Servlet 实体(instance)，例如：page  
      ServletRequest getRequest()        回传目前网页的请求，例如：request  
      ServletResponse getResponse()      回传目前网页的响应，例如：response  
      ServletConfig getServletConfig()   回传目前此网页的ServletConfig 对象，例如：config  
      ServletContext getServletContext() 回传目前此网页的执行环境(context)，例如：application  
      HttpSession getSession()           回传和目前网页有联系的会话(session)，例如：session  
    c.PageContext对象提供取得属性的方法  
      Object getAttribute(String name, int scope)    回传name 属性(范围为scope；类型为Object)   
      Enumeration getAttributeNamesInScope(int scope)      
                                       回传所有属性范围为scope 的属性名称，回传类型为Enumeration  
      int getAttributesScope(String name)回传属性名称为name 的属性范围  
      void removeAttribute(String name)  移除属性名称为name 的属性对象  
      void removeAttribute(String name, int scope)   移除属性名称为name，范围为scope 的属性对象  
      void setAttribute(String name, Object value, int scope)          
                                       指定属性对象的名称为name、值为value、范围为scope  
      Object findAttribute(String name)  寻找在所有范围中属性名称为name 的属性对象  
    
   2)request 对象  
     request 对象包含所有请求的信息，  
     如：请求的来源、标头、cookies和请求相关的参数值等等。  
     request 对象实现javax.servlet.http.HttpServletRequest接口的，  
     所提供的方法可以将它分为四大类：  
     (1)储存和取得属性方法；  
      void setAttribute(String name, Object value)      设定name属性的值为value  
      Enumeration getAttributeNamesInScope(int scope)   取得所有scope 范围的属性  
      Object getAttribute(String name)   取得name 属性的值  
      void removeAttribute(String name)  移除name 属性的值  
     (2)取得请求参数的方法  
      String getParameter(String name)   取得name 的参数值  
      Enumeration getParameterNames()    取得所有的参数名称  
      String \[\] getParameterValues(String name)    取得所有name 的参数值  
      Map getParameterMap()              取得一个要求参数的Map  
     (3)能够取得请求HTTP 标头的方法  
      String getHeader(String name)      取得name 的标头  
      Enumeration getHeaderNames()       取得所有的标头名称  
      Enumeration getHeaders(String name) 取得所有name 的标头  
      int getIntHeader(String name)      取得整数类型name 的标头  
      long getDateHeader(String name)    取得日期类型name 的标头  
      Cookie \[\] getCookies()             取得与请求有关的cookies  
     (4)其他的方法  
      String getContextPath()            取得Context 路径(即站台名称)  
      String getMethod()                 取得HTTP 的方法(GET、POST)  
      String getProtocol()               取得使用的协议 (HTTP/1.1、HTTP/1.0 )  
      String getQueryString()            取得请求的参数字符串，不过，HTTP的方法必须为GET  
      String getRequestedSessionId()     取得用户端的Session ID  
      String getRequestURI()             取得请求的URL，但是不包括请求的参数字符串  
      String getRemoteAddr()             取得用户的IP 地址  
      String getRemoteHost()             取得用户的主机名称  
      int getRemotePort()                取得用户的主机端口  
      String getRemoteUser()             取得用户的名称  
      void getCharacterEncoding(String encoding)    设定编码格式，用来解决窗体传递中文的问题  
    
    3)session 对象  
     session对象表示目前个别用户的会话(session)状况。  
     session对象实现javax.servlet.http.HttpSession接口，HttpSession接口所提供的方法  
      long getCreationTime()             取得session产生的时间，单位是毫秒  
      String getId()                     取得session 的ID  
      long getLastAccessedTime()         取得用户最后通过这个session送出请求的时间  
      long getMaxInactiveInterval()      取得最大session不活动的时间，若超过这时间，session 将会失效  
      void invalidate()                  取消session 对象，并将对象存放的内容完全抛弃  
      boolean isNew()                    判断session 是否为"新"的会话  
      void setMaxInactiveInterval(int interval)     
                                       设定最大session不活动的时间，若超过这时间，session 将会失效  
    4)application对象  
     application对象最常被使用在存取环境的信息。  
     因为环境的信息通常都储存在ServletContext中，所以常利用application对象来存取ServletContext中的信息。  
     application 对象实现javax.servlet.ServletContext 接口，ServletContext接口容器所提供的方法  
      int getMajorVersion()              取得Container主要的Servlet API版本  
      int getMinorVersion()              取得Container次要的Servlet API 版本  
      String getServerInfo()             取得Container的名称和版本  
      String getMimeType(String file)    取得指定文件的MIME 类型  
      ServletContext getContext(String uripath)        取得指定Local URL的Application context  
      String getRealPath(String path)    取得本地端path的绝对路径  
      void log(String message)           将信息写入log文件中  
      void log(String message, Throwable throwable)    将stack trace 所产生的异常信息写入log文件中  
    
 3.其他对象：  
    1)page 对象  
     page对象代表JSP本身，更准确地说page对象是当前页面转换后的Servlet类的实例。  
     从转换后的Servlet类的代码中，可以看到这种关系： Object page = this;  
     在JSP页面中，很少使用page对象。  
    2)response 对象  
     response 对象主要将JSP 处理数据后的结果传回到客户端。  
     response 对象是实现javax.servlet.http.HttpServletResponse 接口。response对象所提供的方法。  
    a.设定表头的方法  
      void addCookie(Cookie cookie)                新增cookie  
      void addDateHeader(String name, long date)   新增long类型的值到name标头  
      void addHeader(String name, String value)    新增String类型的值到name标头  
      void addIntHeader(String name, int value)    新增int类型的值到name标头  
      void setDateHeader(String name, long date)   指定long类型的值到name标头  
      void setHeader(String name, String value)    指定String类型的值到name标头  
      void setIntHeader(String name, int value)    指定int类型的值到name标头  
    b.设定响应状态码的方法  
      void sendError(int sc)                       传送状态码(status code)  
      void sendError(int sc, String msg)           传送状态码和错误信息  
      void setStatus(int sc)                       设定状态码  
    c.用来URL 重写(rewriting)的方法      
      String encodeRedirectURL(String url)         对使用sendRedirect()方法的URL予以编码  
    3)out 对象  
     out对象的类型是javax.servlet.jsp.JspWriter，该类从java.io.Writer类派生，以字符流的形式输出数据。  
     out对象实际上是PrintWriter对象的带缓冲的版本(在out对象内部使用PrintWriter对象来输出数据)，  
     可以通过page指令的buffer属性来调整缓冲区的大小，默认的缓冲区是8kb。  
     out 对象能把结果输出到网页上。  
     out主要是用来控制管理输出的缓冲区(buffer)和输出流(output stream)。  
      void clear( )               清除输出缓冲区的内容  
      void clearBuffer( )         清除输出缓冲区的内容  
      void close( )               关闭输出流，清除所有的内容  
      int getBufferSize( )        取得目前缓冲区的大小(KB)  
      int getRemaining( )         取得目前使用后还剩下的缓冲区大小(KB)  
      boolean isAutoFlush( )      回传true表示缓冲区满时会自动清除；false表示不会自动清除并且产生异常处理  
    4)exception对象  
     若要使用exception 对象时，必须在page 指令中设定：<%@ page isErrorPage="true" %>才能使用。  
     exception提供的三个方法：  
      getMessage()   
      getLocalizedMessage()   
      printStackTrace(new java.io.PrintWriter(out))   
    5)config 对象  
     config 对象里存放着一些Servlet 初始的数据结构。  
     config 对象实现于javax.servlet.ServletConfig 接口，它共有下列四种方法：  
      public String getInitParameter(name)  
      public java.util.Enumeration getInitParameterNames( )   
      public ServletContext getServletContext()   
      public Sring getServletName()**

**二、JSTL(JSP Standard Tag Library )   
 减少java代码，简化页面编写；功能封装，提高可重用性  
 1.如何使用JSTL  
   1)对于Java EE之前(即J2EE规范1.4及之前版本)   
     a、复制jstl的jar包(jstl.jar,standard.jar)到/WEB-INF/lib  
     b、在使用jstl功能的jsp页面中增加指令  
        <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>   //核心标签库  
        <%@taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml"%>      
        <%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>   
        <%@taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%>  //数据库标签库  
        <%@taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>   
        //prefix 表前缀(可改，但通常按这写的用)； uri 指向标签库的入口  
   2)Java EE规范把jstl作为规范的一部分  
     所以现在的jstl-1.2已经包含了原来的jstl.jar , standard.jar  
    
 2.core:核心标签库  
   一般用途  
   在JSTL中，一般用途的标签主要是指具有输出，设置变量，和错误处理等功能的标签，他们在jsp中使用比较频繁，它们有：  
  -----------  
  |a、<c:set>|  
  -----------  
   语法：<c:set value="value" var="varName" \[scope= "\{page|request|session|application\}"\]/ >  
        <c:set value="value" target="target" property="propertyName"/ >  
   这个标签用于在某个范围(page,request,session,application)里面设置特定的值  
   (默认为page)，或者设置某个已经存在的javabean的属性。  
   例子：  
     <c:set var="counter" value="200"/>  
     $\{counter\}//输出  
        
     <c:set var="tarena">Tarena It Traning Ltd.</c:set>  
     $\{tarena\}  
    
   可以指定范围，默认是page  
    <c:set value="20" var="maxIdelTime" scope="session"/>  
    $\{maxIdelTime\}  
    
   设置JavaBean的值  
    <jsp:useBean id="girl" class="vo.SuperGirl"/>  
    <c:set value="Shirly" target="$\{girl\}" property="name"/>  
    <td>girl.name</td>  
    <td>$\{girl.name\}</td>  
    
  --------------  
  |b、<c:remove>|  
  --------------  
  语法：  
    <c:remove var="varName" \[scope= "\{page|request|session|application\}"\]/ >  
    它的作用是删除某个变量或者属性。  
  例子：  
    <c:set value="10000" var="maxUser" scope="application"/>  
    <c:set value="10" var="count" scope="session"/>  
    <c:set value="10" var="count"/>  
    $\{maxUser\}  
    $\{count\}  
    <c:remove var="maxUser" scope="application"/>  
    <c:remove var="count" scope="session"/>  
    $\{maxUser\}  
    $\{count\}  
    
  -----------  
  |c、<c:out>|  
  -----------  
  语法：<c:out value="value" \[escapeXml\]="\{true|false\}" \[default="defaultValue"\]/>  
  注意:escapeXml的作用是是否将代码交给xml解析器解释，true为交给xml解析器解释(默认)，false为交给浏览器解释。  
      default 定义缺省值。  
    
  例子：  
    <c:set var="sessionZhang3" value="zhang3-s" scope="session"/>  
    <c:set var="table" value="<table><tr><td>sessionZhang</td></tr></table>" scope="page"/>  
    <c:set var="requestZhang3" value="zhang3-r" scope="request"/>  
    <c:out value="以下输出前面设置的属性<br>" escapeXml="false"/>  
    
    <td colspan=2>  
        <c:out value="$\{sessionZhang3\}"/><br>  
        <c:out value="$\{table\}" escapeXml="false" /><br>//输出表格；escapeXml="true"时只显示字符串  
        <c:out value="$\{requestZhang3\}"/><br>  
        <c:out value="$\{nodefined\}" default="没有nodefined这个变量"/>  
    </td>  
    
  -------------  
  |d、<c:catch>|  
  -------------  
  它的作用是捕捉由嵌套在它里面的标签所抛出来的异常。类似于<%try\{\}catch\{\}%>  
  语法：<c:catch \[var="varName"\]>nested actions</c:catch>  
  例子：  
    <c:catch var="error"><% Integer.parseInt("abc"); %></c:catch>  
    <% try\{ Integer.parseInt("abc"); \}catch(Exception error) \{  \} %> //等价  
    
     <c:out value="$\{error\}"/>  
     <c:out value="$\{error.message\}"/>  
     <c:out value="$\{error.cause\}"/>  
    
   
  控制语句：  
  -----------  
  |a、 <c:if>|    
  -----------  
  语法：   
    <c:if test="testCondition" var="varName"  
    \[scope="\{page|request|session|application\}"\]>  
       Body内容  
    </c:if>  // 注：没有 else   
  例子：  
     <c:set var="age" value="16"/>  
     <c:if test="$\{age<18\}">  
        <h1 align=center>您尚未成年，不能进入游戏中心！</h1>  
     </c:if>  
    
  --------------  
  |b、<c:choose>|  
  --------------  
  例子：  
    <c:set var="tax" value="5000" />  
    <c:choose>  
         <c:when test="$\{tax <=0\}">  
              您今年没有纳税！  
         </c:when>  
         <c:when test="$\{tax<=1000&&tax>0\}">  
           您今年缴纳的税款为$\{tax\},加油！  
         </c:when>  
         <c:when test="$\{tax<=3000&&tax>1000\}">  
           您今年缴纳的税款为$\{tax\},再接再励哦！  
         </c:when>  
         <c:otherwise>  
           您今年纳税超过了3000元，多谢您为国家的繁荣富强作出了贡献！  
         </c:otherwise>  
     </c:choose>  
    
  ---------------  
  |c、<c:forEach>| 循环  
  ---------------  
  语法： <c:forEach \[var="varName"\] items="collection"  \[varStatus="varStatusName"\]  
         \[begin="begin"\] \[end="end"\] \[step="step"\]>  
           Body 内容  
        </c:forEach>  
   items：需要迭代的集合；var：迭代时取集合里的值；  
  例子：  
    <%  List aList=new ArrayList();  
        aList.add("You");       aList.add("are");   aList.add("a");  
        aList.add("beautiful"); aList.add("girl");    
        request.setAttribute("aList",aList);  %>  
    <center> <table border=1>  
       <c:forEach var="word" items="$\{aList\}">  
         <tr><td>$\{word \}</td></tr>  
       </c:forEach>  
    </table> </center>  
    
    <c:forEach items='$\{header\}' var='h'>  
       <tr>  
         <td><li>Header name:<c:out value="$\{h.key\}"/></li></td>  
         <td><li>Header value:<c:out value="$\{h.value\}"/></li></td>  
       </tr>  
    </c:forEach>  
    
  另外一种用法： (类似 for 循环)  
   <c:forEach var="count" begin="10" end="100" step="10">  
       <tr><td>  
         <c:out value="$\{count\}"/><br>  
       </td></tr>  
   </c:forEach>  
    
   
  URL  
  ---------------  
  |a、<c:import> |  
  ---------------  
  相当于<jsp:include>  
   <c:import url="footer.jsp" charEncoding="GBK">  
      <c:param name="name" value="Java"/>  
   </c:import>  
    
  -----------  
  |b、<c:url>|  
  -----------  
  用于构造URL，主要的用途是URL的重写。  
    <c:url var="footer1" value="footer.jsp"/>  
    <c:url var="footer2" value="footer.jsp" scope="page">  
        <c:param name="name" value="Sofie"/>  
    </c:url>  
    <c:out value="$\{footer1\}"/>  
    <c:out value="$\{footer2\}"/>  
    
    <c:url var="next" value="next.jsp"/>  
    <a href="$\{next\}">next</a><br>  
       等价于  
    <a href="<c:url value='next.jsp'/>">next</a> //在 Html 里可嵌套 JSTL  
    
  ----------------  
  |c、<c:redirect>|  
  ----------------  
   //等价于 <jsp:forward>  
    <c:redirect url="$\{footer2\}"/>  
  例如：  
    <c:url var="next" value="next.jsp"/>  
    <c:redirect url="$\{next\}"/>  
    
 3.SQL  
   <sql:setDataSource>  
   <sql:query>  
   <sql:update>  
   <sql:param>  
    
      
    <%@page contentType="text/html; charset=GBK"%>  
    <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>  
    <%@taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>  
      <sql:setDataSource   var="ds"  driver="com.mysql.jdbc.Driver"  
       url="jdbc:mysql://localhost:3306/tarena"  
       user="root" password="11111111" />  
    
  a、查询  
    <sql:query var="rs" dataSource="$\{ds\}" sql="select \* from users" ></sql:query>  
    <c:forEach var="user" items="$\{rs.rows\}">  
        <tr>  
          <td>$\{user.userid\}</td>  
          <td>$\{user.username\}</td>  
          <td>$\{user.password\}</td>  
          <td>$\{user.role\}</td>  
        </tr>  
    </c:forEach>  
    
  b、插入记录  
    <sql:update dataSource="$\{ds\}" sql="insert into users values(101,'maxwell','123','admin')"  
     var="i"></sql:update>  
    <hr>插入$\{i\}条记录.  
    
  c、更新记录  
    <sql:update dataSource="$\{ds\}"  
     sql="UPDATE users SET username='Gavin King' WHERE userid=101" var="i"></sql:update>  
    <hr>更新$\{i\}条记录.  
    
 <sql:param>  
  作用：设置sql语句中"?"表示的占位符号的值。  
 <sql:update dataSource="$\{ds\}" sql="UPDATE users SET username=? WHERE userid=?" var="i">  
    <sql:param value="Rod Johnson" /> //设第一个问号  
    <sql:param value="100" />         //设第二个问号  
  </sql:update>  
  参数等价于  
  //pstmt.setString(1,"Rod Johnson");**

**  //pstmt.setInt(2,100); **

[Image 1]: 
[Center]: /images/20220606/ab6c799e813141cfb749317e9119a8e5.png
[http_blog.csdn.net_u010897406_article_details_49618413]: http://blog.csdn.net/u010897406/article/details/49618413
[http_blog.csdn.net_vltic_article_details_7648961]: http://blog.csdn.net/vltic/article/details/7648961
[23235026-612ffe1780cd430694c949b3ac22377f.jpg]: /images/20220606/55030d6039784637995474ed2ae8837a.png
[23235045-5555c08fa5f24846aef6cff52dc967d1.jpg]: /images/20220606/1a13aff7a734466aa69b93f1a4fbee37.png
[24000130-a3adce566c8a480aab7e3946473efe81.jpg]: /images/20220606/ca4ccb129d88491aa3d0b44b66465bf2.png
[http_www.cnblogs.com_xuekyo_archive_2013_02_23_2923885.html]: http://www.cnblogs.com/xuekyo/archive/2013/02/23/2923885.html