当前位置: 首页 > article >正文

设计模式,持续更新

创建型

简单工厂

public interface Product{}

public class ConcreteProduct implements Product {
}
public class ConcreteProduct1 implements Product {
}
public class ConcreteProduct2 implements Product {
}
public class SimpleFactory{
    public Product createProduct(int type) {
        int type = 1;
        if (type == 1) {
            return new ConcreteProduct();
        } else if (type == 2) {
            return new ConcreteProduct1();
        } else if (type == 3) {
            return new ConcreteProduct2();
        }
    }
}
使用的场景?
创建逻辑比较简单,不关心对象的创建逻辑,对象种类较少

本质是什么?
创建对象的封装,多态

它解决了什么问题?
解耦,调用方不需要知道有哪些子类以及应当实例化哪个子类,避免 new 直接依赖具体类。
把对象创建逻辑集中到工厂里,复用创建逻辑,减少重复代码。

它体现了设计模式中什么原则?
单一职责原则(SRP):工厂类只负责创建对象,客户端不需要关心具体创建过程
依赖倒置原则(DIP):调用方依赖抽象(接口),而不是依赖具体实现

存在的缺陷?
如果对象种类多,工厂类会有很多 if-else,变得难以维护。
新增产品时,需要修改工厂类

你认为与它相关的设计模式有哪些? 它们之间的区别有哪些?
工厂方法模式	每个产品都有自己的工厂	解决简单工厂扩展性差的问题,每个子类工厂独立
抽象工厂模式	生产多个相关产品族	适用于一组相关对象的创建
策略模式	通过不同策略处理逻辑	可结合工厂模式,避免 if-else


*开源架构中哪些使用了这一模式?
MyBatis:SqlSessionFactory 生产 SqlSession
Spring BeanFactory:底层用简单工厂管理 Bean

工厂方法

pubblic interface Product{
    void method();
}
public class P1 implements Product {
     @Override
    public void method() {
        System.out.println("p1");
    }
}
public class P2 implements Product {
     @Override
    public void method() {
        System.out.println("p2");
    }
}

public interface Factory {
    Product create();
}
public class P1Factory implements Factory {
    @Override
    public Product create() {
        return new P1Factory();
    }
}

public class P2Factory implements Factory {
    @Override
    public Product create() {
        return new P2Factory();
    }
}

public class FactoryMethodDemo {
    public static void main(String[] args) {
       
        Product factory = new P1Factory();
        Coffee coffee = factory.create();
        coffee.method();

        
        factory = new P2Factory();
        coffee = factory.createCoffee();
        coffee.method();
    }
}

使用的场景?
产品种类较多,并且可能扩展(如数据库驱动、日志系统)。
客户端不想直接依赖具体类,而是通过抽象接口操作对象。
对象创建逻辑复杂,需要封装在工厂中,避免影响客户端代码。
需要遵循“开闭原则”,允许扩展新产品而不修改现有工厂代码。

本质是什么?
本质: 将对象的创建延迟到子类,避免直接在客户端代码中使用 new 关键字。
简单来说,它是 简单工厂模式的升级版,让每种产品都有独立的工厂,避免了 if-else 代码膨胀的问题。

它解决了什么问题?
避免代码重复:每次创建新对象时,不需要重复写实例化代码,工厂类可以复用。
降低耦合:客户端代码依赖于抽象工厂接口,而不依赖具体实现,增强了灵活性。
符合开闭原则:新增产品时只需新增具体工厂类,而不需要修改现有工厂代码。

它体现了设计模式中什么原则?
开闭原则(OCP,Open-Closed Principle)
扩展新产品时,只需新增工厂,而不影响已有代码。
单一职责原则(SRP,Single Responsibility Principle)
工厂类的唯一职责是创建对象,而非控制对象的业务逻辑。
依赖倒置原则(DIP,Dependency Inversion Principle)
代码依赖于抽象(接口),而不是具体类,增强可扩展性。

存在的缺陷?
增加代码复杂度:每个产品都需要一个工厂类,导致代码量变多。
新增工厂类较多:如果产品种类过多,会导致工厂类数量膨胀,管理较为复杂。
类爆炸问题:当产品数量大时,可能会有大量工厂类,使代码结构复杂。

你认为与它相关的设计模式有哪些? 它们之间的区别有哪些?
简单工厂模式	一个工厂类创建所有对象	适用于产品种类较少、对象创建逻辑简单	不符合开闭原则,新增产品需要修改工厂
工厂方法模式	每种产品都有独立的工厂	适用于产品较多、未来可能扩展的情况	符合开闭原则,但类数量较多
抽象工厂模式	提供一组相关产品的工厂	适用于多个产品族的情况(如 Windows/Mac UI 组件)	创建的是一组相关产品,而非单一产品
建造者模式	复杂对象的逐步构建	对象创建步骤较多,属性较复杂	用于一步步构造复杂对象,而不是简单实例化

*开源架构中哪些使用了这一模式?
Spring Framework(Spring IOC 容器)

BeanFactory 使用工厂方法模式创建和管理 Bean。
ApplicationContext.getBean() 方法背后使用了工厂模式。
JDBC(Java Database Connectivity)

DriverManager.getConnection(url, user, password) 背后就是工厂模式。
JDBC 连接工厂负责创建数据库连接,而不是客户端直接实例化 Connection。
Log4j / SLF4J

LoggerFactory.getLogger(Class clazz) 通过工厂方法创建 Logger 实例,而不是 new Logger()。
Apache Commons DBCP(数据库连接池)

BasicDataSource 通过工厂模式管理数据库连接池,确保连接复用,提升性能。
JDK 并发库

Executors.newFixedThreadPool() 返回 ThreadPoolExecutor,封装线程池创建逻辑,避免直接 new Thread()。



http://www.kler.cn/a/588099.html

相关文章:

  • 数据结构------线性表
  • EDAS:投稿经验-word版本-问题解决
  • C语言_数据结构总结9:树的基础知识介绍
  • 51单片机的工作方式
  • 直方图梯度提升:大数据时代的极速决策引擎
  • Windows编译Flash-attention模块
  • 于 Hexo + GitHub Pages 的搭建个人博客网站的详细教程
  • 失败的面试经历(ʘ̥∧ʘ̥)
  • 如何利用物理按键控制LVGL控件的大小与状态
  • 六十天前端强化训练之第二十天React Router 基础详解
  • python-数据类型字符串和列表
  • java学习总结(四)MyBatis多表
  • linux命令-wget与curl命令详解
  • 【Agent】OpenManus-Agent-BaseAgent详细分析
  • 85.HarmonyOS NEXT 网络请求与数据处理:构建可靠的数据层
  • 剖析sentinel的限流和熔断
  • “driver-class-name: com.mysql.cj.jdbc.Driver“报错问题的解决
  • Gitee重新远程连接仓库(Linux)
  • 【Redis】缓存穿透、缓存击穿、缓存雪崩
  • Leetcode2272:最大波动的子字符串