Download Executive Summary

Brian Schwerdt
Advisor Douglas J. MacIntosh
Software Engineering
April 28, 2003
Updating IBM’s ‘Bookstore’ Workload Application to Utilize the Platform
Independent Java 2 Enterprise Environment Architecture and Add Capabilities to
Exchange Audio/Visual Information
Executive Summary
This thesis will look to enhance IBM’s proprietary ‘Bookstore’ application. The
Bookstore will be rebuilt on the Java 2 Enterprise Environment (J2EE) infrastructure.
The new application will have a developer friendly application layout, simplifying further
enhancements. In addition, the application will transfer pictures and videos from a
database to enhance the user’s visual experience.
The application will require the use of many underlying products running on an
IBM Z-series server. It will run on Websphere Application Server (WAS) version 5.0, a
J2EE compliant application server. The audio/visual data will be stored in a DB2
database as Binary Large Objects (BLOBs), which will be accessed using JDBC. The
data will be fetched using the Structure Query Language (SQL).
This project will result in a fully documented enhancement to the Bookstore
application. Documentation will be up kept throughout the entire design and
development process. This information will be assembled at the end in comprehensible
manner.
Introduction/Background
When IBM produces a new release of their Z/OS operating system, it is of great
importance that nothing has been broken from the previous release. Once the code has
been integrated into a functional product, it is sent to system integration testing. This
department stresses the system with workload applications to assure that it still operates
correctly. In this way, they are able to catch potential problems before the finished
product is shipped to the customer.
A workload application is a program which IBM uses to stress-test new releases
of their servers. They typically simulate one or more of IBM’s clients, using the server as
a client would. In this way, IBM can catch any problems before a customer does. In
extreme cases, when a client catches a problem, IBM can usually respond quickly by
simulating the client with their own workload applications, and determine the cause.
Bookstore was created as a workload application to simulate high demand web
clients such as Amazon. Currently, one can browse for a product and place and cancel
orders. This project will restructure the project from the ground up, as well as add the
ability for a user to browse and sample audio clips, pictures, and video clips. With these
additional features, Bookstore will become a more intense load on the system, stresstesting Z/OS even more.
The addition of these features will use new and quickly developing technologies.
Bookstore will be built upon the J2EE infrastructure. The J2EE is a new architecture
designed to be object-oriented and platform independent [3]. This means that an
application built on the J2EE can run on any operating system. In today’s world of
rapidly changing technologies, the J2EE is designed to be flexible so that a J2EE
application will last.
Dynamic
HTML Pages
Client Tier
JSP Pages / Servlets
Web Tier
(optional)
Enterprise Beans
(EJB)
Database
Business T ier
EIS Tier
Client
Machine
J2EE Server
Machine
Database Server
Machine
Figure 1: J2EE’s multiple tiers [1]
A J2EE application is divided into multiple tiers, or layers, as seen in Figure 1.
Applications can have three or four tiers, although most only have three [1]. The top tier
exists on the client’s machine. This tier consists mainly of interactive webpage
interfaces, but occasionally will also contain some functionality. The next level is the
Web tier. This level may contain Java Server Pages (JSPs) and servlets, which
dynamically handle requests to the server. The Web tier is usually excluded, in which
case the Client tier interacts directly with the Business tier. The Business tier holds the
enterprise beans, which retrieve and process data from the database. Finally, the
Enterprise Information System (EIS) tier is the database in which the information is
stored.
Applet Container
(J2SE)
Applet
J2SE
Containers
HTTP
SSL
Web Container (J2SE)
JSP
EJB
JDBC
J2SE
Containers
Application
Client
Servlet
JDBC
J2SE
Containers
Application Client
Container (J2SE)
EJB Containter (J2SE)
HT TP
SSL
JDBC
J2SE
Containers
Database
Figure 2: J2EE containers [6]
Each tier in the J2EE architecture is essentially a container of Java 2 Standard
Edition (J2SE) classes as seen in Figure 2. These containers create an object-oriented
environment. These containers interact with one another transparently through the use of
standard protocols. Most products built on the J2EE make use of all four of these
container types [6]. These containers are not strictly equivalent to the tiers. For example,
a J2EE application can have a Web container, but place it within the Business tier.
In addition to learning the J2EE architecture, a major hurdle for this project is
handling very large pieces of data. Currently, Bookstore uses a DB2 database. The
database holds information such as a book’s title, author, and a unique identification
number. All of this information is stored within a row of a relational database. However,
these rows are limited in size to 32Kb. The audio and visual data will almost always
exceed this limit. Therefore, a new method must be used.
DB2 allows for the storage of large objects. The data will be stored as a Binary
Large Object (BLOB). DB2 accomplishes this by storing a BLOB locator in the database
rather then the BLOB itself [2]. The locator simply tells the program where the data is
stored.
Although Bookstore uses a DB2 database, the spirit of J2EE is portability. A
program that is portable is independent of both the operating system and other programs
with which it interfaces. The JDBC allows a program to be written once but interface
with any compatible database. By using the JDBC, IBM could move their data to another
type of database without touching the code for Bookstore.
Objectives
Over the course of this project, I will work in a team environment to design a
J2EE compliant architecture to implement Bookstore. In addition, I will work
individually to implement a means of storing and retrieving (at a user’s request) audio
and visual data. Design details will be noted along the way, so that the finished product
is fully documented.
The first semester’s work has consisted mostly of learning new technologies.
DB2 and J2EE both have a considerable learning curve. This semester, I have read
through documentation and run some examples in order to get a better understanding of
them. Learning new technologies is always a hurdle in software development, as they
change very rapidly.
Now that I have an understanding of these technologies, I will design and
implement these additions using a sound software engineering technique. The user
interface will be intuitive and user friendly. The supporting architecture will be reliable,
and built upon the J2EE infrastructure. The entire project will be fully documented. This
will allow another programmer to look at my code and understand what was done. It will
also give project leaders confidence that my design works as expected.
Timeline
Spring 2003
 Become familiar with J2EE, Java and DB2
 Install and run J2EE examples
 Become familiar with basic Bookstore design
 Create a high level design
 Write project proposal
