JSP 自定义标签的学习

  项目中的分页标签,资源树标签,远程资源路径标签,权限控制标签的使用.学习标签的原理目的等.

 

 

 

 

 

 

 

 

 Scriptlet对于快而杂(fast-and-dirty)的编码来说是一种不错的选择，但是从长远来看，您需要为您的JSP页面选择一种不那么杂乱的解决方案,有利于维护。

什么使用taglib？

所谓 标记库（tag library），是指由在JSP页面中使用的标记所组成的库。JSP容器推出时带有一个小型的、默认的标记库。而 自定义标记库是人们为了某种特定的用途或者目的，将一些标记放到一起而形成的一种库。在一个团队中协同工作的开发者们可能会为各自的项目创建一些非常特定化的自定义标记库，同时也会创建一个通用自定义标记库，以供当前使用。

<tools:usageGraph />

每个标记都包含了指向一个Java类的引用，但是类中的代码仍然在它该在的地方：在标签之外，一个编译好的类文件之中。

 

用于输出资源路径的Tag标签

创建标签几步:

 

创建标签对象的类:

package com.unutrip.common.web.tag;

import java.io.Writer;

import javax.servlet.jsp.JspException;
/**
 * 静态资源标签
 * @author benson
 * Jun 23, 2009
 */
@SuppressWarnings("serial")
public class ResourceTag extends BodyTagSupport {
 private String url;//对应的属性必须有相应的getter或者setter属性
 
 @Override
 public int doEndTag() throws JspException {
  try {
   Writer out = pageContext.getOut();
      out.write(url);
   out.flush();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return EVAL_PAGE;//建议采用常量名称,不建议采用常量值
 }
 

 @Override
 public int doStartTag() throws JspException {
  return SKIP_BODY;
 }

 public String getUrl() {
  return url;
 }

 public void setUrl(String url) {
  this.url = url;
 }

}

由于不需要用户输入，而且该标记也没有属性或者嵌入的内容，我们惟一需要关心的一个新方法就是 doEndTag() ()，在这个方法中该标记可以输出内容（在这个例子中是最后修改数据）到JSP页面。

 

所有的JSP标记都应该扩展JSP类 javax.servlet.jsp.tagext.TagSupport ，这个类为JSP标记提供了基本框架。可能您还注意到，该标记返回的 EVAL_PAGE . EVAL_PAGE 是一个预定义的整型常量，它指示容器处理页面的剩下部分。另一种选项就是使用 SKIP_PAGE ，它将中止对页面剩下部分的处理。如果您要将控制转移到另一个页面，例如您要前进（forward）或者重定向（redirect）用户，那么只需要使用 SKIP_PAGE 。剩下来的细节都是与时间戳自身有关的事情。

创建TLD

接下来的一步是创建一个 标记库描述符（tag library descriptor ，TLD）文件。TLD向容器和任何要使用该标记库的JSP页面描述您的标记库。清单 2 显示了一个非常标准的TLD，其中只包含了一个标记。当您将更多的标记添加到库中时，TLD文件的长度和复杂性将随之增长。

 

<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd">
 <display-name>"Unutrip Tags"</display-name>
 <tag>
  <name>resource</name>
  <tag-class>com.unutrip.common.web.tag.ResourceTag</tag-class>
  <body-content>empty</body-content>
  <attribute>
   <name>url</name>
   <required>true</required>
   <rtexprvalue>true</rtexprvalue>
  </attribute>
 </tag>

</taglib>

提供了一个版本（这对于跟踪某个标记库的JSP创建者拥有哪个版本很有用，尤其是在您需要经常修改标记库的情况下更是如此）；该标记库所依赖的JSP版本；一个为该标记库推荐的前缀；以及用于引用这个标记库的URI。注意，我使用了前缀 short-name 作为URI的一部分，这样 比较容易将前缀和标记库的URI看成一个整体。

剩下的信息用于一个特定的标记，这些信息用 tag 元素表示。我指定了该标记的名称、用于该标记的类（这个类应该被编译好并放在适当的地方，以便容器能够装载），最后还指定了该标记是否有嵌入的内容。标记没有嵌入的内容，因此使用"empty"。

 

