本篇文章总结的是书籍：
Design Patterns--Elements of Reusable Object-Oriented Software
设计模式_可复用面向对象软件的基础
MVC是什么？
MVC的组成：MVC模式包括模型（Model）、视图（View）和控制器（Controller）三部分。
• Model：负责应用程序的数据和业务逻辑。
• View：负责用户界面的显示。
• Controller：处理用户输入并更新Model和View。
- MVC的优点：
• 分离关注点：将数据、界面和输入逻辑分开，使得代码更易于管理和维护。
• 模块化：通过模块化的设计，MVC允许组件重用和独立开发。
• 灵活性：不同的视图可以共享同一个模型，实现多种用户界面。
看完是不是干巴巴的，似懂非懂，所有知识都要结合例子来理解：
具体例子：图书管理系统
假设我们要开发一个图书管理系统，通过这个系统，用户可以添加、删除和查看书籍信息。我们将使用MVC模式来实现这个系统。
- 模型（Model）
模型负责处理数据和业务逻辑。在这个例子中，模型包括图书的信息（如书名、作者、出版日期等）。
show me the code!
class Book:
def __init__(self, title, author, publication_date):
self.title = title
self.author = author
self.publication_date = publication_date
class LibraryModel:
def __init__(self):
self.books = []
self.observers = []
def add_book(self, book):
self.books.append(book)
self.notify_observers()
def remove_book(self, book):
self.books.remove(book)
self.notify_observers()
def get_books(self):
return self.books
def add_observer(self, observer):
self.observers.append(observer)
def remove_observer(self, observer):
self.observers.remove(observer)
def notify_observers(self):
for observer in self.observers:
observer.update()
- 视图（View）
视图负责展示数据。在这个例子中，我们有不同的视图来展示图书信息，如列表视图和详细视图。
class BookListView:
def display_books(self, books):
for book in books:
print(f"Title: {book.title}, Author: {book.author}, Publication Date: {book.publication_date}")
class BookDetailView:
def display_book(self, book):
print(f"Title: {book.title}")
print(f"Author: {book.author}")
print(f"Publication Date: {book.publication_date}")
- 控制器（Controller）
控制器处理用户输入并更新模型。在这个例子中，控制器负责处理添加和删除书籍的操作。
class LibraryController:
def __init__(self, model, list_view, detail_view):
self.model = model
self.list_view = list_view
self.detail_view = detail_view
self.model.add_observer(self)
def add_book(self, title, author, publication_date):
book = Book(title, author, publication_date)
self.model.add_book(book)
def remove_book(self, title):
book = next((b for b in self.model.get_books() if b.title == title), None)
if book:
self.model.remove_book(book)
def update(self):
self.list_view.display_books(self.model.get_books())
整合MVC
现在我们将模型、视图和控制器整合起来，实现完整的图书管理系统。
if __name__ == "__main__":
# 创建模型、视图和控制器
model = LibraryModel()
list_view = BookListView()
detail_view = BookDetailView()
controller = LibraryController(model, list_view, detail_view)
# 添加书籍
controller.add_book("The Great Gatsby", "F. Scott Fitzgerald", "1925")
controller.add_book("1984", "George Orwell", "1949")
# 移除书籍
controller.remove_book("1984")
# 显示书籍列表
list_view.display_books(model.get_books())
通过这种设计，系统各个部分之间的耦合度降低，便于维护和扩展。例如，我们可以轻松添加新的视图类型（如图形化界面）而无需修改模型和控制器。
请仔细阅读以上代码，特别注意我们对模型（Model）的设计：LibraryModel类包含图书信息，并通知观察者视图进行更新。
既然例子中提到了观察者，我们顺带简单的介绍一下观察者模式在这里的使用，可以方便我们在后面学习中理解：
观察者模式概述
观察者模式是一种设计模式，其中一个对象（称为“主体”或“被观察者”）维护一组依赖于它的对象（称为“观察者”），并在自身状态发生变化时通知这些观察者。这个模式在MVC结构中非常常见，因为它能让模型（Model）在数据变化时自动通知视图（View）进行更新。
代码解析
- LibraryModel 类
在 LibraryModel 类中，模型包含图书信息，并维护一个观察者列表。当图书信息发生变化时，它会通知所有观察者。
class LibraryModel:
def __init__(self):
self.books = [] # 存储图书的列表
self.observers = [] # 存储观察者的列表
def add_book(self, book):
self.books.append(book)
self.notify_observers() # 通知所有观察者
def remove_book(self, book):
self.books.remove(book)
self.notify_observers() # 通知所有观察者
def get_books(self):
return self.books
def add_observer(self, observer):
self.observers.append(observer)
def remove_observer(self, observer):
self.observers.remove(observer)
def notify_observers(self):
for observer in self.observers:
observer.update() # 调用每个观察者的 update 方法
- LibraryController 类
在 LibraryController 类中，控制器处理用户输入并更新模型。当模型数据发生变化时，控制器作为观察者会收到通知，并调用相应的视图更新方法。
class LibraryController:
def __init__(self, model, list_view, detail_view):
self.model = model
self.list_view = list_view
self.detail_view = detail_view
self.model.add_observer(self) # 将控制器添加为模型的观察者
def add_book(self, title, author, publication_date):
book = Book(title, author, publication_date)
self.model.add_book(book)
def remove_book(self, title):
book = next((b for b in self.model.get_books() if b.title == title), None)
if book:
self.model.remove_book(book)
def update(self):
self.list_view.display_books(self.model.get_books()) # 更新视图
观察者模式的工作流程
1. 添加观察者：
• 在 LibraryController 初始化时，调用 self.model.add_observer(self)，将控制器自身添加为模型的观察者。
2. 通知观察者：
• 当模型中的数据发生变化（如添加或删除图书）时，模型调用 notify_observers 方法。
• notify_observers 方法遍历所有观察者，并调用每个观察者的 update 方法。
3. 更新视图：
• 控制器实现了 update 方法，当它被模型调用时，会更新视图中的数据。例如，调用 self.list_view.display_books(self.model.get_books()) 更新图书列表视图。
此处我们再拓展一下：
MVC经常还会运用到别的设计模式，比如组合和策略模式
组合模式与MVC的结合
我们可以将组合模式用于视图（View）部分，通过组合不同的视图组件来构建复杂的用户界面。例如，我们可以将书籍视为基本组件，而类别视为包含书籍或其他子类别的组合组件。这样，我们可以创建一个层次结构的视图。
组合模式的实现
1. LibraryComponent 类：定义了基本的接口。
2. BookView 类：表示单个书籍。
3. CategoryView 类：表示类别，可以包含书籍和子类别。
class LibraryComponent:
def display(self, indent=0):
pass
class BookView(LibraryComponent):
def __init__(self, book):
self.book = book
def display(self, indent=0):
print(" " * indent + f"Book: {self.book.title}, Author: {self.book.author}, Publication Date: {self.book.publication_date}")
class CategoryView(LibraryComponent):
def __init__(self, name):
self.name = name
self.components = []
def add(self, component):
self.components.append(component)
def remove(self, component):
self.components.remove(component)
def display(self, indent=0):
print(" " * indent + f"Category: {self.name}")
for component in self.components:
component.display(indent + 2)
在控制器中使用组合视图
控制器中添加和删除书籍时，同时更新组合视图。
class LibraryController:
def __init__(self, model, root_view):
self.model = model
self.root_view = root_view
self.model.add_observer(self)
def add_book(self, title, author, publication_date, category_name=None):
book = Book(title, author, publication_date)
self.model.add_book(book)
if category_name:
category_view = self.find_category(self.root_view, category_name)
if category_view:
category_view.add(BookView(book))
else:
self.root_view.add(BookView(book))
self.update_view()
def remove_book(self, title):
book = next((b for b in self.model.get_books() if b.title == title), None)
if book:
self.model.remove_book(book)
self.remove_book_view(self.root_view, title)
self.update_view()
def find_category(self, category_view, category_name):
if category_view.name == category_name:
return category_view
for component in category_view.components:
if isinstance(component, CategoryView):
found = self.find_category(component, category_name)
if found:
return found
return None
def remove_book_view(self, category_view, book_title):
for component in category_view.components:
if isinstance(component, BookView) and component.book.title == book_title:
category_view.remove(component)
return
elif isinstance(component, CategoryView):
self.remove_book_view(component, book_title)
def update_view(self):
self.root_view.display()
def update(self):
self.update_view()
示例运行代码
if __name__ == "__main__":
# 创建模型、视图和控制器
model = LibraryModel()
root_view = CategoryView("Library")
controller = LibraryController(model, root_view)
# 创建类别
fiction = CategoryView("Fiction")
classics = CategoryView("Classics")
modern_classics = CategoryView("Modern Classics")
# 添加类别到根视图
root_view.add(fiction)
fiction.add(classics)
fiction.add(modern_classics)
# 添加书籍到类别
controller.add_book("The Great Gatsby", "F. Scott Fitzgerald", "1925", "Classics")
controller.add_book("1984", "George Orwell", "1949", "Classics")
controller.add_book("To Kill a Mockingbird", "Harper Lee", "1960", "Modern Classics")
# 显示类别和书籍
controller.update_view()
# 移除书籍
controller.remove_book("1984")
print("\nAfter removing '1984':")
controller.update_view()
运行结果
Category: Library
Category: Fiction
Category: Classics
Book: The Great Gatsby, Author: F. Scott Fitzgerald, Publication Date: 1925
Book: 1984, Author: George Orwell, Publication Date: 1949
Category: Modern Classics
Book: To Kill a Mockingbird, Author: Harper Lee, Publication Date: 1960
After removing '1984':
Category: Library
Category: Fiction
Category: Classics
Book: The Great Gatsby, Author: F. Scott Fitzgerald, Publication Date: 1925
Category: Modern Classics
Book: To Kill a Mockingbird, Author: Harper Lee, Publication Date: 1960
策略模式与MVC的结合
我们可以在控制器（Controller）中使用策略模式，以不同的排序策略来排序图书列表，并将排序后的结果传递给视图（View）。
策略模式在控制器中的实现
from abc import ABC, abstractmethod
class SortStrategy(ABC):
@abstractmethod
def sort(self, books):
pass
class TitleSortStrategy(SortStrategy):
def sort(self, books):
return sorted(books, key=lambda book: book.title)
class AuthorSortStrategy(SortStrategy):
def sort(self, books):
return sorted(books, key=lambda book: book.author)
class PublicationDateSortStrategy(SortStrategy):
def sort(self, books):
return sorted(books, key=lambda book: book.publication_date)
在控制器中使用排序策略
class LibraryController:
def __init__(self, model, category_view, strategy: SortStrategy):
self.model = model
self.category_view = category_view
self.strategy = strategy
self.model.add_observer(self)
def set_strategy(self, strategy: SortStrategy):
self.strategy = strategy
def add_book(self, title, author, publication_date):
book = Book(title, author, publication_date)
self.model.add_book(book)
self.update_view()
def remove_book(self, title):
book = next((b for b in self.model.get_books() if b.title == title), None)
if book:
self.model.remove_book(book)
self.update_view()
def update_view(self):
sorted_books = self.strategy.sort(self.model.get_books())
self.category_view.components = [BookView(book) for book in sorted_books]
self.category_view.display()
def update(self):
self.update_view()
策略模式在MVC中的结合示例
if __name__ == "__main__":
# 创建模型、视图和控制器
model = LibraryModel()
category_view = CategoryView("Library")
controller = LibraryController(model, category_view, TitleSortStrategy())
# 添加书籍
controller.add_book("The Great Gatsby", "F. Scott Fitzgerald", "1925")
controller.add_book("1984", "George Orwell", "1949")
controller.add_book("To Kill a Mockingbird", "Harper Lee", "1960")
# 显示书籍列表
controller.update_view()
# 切换排序策略
controller.set_strategy(AuthorSortStrategy())
print("\nBooks sorted by author:")
controller.update_view()
controller.set_strategy(PublicationDateSortStrategy())
print("\nBooks sorted by publication date:")
controller.update_view()
运行结果
Category: Library
Book: 1984, Author: George Orwell, Publication Date: 1949
Book: The Great Gatsby, Author: F. Scott Fitzgerald, Publication Date: 1925
Book: To Kill a Mockingbird, Author: Harper Lee, Publication Date: 1960
Books sorted by author:
Category: Library
Book: The Great Gatsby, Author: F. Scott Fitzgerald, Publication Date: 1925
Book: To Kill a Mockingbird, Author: Harper Lee, Publication Date: 1960
Book: 1984, Author: George Orwell, Publication Date: 1949
Books sorted by publication date:
Category: Library
Book: The Great Gatsby, Author: F. Scott Fitzgerald, Publication Date: 1925
Book: 1984, Author: George Orwell, Publication Date: 1949
Book: To Kill a Mockingbird, Author: Harper Lee, Publication Date: 1960
• 组合模式（Composite Pattern）：在视图层中，CategoryView 作为容器，可以包含多个 BookView 和 CategoryView，每个 CategoryView 可以进一步包含子类别和书籍。这使得我们能够创建一个层次结构的视图，展示图书和类别的关系。
• 策略模式（Strategy Pattern）：在控制器层中，使用不同的排序策略（如按标题、作者和出版日期排序），根据用户的需求动态改变图书排序方式，并更新视图。
• 观察者模式（Observer Pattern）：模型变化时通知控制器，控制器更新视图。
通过这种设计，我们将组合模式和策略模式整合到MVC架构中，实现了一个灵活、可扩展的图书管理系统。
