20

I've mulled over Design Patterns for some time now and I am just starting to see how I might actually begin incorporating some of these more deliberately in my development work. However, I am still confused about their treatment of MVC in the beginning of the book and how it relates to the rest of the book.

Most of the frameworks I have worked with - Spring, Yii, ASP.NET, and even Objective-C Cocoa (UIKit) - cater to the MVC paradigm. I get MVC because to me it is a useful way of classifying objects and how they should message or interact with each other. Plus, these frameworks kind of force it upon you even if you are not setting out to think in the MVC way.

I also feel that I understand the premise of Design Patterns: they really don't like subclassing, they love abstract interfaces, and they strive for loose coupling. I can't say I fully understand all of the patterns yet or how they are useful, but I am getting a feel for it.

My question is this: what is the interplay between MVC and design patterns? What were they getting at in the first chapter of the book with the MVC application example? Are certain design patterns just not relevant in the MVC paradigm? I wonder, for example, how the Command pattern is supposed to fit into MVC. It seems incredibly useful, but do we create a CommandModel and CommandController to send to other controllers? Do we just create a Command object as prescribed in the book? Basically, I am wondering if the ideas of MVC and Design Patterns are wholly disjoint and I just don't understand, or if there are some patterns that do not fit into the mold.

tacos_tacos_tacos
  • 10,277
  • 11
  • 73
  • 126
  • 1
    this might be a good read: http://stackoverflow.com/questions/3148097/mvc-and-command-pattern – roman Feb 02 '12 at 20:53
  • I think the point of that first section (it is actually chapter 2) was to show that these are real concepts used in real programs, not just another academic work with lofty ideas from the ivory tower. – tcarvin Feb 02 '12 at 21:25

4 Answers4

15

My personnal opinion is that MVC is a simplified version of the Observer Pattern which is a simplified version of the Mediator Pattern.

MVC: One Model, One view, the Controler manages the communication between them.

Observer Pattern: One Model, Multiples views ( observers/subscribers ), and the publisher manages the communication

Mediator Pattern: Several different Models, Several views, and the mediator manages the communications between them.