  保存这个文件，并将其放到WEB-INF/tlds目录下（您可能需要在您的容器中创建这个目录）。我将这个文件保存为site-utils.tld，并在该标记库的URI（推荐的前缀）和TLD文件本身之间再次创建一个干净的链接。对于这个特定的标记库，要使其可以使用，最后一步要做的是让您的Web应用知道如何连接一个JSP页面中的URI，如何请求使用一个标记库。这可以通过应用的web.xml文件来做。

jsp的早期版本需要配置,后期不需配置

 

<taglib>
      <taglib-uri>http://www.newInstance.com/taglibs/site-utils</taglib-uri>
      <taglib-location>/WEB-INF/tlds/site-utils.tld</taglib-location>
    </taglib>

我们通过使用web.xml文件中的URI来引用这个标记库，为之分配一个前缀（来自TLD的 short-name 始终是最好的选择），然后就像使用任何其他JSP标记一样使用这个标记。最终得到的是一个简洁的、更好的JSP页面，这个JSP页面运行起来不比有 scriptlet 的时候差.

 

 

简单的标签使用：

package com.easyway.tags;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;

/**
 * 一个tag就是一个普通的java类，它惟一特别之处是它必须继承TagSupport或者BodyTagSupport类。这两个类提供了一些方法，
 * 负责jsp页面和你编写的类之间的交互，例如输入，输出。而这两个类是由jsp容器提供的，无须开发人员自己实现。换句话说，你只需
 * 把实现了业务逻辑的类继承TagSupport或者BodyTagSupport，再做一些特别的工作，你的类就是一个Tag。并且它自己负责和jsp
 * 页面的交互，不用你多操心。
 * 
 * “特别的工作”通常有以下几个步骤：
 * 
 * [1]提供属性的set方法，此后这个属性就可以在jsp页面设置。以jstl标签为例 c:out
 * value=""/，这个value就是jsp数据到tag之间的入口。
 * 所以tag里面必须有一个setValue方法，具体的属性可以不叫value。例如setValue(String data){this.data =
 * data;} 这个“value”的名称是在tld里以attribute元素存在的。 取什么名字都可以，只需tag里提供相应的set方法即可。
 * 
 * [2]处理 doStartTag 或 doEndTag 。这两个方法是 TagSupport提供的。 还是以c:out
 * value=""/为例，当jsp解析这个标签的时候， 在“<”处触发 doStartTag 事件，在“>”时触发 doEndTag 事件。通常在
 * doStartTag 里进行初始化,流程选择操作，在 doEndTag 里后续页面输出控制。
 * [3]编写tld文件,就是把编写的tag组件的信息以mxl形式告诉容器,它才好以一定步骤解释tag组件
 * [4]在jsp页面导入tld。这样，你的jsp页面就可以使用自己的tag组件了。
 * 
 * 通常你会发现自己绝大多数活动都集中在 doStartTag 或
 * doEndTag方法里,如果在服务器端处理标签中的正文或则是嵌套标签时的话,还是过问一下doAfterBody。 一个简单的例子：OutputTag
 * 
 * 启动服务器，如果一切按照上面步骤的话，就能看到 Test Tag: Hello! TEST 字样。最简单的tag就这么出来了。并不难,是不是?
------------------------------------------------------------------
Tag系列的Interface里定义的静态int,通过他们也能一窥tag组键的执行流程,这几个静态值分别是：
SKIP_BODY ： 跳过了开始和结束标签之间的代码,一般是在doStartTag中使用
EVAL_BODY_INCLUDE ：处理嵌套的标签,一般是在doStartTag中使用,由负责处理标签正文的tag接口提供
EVAL_BODY_BUFFERED :对包含的内容进行解析一般是在doStartTag中使用,由负责处理标签正文的bodyTag接口提供,目的是通知jsp容器作
好读取正文的工作(创建一个body-content包装正文和获取存放操作结果的out对象,便于以后的操作和输出).
EVAL_BODY_AGAIN:处理标签正文,嵌套标签的iteratorTag接口的使用
SKIP_PAGE ： 忽略剩下的页面,一般是在doEndTag中使用
EVAL_PAGE ： 继续执行下面的页, 一般是在doEndTag中使用
 


 * 一个简单的输出标签
 * 
 * @author longgangbai
 * 
 */
public class SimpleTag extends TagSupport {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	// 声明标签的属性必须有对应的getter/setter方法
	private String name = null;

