java设计模式

掌握23种经典设计模式,构建高内聚、低耦合、可维护、可扩展的Java系统架构

立即深入学习

设计模式全景图谱

基于GoF《设计模式:可复用面向对象软件的基础》经典理论,结合Java语言特性与企业级开发实践,系统梳理23种设计模式的核心思想、适用场景与实现要点

创建型模式(5种)

关注对象的创建机制,抽象实例化过程,使系统独立于对象的创建、组合和表示方式

  • 单例模式:确保类只有一个实例并提供全局访问点
  • 工厂方法模式:定义创建对象的接口,让子类决定实例化哪一个类
  • 抽象工厂模式:提供创建一系列相关或相互依赖对象的接口
  • 建造者模式:分离复杂对象的构建过程与表示
  • 原型模式:通过复制现有对象创建新对象

结构型模式(7种)

处理类与对象的组合,形成更大的结构,同时保持结构的灵活与高效

  • 适配器模式:将一个类的接口转换成客户端期望的另一个接口
  • 装饰器模式:动态地给对象添加额外职责,是继承的替代方案
  • 代理模式:为其他对象提供一种代理以控制对这个对象的访问
  • 外观模式:为子系统中的一组接口提供统一的高层接口
  • 桥接模式:将抽象部分与实现部分分离,使它们可以独立变化
  • 组合模式:将对象组合成树形结构以表示“部分-整体”层次结构
  • 享元模式:运用共享技术有效支持大量细粒度对象

行为型模式(11种)

关注对象之间的通信与职责分配,描述对象或类之间的交互模式

  • 策略模式:定义一系列算法,将每个算法封装起来并使它们可互换
  • 观察者模式:定义对象间的一对多依赖关系,当一个对象改变状态时,所有依赖者自动更新
  • 命令模式:将请求封装为对象,从而可用不同的请求对客户进行参数化
  • 责任链模式:使多个对象都有机会处理请求,避免请求发送者与接收者的耦合
  • 状态模式:允许对象在内部状态改变时改变其行为
  • 模板方法模式:定义一个操作中的算法骨架,而将一些步骤延迟到子类中
  • 迭代器模式:提供一种方法顺序访问一个聚合对象中各个元素
  • 访问者模式:表示一个作用于某对象结构中的各元素的操作
  • 中介者模式:用一个中介对象来封装一系列对象之间的交互
  • 备忘录模式:在不破坏封装性的前提下,捕获一个对象的内部状态
  • 解释器模式:给定一个语言,定义它的文法的一种表示,并定义一个解释器

创建型模式详解

深入解析单例、工厂、建造者等模式的原理、变体与最佳实践

单例模式:Java中的全局唯一性保障

单例模式确保某个类只有一个实例,并提供全局访问点。在Java中,实现单例需解决三个核心问题:唯一实例、全局访问、线程安全。

常见实现方式:

  1. 饿汉式:类加载时即创建实例,线程安全但可能造成资源浪费
  2. 懒汉式(双重检查锁定):延迟初始化,兼顾性能与安全,推荐企业级应用
  3. 静态内部类:利用JVM类加载机制实现延迟加载与线程安全,代码简洁优雅
  4. 枚举单例:《Effective Java》推荐方式,天然防止反射与反序列化攻击
// 静态内部类单例(推荐)
public class Singleton {
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton() {}
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

典型应用场景:

  • 数据库连接池管理器(如HikariCP的全局配置)
  • Spring容器中的默认Bean作用域(singleton)
  • 日志记录器(Logger)的全局实例
  • 系统配置管理(如AppConfig)

避坑指南:

  • 避免使用双重检查锁定的非volatile版本(JDK5前存在指令重排序风险)
  • 反序列化时需重写readResolve()方法防止创建新实例
  • 反射攻击可通过在构造器中抛出异常防护(枚举单例天然免疫)

工厂模式:解耦对象创建与使用

工厂模式将对象的创建逻辑封装起来,客户端仅依赖抽象接口,实现创建与使用的解耦。Java中常见变体包括工厂方法模式与抽象工厂模式。

工厂方法模式(Factory Method)

定义一个创建对象的接口,但让子类决定实例化哪个类。符合开闭原则,新增产品只需新增工厂子类。

// 抽象产品
public interface Logger {
    void log(String message);
}
// 具体产品
public class FileLogger implements Logger {
    public void log(String msg) { // 写入文件 }
}
public class ConsoleLogger implements Logger {
    public void log(String msg) { System.out.println(msg); }
}
// 抽象工厂
public interface LoggerFactory {
    Logger createLogger();
}
// 具体工厂
public class FileLoggerFactory implements LoggerFactory {
    public Logger createLogger() { return new FileLogger(); }
}
public class ConsoleLoggerFactory implements LoggerFactory {
    public Logger createLogger() { return new ConsoleLogger(); }
}

抽象工厂模式(Abstract Factory)

提供创建一系列相关或相互依赖对象的接口,而无需指定其具体类。适用于产品族场景,如多数据库适配器、多UI主题系统。

典型应用场景:

