设计模式系列—抽象工厂模式-抽象工厂模式

前言

23种设计模式速记
单例（singleton）模式
工厂方法（factory method）模式

前面说完了工厂方法模式，我们发现工厂方法模式存在一个严重的问题：一个具体工厂只能创建一类产品，而实际过程中一个工厂往往需要生产多类产品。为了解决上述问题，可以使用抽象工厂模式，本篇和大家一起来学习抽象工厂模式相关内容。

模式定义
抽象工厂模式，即Abstract Factory Pattern，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

解决的问题
每个工厂只能创建一类产品

即工厂方法模式的缺点

模式组成
抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。

使用步骤

创建抽象工厂类，定义具体工厂的公共接口；
创建抽象产品族类，定义抽象产品的公共接口；
创建抽象产品类（继承抽象产品族类），定义具体产品的公共接口；
创建具体产品类（继承抽象产品类） & 定义生产的具体产品；
创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；

客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例
实例说明
实例概况

背景：隔壁老王有两间塑料加工厂（A厂仅生产容器类产品；B厂仅生产模具类产品）；随着客户需求的变化，A厂所在地的客户需要也模具类产品，B厂所在地的客户也需要容器类产品；
冲突：没有资源（资金+租位）在当地分别开设多一家注塑分厂
解决方案：在原有的两家塑料厂里增设生产需求的功能，即A厂能生产容器+模具产品；B厂间能生产模具+容器产品。

即抽象工厂模式

使用步骤

步骤1： 创建抽象工厂类，定义具体工厂的公共接口。

abstract class Factory{ 
    public abstract AbstractProduct ManufactureContainer(); 
    public abstract AbstractProduct ManufactureMould(); 
}

步骤2： 创建抽象产品族类，定义具体产品的公共接口。

abstract class AbstractProduct{ 
    public abstract void method1(); 
}

步骤3： 创建抽象产品类，定义具体产品的公共接口。

//容器产品抽象类 
abstract class ContainerProduct extends AbstractProduct { 
    @Override 
    public abstract void method1(); 
} 
 
//模具产品抽象类 
abstract class MouldProduct extends AbstractProduct { 
    @Override 
    public abstract void method1(); 
}

步骤4： 创建具体产品类（继承抽象产品类），定义生产的具体产品。

//容器产品A类 
class ContainerProductA extends ContainerProduct{ 
    @Override 
    public void method1() { 
        System.out.println("生产出了容器产品A"); 
    } 
} 
 
//容器产品B类 
class ContainerProductB extends ContainerProduct{ 
    @Override 
    public void method1() { 
        System.out.println("生产出了容器产品B"); 
    } 
} 
 
//模具产品A类 
class MouldProductA extends MouldProduct{ 
 
    @Override 
    public void method1() { 
        System.out.println("生产出了模具产品A"); 
    } 
} 
 
//模具产品B类 
class MouldProductB extends MouldProduct{ 
 
    @Override 
    public void method1() { 
        System.out.println("生产出了模具产品B"); 
    } 
}

步骤5：创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法。

//A厂 - 生产模具+容器产品 
class FactoryA extends Factory{ 
 
    @Override 
    public AbstractProduct ManufactureContainer() { 
        return new ContainerProductA(); 
    } 
 
    @Override 
    public AbstractProduct ManufactureMould() { 
        return new MouldProductA(); 
    } 
} 
 
//B厂 - 生产模具+容器产品 
class FactoryB extends Factory{ 
 
    @Override 
    public AbstractProduct ManufactureContainer() { 
        return new ContainerProductB(); 
    } 
 
    @Override 
    public AbstractProduct ManufactureMould() { 
        return new MouldProductB(); 
    } 
}

步骤6：客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例。

public class AbstractFactoryPattern { 
 
    public static void main(String[] args){ 
        FactoryA mFactoryA = new FactoryA(); 
        FactoryB mFactoryB = new FactoryB(); 
        //A厂当地客户需要容器产品A 
        mFactoryA.ManufactureContainer().method1(); 
        //A厂当地客户需要模具产品A 
        mFactoryA.ManufactureMould().method1(); 
 
        //B厂当地客户需要容器产品B 
        mFactoryB.ManufactureContainer().method1(); 
        //B厂当地客户需要模具产品B 
        mFactoryB.ManufactureMould().method1(); 
 
    } 
}