	/**
	 * 
	 * 简要说明： 1 如何输出到jsp页面：调用JspWriter JspWriter out =
	 * pageContext.getOut();out.print......记住这个方法就可以了。 2
	 * 输出后如何作处理，函数会返回几个值之一。EVAL_PAGE 表示tag已处理完毕，返回jsp页面。
	 * 还有几个值，例如 EVAL_BODY_AGAIN
	 * 和EVAL_BODY_INCLUDE等 跟流程控制有关.
	 */
	@Override
	public int doEndTag() throws JspException {
		try {
			JspWriter out = pageContext.getOut();
			out.print("hello world ," + name);
		} catch (Exception e) {
			throw new JspException(e);
		}
		return EVAL_PAGE;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	};
}

 

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<!-- 
在WEB-INF下新建tlds文件夹，把这个文件取名为test.tld，放到tlds文件夹下。引用时的路径应该这样：WEB-INF\tlds\test.tld

关于tld的简单说明：
short-name：taglib的名称，也称为前缀。比如“c:out value=""/” 里的“c”
name：tag的名字。例如“c:out value=""/” 里的"out”，我们的类也取名为out，由于有前缀作区分，不会同其他库的同名tag组件混淆
tag-class：完整的tag组件路径,记着带包名
body-content：指tag之间的内容。例如c:out value="" ...... /c 起始和关闭标签之间就是body-content。由于没有处理body-content ，
所以上面设为empty,如果是嵌套标签,或则是要在服务器端处理标签体的话,就是jsp了
“attribute”里的name：属性名字。例如c:out value=""/里的value。名字可任意取，只要类里提供相应的set方法即可。
required：是否必填属性。
rtexprvalue：是否支持运行时表达式取值就是是否可以<%=%>或则是${}方式传值。
这是tag的强大功能。

 -->
<taglib>
	<tlib-version>1.0</tlib-version>
	<jsp-version>1.2</jsp-version>
	<short-name>simple</short-name>
	<!--SimpleTag-->
	<tag>
		<name>out</name>
		<tag-class>com.easyway.tags.SimpleTag</tag-class>
		<body-content>empty</body-content>
		<attribute>
			<name>name</name>
			<required>false</required>
			<rtexprvalue>false</rtexprvalue>
		</attribute>
	</tag>
</taglib>

 

 

 

嵌套标签的创建：

1.创建父标签类：

package com.easyway.tags.foreachs;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.TagSupport;

/**
 * 
自定义标签库分为传统标签,简单标签,和标签文件.三者区别在于一个比一个简单.实现细节大致相同.实现原理也大致相同.下面简单说说实现过程.
Tag接口:普通标签体接口.继承与JspTag.
把pageContext传给自己实现的标签类. 
设置标签的属性.(标签体被镶套,则调用setParent方法设置父标签) 
执行doStartTag方法.然后根据这个方法的返回值判断程序的走向 

EVAL_BODY_INCLUDE :把标签体输出到流中. 
SKIP_BODY:忽略标签体 
执行doEndTag方法.返回两种值 EVAL_PAGE 和 SKIP_PAGE 表示执行剩下的jsp代码还是忽略剩下的jsp代码. 
容器缓存标签实例.遇到同样的标签,则重复使用缓存的标签体.释放标签体.调用release()方法. 
IterationTag接口:用于循环实现的接口,这个接口继承于Tag接口.新增了一个方法doAfterBody()和一个返回值的常量EVAL_BODY_AGAIN.

把pageContext传给自己实现的标签类. 
设置标签的属性.(标签体被镶套,则调用setParent方法设置父标签) 
执行doStartTag方法.然后根据这个方法的返回值判断程序的走向. 

EVAL_BODY_INCLUDE :执行标签体 
SKIP_BODY:忽略标签体 
如果上一部返回EVAL_BODY_INCLUDE,那么执行这一步.调用的方法是doAfterBody().返回:(注意,不管返回是什么,这个标签已经执行了一次.
类似于do..while循环) 

EVAL_BODY_AGAIN:表示重复执行标签体. 
SKIP_BODY:不执行标签体.进入下一步. 
容器缓存标签实例.遇到同样的标签,则重复使用缓存的标签体释放标签体.调用release()方法. 
BodyTag接口:继承于IterationTag接口,新增两个方法

setBodyContent():设置bodyContent属性.对于空标签,该方法不会被调用.如果doStartTag()方法返回为SKIP_BODY
或者EVAL_BODY_INCLUDE也不会被调用 
doInitBody():在setBodyContent()方法调用后,标签体第一次被执行之前,该方法调用. 
EVAL_BODY_BUFFERED返回值.只有实现了BodyTag接口,并且在doStartTag()方法中才能返回该值. 
执行流程:

把pageContext传给自己实现的标签类. 
设置标签的属性.(标签体被镶套,则调用setParent方法设置父标签) 
执行doStartTag方法.然后根据这个方法的返回值判断程序的走向. 

EVAL_BODY_INCLUDE :执行标签体. 
SKIP_BODY:忽略标签体 
EVAL_BODY_BUFFERED:标签体不为空,进入下一步. 
调用setBodyContent(),如果第一次执行再调用doInitBody(). 
调用doAfterBody(). 

EVAL_BODY_AGAIN:表示重复执行标签体 
SKIP_BODY:不执行标签体.进入下一步. 
容器缓存标签实例.遇到同样的标签,则重复使用缓存的标签体. 
释放标签体.调用release()方法. 
    api已经有抽象类大致实现了以上步骤,只需重写几个自己需要的方法即可.TagSupport实现了IterationTag接口,BodyTagSupport
    实现了BodyTag接口.

简单标签则SimpleTagSupport实现继承于JspTag的SimpleTag接口.只需重写doTag方法就可完成简单的功能.


    想要使用自己写好的标签还需要定义tld标签描述文件,然后在jsp页面引用.

标签以jar包形式出现,则标签必须放到META-INF目录或其子目录下.如果标签直接部署在web程序中,则标签描述文件必须在WEB-INF目录或其
子目录下



 * 
 * 
 * 标签的嵌套
 * 目标：
 定义两个标签，父标签中含有字符串："hi {0}, i am {1}. "，子标签用来设置父标签的参数占位符。
 步骤：
 （1）开发标签实现类
 （2）编写 tld 标签描述文件
 （3）在 web.xml 中引用 tld
 （4）写jsp测试
 * @author longgangbai
 * 
 * 
 */
public class ParentTag extends TagSupport {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	private String message = "hi {0}, i am {1}. ";

