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

已于 2022-08-04 16:25:03 修改
阅读量442 收藏 2
点赞数 2
分类专栏： 设计模式 文章标签： java 设计模式
于 2021-01-16 13:00:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41604890/article/details/112692297
版权 
参考链接: [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();
    }

}
qq_250056868
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
通用工厂类Factory(C++实现)
辉哥
04-16 4696
灵光一闪：         抽象工厂模式经常被使用，那么同时也会多次写相同或类似的代码。能不能设计一个通用的工厂类，以避免重复设计工厂类呢？
设计模式----工厂模式
03-15
在软件工程领域，设计模式是一种在特定情境下解决常见问题的模板，它为程序员提供了一种标准的解决方案。工厂模式是面向对象设计中最为人熟知的设计模式之一，属于创建型模式，其主要目标是封装对象的创建过程，使得...
Hollis原创|你以为工厂模式很简单，可能是因为你懂的只是冰山的一角
weixin_34262482的博客
05-27 221
GitHub 3.2k Star 的Java工程师成神之路 ，不来了解一下吗? GitHub 3.2k Star 的Java工程师成神之路 ，真的不来了解一下吗? GitHub 3.2k Star 的Java工程师成神之路 ，真的确定不来了解一下吗? 很多人认为工厂模式很简单，只是有一个建造工厂，帮我们进行对象构造而已。那么请尝试回答下以下问题： 1、工厂模式分为几类？ 2、GOF 23种设计模...
常见设计模式之（二）：工厂模式（一）
码中飞翔
03-07 285
文章目录常见设计模式之（一）：工厂模式（一）1 什么是工厂模式（factory pattern）？2 通用工厂模式以及其基于c++实现2.1 通用工厂模式2.2 通用工厂模式的c++实现3 工厂模式的扩展之 简单工厂4 结束语 常见设计模式之（一）：工厂模式（一） 1 什么是工厂模式（factory pattern）？ 摘自 java 设计模式官网 中 有关工厂模式的定义： Define an ...
一个通用工厂模式的优雅实现。。。= =
A328240784的专栏
11-14 1329
package com.itheima.utils; import java.io.IOException; import java.io.InputStream; import java.util.Properties; public class DaoFactory { Properties pro = new Properties(); private static DaoFa
JAVA工厂模式概述，简单实现以及通用工厂
tuc1997的博客
04-06 145
什么是工厂模式 通常如果我们要创建Sample的实例对象，是通过new的方法： Sample sample=new Sample(); Sample sample=new Sample(参数); User user = new User(); UserDAO userDAO = new UserDAOImpl(); 这种方式把接口的实现类，硬编码在程序中，但是这种会让代码之间存在很强的耦合：指定是代码间的强关联关系，一方的改变会影响到另一方不利于代码维护 而工厂模式是我们最常用的实例化对象模式了，是用工
我讲设计模式--工厂方法
04-11
在软件开发领域，设计模式是一种经过验证的、通用的解决方案，用于解决常见的设计问题。"工厂方法"（Factory Method）是面向对象设计中的一种经典设计模式，它属于创建型模式，其主要目的是为了抽象产品的创建过程，...
JAVA设计模式-原则和23种设计模式归纳总结
11-24
JAVA设计模式-原则和23种设计模式归纳总结 本资源主要介绍了JAVA设计模式的原则和23种设计模式的总结。设计模式是软件设计中的一种解决方案，能够使软件系统更加灵活、可维护和可扩展。本资源首先介绍了设计模式的...
23种设计模式-UML-类图.docx
08-07
设计模式是软件开发中的一种解决方案，它提供了一种通用的解决方案来解决软件设计中常见的问题。UML（Unified Modeling Language）是一种标准化的建模语言，用于描述软件系统的结构和行为。下面是关于设计模式和UML...
设计模式----抽象工厂模式
03-28
抽象工厂模式是设计模式中的一种创建型模式，它提供了一种创建对象族的接口，而无需指定具体的类。这种模式允许客户端使用一个通用接口来创建一组相关或相互依赖的对象，而无需了解它们的具体实现。在Java或其他面向...
工厂模式的应用——SSM框架中DAO层工厂
qq_17357299的博客
11-26 2429
通用的数据库“增，删，改，查”
简易理解设计模式之：简单工厂模式——来试试接入支付功能
TwcatL_tree
03-27 1047
介绍： 简单工厂模式是一种创建型模式，又叫做静态工厂方法模式。它的定义为：定义一个用于创建对象的接口，让子类决定实例化那个类。在简单工厂模式中，可以根据参数的不同返回不同类的实例。 类图： 简单工厂模式UML类图 Product（抽象产品类）：要创建的复杂对象，抽离通用方法。 ConcreteProduct（具体产品类）：实现Product接口，即实现具体方法。 Factory（工...
工厂模式-微信支付、支付宝支付
预立数据科技
06-29 2272
工厂模式-微信支付、支付宝支付 当我们做支付项目时，常常项目中需要接入多种支付方式（微信、支付宝、银联等）。 其实这些支付方式，都存在一些类似的业务接口，比如支付、查询、退款等等。 区别就在于每一家参数不一致（参数名不一致）。我们可以利用工厂模式将支付厂商封装起来。 利用工厂模式，我们可以更方便的选择支付方式接口。 下面代码仅仅是结构，暂无具体的支付实现， 下面代码以java代码为例，工厂模式与编程语言无关，其他编程语言也可以，如C# , Go 代码中类似ResultCreatePay、CreatePayP
设计模式之工厂模式案例(支付)
BF的博客
03-18 1858
我们如何能根据一个业务来优雅的实现高扩展性，可维护性高的代码呢，下面介绍一种我们常用的设计模式--工厂模式 具体代码实现： sql脚本： create table channel ( channel_id int auto_increment primary key, channel_name varchar(40) null comment '渠道名称', ...
基于工厂模式和策略模式改造支付系统
xu990128638的专栏
09-15 401
5. checkout 支付策略。6. sendWyre 支付策略。4. 支付策略上线文。
设计模式:从聚合支付业务的设计来聊聊策略模式
码农小胖哥
06-03 1543
六月福利2020 年 6 月公众号码农小胖哥原创文章转发第一名将送全新《Spring Boot 实战》实体书一本，该书是学习热门框架 Spring Boot的经典之作。你不再需要依靠运气...
灵活支付：策略模式在多支付方式系统中的应用
最新发布
来自上海的这位朋友
04-17 350
策略模式是一种行为型设计模式，用于将一组算法封装到具有共同接口的独立类中，使得算法可以在运行时相互替换，提高代码的灵活性和可维护性。我们通过一个支付系统的示例演示了策略模式的应用，其中支持多种支付方式（如信用卡、支付宝和微信支付）。通过使用策略模式，我们可以轻松地为支付系统添加新的支付方式，而无需修改现有代码，从而使支付系统更加灵活和可维护。
通过简单工厂模式实现多种支付理解抽象类和接口
程序猿的世界
06-01 1626
类是描述一个实体的，实体则包含属性和该属性可以实现的动作，所以抽象类可以包含属性和方法。 接口是描述行为的，所以接口仅可以定义方法，不可以定义属性，但可以定义常量。 举例说明实现支付，支付可以有很多种方式：微信、支付宝、京东白条等。他们都至少有一个支付行为，所以首先定义一个支付接口。 <?php interface PayInterface { //支付行为 ...
设计模式之工厂模式
Zz_0_o的博客
07-20 140
工厂模式顾名思义就是将一个类作为一个工厂，调用者不关心你是怎么工作的，只要最后能够得到自己想要的就可以。  首先，我们需要创建一个抽象类，代表着一类物品 public abstract class Noodle { /** * 所有面条的属性：描述 */ public abstract void des(); } 然后我们可以写具体的商品，比如我在这里就写了两个，一个兰州拉面...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值