设计模式——创建型之使用工厂模式（Factory Pattern）灵活自由创建你的产品族和方案（二）

引言

前一篇文章总结了Builder建造者模式，在面对构造复杂对象的时候尤其是需要统一管理装配流程的时候，不失为一种良好的选择，但绝不会是唯一的选择，很多时候都应该结合实际的业务来选择对应的模式和结构，这篇文章讲述的就是另一种创建型设计模式——工厂方法模式Factory Method。

一、工厂模式概述

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。工厂模式专门负责将大量有共同接口的类实例化，工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。 工厂模式有三种形态：Simple Factory简单工厂模式、Factory Method工厂方法模式、Abstract Factory抽象工厂模式，前两者是类的创建模式，后者是对象的创建模式，这三种模式从上到下逐步抽象，并且更具一般性。（GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式与抽象工厂模式，将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。）

二、简单工厂模式

简单工厂（又被称为静态工厂）模式是最简单的工厂模式主要用于生产同一等级结构中的任意产品或者方案，但对于增加新的产品，就要修改原工厂类，符合单一职责原则，不符合开放-封闭原则。简单工厂模式是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例，涉及工厂角色(Factory )、抽象产品(Product)角色及具体产品(Concrete Product)角色等三个角色。



以生产产品A、B、C为例，使用简单工厂模式实现：

1、抽象同一等级系列的产品共性，定义接口创建Product角色

package simplefactory;

/**
* @author Crazy.Mo
* 以生产产品为例，由于生产产品种类可能有所不同，把这一操作抽象为顶层操作produce（也可以定义为抽象类）,至于produce具体生产什么产品，由其子类去决定
*/
public interface IProduct {
public void produce();
}

2、实现接口创建具体的产品实体类

package simplefactory;

public class ProductA implements IProduct {

public void produce() {
System.out.println("产出ProductA...");
}
}

package simplefactory;

public class ProductB implements IProduct {

public void produce() {
System.out.println("产出ProductB...");
}
}

3、定义工厂角色，承担生产产品的角色

package simplefactory;