	private List params;

	public ParentTag() {
		super();
		params = new ArrayList();
	}

	public int doStartTag() throws JspTagException {
		params.clear();
		return EVAL_BODY_INCLUDE;
	}

	public int doEndTag() throws JspTagException {
		if (params != null) {
			Object[] messageArgs = params.toArray();
			MessageFormat formatter = new MessageFormat("");
			formatter.applyPattern(message);
			message = formatter.format(messageArgs);
		}
		try {
			this.pageContext.getOut().write(message);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return EVAL_PAGE;
	}

	public void addParam(Object arg) {
		params.add(arg);
	}
}

 

2.创建嵌套子标签

package com.easyway.tags.foreachs;

import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;
/**
 * 内嵌标签
 * @author longgangbai
 *
 */
public class SonTag extends TagSupport {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private String value = "";

	public void setValue(String value) {
		this.value = value;
	}

	public int doEndTag() throws JspTagException {
		//获取父标签
		Tag t = findAncestorWithClass(this, ParentTag.class);
		ParentTag parent = (ParentTag) t;
		parent.addParam(value);
		return EVAL_PAGE;
	}
}

 

3.创建相关的tld标签描述文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN" "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">
<taglib>
	<tlibversion>1.2</tlibversion>
	<jspversion>1.1</jspversion>
	<shortname>bean</shortname>
	<uri>http://www.aaa.com/tags</uri>

	<tag>
		<name>hello</name>
		<tagclass>com.easyway.tags.foreachs.ParentTag</tagclass>
		<bodycontent>JSP</bodycontent>
	</tag>
	<tag>
		<name>param</name>
		<tagclass>com.easyway.tags.foreachs.SonTag</tagclass>
		<bodycontent></bodycontent>
		<attribute>
			<name>value</name>
			<required>false</required>
			<rtexprvalue>false</rtexprvalue>
		</attribute>
	</tag>
</taglib>

 

4.web页面调用

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib prefix="s" uri="/WEB-INF/simple.tld" %>
<%@taglib prefix="r" uri="/WEB-INF/requset.tld" %>
<%@taglib prefix="hello" uri="/WEB-INF/hello-tag.tld" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>My JSP 'index.jsp' starting page</title>
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->
  </head>
  
