设计模式 - 工厂模式（通用工厂）

素颜马尾好姑娘i 2023-10-07 15:31 97阅读 0赞 
  1. 参考链接: [link](https://www.runoob.com/design-pattern/factory-pattern.html).

什么是工厂模式

  1. 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，
  2. 它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且
  3. 是通过使用一个共同的接口来指向新创建的对象。
  5. 意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
  6. 主要解决：**主要解决接口选择的问题**。
  7. 何时使用：我们明确地计划不同条件下创建不同实例时。
  8. 如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
  9. 关键代码：创建过程在其子类执行。
  10. 优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展
  11. 一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
  12. 缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上
  13. 增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

什么是抽象工厂模式

  1. 抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。
  2. 该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
  3. 在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。
  4. 每个生成的工厂都能按照工厂模式提供对象。
  6. 意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
  7. 主要解决：**主要解决接口选择的问题**。
  8. 何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
  9. 如何解决：在一个产品族里面，定义多个产品。
  10. 关键代码：在一个工厂里聚合多个同类产品。
  11. 优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
  12. 缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

工厂模式解决的是接口选择的问题

实际场景

  1. 顾客在收银端买单时可以选择多种支付方式付款，目前收款包含现金支付，扫码支付，会员余额支付。该接口后期将还会拓展其他支付方式。

如何使用工厂模式解决这一选择支付的问题呢？

1.创建支付常量,不要在代码里出现魔法值
  1. /**
  2.  * 支付常量
  3.  */
  4. public class PayConstant {
  7.     /**
  8.      * 支付类型
  9.      */
  10.     public enum PayTypeEnum {
  13.         /**
  14.          *现金支付（1）
  15.          */
  16.         CASH(1, "现金支付"),
  18.         /**
  19.          * 扫码支付（2）
  20.          */
  21.         SCAN(2, "扫码支付"),
  23.         /**
  24.          * 会员余额支付（3）
  25.          */
  26.         VIP(3, "会员余额支付"),
  28.         ;
  30.         PayTypeEnum(Integer value, String name) {
  32.             this.value = value;
  33.             this.name = name;
  34.         }
  36.         /**
  37.          * 通过编号获取支付方式名称值
  38.          */
  39.         public static String getPayTypeName(Integer payType) {
  41.             PayTypeEnum[] payTypes = values();
  42.             for (PayTypeEnum payTypeEnum : payTypes) {
  44.                 if (payTypeEnum.getValue().equals(payType)) {
  46.                     return payTypeEnum.getName();
  47.                 }
  48.             }
  49.             return null;
  50.         }
  52.         private final Integer value;
  54.         private final String name;
  56.         public Integer getValue() {
  58.             return value;
  59.         }
  61.         public String getName() {
  63.             return name;
  64.         }
  65.     }
  66. }
2.新建支付接口PayService
  1. /**
  2.  * 支付接口
  3.  */
  4. public interface PayService {
  6.     void pay();
  7. }
3.创建具体的实现类实现支付接口PayService

/**

  1. * 具体实现类：现金支付
  2.  */
  3. public class CashPay implements PayService{
  6.     @Override
  7.     public void pay() {
  9.         System.out.println("CashPay实现类:现金支付");
  10.     }
  11. }
  13. /**
  14.  * 具体实现类：扫码支付
  15.  */
  16. public class ScanPay implements PayService{
  19.     @Override
  20.     public void pay() {
  22.         System.out.println("ScanPay实现类:扫码支付");
  23.     }
  24. }
  26. /**
  27.  * 具体实现类：会员余额支付
  28.  */
  29. public class VipPay implements PayService{
  32.     @Override
  33.     public void pay() {
  35.         System.out.println("VipPay实现类:会员余额支付");
  36.     }
  37. }
4.静态工厂：用来生产具体的实现类,也就是说通过静态类方法中if或swich 条件判断去生产创建的实现类

优点

  1. 实现简单，只需一个静态类方法即可，所以也称之为静态工厂。
  2. 将对象的创建和对象本身业务处理分离可以降低系统的耦合度，使得两者修改起来都相对容易。

缺点

  1. 扩展性差，⼯⼚类的职责相对过重，增加新的产品需要修改⼯⼚类
    的判断逻辑，违背即开闭原则。

  2. 增加了系统的复杂度和理解难度，不利于系统的扩展和维护

    public class PayFactory {

    1. public static PayService getPayFactory(Integer payType){
    3.     if(PayConstant.PayTypeEnum.CASH.getValue().equals(payType)){
    5.         return new CashPay();
    6.     }
    7.     if(PayConstant.PayTypeEnum.SCAN.getValue().equals(payType)){
    9.         return new ScanPay();
    10.     }
    11.     if(PayConstant.PayTypeEnum.VIP.getValue().equals(payType)){
    13.         return new VipPay();
    14.     }
    15.     System.out.println("不存在该支付方式");
    16.     throw new BusinessRuntimeException(ErrorResultCode.SYSTEM_ERROR);
    17. }

    }

    public class Main {

  1.     public static void main(String[] args) {
  4.         System.out.println("现金支付=====================");
  5.         PayService cashPay = PayFactory.getPayFactory(PayConstant.PayTypeEnum.CASH.getValue());
  6.         cashPay.pay();
  7.         System.out.println("扫码支付=====================");
  8.         PayService scanPay = PayFactory.getPayFactory(PayConstant.PayTypeEnum.SCAN.getValue());
  9.         scanPay.pay();
  10.         System.out.println("会员余额支付===================");
  11.         PayService vipScanPay = PayFactory.getPayFactory(PayConstant.PayTypeEnum.VIP.getValue());
  12.         vipScanPay.pay();
  14.     }
  16. }
5.spring中结合策略模式来使用简单工厂方法模式

spring中类的创建都不需要我们自己创建了，只要选择的使用它们即可，代码改造一下

  1. /**
  2.  * 支付接口
  3.  */
  4. public interface PayService {
  6.     String pay();
  7. }
  9. /**
  10.  * 具体实现类：现金支付
  11.  */
  12. @Service("CashPay")
  13. public class CashPay implements PayService {
  16.     @Override
  17.     public String pay() {
  19.         return "CashPay实现类:现金支付";
  20.     }
  21. }
  23. /**
  24.  * 具体实现类：扫码支付
  25.  */
  26. @Service("ScanPay")
  27. public class ScanPay implements PayService {
  30.     @Override
  31.     public String pay() {
  33.         return "ScanPay实现类:扫码支付";
  34.     }
  35. }
  37. /**
  38.  * 具体实现类：会员余额支付
  39.  */
  40. @Service("VipPay")
  41. public class VipPay implements PayService {
  43.     @Override
  44.     public String pay() {
  46.         return "VipPay实现类:会员余额支付";
  47.     }
  48. }
  50. /**
  51.  * 支付常量
  52.  */
  53. public class PayConstant {
  56.     /**
  57.      * 支付类型
  58.      */
  59.     public enum PayTypeEnum {
  62.         /**
  63.          *现金支付（1）
  64.          */
  65.         CASH(1, "CashPay"),
  67.         /**
  68.          * 扫码支付（2）
  69.          */
  70.         SCAN(2, "ScanPay"),
  72.         /**
  73.          * 会员余额支付（3）
  74.          */
  75.         VIP(3, "VipPay"),
  77.         ;
  79.         PayTypeEnum(Integer value, String name) {
  81.             this.value = value;
  82.             this.name = name;
  83.         }
  85.         /**
  86.          * 通过编号获取支付方式名称值
  87.          */
  88.         public static String getPayTypeName(Integer payType) {
  90.             PayTypeEnum[] payTypes = values();
  91.             for (PayTypeEnum payTypeEnum : payTypes) {
  93.                 if (payTypeEnum.getValue().equals(payType)) {
  95.                     return payTypeEnum.getName();
  96.                 }
  97.             }
  98.             return null;
  99.         }
  101.         private final Integer value;
  103.         private final String name;
  105.         public Integer getValue() {
  107.             return value;
  108.         }
  110.         public String getName() {
  112.             return name;
  113.         }
  114.     }
  117. }
  119. /**
  120.  * 注意：
  121.  * 从ApplicationContextAware获取ApplicationContext上下文的情况，
  122.  * 仅仅适用于当前运行的代码和已启动的Spring代码处于同一个Spring上下文，
  123.  * 否则获取到的ApplicationContext是空的。
  124.  * 定时任务是没办法获取到项目所在Spring容器启动之后的ApplicationContext
  125.  */
  126. @Component
  127. public class PayServiceFactory implements ApplicationContextAware {
  130.     private static Map<String, PayService> serviceMap;
  132.     @Override
  133.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  135.         serviceMap = applicationContext.getBeansOfType(PayService.class);
  136.     }
  138.     /**
  139.      * 获取对应serviceImpl实现类
  140.      */
  141.     public PayService getService(Integer payType) {
  143.         PayService payService = serviceMap.get(PayConstant.PayTypeEnum.getPayTypeName(payType));
  144.         if(payService == null){
  146.             System.out.println("不存在该支付方式");
  147.             throw new BusinessRuntimeException(ErrorResultCode.SYSTEM_ERROR);
  148.         }
  149.         return payService;
  150.     }
  151. }
  153. import com.zm.service.PayService;
  154. import com.zm.service.factory.PayServiceFactory;
  155. import io.swagger.annotations.ApiOperation;
  156. import org.hibernate.validator.constraints.Range;
  157. import org.springframework.beans.factory.annotation.Autowired;
  158. import org.springframework.validation.annotation.Validated;
  159. import org.springframework.web.bind.annotation.*;
  161. @RestController
  162. @Validated
  163. public class FactoryController {
  166.     @Autowired
  167.     private PayServiceFactory payServiceFactory;
  169.     @GetMapping("/factory")
  170.     @ApiOperation(value = "简单工厂演示" ,httpMethod = "GET")
  171.     public String hello(@Range(min = 1,max = 3) @RequestParam("payType") Integer payType) {
  173.         PayService service = payServiceFactory.getService(payType);
  174.         return service.pay();
  175.     }
  177. }

