（六）Spring之回顾工厂模式

忆亦何为

已于 2022-11-30 13:12:03 修改

阅读量202

点赞数 1

分类专栏：设计模式 Spring 文章标签： spring java 后端

于 2022-11-16 13:07:26 首次发布

本文链接：https://blog.csdn.net/weixin_45832694/article/details/127882961

版权

Spring 同时被 2 个专栏收录

21 篇文章 1 订阅

订阅专栏

设计模式

9 篇文章 0 订阅

订阅专栏

本文详细介绍了工厂模式的三种形态：简单工厂模式、工厂方法模式和抽象工厂模式。简单工厂模式通过静态工厂方法创建对象，但不满足开闭原则。工厂方法模式解决了这个问题，通过抽象工厂和具体工厂类实现产品的创建，增强了扩展性。抽象工厂模式则针对多个产品系列，提供了一组相关对象的创建，提高了灵活性。文章通过披萨制作的例子生动地展示了三种模式的应用。

摘要由CSDN通过智能技术生成

文章目录

工厂模式的三种形态

Spring学习目录

上一篇：（五）Spring之Bean的作用域

下一篇：（七）Bean的实例化方式

工厂模式的三种形态

第一种：简单工厂模式（Simple Factory）：不属于23种设计模式之一。简单工厂模式又叫做：静态工厂方法模式。简单工厂模式是工厂方法模式的一种特殊实现。
第二种：工厂方法模式（Factory Method）：是23种设计模式之一。
第三种：抽象工厂模式（Abstract Factory）：是23种设计模式之一。

简单工厂模式

简单工厂模式是工厂方法模式的一种特殊实现，又被称为：静态工厂方法模式。

简单工厂模式中的角色：

抽象产品角色
具体产品角色
工厂类角色

先看一个披萨项目需求：要便于维护的扩展，要便于维护

披萨种类很多（希腊披萨GreekPizz、奶酪披萨CheesePizz）
披萨的制作有prepare，bake，cut，box
完成披萨店的订购功能

在这里插入图片描述
抽象产品角色
Pizz类：

public abstract class Pizz {
    protected String name;//披萨名字
    public abstract void prepare();//准备原材料
    public void bake(){//烘烤
        System.out.println(name + " baking");
    }
    public void cut(){//切割
        System.out.println(name + " cutting");
    }
    public void box(){//打包
        System.out.println(name + " boxing");
    }

    public void setName(String name) {
        this.name = name;
    }

}

具体产品角色
奶酪披萨CheesePizz：

/**
 * 具体产品角色
 */
public class CheesePizz extends Pizz{
    @Override
    public void prepare() {
        System.out.println("给奶酪披萨准备原材料");
    }
}

希腊披萨GreekPizz：

/**
 * 具体产品角色
 */
public class GreekPizz extends Pizz{
    @Override
    public void prepare() {
        System.out.println("给希腊披萨准备原材料");
    }
}

工厂类角色

/**
 * 工厂类角色
 */
public class PizzFactory {
    /**
     * 静态方法，根据用户传type，返回对应的pizz对象
     * 简单工厂模式中有一个静态方法，所以也被称为：静态工厂模式
     * @param type
     * @return pizz
     */
    public static Pizz createPizz(String type){
        Pizz pizz = null;
        System.out.println("使用简单工厂模式");
        if (type.equals("greek")){
            pizz = new GreekPizz();
            pizz.setName("希腊披萨");
        }else if (type.equals("cheese")){
            pizz = new CheesePizz();
            pizz.setName("奶酪披萨");
        }else {
            System.out.println("披萨种类不存在");
        }
        return pizz;
    }
}

测试程序：

public class Client {
    public static void main(String[] args) {
        Pizz pizz = PizzFactory.createPizz("greek");
        pizz.prepare();
        pizz.bake();
        pizz.cut();
        pizz.box();

        Pizz pizz1 = PizzFactory.createPizz("cheese");
        pizz1.prepare();
        pizz1.bake();
        pizz1.cut();
        pizz1.box();
    }
}

请添加图片描述
优缺点：

优点：客户端程序不需要关心对象的创建细节，需要哪个对象时，只需要向工厂索要即可，初步实现了责任的分离。
客户端只负责“消费”，工厂负责“生产”。生产和消费分离。
缺点一：假设现在需要扩展一个新的产品，工厂类的代码是需要修改的，显然违背了OCP原则。
缺点二：工厂类的责任比较重大，不能出现任何问题，因为这个工厂类负责所有产品的生产，称为全能类，或者有人把它叫做上帝类。
这个工厂类一旦出问题，整个系统必然全部瘫痪。