  <body>&nbsp; 
    This is my JSP page. <br>
    <s:out name="test tags "/>
    <r:demo parameter="filename"/>
    <r:value>$date</r:value>
    <hello:hello>
         <hello:param value="abc"/>
         <hello:param value="efg"/>
    </hello:hello>
  </body>
</html>

 

 

JSTL核心标签
在JSP页面中要使用格式化标签，必须使用<%@ taglib%>指令，
<%@ taglib prefex="c" uri="http://java.sun.com/jsp/jstl/core" %>
 <c:set>标签能够将变量存储在JSP范围中或者是JavaBean的属性中
 有五中格式：
 1，<c:set var="username" value="value"></c:set>//制定变量名和变量值
 2，<c:set var="username" value="value" scope="page|request|session|application"></c:set>将value值保存到范围为scope的变量中
 3，<c:set var="username" scope="page|request|session|application" >
     文本内容
     </c:set>将文本内容的数据存储到范围为scope的变量中
 4，<c:set value="value" target="target" property="propertyName"></c:set>将value值存储到target对象的属性中。
 5，<c:settarget="target" property="propertyName">
      文本内容
     </c:set>将文本内容的数据存储到target对象的属性中
 
 <c:out>标签用来显示数据的内容，其格式语法有四种
 1,<c:out value="value"></c:out>通过value属性指定要显示的值
 2,<c:out value="value" escapeXml="true|false"></c:out>是否将value中的内容按照原样输出
 3,<c:out value="value" default="No Data"></c:out>通过Default属性来设置默认值
 4,<c:out value="value" escapeXml="true|false">
    文本内容
    </c:out>通过文本内容设置默认的值
 
 <c:remove>用来移除指定范围的变量
 <c:remove var="number" scope="session">
 

<%@page language="java" contentType="text/html;charset=gb2312" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
    <head>
        <title>remove标签的使用</title>
    </head>
    <body>
        <h1>remove标签的使用</h1>
        <hr />
        <%--  添加变量number，存储在page范围--%>
        <c:set var = "number" value="${1+2}" scope="page" />
        <%--  输出变量--%>
        number:<c:out value="${pageScope.number}" default="No Data"/>
        <%--  移除page范围number变量--%>
        <c:remove var="number" scope="page" />
        <%--  输出变量--%>
        number:<c:out value="${pageScope.number}" default="No Data"/>
    </body>
</html>
<c:if>标签用来执行流程控制
<c:if>标签有两种格式
 
1，没有本体内容的<c:if test="condition" var = "varName" [scope="{page|request|session|application}"] />
2，有本体内容的<c:if test="condition" var = "varName" [scope="{page|request|session|application}"] >本体内容</c:if>
 <c:choose><c:when><c:otherwise>标签
 

<%@page language="java" contentType="text/html;charset=gb2312" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
    <head>
        <title>Choose标签的使用</title>
    </head>
    <body>
        <h1>Choose标签的使用</h1>
        <hr />
        <c:choose>
            <c:when test="${4<6}">
                <c:out value="Yes" />
            </c:when>
            <c:otherwise>
                <c:out value="No" />
            </c:otherwise>
        </c:choose>
    </body>
</html>

<c:forEach>标签
一种用来遍历集合对象的成员
<c:forEach [var="username"] items="collection" [varStatus="varStatusName"] [begin="begin"] [end="end"] [step="step"] >
 本地内容
</c:forEach>
 
一种是用来使语句循环执行指定的次数
<c:forEach [var="username"] [varStatus="varStatusName"] [begin="begin"] [end="end"] [step="step"] >
 本地内容
 </c:forEach>
 
<c:forTokens>标签，用来根据指定分隔符分割字符串
 <c:forTokens [var="varname"] items="stringOfTokens" delims="delimiters" [varStatus="varStatusName"] [begin="begin"] [end="end"] [step="step"] >
 本地内容
 </c:forEach>
 
 <c:import>标签，可以把静态或者是动态的文件包含到本身的JSP网页中
 <c:import url="url" [context="context"][var="varname"] [scope = "{page|request|session|application}"] [charEncoding="charEncoding"] >
 本地内容
 </c:import>
 
 <c:param>标签，用来传递参数
 
<c:url>标签，用来生成URL
 不带参数的
 <c:url value="value" [context="context"][var="varname"] [scope = "{page|request|session|application}"] />
 带参数的
 <c:url url="url" [context="context"][var="varname"] [scope = "{page|request|session|application}"] >
     <c:param />标签
 </c:url>
 <c:redirect>标签，可以从一个JSP页面跳转到另一个其他的页面上去
 
不带参数的
 <c:redirect url="url" [context="context"]/>
 带参数的
 <c:redirect url="url" [context="context"]>
     <c:param />标签
 </c:redirect>

 

JSP内置对象详解之page、out、exception、config、pageContext内置对象

 一、

page内置对象介绍