测试一下
在这里插入图片描述
在这里插入图片描述

通用模板

如果每个工厂都需要去创建这么类，肯定也是不行，那么封装一个通用的工厂模式

  1. package com.chinadci.fj.app.base.factory;
  3. /**
  4.  * @author zhou
  5.  */
  6. public interface Strategy<T> {
  9.     /**
  10.      * 获得策略的标识
  11.      */
  12.     T getId();
  14. }

通用的策略工厂类

  1. import org.springframework.beans.BeansException;
  2. import org.springframework.beans.factory.InitializingBean;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.ApplicationContextAware;
  6. import java.util.Collection;
  7. import java.util.HashMap;
  8. import java.util.Map;
  10. /**
  11.  * 通用的策略工厂类
  12.  * @param <T>
  13.  * @param <S>
  14.  */
  15. public class StrategyFactory<T, S extends Strategy<T>> implements InitializingBean, ApplicationContextAware {
  19.     private final Class<S> strategyType;
  22.     private Map<T, S> strategyMap;
  25.     private ApplicationContext appContext;
  28.     /**
  29.      * 创建一个策略工厂
  30.      *
  31.      * @param strategyType 策略的类型
  32.      */
  33.     public StrategyFactory(Class<S> strategyType) {
  35.         this.strategyType = strategyType;
  36.     }
  39.     /**
  40.      * 根据策略 id 获得对应的策略的 Bean
  41.      *
  42.      * @param id 策略 id
  43.      * @return 策略的 Bean
  44.      */
  45.     public S getStrategy(T id) {
  47.         return strategyMap.get(id);
  48.     }
  51.     @Override
  52.     public void afterPropertiesSet() {
  54.         // 获取 Spring 容器中，所有 S 类型的 Bean
  55.         Collection<S> strategies = appContext.getBeansOfType(strategyType).values();
  56.         strategyMap = new HashMap<>(strategies.size());
  57.         // 将 所有 S 类型的 Bean 放入到 strategyMap 中
  58.         for (final S strategy : strategies) {
  60.             T id = strategy.getId();
  61.             strategyMap.put(id, strategy);
  62.         }
  63.     }
  65.     @Override
  66.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  68.         appContext = applicationContext;
  69.     }
  71. }

