软件体系结构期末复习（二）

2023年06月05日 2.4k 字大概 10 分钟

此文章仅用作期末复习

一、Aggregate Pattern聚合模式

Aggregate Pattern是一种设计模式，在这种模式中，集合对象（如List、Map等）可以用统一的方式来访问和处理其中的元素，而不用关心具体的实现细节。这种模式可以简化代码的复杂度，提高代码的可维护性和可扩展性。

Aggregate Pattern的核心思想是将集合对象和其中的元素进行分离，从而可以对集合对象进行统一的处理，而不用先对集合对象进行遍历，再对每个元素进行处理。

Python代码举例：

class Book:
    def __init__(self, title, author, price):
        self.title = title
        self.author = author
        self.price = price

class BookCollection:
    def __init__(self):
        self.books = []

    def add_book(self, book):
        self.books.append(book)

    def get_total_price(self):
        return sum(book.price for book in self.books)

    def get_author_books(self, author):
        return [book.title for book in self.books if book.author == author]

# 创建一个书的集合
collection = BookCollection()

# 添加几本书
collection.add_book(Book("The Lord of the Rings", "J.R.R. Tolkien", 20))
collection.add_book(Book("The Hobbit", "J.R.R. Tolkien", 15))
collection.add_book(Book("Harry Potter", "J.K. Rowling", 18))

# 计算书的总价值
total_price = collection.get_total_price()
print("Total price:", total_price)

# 获取某个作者的书名
author_books = collection.get_author_books("J.R.R. Tolkien")
print("Books by J.R.R. Tolkien:", author_books)

在这个例子中，Book表示一本书，BookCollection表示一个包含多本书的集合，可以对集合中的书进行总价值计算和按作者查找操作。使用Aggregate Pattern的好处是，BookCollection可以对书进行统一的操作，而不用关心每本书的具体实现细节。

二、Events Pattern事件模式

Events Pattern是一种设计模式，用于处理事件。它使得程序能够在运行时监听和响应事件，而不需要显式地调用函数或方法。

其作用和意义在于：

使程序更加灵活和可扩展。使用Events Pattern可以将不同模块间的耦合度降低，增加模块的独立性和复用性。
使程序更加易于测试。使用Events Pattern可以更方便地测试程序的各个部分，降低测试的维护成本。
使程序更加易于理解和维护。使用Events Pattern可以将大量的逻辑分散到各个事件处理函数中，使得程序逻辑更加清晰。

以下是一个简单的Python例子：

class Event:
    def __init__(self, name):
        self.name = name

class EventDispatcher:
    def __init__(self):
        self.listeners = {}

    def add_listener(self, event_name, listener):
        if not event_name in self.listeners:
            self.listeners[event_name] = []

        self.listeners[event_name].append(listener)

    def remove_listener(self, event_name, listener):
        if event_name in self.listeners:
            listeners = self.listeners[event_name]
            if listener in listeners:
                listeners.remove(listener)

    def dispatch_event(self, event):
        event_name = event.name
        if event_name in self.listeners:
            listeners = self.listeners[event_name]
            for listener in listeners:
                listener(event)

dispatcher = EventDispatcher()

def on_event(event):
    print(event.name)

dispatcher.add_listener('my event', on_event)

event = Event('my event')
dispatcher.dispatch_event(event)

dispatcher.remove_listener('my event', on_event)

这个例子中，我们定义了一个Event类，代表事件。然后定义了一个EventDispatcher类，用于分发事件和管理事件监听器。最后我们定义了一个on_event函数，用于处理事件。

在主程序中，我们首先创建了一个EventDispatcher对象，并添加了一个事件监听器，当事件发生时，就会调用on_event函数来处理。然后我们创建了一个事件对象，并分发给EventDispatcher，从而触发了事件处理。最后，我们移除了事件监听器。

三、Message Bus Pattern消息总线模式

Message Bus Pattern是一种用于应用程序中不同组件通信的设计模式。它提供了一种中心化的消息传递机制，让不同组件能够以松散耦合的方式进行通信。

在Message Bus Pattern中，消息总线由一个中心化的消息队列组成，各个组件可以将消息发送到消息队列中，并可以从中获取其他组件发送的消息。消息总线还可以提供一些额外的功能，如消息广播、消息过滤、消息路由等。

使用Message Bus Pattern可以有效地解耦应用程序中不同组件之间的关系，降低组件之间的依赖性，提高应用程序的灵活性和可扩展性。

在Python中可以使用第三方库如PyPubSub来实现Message Bus Pattern。下面是一个简单的例子：

from pubsub import pub

class MyComponent:
    def __init__(self):
        self.value = ""
        pub.subscribe(self.on_message, "test")

    def on_message(self, msg):
        self.value = msg

    def get_value(self):
        return self.value

