工厂方法模式与抽象工厂模式

苹果香蕉西红柿

已于 2023-05-18 09:49:15 修改

阅读量501

点赞数

分类专栏：基础 # 设计模式文章标签： java 设计模式

于 2020-03-17 23:13:18 首次发布

本文链接：https://blog.csdn.net/qq_29799655/article/details/104934199

版权

基础同时被 2 个专栏收录

36 篇文章 1 订阅

订阅专栏

设计模式

24 篇文章 0 订阅

订阅专栏

工厂方法模式与抽象工厂模式

一. 工厂方法模式 Factory Method 解决的问题
二. 抽象工厂模式 Abstract Factory Pattern

一. 工厂方法模式 Factory Method 解决的问题

分析简单工厂模式中的合同签署案例,已产品为维度,创建工厂类,根据信息不同使用工厂类创建不同的产品对象,假设增加维度呢,是不是要创建第二个简单工厂,假设增加是个维度呢?,不容易扩展,

案例

客户签署合同,产品AAA,产品BBB分别签署"甲方合同",“乙方合同”,会出现四种情况,A产品签署甲方合同,签署乙方合同,B产品签署甲方合同,签署乙方合同,一共两个维度,产品种类,合同种类

实现步骤

创建产品的父接口
根据类型不同例如产品类型,合同类型,创建具体产品例如"AAA产品+甲方合同",“AAA产品+乙方合同”,“BBB产品+甲方合同”,“BBB产品+乙方合同”
创建抽象父工厂,提供返回实例(具体产品对象)的抽象方法,
根据具体产品的某个维度,继承父工厂,创建多个子工厂,此处具体产品一个有两个维度,产品类型,合同类型,可以以产品类型为维度创建"AAA"工厂,“BBB"工厂,也可以以合同类型为维度创建"甲方合同工厂”,“乙方合同工厂”,在具体调用时,当你已经找到工厂了实际已经确定了一个维度,然后在工厂中根据信息在确定另外一个维度,具体产品就出来了

代码示例(比较冗余,只是看设计模式的思想)

创建产品父接口

//产品抽象接口
interface ProductInterface{
    //获取产品类型
    String getProductType();
    //获取合同类型
    String getContractType();
    //业务代码
    void testRun();
}

创建具体产品

//产品A甲方合同
class ProductAContractA implements ProductInterface{
    private String productType = "AAA";
    private String contractType = "甲方";
    @Override
    public String getProductType() {
        return productType;
    }
    @Override
    public String getContractType() {
        return contractType;
    }
    @Override
    public void testRun() {
        System.out.println("产品AAA签署甲方合同业务代码执行");
    }
}

//产品A乙方合同
class ProductAContractB implements ProductInterface{
    private String productType = "AAA";
    private String contractType = "乙方";
    @Override
    public String getProductType() {
        return productType;
    }
    @Override
    public String getContractType() {
        return contractType;
    }
    @Override
    public void testRun() {
        System.out.println("产品AAA签署乙方合同业务代码执行");
    }
}

//产品B甲方合同
class ProductBContractA implements ProductInterface{
    private String productType = "AAA";
    private String contractType = "乙方";
    @Override
    public String getProductType() {
        return productType;
    }
    @Override
    public String getContractType() {
        return contractType;
    }
    @Override
    public void testRun() {
        System.out.println("产品AAA签署乙方合同业务代码执行");
    }
}

//产品B乙方合同
class ProductBContractB implements ProductInterface{
    private String productType="BBB";
    private String contractType = "乙方";
    @Override
    public String getProductType() {
        return productType;
    }
    @Override
    public String getContractType() {
        return contractType;
    }
    @Override
    public void testRun() {
        System.out.println("产品BBB签署乙方合同业务代码执行");
    }

创建抽象父工厂

//创建抽象工厂,将根据信息创建出对象,对应信息不同的业务代码,下沉到子类工厂
abstract class ProductFactory{
    //根据产品创建对应的具体产品
    abstract ProductInterface createProductContract(String productType);

