1
Overview of Tag Libraries and Utilities

This manual documents tag libraries, JavaBeans, and other utilities supplied with OC4J that are implemented according to industry standards and are generally portable to other JSP or servlet environments. There is also a section summarizing tag libraries provided with other components of the Oracle9i Application Server.

Oracle-specific features, as well as an introduction to the OC4J JSP container and standard JSP technology, are covered in the Oracle9iAS Containers for J2EE Support for JavaServer Pages Reference.

This chapter covers the following topics:

• Overview of Tag Libraries and Utilities Provided with OC4J

• Overview of Oracle Caching Support for Web Applications

• Overview of Tag Libraries from Other Oracle9iAS Components

Tags and JavaBeans introduced in the first section provide functionality in several different areas, including type extensions, integration with XML/XSL, database access, and programming convenience.

Overview of Tag Libraries and Utilities Provided with OC4J

The Oracle extensions introduced in this section are implemented through standard tag libraries or custom JavaBeans and are generally portable to other JSP environments.

Here is a list of the topics covered:

• Tag Syntax Symbology and Notes

• Overview of Extended Type JavaBeans

• Overview of JspScopeListener for Event-Handling

• Overview of Integration with XML and XSL

• Summary of Custom Data-Access JavaBeans and Tag Library

• Summary of JSP Markup Language (JML) Custom Tag Library

• Summary of Oracle9iAS Personalization Tag Library

• Summary of JSP Utility Tags

  Note: See the OC4J demos for sample applications using the features introduced in this section.

Tag Syntax Symbology and Notes

For the syntax documentation in tag descriptions throughout this manual, note the following:

• Italic indicates that you must specify a value or string.

• Optional attributes are enclosed in square brackets: [...]

• Default values of optional attributes are indicated in bold.

• Choices in how to specify an attribute are separated by vertical bars: |

• Except where noted, you can use JSP runtime expressions to set tag attribute values: "<%= jspExpression %>"

• Tag descriptions in this manual use certain tag prefixes by convention; however, you can designate any desired prefix in your taglib directives.

Overview of Extended Type JavaBeans

JSP pages generally rely on core Java types in representing scalar values. However, neither of the following standard type categories is fully suitable for use in JSP pages:

• primitive types such as int, float, and double

  Values of these types cannot have a specified scope--they cannot be stored in a JSP scope object (for page, request, session, or application scope), because only objects can be stored in a scope object.

• wrapper classes in the standard java.lang package, such as Integer, Float, and Double

  Values of these types are objects, so they can theoretically be stored in a JSP scope object. However, they cannot be declared in a jsp:useBean action, because the wrapper classes do not follow the JavaBean model and do not provide zero-argument constructors.

  Additionally, instances of the wrapper classes are immutable. To change a value, you must create a new instance and assign it appropriately.

To work around these limitations, OC4J provides the JmlBoolean, JmlNumber, JmlFPNumber, and JmlString JavaBean classes in package oracle.jsp.jml to wrap the most common Java types.

For information, see Chapter 2, "JavaBeans for Extended Types".

Overview of JspScopeListener for Event-Handling

OC4J provides the JspScopeListener interface for lifecycle management of Java objects of various scopes within a JSP application.

Standard servlet and JSP event-handling is provided through the javax.servlet.http.HttpSessionBindingListener interface, but this is for session-based events only. The Oracle JspScopeListener can be integrated with HttpSessionBindingListener to manage session-based events, and can handle page-based, request-based, and application-based events as well.

For information, see "JSP Event-Handling--JspScopeListener".

Overview of Integration with XML and XSL

You can use JSP syntax to generate any text-based MIME type, not just HTML code. In particular, you can dynamically create XML output. When you use JSP pages to generate an XML document, however, you often want a stylesheet applied to the XML data before it is sent to the client. This is difficult in JavaServer Pages technology, because the standard output stream used for a JSP page is written directly back through the server.

OC4J provides special tags to specify that all or part of a JSP page should be transformed through an XSL stylesheet before it is output. Input can be from the tag body or from an XML DOM object, and output can be to an XML DOM object to the browser.

You can use these tags multiple times in a single JSP page if you want to specify different style sheets for different portions of the page. Note that these tags are portable to other JSP environments.

There is additional XML support as well:

• A utility tag converts data from an input stream to an XML DOM object.

• Several tags, for such features as caching and SQL operations, now can take XML objects as input or send them as output.

XML utility tags are summarized in Table 1-1. Note that there is also XML functionality in the dbOpen SQL tag, and the cacheXMLObj Web Object Cache tag. For more information, see Chapter 5, "XML and XSL Tag Support".

You can find information about Oracle-specific XML support in the Oracle9iAS Containers for J2EE Support for JavaServer Pages Reference.

Table 1-1 Summary of XML Utility Tags  

Tag	Description	Attributes
transform	Output XML data with an XSL transformation, either to an HTTP client or a specified XML DOM object.	href fromXMLObjName toXMLObjName toWriter
styleSheet	Same as transform tag.	href fromXMLObjName toXMLObjName toWriter
parsexml	Convert from an input stream to an XML DOM object.	resource toXMLObjName validateResource root

Summary of Custom Data-Access JavaBeans and Tag Library

OC4J supplies a set of custom JavaBeans for use in accessing the Oracle9i database. The following beans are provided in the oracle.jsp.dbutil package:

• ConnBean opens a database connection. This bean also supports data sources and connection pooling.

