1

Overview

• Fundamental OO Design Principles
• Introduction to Design Patterns

1

Business Concept Modeling (BCM)
The most powerful way to describe an organization's business concepts, rules and policies

This chapter presents how to model any business domain using the Unified Modeling Language (UML). BCM is a crucial topic for students to master the various Domain Models and Pattern Class Diagrams presented in the Design and Implementation chapters of this course.

• Overview
• Examples
• Model Elements: Theory, Syntax
Examples and Exercises for:
• Business Concepts
  • Class
• Business Concept Relationships
  • Inheritance
  • Composition
  • Association
  • Association Role
  • Association Class
• BCM Decision Tree
• BCM Practice: an entire Business Domain

1-2

Object Design Fundamentals
The basis of all advanced OO principles, techniques, and patterns

This chapter explains the fundamental principles of object design and the best strategies to implement them.

We first cover the best basic OO Design techniques that implement Class Relationships, Encapsulation/Specialization, and Inheritance/Polymorphism. Then we explore how objects can collaborate and use each other--based upon Specialization and Delegation--to implement specific functional requirements.

These techniques quickly lead us towards the Propagation Pattern, the most powerful approach to implement elaborated Domain Business Logic. This topic is then complemented by the Visitor Pattern that shows how Domain functionality can be encapsulated outside the Business Classes, keeping the Domain lean and easy to manage.

The chapter finishes with the Role Pattern, which is used to implement flexible and powerful dynamic types and roles. Roles are essential parts of problem domains that require solutions ranging from static, non-changing roles to flexible, changing roles, assuming multiple roles and providing polymorphism across all roles.

All these topics will be applied and further elaborated in later chapters. It will be done in the context of a real-world application that will clearly demonstrate the need for these various strategies.

• OO Principles
  • Encapsulation
  • Specialization
  • Self-Sufficiency
  • Interface
  • Instantiation
  • Abstraction
  • Inheritance
  • Polymorphism
• Class Relationships
  • Inheritance
  • Composition
  • Aggregation
  • Association
  • Association Class
  • Ternary Association
• Encapsulation & Specialization
• Inheritance & Polymorphism
• Polymorphism Strategies
  • Replacement Method Pattern
  • Extension Method Pattern
  • Template Method Pattern
• Association Implementation Basics
• Object Collaboration
• Propagation Pattern
• Visitor Pattern (Advanced)
• The Role Pattern
  • Inheritance Roles
  • Association Roles
  • Role Classes
  • Role Class Generalization
  • Association Class Roles
  • Association Class Roles with Role Type

3

Real-World Application Example
Applying Advanced OO Design on a Real-World Case Study

All object design principles and patterns are best understood in a real-life situation. In this chapter we introduce the artifacts of a real-world problem domain: the scheduling and registration for Public Training Classes. We will use this domain throughout the remainder of the course to exercise many important design principles and patterns.

This hands-on approach helps students to see clearly the need for patterns and to appreciate the design solutions they offer. It will then be very easy to apply these solutions at work.

• The "Public Training Administration" domain example
• Business Synopsis
• Domain Model
• Use Cases
  • Prerequisites
  • Domain Models
  • Scenarios
  • Sequence Diagrams
  • Implementation Steps

3

Application Architecture
Structuring an application's architecture around its domain model

Before we start the design of our sample application and all the implementation details, we must look at the big picture. This chapter shows the architecture of a typical enterprise application and where the domain model fits in.

• Layering of an Enterprise Application
• Java Enterprise (Java EE) Architecture
• Domain Persistence Overview
  • Pure OO persistence
  • OO to Relational persistence
  • Pure Relational persistence
  • When and how to combine strategies

3

Domain Model Design
From analysis model to detailed design

The analysis domain model that was introduced earlier as well as all other analysis artifacts lay the foundation for the detailed design. This chapter covers the considerations and refinements necessary to prepare the domain model for successful implementation.

• Add a Layer Supertype
• Design Attribute Type Classes
• Decide on Attribute Accessibility
• Decide on Association Navigability
• Design Roles according to the required flexibility
• Choose Object and Link construction & management strategies
• Provide client developer interface(s)

3-4

Domain Model Implementation
Converting class diagrams to code

This is a nuts-and-bolts chapter that reveals the implementation details of what has been learned so far. Additional concepts and techniques are introduced in the context of the sample application. Students learn how to implement each detail of the Domain Model including how to manage objects, their relationships and how to provide client access. By the end of this chapter students feel very confident in converting a design model into clean object-oriented code. That type of code is well-structured, maximizes reusability, and therefore provides the platform for high extensibility and maintainability. Consequently, the time-to-market for new features will naturally become shorter.

• Implement Classes & Attributes
• Design Constructors
• Provide Accessor/Mutator Methods
• Object Construction Implementation
  • Constructor
  • Creation Method Pattern
  • Object Factory Pattern
  • Singleton Pattern
• Association Implementation
• Link Management
  • Client-Managed Associations
  • Object-Managed Associations
  • Link Factory Pattern
  • Introspective Link Factory
• Object Identity, Equality & Cloning
  • Object Identity
  • Domain Identity
  • Database Identity
• Client Access
  • Façade Pattern
  • Service Layer

4

Comprehensive Project
Integrating the OO Design Principles and Advanced Design Patterns in a real-world application

At this point it is important for students to experience what issues may arise while implementing a real application. This chapter uses the analysis and design artifacts discussed earlier and many of the OO design techniques learned so far to build the application at hand.

• Domain Design Model
• Layers and Packages
• Application Architecture
• Use Case Implementation
  • Class Implementation
  • Object Construction
  • Association Implementation
  • Association Management
  • Business Logic
  • Client Access

5

The Rules Engine Framework (Advanced)
Offering Dynamic Behavior to End-users or Business Experts

Business rules change more frequently than any other aspect of your enterprise applications. Historically, business rules have been hard-coded as part of the business logic. To provide greater flexibility and control it is a far better approach to encapsulate the rules separately from the domain model, make them dynamic and manage them with a Rules Engine. In this chapter we go over the entire OO analysis and design of a simple but powerful Rules Engine. We analyze what rules are, build a UML model, design a Rules Engine, explore its code and finally extend the engine with additional features during a lab. This is a great opportunity to not only understand Rules Engines but also apply many of the OO Development techniques studied in this course. Furthermore, this chapter introduces additional Design Patterns like "Command", "Composite", "Interpreter" and "Façade". Students see that these patterns emerge from the need to solve specific problems. This is the most effective way to learn Design Patterns.

• Definition
• Class-based / object-based rules
• Object rules challenges and solutions
• Rules Engine features
• Commonly used Rules Engines
• Rules Engine architecture
• Rule instance examples and analysis
• Rule UML model essentials
• Rules narrative, UI and "soft" coding
• Elaborated model
• Rules Structure
  • "Composite" rule
  • "If" structure
  • "Comparison" model
  • "Test", "Value", and "Method"
• Design Patterns used
  • Composite
  • Command
  • Façade
  • Interpreter
• Summary and conclusions
• Rules Engine Lab
  • Creating your own rules
  • Extending the Rules Engine
• Deciding if/when you need a Rules Engine

5

Appendix (Optional)
Additional Design Patterns material that we cover if time allows

• Patterns Catalog
• Additional Design Patterns
  • Prototype
  • Command
  • Template