java最常用设计模式

深入理解23种设计模式原理与实战应用 | 附Spring/JDK源码解析

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

· java最常用设计模式全景解析

为什么java最常用设计模式是程序员进阶的必经之路?

在Java企业级开发中,设计模式早已不是理论概念,而是实战中反复验证的解决方案集合。当面对复杂业务逻辑、高并发场景或系统扩展性需求时,**java最常用设计模式**往往成为架构设计的基石。从Spring框架的核心组件到JDK源码中的经典实现,设计模式无处不在——单例模式保障全局配置一致性,工厂模式解耦对象创建过程,代理模式支撑AOP切面编程,观察者模式驱动事件驱动架构……掌握这些模式,意味着你能够读懂主流框架的设计思想,快速定位源码中的关键逻辑。

本指南面向具备基础Java语法能力的开发者,系统梳理23种经典设计模式,每种模式均包含:
• 核心原理与UML类图说明
• 多种Java实现方式(含线程安全版本)
• Spring源码中的实际应用案例
• 常见反模式与避坑指南
• 开发者高频疑问深度解答

特别说明:随着微服务架构普及,java最常用设计模式的应用场景正在演进——分布式环境下单例模式需结合分布式锁,事件驱动架构强化了观察者模式的异步能力,策略模式与策略引擎结合形成动态规则引擎。这些演进方向将在各章节中重点标注。

💡 核心价值:理解设计模式不是为背诵模式名称,而是掌握问题抽象能力与解耦设计思维。当需求变更时,能快速判断“这属于哪类模式的应用场景”比记住代码实现更重要。

· 23种设计模式分类全景图

设计模式三大分类与核心关系

GoF在《设计模式:可复用面向对象软件的基础》中提出23种经典模式,按用途可分为三类:
创建型模式(5种):关注对象创建机制,解决“如何创建对象”的问题
结构型模式(7种):处理类与对象的组合,构建更大结构
行为型模式(11种):描述对象间职责分配与通信机制

⚡ 创建型模式

  • 〈单例模式〉确保唯一实例
  • 〈工厂模式〉解耦创建与使用
  • 〈建造者模式〉分步构建复杂对象
  • 〈原型模式〉复制现有对象
  • 〈抽象工厂模式〉创建产品族

⚙️ 结构型模式

  • 〈适配器模式〉接口转换
  • 〈装饰器模式〉动态增强功能
  • 〈代理模式〉控制对象访问
  • 〈组合模式〉树形结构统一处理
  • 〈桥接模式〉抽象与实现分离
  • 〈外观模式〉简化子系统接口
  • 〈享元模式〉共享细粒度对象

⚡ 行为型模式

  • 〈策略模式〉算法族动态切换
  • 〈模板方法〉封装不变部分
  • 〈观察者模式〉事件驱动架构
  • 〈责任链模式〉多级处理请求
  • 〈命令模式〉请求参数化
  • 〈状态模式〉状态机实现
  • 〈访问者模式〉分离操作与结构
  • 〈中介者模式〉解耦多对象交互
  • 〈备忘录模式〉保存对象状态
  • 〈解释器模式〉语言解析引擎
  • 〈迭代器模式">顺序访问集合

值得注意的是:java最常用设计模式在实际开发中常组合使用。例如Spring的Bean创建结合了工厂模式与单例模式,AOP代理层使用代理模式,事务管理采用模板方法模式。理解模式间的协作关系,才能构建高内聚低耦合的系统架构。

🔍 开发者调研:据2024年Java开发者生态报告,单例模式、工厂模式、观察者模式、策略模式在企业级项目中使用频率最高,其中87%的项目存在模式误用情况(如单例模式未考虑线程安全),本指南将重点解析这些高频易错场景。

· 单例模式:线程安全与序列化挑战

单例模式的核心价值:全局唯一实例

单例模式确保某个类只有一个实例,并提供全局访问点。在Java中,常见应用场景包括:
• 全局配置管理器(如ApplicationConfig)
• 数据库连接池管理器
• 日志记录器(Logger)
• 缓存管理器(如EhCacheManager)

