1 /** 2 * 3 * Copyright 2003-2004 The Apache Software Foundation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * 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 // 19 // This source code implements specifications defined by the Java 20 // Community Process. In order to remain compliant with the specification 21 // DO NOT add / change / or delete method signatures! 22 // 23 24 package javax.servlet.jsp.tagext; 25 26 import javax.servlet.jsp.JspException; 27 import javax.servlet.jsp.PageContext; 28 29 30 /** 31 * The interface of a classic tag handler that does not want to manipulate 32 * its body. The Tag interface defines the basic protocol between a Tag 33 * handler and JSP page implementation class. It defines the life cycle 34 * and the methods to be invoked at start and end tag. 35 * 36 * <p><B>Properties</B></p> 37 * 38 * <p>The Tag interface specifies the setter and getter methods for the core 39 * pageContext and parent properties.</p> 40 * 41 * <p>The JSP page implementation object invokes setPageContext and 42 * setParent, in that order, before invoking doStartTag() or doEndTag().</p> 43 * 44 * <p><B>Methods</B></p> 45 * 46 * <p>There are two main actions: doStartTag and doEndTag. Once all 47 * appropriate properties have been initialized, the doStartTag and 48 * doEndTag methods can be invoked on the tag handler. Between these 49 * invocations, the tag handler is assumed to hold a state that must 50 * be preserved. After the doEndTag invocation, the tag handler is 51 * available for further invocations (and it is expected to have 52 * retained its properties).</p> 53 * 54 * <p><B>Lifecycle</B></p> 55 * 56 * <p>Lifecycle details are described by the transition diagram below, 57 * with the following comments: 58 * <ul> 59 * <li> [1] This transition is intended to be for releasing long-term data. 60 * no guarantees are assumed on whether any properties have been retained 61 * or not. 62 * <li> [2] This transition happens if and only if the tag ends normally 63 * without raising an exception 64 * <li> [3] Some setters may be called again before a tag handler is 65 * reused. For instance, <code>setParent()</code> is called if it's 66 * reused within the same page but at a different level, 67 * <code>setPageContext()</code> is called if it's used in another page, 68 * and attribute setters are called if the values differ or are expressed 69 * as request-time attribute values. 70 * <li> Check the TryCatchFinally interface for additional details related 71 * to exception handling and resource management. 72 * </ul></p> 73 * 74 * <IMG src="doc-files/TagProtocol.gif" 75 * alt="Lifecycle Details Transition Diagram for Tag"/> 76 * 77 * <p>Once all invocations on the tag handler 78 * are completed, the release method is invoked on it. Once a release 79 * method is invoked <em>all</em> properties, including parent and 80 * pageContext, are assumed to have been reset to an unspecified value. 81 * The page compiler guarantees that release() will be invoked on the Tag 82 * handler before the handler is released to the GC.</p> 83 * 84 * <p><B>Empty and Non-Empty Action</B></p> 85 * <p>If the TagLibraryDescriptor file indicates that the action must 86 * always have an empty action, by an <body-_content> entry of "empty", 87 * then the doStartTag() method must return SKIP_BODY.</p> 88 * 89 * <p>Otherwise, the doStartTag() method may return SKIP_BODY or 90 * EVAL_BODY_INCLUDE.</p> 91 * 92 * <p>If SKIP_BODY is returned the body, if present, is not evaluated.</p> 93 * 94 * <p>If EVAL_BODY_INCLUDE is returned, the body is evaluated and 95 * "passed through" to the current out.</p> 96 */ 97 98 public interface Tag extends JspTag { 99 100 /** 101 * Skip body evaluation. 102 * Valid return value for doStartTag and doAfterBody. 103 */ 104 105 public final static int SKIP_BODY = 0; 106 107 /** 108 * Evaluate body into existing out stream. 109 * Valid return value for doStartTag. 110 */ 111 112 public final static int EVAL_BODY_INCLUDE = 1; 113 114 /** 115 * Skip the rest of the page. 116 * Valid return value for doEndTag. 117 */ 118 119 public final static int SKIP_PAGE = 5; 120 121 /** 122 * Continue evaluating the page. 123 * Valid return value for doEndTag(). 124 */ 125 126 public final static int EVAL_PAGE = 6; 127 128 // Setters for Tag handler data 129 130 131 /** 132 * Set the current page context. 133 * This method is invoked by the JSP page implementation object 134 * prior to doStartTag(). 135 * <p> 136 * This value is *not* reset by doEndTag() and must be explicitly reset 137 * by a page implementation if it changes between calls to doStartTag(). 138 * 139 * @param pc The page context for this tag handler. 140 */ 141 142 void setPageContext(PageContext pc); 143 144 145 /** 146 * Set the parent (closest enclosing tag handler) of this tag handler. 147 * Invoked by the JSP page implementation object prior to doStartTag(). 148 * <p> 149 * This value is *not* reset by doEndTag() and must be explicitly reset 150 * by a page implementation. 151 * 152 * @param t The parent tag, or null. 153 */ 154 155 156 void setParent(Tag t); 157 158 159 /** 160 * Get the parent (closest enclosing tag handler) for this tag handler. 161 * 162 * <p> 163 * The getParent() method can be used to navigate the nested tag 164 * handler structure at runtime for cooperation among custom actions; 165 * for example, the findAncestorWithClass() method in TagSupport 166 * provides a convenient way of doing this. 167 * 168 * <p> 169 * The current version of the specification only provides one formal 170 * way of indicating the observable type of a tag handler: its 171 * tag handler implementation class, described in the tag-class 172 * subelement of the tag element. This is extended in an 173 * informal manner by allowing the tag library author to 174 * indicate in the description subelement an observable type. 175 * The type should be a subtype of the tag handler implementation 176 * class or void. 177 * This addititional constraint can be exploited by a 178 * specialized container that knows about that specific tag library, 179 * as in the case of the JSP standard tag library. 180 * 181 * @return the current parent, or null if none. 182 * @see TagSupport#findAncestorWithClass 183 */ 184 185 Tag getParent(); 186 187 188 // Actions for basic start/end processing. 189 190 191 /** 192 * Process the start tag for this instance. 193 * This method is invoked by the JSP page implementation object. 194 * 195 * <p> 196 * The doStartTag method assumes that the properties pageContext and 197 * parent have been set. It also assumes that any properties exposed as 198 * attributes have been set too. When this method is invoked, the body 199 * has not yet been evaluated. 200 * 201 * <p> 202 * This method returns Tag.EVAL_BODY_INCLUDE or 203 * BodyTag.EVAL_BODY_BUFFERED to indicate 204 * that the body of the action should be evaluated or SKIP_BODY to 205 * indicate otherwise. 206 * 207 * <p> 208 * When a Tag returns EVAL_BODY_INCLUDE the result of evaluating 209 * the body (if any) is included into the current "out" JspWriter as it 210 * happens and then doEndTag() is invoked. 211 * 212 * <p> 213 * BodyTag.EVAL_BODY_BUFFERED is only valid if the tag handler 214 * implements BodyTag. 215 * 216 * <p> 217 * The JSP container will resynchronize the values of any AT_BEGIN and 218 * NESTED variables (defined by the associated TagExtraInfo or TLD) 219 * after the invocation of doStartTag(), except for a tag handler 220 * implementing BodyTag whose doStartTag() method returns 221 * BodyTag.EVAL_BODY_BUFFERED. 222 * 223 * @return EVAL_BODY_INCLUDE if the tag wants to process body, SKIP_BODY 224 * if it does not want to process it. 225 * @throws JspException if an error occurred while processing this tag 226 * @see BodyTag 227 */ 228 229 int doStartTag() throws JspException; 230 231 232 /** 233 * Process the end tag for this instance. 234 * This method is invoked by the JSP page implementation object 235 * on all Tag handlers. 236 * 237 * <p> 238 * This method will be called after returning from doStartTag. The 239 * body of the action may or may not have been evaluated, depending on 240 * the return value of doStartTag. 241 * 242 * <p> 243 * If this method returns EVAL_PAGE, the rest of the page continues 244 * to be evaluated. If this method returns SKIP_PAGE, the rest of 245 * the page is not evaluated, the request is completed, and 246 * the doEndTag() methods of enclosing tags are not invoked. If this 247 * request was forwarded or included from another page (or Servlet), 248 * only the current page evaluation is stopped. 249 * 250 * <p> 251 * The JSP container will resynchronize the values of any AT_BEGIN and 252 * AT_END variables (defined by the associated TagExtraInfo or TLD) 253 * after the invocation of doEndTag(). 254 * 255 * @return indication of whether to continue evaluating the JSP page. 256 * @throws JspException if an error occurred while processing this tag 257 */ 258 259 int doEndTag() throws JspException; 260 261 /** 262 * Called on a Tag handler to release state. 263 * The page compiler guarantees that JSP page implementation 264 * objects will invoke this method on all tag handlers, 265 * but there may be multiple invocations on doStartTag and doEndTag in between. 266 */ 267 268 void release(); 269 270 }