    //通过Contract签署合同
    public static void contractSign(ProductInterface Product){
        Contract.sign(Product);
    }
}

以合同类型为维度,创建子工厂

//有多个维度,根据某个维度创建工厂,例如此处有合同类型与产品两个维度,甲方乙方,产品A,产品B,
//根据合同类型创建工厂,一个工厂代表一个合同类型,在工厂中判断产品种类,获取到两个信息,
//得到结构,进行业务处理
//创建工厂子类A
class ProductContractFactoryA extends ProductFactory{
	//根据传递的产品类型创建出Product对象
    @Override
    public ProductInterface createProductContract(String productType) {
        ProductInterface product = null;
        if("AAA".equals(productType)){
            product = new ProductAContractA();
            product.testRun();
        }else if("BBB".equals(productType)){
            product = new ProductAContractB();
            product.testRun();
        }else {
            System.out.println("没有该产品!");
            //抛出异常
        }
        return product;
    }
}

//创建工厂子类B
class ProductContractFactoryB extends ProductFactory{
	//根据传递的产品类型创建出Product对象
    @Override
    public ProductInterface createProductContract(String productType) {
        ProductInterface product = null;
        if("AAA".equals(productType)){
            product = new ProductBContractA();
            product.testRun();
        }else if("BBB".equals(productType)){
            product = new ProductBContractB();
            product.testRun();
        }else {
            System.out.println("没有该产品!");
            //抛出异常
        }
        return product;
    }
}

创建合同签署功能类

class Contract{
    //合同签署代码,业务代码与功能代码进行剥离,使其只关注功能
    public static void sign(ProductInterface product){
        System.out.println(product.getProductType()+"产品签署"
        		+product.getContractType()+"合同成功或失败");
    }
}

测试

public class FactoryTest {
    public static void main(String[] args) {
        //根据合同类型创建不同的工厂
        //甲方合同工厂(在创建工厂时,就已经确定了一个维度)
        ProductFactory factoryA = new ProductContractFactoryA();
        //乙方合同工厂
        ProductFactory factoryB = new ProductContractFactoryB();
        //通过工厂创建出需要的对象
        //甲方合同AAA产品(再给出确定的产品类型,确定第二个维度,通过工厂创建出对象)
        ProductInterface productAa = factoryA.createProductContract("AAA");
        //执行合同签署
        ProductFactory.contractSign(productAa);
        //甲方合同BBB产品
        ProductInterface productAb = factoryA.createProductContract("BBB");
        ProductFactory.contractSign(productAb);
        //乙方合同AAA产品
        ProductInterface productBa = factoryB.createProductContract("BBB");
        ProductFactory.contractSign(productBa);
    }
}

根据案例分析工厂方法模式

工厂方法是为了解决简单工厂违反ocp原则问题而出现的,抽象出父工厂,根据某个维度创建多个子工厂,将创建对象方法下沉到子工厂中,由子工厂去确定创建什么类型的对象,在调用时当能确定由哪个子工厂去执行创建对象,实际已经确定了一个维度,例如创建产品A的子工厂时,已经确定了产品类型,在子工厂中只需要编写确定合同类型的逻辑代码即可,也就是对简单方法的再次抽象,每抽象一次确定一个维度,假设此时需要增加产品类型C,就需要修改子工厂中的逻辑代码,如果增加一个合同类型,就要增加一个子工厂,开发量较大

JDK源码中的工厂方法模式

查看Collecion接口中的 "Iteratoriterator()"就是一个工厂方法模式,Collection可以看为是抽象工厂相当与此处的ProductFactory，当中的iterator方法就相当于createProductContract(), ArrayList中重写了这个方法，可以将ArrayList看为一个具体的工厂实现，该方法在ArrayList中返回了一个内部类Itr对象实例，这个对象可以看为是具体生产的产品
URLStreamHandlerFactory 该接口是一个用来专门处理URL协议扩展使用的，接口中有一个方法createURLStreamHandler(String protocol), 该接口可以看为是抽象父工厂，该接口被Launcher类实现，并重写了方法，Launche就是这个工厂的具体实现，重写的方法中返回的URLSHandler是一个抽象类，在返回过程中实际返回的是对于的子类

二. 抽象工厂模式 Abstract Factory Pattern

关键是提供一个产品族（一系列相互依赖的对象）抽象接口，将一系列的产品族统一到一起创建，通过抽象接口创建需要的指定实例，对客户端与实现细节进行解耦

示例

生产美的或者海尔的冰箱，电视

根据产品抽象父接口,产品有冰箱,电视…
实现父接口创建具体产品"美的冰箱",“美的电视”,“海尔冰箱”,“海尔电视”
提供创建产品的产品族父工厂接口,什么是产品族,可以理解为某个相同维度的,例如创建冰箱,电视,洗衣机,等都是海尔的或者都是美的的
实现产品族父工厂接口,创建具体产品族子工厂"美的产品族工厂",“海尔产品族工厂”,当获取产品时,在该工厂下返回的都是指定品牌的产品
好了,不编了,编不下去了,我TM到现在没看出来抽象工厂跟工厂方法有什么实际意义上的区别,总觉得两个长得一样…尼玛

分析案例

创建产品父接口

//冰箱
abstract class Refrigerator {
    abstract void produceRefrigerator();
}

//电视
abstract class TV {
    abstract void produceTV();
}

创建具体产品: 美的，海尔，冰箱，电视

//海尔冰箱
class HaierRefrigerator extends Refrigerator{
    @Override
    void produceRefrigerator() {
        System.out.println("生产海尔冰箱");
    }
}

//海尔电视
class HaierTV extends TV {
    @Override
    void produceTV() {
        System.out.println("生产海尔电视");
    }
}

//美的冰箱
class MideaRefrigerator extends Refrigerator{
    @Override
    void produceRefrigerator() {
        System.out.println("生产美的冰箱");
    }
}

//美的电视
class MideaTV extends TV {
    @Override
    void produceTV() {
        System.out.println("生产美的电视");
    }
}

根据某个维度确定产品族，创建产品族抽象工厂

//公共的抽象工厂
interface ElectricFactory{
    //生产冰箱
    Refrigerator getRefrigerator();
    //生产电视
    TV getTV();
}

海尔品牌维度看为是产品族，就可以创建美的工厂，海尔工厂，这样后续可以很方便的增加格力工厂，海信工厂等,在工厂子类中编写逻辑代码，实现具体产品，形成客户端与具体实现的隔离

//美的产品族,工厂子类, 该产品族下生产美的品牌的电器,
class MideaFactory implements ElectricFactory {
    //创建美的冰箱逻辑方法
    @Override
    public Refrigerator getRefrigerator() {
        return new MideaRefrigerator();
    }
    //创建美的电视逻辑方法
    @Override
    public TV getTV() {
        return new MideaTV();
    }
}

//海尔产品族,生产海尔品牌电器
class HaierFactory implements ElectricFactory {
    //创建海尔冰箱逻辑方法
    @Override
    public Refrigerator getRefrigerator() {
        return new HaierRefrigerator();
    }
    //创建海尔电视逻辑方法
    @Override
    public TV getTV() {
        return new HaierTV();
    }
}

客户端调研测试，只关注工厂

public class FactoryTest {
    public static void main(String[] args) {
        //抽象工厂,通过后面的new MideaFactory(),
        //可以看出创建的是美的产品族中的产品
        ElectricFactory mFactory= new MideaFactory();
        Refrigerator mRefrigerator = mFactory.getRefrigerator();
        mRefrigerator.produceRefrigerator();

        //创建海尔产品族,通过海尔产品族创建指定产品
        ElectricFactory hFactory= new HaierFactory();
        TV hRTV = hFactory.getTV();
        hRTV.produceTV();

    }
}

分析抽象工厂模式可以看出：可以比较方便的增加工厂，但是如果增加或修改创建的产品，会比较复杂，比修改某个产品的逻辑代码，或者如增加洗衣机产品，需要创建洗衣机实体类，各个工厂方法中增加洗衣机产品的创建方法等，在产品已定或不容易变动的情况下推荐使用

JDK源码中的抽象工厂模式

查看java.sql.Connection数据库连接相关的接口,查看该接口

以上几个返回DB连接的方法,都是一个产品族中的,相当于案例中的抽象父接口ElectricFactory,实现该接口的,并重新抽象方法的类为产品族具体实现的工厂子类,相当于此处的美的产品族,海尔产品族
查看Mybatis相关的SqlSessionFactory接口，该接口中的方法返回的SqlSession，或Configuration都是属于同一个产品族的，例如连接Mysql时返回的就是Mysql这一产品族的，连接Sqlserver时返回的就是SqlServer的

苹果香蕉西红柿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
工厂方法模式与抽象工厂模式

工厂方法模式工厂方法模式解决的问题工厂方法模式示例案例实现步骤代码示例(比较冗余,只是看设计模式的思想)根据案例分析工厂方法模式工厂方法模式解决的问题分析简单工厂模式中的合同签署案例,已产品为维度,创建工厂类,根据信息不同使用工厂类创建不同的产品对象,假设增加维度呢,是不是要创建第二个简单工厂,假设增加是个维度呢?,不容易扩展,工厂方法模式示例案例客户签署合同,产品AAA,产品BBB分别...
复制链接

扫一扫