投稿
  1. 极客之音首页
  2. 技术随笔

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

飞熊 • • 技术随笔 • 阅读 212

人生之路坎坎坷坷，跌跌撞撞在所难免。但是，不论跌了多少次，你都必须坚强勇敢地站起来。任何时候，无论你面临着生命的何等困惑抑或经受着多少挫折，无论道路多艰难，希望变得如何渺茫，请你不要绝望，再试一次，坚持到底，成功终将属于勇不言败的你。

导读：本篇文章讲解 设计模式 – 工厂模式（通用工厂），希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

参考链接: [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();
    }

}

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

通用模板

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

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();
    }

}

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/133960.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！