Skip to content

参考:设计模式 | 菜鸟教程

是什么? ​

设计模式是一套经过长期实践总结出来的、用于解决软件开发中常见问题的经典解决方案。

它不是现成的代码,也不是某个框架,而是一种解决问题的思想和套路。

设计模式是软件工程中经过反复验证的解决方案,由 GoF(四人帮)在 1994 年系统整理,共 23 种,分三大类:

创建型(5 种)解决"怎么造对象"的问题,将对象的创建与使用解耦。

结构型(7 种)解决"怎么组合对象"的问题,描述类和对象如何组成更大的结构。

行为型(11 种)解决"对象之间怎么通信"的问题,关注职责分配与算法封装。

设计原则 ​

设计模式(Design Pattern)并不是凭空产生的,它们大多建立在一些经典的面向对象设计原则之上。

单一职责原则 ​

单一职责原则(Single Responsibility Principle,SRP):一个类应该只有一个引起它变化的原因。

简单理解:一个类只负责一项职责。

错误示例 ​

java
public class UserService {

    // 用户注册
    public void register() {
        System.out.println("用户注册");
    }

    // 发送邮件
    public void sendEmail() {
        System.out.println("发送邮件");
    }

    // 写日志
    public void writeLog() {
        System.out.println("记录日志");
    }
}

问题:

  • 用户业务变化会修改这个类
  • 邮件功能变化会修改这个类
  • 日志功能变化也会修改这个类

职责过多。

改进 ​

java
public class UserService {
    public void register() {
        System.out.println("用户注册");
    }
}

public class EmailService {
    public void sendEmail() {
        System.out.println("发送邮件");
    }
}

public class LogService {
    public void writeLog() {
        System.out.println("记录日志");
    }
}

实际案例 ​

Spring 中:

  • Controller 负责接收请求
  • Service 负责业务逻辑
  • Mapper/Repository 负责数据库操作

这就是单一职责原则的体现。

开闭原则 ​

开闭原则(Open Closed Principle,OCP):对扩展开放,对修改关闭。

新增功能时尽量通过扩展实现,而不是修改已有代码。

这是最核心的设计原则。

错误示例 ​

java
public class PaymentService {

    public void pay(String type) {
        if ("alipay".equals(type)) {
            System.out.println("支付宝支付");
        } else if ("wechat".equals(type)) {
            System.out.println("微信支付");
        }
    }
}

新增银行卡支付:

java
else if ("bank".equals(type))

每增加一种支付方式都要修改代码。

改进 ​

java
public interface Payment {
    void pay();
}
java
public class AliPay implements Payment {
    public void pay() {
        System.out.println("支付宝支付");
    }
}
java
public class WechatPay implements Payment {
    public void pay() {
        System.out.println("微信支付");
    }
}
java
public class BankPay implements Payment {
    public void pay() {
        System.out.println("银行卡支付");
    }
}

新增支付方式:

只需要新增实现类。

原有代码不用动。

对应设计模式 ​

  • 策略模式
  • 工厂模式
  • 模板方法模式

都大量体现开闭原则。

里氏替换原则 ​

里氏替换原则(Liskov Substitution Principle,LSP):任何基类可以出现的地方,子类一定可以出现。

接口隔离原则 ​

接口隔离原则(Interface Segregation Principle):使用多个隔离的接口,比使用单个接口要好。它还有另外一个意思是:降低类之间的耦合度。

错误示例 ​

java
public interface Animal {

    void eat();

    void fly();

    void swim();
}

狗实现:

java
public class Dog implements Animal {

    public void eat(){}

    public void fly(){}

    public void swim(){}
}

狗根本不会飞。

接口设计不合理。

改进 ​

java
public interface Eatable {
    void eat();
}
java
public interface Flyable {
    void fly();
}
java
public interface Swimmable {
    void swim();
}

需要什么能力实现什么接口。

依赖倒置原则 ​

