You are previewing Building J2EE™ Applications with the Rational Unified Process.
O'Reilly logo
Building J2EE™ Applications with the Rational Unified Process

Book Description

Two of the most significant technological development trends of the past few years have been the Java 2 Platform, Enterprise Edition (J2EE), a platform specifically geared to the needs of enterprise systems, and the Rational Unified Process (RUP), a comprehensive development methodology.

Building J2EE™ Applications with the Rational Unified Process is the first book to bring these two key development concepts together. Featuring a non-trivial sample application, the book demonstrates a customized subset of RUP that is relevant and essential to J2EE development. The text guides readers through the entire development process, from initial requirements gathering through system implementation, illuminating real-world intricacies, complications, tradeoffs, and decision making.

The book presents a review of the latest releases of J2EE and RUP, emphasizing the rationale behind their content. A developer roadmap helps readers navigate the development process successfully, and detailed discussions of each aspect of the process reveal practical strategies and techniques.

Also provided is detailed coverage of the key aspects behind any successful software development effort:

  • Requirements, including use-case modeling and the gathering of architecturally significant requirements

  • Analysis, including the transformation of requirements into a first-cut design model and a user-experience model

  • Design, including the refinement of a design model, introducing interfaces, framework components, design classes, and use-case realizations

  • Implementation, including the creation of source code and executable code based on the design, and the production of J2EE modules necessary for deployment

  • Architectural concerns, including the production of a Software Architecture Document, Deployment Model, and Data Model

  • The use of patterns, in particular J2EE design patterns

  • The use of UML to model J2EE technologies such as Enterprise JavaBeans™

Written for anyone working in J2EE or using RUP, this book is an comprehensive guide that reveals how J2EE and the Rational Unified Process come together to produce a powerful, efficient, and effective approach to enterprise application development.

Forewords were prepared by John Crupi, Distinguished Engineer at Sun Microsystems (and coauthor of Core J2EE Patterns, Prentice Hall, 2001), and Philippe Kruchten, Director of RUP Development at Rational Software (and author of The Rational Unified Process, Addison-Wesley, 2000).