但java最常用设计模式的单例实现存在多个陷阱:

常见实现方式与问题分析

① 饿汉式:类加载即创建

public class ConfigManager {
    private static final ConfigManager INSTANCE = new ConfigManager();
    private ConfigManager() {}
    public static ConfigManager getInstance() {
        return INSTANCE;
    }
}

优点:线程安全、实现简单
缺点:类加载时即创建实例,可能造成资源浪费(当实例创建成本高且不常用时)
适用场景:实例创建开销小、必然被使用的场景(如配置读取器)

② 懒汉式:延迟加载陷阱

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

问题:synchronized导致每次获取都加锁,性能低下
改进方案:DCL双重检查锁定

③ DCL双重检查:volatile是关键

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

关键点:必须使用volatile防止指令重排序!否则可能返回未完全初始化的对象

④ 静态内部类:JVM级延迟加载

public class CacheManager {
    private static class Holder {
        private static final CacheManager INSTANCE = new CacheManager();
    }
    private CacheManager() {}
    public static CacheManager getInstance() {
        return Holder.INSTANCE;
    }
}

原理:利用类加载机制保证线程安全,同时实现延迟加载
优势:无同步开销、实现简洁、推荐企业级使用

⑤ 枚举实现:最安全的单例

public enum ApplicationConfig {
    INSTANCE;
    private Properties config;
    ApplicationConfig() {
        config = new Properties();
        // 加载配置逻辑
    }
    public String getProperty(String key) {
        return config.getProperty(key);
    }
}

优势:
• 自动处理序列化问题(避免反序列化破坏单例)
• 天然防止反射攻击
• 实现最简洁
注意:枚举单例无法延迟加载,但可通过工厂方法包装实现

⚠️ 高频问题:单例模式在分布式系统中的挑战
当应用部署为多实例集群时,JVM级单例无法保证全局唯一。解决方案:
• 使用Redis等分布式缓存实现全局单例
• 结合Zookeeper协调服务
• 采用配置中心统一管理配置(如Apollo/Nacos)
• Spring的@Scope("singleton")仅在单应用内有效!

· 工厂模式:解耦对象创建的艺术

工厂模式的演进路径

当对象创建逻辑复杂或可能变化时,工厂模式将创建责任与使用责任分离。从简单工厂到抽象工厂,java最常用设计模式的工厂体系帮助系统应对需求变更。

① 简单工厂:静态方法工厂

public class ShapeFactory {
    public static Shape createShape(String type) {
        switch (type.toLowerCase()) {
            case "circle": return new Circle();
            case "rectangle": return new Rectangle();
            default: throw new IllegalArgumentException("未知形状类型");
        }
    }
}

问题:违反开闭原则(新增形状需修改工厂类)
改进:工厂方法模式

② 工厂方法:多工厂解耦

public interface ShapeFactory {
    Shape createShape();
}
public class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}
public class RectangleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

优势:符合开闭原则,新增产品只需新增工厂类
典型应用:Spring的BeanFactory体系(DefaultListableBeanFactory等)

③ 抽象工厂:产品族创建

public interface DatabaseFactory {
    Connection createConnection();
    Statement createStatement();
    PreparedStatement createPreparedStatement(String sql);
}
public class MySQLFactory implements DatabaseFactory {
    @Override
    public Connection createConnection() {
        return new MySQLConnection();
    }
    // 其他方法实现...
}

适用场景:需要创建一组相关或依赖对象(如数据库驱动全家桶)
Spring应用:JdbcTemplate的创建逻辑封装在DataSourceUtils中

🔍 Spring源码洞察:Spring的Bean创建过程融合了多种工厂模式:
• AbstractBeanFactory作为抽象工厂
• DefaultListableBeanFactory实现具体工厂
• FactoryBean接口作为扩展点(如TransactionFactory)
理解工厂模式是读懂Spring源码的钥匙!

