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

素颜马尾好姑娘i 2023-10-07 15:31 24阅读 0赞

参考链接: [link](https://www.runoob.com/design-pattern/factory-pattern.html).

## 什么是工厂模式 ##

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

## 什么是抽象工厂模式 ##

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

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

#### 实际场景 ####

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

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

##### 1.创建支付常量,不要在代码里出现魔法值 #####

/**
     * 支付常量
     */
    public class PayConstant {
        
    
        /**
         * 支付类型
         */
        public enum PayTypeEnum {
        
    
            /**
             *现金支付（1）
             */
            CASH(1, "现金支付"),
    
            /**
             * 扫码支付（2）
             */
            SCAN(2, "扫码支付"),
    
            /**
             * 会员余额支付（3）
             */
            VIP(3, "会员余额支付"),
            
            ;
    
            PayTypeEnum(Integer value, String name) {
        
                this.value = value;
                this.name = name;
            }
    
            /**
             * 通过编号获取支付方式名称值
             */
            public static String getPayTypeName(Integer payType) {
        
                PayTypeEnum[] payTypes = values();
                for (PayTypeEnum payTypeEnum : payTypes) {
        
                    if (payTypeEnum.getValue().equals(payType)) {
        
                        return payTypeEnum.getName();
                    }
                }
                return null;
            }
    
            private final Integer value;
    
            private final String name;
    
            public Integer getValue() {
        
                return value;
            }
    
            public String getName() {
        
                return name;
            }
        }
    }

##### 2.新建支付接口PayService #####

/**
     * 支付接口
     */
    public interface PayService {
        
        void pay();
    }

##### 3.创建具体的实现类实现支付接口PayService #####

/\*\*

* 具体实现类：现金支付
     */
    public class CashPay implements PayService{
        
    
        @Override
        public void pay() {
        
            System.out.println("CashPay实现类:现金支付");
        }
    }

/**
     * 具体实现类：扫码支付
     */
    public class ScanPay implements PayService{
        
    
        @Override
        public void pay() {
        
            System.out.println("ScanPay实现类:扫码支付");
        }
    }

/**
     * 具体实现类：会员余额支付
     */
    public class VipPay implements PayService{
        
    
        @Override
        public void pay() {
        
            System.out.println("VipPay实现类:会员余额支付");
        }
    }

##### 4.静态工厂：用来生产具体的实现类,也就是说通过静态类方法中if或swich 条件判断去生产创建的实现类 #####

优点

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

缺点

1.  扩展性差，⼯⼚类的职责相对过重，增加新的产品需要修改⼯⼚类  
    的判断逻辑，违背即开闭原则。
2.  增加了系统的复杂度和理解难度，不利于系统的扩展和维护

public class PayFactory {
        
        public static PayService getPayFactory(Integer payType){
        
            if(PayConstant.PayTypeEnum.CASH.getValue().equals(payType)){
        
                return new CashPay();
            }
            if(PayConstant.PayTypeEnum.SCAN.getValue().equals(payType)){
        
                return new ScanPay();
            }
            if(PayConstant.PayTypeEnum.VIP.getValue().equals(payType)){
        
                return new VipPay();
            }
            System.out.println("不存在该支付方式");
            throw new BusinessRuntimeException(ErrorResultCode.SYSTEM_ERROR);
        }
    }

public class Main {
        
    
        public static void main(String[] args) {
        
    
            System.out.println("现金支付=====================");
            PayService cashPay = PayFactory.getPayFactory(PayConstant.PayTypeEnum.CASH.getValue());
            cashPay.pay();
            System.out.println("扫码支付=====================");
            PayService scanPay = PayFactory.getPayFactory(PayConstant.PayTypeEnum.SCAN.getValue());
            scanPay.pay();
            System.out.println("会员余额支付===================");
            PayService vipScanPay = PayFactory.getPayFactory(PayConstant.PayTypeEnum.VIP.getValue());
            vipScanPay.pay();
    
        }
    
    }

##### 5.spring中结合策略模式来使用简单工厂方法模式 #####

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

/**
     * 支付接口
     */
    public interface PayService {
        
        String pay();
    }

/**
     * 具体实现类：现金支付
     */
    @Service("CashPay")
    public class CashPay implements PayService {
        
    
        @Override
        public String pay() {
        
            return "CashPay实现类:现金支付";
        }
    }

/**
     * 具体实现类：扫码支付
     */
    @Service("ScanPay")
    public class ScanPay implements PayService {
        
    
        @Override
        public String pay() {
        
            return "ScanPay实现类:扫码支付";
        }
    }

/**
     * 具体实现类：会员余额支付
     */
    @Service("VipPay")
    public class VipPay implements PayService {
        
        @Override
        public String pay() {
        
            return "VipPay实现类:会员余额支付";
        }
    }

/**
     * 支付常量
     */
    public class PayConstant {
        
    
        /**
         * 支付类型
         */
        public enum PayTypeEnum {
        
    
            /**
             *现金支付（1）
             */
            CASH(1, "CashPay"),
    
            /**
             * 扫码支付（2）
             */
            SCAN(2, "ScanPay"),
    
            /**
             * 会员余额支付（3）
             */
            VIP(3, "VipPay"),
    
            ;
    
            PayTypeEnum(Integer value, String name) {
        
                this.value = value;
                this.name = name;
            }
    
            /**
             * 通过编号获取支付方式名称值
             */
            public static String getPayTypeName(Integer payType) {
        
                PayTypeEnum[] payTypes = values();
                for (PayTypeEnum payTypeEnum : payTypes) {
        
                    if (payTypeEnum.getValue().equals(payType)) {
        
                        return payTypeEnum.getName();
                    }
                }
                return null;
            }
    
            private final Integer value;
    
            private final String name;
    
            public Integer getValue() {
        
                return value;
            }
    
            public String getName() {
        
                return name;
            }
        }
    
    
    }

/**
     * 注意：
     * 从ApplicationContextAware获取ApplicationContext上下文的情况，
     * 仅仅适用于当前运行的代码和已启动的Spring代码处于同一个Spring上下文，
     * 否则获取到的ApplicationContext是空的。
     * 定时任务是没办法获取到项目所在Spring容器启动之后的ApplicationContext
     */
    @Component
    public class PayServiceFactory implements ApplicationContextAware {
        
        
        private static Map<String, PayService> serviceMap;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        
            serviceMap = applicationContext.getBeansOfType(PayService.class);
        }
        
        /**
         * 获取对应serviceImpl实现类
         */
        public PayService getService(Integer payType) {
        
            PayService payService = serviceMap.get(PayConstant.PayTypeEnum.getPayTypeName(payType));
            if(payService == null){
        
                System.out.println("不存在该支付方式");
                throw new BusinessRuntimeException(ErrorResultCode.SYSTEM_ERROR);
            }
            return payService;
        }
    }

