1
Creating Applications: Overview

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 JavaBeans^TM, JDBC, portals, wireless devices, web cache, web services, JNDI, and JAAS.

Contents of this chapter:

1.1 Overview of Oracle9iAS

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.

1.1.1 J2EE

The J2EE support includes:

Enterprise JavaBeans, which enable your applications to use entity, session, and message-driven beans. EJB comes with an EJB container that provides services for you. Services include transaction, persistence, and lifecycle management.
Servlets, which enable you to generate dynamic responses to web requests.
JavaServer Pages (JSP), which enable you to mix Java and HTML to author web applications easily. JSPs also enable you to generate dynamic responses to web requests.

Servlets and JSPs run within a "web container", which also provides services similar to those provided by the EJB container.
Java Authentication and Authorization Service (JAAS), which enables you to authenticate users (that is, it ensures that users are who they claim to be) and authorizes users (that is, it checks that the user has access to an object before executing or returning the object).
Java Message Service (JMS), which enables you to send and receive data and events asynchronously.
Java Transaction API (JTA), which enables your applications to participate in distributed transactions and access transaction services from other components.
J2EE Connector Architecture, which enables you to connect and perform operations on enterprise information systems.

For complete J2EE details (including specifications), see:

http://java.sun.com/j2ee

1.1.2 Enterprise Portals

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.

Figure 1-1 A portal page

Text description of the illustration portal.gif

1.1.3 Wireless Support

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:

Figure 1-2 An application running on a cell phone

Text description of da_intr2.gif follows

Text description of the illustration da_intr2.gif

1.2 Development Steps

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):

Determine application requirements.

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.
In the business logic tier, determine what objects you need and the interfaces of these objects.

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.
In the client tier, create the presentation data for the client.

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.
Implement the business logic.

You can do this with EJBs, servlets, or other Java classes.

See Chapter 4, "Implementing Business Logic" for details.
Package, deploy, and run your application.

1.3 Development Tools

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.

1.4 What This Guide Covers and Does Not Cover

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:

http://java.sun.com

1 Creating Applications: Overview