Register your product to gain access to bonus material or receive a coupon.
Building J2EE Applications with the Rational Unified Process
- By Peter Eeles, Kelli Houston, Wojtek Kozaczynski
- Published Aug 20, 2002 by Addison-Wesley Professional. Part of the Addison-Wesley Object Technology Series series.
Book
- Sorry, this book is no longer in print.
Description
- Copyright 2003
- Dimensions: 7-3/8" x 9-1/4"
- Edition: 1st
- Book
- ISBN-10: 0-201-79166-8
- ISBN-13: 978-0-201-79166-2
This book is a Rational Software Corporation-specific book focusing on the development of J2EE applications (version 1.3) within a RUP (Rational Unified Process) environment. As such, the book has a heavy dependency on UML (version 1.4). The authors aim to give the reader a basic understanding of component architectures and associated technologies, and how these component architectures and technologies are applied in the context of systematic development, specifically the Rational Unified Process. The reader will learn a set of proven best practices, guidelines, and standards that apply to systems development. It will reflect the next version of RUP which is scheduled for release during in 2002. This version of RUP will be a considerable departure from the current version.
Sample Content
Online Sample Chapter
J2EE: An Introduction to the Rational Unified Process
Downloadable Sample Chapter
Click below for Sample Chapter(s) related to this title:
Sample Chapter
4
Table of Contents
(NOTE: Chapters 2-9 conclude with a Summary.)
Foreword by Philippe Kruchten.
Foreword by John Croupi.
Preface.
1. Introduction.
How this Book is Organized.
2. An Introduction to the Java 2(TM) Platform, Enterprise Edition.
Enterprise Concerns.
Business Concerns.
Integration Concerns.
Development Concerns.
Multi-Tier Architectures and the J2EE Platform.
J2EE Platform Overview.
J2EE Technology Overview.
Containers.
Presentation Tier.
Business Tier.
Integration Tier.
J2EE Deployment Configurations.
J2EE Component Technologies.
Applets.
Application Clients.
Java Servlets.
JavaServer Pages (JSP).
Enterprise JavaBeans (EJB).
Assembly and Deployment.
J2EE Modules.
3. An Introduction to the Rational Unified Process.
Best Practices — The Foundation of RUP.
RUP Key Concepts.
Artifacts.
Roles.
Activities.
Disciplines.
Workflow Details.
Iterations.
Phases.
RUP as a Process Framework.
4. An Introduction to the J2EE Developer Roadmap.
What is a RUP Roadmap?
J2EE Developer Roadmap — Scope and Rationale.
J2EE Developer Roadmap — J2EE-Specific Content.
5. An Introduction to the Sample Application.
Application Overview.
Problem Statement.
Stakeholders and Users.
Stakeholders, Their Concerns and Responsibilities.
Users, Their Concerns and Responsibilities.
Functional Features and Constraints.
Other Requirements and Properties.
Non-Functional Properties.
User Environment.
Deployment Environment.
6. Requirements.
Requirements and Iterative Development.
Requirements Overview.
Workflow Detail: Define the System.
Activity: Capture a Common Vocabulary.
Activity: Find Actors and Use Cases.
Activity: Prioritize Use Cases.
Activity: Review the Requirements.
Workflow Detail: Refine the System Definition.
Activity: Detail a Use Case.
Activity: Structure the Use-Case Model.
Activity: Review the Requirements.
7. Analysis.
Analysis and Iterative Development.
Analysis Overview.
Workflow Detail: Define an Initial Architecture.
Activity: Architectural Analysis.
Activity: Review the Initial Architecture.
Workflow Detail: Analyze Behavior.
Activity: Model the User Experience.
Activity: Review the User Experience.
Activity: Use-Case Analysis.
Activity: Review the Analysis.
8. Design.
Design and Iterative Development.
Design Overview.
Workflow Detail: Refine the Architecture.
Activity: Identify Design Mechanisms.
Activity: Identify Design Elements.
Activity: Incorporate Existing Design Elements.
Activity: Describe Distribution and Concurrency.
Activity: Review the Architecture.
Workflow Detail: Detail the Design.
Activity: Use-Case Design.
Activity: Subsystem Design.
Activity: Component Design.
Activity: Class Design.
Activity: Database Design.
Activity: Review the Design.
9. Implementation.
Implementation and Iterative Development.
Implementation Overview.
Workflow Detail: Structure the Implementation Model.
Activity: Structure the Implementation Model.
Activity: Review the Implementation.
Workflow Detail: Implement Design Elements.
Activity: Implement Design Elements.
Activity: Perform Unit Tests.
Activity: Review the Implementation.
10. Additional Topics.
Business Modeling.
Testing.
Deployment.
Configuration and Change Management.
Project Management.
Environment.
Other Considerations.
In Conclusion — A Note from the Authors.
Appendix A: Describing a Software Architecture.
Introduction.
What Is Architecture?
Communicating the Architecture of a System.
The Software Architecture Document.
Appendix B: Modeling Conventions.
UML Representation of J2EE Developer.
Roadmap Elements.
Requirements Artifacts.
Analysis Artifacts.
Design Artifacts.
Implementation Artifacts.
Design Relationships.
Design Class Attributes and Operations.
J2EE Developer Roadmap Model Structure Guidelines.
Use-Case Model.
User-Experience Model.
Design Model.
Implementation ModeL.
Appendix C — Glossary.
Terms.
Acronyms.
Index. 0201791668T05172002
Preface
About This Book
This book is about developing Java 2 Platform, Enterprise Edition (J2EE) applications with the Rational Unified Process (RUP) and the Unified Modeling Language (UML). There are a number of books describing the J2EE platform and its associated technologies. There are also books about software development processes and about RUP, in particular. However, we could not find a book that described and exemplified how to use a subset of RUP that contains only the most relevant parts of an otherwise large and comprehensive process, to build J2EE applications. The book bridges this gap between the RUP and J2EE technologies.
A world that combines J2EE, RUP and UML is complex. This world requires a good map if you are to successfully navigate your way through it. This book provides such a map both metaphorically and literally. It is metaphorical because the very objective of the book is to provide a description of a "safe path" through the J2EE application development activities. It is also literal because we define a "J2EE Developer Roadmap," which is a process map, to guide us. We describe the content of the book in more detail in Chapter 1, Introduction.
Who This Book Is ForWhile writing the book we kept three audiences in mind. The first audience is software architects, designers and developers familiar with the J2EE platform and its technologies, wanting to understand how to apply them in the context of a software development process. The second audience is development team members familiar with RUP, looking for help in applying the process to J2EE development. The third audience is software professionals who are neither familiar with J2EE nor with RUP, and are looking for an example of how to use RUP in the development of a J2EE application.
Conventions Used in This BookThe book is roughly divided into two parts. The first part, Chapters 2–5, summarizes the J2EE technologies, introduces RUP and the J2EE Developer Roadmap, and briefly describes our sample application. The rest of the book is what we refer to as the "process chapters" and contains a guided tour through a J2EE application development project.
We structured the process chapters to make them easy to read "at a glance," and to make it easy to refer to specific topics of interest. Each process chapter is organized primarily by activities. We provide diagrams that indicate the overall flow between the activities and the key artifacts that are consumed and produced by the activities. For each activity, we provide an overview table that summarizes the purpose of the activity, its input and output artifacts, and a summary of the steps performed within the activity. Following the table, we then describe the details of each of these steps, using the sample application.
In the process chapters, we use only one simple editing convention: we emphasize all references to process elements such as activities, steps, and artifacts.
0201791668P08012002
Index
Click below to download the Index file related to this title:
Index
Updates
Errata
Errata for Building J2EE™ Applications With the Rational Unified Process
Peter Eeles, Kelli Houston, Wojtek Kozaczynski
Chapter 2
- Page 9: Figure 2.2. The text "Applet" is missing from the box in the box labeled "Applet Container". The text "Application" in the box in the "Application Client Container" box should read "Application Client". See corrected PDF file on this site.
- Page 18: Figure 2.8. The box in the "Client Device" box should contain the text "HTML Client". See corrected PDF file on this site.
- Page 31: Figure 2.13. The unlabeled box in the box containing "Servlets" and "Java Classes" should be labeled "JSPs". The unlabeled graphic in the box containing "Java Classes" should be labeled "EJBs". See corrected PDF file on this site.
Chapter 3
- Page 49: "RUP as a Process Framework" section: Remove bold-faced character format for the word "customization" since this is not a RUP process element. The text should still be italicized.
Chapter 4
- Page 54: Figure 4.1. The text "defined in" between the Implementation Model and the Deployment Model should read "deployment defined in". See corrected PDF file on this site.
- Page 55: 1st paragraph: last sentence: Change "...the physical files of the Implementation Model can be maintained using roundtrip engineering" to "...the physical files and directories can be maintained using roundtrip engineering".
Chapter 6
- Page 74: Figure 6.4: The arrows should not have plain arrowheads, but should have open triangles as their heads. See corrected PDF file on this site.
- Page 83: 3rd paragraph: 1st sentence: Change "documented in the Requirements Review of the Software Architecture Document" to "documented in the Software Architecture Document".
- Page 88: 1st paragraph after the bulleted list: 2nd sentence: Change "on relationships between Use Cases, see the Structure the Use-Case Model activity" to "on relationships between Use Cases, see the Structure the Use-Case Model activity". In other words, bold the activity name.
Chapter 7
- Page 127: Footnote 12. Second sentence. The text "The stereotypes are only used..." should read "The stereotypes and icons are only used...".
- Chapter 8
- Page 148: Figure 8.5. The line between client and FrontController should not be a solid line, but a dashed line with an arrowhead at the FrontController end. This line should also be labeled with "send request." See corrected PDF file on this site.
- Page 150: Figure 8.7. The line between client and FrontController should not be a solid line, but a dashed line with an arrowhead at the FrontController end. This line should also be labeled with "send request." The BusinessEntity element should have the stereotype ‹‹EJBEntityBean›› and not ‹‹EJBSessionBean››. See corrected PDF file on this site.
- Page 161: Figure 8.16. The AuctionEJB, BidEJB and CategoryEJB elements should all have the stereotype ‹‹EJBEntityBean›› and not ‹‹EJBSessionBean››. See corrected PDF file on this site.
- Page 166: Figure 8.20. The stereotyped "use" between the PresentationRequestController and the CreateAuctionDispatcher should be removed. The stereotype ‹‹use›› should be placed next to the dashed line between AuctionManagerDelegate and AuctionManagerHomeLocator, and next to the dashed line between UserAccountManagerDelegate and UserAccountManagerHomeLocator. See corrected PDF file on this site.
- Page 182: Third paragraph. Third sentence. The stereotype ‹‹interface realization›› should read ‹‹InterfaceRealization››.
Chapter 10
- Page 231: Footnote 3. This should read "The Deployment Model shows the allocation of implementation elements to system nodes".
Appendix C
Add the following term and definition at their correct position in the Glossary:
- Enterprise Component A software implementation of a business concept or business process. It is a collection of related elements that should be a unit of design, implementation and deployment.