  • Spring的BeanFactory与ApplicationContext体系
  • JDBC的Connection/Statement/ResultSet工厂链
  • MyBatis的SqlSessionFactory与Configuration
  • Web框架中多数据源、多缓存策略的统一管理

工厂模式 vs 构建者模式:

对比项工厂模式建造者模式
关注点创建单一对象构建复杂对象的步骤
对象特性通常较简单,参数较少包含多个可选部件,构建过程复杂
客户端交互调用工厂方法直接获取对象通过Director指导Builder逐步构建

建造者模式:构建复杂对象的艺术

当对象构造过程复杂、参数众多且部分参数可选时,建造者模式通过分步构建实现灵活配置,避免重叠构造器反模式。

public class User {
    private final String username;
    private final String email;
    private final String phone;
    private final Integer age;
    private final String address;
    private User(Builder builder) {
        this.username = builder.username;
        this.email = builder.email;
        this.phone = builder.phone;
        this.age = builder.age;
        this.address = builder.address;
    }
    public static class Builder {
        private final String username;  // 必填项
        private String email;
        private String phone;
        private Integer age;
        private String address;
        public Builder(String username) { this.username = username; }
        public Builder email(String email) { this.email = email; return this; }
        public Builder phone(String phone) { this.phone = phone; return this; }
        public Builder age(Integer age) { this.age = age; return this; }
        public Builder address(String address) { this.address = address; return this; }
        public User build() {
            if (username == null) throw new IllegalStateException("username required");
            return new User(this);
        }
    }
}
// 使用示例
User user = new User.Builder("javapattern")
    .email("user@example.com")
    .age(28)
    .address("Shanghai")
    .build();

适用场景:

  • 对象具有多个可选参数(如HTTP请求构建器OkHttp、Retrofit)
  • 构建过程需保证对象完整性(如数据库连接参数配置)
  • 需要不可变对象(Immutable Object)提升线程安全
  • 领域模型对象(如订单、用户、商品)构建逻辑复杂

与工厂模式的区别深化:

工厂模式关注“创建什么”,强调产品类型的选择;建造者模式关注“怎么创建”,强调构建过程的控制与细节封装。工厂模式常返回一个具体产品,而建造者模式通过Director+Builder组合生成复杂对象。在Spring中,@Configuration类配合@Bean方法常混合使用工厂思想;而JPA的EntityGraph构建则典型使用建造者模式。

2001年:《设计模式》中文版出版

GoF四人组的经典著作《Design Patterns: Elements of Reusable Object-Oriented Software》中文化,标志着设计模式思想正式引入中国Java开发者社区。书中23种模式成为Java开发者的“设计圣经”,催生了大量模式实现与实践案例。

2008年:Spring框架兴起

Spring以IoC容器为核心,大量运用工厂模式、单例模式、代理模式。开发者在无意识中实践设计模式,降低了学习门槛,推动模式在企业级开发中的普及。AbstractBeanFactory、DefaultListableBeanFactory等类成为工厂模式的教科书级实现。

2014年:Java 8函数式编程引入

Lambda表达式与Stream API极大简化了观察者模式、策略模式的实现。例如,Runnable、Comparator、Predicate等函数式接口天然支持策略模式;Observable类虽被弃用,但RxJava等库复兴了观察者模式,使事件驱动架构更简洁优雅。

2020年:云原生与微服务架构兴起

在分布式系统中,适配器模式用于多数据源/消息中间件适配;装饰器模式用于日志、安全、限流等横切关注点的动态增强;模板方法模式广泛用于Spring的JdbcTemplate、RestTemplate等抽象模板类。设计模式成为微服务模块解耦的关键工具。

结构型模式深度解析

构建灵活可扩展的系统架构,平衡性能与可维护性

适配器模式:系统集成的粘合剂

适配器模式将一个类的接口转换成客户端期望的另一个接口,使原本不兼容的类能协同工作。分为类适配器(继承)与对象适配器(组合),Java中更推荐组合方式以遵循合成复用原则。

// 类适配器(继承)
public class VoltageAdapter extends Voltage220V implements Voltage5V {
    public int output5V() {
        int src = output220V();
        return src / 44; // 简化:220V → 5V
    }
}
// 对象适配器(组合,推荐)
public class VoltageAdapter2 implements Voltage5V {
    private Voltage220V voltage220V;
    public VoltageAdapter2(Voltage220V v220) { this.voltage220V = v220; }
    public int output5V() {
        return voltage220V.output220V() / 44;
    }
}
// 实际应用:Java I/O中的InputStreamReader
new InputStreamReader(new FileInputStream("test.txt"), "UTF-8");
// 将字节流(InputStream)适配为字符流(Reader)

典型场景:

