Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

javax.servlet.jsp.el.* (6)javax.servlet.jsp.jstl.* (13)javax.servlet.jsp.jstl.core.* (5)
javax.servlet.jsp.jstl.fmt.* (2)javax.servlet.jsp.jstl.sql.* (4)javax.servlet.jsp.jstl.tlv.* (2)
javax.servlet.jsp.tagext.* (25)

javax.servlet.jsp: Javadoc index of package javax.servlet.jsp.


Package Samples:

javax.servlet.jsp.tagext: Classes and interfaces for the Core JSP 2.0 API.  
javax.servlet.jsp.el: Classes and interfaces for the Core JSP 2.0 API.  
javax.servlet.jsp.jstl.core
javax.servlet.jsp.jstl.fmt
javax.servlet.jsp.jstl.sql
javax.servlet.jsp.jstl.tlv

Classes:

VariableInfo: Information on the scripting variables that are created/modified by a tag (at run-time). This information is provided by TagExtraInfo classes and it is used by the translation phase of JSP. Scripting variables generated by a custom action have an associated scope of either AT_BEGIN, NESTED, or AT_END. The class name (VariableInfo.getClassName) in the returned objects is used to determine the types of the scripting variables. Note that because scripting variables are assigned their values from scoped attributes which cannot be of primitive types, "boxed" types such as java.lang.Integer ...
BodyTag: The BodyTag interface extends IterationTag by defining additional methods that let a tag handler manipulate the content of evaluating its body. It is the responsibility of the tag handler to manipulate the body content. For example the tag handler may take the body content, convert it into a String using the bodyContent.getString method and then use it. Or the tag handler may take the body content and write it out into its enclosing JspWriter using the bodyContent.writeOut method. A tag handler that implements BodyTag is treated as one that implements IterationTag, except that the doStartTag method ...
Tag: 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. Properties The Tag interface specifies the setter and getter methods for the core pageContext and parent properties. The JSP page implementation object invokes setPageContext and setParent, in that order, before invoking doStartTag() or doEndTag(). Methods There are two main actions: doStartTag and doEndTag. Once all appropriate properties ...
JspWriter: The actions and template data in a JSP page is written using the JspWriter object that is referenced by the implicit variable out which is initialized automatically using methods in the PageContext object. This abstract class emulates some of the functionality found in the java.io.BufferedWriter and java.io.PrintWriter classes, however it differs in that it throws java.io.IOException from the print methods while PrintWriter does not. Buffering The initial JspWriter object is associated with the PrintWriter object of the ServletResponse in a way that depends on whether the page is or is not buffered. ...
PageContext: PageContext extends JspContext to provide useful context information for when JSP technology is used in a Servlet environment. A PageContext instance provides access to all the namespaces associated with a JSP page, provides access to several page attributes, as well as a layer above the implementation details. Implicit objects are added to the pageContext automatically. The PageContext class is an abstract class, designed to be extended to provide implementation dependent implementations thereof, by conformant JSP engine runtime environments. A PageContext instance is obtained by a JSP implementation ...
TagLibraryValidator: Translation-time validator class for a JSP page. A validator operates on the XML view associated with the JSP page. The TLD file associates a TagLibraryValidator class and some init arguments with a tag library. The JSP container is reponsible for locating an appropriate instance of the appropriate subclass by new a fresh instance, or reuse an available one invoke the setInitParams(Map) method on the instance once initialized, the validate(String, String, PageData) method will be invoked, where the first two arguments are the prefix and uri for this tag library in the XML View. The prefix is intended ...
SimpleTag: Interface for defining Simple Tag Handlers. Simple Tag Handlers differ from Classic Tag Handlers in that instead of supporting doStartTag() and doEndTag() , the SimpleTag interface provides a simple doTag() method, which is called once and only once for any given tag invocation. All tag logic, iteration, body evaluations, etc. are to be performed in this single method. Thus, simple tag handlers have the equivalent power of BodyTag , but with a much simpler lifecycle and interface. To support body content, the setJspBody() method is provided. The container invokes the setJspBody() method with a ...
IterationTag: The IterationTag interface extends Tag by defining one additional method that controls the reevaluation of its body. A tag handler that implements IterationTag is treated as one that implements Tag regarding the doStartTag() and doEndTag() methods. IterationTag provides a new method: doAfterBody() . The doAfterBody() method is invoked after every body evaluation to control whether the body will be reevaluated or not. If doAfterBody() returns IterationTag.EVAL_BODY_AGAIN, then the body will be reevaluated. If doAfterBody() returns Tag.SKIP_BODY, then the body will be skipped and doEndTag() will ...
LoopTagSupport: Base support class to facilitate implementation of iteration tags. Since most iteration tags will behave identically with respect to actual iterative behavior, JSTL provides this base support class to facilitate implementation. Many iteration tags will extend this and merely implement the hasNext() and next() methods to provide contents for the handler to iterate over. In particular, this base class provides support for: Iteration control, based on protected prepare() , next() , and hasNext() methods Subsetting ( begin , end , step> functionality, including validation of subset parameters for sensibility) ...
JspContext: JspContext serves as the base class for the PageContext class and abstracts all information that is not specific to servlets. This allows for Simple Tag Extensions to be used outside of the context of a request/response Servlet. The JspContext provides a number of facilities to the page/component author and page implementor, including: a single API to manage the various scoped namespaces a mechanism to obtain the JspWriter for output a mechanism to expose page directive attributes to the scripting environment Methods Intended for Container Generated Code The following methods enable the management ...
JspPage: The JspPage interface describes the generic interaction that a JSP Page Implementation class must satisfy; pages that use the HTTP protocol are described by the HttpJspPage interface. Two plus One Methods The interface defines a protocol with 3 methods; only two of them: jspInit() and jspDestroy() are part of this interface as the signature of the third method: _jspService() depends on the specific protocol used and cannot be expressed in a generic way in Java. A class implementing this interface is responsible for invoking the above methods at the appropriate time based on the corresponding Servlet-based ...
JspFragment: Encapsulates a portion of JSP code in an object that can be invoked as many times as needed. JSP Fragments are defined using JSP syntax as the body of a tag for an invocation to a SimpleTag handler, or as the body of a <jsp:attribute> standard action specifying the value of an attribute that is declared as a fragment, or to be of type JspFragment in the TLD. The definition of the JSP fragment must only contain template text and JSP action elements. In other words, it must not contain scriptlets or scriptlet expressions. At translation time, the container generates an implementation of the ...
TagExtraInfo: Optional class provided by the tag library author to describe additional translation-time information not described in the TLD. The TagExtraInfo class is mentioned in the Tag Library Descriptor file (TLD). This class can be used: to indicate that the tag defines scripting variables to perform translation-time validation of the tag attributes. It is the responsibility of the JSP translator that the initial value to be returned by calls to getTagInfo() corresponds to a TagInfo object for the tag being translated. If an explicit call to setTagInfo() is done, then the object passed will be returned ...
ExpressionEvaluator: The abstract base class for an expression-language evaluator. Classes that implement an expression language expose their functionality via this abstract class. An instance of the ExpressionEvaluator can be obtained via the JspContext / PageContext The parseExpression() and evaluate() methods must be thread-safe. That is, multiple threads may call these methods on the same ExpressionEvaluator object simultaneously. Implementations should synchronize access if they depend on transient state. Implementations should not, however, assume that only one object of each ExpressionEvaluator type will be ...
SQLExecutionTag: This interface allows tag handlers implementing it to receive values for parameter markers in their SQL statements. This interface is implemented by both <sql:query> and <sql:update>. Its addSQLParameter() method is called by nested parameter actions (such as <sql:param>) to substitute PreparedStatement parameter values for "?" parameter markers in the SQL statement of the enclosing SQLExecutionTag action. The given parameter values are converted to their corresponding SQL type (following the rules in the JDBC specification) before they are sent to the database. Keeping track ...
BodyContent: An encapsulation of the evaluation of the body of an action so it is available to a tag handler. BodyContent is a subclass of JspWriter. Note that the content of BodyContent is the result of evaluation, so it will not contain actions and the like, but the result of their invocation. BodyContent has methods to convert its contents into a String, to read its contents, and to clear the contents. The buffer size of a BodyContent object is unbounded. A BodyContent object cannot be in autoFlush mode. It is not possible to invoke flush on a BodyContent object, as there is no backing stream. Instances ...
ValidationMessage: A validation message from either TagLibraryValidator or TagExtraInfo. As of JSP 2.0, a JSP container must support a jsp:id attribute to provide higher quality validation errors. The container will track the JSP pages as passed to the container, and will assign to each element a unique "id", which is passed as the value of the jsp:id attribute. Each XML element in the XML view available will be extended with this attribute. The TagLibraryValidator can then use the attribute in one or more ValidationMessage objects. The container then, in turn, can use these values to provide more precise information ...
ScriptFreeTLV: A TagLibraryValidator for enforcing restrictions against the use of JSP scripting elements. This TLV supports four initialization parameters, for controlling which of the four types of scripting elements are allowed or prohibited: allowDeclarations : if true, indicates that declaration elements are not prohibited. allowScriptlets : if true, indicates that scriptlets are not prohibited allowExpressions : if true, indicates that top-level expression elements (i.e., expressions not associated with request-time attribute values) are not prohibited. allowRTExpressions : if true, indicates that expression ...
TryCatchFinally: The auxiliary interface of a Tag, IterationTag or BodyTag tag handler that wants additional hooks for managing resources. This interface provides two new methods: doCatch(Throwable) and doFinally(). The prototypical invocation is as follows: h = get a Tag(); // get a tag handler, perhaps from pool h.setPageContext(pc); // initialize as desired h.setParent(null); h.setFoo("foo"); // tag invocation protocol; see Tag.java try { doStartTag()... .... doEndTag()... } catch (Throwable t) { // react to exceptional condition h.doCatch(t); } finally { // restore data invariants and release per-invocation ...
JspFactory: The JspFactory is an abstract class that defines a number of factory methods available to a JSP page at runtime for the purposes of creating instances of various interfaces and classes used to support the JSP implementation. A conformant JSP Engine implementation will, during it's initialization instantiate an implementation dependent subclass of this class, and make it globally available for use by JSP implementation classes by registering the instance created with this class via the static setDefaultFactory() method. The PageContext and the JspEngineInfo classes are the only implementation-dependent ...
Result: This interface represents the result of a <sql:query> action. It provides access to the following information in the query result: The result rows ( getRows() and getRowsByIndex() ) The column names ( getColumnNames() ) The number of rows in the result ( getRowCount() ) An indication whether the rows returned represent the complete result or just a subset that is limited by a maximum row setting ( isLimitedByMaxRows() ) An implementation of the Result interface provides a disconnected view into the result of a query.
SkipPageException: Exception to indicate the calling page must cease evaluation. Thrown by a simple tag handler to indicate that the remainder of the page must not be evaluated. The result is propagated back to the pagein the case where one tag invokes another (as can be the case with tag files). The effect is similar to that of a Classic Tag Handler returning Tag.SKIP_PAGE from doEndTag(). Jsp Fragments may also throw this exception. This exception should not be thrown manually in a JSP page or tag file - the behavior is undefined. The exception is intended to be thrown inside SimpleTag handlers and in JSP fragments ...
ConditionalTagSupport: Abstract class that facilitates implementation of conditional actions where the boolean result is exposed as a JSP scoped variable. The boolean result may then be used as the test condition in a <c:when> action. This base class provides support for: Conditional processing of the action's body based on the returned value of the abstract method condition() . Storing the result of condition() as a Boolean object into a JSP scoped variable identified by attributes var and scope .
TagAdapter: Wraps any SimpleTag and exposes it using a Tag interface. This is used to allow collaboration between classic Tag handlers and SimpleTag handlers. Because SimpleTag does not extend Tag, and because Tag.setParent() only accepts a Tag instance, a classic tag handler (one that implements Tag) cannot have a SimpleTag as its parent. To remedy this, a TagAdapter is created to wrap the SimpleTag parent, and the adapter is passed to setParent() instead. A classic Tag Handler can call getAdaptee() to retrieve the encapsulated SimpleTag instance.
DynamicAttributes: For a tag to declare that it accepts dynamic attributes, it must implement this interface. The entry for the tag in the Tag Library Descriptor must also be configured to indicate dynamic attributes are accepted. For any attribute that is not declared in the Tag Library Descriptor for this tag, instead of getting an error at translation time, the setDynamicAttribute() method is called, with the name and value of the attribute. It is the responsibility of the tag to remember the names and values of the dynamic attributes.

Home | Contact Us | Privacy Policy | Terms of Service