依赖倒置原则(Dependency Inversion Principle,DIP):高层模块不应该依赖低层模块,两者都应该依赖抽象。

简单理解:面向接口编程不要面向实现编程

错误示例 ​

java
public class UserService {
    private MysqlDao mysqlDao = new MysqlDao();
}

UserService 直接依赖 MysqlDao。

如果换成 Oracle:

java
private OracleDao oracleDao = new OracleDao();

必须修改代码。

改进 ​

java
public interface UserDao {
    void save();
}
java
public class MysqlDao implements UserDao {
    public void save() {}
}
java
public class OracleDao implements UserDao {
    public void save() {}
}
java
public class UserService {
    private UserDao userDao;
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
}

Spring中的体现 ​

Spring IOC 本质上就是依赖倒置原则的实践。

java
@Autowired
private UserDao userDao;

程序依赖接口而非实现类。

迪米特法则 ​

迪米特法则(Law of Demeter,LoD):一个实体应当尽量少地与其他实体之间发生相互作用,使得系统功能模块相对独立。

又称 最少知识原则

错误示例 ​

java
user.getDepartment()
    .getManager()
    .getPhone();

连续访问多个对象。

耦合严重。

改进 ​

java
user.getManagerPhone();

内部细节由 User 自己处理。

外部无需关心。

合成复用原则 ​

合成复用原则(Composite Reuse Principle,CRP):尽量使用合成/聚合的方式,而不是使用继承。

继承 ​

class Car extends Engine {
}

耦合度高。

组合 ​

class Car {
    private Engine engine;
}

更灵活。

实际案例 ​

Spring 推荐:

java
@Service
public class OrderService {

    @Autowired
    private UserService userService;
}

这是组合。

而不是:

java
public class OrderService extends UserService {
}

创建型 ​

单例模式(Singleton) ​

什么是单例模式? ​

单例模式的核心思想是:整个程序运行期间,某个类只能有一个实例。

简单来说:

java
UserService service1 = UserService.getInstance();
UserService service2 = UserService.getInstance();

无论调用多少次:

service1 == service2

结果永远是:

true

因为获取到的是同一个对象。

解决了什么问题? ​

频繁创建和销毁全局使用的类实例的问题。

如何解决? ​

检查系统是否已经存在该单例,如果存在则返回该实例;如果不存在则创建一个新实例。

使用场景 ​

单例模式适用于系统中只需要一个实例且需要全局共享的场景,例如配置中心、数据库连接池、Redis连接池、线程池、日志管理器、缓存管理器等。这些对象通常创建成本较高、需要统一管理或者需要保持全局状态一致,因此设计为单例可以节省资源并保证数据一致性。在 Spring 中,大多数 Service Bean 默认也是单例的。

工厂方法模式(Factory Method) ​

工厂方法模式(Factory Method Pattern):将对象的创建过程交给工厂类负责,而不是由客户端直接 new 对象。

工厂模式提供了一种创建对象的方式,而无需指定要创建的具体类。

核心思想是:把"创建哪种对象"这个决定,从父类推迟到子类。父类只定义一个"工厂方法"的接口,具体创建什么,由子类说了算。

解决了什么问题? ​

工厂模式解决的是"对象创建与对象使用耦合过高"的问题。

一个通知服务

java
// 问题代码 — 直接 new,硬编码类型
public class NotificationService {
    public void send(String type, String msg) {
        if (type.equals("email")) {
            new EmailNotifier().send(msg);     // 直接依赖具体类
        } else if (type.equals("sms")) {
            new SmsNotifier().send(msg);       // 每加一种就改这里
        } else if (type.equals("push")) {
            new PushNotifier().send(msg);      // 越改越脆
        }
    }
}

每次增加新通知类型,都要修改这个 if-else,违反了开闭原则(对扩展开放、对修改关闭)。工厂方法把"决定创建哪个类"的职责移到子类,主逻辑完全不需要改。

优缺点 ​

