Developing a J2EE application can be a very complex undertaking, and many questions must be answered. How do we articulate the requirements of the application to be developed? What J2EE components, such as servlets, JavaServer Pages, and Enterprise JavaBeans, are needed to satisfy these requirements? How is the complexity of developing a large J2EE application managed? And so on.
As we worked with Rational customers, we found ourselves writing papers, giving presentations, and producing examples that showed how the Rational Unified Process (RUP) can be successfully applied to develop J2EE applications. We identified the RUP activities and artifacts most relevant to the J2EE developer, recommended a specific sequencing of these activities, provided J2EE-specific guidance on how to produce these artifacts, and so on. This book brings all of this material, and our experiences, together.
In this book we describe a subset of RUP that we refer to as the J2EE Developer Roadmap. This roadmap contains relevant extracts from RUP itself, which we have simplified and specialized to meet the needs of the J2EE application developer. We have also included a number of extensions to RUP, such as a process for modeling the user experience of a J2EE application. The result is a process that is both lightweight and focused. Its purpose is obvious—to help you build higher quality J2EE applications faster.
If you are like us (and we consider ourselves to be software engineers), then you learn best through studying examples (rather than having to read volumes before you can apply what you have learned). With that in mind, we have structured and written the book following a few simple principles: (1) minimize the necessary introductions and get to the essence of the “RUP for J2EE” content as soon as possible, (2) support all discussions with examples and (3) avoid the temptation to discuss everything we know and instead only discuss what is necessary and useful.
True to our principles, let us briefly describe the structure of the book to provide a map of what's ahead.
Chapters 2 and 3 provide a brief overview of J2EE and RUP, respectively, and therefore provide the technology and process context for the rest of the book.
Chapter 2, An Introduction to the Java 2 Platform, Enterprise Edition, is our attempt at “interpreting” J2EE through the eyes of the architect and the designer who use the J2EE platform as the technical foundation of their applications. In particular, we describe the J2EE platform in terms of the architectural and design concerns it addresses.
Chapter 3, An Introduction to the Rational Unified Process, has two objectives. The first and most obvious is to introduce the key concepts underpinning the RUP and its overall organization. The second objective, which is equally important, is to introduce RUP as a process framework. Over the years RUP has grown to incorporate process guidelines in many different disciplines and domains. No single project will make use of all RUP content and hence RUP should be looked at as a base from which one derives a project, company or domain-specific process. This book provides an example of such a customized process that addresses the needs of the J2EE developer.
The remaining chapters address the primary subject of the book: how to develop J2EE applications. We start by introducing our J2EE-specific process, the J2EE Developer Roadmap.
Chapter 4, An Introduction to the J2EE Developer Roadmap, provides an overview of the customized subset of RUP we have tailored to meet the needs of the J2EE developer. This chapter presents the roadmap that we use throughout the rest of the book. The roadmap shows the RUP activities and artifacts that we consider the “must haves” of J2EE application development as well as the rationale for our selection. Chapter 4 also provides an overview of the J2EE-specific content in the J2EE Developer Roadmap, the details of which are described in Chapters 6–9. Our intention in creating the J2EE Developer Road map was not only to visualize the activities and artifacts of the process, but also to use it as a navigational device for a “guided tour” through the development of a J2EE application. However, to follow one of our principles, we needed a comprehensive example. It is the role of the next chapter to introduce such an example. Chapter 5 describes the application that we selected for that example, and Chapters 6–9 walk you through the development of that example.
Chapter 5, An Introduction to the Sample Application, provides an over view of a reference application that we use throughout the book. The application is an Online Auction. Although it implements only selected aspects of a typical auction system, it is complete from the development point of view; that is, it contains a complete set of artifacts from requirements to code. Chapter 5 discusses the scope of the Online Auction application, the business context in which it operates, and the key constraints under which it was designed.
Chapters 6–9 are the guided tour of the process (the process chapters). The tour has been divided along the lines of the RUP “disciplines” of Requirements, Analysis and Design, and Implementation. Although RUP considers Analysis and Design as a single discipline, we have chosen to discuss the analysis and design activities in two separate chapters to ensure that we cover each of them at the necessary level of detail.
Chapter 6, Requirements, follows the requirements activities of the J2EE Developer Roadmap to define the requirements of the Online Auction application. The requirements are captured in a Glossary, a Use-Case Model, and a Supplementary Specification. We pay special attention to use-case modeling and to the gathering of architecturally significant requirements.
Chapter 7, Analysis, describes the transformation of the requirements into two primary analysis artifacts: a first-cut Design Model and a User-Experience Model, as well as an initial Deployment Model and Software Architecture Document. One characteristic of our J2EE Developer Roadmap is that it eliminates the need for a separate Analysis Model, and shows how to perform the analysis activities within the context of the Design Model.
Chapter 8, Design, describes the activities of developing and refining the following design artifacts in preparation for implementation: the Design Model (including Interfaces, Design Subsystems, Framework Components, Design Classes, and Use-Case Realizations), Software Architecture Document, a Deployment Model, and a Data Model. This chapter describes how key design decisions are made and how they are captured in the design artifacts. In particular we spend considerable time discussing the application of J2EE technologies, the use of patterns (including the Sun J2EE patterns) and architectural mechanisms, and the use of UML to model J2EE technologies (such as Enterprise Java Beans).
Chapter 9, Implementation, discusses the implementation activities that transform the design artifacts into implementation artifacts, such as source code and executable code. In this chapter, we also discuss the production of various J2EE modules (Java archive files) that are required to deploy a J2EE application.
Chapter 9 completes our guided tour through the J2EE Developer Road map as it describes activities that result in a working application. It is certainly our expectation that at this point you should be able to repeat the process for any other J2EE application.
Chapter 10, Additional Topics, discusses aspects of RUP that are not covered in the preceding chapters. Since the J2EE Developer Roadmap includes only those parts of the process that we selected as the “must haves” of J2EE development, parts of RUP have been only mentioned or treated very lightly. In particular, we do not discuss business modeling, testing (other than unit testing), configuration management, and project management to any significant depth. We therefore conclude with a brief discussion of the parts of RUP that you may want to examine in more detail on your own.
We also include two appendices that supplement the primary process information provided in the process chapters. Appendix A, Describing a Software Architecture, briefly discusses how to describe software architecture and the different perspectives that are commonly used to construct architecture descriptions. Appendix B, Modeling Conventions, summarizes the conventions used throughout the book for modeling a J2EE application. In particular, we summarize the UML stereotypes that we used, as well as our recommendations for structuring the application models. Finally, in Appendix C, the Glossary provides a summary of the terms and acronyms used in the book.