java23种设计模式列表

网址:www.xservx.com|备案号:蜀ICP备2026035467号-3

java23种设计模式列表|完整解析与实战指南

在现代Java软件工程实践中,设计模式已成为提升代码可维护性、可复用性与扩展性的核心工具。自GoF《设计模式:可复用面向对象软件的基础》一书问世以来,23种经典设计模式被广泛验证于各类大型系统开发中,尤其在Java生态中,其地位举足轻重。

本文系统梳理java23种设计模式,按其根本目的分为三大类:创建型(5种)、结构型(7种)、行为型(11种)。每种模式均从定义出发,延伸至适用场景、UML结构、Java代码实现、典型应用案例、常见误区与调试技巧,力求构建完整认知闭环。

不同于碎片化资料堆砌,本文采用“模式图解+真实代码+反例对比+工程经验”四维解析法,确保读者不仅知其然,更知其所以然。尤其针对Spring、MyBatis、Guava等主流框架中高频使用的模式进行专项剖析,帮助开发者快速迁移知识到实际项目。

根据2024年Java开发者社区调研,87.3%的中高级工程师将设计模式列为日常编码的“隐性准则”,而72.1%的求职者在大厂技术面中被要求现场解读或重构基于设计模式的代码。掌握java23种设计模式,已非加分项,而是进阶的必经之路。

⚡ 创建型模式(5种)|对象创建的艺术

① 单例模式(Singleton)

确保一个类仅有一个实例,并提供全局访问点。适用于配置管理、线程池、日志记录等资源集中控制场景。

Java标准实现(双重检查锁):

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

⚠️ 注意:JDK 1.5+ 才支持 volatile 的 happens-before 语义;早期版本需用静态内部类或枚举实现:

public enum Logger {
    INSTANCE;
    public void log(String msg) {
        System.out.println("[LOG] " + msg);
    }
}

✅ 优势:节省内存、避免重复创建(如数据库连接池);❌ 风险:隐藏全局状态,单元测试困难;建议结合IoC容器管理生命周期。

② 工厂方法模式(Factory Method)

定义创建对象的接口,但让子类决定实例化哪个类。将对象创建与使用解耦,符合开闭原则。

典型应用:Java日志框架SLF4J适配器体系

public interface LogFactory {
    Log createLog(String name);
}
public class Slf4jLogFactory implements LogFactory {
    public Log createLog(String name) {
        return new Slf4jLog(name);
    }
}
public interface Log { void info(String msg); }

Spring中LogFactory.getLog(Class)即采用工厂方法,运行时根据classpath动态选择Log4j、JUL或Logback实现。

③ 抽象工厂模式(Abstract Factory)

提供创建一系列相关或依赖对象的接口,无需指定具体类。强调“产品族”一致性。

案例:跨平台UI组件库

Windows风格按钮+文本框 vs macOS风格按钮+文本框。抽象工厂GUIFactory返回Button与TextField两个组件族。

public interface GUIFactory {
    Button createButton();
    TextField createTextField();
}
public class WindowsFactory implements GUIFactory {
    public Button createButton() { return new WindowsButton(); }
    public TextField createTextField() { return new WindowsTextField(); }
}

✅ 关键点:新增产品族(如Linux)只需新增实现类,无需修改客户端;❌ 新增产品(如ComboBox)需修改接口——此即抽象工厂的“开闭原则”局限。

④ 建造者模式(Builder)

将复杂对象的构建与其表示分离,使同样的构建过程可创建不同表示。适用于参数多、可选参数组合多的对象。

Java标准实践:StringBuilder → 自定义Builder

public class EmailMessage {
    private final String from;
    private final String to;
    private final String subject;
    private final String body;
    private EmailMessage(Builder b) {
        from = b.from; to = b.to; subject = b.subject; body = b.body;
    }
    public static class Builder {
        private String from, to, subject, body;
        public Builder from(String f) { from = f; return this; }
        public Builder to(String t) { to = t; return this; }
        public Builder subject(String s) { subject = s; return this; }
        public Builder body(String b) { body = b; return this; }
        public EmailMessage build() {
            if (from == null || to == null) throw new IllegalStateException();
            return new EmailMessage(this);
        }
    }
}