        page对象有点类似于Java编程中的this指针，就是指当前JSP页面本身。page是java.lang.Object类的对象。page对象在实际开发过程中并不经常使用。

page对象常用方法

        getClass()：返回当时Object的类。
        hashCode()：返回此时Object的哈希代码。
        toString()：将此时的Object类转换成字符串。
        equals(Object ob)：比较此对象是否与指定的对象相等。
        copy(Object ob)：将此对象复制到指定的对象中。
        clone()：对此对象进行克隆。

二、

out内置对象介绍

         out对象用来在页面输出数据，是在JSP开发过程中使用得最频繁的对象，然而使用起来也是为简便的。

out对象常用方法

         print()：在页面中打印出字符串信息，不换行。
         print()：在页面中打印出字符串信息，并且换行。
         clear()：清除缓冲区中尚存的内容。
         clearBuffer()：清除当前缓冲区中尚存的内容。
         flush()：清除数据流。
         getBufferSize()：返回缓冲区的内存大小，单位大小为字节流。如果不进行缓冲区的设置，大小为0。
         getRemaining()：返回缓冲区还剩下多少字节数可以使用。
         isAutoFlush()：检查当前缓冲区是设置为自动清空，还是满了就抛也异常。
         close()：关闭输出流。
三、

exception内置对象介绍

         exception内置对象用来处理页面出现的异常错误，它是java.lang.Throwable类的一个对象。在JSP开发过程中，通常是在某个页面（比如A.jsp）中加入page指令的errorPage属性来将其指向一个专门处理异常错误的页面（doError.jsp）。如果这个错误处理页面doError.jsp已经封装了从A.jsp页面收到的错误信息，并且错误处理页面doError.jsp含有的isErrorpage属性设置为true，则这个错误处理页面可以调用exception内置对象来处理这个些错误信息。

exception对象常用方法

        getMessage()和getLocalizedMessage()：这两种方法分别返回exception对象的异常消息字符串和本地化语言的异常错误。
        printStackTrace()：显示异常的栈跟踪轨迹。
        toString()：返回关于异常错误的简单消息描述。
        fillInStackTrace()：重写异常错误的栈执行轨迹。

四、

config内置对象介绍

        config内置对象是ServletConfig类的一个实例，用于JSP引擎在Servlet初始化时，通过config向它（Servlet）传递信息。这种信息可以是属性名/值匹配的参数，也可以是通过ServletContext对象传递的服务器的有关信息。一般在JSP开发中行少用到config内置对象，只有在编写Servlet时若需要重载Servlet的init()方法时才会用到。

config对象常用方法

        getServletContext()：返回 一个含有服务器相关信息的ServletContext对象。
        getIntParameter(String name)：返回初始化参数的值。
        getIntParameterNames()：返回包含了Servlet初始化所需要的所有参数，返回类型是枚举型。
五、

pageContext内置对象介绍

         pageContext内置对象是一个比较特殊的对象，它相当于页面中所有其他对象功能的最大集成者，即使用它可以访问到本页面中所有其他的对象，例如前面已经描述的request、response、out和page对象等。由于在JSP中request和response等对象本来就可以通过直接调用方法使用，所以pageContext对象在实际JSP开发中很少使用到。
pageContext对象常用方法

         getRequest()：返回当前页面中的request对象。
         getResponse()：返回当前页面中的response对象。
         getSession()：返回当前页面中的session对象。
         getServletContext()：返回当前页面中的application对象。
         getPage()：返回当前页面中的page对象。
         getOut()：返回当前页面中的out对象。
         getException()：返回当前页面中的exception对象。
         getServletConfig()：返回当前页面中的config对象。
           setAttribute(String name)：给指定的属性名设置属性值。
         getAttribute(String naem)：根据属性名找到相应的属性值。
         setAttribute(String name, Object obj, int scope)：在给定的范围内设置相应的属性值。
         getAttribute(String name, int scope)：在给的范围内获取相应的属性值。
         findAttribute(String name)：寻找一个属性并返回，如果查找不到则返回null。
         removeAttribute(String name)：通过属性名删除掉某个属性。
         removeAttribute(String name, int scope)：在指定的某个范围里删除某个属性。
         getAttributeScope(String name scope)：返回某属性的作用域。
         getAttributeNamesInScope(int scope)：返回指定范围内的所有属性名的枚举。
       
          release()：释放pageContext占据的所有资料。
          forward(String relativeURLpath)：使用当前页面重导到另一个页面。
          include(String relativeURLpath)：使用当前位置包含的另一个页面。