//负责实例化对应产品的对象
public class Factory {
public static final String TYPE_A="a";
public static final String TYPE_B="b";

private Factory() {
}
public static IProduct create(String type){
IProduct product=null;
if(TYPE_A.equals(type)){
product=new ProductA();
}else if(TYPE_B.equals(type)){
product=new ProductB();
}
return product;
}

//结合泛型和反射根据类名自动生成对应的对象，Java EE中使用这种方式比较多，Android中较少使用，因为反射的缘故
@SuppressWarnings("unchecked")
public static <T extends IProduct> T createProduct(Class<T> clz){
IProduct product=null;
try {
product=(IProduct)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) {
IProduct product=null;
product=Factory.create(Factory.TYPE_A);
product.produce();

product=Factory.create(Factory.TYPE_B);
product.produce();

System.out.println("利用反射和泛型方式自动选择...");
product=Factory.createProduct(ProductA.class);
product.produce();
product=Factory.createProduct(ProductB.class);
product.produce();
}

}

如果后期因为业务变更，还需要生产C，就只需要增加C产品的实体类和修改Factory类即可，简单工厂的设计思想是基于最少知识原则（我们调用层不应该知道对象的产生过程），使用简单工厂模式的时候，一般可以把工厂类当做是一个工具类，所以可以把方法设置为静态方法，工厂类本身构造方法可以设置为私有的防止不必要的调用，因此简单工厂模式又被叫为静态工厂。

三、工厂方法模式

工厂方法模式也是定义一个用于创建对象的接口，让子类决定实例化哪一个类且使一个类的实例化延迟到其子类，其实工厂方法模式是简单工厂模式的进一步抽象和推广，其基本思想是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。



通俗来说就是一个产品的生产过程，分解到了两个抽象过程，一个是自身产品的抽象，一个是生产出这个产品的工厂抽象，所以实际的生产流程中，有多少种产品就会有有多少个对应的工厂一一对应，以我们常用的第三方支付API对接为例，可能一开始只需要对接支付宝支付，考虑到后面实际情况还需要对接银联云闪付甚至其他未知的支付方式，为了将来更好的扩展，工厂方法模式将是一个优秀的选项（这里的产品仅仅是个代号，需要放宽自己的思想）

1、抽象同一等级系列的产品共性，定义接口创建IProduct角色

package factorymethod;

//以第三方支付为例，支付方式可能有支付宝、银联云闪付等多种方式，把这些都抽象为顶层操作
public interface IPayApi {
public boolean pay(long money);

//  public void other();
}

2、实现接口创建具体的产品实体类

package factorymethod;

//以第三方支付为例，支付方式可能有支付宝、银联云闪付、微信支付等多种方式，把这些都抽象为顶层操作
public interface IPayApi {
public boolean pay(long money);

//  public void other();
}

package factorymethod;

public class UnionPayApi implements IPayApi {

public boolean pay(long money) {
System.out.println("费用(元)："+money);
System.out.println("通过银联云闪付完成了支付");
return true;
}

}

3、定义抽象工厂和具体的工厂并继承抽象工厂承担实际生产产品的角色

package factorymethod;

//抽象工厂，定义一个顶层抽象工厂，具体生产什么产品由其子类决定
public abstract class PayFactory {
public abstract IPayApi createPayApi();//工厂方法，核心设计思想就是通过它把实例延迟到子类去各自实现

public boolean payout(long money){
IPayApi api=createPayApi();
//api.other();
return api.pay(money);
}
}

package factorymethod;

public class AliPayFactory extends PayFactory {

@Override
public IPayApi createPayApi() {
System.out.println("通过支付宝支付工厂类创建支付宝的支付Api对象");
return new AliPayApi();
}

}

package factorymethod;

public class UnionPayFactory extends PayFactory {

@Override
public IPayApi createPayApi() {
System.out.println("通过银联云闪付工厂类创建云闪付的支付Api对象");
return new UnionPayApi();
}

}

测试

package factorymethod;

public class Client {

public static void main(String[] args) {
IPayApi api=null;
PayFactory factory=new AliPayFactory();
api=factory.createPayApi();
api.pay(1688L);

System.out.println("-----------------------------");
factory=new UnionPayFactory();
api=factory.createPayApi();
api.pay(518L);
}
}

看到这不难看出，工厂方法模式和简单工厂的区别：工厂方法模式只是把简单工厂中的工厂实体类化为两层：抽象工厂类和实际产品的工厂实体类，更利于扩展。

四、抽象工厂模式

通常情况下，简单工厂、工厂方法模式都是单产品系的，而抽象工厂是多产品多系列的，但是从本质上来说工厂方法模式和抽象工厂模式的基本思想是一致的，不同之处在于由于抽象工厂模式是多产品系的所以Product角色会有多个，同样的AbstractFactory角色和对应的实体工厂也会有多个。以汽车生产汽车为例，假如需要生产家轿和SUV，其中家轿和SUV中又分为高中低档，那么采用抽象工厂的话就是很好的选择

1、定义抽象产品族

此处抽象了两个产品族：Car和SUV

package abstractfactory;

public interface ICar {
public void run();
}

public interface ISUV {
public void run();
}

2、实现具体的产品族

根据产品同一系列内的等级实现对应的分产品，SUV系列同样需要实现（代码略）

public class TopCar implements ICar {

public void run() {
System.out.println("高级私轿车飞起来");
}
}

public class MidCar implements ICar {

public void run() {
System.out.println("中级轿车跑起来");
}
}

3、再定义整体的抽象工厂类

package abstractfactory;

//抽象顶层工厂，定义要生产产品的大系列，有N个产品族，在抽象工厂类中就应该有N个创建方法，当然整体抽象工厂可能不仅仅是一层抽象就可以满足（可能需要再抽象，具体请看下文）
public abstract class AbstractFactory {
public abstract ICar manufactureCar();//生产ICar
public abstract ISUV manufactureSUV();//生产ISUV
}

4、再实现各自产品系列对应的实体工厂类

有M个产品等级就应该有M个实现工厂类，在每个实现工厂中，实现不同产品族

的生产任务。

package abstractfactory;

public class TopFactory extends AbstractFactory {

@Override
public ICar manufactureCar() {
System.out.println("通过高等工厂生产高等家轿");
return new TopCar();
}

@Override
public ISUV manufactureSUV() {
System.out.println("通过高等工厂生产高等SUV");
return new TopSUV();
}
}

public class MidFactory extends AbstractFactory {
//同TopFactory
}

测试

public class Client {

public static void main(String[] args) {
AbstractFactory topFactory=new TopFactory();
AbstractFactory midFactory=new MidFactory();

ICar car=topFactory.manufactureCar();
car.run();
car=midFactory.manufactureCar();
car.run();

ISUV suv=topFactory.manufactureSUV();
suv.run();
suv=midFactory.manufactureSUV();
suv.run();
}
}

以上是多产品都拥有同一的系列的情况，但如果是多产品不同系列时，比如说生产轿车和SUV时，其中SUV只有高等没有中等，而家轿分为高等和中等，则需要对于整体工厂进行“再次抽象”

//顶层抽象工厂，无任何方法
public abstract class AbstractFactory {
}

//由于目前已知产品的系列并不完全相同，所以还需要进行次顶层抽象
public abstract class SecAbstractFactory extends AbstractFactory  {
public abstract ICar manufactureCar();//生产ICar
public abstract ISUV manufactureSUV();//生产ISUV
}

public abstract class CarAbstractFactory extends AbstractFactory {
public abstract ISUV manufactureCar();//生产Car
}

那么TopFactory则需要改成

public class TopFactory extends SecAbstractFactory {

@Override
public ICar manufactureCar() {
System.out.println("通过高等工厂生产高等家轿");
return new TopCar();
}

@Override
public ISUV manufactureSUV() {
System.out.println("通过高等工厂生产高等SUV");
return new TopSUV();
}
}

相应地MidFactory

public class MidFactory extends CarAbstractFactory {

}

五、结合泛型和反射实现自动选择工厂

//结合泛型和反射根据类名自动生成对应的对象，Java EE中使用这种方式比较多，Android中较少使用，因为反射的缘故
@SuppressWarnings("unchecked")
public static <T extends IProduct> T createProduct(Class<T> clz){
IProduct product=null;
try {
product=(IProduct)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 Singleton {
//构造方法私有不允许通过new产生一个对象
private Singleton(){
}
}

工厂通过反射方式创建对象

public class SingletonFactory {
private static Singleton singleton;
static{
try {
Class cl= Class.forName(Singleton.class.getName());
//获得无参构造
Constructor constructor=cl.getDeclaredConstructor();
//设置无参构造是可访问的
constructor.setAccessible(true);
//产生一个实例对象
singleton = (Singleton)constructor.newInstance();
} catch (Exception e) {
}
}
public static Singleton getSingleton(){
return singleton;
}
}

2、延迟加载初始化

通过工厂方法模式创建了一个单例对象，该框架可以继续扩展，在一个项目中可以

产生一个单例构造器，所有需要产生单例的类都遵循一定的规则（比如构造方法是private），然

后通过扩展该框架，只要输入一个类型就可以获得唯一的一个实例。基于性能考虑，我们还可以考虑延迟初始化（Lazy initialization），即一个对象被消费完毕后，并不立刻释放，工厂类保持其初始状态，等待再次被使用。同时延迟初始化也是工厂方法模式的一个扩展应用，其通用类UML类图如下



ProductFactory负责产品类对象的创建工作，并且通过prMap变量产生一个缓存，对需要

再次被重用的对象保留，通过定义一个Map容器，容纳所有产生的对象，如果在Map容器中已经有的对象，则直接取出返回；如果没有，则根据需要的类型产生一个对象并放入到Map容器中，以方便下次调用。

//Product和ConcreteProduct代码略，和普通工厂模式一致，Product定义产品共性，ConcreteProduct实现具体产品细节
public class ProductFactory {
private static final Map<String,Product> prMap = new HashMap();
public static synchronized Product createProduct(String type) throws Exception{
Product product =null;
//如果Map中已经有这个对象
if(prMap.containsKey(type)){
product = prMap.get(type);
}else{
if(type.equals("Product1")){
product = new ConcreteProduct1();
}else{
product = new ConcreteProduct2();
}
//同时把对象放到缓存容器中
prMap.put(type,product);
}
return product;
}
}

小结

虽然结构上建造者模式和工厂方法模式都用于创建复杂对象，但两者的专注点不同，建造者模式最主要的功能是基本方法的调用顺序安排，通俗地说就是零件的装配，顺序不同产生的对象也不同；而工厂方法则重点是创建，创建零件是它的主要职责，组装顺序则不是它关心的。关注的是零件类型和装配顺序，不过设计模式在任何时候也不能生搬硬套，实际开发中常常只是借鉴他的思想灵活和结合各种模式（不要以为模式一定是按照某种模板框架的，很多时候都会经过一些变形，源码里经常这样干），才是编程之道。

源码传送门