• ConnCacheBean uses the Oracle connection caching implementation for database connections. (This requires JDBC 2.0.)

• DBBean executes a database query.

• CursorBean provides general DML support for queries; UPDATE, INSERT, and DELETE statements; and stored procedure calls.

For information, see "JavaBeans for Data Access".

For JSP programmers, OC4J also provides a custom tag library for SQL functionality, wrapping the functionality of the JavaBeans. These tags are summarized in Table 1-2. For further information, see "SQL Tags for Data Access".

Table 1-2 Summary of Data-Access Tag Library  

Tag	Description	Attributes
dbOpen	Open a database connection. This tag also supports data sources and connection pooling.	connId scope dataSource user password URL commitOnClose
dbClose	Close a database connection.	connId scope
dbQuery	Execute a query.	queryId connId scope output maxRows skipRows bindParams toXMLObjName
dbCloseQuery	Close the cursor for a query.	queryId
dbNextRow	Process the rows of a result set.	queryId
dbExecute	Execute any SQL statement (DML or DDL).	connId scope output bindParams
dbSetParam	Set a parameter to bind into a dbQuery or dbExecute tag.	name value scope
dbSetCookie	Set a cookie.	name value domain comment maxAge version secure path

Summary of JSP Markup Language (JML) Custom Tag Library

Although the Sun Microsystems JavaServer Pages Specification, Version 1.1 supports scripting languages other than Java, Java is the primary language used. Even though JavaServer Pages technology is designed to separate the dynamic/Java development effort from the static/HTML development effort, it is a hindrance if the Web developer does not know any Java, especially in small development groups where no Java experts are available.

OC4J provides custom tags as an alternative--the JSP Markup Language (JML). The Oracle JML tag library provides an additional set of JSP tags so that you can script your JSP pages without using Java statements. JML provides tags for variable declarations, control flow, conditional branches, iterative loops, parameter settings, and calls to objects. The JML tag library also supports XML functionality, as noted previously.

The following example shows use of the JML for tag, repeatedly printing "Hello World" in progressively smaller headings (H1, H2, H3, H4, H5):

<jml:for id="i" from="<%= 1 %>" to="<%= 5 %>" >
     <H<%=i%>>
            Hello World!
     </H<%=i%>>
</jml:for>

The JML tag library is summarized in Table 1-3. For more information, see Chapter 3, "JSP Markup Language Tags".

Table 1-3 Summary of JSP Markup Language Tag Library  

Tag	Description	Attributes
useVariable	This tag offers a convenient alternative to the jsp:useBean tag for declaring simple variables.	id scope type value
useForm	This tag provides a convenient syntax for declaring variables and setting them to values passed in from the request.	id scope type param
useCookie	This tag offers a convenient syntax for declaring variables and setting them to values contained in cookies.	id scope type cookie
remove	This tag removes an object from its scope.	id scope
if	This tag evaluates a single conditional statement. If the condition is true, then the body of the if tag is executed.	condition
choose	The choose tag, with associated when and otherwise tags, provides a multiple conditional statement.	(none)
when	This is used with the choose tag.	condition
otherwise	This is optionally used with the choose and when tags.	(none)
for	This tag provides the ability to iterate through a loop, as with a Java for loop.	id from to
foreach	This tag provides the ability to iterate over a homogeneous set of values in a Java array, Enumeration instance, or Vector instance.	id in limit type
return	When this tag is reached, execution returns from the page without further processing.	(none)
flush	This tag writes the current contents of the page buffer back to the client. This applies only if the page is buffered; otherwise, there is no effect.	(none)

Note: Oracle JSP container versions preceding the JSP 1.1 specification use an Oracle-specific compile-time implementation of the JML tag library. Oracle still supports this implementation as an alternative to the standard runtime implementation, as documented in Appendix A, "JML Compile-Time Syntax and Tags".

Summary of Oracle9iAS Personalization Tag Library

Web site personalization is a mechanism to personalize recommendations to users of a site, based on behavioral and demographic data. Recommendations are made in real-time, during a user's Web session. User behavior is saved to a database repository for use in building models for predictions of future user behavior.

Oracle9iAS Personalization uses data mining algorithms in the Oracle database to choose the most relevant content available for a user. Recommendations are calculated by an Oracle9iAS Personalization recommendation engine, using typically large amounts of data regarding past and current user behavior. This is superior to other approaches that rely on "common sense" heuristics and require manual definition of rules in the system.

The Oracle9iAS Personalization tag library brings this functionality to a wide audience of JSP developers for use in HTML, XML, or JavaScript pages. The tag interface is layered on top of the lower level Java API of the recommendation engine.

Table 1-4 summarizes the Oracle9iAS Personalization Tag Library. See Chapter 9, "Oracle9iAS Personalization Tags" for information.

Table 1-4 Summary of Oracle9iAS Personalization Tag Library  