Table of Contents

  1. Copyright
  2. Foreword
  3. Foreword
  4. Preface
    1. About This Book
    2. Who This Book Is For
    3. Conventions Used in This Book
    4. Acknowledgments
  5. 1. Introduction
    1. How This Book Is Organized
  6. 2. An Introduction to the Java 2 Platform, Enterprise Edition
    1. Enterprise Concerns
      1. Business Concerns
      2. Integration Concerns
      3. Development Concerns
    2. Multitier Architectures and the J2EE Platform
    3. J2EE Platform Overview
      1. J2EE Technology Overview
        1. J2EE Application Component Technologies
        2. J2EE Services
        3. J2SE Services
      2. Containers
        1. Containers and Servers
      3. Presentation Tier
      4. Business Tier
      5. Integration Tier
      6. J2EE Deployment Configurations
        1. Standalone Deployment Configuration
        2. EJB-Centric Deployment Configuration
        3. Web-Centric Deployment Configuration
        4. Multitier Deployment Configuration
    4. J2EE Component Technologies
      1. Applets
      2. Application Clients
      3. Java Servlets
      4. JavaServer Pages (JSP)
      5. Enterprise JavaBeans (EJB)
        1. Home Interface
        2. Remote Interface
        3. Local Home Interface
        4. Local Interface
        5. Bean Class
        6. Session Beans
        7. Entity Beans
        8. Message-Driven Beans
    5. Assembly and Deployment
      1. J2EE Modules
    6. Summary
  7. 3. An Introduction to the Rational Unified Process
    1. Best Practices—The Foundation of RUP
    2. RUP Key Concepts
      1. Artifacts
      2. Roles
      3. Activities
      4. Disciplines
      5. Workflow Details
      6. Iterations
      7. Phases
        1. Inception
        2. Elaboration
        3. Construction
        4. Transition
    3. RUP as a Process Framework
    4. Summary
  8. 4. An Introduction to the J2EE Developer Roadmap
    1. What Is a RUP Roadmap?
    2. J2EE Developer Roadmap–Scope and Rationale
    3. J2EE Developer Roadmap–J2EE-Specific Content
    4. Summary
  9. 5. An Introduction to the Sample Application
    1. Application Overview
    2. Problem Statement
    3. Stakeholders and Users
      1. Stakeholders: Their Concerns and Responsibilities
      2. Users: Their Concerns and Responsibilities
    4. Functional Features and Constraints
    5. Other Requirements and Properties
      1. Nonfunctional Properties
      2. User Environment
      3. Deployment Environment
    6. Summary
  10. 6. Requirements
    1. Requirements and Iterative Development
    2. Requirements Overview
    3. Workflow Detail: Define the System
      1. Activity: Capture a Common Vocabulary
        1. Step: Identify Common Terms
      2. Activity: Find Actors and Use Cases
        1. Step: Find Actors
        2. Step: Find Use Cases
        3. Step: Collect Supplementary Requirements
        4. Step: Describe How Actors and Use Cases Interact
        5. Step: Package Use Cases and Actors
      3. Activity: Prioritize Use Cases
        1. Step: Prioritize the Use Cases
        2. Step: Update the Software Architecture Document
      4. Activity: Review the Requirements
        1. Step: Conduct the Review
    4. Workflow Detail: Refine the System Definition
      1. Activity: Detail a Use Case
        1. Step: Detail the Flows of Events of the Use Case
        2. Step: Describe the Special Requirements of the Use Case
        3. Step: Describe Preconditions of the Use Case
        4. Step: Describe Postconditions of the Use Case
      2. Activity: Structure the Use-Case Model
        1. Step: Structure the Use Cases
        2. Step: Structure the Actors
      3. Activity: Review the Requirements
        1. Step: Conduct the Review
    5. Summary
  11. 7. Analysis
    1. Analysis and Iterative Development
    2. Analysis Overview
    3. Workflow Detail: Define an Initial Architecture
      1. Activity: Architectural Analysis
        1. Step: Develop Architecture Overview
        2. Step: Survey Available Assets
        3. Step: Define the Initial Deployment Model
        4. Step: Structure the Design Model
        5. Step: Identify Key Abstractions
        6. Step: Identify Analysis Mechanisms
      2. Activity: Review the Initial Architecture
        1. Step: Conduct the Review
    4. Workflow Detail: Analyze Behavior
      1. Activity: Model the User Experience
        1. Step: Identify the Participating Screens
        2. Step: Model the Screen Flows
        3. Step: Define the Screen Navigation Paths
        4. Step: Reconcile the Use-Case Storyboards
        5. Step: Document Usability Requirements
      2. Activity: Review the User Experience
        1. Step: Conduct the Review
      3. Activity: Use-Case Analysis
        1. Step: Identify the Participating Analysis Classes
        2. Step: Model the Use-Case Flows
        3. Step: Describe the Analysis Classes
        4. Step: Reconcile the Use-Case Realizations
        5. Step: Ensure Consistency with the User-Experience Model
      4. Activity: Review the Analysis
        1. Step: Conduct the Review
    5. Summary
  12. 8. Design
    1. Design and Iterative Development
    2. Design Overview
    3. Workflow Detail: Refine the Architecture
      1. Activity: Identify Design Mechanisms
        1. Step: Inventory Design and Implementation Mechanisms
        2. Step: Select Design and Implementation Mechanisms
        3. Step: Document the Mechanisms
      2. Activity: Identify Design Elements
        1. Step: Identify Design Subsystems and Their Interfaces
        2. Step: Identify Framework Components and Their Interfaces
        3. Step: Identify Design Classes
      3. Activity: Incorporate Existing Design Elements
        1. Step: Identify Reuse Opportunities
        2. Step: Reverse-Engineer Assets
        3. Step: Incorporate Existing Design Elements into the Design Model
      4. Activity: Describe Distribution and Concurrency
        1. Step: Define the Network Configuration
        2. Step: Distribute Elements to Containers and Nodes
        3. Step: Analyze Application Concurrency
        4. Step: Identify Concurrency Mechanisms
      5. Activity: Review the Architecture
        1. Step: Conduct the Review
    4. Workflow Detail: Detail the Design
      1. Activity: Use-Case Design
        1. Step: Realize Each Flow of Events
        2. Step: Reconcile the Use-Case Realizations
      2. Activity: Subsystem Design
        1. Step: Distribute Subsystem Behavior to Subsystem Elements
        2. Step: Describe Subsystem Dependencies
      3. Activity: Component Design
        1. Step: Distribute Component Behavior to Component Elements
        2. Step: Describe Component Dependencies
      4. Activity: Class Design
        1. Step: Define Class Visibility
        2. Step: Define Class Operations
        3. Step: Define Attributes
        4. Step: Define Dependencies and Relationships
      5. Activity: Database Design
        1. Step: Map Entity EJBs to the Data Model
        2. Step: Distribute Class Behavior in the Database
      6. Activity: Review the Design
        1. Step: Conduct the Review
    5. Summary
  13. 9. Implementation
    1. Implementation and Iterative Development
    2. Implementation Overview
    3. Workflow Detail: Structure the Implementation Model
      1. Activity: Structure the Implementation Model
        1. Step: Establish the Implementation Model Structure
      2. Activity: Review the Implementation
        1. Step: Conduct the Review
    4. Workflow Detail: Implement Design Elements
      1. Activity: Implement Design Elements
        1. Step: Implement Design Subsystems
        2. Step: Implement Framework Components
        3. Step: Implement Design Classes and Interfaces
        4. Step: Implement Deployment Elements
        5. Implementation Optimizations
      2. Activity: Perform Unit Tests
        1. Step: Implement Unit Tests
        2. Step: Execute Unit Tests
        3. Step: Evaluate the Execution of Unit Tests
        4. Step: Verify Unit Test Results
        5. Step: Recover from Halted Unit Tests
      3. Activity: Review the Implementation
        1. Step: Conduct the Review
    5. Summary
  14. 10. Additional Topics
    1. Business Modeling
    2. Testing
    3. Deployment
    4. Configuration and Change Management
    5. Project Management
    6. Environment
    7. Other Considerations
    8. In Conclusion—A Note from the Authors
  15. A. Describing a Software Architecture
    1. Introduction
    2. What Is Architecture?
    3. Communicating the Architecture of a System
    4. The Software Architecture Document
  16. B. Modeling Conventions
    1. UML Representation of J2EE Developer Roadmap Elements
      1. Requirements Artifacts
      2. Analysis Artifacts
      3. Design Artifacts
      4. Implementation Artifacts
      5. Design Relationships
      6. Design Class Attributes and Operations
    2. J2EE Developer Roadmap Model Structure Guidelines
      1. Use-Case Model
      2. User-Experience Model
      3. Design Model
      4. Implementation Model
  17. C. Glossary
    1. Terms
      1. Glossary
    2. Acronyms
  18. Bibliography