输出结果

生产出了容器产品A 
生产出了模具产品A 
生产出了容器产品B 
生产出了模具产品B

优点

可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

缺点
当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这样也就违背了“开发——封闭”原则。

对于新的产品族符合开-闭原则；对于新的产品种类不符合开-闭原则，这一特性称为开-闭原则的倾斜性。

应用场景
程序需要处理不同系列的相关产品，但是您不希望它依赖于这些产品的具体类时，可以使用抽象工厂。

源码中的应用

#JDK 
java.sql.Connection 
java.sql.Driver 
 
# mybatis 
SqlSessionFactory

java.sql.Connection

public interface Connection  extends Wrapper, AutoCloseable { 
 //...      
     //返回普通的sql执行器 
        Statement createStatement() throws SQLException; 
  //返回具有参数化预编译功能的sql执行器 
     PreparedStatement prepareStatement(String sql) throws SQLException; 
     //返回可以执行存储过程的sql执行器 
        CallableStatement prepareCall(String sql) throws SQLException;    
    //...          
}

从上面的注释就可以看出，这就是典型的抽象工厂接口，描述了不同的产品等级Statement、PreparedStatement、CallableStatement，它们都位于抽象接口Statement产品等级结构中。我们可以继续寻找该抽象工厂接口的实现类。

以Mysql为例，可以找到Mysql对这个工厂接口的实现类ConnectionImpl，ConnectionImpl并不是直接实现了java.sql.Connection,而是通过实现自己扩展的MySQLConnection接口，该接口也是间接继承了java.sql.Connection

public class ConnectionImpl extends ConnectionPropertiesImpl implements MySQLConnection { 
 //... 
 
 public java.sql.Statement createStatement() throws SQLException { 
        return createStatement(DEFAULT_RESULT_SET_TYPE, DEFAULT_RESULT_SET_CONCURRENCY); 
    } 
    
 public java.sql.PreparedStatement prepareStatement(String sql) throws SQLException { 
        return prepareStatement(sql, DEFAULT_RESULT_SET_TYPE, DEFAULT_RESULT_SET_CONCURRENCY); 
    } 
     
 public java.sql.CallableStatement prepareCall(String sql) throws SQLException { 
 
        return prepareCall(sql, DEFAULT_RESULT_SET_TYPE, DEFAULT_RESULT_SET_CONCURRENCY); 
    } 
  
 //... 
}

以createStatement为例，跟踪其调用代码可以看到StatementImpl这个类就是实现了java.sql.Statement的具体产品类

public java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException { 
    checkClosed(); 
 
    StatementImpl stmt = new StatementImpl(getMultiHostSafeProxy(), this.database); 
    stmt.setResultSetType(resultSetType); 
    stmt.setResultSetConcurrency(resultSetConcurrency); 
 
    return stmt; 
}

SqlSessionFactory

/** 
 * Creates an {@link SqlSession} out of a connection or a DataSource 
 *  
 * @author Clinton Begin 
 */ 
public interface SqlSessionFactory { 
 
  SqlSession openSession(); 
 
  SqlSession openSession(boolean autoCommit); 
  SqlSession openSession(Connection connection); 
  SqlSession openSession(TransactionIsolationLevel level); 
 
  SqlSession openSession(ExecutorType execType); 
  SqlSession openSession(ExecutorType execType, boolean autoCommit); 
  SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level); 
  SqlSession openSession(ExecutorType execType, Connection connection); 
 
  Configuration getConfiguration(); 
 
}

SqlSessionFactory也是抽象工厂接口，Configuration和SqlSession都是在不同的产品等级上。通过IDEA工具可以通过UML图清晰得看到SqlSessionFactory的工厂实现类

以上两个例子都和数据库操作相关，同样使用了抽象工厂模式。在jdbc中，客户端通过Connection工厂获取到Statement产品对象，然后通过该对象进行增删改查操作，对于mybatis这种数据库操纵框架而言（底层也是封装了jdbc api)有异曲同工,通过SeqSessionFactory工厂获取到SqlSession产品对象，然后进行增删改查操作。

PS：以上代码提交在 Github ：

https://github.com/Niuh-Study/niuh-designpatterns.git