Tag	Description	Attributes
startRESession	Use this tag to start an Oracle9iAS Personalization recommendation engine session.	REName REURL RESchema REPassword RECacheSize REFlushInterval applicationSession createSession userType userID storeUserIDIn disableRecording
endRESession	Use this tag to explicitly end a recommendation engine session.	(none)
setVisitorToCustomer	Use this tag for situations where an anonymous visitor creates a registered customer account.	customerID
getRecommendations	Use this tag to request a set of recommendations for purchasing, navigation, or ratings.	from fromHotPicksGroups storeResultsIn storeInterestDimensionIn maxQuantity tuningName tuningDataSource tuningInterestDimension tuningPersonalizationIndex tuningProfileDataBalance tuningProfileUsage filteringName filteringTaxonomyID filteringMethod filteringCategories sortOrder
getCrossSellRecommendations	Use this tag to request a set of recommendations for purchasing, navigation, or ratings, based on input of a set of past items (such as past purchases) that are used as a basis for the recommendations.	storeResultsIn storeInterestDimensionIn fromHotPicksGroups inputItemList maxQuantity tuningName tuningDataSource tuningInterestDimension tuningPersonalizationIndex tuningProfileDataBalance tuningProfileUsage filteringName filteringTaxonomyID filteringMethod filteringCategories sortOrder
selectFromHotPicks	Use this tag to request recommendations from a set of "hot picks" groups only.	hotPicksGroups storeResultsIn storeInterestDimensionIn maxQuantity tuningName tuningDataSource tuningInterestDimension tuningPersonalizationIndex tuningProfileDataBalance tuningProfileUsage filteringName filteringTaxonomyID filteringMethod filteringCategories sortOrder
evaluateItems	Use this tag to evaluate only the set of items that are input to the tag.	storeResultsIn taxonomyID inputItemList tuningName tuningDataSource tuningInterestDimension tuningPersonalizationIndex tuningProfileDataBalance tuningProfileUsage sortOrder
forItem	You can use this tag to select individual items input to a tag that requires an input list.	index itemList type ID
getNextItem	You can optionally use this tag within some recommendation tags to access and process returned items.	storeTypeIn storeIDIn storeItemIn
recordNavigation	Use this tag to record a navigation item into the recommendation engine session cache.	type ID index itemList
recordPurchase	Use this tag to record a purchasing item into the recommendation engine session cache.	type ID index itemList
recordRating	Use this tag to record a rating item into the recommendation engine session cache.	value type ID index itemList
recordDemographic	Use this tag to record a demographic item into the recommendation engine session cache.	type value
removeNavigationRecord	Use this tag to remove a navigation item that had been recorded into the recommendation engine session cache earlier in the session.	type ID index itemList
removePurchaseRecord	Use this tag to remove a purchasing item that had been recorded into the recommendation engine session cache earlier in the session.	type ID index itemList
removeRatingRecord	Use this tag to remove a rating item that had been recorded into the recommendation engine session cache earlier in the session.	value type ID index itemList
removeDemographicRecord	Use this tag to remove a demographic item that had been recorded into the recommendation engine session cache earlier in the session.	type value

Summary of JSP Utility Tags

OC4J provides utility tags to accomplish the following from within Web applications:

• sending e-mail messages

• uploading and downloading files

• using EJBs

• using miscellaneous utilities

For sending e-mail messages, you can use the sendMail tag or the oracle.jsp.webutil.email.SendMailBean JavaBean. Table 1-5 summarizes the sendMail tag. See "Mail JavaBean and Tag" for more information.

Table 1-5 Summary of sendMail Tag  

Tag	Description	Attributes
sendMail	Send an e-mail message from a JSP page. Tag functionality includes globalization support.	host sender recipient cc bcc subject contentType contentEncoding

For uploading files, you can use the httpUpload tag or the oracle.jsp.webutil.fileaccess.HttpUploadBean JavaBean. For downloading, there is the httpDownload tag or the HttpDownloadBean JavaBean. Table 1-6 summarizes the file access tags. For more information see "File-Access JavaBeans and Tags".

Table 1-6 Summary of File Access Tag Library  

Tag	Description	Attributes
httpUploadForm	For convenience, you can use this tag to create a form in your application, using multipart encoded form data, that allows users to specify the files to upload.	formsAction maxFiles fileNameSize maxFileNameSize includeNumbers submitButtonText
httpUpload	Upload files from the client to a server. You can upload into either a file system or a database.	destination destinationType connId scope overwrite fileType table prefixColumn fileNameColumn dataColumn
httpDownload	Download files from a server to the client. You can download from either a file system or a database.	servletPath source sourceType connId scope recurse fileType table prefixColumn fileNameColumn dataColumn

For using EJBs, there are tags to create a home instance, create an EJB instance, and iterate through a collection of EJBs. Table 1-7 summarizes the EJB tag library. See "EJB Tags" for more information.

Table 1-7 Summary of EJB Tag Library  

Tag	Description	Attributes
useHome	This tag looks up the home interface for the EJB and creates an instance of it.	id type location
useBean	Use this tag for instantiating and using the EJB. Its functionality has similarities to the standard jsp:useBean tag for a JavaBean.	id type value scope
createBean	For first instantiating an EJB, if you do not use the value attribute of the EJB useBean tag, you must nest an EJB createBean tag within the useBean tag to do the work of creating the EJB instance.	instance
iterate	Use this tag to iterate through a collection of EJB instances (more typical for entity beans).	id type collection max

There are also utility tags for displaying a date, displaying an amount of money in the appropriate currency, displaying a number, iterating through a collection, evaluating and including the tag body depending on whether the user belongs to a specified role, and displaying the last modification date of the current file. Table 1-8 summarizes these tags. See "General Utility Tags" for more information.

Table 1-8 Summary of General Utility Tag Library  

