前言

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

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

模式定义

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

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

解决的问题

每个工厂只能创建一类产品

即工厂方法模式的缺点

模式组成

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

使用步骤

1. 创建抽象工厂类，定义具体工厂的公共接口；
2. 创建抽象产品族类 ，定义抽象产品的公共接口；
3. 创建抽象产品类 （继承抽象产品族类），定义具体产品的公共接口；
4. 创建具体产品类（继承抽象产品类） & 定义生产的具体产品；
5. 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
6. 客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例

实例说明

实例概况

• 背景：隔壁老王有两间塑料加工厂（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

文章持续更新，可以微信搜一搜「 一角钱技术 」第一时间阅读， 本文 GitHub org_hejianhui/JavaStudy 已经收录，欢迎 Star。