· 代理模式:AOP的底层实现机制

代理模式的两种实现方式

代理模式为其他对象提供一种代理以控制对这个对象的访问。在Java中,主要通过两种方式实现:

① 静态代理:编译期生成

public interface UserService {
    void addUser(String name);
}
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("添加用户: " + name);
    }
}
public class UserServiceProxy implements UserService {
    private final UserService target;
    UserServiceProxy(UserService target) {
        this.target = target;
    }
    @Override
    public void addUser(String name) {
        System.out.println("开始事务");
        target.addUser(name);
        System.out.println("提交事务");
    }
}

缺点:每个目标类都需要代理类,代码膨胀严重
解决方案:动态代理

② 动态代理:运行时生成

public class TransactionHandler implements InvocationHandler {
    private final Object target;
    TransactionHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始事务");
        Object result = method.invoke(target, args);
        System.out.println("提交事务");
        return result;
    }
}
// 使用
UserService target = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    target.getClass().getInterfaces(),
    new TransactionHandler(target)
);

优势:无需为每个目标类编写代理类
Spring应用:JDK动态代理用于基于接口的代理;CGLIB用于基于继承的代理

💡 AOP底层原理:Spring AOP的核心是代理模式!
• @Transactional注解通过动态代理实现事务控制
• @Cacheable注解通过代理实现缓存逻辑
• 自定义@Loggable注解可通过代理实现日志切面
掌握代理模式是理解Spring AOP的基石!

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

观察者模式的Java实现演进

观察者模式定义对象间的一对多依赖关系,当一个对象改变状态时,所有依赖者自动收到通知。在Java中,从java.util.Observer到Spring Event,java最常用设计模式的观察者体系不断演进。

① java.util.Observer:已过时的实现

public class WeatherData extends Observable {
    private float temperature;
    public void setTemperature(float temp) {
        temperature = temp;
        setChanged();
        notifyObservers(temperature);
    }
}
public class CurrentConditionsDisplay implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("当前温度: " + arg);
    }
}

问题:Observable是类而非接口,继承即受限
现代方案:自定义观察者或使用Spring Event

② 自定义观察者:接口驱动

public interface Observer<T> {
    void update(T event);
}
public class EventBus<T> {
    private final List<Observer<T>> observers = new CopyOnWriteArrayList<>();
    public void register(Observer<T> observer) {
        observers.add(observer);
    }
    public void notify(T event) {
        observers.forEach(o -> o.update(event));
    }
}

优势:灵活扩展,支持泛型类型安全
典型应用:Netty的ChannelHandler链式处理

③ Spring Event:异步事件驱动

// 定义事件
public class UserRegisteredEvent extends ApplicationEvent {
    private final String username;
    UserRegisteredEvent(Object source, String username) {
        super(source);
        this.username = username;
    }
    public String getUsername() { return username; }
}
// 监听器
@Component
public class EmailNotificationListener {
    @EventListener
    public void handleUserRegistered(UserRegisteredEvent event) {
        System.out.println("发送注册邮件给: " + event.getUsername());
    }
}
// 发布事件
@Autowired
private ApplicationEventPublisher publisher;
publisher.publishEvent(new UserRegisteredEvent(this, "zhangsan"));

高级特性:
• @Async实现异步事件处理
• @Order控制监听器执行顺序
• TransactionalEvent支持事务绑定事件
典型应用:Spring Security的AuthenticationSuccessEvent

🔍 开发者高频问题:观察者模式 vs 发布订阅模式
• 观察者模式:目标与观察者直接交互(紧耦合)
• 发布订阅模式:通过消息代理解耦(松耦合)
Spring Event本质是观察者模式,但通过ApplicationContext作为中介,具备发布订阅的部分特性!

· 策略模式:消除冗长if-else的艺术

策略模式的实战价值

策略模式定义一系列算法,将每个算法封装起来,并使它们可互换。在业务开发中,策略模式常用于替代冗长的if-else判断,提升代码可维护性。

① 基础策略模式实现

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal originalPrice);
}
public class NormalDiscount implements DiscountStrategy {
    @Override
    public BigDecimal calculate(BigDecimal price) {
        return price;
    }
}
public class VIPDiscount implements DiscountStrategy {
    @Override
    public BigDecimal calculate(BigDecimal price) {
        return price.multiply(BigDecimal.valueOf(0.8));
    }
}

使用方式:
DiscountStrategy strategy = new VIPDiscount();
BigDecimal finalPrice = strategy.calculate(originalPrice);

② 枚举策略:结合策略注册表

public enum DiscountType {
    NORMAL("normal", new NormalDiscount()),
    VIP("vip", new VIPDiscount()),
    SUPER_VIP("super_vip", new SuperVipDiscount());
    private final String code;
    private final DiscountStrategy strategy;
    DiscountType(String code, DiscountStrategy strategy) {
        this.code = code;
        this.strategy = strategy;
    }
    public static DiscountStrategy getStrategy(String code) {
        return Arrays.stream(DiscountType.values())
            .filter(t -> t.code.equals(code))
            .map(t -> t.strategy)
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("未知优惠类型"));
    }
}

优势:统一管理策略,避免散乱的if-else
适用场景

③ Spring策略注册:动态策略管理

// 策略接口
@FunctionalInterface
public interface PriceCalculator {
    BigDecimal calculate(BigDecimal price);
}
// 策略实现
@Component
public class NormalCalculator implements PriceCalculator {
    @Override
    public BigDecimal calculate(BigDecimal price) {
        return price;
    }
}
// 策略注册表
@Component
public class PriceCalculatorRegistry {
    private final Map<String, PriceCalculator> calculators = new HashMap<>();
    public PriceCalculatorRegistry(List<PriceCalculator> allCalculators) {
        allCalculators.forEach(c -> {
            String name = ClassUtils.getSimpleName(c.getClass()).toLowerCase();
            calculators.put(name.replace("calculator", ""), c);
        });
    }
    public PriceCalculator getCalculator(String type) {
        return calculators.getOrDefault(type, calculators.get("normal"));
    }
}

使用示例:
PriceCalculator calculator = registry.getCalculator("vip");
BigDecimal finalPrice = calculator.calculate(originalPrice);
优势:新增策略无需修改注册表,自动通过Spring注入

💡 业务场景:策略模式在电商系统中的应用
• 优惠策略:满减、折扣、赠品
• 运费策略:包邮、标准运费、快递加价
• 支付策略:支付宝、微信、银联
掌握策略模式是构建可扩展业务系统的关键!

· 模板方法模式:封装不变部分

模板方法模式的核心思想

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

① 基础模板方法

public abstract class AbstractDataImporter {
    // 模板方法
    public final void importData(String filePath) {
        List<String> lines = readFile(filePath);
        List<Object> data = parseData(lines);
        validateData(data);
        saveData(data);
        logImportResult(data.size());
    }
    protected abstract List<Object> parseData(List<String> lines);
    protected abstract void saveData(List<Object> data);
    // 默认实现
    protected List<String> readFile(String filePath) {
        // 文件读取逻辑
    }
    protected void validateData(List<Object> data) {
        // 默认验证逻辑
    }
    protected void logImportResult(int count) {
        System.out.println("成功导入 " + count + " 条数据");
    }
}

关键点:模板方法必须是final,防止子类重写破坏算法结构
适用场景:算法骨架固定,部分步骤可变

② 钩子方法:允许子类定制

public abstract class AbstractDataImporter {
    protected void beforeSave(List<Object> data) {}
    protected void afterSave(List<Object> data) {}
    public final void importData(String filePath) {
        // ...
        beforeSave(data);
        saveData(data);
        afterSave(data);
        // ...
    }
}
public class CustomerImporter extends AbstractDataImporter {
    @Override
    protected void afterSave(List<Object> data) {
        // 发送欢迎邮件
    }
}

