工厂模式（Factory Pattern）

作者: Djbfifjd | 来源:发表于2019-05-15 17:05 被阅读41次

概述

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

在Java语言中，我们通常有以下几种创建对象的方式：

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

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

主要解决：
主要解决接口选择的问题。

何时使用：
我们明确地计划不同条件下创建不同实例时。

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

关键代码：
创建过程在其子类执行。

应用实例：

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

优点：

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

缺点：

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

使用场景：

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

注意事项：

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

简单工厂模式（Simple Factory Pattern）

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

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

步骤 1：创建一个接口。
Shape.java

public interface Shape {
    void draw();
}

步骤 2：创建实现接口的实体类。
Rectangle.java

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

Square.java

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

Circle.java

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

步骤 3：创建一个工厂，生成基于给定信息的实体类的对象。
ShapeFactory.java

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：使用该工厂，通过传递类型信息来获取实体类的对象。
FactoryPatternDemo.java

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端直接通过工厂创建出来就可以使用了。
产品抽象类

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

具体A产品

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

具体B产品

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

工厂抽象类

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

具体工厂

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

客户端使用

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），这种叫做工厂方法模式或者静态工厂模式。

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

抽象工厂模式

为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定他们的具体实现类。
例如：
Q3和Q7有不同的轮胎、发动机、制动系统。虽然生产的零件不同，型号不同。但是根本上都有共同的约束，就是轮胎、发动机、制动系统。设计如下：

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

抽象工厂

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

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

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

}

三个产品抽象接口

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

//输出
普通轮胎
国产发动机
普通制动

区别

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

工厂模式（Factory Pattern）

概述

简单工厂模式（Simple Factory Pattern）

工厂方法模式

也可以通过反射的方式

抽象工厂模式

区别

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

框架原理