优点:

  1. 调用者只需要知道对象的名称即可创建对象。
  2. 扩展性高,如果需要增加新产品,只需扩展一个工厂类即可。
  3. 屏蔽了产品的具体实现,调用者只关心产品的接口。

缺点:

每次增加一个产品时,都需要增加一个具体类和对应的工厂,使系统中类的数量成倍增加,增加了系统的复杂度和具体类的依赖。

使用场景 ​

工厂模式适用于对象创建逻辑复杂、存在多个实现类、需要统一管理对象创建、或者未来需要扩展的场景。例如支付系统、消息发送系统、数据库连接、Spring Bean 创建等。它能够将对象的创建与使用解耦,提高系统的扩展性和维护性。如果对象创建非常简单且不存在扩展需求,则没有必要使用工厂模式,直接使用 new 即可。

抽象工厂模式(Abstract Factory) ​

抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的具体类。

解决了什么问题? ​

解决了接口选择的问题。

如何解决?

在一个产品族中定义多个产品,由具体工厂实现创建这些产品的方法。

在一个工厂中聚合多个同类产品的创建方法。

适用场景 ​

当系统需要创建多个相关或依赖的对象,而不需要指定具体类时。

应用实例 ​

假设有不同类型的衣柜,每个衣柜(具体工厂)只能存放一类衣服(成套的具体产品),如商务装、时尚装等。每套衣服包括具体的上衣和裤子(具体产品)。所有衣柜都是衣柜类(抽象工厂)的具体实现,所有上衣和裤子分别实现上衣接口和裤子接口(抽象产品)。

优缺点 ​

优点

  1. 确保同一产品族的对象一起工作。
  2. 客户端不需要知道每个对象的具体类,简化了代码。

缺点

扩展产品族非常困难。增加一个新的产品族需要修改抽象工厂和所有具体工厂的代码。

使用场景 ​

  1. QQ 换皮肤时,整套皮肤一起更换。
  2. 创建跨平台应用时,生成不同操作系统的程序。

建造者模式(Builder) ​

原型模式(Prototype) ​

结构型 ​

代理模式(Proxy) ​

是什么 ​

核心思想是:不给客户端直接访问目标对象,而是通过一个代理对象间接访问目标对象。

可以把它想象成生活中的"明星经纪人"。粉丝(客户端 Client)不能直接联系到明星(真实对象 RealSubject),而是需要通过经纪人(代理 Proxy)。这个经纪人可以帮明星处理很多事情,比如过滤掉不重要的请求、安排日程、谈合同等等,而明星本人则可以专注于自己的核心工作——表演。

在这个过程中,经纪人和明星都实现了相同的"能力接口"(比如"接受采访"、"商业演出"),所以对外界来说,与经纪人沟通和与明星直接沟通,在接口上是一致的。

解决了什么问题 ​

解决的是:在不修改原有业务代码的情况下,对目标对象的访问进行控制或增强。

简单来说,就是把一些与业务无关但又必须执行的功能(日志、权限、事务、缓存等)从业务代码中分离出来,交给代理对象处理。

优缺点 ​

优点

  • 职责分离:代理模式将访问控制与业务逻辑分离。
  • 扩展性:可以灵活地添加额外的功能或控制。
  • 智能化:可以智能地处理访问请求,如延迟加载、缓存等。

缺点

  • 性能开销:增加了代理层可能会影响请求的处理速度。
  • 实现复杂性:某些类型的代理模式实现起来可能较为复杂。

使用场景 ​

凡是需要在不修改原有业务代码的情况下,对方法调用进行增强或控制的场景,都可以使用代理模式。

注意事项 ​

  • 与适配器模式的区别:适配器模式改变接口,而代理模式不改变接口。
  • 与装饰器模式的区别:装饰器模式用于增强功能,代理模式用于控制访问。

装饰器模式(Decorator) ​

是什么? ​

装饰器模式(Decorator Pattern):在不修改原有对象的情况下,动态地给对象添加额外的职责/功能。

核心思想:把原始对象"包"进一个装饰器对象里,装饰器和原始对象实现同一个接口,客户端可以无感知地使用增强后的对象。装饰器在调用原始对象方法的前后,可以插入自己的逻辑。

就像奶茶加配料:基础是一杯原味奶茶,你可以加珍珠、加椰果、加奶盖——每加一样东西都是在原来的基础上"装饰"一层,最终你还是得到一杯奶茶(同一个接口),但功能更丰富了。

Java 中的经典例子:BufferedReader 装饰了 Reader,给普通 Reader 增加了缓冲读取能力。

java
Reader reader = new BufferedReader(new FileReader("file.txt"));

解决了什么问题? ​

解决的是:需要在运行时动态给对象增加功能,而不是通过继承在编译期确定。继承会导致类爆炸(每种功能组合都要新建子类),装饰器模式通过组合的方式灵活扩展对象功能。

优缺点 ​

优点

  1. 装饰器是继承的一种替代方案,比继承更灵活,可以在运行时动态增删功能。
  2. 通过组合而非继承来扩展功能,遵循合成复用原则。
  3. 装饰类之间相互独立,可以自由组合,产生不同的功能叠加效果。

缺点

  1. 多层装饰会使代码复杂度增加。
  2. 装饰器模式会产生大量小对象,增加系统负担。

使用场景 ​

当需要在不影响其他对象的情况下,动态、透明地给单个对象添加功能,或者需要可撤销地给对象增加功能时,适合使用装饰器模式。

应用实例:

  • Java IO 流:BufferedReader、BufferedInputStream、DataInputStream 等
  • Collections.synchronizedList() / Collections.unmodifiableList() 对集合的装饰
  • 中间件/拦截器链:每个中间件都是对核心处理器的装饰

与代理模式的区别 ​

  • 代理模式:控制对对象的访问(权限检查、延迟加载),专注于"能不能访问"。
  • 装饰器模式:增强对象的功能(加能力),专注于"增加什么功能"。

适配器模式(Adapter) ​

是什么? ​

适配器模式(Adapter Pattern):将一个类的接口转换成客户端期望的另一个接口,让原本接口不兼容的类可以一起工作。

核心思想:像电源转换插头——国标插头插不进欧标插座,加一个转换头(适配器)就能用了。原始类和目标接口都不用改。

三种实现方式:

1. 类适配器(继承)

java
// 目标接口
interface USB { void chargeUSB(); }

// 被适配者(无法修改的现有类)
class TypeC { void chargeTypeC() { ... } }

// 适配器:继承 TypeC,同时实现 USB
class Adapter extends TypeC implements USB {
    public void chargeUSB() { chargeTypeC(); }  // 转接
}

2. 对象适配器(组合,更推荐)

java
class Adapter implements USB {
    private TypeC typeC;
    public Adapter(TypeC typeC) { this.typeC = typeC; }
    public void chargeUSB() { typeC.chargeTypeC(); }
}

对象适配器更灵活,因为一个适配器可以适配被适配者及它的所有子类。

3. 接口适配器(缺省适配器)

不想实现接口的所有方法时,先用一个抽象类空实现所有方法,子类只重写需要的方法。

解决了什么问题? ​

解决的是:让接口不兼容的类可以一起工作。当你想复用某个现有类,但它的接口与系统要求的接口不一致时,不需要修改现有类,只需加一个适配器做中转。

优缺点 ​

优点

  1. 可以让两个无关的类一起运行。
  2. 提高了类的复用性:现有类无需修改即可被复用。
  3. 灵活性好:适配器可以灵活地适配不同的被适配者。

缺点

  1. 过多使用适配器会让系统变复杂,调用链路变长。
  2. 类适配器使用继承,无法同时适配多个被适配者及其子类。

使用场景 ​

当需要复用现有的类,而该类的接口又与系统要求的接口不匹配时,适合使用适配器模式。

应用实例:

  • Spring AOP 中,MethodBeforeAdvice、AfterReturningAdvice 等通过 AdvisorAdapter 适配成统一的 MethodInterceptor
  • java.io.InputStreamReader 将字节流 InputStream 适配为字符流 Reader
  • Arrays.asList() 将数组适配为 List

与装饰器模式的区别 ​

  • 适配器:改变接口,解决"不兼容"问题。
  • 装饰器:不改变接口,解决"功能增强"问题。

桥接模式(Bridge) ​

组合模式(Composite) ​

外观模式(Facade) ​

享元模式(Flyweight) ​

行为型 ​

策略模式(Strategy) ​

是什么? ​

策略模式(Strategy Pattern):定义一组算法(策略),将每个算法封装起来,并且使它们可以相互替换。

简单理解就是:把变化的逻辑抽出来,封装成独立策略,运行时动态选择

解决了什么问题? ​

策略模式解决了系统中算法(业务规则)经常变化、需要动态切换的问题,并通过将不同算法封装成独立策略类,降低代码耦合度,提高扩展性。

优缺点 ​

优点

  1. 算法切换自由:可以在运行时根据需要切换算法。
  2. 避免多重条件判断:消除了复杂的条件语句。
  3. 扩展性好:新增算法只需新增一个策略类,无需修改现有代码。

缺点

  1. 策略类数量增多:每增加一个算法,就需要增加一个策略类。
  2. 所有策略类都需要暴露:策略类需要对外公开,以便可以被选择和使用。

使用场景 ​

当一个系统中有许多类,它们之间的区别仅在于它们的行为时。

实现方式:

  • 定义策略接口:所有策略类都将实现这个统一的接口。
  • 创建具体策略类:每个策略类封装一个具体的算法或行为。
  • 上下文类:包含一个策略对象的引用,并通过该引用调用策略。

模板方法模式(Template Method) ​

观察者模式(Observer) ​

是什么? ​

观察者模式(Observer Pattern):定义对象间一对多的依赖关系,当一个对象状态发生变化时,所有依赖它的对象都会自动得到通知并更新。

简单理解就是:发布-订阅 — 一个主题被多个观察者订阅,主题变化时自动通知所有订阅者。

生活中就像微信公众号:你关注一个号(注册观察者),号主发新文章时所有粉丝同时收到推送(通知所有观察者),你取关后就不再收到(移除观察者)。

核心角色:

  • Subject(主题/被观察者):维护观察者列表,提供注册、移除和通知方法。
  • Observer(观察者/订阅者):定义一个更新接口,当主题状态变化时被调用。

解决了什么问题? ​

解决的是对象之间一对多通知的问题:当一个对象状态改变时,需要自动通知其他多个对象,同时保持它们之间的松耦合。主题不需要知道观察者的具体实现,只需要知道观察者实现了统一的更新接口。

优缺点 ​

优点

  1. 松耦合:主题和观察者之间是抽象依赖,各自可以独立变化。
  2. 广播通信:一条消息可以同时通知所有观察者。
  3. 符合开闭原则:新增观察者无需修改主题代码。

缺点

  1. 观察者过多时,通知所有观察者耗时较长。
  2. 观察者和主题之间如果存在循环依赖,可能导致系统崩溃。
  3. 观察者不知道被通知的具体原因,只能知道主题发生了变化。

使用场景 ​

当一个对象的状态变化需要通知其他对象,或者一个对象需要通知其他对象而又不希望它们之间紧密耦合时,适合使用观察者模式。

应用实例:

  • Java 原生 java.util.Observer / EventListener
  • GUI 事件监听(按钮点击回调)
  • 消息队列的发布/订阅模型
  • Spring 事件机制(ApplicationEvent / @EventListener)
  • RxJava 响应式编程

迭代器模式(Iterator) ​

责任链模式(Chain of Responsibility) ​

命令模式(Command) ​

备忘录模式(Memento) ​

状态模式(State) ​

访问者模式(Visitor) ​

中介者模式(Mediator) ​

解释器模式(Interpreter) ​

最后更新于: