About OJSP Tag Libraries and Utilities

This topic documents tag libraries, JavaBeans, and other utilities supplied with OC4J that are implemented according to JSP standards. There is also a discussion of support for the JavaServer Pages Standard Tag Library (JSTL), and 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, standard JSP technology, and standard JSP 1.2 tag library features, are covered in the Oracle Application Server Containers for J2EE Support for JavaServer Pages Developer's Guide 10g.

This topic covers the following topics:

• Overview of Tag Libraries and Utilities Provided with OC4J

• Summary of Oracle Caching Support for Web Applications

• Support for the JavaServer Pages Standard Tag Library

• Overview of Tag Libraries from Other Oracle Application Server 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 tag libraries or custom JavaBeans that comply with JSP and JavaBeans standards.

Here is a list of the topics covered:

• Tag Syntax Symbology and Notes

• Overview of Integration with XML and XSL

• Summary of Data-Access JavaBeans and Tag Library

• Summary of JSP Utility Tags

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 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.

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 "About XML and XSL Tag Support".

You can find information about standard JSP 1.2 XML support in the Oracle Application Server Containers for J2EE Support for JavaServer Pages Developer's Guide 10g.

Table 1-1 Summary of XML Utility Tags  

Summary of 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  

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, optionally with server-side or client-side attachments, you can use the oracle.jsp.webutil.email.SendMailBean JavaBean or the sendMail tag. Table 1-6 summarizes the sendMail tag. See "Mail JavaBean and Tag" for more information.

Table 1-6 Summary of sendMail Tag  

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-7 summarizes the file access tags. For more information see "File-Access JavaBeans and Tags".

Table 1-7 Summary of File Access Tag Library  

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

Table 1-8 Summary of EJB Tag Library  

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-9 summarizes these tags. See "General Utility Tags" for more information.

Table 1-9 Summary of General Utility Tag Library  

Summary 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

The Oracle tag libraries introduced in this section are JSP standards-compliant.

Oracle Application Server and JSP Caching Features

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

• OracleAS 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 OracleAS 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 enables 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 OracleAS Web Cache, as well as detailed documentation of the JESI tag library, see "About JESI Tags for Edge Side Includes".

  For additional information about the OracleAS Web Cache, see the Oracle Application Server Web Cache Administration and Deployment Guide 10g.

• 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 enables 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 "About 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 the Oracle Application Server Containers for J2EE Services Guide 10g.

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 Oracle Application Server Java Object Cache works at the Java object level, but is not integrated with HTTP. As for the OracleAS 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. (OracleAS 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 OracleAS Web Cache.

The Web Object Cache does not replace or eliminate the need for either the OracleAS Web Cache or the Oracle 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 OracleAS Web Cache together in the same page.

Web Object Cache Versus Oracle Application Server Web Cache

Think of the OracleAS 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 OracleAS 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 OracleAS 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 OracleAS Web Cache alone.

As a complement to the OracleAS 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 Oracle Application Server Java Object Cache

In comparison to the Oracle 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 OracleAS 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-10 summarizes the JESI tag library. See "Oracle JESI Tag Descriptions" for more information.

Table 1-10 Summary of JESI Tag LIbrary  

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 page 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-11 summarizes the Web Object Cache tag library. See "Web Object Cache Tag Descriptions" for more information.

Table 1-11 Summary of Web Object Cache Tag LIbrary  

Support for the JavaServer Pages Standard Tag Library

With Oracle9iAS release 2 (9.0.3), the OC4J JSP product supports the JavaServer Pages Standard Tag Library (JSTL), as specified in the Sun Microsystems JavaServer Pages Standard Tag Library, Version 1.0 specification. This section provides an overview of JSTL features and OC4J support, covering the following topics:

• Overview and Philosophy of JSTL

• Summary of JSTL Expression Language

• Overview of JSTL Tags and Additional Features

• JSTL in Oracle9iAS Release 2: Usage Notes and Future Considerations

As of the OC4J 9.0.3 implementation, JSTL is not yet directly included with the OC4J product. You can download the reference implementation from:

http://jakarta.apache.org/builds/jakarta-taglibs/releases/standard/

For information about using this JSTL reference implementation with the OC4J demo applications, refer to the JSP FAQ document, available through:

http://otn.oracle.com/tech/java/oc4j

For complete information about JSTL, refer to the specification at the following location:

http://www.jcp.org/aboutJava/communityprocess/first/jsr052/index.html

Overview and Philosophy of JSTL

JSTL is intended as a convenience for JSP page authors who are not familiar or not comfortable with scripting languages such as Java. Historically, scriptlets have been used in JSP pages to process dynamic data. With JSTL, the intent is for JSTL tag usage to replace the need for scriptlets.

Readers who have used previous versions of the OC4J JSP product will recognize this as similar to the goals of the Oracle JavaServer Pages Markup Language (JML) tag library. While the JML tag library is still supported, use of the standard JSTL is encouraged. Also see "JSTL in Oracle9iAS Release 2: Usage Notes and Future Considerations".

Key JSTL features include the following:

• JSTL expression language (EL)

  The expression language further simplifies the code required to access and manipulate application data, making it possible to avoid request-time expressions as well as scriptlets. See the next section, "Summary of JSTL Expression Language".

• core tags for expression language support, conditional logic and flow control, iterator actions, and accessing URL-based resources

• tags for XML processing, flow control, and XSLT transformations

• SQL tags for database access

• tags for i18n-capable internationalization and formatting

  (The term "i18n" refers to an internationalization standard.)

Tag support is broken into four JSTL sublibraries according to the preceding functional areas. Table 1-12 shows the standard TLD URI and prefix for each sublibrary.

Table 1-12 JSTL Sublibraries

See "Overview of JSTL Tags and Additional Features" for more information.

Summary of JSTL Expression Language

The JSTL expression language makes use of the fact that JSP scoped attributes and request parameters are the preferred vehicles for passing information to and from JSP pages. By using the JSTL expression language, you can avoid having to use JSP scriptlets and request-time expressions.

In JSTL 1.0, the expression language can be used only in JSTL tag attribute values.

As an example, consider the following use of the JSTL c:if tag to pick out steel-making companies from a company list:

<c:if test="${company.industry == 'steel'}">
   ...
</c:if>

The rest of this section summarizes JSTL expression language syntax and documents how to enable JSTL expression language evaluation in your OC4J JSP applications.

JSTL Expression Language Syntax

This following list offers a brief summary of key syntax features of the JSTL expression language. This is followed by a few simple examples.

• invocation

  The JSTL expression language is invoked through ${expression} syntax. The most basic semantic is that invocation for a named variable ${foo} yields the same result as the method call PageContext.findAttribute(foo).

• data structure access

  To access data within JavaBeans and within collections such as lists, maps, and arrays, the expression language supports the "." and "[]" constructs. The "." construct allows access to properties whose names are standard Java identifiers. The "[]" construct is for more generalized access, but for valid Java identifiers is equivalent to the "." construct. The expressions foo.bar and foo["bar"] yield the same result.

• relational operators

  The expression language supports the relational operators == (or eq), != (or ne), < (or lt), > (or gt), <= (or le), >= (or ge).

• arithmetic operators

  The expression language supports the arithmetic operators +, -, *, / (or div), % (or mod, for remainder or modulo).

• logical operators

  The expression language supports the logical operators && (or and), || (or or), ! (or not), empty.

Example: Basic

The following example shows fairly basic invocations of the expression language, including the relational "<=" (less than or equal to) operator.

<c:if test="${auto.price <= customer.priceLimit}">
   The <c:out value="${auto.makemodel}"/> is in your price range.
</c:if>

Example: Accessing Collections

The following example, from the Sun Microsystems JavaServer Pages Standard Tag Library, Version 1.0 specification, shows use of the "." and "[]" constructs.

<%-- "productDir" is a Map object containing the description of
      products, "preferences" is a Map object containing the
      preferences of a user --%>
product:
<c:out value="${productDir[product.custId]}"/>
shipping preference:
<c:out value="${user.preferences['shipping']}"/>

JSTL Expression Language Implicit Objects

JSTL offers the following implicit objects:

• pageScope--Allows access to page-scope variables.

• requestScope--Allows access to request-scope variables.

• sessionScope--Allows access to session-scope variables.

• applicationScope--Allows access to application-scope variables.

• pageContext--Allows access to all properties of the page context of a JSP page.

• param--This is a Java Map object where param["foo"] returns the first string value associated with the request parameter foo.

• paramValues--paramValues["foo"] returns an array of all string values associated with request parameter foo.

• header--Similarly to using param, you can use this to access the first string value associated with a request header.

• headerValues--Similarly to using paramValues, you can use this to access all string values associated with a request header.

• initParam--Allows access to context initialization parameters.

• cookie--Allows access to cookies received in the request.

JSTL Expression Language Additional Features

The expression language also offers the following features:

• It can provide default values where failure to evaluate an expression is considered to be recoverable.

• Where application data might not exactly match the type expected by a tag attribute or expression language operator, there are rules to convert the type of the resulting value to the expected type.

See the JSTL 1.0 specification for information.

Overview of JSTL Tags and Additional Features

This section provides a summary of JSTL tags and discusses some additional JSTL features. The following topics are covered:

• Scoped Variables

• Configuration Data and the Config Class

• JSTL Tag Summary

Scoped Variables

JSTL tags make data available through JSP scoped attributes, referred to as scoped variables, which are used in place of scripting variables. JSTL tags that can make data available in this way have var and scope among their attributes, used as follows:

• var--Specify the variable that is to be exposed.

• scope--Specify the scope of the variable, either page (default), request, session, or application.

The scope attribute would not be relevant for NESTED variables (which would always have page scope), but variables in the JSTL are AT_END (available from the end-tag to the end of the page).

The following example uses the core library iterator action tag forEach and expression language support tag out to expose the current item of an employees collection:

<c:forEach var="employee" items="${customers}">
   The current employee is <c:out value="${customer}"/>
</c:forEach>

Configuration Data and the Config Class

JSTL includes functionality to dynamically override JSP configuration data for a particular scope, through a scoped variable. You can accomplish this using functionality of the javax.servlet.jsp.jstl.core.Config class.

According to the JSP 1.2 specification, all scopes (page, request, session, and application) that exist within a JSP page context should together form a single namespace; that is, the name of a scoped variable should be unique across execution of a page.

The Config class has functionality to transparently manipulate configuration parameter names to produce the effect that each scope has its own namespace. Effectively, this enables you to set a configuration parameter for a particular scope only.

See the JSTL 1.0 specification for information.

JSTL Tag Summary

Table 1-13 summarizes the JSTL tags, organized into functional groupings. The JSTL standard tag prefix is noted for each group.

Table 1-13 Summary of JavaServer Pages Standard Tag Library  

http://www.w3.org/TR/xpath

JSTL in Oracle9iAS Release 2: Usage Notes and Future Considerations

Be aware off the following considerations:

• The JSTL expression language implementation might change somewhat in future versions of JSTL.

• The custom XML and SQL tag libraries provided with OC4J pre-date JSTL and have areas of duplicate functionality. Going forward, for standards compliance, it is advisable to use JSTL instead of the custom libraries as a general rule. Oracle is not desupporting the existing tags, however. For features in the custom libraries that are not yet available in JSTL, where there seems to be general usefulness, Oracle will try in the future to have the features adopted into the JSTL standard as appropriate.

• Refer to the ojsp/jstl demos in your OC4J installation for examples of JSTL usage. Also check the Oracle9iAS release 2 (9.0.3) release notes for system property settings that are required for some of the demos.

Overview of Tag Libraries from Other Oracle Application Server Components

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

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

• Oracle JDeveloper User Interface Extension (UIX) Tag Library

• Oracle JDeveloper BC4J/UIX Tag Library

• Oracle Reports Tag Library

• Oracle Application Server Wireless Location (Spatial) Tag Library

• Oracle Application Server Ultra Search Tag Library

• Oracle Application Server Portal Tag Library

The Oracle tag libraries introduced in this section are JSP standards-compliant.

The following discussion assumes some prior knowledge of the underlying components.

Oracle9i JDeveloper Business Components for Java (BC4J) Tag Library

Oracle9i JDeveloper provides a set of 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-14 summarizes the BC4J tag library. The typical tag prefix is jbo.

For more information, refer to the Oracle9i JDeveloper online help.

Table 1-14 Summary of BC4J Tag Library  

Oracle9i JDeveloper User Interface Extension (UIX) Tag Library

Oracle9i JDeveloper provides a set of 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-15 summarizes the UIX tag library. The typical tag prefix is uix.

For more information, refer to the Oracle9i JDeveloper online help.

Table 1-15 Summary of UIX Tag Library  

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-16 summarizes the BC4J/UIX tags. The typical tag prefix is bc4juix.

For more information, refer to the Oracle9i JDeveloper online help.

Table 1-16 Summary of BC4J/UIX Tag Library  

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-17 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-17 Summary of Reports Tag Library  

Oracle Application Server 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 and by either category or name

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

The OracleAS 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-18. The typical tag prefix is loc.

For more information, refer to the Oracle Application Server Wireless Developer's Guide 10g.

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

Oracle Application Server Ultra Search Tag Library

OracleAS 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-19. The typical tag prefix is US.

For more information, see the Oracle Ultra Search User's Guide. Alternatively, refer to the Ultra Search online documentation, under Ultra Search JSP Tag Library.

Table 1-19 Summary of Ultra Search Tag Library  

Oracle Application Server Portal Tag Library

With OracleAS 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 OracleAS 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-20. 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-20 Summary of Portal Tag Library