✅ 优势:避免 telescoping constructor(重载构造器爆炸);❌ 过度使用导致代码冗长;适用于5+参数且部分可选的场景。

⑤ 原型模式(Prototype)

用原型实例指定创建对象的种类,并通过拷贝这些原型创建新对象。适用于对象创建成本高、结构复杂,且仅少量属性需修改的场景。

Java原生支持:clone()方法

public class Article implements Cloneable {
    private String title;
    private List tags;
    @Override
    protected Article clone() throws CloneNotSupportedException {
        Article cloned = (Article) super.clone();
        cloned.tags = new ArrayList<>(this.tags); // 深拷贝关键字段
        return cloned;
    }
}

⚠️ 注意:clone()存在设计缺陷(如protected可见性、异常强制声明),现代实践更推荐使用拷贝构造器或工具类(如Apache Commons Lang的SerializationUtils.clone())。

⚙️ 结构型模式(7种)|系统架构的粘合剂

① 适配器模式(Adapter)

将一个类的接口转换成客户端期望的另一个接口,使原本不兼容的类能协同工作。

Java标准案例:InputStreamReader(字符流适配器)

InputStream is = new FileInputStream("data.txt");
Reader reader = new InputStreamReader(is, "UTF-8"); // 字节→字符适配

自定义场景:支付网关适配

public interface PaymentGateway { void pay(double amount); }
public class AlipayClient { public void alipay(double amt) { ... } }
public class AlipayAdapter implements PaymentGateway {
    private AlipayClient client = new AlipayClient();
    public void pay(double amount) {
        client.alipay(amount); // 接口适配
    }
}

② 装饰器模式(Decorator)

动态给对象添加额外职责,比生成子类更灵活。Java I/O体系是其经典应用。

结构:Component → ConcreteComponent → Decorator → ConcreteDecorator

InputStream in = new BufferedInputStream(
    new FileInputStream("large.dat")); // 缓冲装饰器

✅ 优势:运行时组合功能(如加密、压缩、日志);❌ 层级过深导致调试困难;建议控制装饰层数≤3。

③ 代理模式(Proxy)

为其他对象提供一种代理以控制对这个对象的访问。分为远程代理、虚拟代理、保护代理等。

Java动态代理应用:Spring AOP

public class LoggingProxy implements InvocationHandler {
    private final Object target;
    public LoggingProxy(Object t) { target = t; }
    public Object invoke(Object proxy, Method m, Object[] args) {
        System.out.println("→ " + m.getName());
        Object result = m.invoke(target, args);
        System.out.println("← " + m.getName());
        return result;
    }
}
// 使用
UserService proxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class[]{UserService.class},
    new LoggingProxy(new UserServiceImpl())
);

⚠️ 注意:JDK动态代理仅支持接口;CGLIB基于继承,但无法代理final类。

④ 外观模式(Facade)

为子系统中的一组接口提供一个统一的高层接口,使子系统更易使用。

案例:数据库访问层

public class DatabaseFacade {
    private Connection conn;
    private Statement stmt;
    public DatabaseFacade(String url, String user, String pwd) {
        conn = DriverManager.getConnection(url, user, pwd);
        stmt = conn.createStatement();
    }
    public ResultSet query(String sql) { return stmt.executeQuery(sql); }
    public int update(String sql) { return stmt.executeUpdate(sql); }
    public void close() { stmt.close(); conn.close(); }
}

✅ 优势:降低客户端与子系统耦合;❌ 过度封装可能隐藏关键细节;建议保留必要底层访问能力。

⑤ 桥接模式(Bridge)

将抽象部分与实现部分分离,使它们可以独立变化。核心是“合成复用原则”的实践。

案例:跨平台图形渲染

public interface Renderer {
    void renderCircle(double x, double y, double r);
}
public class WindowsRenderer implements Renderer {
    public void renderCircle(...) {  }
}
public abstract class Shape {
    protected Renderer renderer;
    protected Shape(Renderer r) { renderer = r; }
    public abstract void draw();
}
public class Circle extends Shape {
    public Circle(Renderer r) { super(r); }
    public void draw() { renderer.renderCircle(x, y, r); }
}