优势:提供扩展点,子类可选择性覆盖
典型应用:Spring的AbstractApplicationContext

③ Spring中的模板方法

// JdbcTemplate的execute方法
public <T> T execute(ConnectionCallback<T> action) {
    Connection con = getConnection();
    try {
        return action.doInConnection(con);
    } finally {
        closeConnection(con);
    }
}
// 使用示例
String name = jdbcTemplate.execute(new ConnectionCallback<String>() {
    @Override
    public String doInConnection(Connection con) throws SQLException {
        Statement stmt = con.createStatement();
        try {
            ResultSet rs = stmt.executeQuery("SELECT name FROM user LIMIT 1");
            return rs.next() ? rs.getString("name") : "unknown";
        } finally {
            rs.close();
            stmt.close();
        }
    }
});

设计思想:JdbcTemplate将连接获取、异常处理、资源关闭封装为模板,开发者只需实现核心SQL操作
延伸应用:RestTemplate、JmsTemplate等均采用此模式

💡 开发者建议:模板方法模式特别适合以下场景:
• 数据处理流程固定(读取→解析→转换→保存)
• 业务流程标准化(登录→权限校验→业务处理→日志记录)
• 框架级抽象设计(Spring、MyBatis大量使用)

· 开发者高频问题深度解答

网友们还关心的问题

Q1: 设计模式是否会导致代码复杂度增加?

A:合理使用设计模式可降低复杂度!关键在于:
• 仅在需求明确变化时引入模式
• 避免过度设计(如为简单类添加工厂)
• 优先选择简单模式(策略、装饰器)而非复杂模式(访问者、解释器)
经验法则:当同一段代码重复出现3次以上时,考虑抽取为模式

Q2: Spring中@component和@bean的区别?

A:这涉及工厂模式与单例模式的组合应用:
• @Component:由Spring自动扫描注册Bean,使用默认构造器
• @Bean:在@Configuration类中显式声明Bean,可自定义创建逻辑
• 本质:@Component是简单工厂,@Bean是工厂方法
• 两者都默认单例,但@Bean可指定@Scope("prototype")

Q3: 代理模式在微服务中的局限性?

A:单JVM内的代理在分布式场景下失效!解决方案:
• 使用远程代理(如Dubbo的ProxyFactory)
• 通过网关实现服务级代理
• 采用RPC框架的动态代理(如gRPC的Stub)
关键点:分布式系统中,代理模式需升级为服务代理模式

Q4: 如何选择观察者模式与命令模式?

A:核心区别在于:
• 观察者模式:事件发生时广播通知(推模式)
• 命令模式:将请求封装为对象(参数化请求)
选择准则:
• 多个对象需响应同一事件 → 观察者
• 需要撤销/重做/排队请求 → 命令

🔍 实战建议:设计模式不是银弹!
• 新手易犯错误:为用模式而用模式
• 高手做法:先实现功能,再重构为模式
• 黄金法则:保持代码可读性 > 模式完整性

· 资源推荐与学习路径

权威资料与实践工具

📚 必读经典

  • 《设计模式:可复用面向对象软件的基础》——GoF原著
  • 《Head First设计模式》——图文并茂的入门首选
  • 《Spring源码深度解析》——理解Spring中模式应用
  • 《Java并发编程实战》——单例模式线程安全进阶

💻 实用工具

  • PlantUML:绘制UML图,支持模式可视化
  • Refactoring Guru:在线模式图解与代码示例
  • Design Patterns in Java:GitHub开源项目

🎓 学习路径建议

  1. 掌握单例、工厂、代理(高频使用)
  2. 理解策略、模板、观察者(业务解耦关键)
  3. 研究Spring源码中的模式应用
  4. 实践:重构自己代码中的if-else地狱
💡 最后建议:学习java最常用设计模式不是为记住模式名称,而是培养:
• 问题抽象能力:识别代码中的模式应用场景
• 解耦设计思维:通过模式实现高内聚低耦合
• 框架源码洞察力:看懂Spring等框架的设计哲学