執行模板
這裡所討論的模板將在三種定制標簽下執行:
Template: insert
Template: put
Template: get
insert 標簽中包含一個模板，但是在包含之前，put 標簽存儲有一些信息——name， URI和Boolean 值（用來指定將內容是包含還是直接顯示）——關於模板所包含的內容。在template:get中包含（或顯示）了指定的內容，隨後將訪問這些信息。
template:put 把Bean 存儲在請求區域（但並不直接存儲），因為如果兩個模板使用了相同的內容名，一個嵌套模板就將覆蓋封裝模板中的內容。
為了保證每一個模板能夠只存取它自己的信息，template:insert 保留了一個hashtable堆棧。每一個insert 開始標簽建立一個 hashtable並把它放入堆棧。封裝的put 標簽建立bean並把它們保存到最近建立的hashtable中。隨後，在被包含模板中的 get 標簽訪問hashtable中的bean。圖 4 顯示了堆棧是如何被保留的。
圖 4. 在請求區域存儲模板參數 點擊放大(24 KB)
在圖 4中每一個模板訪問正確的頁腳、footer.html 和footer_2.html。如果 bean被直接存儲在請求區域，圖 4中的step 5將覆蓋在step 2中指定的footer bean。
模板標簽執行
接下來我們將分析三個模板標簽的執行: insert， put和get。我們先從圖 5開始。這個圖表說明了當一個模板被使用時，insert和put標簽事件的執行順序。
圖 5. put和insert 標簽執行順序 點擊放大(24 KB)
如果一個模板堆棧已經不存在，insert 開始標簽就會建立一個並把它放置到請求區域。隨後一個hashtable也被建立並放到堆棧中。
每一個 put 開始標簽建立一個PageParameter bean，並存儲在由封裝的insert標簽建立的hashtable中。
插入 end 標簽包含了這個模板。這個模板使用get標簽來訪問由put標簽建立的bean。在模板被處理以後，由insert 開始標簽建立的hashtable就從堆棧中清除。
圖 6顯示template:get的順序圖表。
圖 6. get標簽的順序圖表 點擊放大(11 KB)
模板標簽列表
標簽handler很簡單。在例 3.a中列出了Insert標簽類——標簽handler。
例 3.a. InsertTag.java
packagetags.templates;
import java.util.Hashtable;
import java.util.Stack;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.TagSupport;
public class InserttagextendstagSupport {
private Stringtemplate;
private Stack stack;
// setter method fortemplate 屬性
public void setTemplate(Stringtemplate) {
this.template =template;
}
public int doStartTag() throws JspException {
stack = getStack(); // obtain a reference to thetemplate stack
stack.push(new Hashtable()); // push new hashtable onto stack
return EVAL_BODY_INCLUDE; // pass tagbody through unchanged
}
public int doEndTag() throws JspException {
try {
pageContext.include(template); // includetemplate
}
catch(Exception ex) { // IOException or ServletException
throw new JspException(ex.getMessage()); // recast exception
}
stack.pop(); // pop hashtable off stack
return EVAL_PAGE; // evaluate the rest of the page after the tag
}
// taghandlers should always implement release() because
// handlers can be reused by the JSP container
public void release() {
template = null;
stack = null;
}
public Stack getStack() {
// try to get stack from request scope
Stack s = (Stack)pageContext.get屬性(
"template-stack"，
PageContext.REQUEST_SCOPE);
// if the stack's not present， create a new one和
// put it into request scope
if(s == null) {
s = new Stack();
pageContext.set屬性("template-stack"， s，
PageContext.REQUEST_SCOPE);
}
return s;
}
}
例 3.b 列出了 Put標簽類和標簽handler:
例 3.b. PutTag.java
packagetags.templates;
import java.util.Hashtable;
import java.util.Stack;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.TagSupport;
import beans.templates.PageParameter;
public class PuttagextendstagSupport {
private String name， content， direct="false";
// setter methods for Put tag attributes
public void setName(String s) { name = s; }
public void setContent(String s) {content = s; }
public void setDirect(String s) { direct = s; }
public int doStartTag() throws JspException {
// obtain a reference to enclosing insert tag
Inserttagparent = (InsertTag)getAncestor(
"tags.templates.InsertTag");
// puttags must be enclosed in an insert tag
if(parent == null)
throw new JspException("PutTag.doStartTag(): " +
"No Inserttagancestor");
// gettemplate stack from insert tag
Stacktemplate_stack = parent.getStack();
//template stack should never be null
if(template_stack == null)
throw new JspException("PutTag: notemplate stack");
// peek at hashtable on the stack
Hashtable params = (Hashtable)template_stack.peek();
// hashtable should never be null either
if(params == null)
throw new JspException("PutTag: no hashtable");
// put a new PageParameter in the hashtable
params.put(name， new PageParameter(content， direct));
return SKIP_BODY; // not interested in tagbody， if present
}
// taghandlers should always implement release() because
// handlers can be reused by the JSP container
public void release() {
name = content = direct = null;
}
// convenience method for finding ancestor names with
// a specific class name
privatetagSupport getAncestor(String className)
throws JspException {
Class klass = null; // can't name variable "class"
try {
klass = Class.forName(className);
}
catch(ClassNotFoundException ex) {
throw new JspException(ex.getMessage());
}
return (TagSupport)findAncestorWithClass(this， klass);
}
}
PutTag.doStarttag建立了一個 PageParameter bean – 在例 3.c中列出——然後存儲到請求區域。
例 3.c. PageParameter.java
package beans.templates;
public class PageParameter {
private String content， direct;
public void setContent(String s) {content = s; }
public void setDirect(String s) { direct = s; }
public String getContent() { return content;}
public boolean isDirect() { return Boolean.valueOf(direct).booleanValue(); }
public PageParameter(String content， String direct) {
this.content = content;
this.direct = direct;
}
}
PageParameter將作為簡單的占位符使用。我們來看一看例 3.d中的Gettag類和tag handler:
例 3.d. GetTag.java
packagetags.templates;
import java.util.Hashtable;
import java.util.Stack;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.TagSupport;
import beans.templates.PageParameter;
public class GettagextendstagSupport {
private String name;
// setter method for name attribute
public void setName(String name) {
this.name = name;
}
public int doStartTag() throws JspException {
// obtain reference totemplate stack
Stack stack = (Stack)pageContext.get attribute (
"template-stack"， PageContext.REQUEST_SCOPE);
// stack should not be null
if(stack == null)
throw new JspException("GetTag.doStartTag(): " +
"NO STACK");
// peek at hashtable
Hashtable params = (Hashtable)stack.peek();
// hashtable should not be null
if(params == null)
throw new JspException("GetTag.doStartTag(): " +
"NO HASHTABLE");
// get page parameter from hashtable
PageParameter param = (PageParameter)params.get(name);
if(param != null) {
String content = param.getContent();
if(param.isDirect()) {
// print content if direct attribute is true
try {
pageContext.getOut().print(content);
}
catch(java.io.IOException ex) {
throw new JspException(ex.getMessage());
}
}
else {
// include content if direct attribute is false
try {
pageContext.getOut().flush();
pageContext.include(content);
}
catch(Exception ex) {
throw new JspException(ex.getMessage());
}
}
}
return SKIP_BODY; // not interested in tagbody， if present
}
// taghandlers should always implement release() because
// handlers can be reused by the JSP container
public void release() {
name = null;
}
}
GetTag.doStartTag從請求區域返回了頁面參數bean並從bean中獲得了content和direct 屬性。然後，內容可以根據direct屬性值選擇是被包含還是顯示。
結論
模板是一種簡單而有非常有用的概念。模板的封裝布局能夠對布局改變的影響達到最小化。而且模板能夠根據用戶的不同來區分不同的內容，它還能夠嵌套到其他的模板和JSP頁面中。
<全文完>