Tag	Description	Attributes
displayCurrency	This tag displays a specified amount of money, formatted as currency for the locale.	amount locale
displayDate	This tag displays a specified date, formatted appropriately for the locale.	date locale
displayNumber	This displays the specified number, for the locale and optionally in the specified format.	number locale format
iterate	Use this tag to iterate through a collection.	id type collection max
ifInRole	Use this tag to evaluate the tag body and include it in the body of the JSP page, depending on whether the user is in the specified application role.	role include
lastModified	This tag displays the date of the last modification of the current file, in appropriate format for the locale.	locale

Overview of Oracle Caching Support for Web Applications

This section provides the following information:

• an introduction to caching features supported by the Oracle9i Application Server in general and the OC4J JSP container in particular

• a discussion of the role of the OC4J Web Object Cache in relation to other Oracle9i Application Server caching components

• a summary of tag libraries relating to caching features

  Note: See the OC4J demos for sample applications using the features introduced in this section.

Oracle9i Application Server and JSP Caching Features

The Oracle9i Application Server and OC4J provide the following caching features:

• Oracle9iAS Web Cache

  This is an HTTP-level cache, maintained outside the application, providing very fast cache operations. It is a pure, content-based cache, capable of caching static data (such as HTML, GIF, or JPEG files) or dynamic data (such as servlet or JSP results). Given that it exists as a flat content-based cache outside the application, it cannot cache objects (such as Java objects or XML DOM objects) in a structured format. In addition, it has relatively limited post-processing abilities on cached data.

  The Oracle9iAS Web Cache provides an ESI processor to support Edge Side Includes, an XML-style markup language that allows dynamic content assembly away from the Web server. This technology allows you to break cacheable pages into separate cached objects, as desired. OC4J supports this technology through its JESI tag library.

  For an overview of Edge Side Includes and the Oracle9iAS Web Cache, as well as detailed documentation of the JESI tag library, see Chapter 6, "JESI Tags for Edge Side Includes".

  For additional information about the Oracle9iAS Web Cache, see the Oracle9iAS Web Cache Administration and Deployment Guide.

• OC4J Web Object Cache

  This is an application-level cache, embedded and maintained within a Java Web application. It is a hybrid cache, both Web-based and object-based. A custom tag library or API allows you to define page fragment boundaries and to capture, store, reuse, process, and manage the intermediate and partial execution results of JSP pages and servlets as cached objects. Each block can produce its own resulting cache object. The produced objects can be HTML or XML text fragments, XML DOM objects, or Java serializable objects. These objects can be cached conveniently in association with HTTP semantics. Alternatively, they can be reused outside HTTP, such as in outputting cached XML objects through Simple Mail Transfer Protocol (SMTP), Java Messaging Service (JMS), Advanced Queueing (AQ), or Simple Object Access Protocol (SOAP).

  For more information, see Chapter 7, "Web Object Cache Tags and API".

• Oracle9i Application Server Java Object Cache

  The Oracle9i Application Server Java Object Cache is a general-use cache to manage Java objects within a process, across processes, and on local disk. By managing local copies of objects that are difficult or expensive to retrieve or create, the Java Object Cache significantly improves server performance. By default, the OC4J Web Object Cache uses the Oracle9i Application Server Java Object Cache as its underlying cache repository.

  For details, see theOracle9iAS Containers for J2EE Services Guide.

Role of the JSP Web Object Cache

It is important to understand the role of the OC4J Web Object Cache in the overall setup of a Web application. It works at the Java level and is closely integrated with the HTTP environment of servlet and JSP applications. By contrast, the Oracle9i Application Server Java Object Cache works at the Java object level, but is not integrated with HTTP. As for the Oracle9iAS Web Cache, it is well integrated with HTTP and is an order of magnitude faster than the Web Object Cache, but it does not operate at the Java level. For example, it cannot apply a stylesheet to a cached DOM object within the J2EE container, reuse the cached result in other protocols, or allow direct DOM operations. (Oracle9iAS Web Cache can, however, apply a stylesheet to raw XML documents, as opposed to DOM objects, that were cached from the original Web server through HTTP.)

The Web Object Cache is not intended for use as the main Web cache for an application. It is an auxiliary cache embedded within the same Java virtual machine that is running your servlets and JSP pages. Because the retrieval path for cached results in the Web Object Cache includes the JVM and the JSP and servlet engines, it generally takes much longer to serve a page from the Web Object Cache compared to the Oracle9iAS Web Cache.

The Web Object Cache does not replace or eliminate the need for either the Oracle9iAS Web Cache or the Oracle9i Application Server Java Object Cache--it is a complementary caching component in the overall framework of a Web application and should be used together with the other caching products, as appropriate. In fact, the Web Object Cache uses the Java Object Cache as its default repository. And through combined use of the OC4J JESI tags and Web Object Cache tags, you can use the Web Object Cache and Oracle9iAS Web Cache together in the same page.

Web Object Cache Versus Oracle9iAS Web Cache

Think of the Oracle9iAS Web Cache as the primary caching component. It serves cached pages directly to HTTP clients and handles large volumes of HTTP traffic quickly, fitting the requirements of most Web sites. You can use the Oracle9iAS Web Cache to store complete Web pages or partial pages (through use of the JESI tags). Cached pages can be customized, to a certain extent, before being sent to a client, including cookie-replacement and page-fragment concatenation, for example.

It is advisable to use the Oracle9iAS Web Cache as much as possible to reduce the load on the Web application server and back-end database. The caching needs of a large percentage of Web pages can be addressed by the Oracle9iAS Web Cache alone.