class MyApp:
    def __init__(self):
        self.component = MyComponent()

    def run(self):
        pub.sendMessage("test", msg="Hello World!")
        print(self.component.get_value())

app = MyApp()
app.run()

在这个例子中，MyComponent是一个组件，它订阅了名为”test”的消息。当有消息发送到”test”的时候，MyComponent会调用on_message方法更新自己的状态。MyApp是一个应用程序，它将一个消息发送到”test”，并输出MyComponent的值。这样，在MyApp和MyComponent之间就实现了一种简单的消息传递方式，它们之间并没有直接的依赖关系。

四、Onion Architecture洋葱模式

Onion Architecture是一种软件设计模式，它的主要思想是将应用程序按照不同的层次进行分离，以便更好地维护和测试整个应用程序。这种架构的核心思想是将应用程序分为三个主要的层次：表示层、应用层和领域层。各个层次之间相互隔离，从而形成一个可扩展、可维护且高度可测试的应用程序。

领域层：该层包含应用程序的核心业务逻辑，它也是整个应用程序的基础。领域层的目的是将业务逻辑和数据从其它部分隔离开来，从而使得业务逻辑更加清晰、易于理解和维护。
应用层：该层是领域层和表示层之间的桥梁。它包含与用户交互的逻辑，并将用户的请求传递给领域层进行处理。应用层还负责处理事务和安全性等方面的关注点。
表示层：该层包含用户界面和所有与用户交互的逻辑。表示层接受用户输入，并将其传递给应用层进行处理。表示层还负责将处理结果呈现给用户。

使用Onion Architecture设计一个程序，可以带来以下好处：

更好的可测试性：不同的层次之间相互隔离，从而可以更容易地编写单元测试和集成测试。
更好的可维护性：不同的层次之间相互隔离，从而可以更容易地进行代码维护和修改。
更好的可扩展性：由于不同的层次之间相互隔离，因此可以更容易地添加新功能。

下面是一个简单的Python代码示例，该示例使用Onion Architecture实现了一个名为“Hello World”的应用程序：

领域层：

1
2
3

class Greeter:
    def greet(self, name: str) -> str:
        return f"Hello, {name}!"

应用层：

class GreetingService:
    def __init__(self, greeter: Greeter):
        self.greeter = greeter

    def greet(self, name: str) -> str:
        return self.greeter.greet(name)

表示层：

class Console:
    def __init__(self, greeting_service: GreetingService):
        self.greeting_service = greeting_service
        
    def run(self):
        name = input("What is your name? ")
        greeting = self.greeting_service.greet(name)
        print(greeting)

在这个代码示例中，Greeter类表示领域层，GreetingService类表示应用层，Console类表示表示层。整个应用程序的控制流程由Console类来控制，在用户输入名字之后，会调用GreetingService类中的greet方法，进而调用Greeter类中的greet方法，最终返回一个问候语到控制台中。整个应用程序的结构清晰、易于理解，并且不同的层次之间相互隔离。

五、Layered Architecture分层架构

Layered Architecture（分层架构）是一种软件设计模式，将软件系统的不同部分分为多个层次，每个层次专门负责一种或多种功能。每个层次之间都有严格的接口规范，可以使系统更加模块化和可维护。

Layered Architecture的主要作用是提高软件系统的灵活性和可扩展性。由于不同层次之间都有清晰的界限和规范，可以降低模块之间的耦合度，使得各个模块之间更加独立。此外，由于每个层次都有自己的功能，可以使得系统的功能更加清晰，易于理解和维护。

下面是一个简单的Python代码示例，展示了一个基于Layered Architecture的计算器程序：

class View:
    def get_user_input(self):
        pass

    def show_result(self, result):
        pass

class Controller:
    def __init__(self, view, model):
        self.view = view
        self.model = model

    def run(self):
        user_input = self.view.get_user_input()
        result = self.model.calculate(user_input)
        self.view.show_result(result)

class Model:
    def calculate(self, user_input):
        pass

view = View()
model = Model()
controller = Controller(view, model)
controller.run()

在上面的示例中，View层负责显示用户界面和获取用户的输入，Model层负责计算逻辑，Controller层将View和Model连接起来，实现用户输入与计算逻辑之间的交互。这三个层次之间都有严格的接口规范，实现了各自的功能，并且可以轻松地扩展或修改某个层次的功能而不影响其他层次的正常运行。

总之，分层架构是一种非常常见的软件设计模式，可以使软件系统更加灵活，易于维护和扩展。在实际开发中，需要根据具体情况确定各个层次的功能和接口规范，并严格遵守规范，以达到更好的效果。