设计模式-工厂模式

什么是工厂模式？

工厂模式（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.   }
  19.   @Override
  20.   public List<T> read() {
  21.     return null;
  22.   }
  23. }
  25. class ExcelItemReader<T> implements FileItemReader<T> {
  26.   @Override
  27.   public List<T> read() {
  28.     return null;
  29.   }
  30. }
  32. class JsonFileItemReader<T> implements FileItemReader<T> {
  33.   @Override
  34.   public List<T> read() {
  35.     return null;
  36.   }
  37. }
  39. interface JdbcItemReader<T> extends ItemReader<T> {
  41. }
  43. class JdbcCursorItemReader<T> implements JdbcItemReader<T> {
  44.   @Override
  45.   public List<T> read() {
  46.     return null;
  47.   }
  48. }
  50. class HibernateItemReader<T> implements JdbcItemReader<T> {
  51.   @Override
  52.   public List<T> read() {
  53.     return null;
  54.   }
  55. }
  57. interface Creator<T> {
  58.   ItemReader<T> create(String type);
  59. }
  61. class FileItemReaderFactory<T> implements Creator<T> {
  62.   private final BufferReaderFactory bufferReaderFactory;
  63.   private final BeanMappingFactory beanMappingFactory;
  65.   public FileItemReaderFactory(BufferReaderFactory bufferReaderFactory, BeanMappingFactory beanMappingFactory) {
  66.     this.bufferReaderFactory = bufferReaderFactory;
  67.     this.beanMappingFactory = beanMappingFactory;
  68.   }
  70.   @Override
  71.   public ItemReader<T> create(String fileName) {
  72.     if (fileName.endsWith("csv") || fileName.endsWith("txt")) {
  73.       return new FlatFileItemReader<>(bufferReaderFactory, beanMappingFactory);
  74.     } else if (fileName.endsWith("xlsx") || fileName.endsWith("xls")) {
  75.       return new ExcelItemReader<>();
  76.     } else if (fileName.endsWith("json")) {
  77.       return new JsonFileItemReader<>();
  78.     } else {
  79.       throw new IllegalArgumentException("不支持的数据库读取类型");
  80.     }
  81.   }
  82. }
  84. class JdbcItemReaderFactory<T> implements Creator<T> {
  85.   @Override
  86.   public ItemReader<T> create(String type) {
  87.     if(type.equals("jdbc")){
  88.       return new JdbcCursorItemReader<>();
  89.     }else if (type.equals("hibernate")){
  90.       return new HibernateItemReader<>();
  91.     }else {
  92.       throw new IllegalArgumentException("不支持的数据库读取类型");
  93.     }
  94.   }
  95. }
  97. interface BufferReaderFactory {
  98.   BufferedReader create(Resource resource, String encoding);
  99. }
  101. interface BeanMappingFactory {
  102.   BeanPropertyMap create(Class<?> clazz, String lineData);
  103. }
  104.    
  105. public static void main(String[] args) {
  106.         String fileName = "test.xlsx";
  107.         Creator<ReadTestEntity> creator = new FileItemReaderFactory<>();
  108.         List<ReadTestEntity> read = creator.create(fileName).read();
  109. }

  复制代码

总结

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