Oracle Application Server Containers for J2EE JSP Tag Libraries and Utilities Reference 10g (9.0.4) Part Number B10319-01 |
|
This manual documents tag libraries, JavaBeans, and other utilities supplied with Oracle Application Server Containers for J2EE (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 Oracle components outside of OC4J.
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.
This chapter consists of the following sections:
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.
Note: The Sample Applications chapter available in previous releases has been removed. Applications that were listed there are available in the OC4J demos, available from the following location on the Oracle Technology Network (requiring an OTN membership, which is free of charge): http://otn.oracle.com/tech/java/oc4j/demos/ |
The Oracle extensions that are introduced in the following sections are implemented through tag libraries or custom JavaBeans that comply with JSP and JavaBeans standards.
Be aware that some custom tag libraries provided with OC4J--XML, data-access, and JML--pre-date the JavaServer Pages Standard Tag Library (JSTL) and have areas of duplicate functionality. For standards compliance, it is now generally advisable to use JSTL instead of these custom libraries. See "Support for the JavaServer Pages Standard Tag Library".
Oracle is not desupporting the existing libraries, however. For features in the custom library that are not yet available in JSTL, where there seems to be general usefulness, Oracle will try to have the features adopted into the JSTL standard as appropriate.
Notes:
|
For the syntax documentation in tag descriptions throughout this manual, note the following:
[...]
<%=
jspExpression %>"
taglib
directives.
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:
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.
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".
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 with JspScopeListener".
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:
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 standard JSP 1.2 XML support in the Oracle Application Server Containers for J2EE Support for JavaServer Pages Developer's Guide.
OC4J supplies a set of custom JavaBeans for use in accessing Oracle 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".
Although the JSP specification 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".
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". |
Web site personalization is a mechanism to tailor 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.
OracleAS Personalization uses data mining algorithms in Oracle Database to choose the most relevant content available for a user. Recommendations are calculated by an OracleAS 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 OracleAS 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 Java API of the recommendation engine.
Table 1-4 summarizes the OracleAS Personalization tag library. See Chapter 10, "Personalization Tags" for information.
The Web services tag library provided with OC4J enables developers to conveniently create JSP pages for Web service client applications. The implementation uses a SOAP-based mechanism, supporting RPC-style or document-style services. A client application would access a Web Services Description Language (WSDL) document, then use the WSDL information to access the operations of a Web service.
The tag library also uses the Oracle implementation of the dynamic invocation API, described in the Oracle Application Server Web Services Developer's Guide. When a client application acquires a WSDL document at runtime, the dynamic invocation API is the vehicle for invoking any SOAP operation described in the WSDL document.
The Web services tag library is summarized in Table 1-5. For more information, see Chapter 11, "Web Services Tags".
OC4J provides tag libraries for file access (uploading and downloading) and for sending e-mail messages from an application.
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".
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-7 summarizes the sendMail
tag. See "Mail JavaBean and Tag" for more information.
OC4J provides a custom tag library to simplify the use of Enterprise JavaBeans in JSP pages. The functionality of the OC4J EJB tags follows the J2EE specification. The tags allow you to instantiate EJBs by name, using configuration information in the web.xml
file.
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.
OC4J has 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.
This section provides the following information:
The Oracle tag libraries introduced in this section comply with JSP standards.
Note: See the OC4J demos for sample applications using the features introduced in this section. The can be downloaded from the following location on the Oracle Technology Network: http://otn.oracle.com/tech/java/oc4j/demos/ |
The Oracle Application Server and OC4J provide the following caching features:
This is an HTTP-level cache, maintained outside the application, providing very fast cache operations. It is a 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 content-based cache outside the application, it cannot cache objects (such as Java objects or XML DOM objects) in a Java object format. In addition, post-processing operations applicable to cached data cannot be coded in Java and are predefined by the cache itself.
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 separate cacheable pages into distinct 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 Chapter 6, "JESI Tags for Edge Side Includes".
For additional information about the OracleAS Web Cache, see the Oracle Application Server Web Cache Administrator's Guide.
This is an application-level cache that is 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 page fragment can produce a separate 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 request and session semantics. Alternatively, they can be reused outside HTTP, such as when an application outputs 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".
The Oracle Application Server Java Object Cache is a general-use Java 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 can significantly improve application performance. By default, the OC4J Web Object Cache uses the Oracle Application Server Java Object Cache as its underlying cache repository.
For details about the Java Object Cache, see the Oracle Application Server Containers for J2EE Services Guide.
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 orders of magnitude faster than the Web Object Cache, but it does not operate at the Java level and cannot be directly invoked by Web application code. For example, it cannot apply a style sheet 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 style sheet to text-based 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.
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 speed up response and 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 can repeatedly reuse objects after they are cached and you require post-processing on cached objects before they are served to a client.
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 any HTTP environment in which it might be embedded. For example, its cache keys do not automatically 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 with resulting Web pages. The Java Object Cache provides only a programmatic way to specify cache maintenance policies, whereas the Web Object Cache allows the alternative of specifying policies through configuration files.
OC4J supplies two tag libraries for use with Oracle Application Server caching features:
This section summarizes those libraries.
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.
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. The programming interfaces it provides are 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.
With Oracle Application Server 10g (9.0.4), the OC4J JSP product includes an implementation of the JavaServer Pages Standard Tag Library (JSTL), as specified in the Sun Microsystems JavaServer Pages Standard Tag Library, Version 1.0 specification. The following sections provide an overview of JSTL features and OC4J support:
For complete information about JSTL, refer to the specification at the following location:
http://www.jcp.org/aboutJava/communityprocess/first/jsr052/index.html
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 Usage Notes and Future Considerations".
Key JSTL features include the following:
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".
(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.
See "Overview of JSTL Tags and Additional Features" for more information.
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.
This following list offers a brief summary of key syntax features of the JSTL expression language. This is followed by a few simple examples.
The JSTL expression language is invoked through ${
expression
}
syntax. The most basic semantic is that invocation of a named variable ${foo}
yields the same result as the method call PageContext.findAttribute(foo)
.
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, for example.
The expression language supports the relational operators ==
(or eq
), !=
(or ne
), <
(or lt
), >
(or gt
), <=
(or le
), >=
(or ge
).
The expression language supports the arithmetic operators +
, -
, *
, /
(or div
), %
(or mod
, for remainder or modulo).
The expression language supports the logical operators &&
(or and
), ||
(or or
), !
(or not
), empty
.
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>
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 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
: Use paramValues["foo"]
, for example, to return 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.
The expression language also offers the following features:
See the JSTL 1.0 specification for information.
The following sections provide a summary of JSTL tags and discuss some additional JSTL features:
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
: the variable that is to be exposed
scope
: 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>
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 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.
Table 1-13 summarizes the JSTL tags, organized into functional groups. The JSTL standard tag prefix is noted for each group.
Note: JSTL tags for XML processing are based on XPath (XML Path), a W3C recommendation. XPath provides a concise notation for specifying and selecting parts of an XML document. Refer to the following Web site for information: http://www.w3.org/TR/xpath |
Be aware off the following considerations:
http://jakarta.apache.org/taglibs/doc/standard-doc/intro.html
A number of other Oracle components, outside OC4J, provide JSP tag libraries. The following sections summarize these libraries:
The Oracle tag libraries introduced in this section comply with JSP standards.
The following discussion assumes some prior knowledge of the underlying components.
Oracle JDeveloper provides a set of custom tags known as Oracle Business Components for Java (BC4J) data tags. BC4J data tags provide a simple tag-based approach for interaction with business components data sources. The tags provide complete access to business components and allow viewing, editing, and full DML control.
Custom data tags allow simplified interaction with BC4J data sources. The tag-based approach to building JSP applications with BC4J does not require extensive Java programming and is very much like coding an HTML page.
Table 1-14 summarizes the BC4J tag library. The default or typical tag prefix is jbo
, but you can change this in your taglib
directives.
For more information, refer to the Oracle JDeveloper online help or to the following location on the Oracle Technology Network:
http://otn.oracle.com/products/jdev/content.html
Oracle 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 JSP Border Layout, UIX JSP Form, UIX JSP Layout, UIX JSP Message Components, UIX JSP Page Layout, UIX JSP Simple Components, and UIX JSP Table.
Table 1-15 summarizes the UIX tag library. The default or typical tag prefix is uix
, but you can change this in your taglib
directives.
For more information, refer to the Oracle JDeveloper online help or to the following location on the Oracle Technology Network:
http://otn.oracle.com/products/jdev/content.html
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 JSP tags. The default or typical tag prefix is bc4juix
, but you can change this in your taglib
directives.
For more information, refer to the Oracle JDeveloper online help or to the following location on the Oracle Technology Network:
http://otn.oracle.com/products/jdev/content.html
Oracle Reports consists of Oracle Reports Developer (a component of the Oracle Developer Suite) and Oracle Reports Services (a component of the Oracle Application Server). The Oracle Reports Developer includes tags integrated with data model objects that are used to create JSP reports. The Oracle 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 an HTML page for a JSP-based Web report.
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 custom JSP tags for Oracle Reports. By default, these tags use the rw
prefix, but you can change this in your taglib
directives.
For more information, refer to the Oracle Reports Developer online help, available through the Help menu in Reports Builder. You can also find more information about Oracle Reports on the Oracle Technology Network:
http://otn.oracle.com/products/reports/content.html
Developers of location-based applications need specialized services for the following:
The OracleAS Wireless location application components compose an API for performing geocoding, providing driving directions, and looking up business directories. Service proxies are included that map existing key providers to the API, and additional providers are expected to be accommodated in the future.
For JSP developers, a tag library is provided. Table 1-18 summarizes the library, organizing tags by the types of applications for which they are used. The default or typical tag prefix is loc
, but you can change this in your taglib
directives.
For more information, refer to the Oracle Application Server Wireless Developer's Guide.
The OracleAS MapViewer is a programmable tool for rendering maps using spatial data managed by Oracle Spatial or Oracle Locator (also referred to as Locator). OracleAS MapViewer provides tools that hide the complexity of spatial data queries and cartographic rendering, while providing customizable options for more advanced users. These tools can be deployed in a platform-independent manner and are designed to integrate with map-rendering applications.
For convenience, OracleAS MapViewer includes a JSP tag library that you can use to submit map requests.
The tag library is summarized in Table 1-19. The default or typical tag prefix is mv
, but you can change this in your taglib
directives.
For more information, see the Oracle Application Server MapViewer User's Guide.
Oracle 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 tag library is summarized in Table 1-20. The default or typical tag prefix is US
, but you can change this in your taglib
directives.
For more information, see the Oracle Ultra Search User's Guide. Alternatively, refer to the Oracle Ultra Search online documentation, under Oracle Ultra Search JSP Tag Library.
With OracleAS Portal, developers can accomplish the following:
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-21. The default or typical tag prefix is portal
, but you can change this in your taglib
directives.
For more information, refer to OracleAS Portal: Adding JSPs, available through the Oracle Technology Network:
http://otn.oracle.com/documentation
The Oracle Business Intelligence Beans (Oracle BI Beans) product consists of Java components, utilities, and a JSP tag library that enable rapid development of analytical applications. Oracle BI Beans applications leverage the capabilities of OLAP in Oracle Database. Using Oracle BI Beans, you can develop both HTML-client and Java-client applications.
Oracle BI Beans includes the following groups of Java components:
For further developer convenience, Oracle BI Beans includes a JSP tag library. You can use JDeveloper to create Oracle BI Beans JSP pages. A JDeveloper wizard prompts you for information related to the tag that you want to use and inserts the coded tag in the JSP page.
The Oracle BI Beans tags are categorized as follows:
BIThinSession
, Render
, InsertHiddenFields
ExplorerDetail
, ExplorerQuickSearch
, ExplorerTree
, SearchTool
Presentation
, Toolbar
, FavoriteTool
, RotateTool
, SortTool
, ViewType
DialogLink
, ApplyButton
, CancelButton
, SaveButton
, ExportOptions
, FindMember
, PrintOptions
, PrinterFriendlyView
, SaveAs
, SaveConfirmation
Table 1-22 summarizes the individual tags. The default or typical tag prefix is orabi
, but you can change this in your taglib
directives.
For more information, refer to the Oracle BI Beans online help. Under "Building Web Modules", click "Using JSP Tags", then "List of BI Beans JSP Tags".
Oracle Application Server provides the Multimedia Tag Library, a custom JSP tag library for use by developers and Web page authors when generating multimedia HTML tags in JSP pages and uploading multimedia data into interMedia objects.
Oracle interMedia enables Oracle Database to store, retrieve, manage, and manipulate images, audio, video, and other media data, while integrating it with other enterprise information. Specifically, Oracle interMedia supports media storage, media retrieval, media management, and manipulation of media data managed by Oracle and stored in binary large objects, file-based large objects, URLs that contain media data, and specialty servers. Oracle interMedia is accessible to applications through relational and object interfaces.
Oracle interMedia uses object types that are similar to Java classes to describe media data. These interMedia objects have a common media data storage model. Oracle interMedia also provides Java classes to enable users to write Java applications using interMedia objects. There are also Oracle interMedia Java classes for servlets and JavaServer Pages to facilitate retrieving and uploading media data from and to Oracle Database instances.
The Multimedia Tag Library includes a set of tags for retrieving media data and a set for uploading media data. The Multimedia JSP tags for media retrieval include a set of common attributes and tag-specific media-render-attributes. The common attributes are: custom-retrieval-attributes, database-connection-attributes, media-access-attributes, media-cache-control-attributes, and table-and-column-attributes. The media-render-attributes are described with each media retrieval tag.
Table 1-23 summarizes the Multimedia JSP tags for media retrieval and lists the media-render-attributes for each tag.
Table 1-24 summarizes the Multimedia JSP tags for media upload.
See Oracle Application Server 10g Multimedia Tag Library for JSP User's Guide and Reference for additional information about the Multimedia JSP tags. That guide is a supplement to Oracle interMedia Reference, Oracle interMedia User's Guide, and Oracle interMedia Java Classes Reference.
|
Copyright © 2002, 2003 Oracle Corporation. All Rights Reserved. |
|