  • 数据库驱动适配(JDBC Driver统一接口适配不同DB实现)
  • 第三方SDK集成(如微信支付API适配为统一支付服务接口)
  • Spring的HandlerAdapter体系(适配不同类型的Controller)
  • 旧系统与新系统集成(Legacy Adapter模式)

与装饰器模式的辨析:

适配器模式重在“转换”,解决接口不兼容问题;装饰器模式重在“增强”,在不修改原对象前提下动态添加功能。例如:InputStreamReader是适配器(字节→字符),而BufferedInputStream是装饰器(添加缓冲功能)。

装饰器模式:动态扩展对象功能

装饰器模式动态地给对象添加额外职责,比生成子类更灵活。核心在于:装饰者与被装饰者实现相同接口,装饰者持有被装饰者引用。

// 抽象组件
public interface Component {
    void operation();
}
// 具体组件
public class ConcreteComponent implements Component {
    public void operation() { System.out.println("核心业务逻辑"); }
}
// 抽象装饰器
public abstract class Decorator implements Component {
    protected Component component;
    public Decorator(Component c) { this.component = c; }
}
// 具体装饰器A:添加日志
public class LoggingDecorator extends Decorator {
    public LoggingDecorator(Component c) { super(c); }
    public void operation() {
        System.out.println("[LOG] 开始执行...");
        component.operation();
        System.out.println("[LOG] 执行完成");
    }
}
// 具体装饰器B:添加缓存
public class CachingDecorator extends Decorator {
    private final Map cache = new ConcurrentHashMap<>();
    public CachingDecorator(Component c) { super(c); }
    public void operation() {
        String key = "default";
        if (!cache.containsKey(key)) {
            cache.put(key, component.operation());
        }
        // 实际返回值需调整,此处简化
        System.out.println("[CACHE] 命中缓存");
    }
}

Java典型应用:

  • Java I/O流体系(BufferedInputStream、DataInputStream等)
  • Servlet过滤器链(FilterChain实现装饰链)
  • Spring的TransactionTemplate、DataSourceProxy
  • Dubbo的Filter扩展机制(如MonitorFilter、TimeoutFilter)

优势与风险:

  • ✓ 动态扩展,符合开闭原则
  • ✓ 避免子类爆炸(如10种装饰×5层装饰 → 50子类 vs 装饰组合)
  • ✗ 多层装饰导致调试困难(需关注装饰顺序)
  • ✗ 小对象频繁创建可能影响GC(可配合享元模式优化)

代理模式:控制对象访问的守门人

代理模式为其他对象提供一种代理以控制对该对象的访问。分为静态代理(手动编写)与动态代理(JDK/CGLIB),广泛应用于AOP、远程调用、延迟加载等场景。

// JDK动态代理(基于接口)
public class ProxyInvocationHandler implements InvocationHandler {
    private final Object target;
    public ProxyInvocationHandler(Object target) { this.target = target; }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[Before] 调用: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("[After] 返回: " + result);
        return result;
    }
}
// 使用
UserService proxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class[]{UserService.class},
    new ProxyInvocationHandler(userServiceImpl)
);
// CGLIB动态代理(基于继承)
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserServiceImpl.class);
enhancer.setCallback(new MethodInterceptor() {
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) {
        System.out.println("[CGLIB] 拦截: " + method.getName());
        return proxy.invokeSuper(obj, args);
    }
});
UserServiceImpl proxy = (UserServiceImpl) enhancer.create();

代理类型对比:

