登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

豆瓜网 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›设计模式-工厂模式

设计模式-工厂模式

连热 2025-6-26 13:05:54
什么是工厂模式？

工厂模式（Factory Pattern）是一种创建型设计模式，它将对象的创建和使用分离，通过工厂类来负责创建对象。这种模式可以降低代码间的耦合度，提高可维护性和可扩展性。
一、核心思想

  • 将对象创建逻辑封装在工厂类中，客户端无需直接实例化对象，而是通过工厂获取。
  • 遵循依赖倒置原则：依赖抽象而非具体实现。
二、工厂模式的三种形态
1. 简单工厂（Simple Factory）

  • 特点：静态工厂方法，创建逻辑集中在一个工厂类。
  • 缺点：不符合开闭原则，新增产品需修改工厂类。
2. 工厂方法（Factory Method）

  • 特点：定义抽象工厂接口，具体产品由子类工厂创建。
  • 优点：符合开闭原则，新增产品只需添加新的工厂子类。
3. 抽象工厂（Abstract Factory）

  • 特点：创建产品家族，每个具体工厂负责创建一系列相关产品。
  • 适用场景：系统需要独立于产品的创建、组合和表示时。
工厂模式的优缺点


  • 优点

  • 解耦对象创建和使用：客户端只需关注接口，无需关心具体实现。
  • 符合开闭原则：工厂方法模式中，新增产品只需扩展工厂子类。
  • 便于维护和扩展：创建逻辑集中，修改时只需调整工厂类。
  • 利于代码复用：工厂类可被多个客户端复用。


  • 缺点

  • 类数量增加：每个产品都可能需要对应的工厂类，导致代码结构复杂。
  • 抽象层级提高：需要理解抽象工厂和具体工厂的关系，增加学习成本。
  • 过度设计风险：简单场景下使用工厂模式可能增加不必要的复杂度。
什么场景下使用工厂模式


  • 对复杂对象的创建：某些类在new创建完之后，并不能拥有完成的功能，需要一些参数，活在构造方法中有复杂的参数传递时，这个时候就需要用到工厂模式
  • 根据条件动态创建对象：在支付的场景下，可能有微信、支付宝、银联等多种支付方式，可以根据选择创建不同的对象
  • 统一管理对象创建逻辑：以spring为例，在bean的实例化过程中，需要统一管理bean的生命周期，涉及一整套的接口判断，逻辑校验等，这个时候也可以是工厂模式
代码举例

下边以简单工厂模式、工厂方法、抽象工厂、实例开发中怎么用举例。（这里仅仅是一个设计思路，实际开发中还需要根据功能和业务修改）

  • 简单工厂：
    举例一个实际开发中用的场景，用户上传文件，但是文件涉及多种，比如flat文件、Excel、json、xml文件，上传的文件读取内容，下边就用工厂模式来设计
    1. interface FileItemReader<T>{
    2.     List<T> read();
    3. }
    4.    
    5. class FlatFileItemReader<T> implements FileItemReader<T>{
    6.   @Override
    7.   public List<T> read() {
    8.     return null;
    9.   }
    10. }
    12. class ExcelItemReader<T> implements FileItemReader<T>{
    13.   @Override
    14.   public List<T> read() {
    15.     return null;
    16.   }
    17. }
    19. class JsonFileItemReader<T> implements FileItemReader<T>{
    20.   @Override
    21.   public List<T> read() {
    22.     return null;
    23.   }
    24. }
    26. class FileItemReaderFactory<T>{
    27.   public FileItemReader<T> createFileItemReader(String fileName){
    28.     if(fileName.endsWith("csv") || fileName.endsWith("txt")){
    29.       return new FlatFileItemReader<>();
    30.     }else if(fileName.endsWith("xlsx") || fileName.endsWith("xls")){
    31.       return new ExcelItemReader<>();
    32.     }else if(fileName.endsWith("json")){
    33.       return new JsonFileItemReader<>();
    34.     }else {
    35.       throw new IllegalArgumentException("不支持的文件类型");
    36.     }
    37.   }
    38. }
    40. public class FactoryDemo {
    42.     public static void main(String[] args) {
    43.         String fileName = "test.xlsx";
    44.         FileItemReaderFactory<ReadTestEntity> factory = new FileItemReaderFactory<>();
    45.         FileItemReader<ReadTestEntity> fileItemReader = factory.createFileItemReader(fileName);
    46.         List<ReadTestEntity> read = fileItemReader.read();
    47.     }
    48. }
    复制代码
  • 工厂方法:
    以读数据为例子，读数据可能从数据库里读、文件里读、还有一些非关系型数据库中读，就用工厂方法设计下边程序，就用上边的例子继续拓展了
    1. interface ItemReader<T> {
    2. List<T> read();
    3. }
    5. interface FileItemReader<T> extends ItemReader<T> {
    7. }
    9. class FlatFileItemReader<T> implements FileItemReader<T> {
    10.   @Override
    11.   public List<T> read() {
    12.     return null;
    13.   }
    14. }
    16. class ExcelItemReader<T> implements FileItemReader<T> {
    17.   @Override
    18.   public List<T> read() {
    19.     return null;
    20.   }
    21. }
    23. class JsonFileItemReader<T> implements FileItemReader<T> {
    24.   @Override
    25.   public List<T> read() {
    26.     return null;
    27.   }
    28. }
    30. interface JdbcItemReader<T> extends ItemReader<T> {
    32. }
    34. class JdbcCursorItemReader<T> implements JdbcItemReader<T> {
    35.   @Override
    36.   public List<T> read() {
    37.     return null;
    38.   }
    39. }
    41. class HibernateItemReader<T> implements JdbcItemReader<T> {
    42.   @Override
    43.   public List<T> read() {
    44.     return null;
    45.   }
    46. }
    48. interface Creator<T> {
    49.   ItemReader<T> create(String type);
    50. }
    52. class FileItemReaderFactory<T> implements Creator<T> {
    53.   @Override
    54.   public ItemReader<T> create(String fileName) {
    55.     if (fileName.endsWith("csv") || fileName.endsWith("txt")) {
    56.       return new FlatFileItemReader<>();
    57.     } else if (fileName.endsWith("xlsx") || fileName.endsWith("xls")) {
    58.       return new ExcelItemReader<>();
    59.     } else if (fileName.endsWith("json")) {
    60.       return new JsonFileItemReader<>();
    61.     } else {
    62.       throw new IllegalArgumentException("不支持的文件类型");
    63.     }
    64.   }
    65. }
    67. class JdbcItemReaderFactory<T> implements Creator<T> {
    68.   @Override
    69.   public ItemReader<T> create(String type) {
    70.     if(type.equals("jdbc")){
    71.       return new JdbcCursorItemReader<>();
    72.     }else if (type.equals("hibernate")){
    73.       return new HibernateItemReader<>();
    74.     }else {
    75.       throw new IllegalArgumentException("不支持的文件类型");
    76.     }
    77.   }
    78. }
    80. public static void main(String[] args) {
    81.         String fileName = "test.xlsx";
    82.         Creator<ReadTestEntity> creator = new FileItemReaderFactory<>();
    83.         List<ReadTestEntity> read = creator.create(fileName).read();
    84. }
    复制代码
  • 抽象工厂
    继续上边的设计，以读取flat类型文件为例，读取文件时候需要获取不同的流，也需要不同的数据映射关系，这里用抽象工厂就很合适
    1. interface ItemReader<T> {
    2.   List<T> read();
    3. }
    5. interface FileItemReader<T> extends ItemReader<T> {
    7. }
    9. class FlatFileItemReader<T> implements FileItemReader<T> {
    11.   private final BufferReaderFactory bufferReaderFactory;
    12.   private final BeanMappingFactory beanMappingFactory;
    14.   public FlatFileItemReader(BufferReaderFactory bufferReaderFactory, BeanMappingFactory beanMappingFactory) {
    15.     this.bufferReaderFactory = bufferReaderFactory;
    16.     this.beanMappingFactory = beanMappingFactory;
    17.   }
    20.   @Override
    21.   public List<T> read() {
    22.     return null;
    23.   }
    24. }
    26. class ExcelItemReader<T> implements FileItemReader<T> {
    27.   @Override
    28.   public List<T> read() {
    29.     return null;
    30.   }
    31. }
    33. class JsonFileItemReader<T> implements FileItemReader<T> {
    34.   @Override
    35.   public List<T> read() {
    36.     return null;
    37.   }
    38. }
    40. interface JdbcItemReader<T> extends ItemReader<T> {
    42. }
    44. class JdbcCursorItemReader<T> implements JdbcItemReader<T> {
    45.   @Override
    46.   public List<T> read() {
    47.     return null;
    48.   }
    49. }
    51. class HibernateItemReader<T> implements JdbcItemReader<T> {
    52.   @Override
    53.   public List<T> read() {
    54.     return null;
    55.   }
    56. }
    58. interface Creator<T> {
    59.   ItemReader<T> create(String type);
    60. }
    62. class FileItemReaderFactory<T> implements Creator<T> {
    63.   private final BufferReaderFactory bufferReaderFactory;
    64.   private final BeanMappingFactory beanMappingFactory;
    66.   public FileItemReaderFactory(BufferReaderFactory bufferReaderFactory, BeanMappingFactory beanMappingFactory) {
    67.     this.bufferReaderFactory = bufferReaderFactory;
    68.     this.beanMappingFactory = beanMappingFactory;
    69.   }
    71.   @Override
    72.   public ItemReader<T> create(String fileName) {
    73.     if (fileName.endsWith("csv") || fileName.endsWith("txt")) {
    74.       return new FlatFileItemReader<>(bufferReaderFactory, beanMappingFactory);
    75.     } else if (fileName.endsWith("xlsx") || fileName.endsWith("xls")) {
    76.       return new ExcelItemReader<>();
    77.     } else if (fileName.endsWith("json")) {
    78.       return new JsonFileItemReader<>();
    79.     } else {
    80.       throw new IllegalArgumentException("不支持的数据库读取类型");
    81.     }
    82.   }
    83. }
    85. class JdbcItemReaderFactory<T> implements Creator<T> {
    86.   @Override
    87.   public ItemReader<T> create(String type) {
    88.     if(type.equals("jdbc")){
    89.       return new JdbcCursorItemReader<>();
    90.     }else if (type.equals("hibernate")){
    91.       return new HibernateItemReader<>();
    92.     }else {
    93.       throw new IllegalArgumentException("不支持的数据库读取类型");
    94.     }
    95.   }
    96. }
    98. interface BufferReaderFactory {
    99.   BufferedReader create(Resource resource, String encoding);
    100. }
    102. interface BeanMappingFactory {
    103.   BeanPropertyMap create(Class<?> clazz, String lineData);
    104. }
    105.    
    106. public static void main(String[] args) {
    107.         String fileName = "test.xlsx";
    108.         Creator<ReadTestEntity> creator = new FileItemReaderFactory<>();
    109.         List<ReadTestEntity> read = creator.create(fileName).read();
    110. }
    复制代码
总结

通过上边的举例，工厂模式其实就是将较为复杂的类创建，统一的bean的生命周期，不同类型的类统一封装起来，为了代码的解偶。

来源：豆瓜网用户自行投稿发布，如果侵权，请联系站长删除
设计模式工厂模式

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
连热
2025-6-26 13:05:54

0

粉丝关注

15

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