Developing Applications with Java (TM) and UML focuses on the craft of creating quality Java software. The book introduces the fundamentals of the Unified Modeling Language (UML) and demonstrates how to use this standard object-oriented notation to build more robust Java applications that fulfill users' requirements and stand the test of time.
The book features the Rational Unified Process, using a large-scale application to illustrate the development process: how to establish a sound project plan, gather application requirements using use cases, create a successful Java design with UML, and implement Java code from the UML class and sequence diagrams. This sample application showcases the latest Java technology frameworks, including Java Server Pages (TM) (JSP), servlets, and the Enterprise Java Beans (TM) (EJB) 2.0 server-side technology.
You will learn how to:
Estimate with accuracy and confidence projects built using the use case approach
Map UML to Java-based deliverables
Understand and describe application requirements using UML use cases
Create a design based on UML class and sequence diagrams
Use Rational Rose to create and track UML artifacts and generate skeletons for component code
Build server-side Java functionality using JSP, servlets, and EJB 2.0 beans
Produce code using several options, including JavaBeans, EJB Session Beans, and EJB Entity Beans (using both Bean-Managed Persistence and Container-Managed Persistence)
Explore the benefits of deploying Java applications on both open-source and commercial application server products
Based on the author's extensive professional experience and the most advanced software development methods, Developing Applications with Java (TM) and UML teaches you how to use UML and the latest developments in technology to create truly successful, professional-quality Java applications.
0201702525B09042001
Auflage
Sprache
Verlagsort
Verlagsgruppe
Zielgruppe
Für höhere Schule und Studium
Maße
Höhe: 234 mm
Breite: 187 mm
Dicke: 29 mm
Gewicht
ISBN-13
978-0-201-70252-1 (9780201702521)
Schweitzer Klassifikation
Paul R. Reed, Jr., is President of Jackson-Reed, Inc. (www.jacksonreed.com), where he consults on the implementation of object-oriented distributed systems worldwide. He develops and leads seminars on such topics as object-oriented analysis and design, use case analysis, the Unified Process, Internet application development, and client/server technology. Paul also speaks at various industry events, including DB/Expo, UML World, and VBITS, and is the author of numerous journal articles as well as Developing Applications with Visual Basic and UML (Addison-Wesley, 2000).
0201702525AB10302001
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
