Java tutorial
/* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved. * * The contents of this file are subject to the terms of either the GNU * General Public License Version 2 only ("GPL") or the Common Development * and Distribution License("CDDL") (collectively, the "License"). You * may not use this file except in compliance with the License. You can * obtain a copy of the License at * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html * or packager/legal/LICENSE.txt. See the License for the specific * language governing permissions and limitations under the License. * * When distributing the software, include this License Header Notice in each * file and include the License file at packager/legal/LICENSE.txt. * * GPL Classpath Exception: * Oracle designates this particular file as subject to the "Classpath" * exception as provided by Oracle in the GPL Version 2 section of the License * file that accompanied this code. * * Modifications: * If applicable, add the following below the License Header, with the fields * enclosed by brackets [] replaced by your own identifying information: * "Portions Copyright [year] [name of copyright owner]" * * Contributor(s): * If you wish your version of this file to be governed by only the CDDL or * only the GPL Version 2, indicate your decision by adding "[Contributor] * elects to include this software in this distribution under the [CDDL or GPL * Version 2] license." If you don't indicate a single choice of license, a * recipient has the option to distribute your version of this file under * either the CDDL, the GPL Version 2 or to extend the choice of license to * its licensees as provided above. However, if you add GPL Version 2 code * and therefore, elected the GPL Version 2 license, then the option applies * only if the new code is made subject to such option by the copyright * holder. * * * This file incorporates work covered by the following copyright and * permission notice: * * Copyright 2004 The Apache Software Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package javax.servlet.jsp.tagext; import javax.servlet.jsp.*; /** * The interface of a classic tag handler that does not want to manipulate * its body. The Tag interface defines the basic protocol between a Tag * handler and JSP page implementation class. It defines the life cycle * and the methods to be invoked at start and end tag. * * <p><B>Properties</B></p> * * <p>The Tag interface specifies the setter and getter methods for the core * pageContext and parent properties.</p> * * <p>The JSP page implementation object invokes setPageContext and * setParent, in that order, before invoking doStartTag() or doEndTag().</p> * * <p><B>Methods</B></p> * * <p>There are two main actions: doStartTag and doEndTag. Once all * appropriate properties have been initialized, the doStartTag and * doEndTag methods can be invoked on the tag handler. Between these * invocations, the tag handler is assumed to hold a state that must * be preserved. After the doEndTag invocation, the tag handler is * available for further invocations (and it is expected to have * retained its properties).</p> * * <p><B>Lifecycle</B></p> * * <p>Lifecycle details are described by the transition diagram below, * with the following comments: * <ul> * <li> [1] This transition is intended to be for releasing long-term data. * no guarantees are assumed on whether any properties have been retained * or not. * <li> [2] This transition happens if and only if the tag ends normally * without raising an exception * <li> [3] Some setters may be called again before a tag handler is * reused. For instance, <code>setParent()</code> is called if it's * reused within the same page but at a different level, * <code>setPageContext()</code> is called if it's used in another page, * and attribute setters are called if the values differ or are expressed * as request-time attribute values. * <li> Check the TryCatchFinally interface for additional details related * to exception handling and resource management. * </ul></p> * * <IMG src="doc-files/TagProtocol.gif" * alt="Lifecycle Details Transition Diagram for Tag"/> * * <p>Once all invocations on the tag handler * are completed, the release method is invoked on it. Once a release * method is invoked <em>all</em> properties, including parent and * pageContext, are assumed to have been reset to an unspecified value. * The page compiler guarantees that release() will be invoked on the Tag * handler before the handler is released to the GC.</p> * * <p><B>Empty and Non-Empty Action</B></p> * <p>If the TagLibraryDescriptor file indicates that the action must * always have an empty action, by an <body-content> entry of "empty", * then the doStartTag() method must return SKIP_BODY.</p> * * <p>Otherwise, the doStartTag() method may return SKIP_BODY or * EVAL_BODY_INCLUDE.</p> * * <p>If SKIP_BODY is returned the body, if present, is not evaluated.</p> * * <p>If EVAL_BODY_INCLUDE is returned, the body is evaluated and * "passed through" to the current out.</p> */ public interface Tag extends JspTag { /** * Skip body evaluation. * Valid return value for doStartTag and doAfterBody. */ public final static int SKIP_BODY = 0; /** * Evaluate body into existing out stream. * Valid return value for doStartTag. */ public final static int EVAL_BODY_INCLUDE = 1; /** * Skip the rest of the page. * Valid return value for doEndTag. */ public final static int SKIP_PAGE = 5; /** * Continue evaluating the page. * Valid return value for doEndTag(). */ public final static int EVAL_PAGE = 6; // Setters for Tag handler data /** * Set the current page context. * This method is invoked by the JSP page implementation object * prior to doStartTag(). * <p> * This value is *not* reset by doEndTag() and must be explicitly reset * by a page implementation if it changes between calls to doStartTag(). * * @param pc The page context for this tag handler. */ void setPageContext(PageContext pc); /** * Set the parent (closest enclosing tag handler) of this tag handler. * Invoked by the JSP page implementation object prior to doStartTag(). * <p> * This value is *not* reset by doEndTag() and must be explicitly reset * by a page implementation. * * @param t The parent tag, or null. */ void setParent(Tag t); /** * Get the parent (closest enclosing tag handler) for this tag handler. * * <p> * The getParent() method can be used to navigate the nested tag * handler structure at runtime for cooperation among custom actions; * for example, the findAncestorWithClass() method in TagSupport * provides a convenient way of doing this. * * <p> * The current version of the specification only provides one formal * way of indicating the observable type of a tag handler: its * tag handler implementation class, described in the tag-class * subelement of the tag element. This is extended in an * informal manner by allowing the tag library author to * indicate in the description subelement an observable type. * The type should be a subtype of the tag handler implementation * class or void. * This addititional constraint can be exploited by a * specialized container that knows about that specific tag library, * as in the case of the JSP standard tag library. * * @return the current parent, or null if none. * @see TagSupport#findAncestorWithClass */ Tag getParent(); // Actions for basic start/end processing. /** * Process the start tag for this instance. * This method is invoked by the JSP page implementation object. * * <p> * The doStartTag method assumes that the properties pageContext and * parent have been set. It also assumes that any properties exposed as * attributes have been set too. When this method is invoked, the body * has not yet been evaluated. * * <p> * This method returns Tag.EVAL_BODY_INCLUDE or * BodyTag.EVAL_BODY_BUFFERED to indicate * that the body of the action should be evaluated or SKIP_BODY to * indicate otherwise. * * <p> * When a Tag returns EVAL_BODY_INCLUDE the result of evaluating * the body (if any) is included into the current "out" JspWriter as it * happens and then doEndTag() is invoked. * * <p> * BodyTag.EVAL_BODY_BUFFERED is only valid if the tag handler * implements BodyTag. * * <p> * The JSP container will resynchronize the values of any AT_BEGIN and * NESTED variables (defined by the associated TagExtraInfo or TLD) * after the invocation of doStartTag(), except for a tag handler * implementing BodyTag whose doStartTag() method returns * BodyTag.EVAL_BODY_BUFFERED. * * @return EVAL_BODY_INCLUDE if the tag wants to process body, SKIP_BODY * if it does not want to process it. * @throws JspException if an error occurred while processing this tag * @see BodyTag */ int doStartTag() throws JspException; /** * Process the end tag for this instance. * This method is invoked by the JSP page implementation object * on all Tag handlers. * * <p> * This method will be called after returning from doStartTag. The * body of the action may or may not have been evaluated, depending on * the return value of doStartTag. * * <p> * If this method returns EVAL_PAGE, the rest of the page continues * to be evaluated. If this method returns SKIP_PAGE, the rest of * the page is not evaluated, the request is completed, and * the doEndTag() methods of enclosing tags are not invoked. If this * request was forwarded or included from another page (or Servlet), * only the current page evaluation is stopped. * * <p> * The JSP container will resynchronize the values of any AT_BEGIN and * AT_END variables (defined by the associated TagExtraInfo or TLD) * after the invocation of doEndTag(). * * @return indication of whether to continue evaluating the JSP page. * @throws JspException if an error occurred while processing this tag */ int doEndTag() throws JspException; /** * Called on a Tag handler to release state. * The page compiler guarantees that JSP page implementation * objects will invoke this method on all tag handlers, * but there may be multiple invocations on doStartTag and doEndTag in between. */ void release(); }