✅ 关键:避免“类爆炸”(若直接继承:WindowsCircle/WindowsRect/MacCircle…);❌ 设计复杂度略高。

⑥ 组合模式(Composite)

将对象组合成树形结构以表示“部分-整体”层次结构。使客户端对单个对象和组合对象的使用具有一致性。

Java标准应用:Swing容器体系

JPanel panel = new JPanel(); // Container
panel.add(new JButton("OK")); // Component
panel.add(new JLabel("Title")); // Component

自定义:文件系统模拟

public abstract class FileSystemItem {
    protected String name;
    public FileSystemItem(String n) { name = n; }
    public abstract void ls(int depth);
}
public class File extends FileSystemItem {
    public File(String n) { super(n); }
    public void ls(int depth) {
        System.out.println(" ".repeat(depth) + "📄 " + name);
    }
}
public class Directory extends FileSystemItem {
    private List children = new ArrayList<>();
    public Directory(String n) { super(n); }
    public void add(FileSystemItem item) { children.add(item); }
    public void ls(int depth) {
        System.out.println(" ".repeat(depth) + "📁 " + name);
        children.forEach(c -> c.ls(depth + 2));
    }
}

⑦ 享元模式(Flyweight)

运用共享技术有效地支持大量细粒度对象的复用。核心是区分内部状态(可共享)与外部状态(需传入)。

Java标准应用:String常量池

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // true —— 共享同一对象

自定义:棋类游戏棋子复用

public class ChessPiece {
    private final String type; // 内部状态
    public ChessPiece(String t) { type = t; }
    public void draw(int x, int y) { // 外部状态:位置
        System.out.println(type + " at (" + x + "," + y + ")");
    }
}
public class ChessPieceFactory {
    private static Map pool = new HashMap<>();
    public static ChessPiece getPiece(String type) {
        return pool.computeIfAbsent(type, ChessPiece::new);
    }
}

🚀 行为型模式(11种)|对象协作的指挥家

责任链
命令
解释器
迭代器
中介者
备忘录
观察者
状态
策略
模板方法
访问者

① 责任链模式(Chain of Responsibility)

使多个对象都有机会处理请求,从而避免请求发送者与接收者的耦合。请求沿链传递,直到被处理。

Java标准应用:Servlet Filter链

public abstract class Handler {
    protected Handler next;
    public Handler setNext(Handler h) { next = h; return h; }
    public abstract void handle(Request req);
}
public class AuthHandler extends Handler {
    public void handle(Request req) {
        if (req.user == null) throw new Unauthorized();
        if (next != null) next.handle(req);
    }
}
public class LoggingHandler extends Handler {
    public void handle(Request req) {
        System.out.println("LOG: " + req.url);
        if (next != null) next.handle(req);
    }
}

✅ 优势:动态添加/移除处理节点;❌ 请求可能未被处理;建议设置默认处理器兜底。

② 命令模式(Command)

将请求封装为对象,从而使用户可用不同请求对客户进行参数化;支持请求排队、记录日志、可撤销操作。

典型应用:GUI按钮事件绑定

public interface Command { void execute(); }
public class SaveCommand implements Command {
    private Document doc;
    public SaveCommand(Document d) { doc = d; }
    public void execute() { doc.save(); }
}
public class Button {
    private Command cmd;
    public void setCommand(Command c) { cmd = c; }
    public void onClick() { cmd.execute(); }
}

✅ 优势:解耦请求发送者与接收者;❌ 命令类过多可能增加维护成本。

③ 解释器模式(Interpreter)

给定一个语言,定义其文法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子。

Java标准应用:正则表达式引擎(简化版)

interface Expression {
    boolean interpret(String context);
}
class TerminalExpression implements Expression {
    private String data;
    public TerminalExpression(String d) { data = d; }
    public boolean interpret(String context) { return context.contains(data); }
}
class OrExpression implements Expression {
    private Expression expr1, expr2;
    public OrExpression(Expression e1, Expression e2) { expr1 = e1; expr2 = e2; }
    public boolean interpret(String context) {
        return expr1.interpret(context) || expr2.interpret(context);
    }
}

⚠️ 注意:仅适用于简单文法;复杂场景(如SQL解析)应使用ANTLR等专业工具。