As a complement to the Oracle9iAS Web Cache, you can use the Web Object Cache to capture intermediate results of JSP and servlet execution, and subsequently reuse these cached results in other parts of the Java application logic. It is not beneficial to use the Web Object Cache in your Web application unless you are doing a significant amount of post-processing on cached objects between the time they are cached and the time they are served to a client.

Web Object Cache Versus Oracle9i Application Server Java Object Cache

In comparison to the Oracle9i Application Server Java Object Cache, the Web Object Cache makes it much easier to store and maintain partial execution results in dynamic Web pages. The Java Object Cache, being a pure object-based framework for any general Java application, is not aware of the HTTP environment in which it may be embedded. For example, it does not directly depend on HTTP cookies or sessions. When you directly use the Java Object Cache within a Web application, you are responsible for creating any necessary interfacing. The Java Object Cache does not provide a way to specify maintenance policies declaratively.

Summary of Tag Libraries for Caching

OC4J supplies two tag libraries for use with Oracle9iAS caching features:

• JESI tag library

• Web Object Cache tag library

This section summarizes those libraries.

Summary of JESI Tag Library

OC4J provides the JESI tag library as a convenient interface to ESI tags and Edge Side Includes functionality for Web caching. Developers have the option of using ESI tags directly in any Web application, but JESI tags provide additional convenience in a JSP environment.

Table 1-9 summarizes the JESI tag library. See "Oracle JESI Tag Descriptions" for more information.

Table 1-9 Summary of JESI Tag LIbrary  

Tag	Description	Attributes
control	This tag controls caching characteristics for JSP pages in the control/include usage model. You can use a JESI control tag in the top-level page or any included page.	expiration maxRemovalDelay cache
include	This tag, like a standard jsp:include tag, dynamically inserts output from the included page into output from the including page. Additionally, it is directing that the included page be processed and assembled by the ESI processor.	page alt ignoreError copyparam flush
template	Use this tag to specify caching behavior for the aggregate page, outside any fragments, in the template/fragment usage model.	expiration maxRemovalDelay cache
fragment	Use one or more JESI fragment tags within a JESI template tag, between the JESI template start and end tags, in the template/fragment model.	expiration maxRemovalDelay cache
invalidate	Use this tag with its JESI object subtag to explicitly invalidate one or more cached objects.	url username password config output
object	Use this required subtag of the JESI invalidate tag to specify cached objects to invalidate, according to either the complete URI or a URI prefix.	uri prefix maxRemovalDelay
cookie	Optionally use this subtag of the JESI object tag to use cookie information as a further criterion for invalidation.	name value
header	Optionally use this subtag of the JESI object tag to use HTTP/1.1 header information as a further criterion for invalidation.	name value
personalize	Use this tag to allow page customization, by informing the ESI processor of dependencies on cookie and session information.	name value

Summary of Web Object Cache Tag Library

The OC4J Web Object Cache is a mechanism that allows Web applications written in Java to capture, store, reuse, post-process, and maintain the partial and intermediate results generated by a dynamic Web page, such as a JSP or servlet. For programming interfaces, it provides a tag library (for use in JSP pages) and a Java API (for use in servlets).

Table 1-10 summarizes the Web Object Cache tag library. See "Web Object Cache Tag Descriptions" for more information.

Table 1-10 Summary of Web Object Cache Tag LIbrary  

Tag	Description	Attributes
cache	Use this tag to set up general caching, as opposed to caching of XML objects or Java serializable objects, in a JSP application.	policy ignoreCache invalidateCache scope autoType selectedParam selectedCookies reusableTimeStamp reusableDeltaTime name expirationType TTL timeInaDay dayInaWeek dayInaMonth writeThrough printCacheBlockInfo printCachePolicy cacheRepositoryName reportException
cacheXMLObj	Generally speaking, use this tag instead of the cache tag if you are caching XML DOM objects. The cacheXMLObj tag supports all the cache tag attributes, as well as additional XML-specific parameters.	policy ignoreCache invalidateCache scope autoType selectedParam selectedCookies reusableTimeStamp reusableDeltaTime name expirationType TTL timeInaDay dayInaWeek dayInaMonth writeThrough printCacheBlockInfo printCachePolicy cacheRepositoryName reportException fromXMLObjName toXMLObjName toWriter
useCacheObj	Use this tag to cache any Java serializable object. The useCacheObj tag supports all the cache tag parameters, as well as additional attributes specific to its functionality.	policy ignoreCache invalidateCache scope autoType selectedParam selectedCookies reusableTimeStamp reusableDeltaTime name expirationType TTL timeInaDay dayInaWeek dayInaMonth writeThrough printCacheBlockInfo printCachePolicy cacheRepositoryName reportException type id cacheScope
cacheInclude	This tag combines functionality of the cache tag (but not the cacheXMLObj tag or useCacheObj tag) and the standard jsp:include tag.	policy page printCacheBlockInfo reportException
invalidateCache	Use this tag to explicitly invalidate a cache block through program logic. Most parameters of the invalidateCache tag also exist in the cache and cacheXMLObj tags and are used in the same way.	policy ignoreCache scope autoType selectedParam selectedCookies name invalidateNameLike page autoInvalidateLevel cacheRepositoryName reportException

Overview of Tag Libraries from Other Oracle9iAS Components

A number of other Oracle9iAS components provide JSP tag libraries. This section summarizes the following libraries:

• Oracle9i JDeveloper Business Components for Java (BC4J) Tag Library

• Oracle9i JDeveloper User Interface Extension (UIX) Tag Library

• Oracle9i JDeveloper BC4J/UIX Tag Library

• Oracle9i Reports Tag Library

• Oracle9iAS Wireless Location (Spatial) Tag Library

• Oracle9iAS Ultra Search Tag Library

• Oracle9iAS Portal Tag Library

Some prior knowledge of these components is helpful.

Oracle9i JDeveloper Business Components for Java (BC4J) Tag Library

Oracle9i JDeveloper provides set of JSP 1.1-compliant custom tags known as Business Components for Java (BC4J) data tags. BC4J data tags provide a simple tag-based approach for interaction with business component data sources. The tags provide complete access to business components and allow viewing, editing, and full DML control.

Custom data tags allow for simplified interaction with Business Components for Java data sources. The tag-based approach to building JSP applications with business components does not require extensive Java programming and is very much like coding an HTML page.

Table 1-11 summarizes the BC4J tag library. The typical tag prefix is jbo.

For more information, refer to the Oracle9i JDeveloper online help, or their documentation on the Oracle Technology Network:

http://otn.oracle.com/products/jdev/content.html

Note: Because of the size of this library, tags are not described individually.

Table 1-11 Summary of BC4J Tag Library  

Tag Group	Description of Group	Individual Tags
Component tags	This group includes tags to display a form and edit a record, handle business component events, perform a search on a data source, display a record bound to a data source, display a table bound to a data source, and render database transaction operations.	DataEdit DataHandler DataNavigate DataQuery DataRecord DataScroller DataTable DataTransaction
Connection tags	This group includes tags to create an application module instance to service HTTP requests, apply changes made on a data source to the database, create a dynamic view object from an application module, create a JSP page data source, create a data source variable, post changes made on a data source to the database, re-execute the data of a data source, trigger the release of an application module instance, and roll back current data source changes.	ApplicationModule Commit CreateViewObject DataSource DataSourceRef PostChanges RefreshDataSource ReleasePageResources RollBack
Data access tags	This group includes tags to iterate through the data source attribute definition, set a WHERE clause, execute a SQL statement, display an attribute using a field renderer, retrieve a data row instance and perform an operation, iterate through the rows of a data source, move the viewing range of a data source, update an attribute in a row, display the criteria of a data item, display the meta data of an attribute, display the hints of an attribute, display an attribute value, set search view criteria, and iterate through the rows of view criteria.	AttributeIterate Criteria CriteriaRow ExecuteSQL RenderValue Row RowsetIterate RowsetNavigate SetAttribute ShowCriteria ShowDefinition ShowHint ShowValue ViewCriteria ViewCriteriaIterate
Event tags	This group includes tags to execute a business component event, handle a business component event, and build a URL for events.	FormEvent OnEvent UrlEvent
Forms tags	This group includes tags to insert an input date field, insert an input field, insert a hidden input field, insert a password field, overwrite the field renderer, and add HTML attributes to an input tag.	InputDate InputHidden InputPassword InputRender InputSelect InputSelectGroup InputSelectLOV InputText InputTextArea SetDomainRenderer SetFieldRenderer SetHtmlAttribute
interMedia tags	This group includes tags to insert an HTML ANCHOR tag for an interMedia object, insert an HTML OBJECT tag for an interMedia audio object, insert an HTML IMAGE tag for an interMedia image object, insert an HTML OBJECT tag for an interMedia video object, insert an HTML FORM tag for a file upload, and insert a URL string for an interMedia object.	AnchorMedia EmbedAudio EmbedImage EmbedVideo FileUploadForm MediaUrl
Web bean tags	This group includes tags to insert a Web bean or Data Web bean into a page.	DataWebBean WebBean

Oracle9i JDeveloper User Interface Extension (UIX) Tag Library

Oracle9i JDeveloper provides set of JSP 1.1-compliant custom tags known as User Interface Extension (UIX) tags. The tags invoke UIX controls, generating the HTML to render tabs, buttons, tables, headers, and other layout and navigational components that implement the Oracle browser look and feel.

The tags are included on several palette pages: UIX Page, UIX Layout, UIX Table, UIX Form, UIX Border Layout, and BC4J UIX. These support page layout, table layout, form layout, border layout, and data-binding to a business components project.

Table 1-12 summarizes the UIX tag library. The typical tag prefix is uix.

For more information, refer to the Oracle9i JDeveloper online help, or their documentation on the Oracle Technology Network:

http://otn.oracle.com/products/jdev/content.html

Note: Because of the size of this library, tags are not described individually.

Table 1-12 Summary of UIX Tag Library  

Tag Group	Description of Group	Individual Tags
Border layout tags	This group includes tags to lay out indexed "children", specify the border above or below indexed children, and specify the border to the left or right of indexed children.	borderLayout bottom innerBottom innerEnd innerLeft innerRight innerStart innerTop left right top
Form tags	This group includes tags to create a browser input checkbox, display a menu-style list of input items, create a text field for entering dates and a button for selecting dates from a calendar, add a widget for uploading a file, create an HTML form in the page, add a value that will be submitted with a form, display a defined list of items for input, create a text field with a button for launching a list-of-values dialog, create a single option input field, insert a browser radio button, create a set of radio buttons, create a button to reset form content, insert a button for submitting a form, and create a single-line text field or multi-line text area.	checkBox choice dateField fileUpload form formValue list lovField option radioButton radioGroup resetButton submitButton textInput
Layout tags	This group includes tags to lay out children horizontally or vertically.	flowLayout stackLayout
Page tags	This group consists of numerous tags to create and manipulate page content. Among many other functions, this includes inserting a trail of links back to the home page, building a UIX tree and saving it to the page context, inserting buttons, placing ancillary information on the page, creating a copyright or corporate branding section, inserting page footer links, adding a banner that can contain links for site navigation, placing labels, inserting images, inserting a text link, applying a template to the page, and inserting a CSS stylesheet.	body breadCrumbs buildTree button case cobranding contentContainer contentFooter contents copyright corporateBranding dataScope document end footer globalButton globalButtonBar globalButtons globalHeader header image inlineMessage labeledFieldLayout largeAdvertisement leading leadingFooter link location mediumAdvertisement messageBox messagePrompt messageStyledText navigationBar pageButtonBar pageHeader pageLayout privacy productBranding quickSearch rawText ref renderingContext separator shuttle sideNav
Page tags	(continued)	spacer start styleSheet styledText switcher tabBar tabs tip trailing trailingFooter train
Table tags	This group includes tags that, among other functions, let users add rows of data and see updated data totals, add formatting, encapsulate formatting information for a table column, render a selection column for multiple selection of rows, stamp column headers for sorting, and support editing and formatting of tabular data.	addTableRow cellFormat column columnFooter columnHeader columnHeaderStamp hideShow multipleSelection rowLayout singleSelection sortableHeader table tableDetail tableLayout totalRow
Validation tags	This group of tags is to insert validators and tags relating to validation.	date decimal onBlurValidater onSubmitValidater regExp wml

Oracle9i JDeveloper BC4J/UIX Tag Library

UIX JSP pages can include both BC4J data tags and BC4J UIX convenience tags that simplify the presentation of data.

The BC4J UIX convenience tags rely on an ApplicationModule data tag to get the data source from the BC4J application module. In addition to the BC4J UIX tags listed here, you can use the (non-UIX) BC4J tags in UIX JSP pages.

Table 1-13 summarizes the BC4J/UIX tags. The typical tag prefix is bc4juix.

For more information, refer to the Oracle9i JDeveloper online help, or their documentation on the Oracle Technology Network:

http://otn.oracle.com/products/jdev/content.html

Table 1-13 Summary of BC4J/UIX Tag Library  

Tag	Description	Attributes
AddTableRow	Renders a special "TableRow" that lets users add rows of data to the data source. The body can contain JSP content.	text rows destination
InputRender	Renders an input field from a data source to a page.	datasource dataitem
LabelStyledText	Binds styled text labels to the data source automatically.	datasource dataitem
NavigationBar	Binds the navigation bar to the data source automatically.	datasource
RenderValue	Displays data of special data types--such as images, audio, or video--using a field render specific to the data object type.	datasource dataitem
StyledText	Binds styled text to the data source automatically.	datasource dataitem styleClass accessKey destination
Table	Binds a table to the data source automatically. The body can contain JSP content.	datasource alternateText destination formSubmitted height width name nameTransformed proxied summary text value
TableDetail	Causes the detail column from the data source to be displayed. The body can contain JSP content.	(none)

Oracle9i Reports Tag Library

Oracle9i Reports tags integrate with data model objects that are used to create Oracle reports. The Reports custom tags allow you to quickly add report blocks and graphs to existing JSP files. These tags can be used as templates to enable you to build and insert your own data-driven Java component into a Reports HTML page.

An example of a custom JSP tag is the 3D Graphics charting component. Using a custom JSP tag, you can pass Reports data to the 3D application server, which creates an image of the chart. The custom JSP tag then returns HTML to reference the created image.

The report and objects tags, respectively, delimit and define the report block. Inside these tags, other custom tags define the content and the look and feel of the report data.

Table 1-14 summarizes the Reports tags. The typical tag prefix is rw.

For more information, refer to the Oracle9i Reports Developer online help, under "Reference/JSP Tags". You can also find more information about Reports on the Oracle Technology Network:

http://otn.oracle.com/products/reports/content.html

Table 1-14 Summary of Reports Tag Library  

Tag	Description	Attributes
report	Delimits a report object within a JSP page.	id parameters
objects	Modifies the report definition.	id
field	Provides formatting to render a single value source object in HTML.	id src breakLevel breakValue nullValue containsHtml formatMask formatTrigger
foreach	Loops through a data source group.	id src startRow endRow increment
getValue	Retrieves the name for a report object.	id src formatMask
graph	Defines a graph or chart.	id src groups dataValues series width height graphHyperlink
include	Reformats a top-level layout object into a simple HTML table.	id src format
seq	Defines a sequence of values.	name seq
seqval	Operates on a sequence of values defined by the seq tag.	ref op
id	Generates unique HTML IDs for row and column headers for compliance with the American Disabilities Act.	id breakLevel asArray
headers	Retrieves ID values generated by the id tag for row and column headers.	id src

Oracle9iAS Wireless Location (Spatial) Tag Library

Developers of location-based applications need specialized services for the following:

• geocoding--associating geographical coordinates with addresses

• mapping--providing a graphical map for a point, set of points, route, or driving maneuver

• routing--providing driving directions

• business directories ("yellow pages")--listing businesses by region by either category or name