Stephane Rolland
  • 38,876
  • 35
  • 121
  • 169
  • 1
    I found your zen answer to this question, and I agree completely. – Miroslav Trninic Jul 07 '13 at 11:05
  • I don't think that there is a 1-1 relationship between model and view in MVC. You can easily have multiple views for the same model. At least to my understanding, this is one of the advantages of using MVC; having several representations of the same model that update simultaneously with a single update to the model. – Thomas Eizinger Dec 23 '17 at 20:27
  • @ThomasEizinger but in such case, what differences would you see (if any) with the Observer Pattern ? – Stephane Rolland Dec 24 '17 at 16:54
  • This guy (http://peter.michaux.ca/maria/) for example claims that MVC is actually a combination of three patterns: Observer, Strategy and Composition. I don't have personal experience with Smalltalk (where MVC originated from) but I think it is a reasonable statement to describe MVC as the combination of these three patterns. – Thomas Eizinger Dec 24 '17 at 17:09
  • @ThomasEizinger I will read about it, although my first instinct reaction was that he was wrong. I see no Composition pattern in the MVC, but I will read more so as to understand his point of view. Thanks for the info. – Stephane Rolland Dec 24 '17 at 17:21
  • Probably everybody agree that Model-View part is 100% Observer Pattern(it's maybe harder to understand if you do only WebApp development where you have only one view). My opinion that Controller part is mostly look like Command Pattern(Controller is your command). At UI you click button and some command will be executed. For sure you can find around 5 other patters that have some similarity, but conceptually it's a closest item. – Vitalii Fedoryshyn Feb 18 '22 at 10:13
  • @StephaneRolland next is wrong at this answer(need to mention it, as answer marked as accepted): 1. In MVC pattern can be multiple views(see wiki, see how it was introduced first). 2. I totally disagree about Mediator Pattern, it uses for other goals, just read definition from wiki of GoF book and have a look at UML diagram of current pattern. 3. 'Controler manages the communication between them' - come on, this is wrong statement. – Vitalii Fedoryshyn Feb 18 '22 at 10:20
9

The MVC in the GoF book is for the desktop, it uses the observer pattern to update views. The command example in the GoF book is for an editor.

There are other flavors of MVC where the use of other design patterns may not be obvious:
What is the difference between MVC and MVVM?
Presentation abstraction control

The GoF book says:

...

Taken at face value, this example reflects a design that decouples views from models. But the design is applicable to a more general problem: decoupling objects so that changes to one can affect any number of others without requiring the changed object to know details of the others. This more general design is described by the Observer (page 293) design pattern.

Another feature of MVC is that views can be nested. For example, a control panel of buttons might be implemented as a complex view containing nested button views. The user interface for an object inspector can consist of nested views that may be reused in a debugger. MVC supports nested views with the CompositeView class, a subclass of View. CompositeView objects act just like View objects; a composite view can be used wherever a view can be used, but it also contains and manages nested views.

Again, we could think of this as a design that lets us treat a composite view just like we treat one of its components. But the design is applicable to a more general problem, which occurs whenever we want to group objects and treat the group like an individual object. This more general design is described by the Composite (163) design pattern. It lets you create a class hierarchy in which some subclasses define primitive objects (e.g., Button) and other classes define composite objects (CompositeView) that assemble the primitives into more complex objects.

MVC also lets you change the way a view responds to user input without changing its visual presentation. You might want to change the way it responds to the keyboard, for example, or have it use a pop-up menu instead of command keys. MVC encapsulates the response mechanism in a Controller object. There is a class hierarchy of controllers, making it easy to create a new controller as a variation on an existing one.

A view uses an instance of a Controller subclass to implement a particular response strategy; to implement a different strategy, simply replace the instance with a different kind of controller. It's even possible to change a view's controller at run-time to let the view change the way it responds to user input. For example, a view can be disabled so that it doesn't accept input simply by giving it a controller that ignores input events.

The View-Controller relationship is an example of the Strategy (315) design pattern. A Strategy is an object that represents an algorithm. It's useful when you want to replace the algorithm either statically or dynamically, when you have a lot of variants of the algorithm, or when the algorithm has complex data structures that you want to encapsulate.

MVC uses other design patterns, such as Factory Method (107) to specify the default controller class for a view and Decorator (175) to add scrolling to a view. But the main relationships in MVC are given by the Observer, Composite, and Strategy design patterns.

...

Community
  • 1
  • 1
Ray Tayek
  • 9,841
  • 8
  • 50
  • 90
4

MVC is a pattern. But it only covers a small aspect of a web application. Another common pattern that gets used with MVC is the Repository. These are more architectural patterns.... their scope has a bigger impact on the overall project.

the GOF patterns will introduce themselves in little ways all over the place. They can help build MVC infrastructure depending on design choices. eg, Strategy gets used a lot so you can plug in different ways of doing things like "authentication" etc.

You don't have to use the patterns as they are, they don't even have to be the exact same code structure. Its more the design principle / goal of the pattern that you employ in the design.

Keith Nicholas
  • 43,549
  • 15
  • 93
  • 156
2

MVC is an architectural pattern. It perfectly fits with other design patterns like Command Pattern. But you do not apply patterns just because they exist and they are written in an authoritative book. You apply patterns when you have a programming/design problem and there is a way to solve that problem that was discovered by someone else and was written down. The way to solve a problem is a pattern. For example, you have an application that saves data to the database. Data to be saved is quite complex: some records must be inserted, some records updated and some deleted. The sequence of steps is important because the records to be inserted into one table depend on records to be inserted into another table. So, a database transaction must be used. One of possible ways to implement the transaction is to use Command Pattern. The way to do it is very well explained in Larman's "Applying UML and Patterns" book (chapter "Designing a Persistence Framework wth Patterns", section "Designing a Transaction with the Command Pattern" - scroll down to the page 556). PersistentObject is an abstract Model class there. All other Model classes extend it. In that example MVC is implemented in the UI, Application and Domain layers but Command is implemented in the Persistence layer. These patterns help to solve different problems and they are mutually supportive in that example.

bancer
  • 7,475
  • 7
  • 39
  • 58