Summer 2003
 Work with IBM on site in Poughkeepsie
 Develop low level details of design
 Implement additions
 Thoroughly test and debug product
 Maintain documentation of progress
Fall 2003
 Compile documentation in a professional format
 Write up thesis
Evaluation
As with any project of this scope, I must have means to assure that I stay on
target. I have set the above timeline in order to best evaluate my progress. I will
regularly compare my work with the goals I have set. As the design process proceeds, I
will keep notes on design details and high level functionality. In this way, the
functionality can be compared to the original specifications to assure the design remains
on task.
Once the enhancements have been made, the software must undergo testing.
Since the J2EE is inherently object-oriented and these objects hold their own
functionality as well as data, each container can be tested individually. The final test will
be integrating all of the pieces into one finished product.
References
[1] Stefanie Bodoff, Dale Green, Kim Haase, Eric Jendrock, Monica Pawlan, Beth
Stearns, “The J2EE Tutorial”, Addison-Wesley, Boston, 2002.
[2] Paolo Bruni, Patric Becker, Micheal Dewert and Bob Riehle, “Large Objects with
DB2 for Z/OS and OS/390 Redbook”, IBM corporation, 2002.
[3] Altendorf E, Hohman M, Zabicki R, “Using J2EE on a large, Web-based project”,
IEEE computer society, Los Alamitos, 2002.
[4] Cecchet E, Marguerite J, Zwaenepoel W, “Performance and Scalability of EJB
Applications”, Association of Computing Machinery, 2002.
[5] Bruce Eckel, “Thinking In Java”, MindView, Inc., 2002.
[6] Bill Shanon, “Java 2 Platform Enterprise Edition Specifications, v1.4”, Sun
Microsystems, California, 2002.