工厂模式(Factory Pattern)

一、概述

工厂模式包括简单工厂模式(Simple Factory Pattern)、工厂方法模式和抽象工厂模式，是 Java 中最常用的一类创建型设计模式，它提供了一种创建对象的最佳方式。正如它的名字，可以像工厂一样生产出想要的东西，只要提供原料。在工厂模式中，在创建对象时不会对客户端暴露创建逻辑，而是通过使用一个共同的接口来指向新创建的对象。简单工厂模式是工厂方法模式的“小弟”，它不属于 GoF 23 种设计模式，但在软件开发中应用也较为频繁，通常将它作为学习其他工厂模式的入门。此外，工厂方法模式还有一位“大哥”——抽象工厂模式。这三种工厂模式各具特色，难度也逐个加大，在软件开发中它们都得到了广泛的应用，成为面向对象程序中常用的创建对象的工具。

1️⃣在 Java 中，通常有以下几种创建对象的方式：

  1. 使用 new 关键字直接创建对象(最简单，灵活性较差)
  2. 通过反射机制创建对象
  3. 通过 clone() 创建对象
  4. 通过工厂类创建对象

2️⃣意图
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

3️⃣主要解决
主要解决接口选择的问题。

4️⃣何时使用
明确地计划不同条件下创建不同实例时。

5️⃣如何解决
让其子类实现工厂接口，返回的也是一个抽象的产品。

6️⃣关键代码
创建过程在其子类执行。

7️⃣应用实例

  1. 需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。
  2. Hibernate 换数据库只需换方言和驱动就可以。

8️⃣优点

  1. 屏蔽产品的具体实现，调用者只关心产品的接口。
    对调用者屏蔽具体的产品类。如果使用工厂模式，调用者只关心产品的接口就可以了，至于具体的实现，调用者根本无需关心。即使变更了具体的实现，对调用者来说没有任何影响。
  2. 可以使代码结构清晰，有效地封装变化。在编程中，产品类的实例化有时候是比较复杂和多变的，通过工厂模式，将产品的实例化封装起来，使得调用者根本无需关心产品的实例化过程，只需依赖工厂即可得到自己想要的产品。
  3. 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。降低耦合度。产品类的实例化通常来说是很复杂的，它需要依赖很多的类，而这些类对于调用者来说根本无需知道，如果使用了工厂方法，我们需要做的仅仅是实例化好产品类，然后交给调用者使用。对调用者来说，产品所依赖的类都是透明的。

9️⃣缺点

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

🔟使用场景

  1. 日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
  2. 数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
  3. 设计一个连接服务器的框架，需要三个协议“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。

1️⃣1️⃣注意事项

作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式。而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

二、简单工厂模式不属于23种GOF设计模式

又叫做静态工厂方法(StaticFactory Method)模式。 主要用于创建同一类的对象，比如创建图形类(Rectangle 矩形、Square 正方形、Circle 圆形)

创建一个 Shape 接口和实现 Shape 接口的实现类。下一步是定义工厂类 ShapeFactory。FactoryPatternDemo，演示类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息(RECTANGLE、SQUARE、CIRCLE)，以便获取它所需对象的类型。

1️⃣创建一个接口

public interface Shape {
    void draw();
}

2️⃣创建实现接口的实现类

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

3️⃣创建一个工厂，生成基于给定信息的实现类的对象

public class ShapeFactory {
    //使用 getShape 方法获取形状类型的对象
    public Shape getShape(String shapeType){
        if("CIRCLE".equalsIgnoreCase(shapeType)){
            return new Circle();
        }else if("RECTANGLE".equalsIgnoreCase(shapeType)){
            return new Rectangle();
        }else if("SQUARE".equalsIgnoreCase(shapeType)){
            return new Square();
        }
        return null;
    }
}

4️⃣使用该工厂，通过传递类型信息来获取实现类的对象。

public class FactoryPatternDemo {
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();

        //获取 Circle 的对象，并调用它的 draw 方法
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        shape1.draw();

        //获取 Rectangle 的对象，并调用它的 draw 方法
        Shape shape2 = shapeFactory.getShape("RECTANGLE");
        shape2.draw();

        //获取 Square 的对象，并调用它的 draw 方法
        Shape shape3 = shapeFactory.getShape("SQUARE");
        shape3.draw();
    }
}

5️⃣执行程序，输出结果：

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.

根据传入不同的 shapeType(如：RECTANGLE、SQUARE、CIRCLE)去创建不同的对象，然后再通过不同的 shapeType 对象去给里面的属性赋值。无论 RECTANGLE、SQUARE、CIRCLE 都是 Shape，所以说简单工厂模式就是用来创建同一类对象的不同实例。

三、工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。在工厂里面可以对对象的创建做严格的定义，client 端直接通过工厂创建出来就可以使用了。

1️⃣产品抽象类

public abstract class Product {  
    public abstract void method(); 
}

2️⃣具体A产品

public class ProductA extends Product { 
    @Override
    public void method() {
        System.out.println("产品A");
    }
}

3️⃣具体B产品

public class ProductB extends Product { 
    @Override
    public void method() {
        System.out.println("产品B");
    }
}

4️⃣工厂抽象类

public abstract class Factory { 
    public abstract Product createProduct();
}

5️⃣具体工厂

public class ProductFactory extends Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

6️⃣客户端使用

public class Client {
    public static void main(String[] args) {
        Factory factory = new ProductFactory();
        Product product = factory.createProduct();
        product.method();
    }
}

也可以通过反射的方式

public abstract class Factory {
    public abstract <T extends Product> T createProduct(Class<T> clz);
}

public class ConcreteFactory extends Factory {
    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product  product = null;
        try {
            product= (Product) Class.forName(clz.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) product;
    }
}

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product product = factory.createProduct(ConcreteProductB.class);
        product.method();
    }
}

拥有多个工厂的方式称为多工厂方法模式，如果只有一个工厂可以去掉抽象类直接定义一个 static 的方法返回对象(用 static 修饰可以不用初始化工厂直接返回产品，也可以不用 static)，这种叫做工厂方法模式或者静态工厂模式。

优点和缺点是一样的：新加一个产品需要相应的产品类和一个工厂子类。

四、抽象工厂模式

为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定具体实现类。

1️⃣抽象工厂模式与工厂方法模式的区别
抽象工厂模式是工厂方法模式的升级版本，它用来创建一组相关或者相互依赖的对象。它与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

在抽象工厂模式中，有一个产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。拿生产汽车的例子来说明他们之间的区别：

在上面的类图中，两厢车和三厢车称为两个不同的等级结构。而2.0排量车和2.4排量车则称为两个不同的产品族。再具体一点，2.0排量两厢车和2.4排量两厢车属于同一个等级结构，2.0排量三厢车和2.4排量三厢车属于另一个等级结构；而2.0排量两厢车和2.0排量三厢车属于同一个产品族，2.4排量两厢车和2.4排量三厢车属于另一个产品族。

明白了等级结构和产品族的概念，就理解工厂方法模式和抽象工厂模式的区别了，如果工厂的产品全部属于同一个等级结构，则属于工厂方法模式；如果工厂的产品来自多个等级结构，则属于抽象工厂模式。在本例中，如果一个工厂模式提供2.0排量两厢车和2.4排量两厢车，那么属于工厂方法模式；如果一个工厂模式是提供2.4排量两厢车和2.4排量三厢车两个产品，那么这个工厂模式就是抽象工厂模式，因为提供的产品是分属两个不同的等级结构。当然，如果一个工厂提供全部四种车型的产品，因为产品分属两个等级结构，当然也属于抽象工厂模式了。

2️⃣Q3 和 Q7 有不同的轮胎、发动机、制动系统。虽然生产的零件不同，型号不同。但是根本上都有共同的约束，就是轮胎、发动机、制动系统。设计如下：

  1. 需要一个抽象工厂，里面有三个接口分别为生产轮胎、发动机、制动系统，抽象类。
  2. 需要三个抽象产品分别为轮胎、发动机、制动系统，抽象接口。
  3. 需要实现上面的三个抽象接口，定义出每个接口不同的对象，比如：普通轮胎和越野轮胎。
  4. 需要两个具体类继承自上面的抽象类，实现具体的工厂，比如：生产 Q3 的工厂和生产 Q7 的工厂。
  5. 在客户端 new 出对应的具体工厂并调用对应的生产方法。

三个产品抽象接口

public interface ITire {
    void tire();//轮胎 
}

public interface IEngine {
    void engine();//发动机
}

public interface IBrake {
    void brake();//制动系统
}

根据抽象接口定义不同的对象

public class NormalBrake implements IBrake{
    @Override
    public void brake() {
        System.out.println("普通制动");
    }
}

public class SeniorBrake implements IBrake{
    @Override
    public void brake() {
        System.out.println("高级制动");
    }
}  //后面的定义省略。。。。。。。。。。。。。

抽象工厂

public abstract class CarFactory {
    /**
     * 生产轮胎
     * @return 轮胎
     * */
    public abstract ITire createTire();

    /**
     * 生产发动机
     * @return 发动机
     * */
    public abstract IEngine createEngine();

    /**
     * 生产制动系统
     * @return 制动系统
     * */
    public abstract IBrake createBrake();

}

实现具体的工厂类

public class Q3Factory extends CarFactory{

    @Override
    public ITire createTire() {
        return new NormalTire();
    }

    @Override
    public IEngine createEngine() {
        return new DomesticEngine();
    }

    @Override
    public IBrake createBrake() {
        return new NormalBrake();
    }
}

客户端使用

public class Client {
    public static void main(String[] args) {
        //A车厂
        CarFactory factoryQ3 = new Q3Factory();
        factoryQ3.createTire().tire();
        factoryQ3.createEngine().engine();
        factoryQ3.createBrake().brake();
        System.out.println("---------------");
    }
}

//输出

普通轮胎
国产发动机
普通制动

五、区别

1️⃣工厂方法模式：只有一个抽象产品类，具体工厂类只能创建一个具体产品类的实例。
2️⃣抽象工厂模式：有多个抽象产品类 ，具体工厂类能创建多个具体产品类的实例。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 159,458评论 4赞 363
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,454评论 1赞 294
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 109,171评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,062评论 0赞 207
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,440评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,661评论 1赞 219
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,906评论 2赞 313
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,609评论 0赞 200
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,379评论 1赞 246
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,600评论 2赞 246
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,085评论 1赞 261
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,409评论 2赞 254
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,072评论 3赞 237
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,088评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,860评论 0赞 195
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,704评论 2赞 276
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,608评论 2赞 270