import com.zm.service.PayService;
    import com.zm.service.factory.PayServiceFactory;
    import io.swagger.annotations.ApiOperation;
    import org.hibernate.validator.constraints.Range;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.*;
    
    @RestController
    @Validated
    public class FactoryController {
        
    
        @Autowired
        private PayServiceFactory payServiceFactory;
    
        @GetMapping("/factory")
        @ApiOperation(value = "简单工厂演示" ,httpMethod = "GET")
        public String hello(@Range(min = 1,max = 3) @RequestParam("payType") Integer payType) {
        
            PayService service = payServiceFactory.getService(payType);
            return service.pay();
        }
    
    }

测试一下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 1]

### 通用模板 ###

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

package com.chinadci.fj.app.base.factory;
    
    /**
     * @author zhou
     */
    public interface Strategy<T> {
        
    
        /**
         * 获得策略的标识
         */
        T getId();
    
    }

#### 通用的策略工厂类 ####

import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 通用的策略工厂类
     * @param <T>
     * @param <S>
     */
    public class StrategyFactory<T, S extends Strategy<T>> implements InitializingBean, ApplicationContextAware {
        
    
    
        private final Class<S> strategyType;
    
    
        private Map<T, S> strategyMap;
    
    
        private ApplicationContext appContext;
    
    
        /**
         * 创建一个策略工厂
         *
         * @param strategyType 策略的类型
         */
        public StrategyFactory(Class<S> strategyType) {
        
            this.strategyType = strategyType;
        }
    
    
        /**
         * 根据策略 id 获得对应的策略的 Bean
         *
         * @param id 策略 id
         * @return 策略的 Bean
         */
        public S getStrategy(T id) {
        
            return strategyMap.get(id);
        }
    
    
        @Override
        public void afterPropertiesSet() {
        
            // 获取 Spring 容器中，所有 S 类型的 Bean
            Collection<S> strategies = appContext.getBeansOfType(strategyType).values();
            strategyMap = new HashMap<>(strategies.size());
            // 将 所有 S 类型的 Bean 放入到 strategyMap 中
            for (final S strategy : strategies) {
        
                T id = strategy.getId();
                strategyMap.put(id, strategy);
            }
        }
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        
            appContext = applicationContext;
        }
    
    }

### 接口去继承Strategy类 ###

/**
     * 支付接口
     * @author zhou
     */
    public interface PayService extends Strategy<String>{
        
    
        String pay();
    
    }

import org.springframework.stereotype.Service;
    
    /**
     * 具体实现类：现金支付
     */
    @Service("CashPay")
    public class CashPay implements PayService {
        
    
        @Override
        public String pay() {
        
            return "CashPay实现类:现金支付";
        }
    
        @Override
        public String getId() {
        
            return "1";
        }
    }

import org.springframework.stereotype.Service;
    
    /**
     * 具体实现类：扫码支付
     */
    @Service("ScanPay")
    public class ScanPay implements PayService {
        
    
        @Override
        public String pay() {
        
            return "ScanPay实现类:扫码支付";
        }
    
        @Override
        public String getId() {
        
            return "2";
        }
    }

import org.springframework.stereotype.Service;
    
    /**
     * 具体实现类：会员余额支付
     */
    @Service("VipPay")
    public class VipPay implements PayService {
        
        @Override
        public String pay() {
        
            return "VipPay实现类:会员余额支付";
        }
    
        @Override
        public String getId() {
        
            return "3";
        }
    }

#### 注册bean ####

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * 注册bean工厂
     * @author zhou
     */
    @Configuration
    public class FactoryConfig {
        
    
        @Bean(name = "payServiceFactory")
        public StrategyFactory<String, PayService> payServiceFactory() {
        
            return new StrategyFactory<>(PayService.class);
        }
    
    
    }

import com.zm.factory.PayService;
    import com.zm.factory.StrategyFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.*;
    
    @RestController
    @Validated
    public class FactoryController {
        
    
        @Autowired
        private StrategyFactory<String, PayService> payServiceFactory;
        // http://localhost:8080/factory?payType=1
        @GetMapping("/factory")
        public String hello(@RequestParam("payType") String payType) {
        
            PayService service = payServiceFactory.getStrategy(payType);
            return service.pay();
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210116135147584.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210116135220318.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjA0ODkw,size_16,color_FFFFFF,t_70