|Oracle9i Application Server Application Developer's Guide
Release 2 (9.0.2)
Part Number A95101-01
When you create applications to be deployed on Oracle9i Application Server, you might think of different ways to implement a feature. This guide walks you through the design and implementation of a sample application, and in the process of doing so, it discusses the available options for each feature and the advantages and disadvantages of each option.
The resulting application is modular and extensible: you can easily add features, add different client types (including wireless devices), and change the implementation of a feature with minimal impact on other features.
The sample application used in this guide is called "Employee Benefit Application". It enables users to view data such as employee name, phone, email, and job ID. Users can also add or remove their benefit elections. The application retrieves and updates data in an Oracle database.
The sample application makes use of many different technologies, including JavaServer Pages, servlets, Enterprise JavaBeansTM, JDBC, portals, wireless devices, web cache, web services, JNDI, and JAAS.
Contents of this chapter:
The Oracle9iAS platform supports many technologies; as a result, you have many choices when you design and create your applications. The following sections describe some of these key technologies.
The J2EE support includes:
Servlets and JSPs run within a "web container", which also provides services similar to those provided by the EJB container.
For complete J2EE details (including specifications), see:
Portals in Oracle9iAS enable you to aggregate, or group, your applications into a single web page. When users visit the page, they get a centralized location where they can see only the applications to which they have access with single sign-on capabilities. These applications, when displayed within a portal framework, are called portlets.
Figure 1-1 shows a picture of a portal.
Browser clients do their rendering based on HTML tags, and there is more or less a standard set of tags and attributes that you can use. Wireless clients, on the other hand, understand different sets of tags and attributes, depending on the wireless device, and speak different protocols.
To make it easy for application developers, the wireless feature in Oracle9iAS comes with adaptors and transformers. This enables you to write your application once, and provide access to it from any wireless device. The way this works is that you write the presentation data in XML according to a standard DTD (document type definition), and the adaptors convert the XML on the fly to the markup language preferred by the client.
You can write your application such that it supports both browsers and wireless devices. Your application can check if a request is coming from a wireless client and return the appropriate response (HTML or XML). The sample application shows how to do that. See Chapter 7, "Supporting Wireless Clients" for details.
Figure 1-2 shows the Employee Benefit application running on a cell phone:
Designing and developing an application with all these technologies can be a little overwhelming. Here are some high-level steps to guide you (later chapters in this book provide the details):
Be sure to separate the presentation (or client) tier requirements from the business logic tier requirements. Separating the requirements by tier helps you design your application in a modular fashion. Modularity promotes a clean separation of functionality and enables you to reuse, update, or replace modules without affecting the rest of the application.
See Section 2.1, "Requirements for the Sample Application" for details.
It helps to draw a sketch of the design based on the interfaces. Also determine how the client tier can invoke methods in the objects.
When you determine what objects you need, you have many implementation choices. For example, you can use servlets, JavaBeans, Enterprise JavaBeans, or plain Java classes to implement your business logic.
See Chapter 4, "Implementing Business Logic" for details.
The presentation data determine how the application looks to the users. Typically, the presentation data is in HTML (for browsers) or XML (for wireless devices). The HTML or XML tags can come from static files, JSPs, or other Java classes.
JSPs and other Java classes can output the presentation data programmatically. In JSP files, you embed commands to invoke methods on the Java objects that implement your business logic. You can then display the values that the methods return.
See Chapter 5, "Creating Presentation Pages" for details.
You can do this with EJBs, servlets, or other Java classes.
See Chapter 4, "Implementing Business Logic" for details.
To create applications for Oracle9iAS, you can use text editors such as emacs or vi, or you can use IDEs (integrated development environment).
If you use a text editor, you also need additional tools such as a Java compiler (for example, javac), a Java archive tool (for example, jar), and a packaging tool so that you can compile your files and build JAR and EAR files.
If you use IDEs, they can automate the tasks listed above for you. Oracle provides an IDE called Oracle9i JDeveloper. JDeveloper has support for each stage in the development lifecycle: it contains UML modelling and generation tools, debugging tools, profiling tools, and tuning tools.
JDeveloper is closely integrated with Oracle9iAS: you can deploy applications on Oracle9iAS from JDeveloper.
This guide shows a complete application, clients (browsers and wireless devices), and database schema. It describes the logic behind the application design.
It also shows how to deploy/configure the application.
It does not describe the details for the APIs that the application uses. For that information, refer to the Oracle9iAS J2EE Users Guide.
This guide assumes the reader has some concept of servlets, JSPs, portals, web services, wireless devices, and introductory knowledge of EJBs. If you need more information on these topics, see the Oracle9iAS library for a list of books.
To read the Java specifications, see: