参考:设计模式 | 菜鸟教程
是什么?
设计模式是一套经过长期实践总结出来的、用于解决软件开发中常见问题的经典解决方案。
它不是现成的代码,也不是某个框架,而是一种解决问题的思想和套路。
设计模式是软件工程中经过反复验证的解决方案,由 GoF(四人帮)在 1994 年系统整理,共 23 种,分三大类:
创建型(5 种)解决"怎么造对象"的问题,将对象的创建与使用解耦。
结构型(7 种)解决"怎么组合对象"的问题,描述类和对象如何组成更大的结构。
行为型(11 种)解决"对象之间怎么通信"的问题,关注职责分配与算法封装。
设计原则
设计模式(Design Pattern)并不是凭空产生的,它们大多建立在一些经典的面向对象设计原则之上。
单一职责原则
单一职责原则(Single Responsibility Principle,SRP):一个类应该只有一个引起它变化的原因。
简单理解:一个类只负责一项职责。
错误示例
public class UserService {
// 用户注册
public void register() {
System.out.println("用户注册");
}
// 发送邮件
public void sendEmail() {
System.out.println("发送邮件");
}
// 写日志
public void writeLog() {
System.out.println("记录日志");
}
}问题:
- 用户业务变化会修改这个类
- 邮件功能变化会修改这个类
- 日志功能变化也会修改这个类
职责过多。
改进
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):对扩展开放,对修改关闭。
新增功能时尽量通过扩展实现,而不是修改已有代码。
这是最核心的设计原则。
错误示例
public class PaymentService {
public void pay(String type) {
if ("alipay".equals(type)) {
System.out.println("支付宝支付");
} else if ("wechat".equals(type)) {
System.out.println("微信支付");
}
}
}新增银行卡支付:
else if ("bank".equals(type))每增加一种支付方式都要修改代码。
改进
public interface Payment {
void pay();
}public class AliPay implements Payment {
public void pay() {
System.out.println("支付宝支付");
}
}public class WechatPay implements Payment {
public void pay() {
System.out.println("微信支付");
}
}public class BankPay implements Payment {
public void pay() {
System.out.println("银行卡支付");
}
}新增支付方式:
只需要新增实现类。
原有代码不用动。
对应设计模式
- 策略模式
- 工厂模式
- 模板方法模式
都大量体现开闭原则。
里氏替换原则
里氏替换原则(Liskov Substitution Principle,LSP):任何基类可以出现的地方,子类一定可以出现。
接口隔离原则
接口隔离原则(Interface Segregation Principle):使用多个隔离的接口,比使用单个接口要好。它还有另外一个意思是:降低类之间的耦合度。
错误示例
public interface Animal {
void eat();
void fly();
void swim();
}狗实现:
public class Dog implements Animal {
public void eat(){}
public void fly(){}
public void swim(){}
}狗根本不会飞。
接口设计不合理。
改进
public interface Eatable {
void eat();
}public interface Flyable {
void fly();
}public interface Swimmable {
void swim();
}需要什么能力实现什么接口。
依赖倒置原则
依赖倒置原则(Dependency Inversion Principle,DIP):高层模块不应该依赖低层模块,两者都应该依赖抽象。
简单理解:面向接口编程不要面向实现编程
错误示例
public class UserService {
private MysqlDao mysqlDao = new MysqlDao();
}UserService 直接依赖 MysqlDao。
如果换成 Oracle:
private OracleDao oracleDao = new OracleDao();必须修改代码。
改进
public interface UserDao {
void save();
}public class MysqlDao implements UserDao {
public void save() {}
}public class OracleDao implements UserDao {
public void save() {}
}public class UserService {
private UserDao userDao;
public UserService(UserDao userDao) {
this.userDao = userDao;
}
}Spring中的体现
Spring IOC 本质上就是依赖倒置原则的实践。
@Autowired
private UserDao userDao;程序依赖接口而非实现类。
迪米特法则
迪米特法则(Law of Demeter,LoD):一个实体应当尽量少地与其他实体之间发生相互作用,使得系统功能模块相对独立。
又称 最少知识原则
错误示例
user.getDepartment()
.getManager()
.getPhone();连续访问多个对象。
耦合严重。
改进
user.getManagerPhone();内部细节由 User 自己处理。
外部无需关心。
合成复用原则
合成复用原则(Composite Reuse Principle,CRP):尽量使用合成/聚合的方式,而不是使用继承。
继承
class Car extends Engine {
}耦合度高。
组合
class Car {
private Engine engine;
}更灵活。
实际案例
Spring 推荐:
@Service
public class OrderService {
@Autowired
private UserService userService;
}这是组合。
而不是:
public class OrderService extends UserService {
}创建型
单例模式(Singleton)
什么是单例模式?
单例模式的核心思想是:整个程序运行期间,某个类只能有一个实例。
简单来说:
UserService service1 = UserService.getInstance();
UserService service2 = UserService.getInstance();无论调用多少次:
service1 == service2结果永远是:
true因为获取到的是同一个对象。
解决了什么问题?
频繁创建和销毁全局使用的类实例的问题。
如何解决?
检查系统是否已经存在该单例,如果存在则返回该实例;如果不存在则创建一个新实例。
使用场景
单例模式适用于系统中只需要一个实例且需要全局共享的场景,例如配置中心、数据库连接池、Redis连接池、线程池、日志管理器、缓存管理器等。这些对象通常创建成本较高、需要统一管理或者需要保持全局状态一致,因此设计为单例可以节省资源并保证数据一致性。在 Spring 中,大多数 Service Bean 默认也是单例的。
工厂方法模式(Factory Method)
工厂方法模式(Factory Method Pattern):将对象的创建过程交给工厂类负责,而不是由客户端直接 new 对象。
工厂模式提供了一种创建对象的方式,而无需指定要创建的具体类。
核心思想是:把"创建哪种对象"这个决定,从父类推迟到子类。父类只定义一个"工厂方法"的接口,具体创建什么,由子类说了算。
解决了什么问题?
工厂模式解决的是"对象创建与对象使用耦合过高"的问题。
一个通知服务
// 问题代码 — 直接 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,违反了开闭原则(对扩展开放、对修改关闭)。工厂方法把"决定创建哪个类"的职责移到子类,主逻辑完全不需要改。
优缺点
优点:
- 调用者只需要知道对象的名称即可创建对象。
- 扩展性高,如果需要增加新产品,只需扩展一个工厂类即可。
- 屏蔽了产品的具体实现,调用者只关心产品的接口。
缺点:
每次增加一个产品时,都需要增加一个具体类和对应的工厂,使系统中类的数量成倍增加,增加了系统的复杂度和具体类的依赖。
使用场景
工厂模式适用于对象创建逻辑复杂、存在多个实现类、需要统一管理对象创建、或者未来需要扩展的场景。例如支付系统、消息发送系统、数据库连接、Spring Bean 创建等。它能够将对象的创建与使用解耦,提高系统的扩展性和维护性。如果对象创建非常简单且不存在扩展需求,则没有必要使用工厂模式,直接使用 new 即可。
抽象工厂模式(Abstract Factory)
抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的具体类。
解决了什么问题?
解决了接口选择的问题。
如何解决?
在一个产品族中定义多个产品,由具体工厂实现创建这些产品的方法。
在一个工厂中聚合多个同类产品的创建方法。
适用场景
当系统需要创建多个相关或依赖的对象,而不需要指定具体类时。
应用实例
假设有不同类型的衣柜,每个衣柜(具体工厂)只能存放一类衣服(成套的具体产品),如商务装、时尚装等。每套衣服包括具体的上衣和裤子(具体产品)。所有衣柜都是衣柜类(抽象工厂)的具体实现,所有上衣和裤子分别实现上衣接口和裤子接口(抽象产品)。
优缺点
优点
- 确保同一产品族的对象一起工作。
- 客户端不需要知道每个对象的具体类,简化了代码。
缺点
扩展产品族非常困难。增加一个新的产品族需要修改抽象工厂和所有具体工厂的代码。
使用场景
- QQ 换皮肤时,整套皮肤一起更换。
- 创建跨平台应用时,生成不同操作系统的程序。
建造者模式(Builder)
原型模式(Prototype)
结构型
代理模式(Proxy)
是什么
核心思想是:不给客户端直接访问目标对象,而是通过一个代理对象间接访问目标对象。
可以把它想象成生活中的"明星经纪人"。粉丝(客户端 Client)不能直接联系到明星(真实对象 RealSubject),而是需要通过经纪人(代理 Proxy)。这个经纪人可以帮明星处理很多事情,比如过滤掉不重要的请求、安排日程、谈合同等等,而明星本人则可以专注于自己的核心工作——表演。
在这个过程中,经纪人和明星都实现了相同的"能力接口"(比如"接受采访"、"商业演出"),所以对外界来说,与经纪人沟通和与明星直接沟通,在接口上是一致的。
解决了什么问题
解决的是:在不修改原有业务代码的情况下,对目标对象的访问进行控制或增强。
简单来说,就是把一些与业务无关但又必须执行的功能(日志、权限、事务、缓存等)从业务代码中分离出来,交给代理对象处理。
优缺点
优点
- 职责分离:代理模式将访问控制与业务逻辑分离。
- 扩展性:可以灵活地添加额外的功能或控制。
- 智能化:可以智能地处理访问请求,如延迟加载、缓存等。
缺点
- 性能开销:增加了代理层可能会影响请求的处理速度。
- 实现复杂性:某些类型的代理模式实现起来可能较为复杂。
使用场景
凡是需要在不修改原有业务代码的情况下,对方法调用进行增强或控制的场景,都可以使用代理模式。
注意事项
- 与适配器模式的区别:适配器模式改变接口,而代理模式不改变接口。
- 与装饰器模式的区别:装饰器模式用于增强功能,代理模式用于控制访问。
装饰器模式(Decorator)
是什么?
装饰器模式(Decorator Pattern):在不修改原有对象的情况下,动态地给对象添加额外的职责/功能。
核心思想:把原始对象"包"进一个装饰器对象里,装饰器和原始对象实现同一个接口,客户端可以无感知地使用增强后的对象。装饰器在调用原始对象方法的前后,可以插入自己的逻辑。
就像奶茶加配料:基础是一杯原味奶茶,你可以加珍珠、加椰果、加奶盖——每加一样东西都是在原来的基础上"装饰"一层,最终你还是得到一杯奶茶(同一个接口),但功能更丰富了。
Java 中的经典例子:BufferedReader 装饰了 Reader,给普通 Reader 增加了缓冲读取能力。
Reader reader = new BufferedReader(new FileReader("file.txt"));解决了什么问题?
解决的是:需要在运行时动态给对象增加功能,而不是通过继承在编译期确定。继承会导致类爆炸(每种功能组合都要新建子类),装饰器模式通过组合的方式灵活扩展对象功能。
优缺点
优点
- 装饰器是继承的一种替代方案,比继承更灵活,可以在运行时动态增删功能。
- 通过组合而非继承来扩展功能,遵循合成复用原则。
- 装饰类之间相互独立,可以自由组合,产生不同的功能叠加效果。
缺点
- 多层装饰会使代码复杂度增加。
- 装饰器模式会产生大量小对象,增加系统负担。
使用场景
当需要在不影响其他对象的情况下,动态、透明地给单个对象添加功能,或者需要可撤销地给对象增加功能时,适合使用装饰器模式。
应用实例:
- Java IO 流:
BufferedReader、BufferedInputStream、DataInputStream等 Collections.synchronizedList()/Collections.unmodifiableList()对集合的装饰- 中间件/拦截器链:每个中间件都是对核心处理器的装饰
与代理模式的区别
- 代理模式:控制对对象的访问(权限检查、延迟加载),专注于"能不能访问"。
- 装饰器模式:增强对象的功能(加能力),专注于"增加什么功能"。
适配器模式(Adapter)
是什么?
适配器模式(Adapter Pattern):将一个类的接口转换成客户端期望的另一个接口,让原本接口不兼容的类可以一起工作。
核心思想:像电源转换插头——国标插头插不进欧标插座,加一个转换头(适配器)就能用了。原始类和目标接口都不用改。
三种实现方式:
1. 类适配器(继承)
// 目标接口
interface USB { void chargeUSB(); }
// 被适配者(无法修改的现有类)
class TypeC { void chargeTypeC() { ... } }
// 适配器:继承 TypeC,同时实现 USB
class Adapter extends TypeC implements USB {
public void chargeUSB() { chargeTypeC(); } // 转接
}2. 对象适配器(组合,更推荐)
class Adapter implements USB {
private TypeC typeC;
public Adapter(TypeC typeC) { this.typeC = typeC; }
public void chargeUSB() { typeC.chargeTypeC(); }
}对象适配器更灵活,因为一个适配器可以适配被适配者及它的所有子类。
3. 接口适配器(缺省适配器)
不想实现接口的所有方法时,先用一个抽象类空实现所有方法,子类只重写需要的方法。
解决了什么问题?
解决的是:让接口不兼容的类可以一起工作。当你想复用某个现有类,但它的接口与系统要求的接口不一致时,不需要修改现有类,只需加一个适配器做中转。
优缺点
优点
- 可以让两个无关的类一起运行。
- 提高了类的复用性:现有类无需修改即可被复用。
- 灵活性好:适配器可以灵活地适配不同的被适配者。
缺点
- 过多使用适配器会让系统变复杂,调用链路变长。
- 类适配器使用继承,无法同时适配多个被适配者及其子类。
使用场景
当需要复用现有的类,而该类的接口又与系统要求的接口不匹配时,适合使用适配器模式。
应用实例:
- Spring AOP 中,
MethodBeforeAdvice、AfterReturningAdvice等通过AdvisorAdapter适配成统一的MethodInterceptor java.io.InputStreamReader将字节流InputStream适配为字符流ReaderArrays.asList()将数组适配为List
与装饰器模式的区别
- 适配器:改变接口,解决"不兼容"问题。
- 装饰器:不改变接口,解决"功能增强"问题。
桥接模式(Bridge)
组合模式(Composite)
外观模式(Facade)
享元模式(Flyweight)
行为型
策略模式(Strategy)
是什么?
策略模式(Strategy Pattern):定义一组算法(策略),将每个算法封装起来,并且使它们可以相互替换。
简单理解就是:把变化的逻辑抽出来,封装成独立策略,运行时动态选择
解决了什么问题?
策略模式解决了系统中算法(业务规则)经常变化、需要动态切换的问题,并通过将不同算法封装成独立策略类,降低代码耦合度,提高扩展性。
优缺点
优点
- 算法切换自由:可以在运行时根据需要切换算法。
- 避免多重条件判断:消除了复杂的条件语句。
- 扩展性好:新增算法只需新增一个策略类,无需修改现有代码。
缺点
- 策略类数量增多:每增加一个算法,就需要增加一个策略类。
- 所有策略类都需要暴露:策略类需要对外公开,以便可以被选择和使用。
使用场景
当一个系统中有许多类,它们之间的区别仅在于它们的行为时。
实现方式:
- 定义策略接口:所有策略类都将实现这个统一的接口。
- 创建具体策略类:每个策略类封装一个具体的算法或行为。
- 上下文类:包含一个策略对象的引用,并通过该引用调用策略。
模板方法模式(Template Method)
观察者模式(Observer)
是什么?
观察者模式(Observer Pattern):定义对象间一对多的依赖关系,当一个对象状态发生变化时,所有依赖它的对象都会自动得到通知并更新。
简单理解就是:发布-订阅 — 一个主题被多个观察者订阅,主题变化时自动通知所有订阅者。
生活中就像微信公众号:你关注一个号(注册观察者),号主发新文章时所有粉丝同时收到推送(通知所有观察者),你取关后就不再收到(移除观察者)。
核心角色:
- Subject(主题/被观察者):维护观察者列表,提供注册、移除和通知方法。
- Observer(观察者/订阅者):定义一个更新接口,当主题状态变化时被调用。
解决了什么问题?
解决的是对象之间一对多通知的问题:当一个对象状态改变时,需要自动通知其他多个对象,同时保持它们之间的松耦合。主题不需要知道观察者的具体实现,只需要知道观察者实现了统一的更新接口。
优缺点
优点
- 松耦合:主题和观察者之间是抽象依赖,各自可以独立变化。
- 广播通信:一条消息可以同时通知所有观察者。
- 符合开闭原则:新增观察者无需修改主题代码。
缺点
- 观察者过多时,通知所有观察者耗时较长。
- 观察者和主题之间如果存在循环依赖,可能导致系统崩溃。
- 观察者不知道被通知的具体原因,只能知道主题发生了变化。
使用场景
当一个对象的状态变化需要通知其他对象,或者一个对象需要通知其他对象而又不希望它们之间紧密耦合时,适合使用观察者模式。
应用实例:
- Java 原生
java.util.Observer/EventListener - GUI 事件监听(按钮点击回调)
- 消息队列的发布/订阅模型
- Spring 事件机制(
ApplicationEvent/@EventListener) - RxJava 响应式编程