Developing Applications with Java¿ and UML

In this book, leading object-oriented consultant Paul Reed integrates Java and UML to create a powerfully effective process for building robust software. Reed covers the entire lifecycle, demonstrating how to establish sound project plans, estimate projects with greater accuracy and confidence, create sound Java designs with UML, use visual modeling tools, and construct better applications. Paul Reed begins by reviewing the dilemmas facing software developers, and demonstrating how the new UML-based Synergy methodology addresses these dilemmas. He introduces UML and the Synergy methodology through a comprehensive, start-to-finish case study in enterprise development. Learn how to create use cases; build UML class diagrams that enable the categorization of business rules; build early prototypes; and much more. The book shows how to choose appropriate distributed technologies (including RMI, CORBA, JSP, servlets, and EJB); implement data persistence; finalize a design; generate code from UML class diagrams; and create a distributed implementation that can be deployed on application servers such as IBM's WebSphere and BEA's WebLogic. Along the way, Reed introduces two leading visual modeling tools: Rational Rose and Advanced Software's GDPro. For Java developers, analysts, designers, and software engineers at all levels of experience.

Preface. Acknowledgements. 1. The Project Dilemma. In This Chapter. Goals. The Sad Truth. The Project Dilemma. Iterative and Incremental Software Development. Risk-Based Development. The Iterative Software Process Model. Combining Iterative with Incremental: Multidimensional View. The Synergy Process Model. The Unified Process. Other Processes (XP). Selling the Idea of a Software Process to the Business. The Unified Modeling Language. The Place of UML in a Software Process. The Essence of Modeling. The UML Diagrams. Checkpoint. Where We've Been. Where We're Going Next. 2. Java, Object-Oriented Analysis and Design, and UML. In This Chapter. Goals. Java as an Industrial-Strength Development Language. Java and Object-Oriented Programming. Java and Classes. More on Java and Classes. Java and Complex Types (Java Reference Types). Java and Message Passing. Java and Encapsulation. Java and Inheritance. Java and Polymorphism. Why UML and Java. Class Diagram. Sequence Diagram. Component Diagram. Deployment Diagram. Visual Modeling Tool Support. Checkpoint. Where We've. Where We're Going Next. 3. Starting the Project. In This Chapter. Goals. Establishing the Project Vision. The Process Model. Working Template of the Project Vision. Actors. Event List and Event Table. Identifying and Categorizing Business Rules. Event Capture Format. The Project Vision. Checkpoint. Where We've Been. Where We're Going Next. 4. Use-Cases. In This Chapter. Goals. The Sample Project. The Process Model. Use-Cases. Finding the Pathways through Use-Cases. Use-Case Template: Section 1e. Use-Case Template: Section 2. Use-Case Template: Section 3. Use-Case Template: Section 4. Finding the Happy Path. Finding the Alternate Pathways. Finding the Exception Pathways. Common Use-Case Pitfalls. Shadow Use Cases. Describing Details of the Happy Path. The Completed Process Orders Use-Case Template. Preparing the Preliminary Architecture. Project Charter: Increments and Estimates. Increments. Estimates: The Issues. Estimates: The Process. Checkpoint. Where We've Been. Where We're Going Next. 5. Classes. In This Chapter. Goals. The Elaboration Phase. Detailing Details of Pathways. Identifying Classes. Role of the UML Class Diagram. What Makes a Good Class? Applying Filter Rules. Types of Classes. Relationships. Establishing Associations. Establishing Roles. Establishing Multiplicity. Advanced Associations. Generalization. Creating the Class Diagram. Identifying Attributes and Operations. Attributes. Operations. Interfaces. Object Diagram. Finishing Up: The Analysis Model. Checkpoint. Where We've Been. Where We're Going Next. 6. Building a User Interface Prototype. In This Chapter. Goals. Building an Early Prototype. The Prototype. Gathering Requirements. User Interface Prototype. Actor and Use-Case Boundaries. User Interface Artifacts. Use-Case Coupling. The First Pass. Screen Structure Charts. Creating the Prototype. Windowing Components. Collecting User Feedback by Using Screen Dialogs. Learning from the Prototype. Checkpoint. Where We've Been. Where We're Going Next. 7. Dynamic Elements of the Application. In This Chapter. Goals. Next Steps of the Elaboration Phase. Dynamic Modeling. Types of Dynamic Models. The Sequence Diagram. Sequence Diagram of the Happy Path. Use-Case Template. Class Coupling and Cohesion. Sequence Diagram for an Alternate Pathway. Transferring Knowledge to the Class Diagram. Walking Through the Sequence Diagram. The Collaboration Diagram. The State Diagram. Modeling the State Diagram of the Remulak Order Class. Alternative View of State Diagrams. The Activity Diagram. Selecting the Right Diagram. Non-UML Extensions in the Design: Usage Matrices. Event/Frequency Matrix. Object/Location Matrix. Object/Volume Matrix. Checkpoint. Where We've Been. Where We're Going Next. 8. The Technology Landscape. In This Chapter. Goals. Next Steps of the Elaboration Phase. Separating Services. Logical versus Physical Tiers. Tier Strategy. Communication among the Six Layers. Interprocess Communication Architecture. Layer Communication Architecture. Managing Transaction Scope. Enterprise JavaBeans. Incorporating the Internet into the Solution. More About the Web Interface. Remulak Productions' Execution Architecture. Checkpoint. Where We've Been. Where We're Going Next. 9. Data Persistence: Storing the Objects. In This Chapter. Goals. Next Steps of the Elaboration Phase. Object-Oriented Concepts and Translating to the Physical Design. Mapping Classes to Tables. Mapping Simple Associations. Mapping Inheritance to the Relational Database. Mapping Aggregation and Composition to the Relational Database. Mapping Reflexive Associations to the Relational Database. Key Structures and Normalization. Using a Visual Modeling Tool to Generate the DDL. Stored Procedures and Triggers and the Object-Oriented Project. The Data Translation Services and Data Access Services Layers. JavaBeans with Native JDBC Support. JavaBeans and Native JDBC Data Management. Enterprise JavaBeans and Data Management. Commercial Persistence Layers. Checkpoint. Where We've Been. Where We're Going Next. 10. Infrastructure and Architecture Review. In This Chapter. Goals. Next Steps of the Elaboration Phase. Infrastructure Issues and Communicating with All Layers. The Presentation Services Layer. The Business Context Services Layer. The Business Rule Services Layer. Cooperating Classes: Boundary, Control, and Entity. Deployment Architecture View. Checkpoint. Where We've Been. Where We're Going Next. 11. Constructing a Solution: Servlets, JSP and JavaBeans. In This Chapter. Goals. Next Steps of the Elaboration Phase. Building the Architectural Prototype: Part 1. Baselining the Environment. Setting up Your Environment. Invoking Servlets. The Servlet for Remulak: Broker Services. The Servlet for Remulak: Responding to an Action Request. Java Server Pages for Remulak. Building the Architectural Prototype: Part 2. Remulak Controllers and Initial Operations. Remulak Transaction Management: Roll Your Own. Remulak Controllers and Subsequent Operations. Building the Architectural Prototype: Part 3. Entity Beans. Data Access Objects. Front to Back in one Package. Checkpoint. Where We've Been. Where We're Going Next. 12. Constructing a Solution: Servlets, JSP, and Enterprise JavaBeans. In This Chapter. Goals. Next Steps of the Elaboration Phase. Building the Architectural Prototype: Part 1. Baselining the Environment. Visual Modeling: Its Mission for the Project. Visual Modeling: Its Mission for Program Code Generation. Reviewing the Setup Issues. Modifying the Code Generation Parameters. A Final Pass at Attributes and Operations. Converting Classes to Enterprise JavaBeans. Generating Code. Building the Architectural Prototype: Part 2. A Primer on Enterprise JavaBeans. EJB Callback Mechanism. Working with an EJB. EJB Sequence Diagrams. EJB Transaction Management. Building the Architectural Prototype: Part 3. Adding Logic to the Generated Code. A Bit of Magic in Those Tags. Compiling the EJB Code. Building a Simple Client to Test the Beans. Enhancing the CMP Implementation. Adding More Use-Case Pathways. Changes to the JSPs. Adding an Address JSP. Changes to the Servlet. Changes to the Use-Case Controller. Creating a BMP Implementation. A Road Most Traveled. The Technology Decision. The Process of Getting There. Checkpoint. Where We've Been. Appendix A: The Unified Process Project Plans. In This Appendix. The Plans. Appendix B: The Synergy Process Project Plan. In This Appendix. The Plan. Appendix C: Estimating Projects on the Basis of Use-Cases. In This Appendix. Weighting Actors. Weighting Use-Cases. Weighting Technical Factors. Weighting Project Participants. Use-Case Points. The Project Estimate. Appendix D: Sample Project Output. In This Appendix. Use-Case Definitions. The Process Orders Use-Case. The Maintain Orders Use-Case. The Maintain Inventory Use-Case. The Shipping Use-Case. The Invoicing Use-Case. The Maintain Relationships Use-Case. The Decision Support Use-Case. Happy Path Task Steps. The Process Orders Happy Path. The Maintain Orders Happy Path. The Maintain Inventory Happy Path. The Shipping Happy Path. The Invoicing Happy Path. The Maintain Relationships Happy Path. The Decision Support Happy Path. Database Support. Microsoft SQL Server 7.0. DDL for Oracle (Version 8.1.0). Appendix E: BEA WebLogic Application Server. In This Appendix. Bibliography. Index. 0201702525T10302001