CMPT 270: MVC Architecture Quiz

CMPT 270: Developing Object Oriented Systems - Model-View-Controller Architecture

• The course covers object-oriented system development using the Model-View-Controller (MVC) architecture.
• Learning objectives include understanding MVC architecture, differentiating it from three-layer architecture, and implementing MVC using the Observer pattern.

Model-View-Controller Design Pattern

• Model: Holds and manipulates data, performs business logic, notifies the View when data changes.
• View: Takes user input, presents and visualizes data.
• Controller: Receives user input, converts it into messages for the Model.

MVC - Interaction Cycle

• The MVC architecture mirrors the human interaction cycle with an interactive application.
• The flow is: Real World → User → View → Controller → Model → Program/System

Benefits of MVC

• Provides a recognizable structure to applications.
• Offers separation of concerns, which promotes code reusability.

Adoption of MVC

• MVC, originally introduced in SmallTalk in the 1970s, is language- and platform-agnostic.
• It's commonly used to develop user interfaces by dividing related program logic into three interconnected elements.
• Frequently used in games and visually interactive systems (like drawing applications).

Exercise 1: A Simple MVC System

• Create classes for the Model, View, and Controller.
• Develop a simple incrementing calculator program using MVC.

MVC with Observer Pattern

• The View implements the Observer interface.
• The Model's update() method is called when its data changes.
• The Model tells the View its data has changed using notifyObservers().

Model - Observable

• The Model should inherit from the Observable class in Java.
• This lets the Model have Observers added to it.
• The addObserver() method is inherited from the Observable class.
• model.addObserver(view) is typically placed after creating the Model and View to enable the View to receive notifications when the Model changes.

In the Model

• After making a data change, use setChanged() to signal the data alteration.
• notifyObservers() tells all observers the model has updated.
• This triggers the update() method in the observers.

Updating the View

• The View, after being notified of an update, can either fetch model data using accessor methods (pull) or receive updated data directly (push).
• When employing pull, the View must access the Model (typically as an instance variable).

Push Updates

• Use notifyObservers(Object arg) to send specific data to observers when the model changes. This is a push update method.
• If push updates are used, the View does not need direct access to the model.

Observers

• A model can have multiple observers.
• All observers are notified when the model changes.
• The Model has little knowledge of its observers; this promotes code reuse and reduces coupling.

Controller

• The controller handles user interactions and communicates to the Model.
• If a user action (like a button click) occurs, the controller tells the Model to change.
• This triggers notifications to observers (like the View), that data may have changed.

Example 2: MVC with Observer

• Refactor the simple MVC system to integrate the Observer pattern.

Exercise 3: MVC with Multiple Views

• MVC with the Observer pattern promotes loose coupling between the Model and View.
• Multiple views can receive updates from the Model and display the model in different ways (e.g., video game, minimap).
• Add a second view and include it in the Model's observers.

Summary

• MVC is commonly used to build interactive systems.
• The Observer pattern simplifies updating the view when the model changes.