行为型模式-策略模式和责任链模式对比

一、区别：

目的和问题解决方式：
- 策略模式的主要目的是将一组算法或行为封装成独立的策略对象，并使客户端能够在运行时选择其中一个策略来执行。这种模式通常用于实现相同操作的不同算法或策略之间的切换和替换。
- 责任链模式的主要目的是将请求的发送者和接收者解耦，允许多个对象依次处理请求，直到其中一个对象能够处理请求为止。责任链模式通常用于创建一个处理请求的对象链，每个对象都尝试处理请求，如果它不能处理，则将请求传递给下一个对象，以此类推，直到找到一个合适的处理者。
参与者：
- 策略模式通常涉及两个主要参与者：上下文（Context）和策略（Strategy）。上下文是客户端与策略对象交互的接口，策略是实际执行的算法或行为的接口。
- 责任链模式涉及多个处理器或处理者对象，它们组成一个链。每个处理器都有一个处理请求的方法，并且知道下一个处理者是谁。请求从链的开头传递到链的末尾，直到有一个处理者处理它或者请求到达链的末尾。
关注点：
- 策略模式关注于选择不同的算法或策略来完成特定的任务，强调了替代性。
- 责任链模式关注于将请求沿着链传递，并由适当的处理者处理，强调了请求的传递和处理。
适用场景：
- 策略模式适用于需要在运行时动态选择算法或策略的情况，以及避免使用大量的条件语句来实现不同行为的情况。
- 责任链模式适用于具有多个对象处理请求的情况，每个对象可以决定是否处理请求，以及如何传递请求，例如日志记录、异常处理等场景。

总的来说，策略模式用于选择不同的策略或算法，而责任链模式用于将请求传递给一系列对象，直到找到一个合适的处理者。它们解决不同类型的问题，根据具体情况选择合适的模式来实现更清晰和可维护的代码。

我们通过具体的示例来说明策略模式和责任链模式的区别。

二、策略模式示例

假设你正在开发一个电商网站，需要计算商品的折扣价格。不同类型的商品可以有不同的折扣策略，例如普通商品按原价销售，VIP用户享受9折优惠，促销商品打7折，以及其他可能的折扣策略。

策略模式代码示例：

# 抽象策略接口
class DiscountStrategy:
    def apply_discount(self, original_price):
        pass

# 具体策略类
class RegularCustomerDiscount(DiscountStrategy):
    def apply_discount(self, original_price):
        return original_price

class VipCustomerDiscount(DiscountStrategy):
    def apply_discount(self, original_price):
        return original_price * 0.9

class SaleDiscount(DiscountStrategy):
    def apply_discount(self, original_price):
        return original_price * 0.7

# 上下文类
class ShoppingCart:
    def __init__(self, discount_strategy):
        self.discount_strategy = discount_strategy

    def checkout(self, cart_total):
        return self.discount_strategy.apply_discount(cart_total)

# 客户端代码
cart_total = 100.0
regular_customer = ShoppingCart(RegularCustomerDiscount())
vip_customer = ShoppingCart(VipCustomerDiscount())
sale = ShoppingCart(SaleDiscount())

print("Regular customer total:", regular_customer.checkout(cart_total))
print("VIP customer total:", vip_customer.checkout(cart_total))
print("Sale total:", sale.checkout(cart_total))

在这个例子中，策略模式允许你在运行时选择不同的折扣策略，而不需要修改购物车类。

三、责任链模式示例

现在，假设你的电商网站需要一个日志记录系统，可以根据不同的日志级别将日志消息传递给不同的日志处理器。日志级别包括DEBUG、INFO、WARNING和ERROR，每个级别都有不同的处理方式，例如将DEBUG级别的日志保存到文件，将ERROR级别的日志发送给管理员。

责任链模式代码示例：

# 抽象处理器接口
class Logger:
    def set_next(self, next_logger):
        pass

    def log_message(self, level, message):
        pass

# 具体处理器类
class DebugLogger(Logger):
    def set_next(self, next_logger):
        self.next_logger = next_logger

    def log_message(self, level, message):
        if level == "DEBUG":
            print(f"Debug Log: {message}")
        elif self.next_logger:
            self.next_logger.log_message(level, message)

class InfoLogger(Logger):
    def set_next(self, next_logger):
        self.next_logger = next_logger

    def log_message(self, level, message):
        if level == "INFO":
            print(f"Info Log: {message}")
        elif self.next_logger:
            self.next_logger.log_message(level, message)

class ErrorLogger(Logger):
    def set_next(self, next_logger):
        self.next_logger = next_logger

    def log_message(self, level, message):
        if level == "ERROR":
            print(f"Error Log: {message}")
        elif self.next_logger:
            self.next_logger.log_message(level, message)

# 客户端代码
debug_logger = DebugLogger()
info_logger = InfoLogger()
error_logger = ErrorLogger()

debug_logger.set_next(info_logger)
info_logger.set_next(error_logger)

debug_logger.log_message("DEBUG", "This is a debug message.")
debug_logger.log_message("INFO", "This is an info message.")
debug_logger.log_message("ERROR", "This is an error message.")

在这个例子中，责任链模式允许你将日志消息传递给一系列不同的日志处理器，每个处理器决定是否处理消息，以及如何处理。如果某个处理器无法处理消息，它将消息传递给下一个处理器，直到找到合适的处理者。这种方式可以实现灵活的日志记录系统，而不需要修改已有的代码。

总结：策略模式用于选择不同的策略来处理不同的情况，而责任链模式用于将请求传递给一系列处理器，直到找到一个合适的处理者，有点像击鼓传花。