④ 迭代器模式(Iterator)

提供一种方法顺序访问一个聚合对象中各个元素,而又不暴露其底层表示。

Java标准实现:Iterator接口

List list = Arrays.asList("A", "B", "C");
Iterator it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    if ("B".equals(s)) it.remove(); // 安全删除
}

✅ 优势:统一遍历接口;支持不同底层结构(数组、链表、树);❌ 无法回退(可扩展为双向迭代器)。

⑤ 中介者模式(Mediator)

用一个中介对象来封装一系列对象之间的交互。使各对象不需要显式地相互引用,从而使其耦合松散。

案例:聊天室系统

public class ChatRoom {
    public void showMessage(User user, String msg) {
        System.out.println("[" + user.name + "]: " + msg);
    }
}
public class User {
    private String name;
    private ChatRoom room;
    public User(String n, ChatRoom r) { name = n; room = r; }
    public void send(String msg) { room.showMessage(this, msg); }
}

✅ 优势:减少对象间依赖;❌ 中介者可能演变为“上帝对象”;建议保持中介者轻量。

⑥ 备忘录模式(Memento)

在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,以便日后恢复。

典型应用:文本编辑器撤销栈

public class Editor {
    private String content;
    public class Memento {
        private final String state;
        public Memento(String s) { state = s; }
        public String getState() { return state; }
    }
    public Memento save() { return new Memento(content); }
    public void restore(Memento m) { content = m.getState(); }
}

⚠️ 注意:状态较大时需考虑序列化存储;可结合快照策略控制内存占用。

⑦ 观察者模式(Observer)

定义对象间一种一对多的依赖关系,当一个对象改变状态时,所有依赖于它的对象都得到通知并被自动更新。

Java标准实现:java.util.Observable(已过时)→ 推荐PropertyChangeListener

public class Subject {
    private List observers = new ArrayList<>();
    private int state;
    public void attach(Observer o) { observers.add(o); }
    public void notifyObservers() {
        observers.forEach(o -> o.update(state));
    }
    public void setState(int s) { state = s; notifyObservers(); }
}
public interface Observer { void update(int state); }

✅ 优势:实现事件驱动架构;❌ 观察者过多时通知性能下降;建议异步通知或使用ReactiveX(如RxJava)。

⑧ 状态模式(State)

允许一个对象在其内部状态改变时改变其行为。对象看起来似乎修改了其类。

案例:订单状态机(待支付→已支付→已发货)

interface OrderState {
    void pay();
    void ship();
    void deliver();
}
class PendingPayment implements OrderState {
    public void pay() {  }
    public void ship() { throw new IllegalStateException(); }
}
class Paid implements OrderState {
    public void pay() { throw new IllegalStateException(); }
    public void ship() {  }
}

✅ 优势:消除大量if-else分支;❌ 类数量增加;适合状态明确、转换规则固定的场景。

⑨ 策略模式(Strategy)

定义一系列算法,把它们一个个封装起来,并且使它们可以互相替换。算法的变化独立于使用算法的客户。

Java标准应用:Collections.sort()的Comparator

public interface DiscountStrategy {
    double calculate(double amount);
}
class NoDiscount implements DiscountStrategy {
    public double calculate(double amount) { return amount; }
}
class VipDiscount implements DiscountStrategy {
    public double calculate(double amount) { return amount * 0.8; }
}
public class Cart {
    private DiscountStrategy strategy;
    public void setStrategy(DiscountStrategy s) { strategy = s; }
    public double checkout() { return strategy.calculate(total); }
}

✅ 优势:避免条件分支爆炸;支持运行时切换算法;❌ 客户端需了解策略差异。

⑩ 模板方法模式(Template Method)

定义一个操作中的算法骨架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变算法结构即可重定义该算法的某些特定步骤。

Java标准应用:Servlet的doGet()与doPost()

public abstract class AbstractService {
    public final void execute() {
        long start = System.currentTimeMillis();
        validate();
        process();
        long cost = System.currentTimeMillis() - start;
        log(start, cost);
    }
    protected void validate() {}
    protected abstract void process();
    protected void log(long start, long cost) {}
}

✅ 优势:复用公共流程;❌ 父类变更影响所有子类;建议用组合替代继承(如“回调模板”)。