工厂方法模式

工厂方法模式可以解决简单工厂模式当中的OCP问题。
怎么解决的？一个工厂对应生产一种产品。
这样工厂就不是全能类了，不是上帝类了。
另外，也可以符合OCP原则。

工厂方法模式中的角色：

抽象产品角色
具体产品角色
抽象工厂角色
具体工厂角色

客户在点披萨时，可以点不同口味的披萨，例如北京的奶酪披萨、伦敦的奶酪披萨等，这时候可以创建不同的简单工厂类，从当前来说也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性就不是特别好。
这时候就要选择工厂方法模式，定义一个创建对象的抽象方法，由子类决定要实例化的类，工厂方法模式将对象的实例化推迟到子类。
在这里插入图片描述

抽象产品角色
Pizz

public abstract class Pizz {
    protected String name;//披萨名字
    public abstract void prepare();//准备原材料
    public void bake(){//烘烤
        System.out.println(name + " baking");
    }
    public void cut(){//切割
        System.out.println(name + " cutting");
    }
    public void box(){//打包
        System.out.println(name + " boxing");
    }

    public void setName(String name) {
        this.name = name;
    }

}

具体产品角色
希腊披萨GreekPizz

/**
 * 具体产品角色
 */
public class GreekPizz extends Pizz {
    @Override
    public void prepare() {
        setName("希腊披萨");
        System.out.println("给希腊披萨准备原材料");
    }
}

奶酪披萨CheesePizz

/**
 * 具体产品角色
 */
public class CheesePizz extends Pizz {
    @Override
    public void prepare() {
        setName("奶酪披萨");
        System.out.println("给奶酪披萨准备原材料");
    }
}

北京披萨BJPizz

public class BJPizz extends Pizz{
    @Override
    public void prepare() {
        setName("北京披萨");
        System.out.println("给北京披萨准备原材料");
    }
}

抽象工厂角色

/**
 * 抽象工厂角色
 * 方法不再是静态了，是抽象方法
 */
public abstract class PizzFactory {
   public abstract Pizz createPizz();
}

具体工厂角色
希腊披萨工厂GreekPizzFactory

public class GreekPizzFactory extends PizzFactory{
    @Override
    public Pizz createPizz() {
        return new CheesePizz();
    }
}

奶酪披萨工厂CheesePizzFactory


public class CheesePizzFactory extends PizzFactory{

    @Override
    public Pizz createPizz() {
        return new CheesePizz();
    }
}

北京披萨工厂BJPizzFactory

public class BJPizzFactory extends PizzFactory{
    @Override
    public Pizz createPizz() {
        return new BJPizz();
    }
}

测试程序：

public class Client {
    public static void main(String[] args) {
        PizzFactory pizzFactory = new CheesePizzFactory();// 注意：这里可以采用 简单工厂模式 进行隐藏
        Pizz pizz = pizzFactory.createPizz();
        pizz.prepare();
        pizz.bake();
        pizz.cut();
        pizz.box();

        PizzFactory pizzFactory1 = new GreekPizzFactory();
        Pizz pizz1 = pizzFactory1.createPizz();
        pizz1.prepare();
        pizz1.bake();
        pizz1.cut();
        pizz1.box();

        PizzFactory pizzFactory2 = new BJPizzFactory();
        Pizz pizz2 = pizzFactory2.createPizz();
        pizz2.prepare();
        pizz2.bake();
        pizz2.cut();
        pizz2.box();
    }
}

请添加图片描述
优缺点：
工厂方法模式的优点：
当你扩展一个产品的时候，符合OCP原则，因为只需要添加两个类，一个类是具体产品类，一个类是具体工厂类。都是添加类，没有修改之前的代码，所以符合OCP。

一个调用者想创建一个对象，只要知道其名称就可以了。
扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
屏蔽产品的具体实现，调用者只关心产品的接口。

工厂方法模式的缺点：
每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

抽象工厂模式

抽象工厂模式相对于工厂方法模式来说，就是工厂方法模式是针对一个产品系列的，而抽象工厂模式是针对多个产品系列的，即工厂方法模式是一个产品系列一个工厂类，而抽象工厂模式是多个产品系列一个工厂类。

抽象工厂模式特点：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。它有多个抽象产品类，每个抽象产品类可以派生出多个具体产品类，一个抽象工厂类，可以派生出多个具体工厂类，每个具体工厂类可以创建多个具体产品类的实例。
每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结果。

抽象工厂中包含4个角色：

抽象产品角色
具体产品角色
抽象工厂角色
具体工厂角色