• traffic--providing information about accidents, construction, and other incidents that affect traffic flow

The Oracle9iAS Wireless location application components are a set of APIs for performing geocoding, providing driving directions, and looking up business directories. Service proxies are included that map existing important providers to the APIs, and additional providers are expected to be accommodated in the future.

For JSP developers, a tag library is provided, as summarized in Table 1-15. The typical tag prefix is loc.

For more information, refer to the Oracle9iAS Wireless Developer's Guide.

Table 1-15 Summary of Location (Spatial) Tag Library  

Tag	Description	Attributes
address	For a geocoding, mapping, or routing application, this specifies an address to be geocoded, located on a map, or used as the start or end address of a route, or as the center for a business directory query.	name type businessName firstLine city state postalCode country
map	For a mapping application, this specifies a map with a specified resolution, showing one of the following: one or more points, a route, or a driving maneuver.	name type points route maneuver xres yres
route	For a routing application, this specifies a route with a specified map resolution. It includes maneuvers, an overview map, and maneuver maps.	name type xres yres
iterateManeuvers	For a routing application, this creates a collection of driving maneuvers, presenting the maneuvers individually.	name type routeID
businesses	For a business directory application, this specifies a collection of businesses that share one or more attributes.	name type businessName categoryID keyword city state postalCode country centerID radius nearestN
iterateBusinesses	For a business directory application, this presents individually the businesses in a collection returned by the businesses tag.	name type collection
category	For a business directory application, this specifies a business category, such as "dealers".	name type parentCategory categoryName
iterateCategoriesMatchingKeyword	For a business directory application, this creates a collection of categories that match a specified keyword value, and presents the categories individually.	name type parentCategory keyword
iterateChildCategories	For a business directory application, this specifies a collection of immediate "child" subcategories, presented individually.	name type parentCategory

Oracle9iAS Ultra Search Tag Library

Oracle9iAS Ultra Search provides a custom tag library for use by developers in incorporating content search functionality into JSP applications. The library includes the following functionality:

• the ability to retrieve search attributes, groups, languages, and lists of values (LOVs) for rendering the advance query form

• the ability to iterate through the resulting hit set, and retrieve document attributes and properties for rendering the result page

• the ability to perform a search with "relevance boosting" and an estimation of the total hit count

The tag library is summarized in Table 1-16. The typical tag prefix is US.

For more information, refer to the Ultra Search online documentation, under "Ultra Search JSP Tag Library".

Table 1-16 Summary of Ultra Search Tag Library  

Tag	Description	Attributes
instance	This tag establishes a connection to an Ultra Search instance.	instanceId username password url dataSourceName tablePagePath emailPagePath filePagePath
iterAttributes	For an advanced query, use this tag to show the list of attributes that are available.	instance locale
iterGroups	For an advanced query, use this tag to show the list of groups that are available.	instance locale
iterLanguages	For an advanced query, use this tag to show the list of languages defined in the Ultra Search instance.	instance
iterLOV	Use this tag to show all values defined for a search attribute.	instance locale attributeName attributeType
getResult	Use this tag to perform the search.	resultId instance query queryLocale documentLanguage from to boostTerm withCount
fetchAttribute	This is a nested tag within getResult to specify which attributes of each document should be fetched along with the query results. There can be multiple fetchAttribute tags nested inside a getResult tag.	attributeName attributeType
showHitCount	If withCount="true" in the getResult tag, then the result includes a total number of hits and you can use showHitCount to display this number.	result
iterResult	This tag iterates through all the documents in the search results. Use this to present the results in the JSP page.	result instance
showAttributeValue	Renders a document attribute.	attributeName attributeType default

Oracle9iAS Portal Tag Library

With Oracle9iAS Portal, developers can accomplish the following:

• Build and deploy Internet portals to deliver relevant information and applications to customers, employees, and partners.

• Develop portals rapidly, without code, using productive online tools.

• Increase user productivity with single sign-on and self-service publishing.

• Add value quickly with over 250 prebuilt portlets based on open standards.

The Oracle9iAS Portal tag library provides further convenience for developers building customizable Internet portals. A developer can create internal JSP pages, which are stored inside the Portal database and downloaded when the portal is executed, or external JSP pages, which are stored in the file system, or some combination.

The tag library is summarized in Table 1-17. The typical tag prefix is portal.

For more information, refer to the document Oracle9i Application Server Portal: Adding JSPs, available through the Oracle Technology Network:

http://otn.oracle.com

Table 1-17 Summary of Portal Tag Library  

Tag	Description	Attributes
usePortal	Use this to specify the overall portal, which forms the framework of the Web page and contains portlets that have the dynamic content. This must be the first Portal tag in a JSP page.	id pagegroup login
prepare	Use this to set up a bundle of one or more portlets that will be displayed within the portal.	portal portletHeaders
portlet	Use one or more of these tags inside a prepare tag to declare the portlets to be displayed.	id instance header
showPortlet	Use this to display a portlet--typically, but not necessarily, a portlet that was declared through a portlet tag. In its simplest usage, however, the showPortlet tag itself specifies the portlet to display.	name portal header
parameter	Use this inside a portlet or showPortlet tag to specify a parameter setting for a portlet. (For example, for a stock-quote portlet, specify the stock to quote.)	name value
useStyle	Specify a CSS style to use for the portal, or use the default style. (Alternatively, do not use this tag at all and implement the desired style by other means.)	name portal