类型实现方式适用场景
静态代理手写代理类接口稳定、代理逻辑简单(如RPC Client Stub)
JDK动态代理反射+InvocationHandler目标类实现接口(Spring AOP默认)
CGLIB代理继承+MethodInterceptor目标类无接口或需代理非public方法

典型应用场景:

  • Spring AOP(事务、日志、安全控制)
  • MyBatis的Mapper代理(自动生成实现类)
  • RPC框架(Dubbo、gRPC的Stub/Skeleton)
  • 延迟加载(Hibernate的Proxy)

行为型模式实战

优化对象间协作,提升系统灵活性与可维护性

观察者模式:事件驱动架构的核心

观察者模式定义对象间的一对多依赖关系,当一个对象状态改变时,所有依赖者自动收到通知。Java中Observable类已过时,推荐使用java.util.Observer接口或自定义事件总线。

// 自定义观察者模式
public interface Observer {
    void update(String event);
}
public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers(String event);
}
public class EventBus implements Subject {
    private final List observers = new CopyOnWriteArrayList<>();
    public void registerObserver(Observer o) { observers.add(o); }
    public void removeObserver(Observer o) { observers.remove(o); }
    public void notifyObservers(String event) {
        observers.forEach(o -> o.update(event));
    }
}
// 使用
EventBus bus = new EventBus();
bus.registerObserver(e -> System.out.println("日志: " + e));
bus.registerObserver(e -> System.out.println("监控: " + e));
bus.notifyObservers("用户登录成功");

Java生态应用:

  • Spring的ApplicationEvent体系(@EventListener、@PublishEvent)
  • JavaFX的事件处理(MouseEvent、ActionEvent)
  • Reactive Streams(Flux/Mono)实现响应式观察者
  • 消息队列客户端(Kafka消费者组本质是分布式观察者)

与发布-订阅模式区别:

观察者模式中,Subject直接持有Observer引用(同步调用);发布-订阅模式通过消息代理解耦(异步通信)。Spring的ApplicationEvent属于观察者模式,而RabbitMQ/Kafka属于发布-订阅模式。

策略模式:算法封装与切换的艺术

策略模式定义一系列算法,将每个算法封装起来并使它们可互换。客户端在运行时选择具体策略,避免大量if-else分支。

// 策略接口
public interface DiscountStrategy {
    double calculate(double originalPrice);
}
// 具体策略
public class NormalDiscount implements DiscountStrategy {
    public double calculate(double price) { return price; }
}
public class MemberDiscount implements DiscountStrategy {
    public double calculate(double price) { return price * 0.9; }
}
public class VipDiscount implements DiscountStrategy {
    public double calculate(double price) { return price * 0.8; }
}
// 上下文
public class PriceContext {
    private DiscountStrategy strategy;
    public PriceContext(DiscountStrategy s) { this.strategy = s; }
    public void setStrategy(DiscountStrategy s) { this.strategy = s; }
    public double executeStrategy(double price) { return strategy.calculate(price); }
}
// 使用
PriceContext ctx = new PriceContext(new VipDiscount());
System.out.println(ctx.executeStrategy(100.0)); // 输出: 80.0

典型应用场景:

  • 支付渠道选择(微信/支付宝/银联)
  • 排序算法动态选择(Arrays.sort根据数据类型选择插入/快速/归并)
  • 缓存淘汰策略(LRU/FIFO/LFU)
  • Spring的ResourceLoader体系(ClassPath/FileSystem/URL)

与状态模式关系:

策略模式强调“算法可互换”,状态模式强调“状态可迁移”。例如:订单状态(待支付/已支付/已发货)的切换是状态模式;而支付方式(微信/支付宝)的选择是策略模式。两者常结合使用:订单状态类持有一个支付策略对象。

模板方法:复用算法骨架

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

