设计模式入门教程 — 代码设计的艺术

编程教程 管理员 2026年06月23日 125 次阅读 1379 字 约 5 分钟
适用人群：有编程基础的开发者
学习时长：约1-2周（每天1-2小时）
重要程度：★★★☆☆（进阶提升）

一、什么是设计模式？

设计模式是前人总结的代码设计经验，用于解决特定场景下的常见问题。

类型模式说明
创建型单例、工厂、建造者对象创建方式
结构型适配器、装饰器、代理对象组合方式
行为型观察者、策略、模板方法对象交互方式

二、创建型模式

2.1 单例模式（Singleton）

# 保证一个类只有一个实例
class Database:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.connection = None
        return cls._instance
    
    def connect(self):
        if not self.connection:
            self.connection = "数据库连接已建立"
        return self.connection

# 使用
db1 = Database()
db2 = Database()
print(db1 is db2)  # True

// JavaScript单例
class Database {
  static instance = null
  
  static getInstance() {
    if (!Database.instance) {
      Database.instance = new Database()
    }
    return Database.instance
  }
  
  constructor() {
    this.connection = null
  }
  
  connect() {
    if (!this.connection) {
      this.connection = '数据库连接已建立'
    }
    return this.connection
  }
}

2.2 工厂模式（Factory）

# 根据参数创建不同对象
class User:
    def __init__(self, name, role):
        self.name = name
        self.role = role

class UserFactory:
    @staticmethod
    def create(name, role):
        if role == 'admin':
            return AdminUser(name)
        elif role == 'editor':
            return EditorUser(name)
        else:
            return User(name, role)

class AdminUser(User):
    def __init__(self, name):
        super().__init__(name, 'admin')
        self.permissions = ['read', 'write', 'delete']

class EditorUser(User):
    def __init__(self, name):
        super().__init__(name, 'editor')
        self.permissions = ['read', 'write']

# 使用
user = UserFactory.create('张三', 'admin')

2.3 建造者模式（Builder）

# 分步构建复杂对象
class QueryBuilder:
    def __init__(self):
        self._table = None
        self._conditions = []
        self._order = None
        self._limit = None
    
    def table(self, table):
        self._table = table
        return self
    
    def where(self, condition):
        self._conditions.append(condition)
        return self
    
    def order_by(self, field, direction='ASC'):
        self._order = f"{field} {direction}"
        return self
    
    def limit(self, limit):
        self._limit = limit
        return self
    
    def build(self):
        sql = f"SELECT * FROM {self._table}"
        if self._conditions:
            sql += " WHERE " + " AND ".join(self._conditions)
        if self._order:
            sql += f" ORDER BY {self._order}"
        if self._limit:
            sql += f" LIMIT {self._limit}"
        return sql

# 使用
query = (QueryBuilder()
    .table('users')
    .where('age > 18')
    .where('status = "active"')
    .order_by('created_at', 'DESC')
    .limit(10)
    .build())
# SELECT * FROM users WHERE age > 18 AND status = "active" ORDER BY created_at DESC LIMIT 10

三、结构型模式

3.1 适配器模式（Adapter）

# 将不兼容的接口转换为兼容接口
class OldPaymentSystem:
    def process_old_payment(self, amount):
        return f"旧系统处理支付：{amount}元"

class NewPaymentSystem:
    def pay(self, amount, currency):
        return f"新系统处理支付：{amount}{currency}"

class PaymentAdapter:
    def __init__(self, old_system):
        self.old_system = old_system
    
    def pay(self, amount, currency='CNY'):
        return self.old_system.process_old_payment(amount)

# 使用
old_system = OldPaymentSystem()
adapter = PaymentAdapter(old_system)
adapter.pay(100)  # 旧系统处理支付：100元

3.2 装饰器模式（Decorator）

# 动态添加功能
def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"调用函数：{func.__name__}")
        result = func(*args, **kwargs)
        print(f"函数返回：{result}")
        return result
    return wrapper

def cache_decorator(func):
    cache = {}
    def wrapper(*args):
        if args in cache:
            print("从缓存返回")
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return wrapper

@log_decorator
@cache_decorator
def expensive_calculation(n):
    return sum(range(n))

# 使用
expensive_calculation(1000000)

3.3 代理模式（Proxy）

# 控制对象访问
class RealImage:
    def __init__(self, filename):
        self.filename = filename
        self.load_from_disk()
    
    def load_from_disk(self):
        print(f"加载图片：{self.filename}")
    
    def display(self):
        print(f"显示图片：{self.filename}")

class ProxyImage:
    def __init__(self, filename):
        self.filename = filename
        self.real_image = None
    
    def display(self):
        if not self.real_image:
            self.real_image = RealImage(self.filename)
        self.real_image.display()

# 使用
image = ProxyImage("photo.jpg")  # 不立即加载
image.display()  # 第一次调用时才加载

四、行为型模式

4.1 观察者模式（Observer）

# 一对多依赖关系，状态变化时通知所有观察者
class EventEmitter:
    def __init__(self):
        self._listeners = {}
    
    def on(self, event, callback):
        if event not in self._listeners:
            self._listeners[event] = []
        self._listeners[event].append(callback)
    
    def emit(self, event, *args, **kwargs):
        if event in self._listeners:
            for callback in self._listeners[event]:
                callback(*args, **kwargs)
    
    def off(self, event, callback):
        if event in self._listeners:
            self._listeners[event].remove(callback)

# 使用
emitter = EventEmitter()
emitter.on('user_created', lambda user: print(f"用户已创建：{user}"))
emitter.on('user_created', lambda user: print(f"发送欢迎邮件给：{user}"))
emitter.emit('user_created', '张三')

4.2 策略模式（Strategy）

# 定义算法族，使它们可以互相替换
class PaymentStrategy:
    def pay(self, amount):
        raise NotImplementedError

class Alipay(PaymentStrategy):
    def pay(self, amount):
        return f"支付宝支付：{amount}元"

class WechatPay(PaymentStrategy):
    def pay(self, amount):
        return f"微信支付：{amount}元"

class CreditCard(PaymentStrategy):
    def pay(self, amount):
        return f"信用卡支付：{amount}元"

class PaymentContext:
    def __init__(self, strategy):
        self.strategy = strategy
    
    def pay(self, amount):
        return self.strategy.pay(amount)

# 使用
context = PaymentContext(Alipay())
context.pay(100)  # 支付宝支付：100元

context = PaymentContext(WechatPay())
context.pay(100)  # 微信支付：100元

4.3 模板方法模式（Template Method）

# 定义算法骨架，子类实现具体步骤
class DataParser:
    def parse(self, filepath):
        data = self.read_file(filepath)
        parsed = self.parse_data(data)
        self.save(parsed)
    
    def read_file(self, filepath):
        with open(filepath, 'r') as f:
            return f.read()
    
    def parse_data(self, data):
        raise NotImplementedError
    
    def save(self, data):
        print(f"保存数据：{len(data)}条")

class CSVParser(DataParser):
    def parse_data(self, data):
        return data.split('\n')

class JSONParser(DataParser):
    def parse_data(self, data):
        import json
        return json.loads(data)

# 使用
parser = CSVParser()
parser.parse('data.csv')

五、设计原则

原则说明示例
单一职责一个类只做一件事UserService只处理用户逻辑
开闭原则对扩展开放，对修改关闭用继承/接口扩展功能
里氏替换子类可以替换父类Admin可以替换User
接口隔离接口要小而专分离读写接口
依赖反转依赖抽象而非具体依赖接口而非实现类

学习建议

  1. 先理解SOLID原则，这是设计模式的基础
  2. 掌握常用模式：单例、工厂、观察者、策略
  3. 在实际项目中应用，不要为了用而用
  4. 理解模式的适用场景，知道什么时候该用
  5. 不要过度设计，简单优先
返回首页