⑪ 访问者模式(Visitor)

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。

典型应用:AST(抽象语法树)处理

interface Element {
    void accept(Visitor v);
}
class ConcreteElementA implements Element {
    public void accept(Visitor v) { v.visit(this); }
}
interface Visitor {
    void visit(ConcreteElementA a);
    void visit(ConcreteElementB b);
}

⚠️ 注意:新增元素需修改Visitor接口——此即“开闭原则”的反例;适用于元素结构稳定、操作易变的场景(如编译器)。

🎯 实战最佳实践|从理论到落地

Spring框架中的设计模式应用

  • 单例:默认Bean作用域为singleton
  • 工厂:BeanFactory与ApplicationContext
  • 代理:JdkDynamicAopProxy与CglibAopProxy
  • 模板:JdbcTemplate封装JDBC样板代码
  • 策略:HandlerMapping接口多种实现
  • 观察者:ApplicationEvent与ApplicationListener

MyBatis中的核心模式

  • 建造者:SqlSessionFactoryBuilder构建SqlSessionFactory
  • 代理:Mapper接口通过JDK动态代理生成实现
  • 适配器:StatementHandler适配不同数据库驱动
  • 责任链:Plugin拦截器链处理

Guava库中的优雅设计

  • 单例:ImmutableList.of()返回共享实例
  • 装饰器:Collections2.transformedImmutableList()
  • 策略:Ordering定义比较策略
  • 观察者:EventBus异步事件总线

⚠️ 实施建议

  1. 先重构现有代码:优先处理if-else分支过多、重复代码的模块
  2. 小步快跑:每次仅引入1-2种模式,避免过度设计
  3. 团队共识:制定设计模式使用规范文档,避免滥用
  4. 结合框架:利用Spring等框架内置模式能力,减少手写

⚠️ 常见误区与调试技巧

误区1:为模式而模式

强行套用模式导致代码复杂度上升,却未带来实际收益。例如:用单例模式管理轻量级工具类(如MathUtils),反而增加测试难度。

正确做法:只有当“全局唯一实例”确实带来价值(如数据库连接池)时才用单例。

误区2:过度使用继承

在策略模式中用继承替代组合,导致类层级爆炸。例如:为每种折扣策略创建子类,而非实现策略接口。

正确做法:优先使用组合(如DiscountStrategy接口),遵循“多用组合,少用继承”原则。

误区3:忽略性能影响

装饰器模式导致多层包装,增加调用开销;代理模式引发反射调用(JDK动态代理)。

调试技巧:使用JProfiler或Async-Profiler分析热点方法;对高频调用路径考虑缓存或优化实现(如用MethodHandle替代反射)。

误区4:状态管理混乱

状态模式中状态转移逻辑分散在各状态类,导致难以维护。

解决方案:引入状态机框架(如Spring StateMachine),或定义明确的转移表。

调试工具推荐

  • UML建模:PlantUML(代码生成UML图)
  • 运行时跟踪:IDEA的Method Trace插件
  • 日志监控:SLF4J + MDC(上下文传播)

❓ 网友们还关心

Q1:Java 8+ 中函数式接口能否替代策略模式?

A:可以部分替代!对于单方法策略(如Comparator),用lambda更简洁;但对于需维护状态的策略(如DiscountStrategy含优惠券缓存),仍需类实现。

Q2:设计模式与SOLID原则的关系?

A:设计模式是SOLID原则的实践载体。例如:

  • 单例模式 → 单一职责(SRP)
  • 依赖倒置(DIP) → 工厂、抽象工厂模式
  • 接口隔离(ISP) → 桥接、装饰器模式

Q3:如何判断是否该用代理模式?

A:满足以下任一即可考虑:

  1. 需在调用前后插入逻辑(如日志、权限校验)
  2. 需延迟加载(虚拟代理)
  3. 需控制远程对象访问(远程代理)

否则直接调用更高效。

Q4:设计模式在微服务中还有用吗?

A:更有用!例如:

  • 服务网关 → 责任链模式(认证、限流、日志链)
  • 配置中心 → 观察者模式(配置变更通知)
  • 熔断降级 → 状态模式(正常/熔断/降级)