GOF设计模式：从原理到实践的软件开发利器

GOF设计模式：从原理到实践的软件开发利器

引用

CSDN

等

15

来源

1.

https://blog.csdn.net/fly910905/article/details/115564961

2.

https://blog.csdn.net/ljx1400052550/article/details/139509099

3.

https://blog.csdn.net/Gypsophila_F/article/details/140608531

4.

https://blog.csdn.net/qq_33204709/article/details/136465784

5.

https://blog.csdn.net/weixin_40030076/article/details/140107997

6.

https://cloud.baidu.com/article/3354113

7.

https://blog.csdn.net/qq_62571013/article/details/140544999

8.

https://blog.csdn.net/weixin_46926189/article/details/136096505

9.

https://blog.csdn.net/weixin_57057153/article/details/136017726

10.

https://blog.csdn.net/m0_55893713/article/details/137596249

11.

https://springframework.guru/gang-of-four-design-patterns/

12.

https://cloud.tencent.com/developer/article/2384805

13.

https://cloud.tencent.com/developer/article/2478381

14.

http://ce-dong.net/article.asp?pid=202&id=695

15.

https://cloud.tencent.com/developer/article/2465357

20多年前，四位软件工程领域的专家（Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides，简称"四人帮"或GOF）共同撰写了《设计模式：可复用的面向对象软件元素》一书，系统地总结了23种经典的设计模式。这些模式不仅在当时引起了巨大反响，至今仍是软件开发领域的重要参考资料，持续占据Amazon畅销书榜单。

什么是设计模式？

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。它提供了一个通用的解决方案模板，用于解决软件开发中常见的问题。设计模式分为三大类，共23种：

• 创建型模式：关注对象的创建过程，如单例模式、工厂模式等。
• 结构型模式：定义对象间的组织结构，如适配器模式、装饰者模式等。
• 行为型模式：描述对象间的交互方式，如观察者模式、策略模式等。

典型设计模式详解

单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供全局访问点。它有两种主要实现方式：饿汉式和懒汉式。

• 饿汉式：在类加载时就创建实例，线程安全但可能造成内存浪费。

  public class Singleton {
      private static Singleton instance = new Singleton();
      private Singleton() {}
      public static Singleton getInstance() {
          return instance;
      }
  }
  

• 懒汉式：在第一次使用时才创建实例，需要使用双重检查锁定来保证线程安全。

  public class Singleton {
      private static volatile Singleton instance;
      private Singleton() {}
      public static Singleton getInstance() {
          if (instance == null) {
              synchronized (Singleton.class) {
                  if (instance == null) {
                      instance = new Singleton();
                  }
              }
          }
          return instance;
      }
  }
  

单例模式常用于日志管理、配置读取等场景。例如，日志管理类只需要一个实例，且需要在程序启动时就可用，因此适合使用饿汉式单例。

观察者模式（Observer Pattern）

观察者模式定义了对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知并自动更新。典型应用场景包括：

• 事件处理：如GUI中的按钮点击事件
• 分布式系统消息通知
• 日志系统
• 股票行情监测

下面是一个简单的Java代码示例：

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update(String message);
}

interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}

class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " 收到消息: " + message);
    }
}

策略模式（Strategy Pattern）

策略模式允许定义一系列算法，并将它们封装在独立的策略类中，使得它们可以互相替换。这在需要动态选择不同实现方式的场景下非常有用，例如：

• 支付方式选择：支持信用卡支付、支付宝、微信支付等多种方式
• 排序算法选择
• 数据验证

以下是策略模式的基本实现：

// 策略接口
public interface PaymentStrategy {
    void pay(double amount);
}

// 具体策略类
public class CreditCardPayment implements PaymentStrategy {
    public void pay(double amount) {
        System.out.println("使用信用卡支付：" + amount);
    }
}

public class WeChatPay implements PaymentStrategy {
    public void pay(double amount) {
        System.out.println("使用微信支付：" + amount);
    }
}

// 上下文类
public class PaymentContext {
    private PaymentStrategy paymentStrategy;

    public PaymentContext(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void pay(double amount) {
        paymentStrategy.pay(amount);
    }
}

实际应用案例

在实际开发中，设计模式被广泛应用于各种场景。例如，在电商系统中：

• 购物车功能：使用单例模式确保购物车只有一个实例
• 商品数量变化通知：使用观察者模式处理库存变化
• 支付方式选择：使用策略模式灵活管理不同支付方式

在开源框架中，设计模式的应用更为普遍：

• Spring框架：大量使用了工厂模式、代理模式等
• MyBatis：运用了责任链模式、模板方法模式等

通过理解和应用这些设计模式，开发者可以编写出更加健壮、灵活且易于维护的代码。虽然设计模式不是万能的，但它为解决常见问题提供了一个清晰的思路，帮助开发者避免重复造轮子，提高软件开发效率和质量。