Release 2 (9.0.2)
Part Number A95882-01
 Home |
 Solution Area |
 Contents |
 Index |
| Oracle9iAS Containers for J2EE Support for JavaServer Pages Reference Release 2 (9.0.2) Part Number A95882-01 |
|
The JSP container provided with Oracle9iAS Containers for J2EE (OC4J) in the Oracle9i Application Server is a complete implementation of the Sun Microsystems JavaServer Pages Specification, Version 1.1, with support for some JSP 1.2 features as well. Complete JSP 1.2 support will follow in the near future.
This chapter provides overviews of the Oracle9i Application Server, OC4J, the OC4J JSP implementation and features, and portable tag libraries and utilities that are also supplied (documented in the Oracle9iAS Containers for J2EE JSP Tag Libraries and Utilities Reference).
The following topics are covered here:
This section provides a brief overview of the Oracle9i Application Server, its J2EE environment, its JSP implementation, and its Web server:
Oracle9i Application Server is a scalable, secure, middle-tier application server. It can be used to deliver Web content, host Web applications, connect to back-office applications, and make these services accessible to any client browser. Users can access information, perform business analysis, and run business applications on the Internet or corporate intranets or extranets. Major areas of functionality include Business Intelligence, e-Business Integration, J2EE Web Services, Performance and Caching, Portals, Wireless, and Management and Security.
To deliver this range of content and services, the Oracle9i Application Server incorporates many components, including the Oracle HTTP Server, Oracle9iAS Web Cache, Oracle9iAS Portal, Oracle9iAS Wireless, Oracle9iAS Forms Services and Reports Services (to support Oracle Forms-based applications and reports generation), Oracle9iAS Personalization, and various business logic runtime environments that support Enterprise JavaBeans, stored procedures, and Oracle Business Components for Java.
For its J2EE environment, Oracle9iAS provides the Oracle9iAS Containers for J2EE (OC4J), which includes the JSP container described in this manual, a servlet container, and an EJB container.
(In addition, Oracle9iAS includes an Apache JServ servlet environment, documented in Appendix B, "The Apache JServ Environment".)
OC4J is a high-performance J2EE-compliant environment providing a scalable and reliable server infrastructure by supporting clusters and load balancing. (See the Oracle9i Application Server Performance Guide for information about clustering.)
Each OC4J instance runs in a single Java virtual machine. The JVM running an OC4J instance is referred to as a node. One or more nodes--typically about two to four--form an island. Multiple islands together form a cluster. For each cluster, there is a JVM for each OC4J instance, plus a JVM for the load balancer.
In addition to load balancing, which improves performance by distributing requests among multiple servers, the clustering mechanism provides fault tolerance, which allows any particular server to redirect a client to another server in the event of failure.
OC4J also supports standard EAR/WAR deployment, provides a convenient auto-deployment feature, and supports the following services:
OC4J supplies the following containers:
The JSP bundle also supplies tag libraries to implement SQL access, caching capabilities, file access, and other features. For further overview of the JSP container provided with OC4J, see "Overview of the JSP Implementation in OC4J".
The OC4J servlet container supports the following features:
The OC4J EJB container supports the following features:
The JSP container in OC4J is compliant with the Sun Microsystems JSP 1.1 specification. It also offers selected JSP 1.2 features, with full 1.2 compliance to follow in the near future.
In addition, because the JSP 1.1 specification requires a servlet 2.1 or higher environment, the JSP container offers servlet 2.2 emulation for earlier environments, such as the Apache JServ servlet 2.0 environment. JServ is included with Oracle9iAS; however, OC4J is the recommended environment.
This section offers additional information on the following topics:
In Oracle9iAS release 1.0.2.2, the first release to include OC4J, there were two JSP containers: 1) a container developed by Oracle and formerly known as OracleJSP; 2) a container licensed from Ironflare AB and formerly known as the "Orion JSP container".
The OracleJSP container offered several advantages, including useful value-added features and enhancements such as for globalization and SQLJ support. The Orion container also offered advantages, including superior speed, but had disadvantages as well. It did not always exhibit standard behavior when compared to the JSP 1.1 reference implementation (Tomcat), and its support for internationalization and globalization was not as complete.
Oracle9iAS release 2 integrates the OracleJSP and Orion containers into a single JSP container known as the "OC4J JSP container". This container offers the best features of both previous versions, runs efficiently as a servlet in the OC4J servlet container, and is integrated with other OC4J containers as well. The integrated container primarily consists of the OracleJSP translator and the Orion container runtime, running with a newly simplified dispatcher and the OC4J 1.0.2.2 core runtime classes. The result is one of the fastest JSP engines on the market.
The OC4J JSP container adds new features in Oracle9iAS 9.0.2, including the following:
You have a choice of: 1) running JSP pages without any automatic reloading of classes or recompilation of JSP pages; 2) automatically reloading any classes that are used by the JSP page and have changed; or 3) automatically recompiling any JSP pages that have changed, as well as reloading any classes that have changed.
In "JSP Configuration Parameters", see the description of the main_mode parameter.
For single-threaded (non-thread-safe) JSP pages, page instances are pooled. There is no switch for this feature--it is always enabled.
To save time in tag handler creation and garbage collection, you can optionally enable pooling of tag handler instances. They are pooled in application scope. You can use different settings in different pages, or even in different sections of the same page. See "Disabling or Enabling Tag Handler Instance Pooling".
flush="false" setting for included pages (OC4J or JServ)
The current OC4J release does not fully support the JSP 1.2 specification, but does support the setting flush="false" for the jsp:include tag, as in the following example:
<jsp:include flush="false" page="foo.jsp" />
The JSP 1.1 specification supports only a flush="true" setting, which results in the buffer being flushed to the browser whenever a jsp:include tag is executed.
|
Note: Also see "Overview of Oracle Value-Added Features". |
The JSP container is provided as a component of OC4J, but is portable to other environments. Because of its servlet 2.2 emulation features, this includes pre-2.1 servlet environments, in particular the Apache JServ servlet 2.0 environment.
The servlet 2.0 specification was limited in that it provided only a single servlet context per Java virtual machine, instead of a servlet context for each application. The OC4J JSP servlet 2.2 emulation allows a full application framework in a servlet 2.0 environment, including providing applications with distinct ServletContext and HttpSession objects.
Because of this extended functionality, the OC4J JSP container is not limited by the underlying servlet environment.
In addition to JServ 1.1, the OC4J JSP container has been tested with Tomcat 3.1 (servlet 2.2) from the Apache Software Foundation, and JSWDK 1.0 (JavaServer Web Developer's Kit, servlet 2.1) from Sun Microsystems.
The JSP container in OC4J uses the front-end servlet oracle.jsp.runtimev2.JspServlet. See "JSP Configuration in OC4J".
For non-OC4J environments, including Apache JServ, use the old front-end servlet, oracle.jsp.JspServlet. See "Getting Started in a JServ Environment".
(The front-end servlet for the old Orion JSP container is com.evermind.server.http.JSPServlet, but its use is not recommended.)
Oracle HTTP Server, powered by the Apache Web server, is included with Oracle9i Application Server as the HTTP entry point for Web applications. By default, it is the front-end for all OC4J processes--client requests go through Oracle HTTP Server first.
When the Oracle HTTP Server is used, dynamic content is delivered through various Apache mod components provided either by the Apache Software Foundation or by Oracle. Static content is typically delivered from the file system, which is more efficient in this case. An Apache mod is typically a module of C code, running in the Apache address space, that passes requests to a particular mod-specific processor. The mod software will have been written specifically for use with the particular processor.
Oracle9iAS supplies the mod_oc4j Apache mod, which is used for communication between the Oracle HTTP Server and OC4J. It routes requests from the Oracle HTTP Server to OC4J processes, and forwards responses from OC4J processes to Web clients.
Communication is through the Apache JServ protocol (AJP). AJP was chosen over HTTP because of a variety of AJP features allowing faster communication, including use of binary format and more efficient processing of message headers.
The following features are provided with mod_oc4j:
This is accomplished through enhanced use of cookies. Routing information is maintained in the cookie itself to ensure that stateful servlets are always routed to the same OC4J JVM.
A mod_oc4j module can restart an OC4J instance automatically, if necessary.
|
Notes:
|
Visual Java programming tools now typically support JSP coding. In particular, Oracle9i JDeveloper supports JSP development and includes the following features:
See "Application Deployment with Oracle9i JDeveloper" for more information about JSP deployment support.
For debugging, JDeveloper can set breakpoints within JSP page source and can follow calls from JSP pages into JavaBeans. This is much more convenient than manual debugging techniques, such as adding print statements within the JSP page to output state into the response stream (for viewing in your browser) or to the server log (through the log() method of the implicit application object).
For information about JDeveloper, refer to the JDeveloper online help, or to the following site on the Oracle Technology Network:
http://otn.oracle.com/products/jdev/content.html
For an overview of JSP tag libraries provided with JDeveloper, see the Oracle9iAS Containers for J2EE JSP Tag Libraries and Utilities Reference.
OC4J value-added features for JSP pages can be grouped into three major categories:
The rest of this section provides feature overviews in each of these areas.
This section provides an overview of extended OC4J JSP features that are implemented through custom tag libraries and custom JavaBeans and classes that are generally portable to other JSP environments. These features are fully documented in the Oracle9iAS Containers for J2EE JSP Tag Libraries and Utilities Reference. Here is a summary list:
JspScopeListener for event-handling
JSP pages generally rely on core Java types in representing scalar values. However, neither of the following 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, you cannot declare them in a jsp:useBean action, because the wrapper classes do not follow the JavaBean model and do not provide a zero-argument constructor.
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.
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 handles session-based events only. You can integrate the Oracle JspScopeListener with HttpSessionBindingListener to handle session-based events, as well as page-based, request-based, and application-based events.
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:
For information about XML-related tags, refer to the Oracle9iAS Containers for J2EE JSP Tag Libraries and Utilities Reference.
OC4J supplies a set of custom JavaBeans for database access. 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.
OC4J provides a custom SQL tag library for database access. The following tags are provided:
dbOpen--Open a database connection. This tag also supports data sources and connection pooling.
dbClose--Close a database connection.
dbQuery--Execute a query.
dbCloseQuery--Close the cursor for a query.
dbNextRow--Process the rows of a result set.
dbExecute--Execute any SQL statement (DML or DDL).
dbSetParam--Set a parameter to bind into a dbQuery or dbExecute tag.
dbSetCookie--Set a cookie.
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 no doubt still 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, flow control, 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>
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.
OC4J provides utility tags to accomplish the following from within Web applications:
For sending e-mail messages, you can use the sendMail tag or the oracle.jsp.webutil.email.SendMailBean JavaBean.
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.
For using EJBs, there are tags to create a home instance, create an EJB instance, and iterate through a collection of EJBs.
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.
This section provides an overview of Oracle-specific programming extensions supported by the OC4J JSP container:
Dynamic server pages commonly include data extracted from databases. JSP developers typically rely on the standard Java Database Connectivity (JDBC) API or a custom set of database JavaBeans.
SQLJ is a standard syntax for embedding static SQL instructions directly in Java code, greatly simplifying database-access programming. The OC4J JSP container supports SQLJ programming in JSP scriptlets.
SQLJ statements are indicated by the #sql token. You can trigger the JSP translator to invoke the Oracle SQLJ translator by using the file name extension .sqljsp for the JSP source code file, or by specifying language="sqlj" in a page directive.
For more information, see "JSP Support for Oracle SQLJ".
In Oracle9iAS 9.0.2, the OC4J JSP container introduces a feature called global includes. You can use this feature to specify one or more files to statically include into JSP pages in (or under) a specified directory, through virtual JSP include directives. During translation, the JSP container looks for a configuration file, /WEB-INF/ojsp-global-include.xml, that specifies the included files and the directories for the pages.
This enhancement is particularly useful in migrating applications that had used globals.jsa or translate_params functionality in previous Oracle JSP releases. For more information, see "Oracle JSP Global Includes".
The Dynamic Monitoring System (DMS) adds performance-monitoring features to a number of Oracle9iAS components, including OC4J. The goal of DMS is to provide information about runtime behavior, using built-in performance measurements, so that users can diagnose, analyze, and debug any performance problems. DMS provides this information in a package that can be used at any time, including during live deployment. Data are published through HTTP and can be viewed with a browser.
The OC4J JSP container supports DMS features, calculating relevant statistics and providing information to DMS servlets such as the spy servlet and monitoring agent. Statistics include the following (using averages, maximums, and minimums, as applicable):
(Counts of JSP instances are applicable only for single-threaded situations, where isThreadSafe is set to false.)
Standard configuration for these servlets is in the OC4J global-web-application.xml configuration file. Use the Oracle Enterprise Manager to access DMS, for displaying DMS information and, as appropriate, altering DMS configuration.
OC4J supports special features for the servlet 2.0 JServ environment. It is highly advisable to migrate to the servlet 2.3 OC4J environment as soon as practical, but in the meantime, be aware of the following:
The referenced sections include migration information.
Faced with Web performance challenges, e-businesses must invest in more cost-effective technologies and services to improve the performance of their Internet sites. Web caching, the caching of both static and dynamic Web content, is a key technology in this area. Benefits of Web caching include performance, scalability, high availability, cost savings, and network traffic reduction.
OC4J provides the following support for Web caching technologies:
The Oracle9iAS Web Cache provides an ESI engine.
The Web Object Cache uses the Oracle9i Application Server Java Object Cache as its default repository.
These features are documented in the Oracle9iAS Containers for J2EE JSP Tag Libraries and Utilities Reference.
|
 Copyright © 2000, 2002 Oracle Corporation. All Rights Reserved. |
|