定义一个接口用于创建相关或有依赖关系的对象族，而无需指明具体的类。抽象工厂模式是简单工厂模式和工厂方法模式的整合和改进。
在这里插入图片描述
抽象产品角色
Pizz：

public abstract class Pizz {
    protected String name;//披萨名字
    public abstract void prepare();//准备原材料
    public void bake(){//烘烤
        System.out.println(name + " baking");
    }
    public void cut(){//切割
        System.out.println(name + " cutting");
    }
    public void box(){//打包
        System.out.println(name + " boxing");
    }

    public void setName(String name) {
        this.name = name;
    }

}

具体产品角色
伦敦披萨家族：
伦敦胡椒披萨LDPepperPizz

/**
 * 具体产品角色
 * 伦敦胡椒披萨
 */
public class LDPepperPizz extends Pizz{
    @Override
    public void prepare() {
        setName("伦敦的胡椒披萨");
        System.out.println("伦敦胡椒披萨准备材料");
    }
}

伦敦奶酪披萨LDCheesePizz

/**
 * 具体产品角色
 * 伦敦奶酪披萨
 */
public class LDCheesePizz extends Pizz{
    @Override
    public void prepare() {
        setName("伦敦的奶酪披萨");
        System.out.println("伦敦奶酪披萨准备材料");
    }
}

北京披萨家族：
北京胡椒披萨BJPepperPizz

/**
 * 具体产品角色
 * 北京胡椒披萨
 */
public class BJPepperPizz extends Pizz{
    @Override
    public void prepare() {
        setName("北京的胡椒披萨");
        System.out.println("北京胡椒披萨准备材料");
    }
}

北京奶酪披萨BJCheesePizz

/**
 * 具体产品角色
 * 北京奶酪披萨
 */
public class BJCheesePizz extends Pizz{
    @Override
    public void prepare() {
        setName("北京的奶酪披萨");
        System.out.println("北京奶酪披萨准备材料");
    }
}

抽象工厂角色：

/**
 * 抽象工厂角色
 * 抽象工厂接口
 * 这个地方也可以是抽象类
 */
public interface AbsFactory {
    //让下面的工厂子类具体实现
    Pizz createPizz(String ordertype);
}

具体工厂角色
伦敦工厂LDFactory

public class LDFactory implements AbsFactory{
    @Override
    public Pizz createPizz(String ordertype) {
        Pizz pizz = null;
        if ("cheese".equals(ordertype)){
            pizz = new LDCheesePizz();
        }else if ("pepper".equals(ordertype)){
            pizz = new LDPepperPizz();
        }else{
            System.out.println("没有这个披萨");
        }
        return pizz;
    }
}

北京工厂BJFactory

public class BJFactory implements AbsFactory{
    @Override
    public Pizz createPizz(String ordertype) {
        Pizz pizz = null;
        if ("cheese".equals(ordertype)){
            pizz = new BJCheesePizz();
        }else if ("pepper".equals(ordertype)){
            pizz = new BJPepperPizz();
        }else{
            System.out.println("没有这个披萨");
        }
        return pizz;
    }
}

测试程序：

public class Client {
    public static void main(String[] args) {
        AbsFactory factory = new BJFactory();
        Pizz BJcheese = factory.createPizz("cheese");
        Pizz BJpepper = factory.createPizz("pepper");

        BJcheese.prepare();
        BJcheese.bake();
        BJcheese.cut();
        BJcheese.box();

        BJpepper.prepare();
        BJpepper.bake();
        BJpepper.cut();
        BJpepper.box();

        AbsFactory factory2 = new LDFactory();
        Pizz LDcheese = factory2.createPizz("cheese");
        Pizz LDpepper = factory2.createPizz("pepper");

        LDcheese.prepare();
        LDcheese.bake();
        LDcheese.cut();
        LDcheese.box();

        LDpepper.prepare();
        LDpepper.bake();
        LDpepper.cut();
        LDpepper.box();
    }
}

请添加图片描述
优缺点：

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在AbsFactory里加代码，又要在具体的里面加代码。

忆亦何为

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
（六）Spring之回顾工厂模式

客户在点披萨时，可以点不同口味的披萨，例如北京的奶酪披萨、伦敦的奶酪披萨等，这时候可以创建不同的简单工厂类，从当前来说也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性就不是特别好。抽象工厂模式相对于工厂方法模式来说，就是工厂方法模式是针对一个产品系列的，而抽象工厂模式是针对多个产品系列的，即工厂方法模式是一个产品系列一个工厂类，而抽象工厂模式是多个产品系列一个工厂类。当你扩展一个产品的时候，符合OCP原则，因为只需要添加两个类，一个类是具体产品类，一个类是具体工厂类。
复制链接

扫一扫