Java设计模式工厂模式

共计 7292 个字符，预计需要花费 19 分钟才能阅读完成。

简单工厂其实并不属于 23 种 GOF 设计模式之一，该模式是工厂方法模式的弱化（或者说是工厂方法模式的一种特例），因为简单，所以称为简单工厂模式（Simple Factory Pattern），也叫做静态工厂模式。虽然不是 ” 标准 ” 的设计模式（更像是一种编程习惯），但在实际项目中，采用该方法的案例还是比较多的。

简单工厂模式没有严格的定义，我们姑且使用以下描述：

提供一个创建对象实例的功能，而无须关心其具体实现。被创建实例的类型可以是接口、抽象类，也可以是具体的类

具体的工厂类
创建产品的工厂方法
- 静态方法（静态工厂名字的由来）
- 通常会有一个 ” 类型 ” 参数（还有一种是可以提供多个静态工厂方法并通过不同方法名区别要创建的产品）
- 根据参数，利用 if 或者 switch 创建产品并返回

public interface Product {void doSomething();
    void doAnything();}

public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {System.out.println("ConcreteProductA doSomething");

    }

    @Override
    public void doAnything() {System.out.println("ConcreteProductA doAnything");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void doSomething() {System.out.println("ConcreteProductB doSomething");

    }

    @Override
    public void doAnything() {System.out.println("ConcreteProductB doAnything");
    }
}

public class Creator {public static Product createProduct(String type) {
        Product product = null;
        switch (type) {
            case "A":
                product = new ConcreteProductA();
                break;
            case "B":
                product = new ConcreteProductB();
                break;
        }
        return product;
    }
}

public class Client {public static void main(String[] args) {Product productA = Creator.createProduct("A");
        productA.doSomething();
        productA.doAnything();
      
        Product productB = Creator.createProduct("B");
        productB.doSomething();
        productB.doAnything();}

}

简单
解耦
- 客户端不需要依赖具体的产品类，只依赖工厂类，传入不同的参数就可以得到不同的对象；
- 工厂方法可以根据用户条件返回同一类型的不同子类；
- 工厂方法中可以增加额外创建对象的细节，并且对客户端屏蔽这些细节。

工厂类的扩展比较困难，每增加一个产品，就要在工厂中添加相应的分支，对扩展开放的同时对修改也开放了，不符合开闭原则。如果有很多产品，那么工厂方法会显得特别 ” 臃肿 ”，降低可读性且不易维护。

new 的替代品，需要用 new 创建对象的地方都可以考虑简单工厂；
产品种类较少，并且基本可以预见不需要太多扩展的情况（产品需求基本已经确定，例如计算器，已知的运算类型大概就那么多种）

Define an interface for creating an object,but let subclasses decide which class toinstantiate.Factory Method lets a class defer instantiation to subclasses.

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

public interface Product {void doSomething();
    void doAnything();}

public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {System.out.println("ConcreteProductA doSomething");

    }

    @Override
    public void doAnything() {System.out.println("ConcreteProductA doAnything");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void doSomething() {System.out.println("ConcreteProductB doSomething");

    }

    @Override
    public void doAnything() {System.out.println("ConcreteProductB doAnything");
    }
}

public interface Creator {Product createProduct();
}

public class ConcreteCreatorA implements Creator {
    @Override
    public Product createProduct() {return new ConcreteProductA();
    }
}

public class ConcreteCreatorB implements Creator {
    @Override
    public Product createProduct() {return new ConcreteProductB();
    }
}

public static void main(String[] args) {Creator creatorA = new ConcreteCreatorA();
        Product productA = creatorA.createProduct();
        productA.doSomething();
        productA.doAnything();

        Creator creatorB = new ConcreteCreatorB();
        Product productB = creatorB.createProduct();
        productB.doSomething();
        productB.doAnything();}

良好的封装性，代码结构清晰
一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类名（或约束字符串）就可以了，不用知道创建对象的艰辛过程，降低模块间的耦合。
工厂方法模式的扩展性非常优秀
在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。
工厂方法模式是典型的解耦框架
高层模块值需要知道产品的抽象类，其他的实现类都不用关心，符合迪米特法则，我不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；当然也符合里氏替换原则，使用产品子类替换产品父类。

每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。

利用反射机制来解决 ” 每增加一个产品类，就需要增加一个对应的工厂类 ” 的问题

public interface Creator {<T extends Product> T createProduct(Class<T> clazz);
}

public class ConcreteCreator implements Creator {
    @Override
    public <T extends Product> T createProduct(Class<T> clazz) {
        Product product= null;
        try {product = (Product) Class.forName(clazz.getName()).newInstance();} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {e.printStackTrace();
        }
        return (T) product;
    }
}

public class Client {public static void main(String[] args) {Creator creator = new ConcreteCreator();

        Product productA = creator.createProduct(ConcreteProductA.class);
        productA.doSomething();
        productA.doAnything();

        Product productB = creator.createProduct(ConcreteProductB.class);
        productB.doSomething();
        productB.doAnything();}
}

工厂方法模式是对简单工厂的进一步抽象和解耦。和简单工厂比：

工厂方法模式多了一个抽象工厂类
每个产品都对应一个具体的工厂类
工厂方法模式把简单工厂的内部逻辑判断转移到了客户端代码来进行。各个实例对象的创建代码，没有耦合在同一个工厂类里。
工厂方法模式更易于扩展，克服了简单工厂会违背开闭原则的缺点，又保持了封装对象创建过程的优点。

Provide an interface for creating families of related or dependent objects without specifyingtheir concrete classes.

为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。

产品 A 家族

public interface ProductA {void doSomething();
    void doAnything();}

产品 B 家族

public interface ProductB {void doSomething();
    void doAnything();}

产品 A 家族，产品等级 1

public class ConcreteProductA1 implements ProductA {
    @Override
    public void doSomething() {System.out.println("ConcreteProductA1 doSomething");
    }

    @Override
    public void doAnything() {System.out.println("ConcreteProductA1 doAnything");
    }
}

产品 A 家族，产品等级 2

public class ConcreteProductA2 implements ProductA {
    @Override
    public void doSomething() {System.out.println("ConcreteProductA2 doSomething");
    }

    @Override
    public void doAnything() {System.out.println("ConcreteProductA2 doAnything");
    }
}

产品 B 家族，产品等级 2

public class ConcreteProductB1 implements ProductB {
    @Override
    public void doSomething() {System.out.println("ConcreteProductB1 doSomething");
    }

    @Override
    public void doAnything() {System.out.println("ConcreteProductB1 doAnything");
    }
}

产品 B 家族，产品等级 2

public class ConcreteProductB2 implements ProductB {
    @Override
    public void doSomething() {System.out.println("ConcreteProductB2 doSomething");
    }

    @Override
    public void doAnything() {System.out.println("ConcreteProductB2 doAnything");
    }
}

public interface Creator {
    /**
     * 创建 A 产品家族
     * @return
     */
    ProductA createProductA();

    /**
     * 创建 B 产品家族
     * @return
     */
    ProductB createProductB();

    // ...
    // 有 N 个产品族，在抽象工厂类中就应该有 N 个创建方法
}

有 N 个产品族，在抽象工厂类中就应该有 N 个创建方法

public class ConcreteCreator1 implements Creator {
    @Override
    public ProductA createProductA() {return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {return new ConcreteProductB1();
    }
}

public class ConcreteCreator2 implements Creator {
    @Override
    public ProductA createProductA() {return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {return new ConcreteProductB2();
    }
}

有 M 个产品等级，就应该有 M 个具体工厂实现

public class Client {public static void main(String[] args) {Creator creator1 = new ConcreteCreator1();

        ProductA productA1 = creator1.createProductA();
        productA1.doSomething();
        productA1.doAnything();

        ProductB productB1 = creator1.createProductB();
        productB1.doSomething();
        productB1.doAnything();

        Creator creator2 = new ConcreteCreator2();

        ProductA productA2 = creator2.createProductA();
        productA2.doSomething();
        productA2.doAnything();

        ProductB productB2 = creator2.createProductB();
        productB2.doSomething();
        productB2.doAnything();}
}

封装性，高层模块不需要关心每个产品的实现类，不关心对象是如何创建出来的，只要知道工厂类是谁，就能创建出一个需要的对象
一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象，并且很容易交换产品系列
可以定义产品族内的约束，并且这样的约束对高层模块来说是透明的

抽象工厂模式的最大缺点就是产品族扩展非常困难，以上面的通用代码为例，如果要增加一个产品 C，也就是说产品家族由原来的 2 个增加到 3 个，抽象工厂类 Creator 要增加一个方法 createProductC()，然后每个实现类都要修改，违反了开闭原则。

注意是产品族扩展困难，而不是产品等级，如果新增一个产品等级，只需增加一个具体工厂类的实现即可完成扩展

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

工厂方法模式生产一个产品，抽象工厂模式生产多个产品（一系列产品）；在编程中，通常表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

简单工厂、工厂方法、抽象工厂这三种模式是逐步抽象的，后者适用于更为一般的场景，而前者是后者的特例。但它们的目标是殊途同归的，目的都是灵活地创建所需的对象并且对客户端隐藏对象创建细节，三者的扩展性和开发量有所不同，可以根据实际情况选择合适的模式来代替以 new 的方式创建对象的过程：

简单工厂适用于产品种类较少，且不需要太多扩展的场景
工厂方法模式作为简单工厂的进一步抽象和补充，更加适用于有很多扩展需求的场景
如果一个产品族都有相同的约束（在有多个业务品种、业务分类时，即：具有产品族 & 产品等级结构的概念），则可以使用抽象工厂模式

例如一个文本编辑器和一个图片处理器，都是软件实体，但是 *nix 下的文本编辑器和 Windows 下的文本编辑器虽然功能和界面都相同，但是代码实现是不同的，图片处理器也有类似情况。也就是具有了共同的约束条件：操作系统类型。于是我们可以使用抽象工厂模式，产生不同操作系统下的编辑器和图片处理器。

源码地址：https://gitee.com/tianranll/java-design-patterns.git

参考文献：《设计模式之禅》、《大话设计模式》

一、简单工厂

定义

关键点

实现

抽象产品类（接口或抽象类）

具体产品类

工厂类

客户端代码

优点

缺点

使用场景

二、工厂方法

定义

实现

抽象产品类

具体产品类

抽象工厂类

具体工厂类

客户端代码

优点

缺点

扩展

抽象工厂类

具体工厂类

客户端代码

工厂方法 VS 简单工厂

三、抽象工厂

定义

实现

抽象产品类

具体产品类

抽象工厂类

具体工厂类

客户端代码

优点

缺点

抽象工厂 VS 工厂方法

四、总结

Just My Socks（注册教程内含优惠码）

Java设计模式工厂模式

一、简单工厂

定义

关键点

实现

抽象产品类（接口或抽象类）

具体产品类

工厂类

客户端代码

优点

缺点

使用场景

二、工厂方法

定义

实现

抽象产品类

具体产品类

抽象工厂类

具体工厂类

客户端代码

优点

缺点

扩展

抽象工厂类

具体工厂类

客户端代码

工厂方法 VS 简单工厂

三、抽象工厂

定义

实现

抽象产品类

具体产品类

抽象工厂类

具体工厂类

客户端代码

优点

缺点

抽象工厂 VS 工厂方法

四、总结

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）