接口去继承Strategy类

  1. /**
  2.  * 支付接口
  3.  * @author zhou
  4.  */
  5. public interface PayService extends Strategy<String>{
  8.     String pay();
  10. }
  12. import org.springframework.stereotype.Service;
  14. /**
  15.  * 具体实现类：现金支付
  16.  */
  17. @Service("CashPay")
  18. public class CashPay implements PayService {
  21.     @Override
  22.     public String pay() {
  24.         return "CashPay实现类:现金支付";
  25.     }
  27.     @Override
  28.     public String getId() {
  30.         return "1";
  31.     }
  32. }
  34. import org.springframework.stereotype.Service;
  36. /**
  37.  * 具体实现类：扫码支付
  38.  */
  39. @Service("ScanPay")
  40. public class ScanPay implements PayService {
  43.     @Override
  44.     public String pay() {
  46.         return "ScanPay实现类:扫码支付";
  47.     }
  49.     @Override
  50.     public String getId() {
  52.         return "2";
  53.     }
  54. }
  56. import org.springframework.stereotype.Service;
  58. /**
  59.  * 具体实现类：会员余额支付
  60.  */
  61. @Service("VipPay")
  62. public class VipPay implements PayService {
  64.     @Override
  65.     public String pay() {
  67.         return "VipPay实现类:会员余额支付";
  68.     }
  70.     @Override
  71.     public String getId() {
  73.         return "3";
  74.     }
  75. }

注册bean

  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  4. /**
  5.  * 注册bean工厂
  6.  * @author zhou
  7.  */
  8. @Configuration
  9. public class FactoryConfig {
  12.     @Bean(name = "payServiceFactory")
  13.     public StrategyFactory<String, PayService> payServiceFactory() {
  15.         return new StrategyFactory<>(PayService.class);
  16.     }
  19. }
  21. import com.zm.factory.PayService;
  22. import com.zm.factory.StrategyFactory;
  23. import org.springframework.beans.factory.annotation.Autowired;
  24. import org.springframework.validation.annotation.Validated;
  25. import org.springframework.web.bind.annotation.*;
  27. @RestController
  28. @Validated
  29. public class FactoryController {
  32.     @Autowired
  33.     private StrategyFactory<String, PayService> payServiceFactory;
  34.     // http://localhost:8080/factory?payType=1
  35.     @GetMapping("/factory")
  36.     public String hello(@RequestParam("payType") String payType) {
  38.         PayService service = payServiceFactory.getStrategy(payType);
  39.         return service.pay();
  40.     }
  42. }

发表评论

表情：
评论列表 （有 0 条评论，97人围观）

还没有评论，来说两句吧...

相关阅读