// 抽象模板
public abstract class DataImporter {
    // 模板方法(final防止重写)
    public final void importData() {
        openFile();
        readData();
        processData();
        saveData();
        closeFile();
    }
    protected abstract void openFile();
    protected abstract void readData();
    protected void processData() { // 默认实现 }
    protected abstract void saveData();
    protected void closeFile() { // 默认实现 }
}
// 具体模板
public class CSVImporter extends DataImporter {
    protected void openFile() { // 打开CSV文件 }
    protected void readData() { // 读取CSV行 }
    protected void processData() { // 解析CSV字段 }
    protected void saveData() { // 保存到DB }
}

Java典型应用:

  • Spring的JdbcTemplate(execute、query等模板方法)
  • Servlet的HttpServlet(doGet/doPost由子类实现)
  • Java集合框架的AbstractList/AbstractMap
  • MyBatis的BaseExecutor(query/update模板方法)

钩子方法(Hook):

模板方法可定义可选方法供子类选择性重写,如processData()提供默认空实现。Spring的AbstractApplicationContext的onRefresh()即钩子方法,允许子类在容器刷新时插入自定义逻辑。

企业级实战应用

设计模式在微服务、高并发、分布式系统中的深度实践

微服务架构中的模式组合

在Spring Cloud微服务中,设计模式被广泛应用于模块解耦:

  • 适配器模式:Spring Cloud LoadBalancer适配不同负载均衡策略(轮询/随机/加权)
  • 装饰器模式:Sentinel的SlotChain(AuthoritySlot、FlowSlot等动态组合)
  • 模板方法:Spring Boot的AutoConfigurationRunner
  • 工厂模式:FeignClient的动态代理生成

实际案例:某电商订单服务通过策略模式+状态模式实现订单生命周期管理,状态迁移(待支付→已支付→已发货)触发不同策略(优惠券释放、库存回滚),系统可维护性提升40%。

高并发场景的模式优化

面对百万级QPS,设计模式需结合性能考量:

  • 单例模式:使用静态内部类或枚举实现线程安全单例,避免synchronized开销
  • 享元模式:Integer缓存(-128~127)、String常量池、线程池中的工作线程复用
  • 原型模式:通过clone()或序列化实现对象深拷贝,避免频繁new(如Netty的ByteBuf池)
  • 建造者模式:Netty的ChannelOption配置、OkHttp的Request.Builder

反例:某系统用工厂模式创建大量短生命周期对象导致GC频繁,改用对象池+建造者模式后,GC时间下降60%。

DDD领域驱动设计中的模式

在领域驱动设计(DDD)中,设计模式是实现领域模型的关键工具:

  • 工厂模式:AggregateRoot的工厂方法封装复杂创建逻辑
  • 构建者模式:Value Object的不可变对象构建(如Money、Address)
  • 装饰器模式:Domain Service的横切关注点(缓存、日志)增强
  • 观察者模式:领域事件(Domain Event)发布订阅机制

案例:金融系统中,交易聚合根通过工厂方法创建订单,订单状态变更时发布DomainEvent,由事件监听器触发通知、对账等操作,实现领域逻辑与技术细节解耦。

常见问题解答

关于java设计模式的典型疑问与权威解答

Q1: 单例模式的线程安全问题

A:Java中实现线程安全单例的推荐方式:

  1. 静态内部类:利用JVM类加载机制,延迟加载且线程安全
  2. 枚举单例:《Effective Java》推荐,天然防反射与反序列化
  3. 双重检查锁定(volatile):需声明INSTANCE为volatile防止指令重排序

错误示例(非volatile懒汉式):

private static Singleton instance;  // 缺少volatile
public static Singleton getInstance() {
    if (instance == null) {
        synchronized (Singleton.class) {
            if (instance == null) {
                instance = new Singleton(); // 可能发生指令重排序
            }
        }
    }
    return instance;
}

正确实现:

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

Q2: 代理模式性能影响

A:动态代理确实有性能开销,但现代JDK已大幅优化:

  • JDK代理:基于反射,JDK8后性能提升明显( invokedynamic)
  • CGLIB代理:生成子类,首次加载慢但运行快;JDK15+需开启--enable-preview
  • 优化建议:
    • 避免嵌套多层代理(如代理的代理)
    • 高频调用场景用缓存代理对象
    • 非必要时用静态代理或直接调用

实测数据(Spring AOP vs 直接调用):

调用次数直接调用(ms)JDK代理(ms)
10001.21.8
10000085.6112.3

结论:10万次调用仅增加26ms,对大多数业务系统可忽略。

Q3: 设计模式学习路径

A:建议循序渐进:

  1. 基础阶段:掌握SOLID原则,理解类图与时序图
  2. 入门阶段:精读单例、工厂、策略、观察者模式,手写代码
  3. 进阶阶段:分析Spring源码中的模式应用(如ApplicationContext体系)
  4. 实战阶段:在项目中重构if-else逻辑为策略模式,或添加日志为装饰器

推荐学习资源:

  • 《设计模式:可复用面向对象软件的基础》(GoF)
  • 《Head First设计模式》(图解入门)
  • 《Spring源码深度解析》(实战应用)
  • GitHub开源项目:Spring Framework、MyBatis源码