动机

1. 在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。
2. 如何应对这种变化？如何绕过常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

模式定义

提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。

类图

总结

1. 如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的工厂完全可以。
2. “系列对象”指的是在某以特定系列下的对象之间有相互依赖、或作用的关系。不同系列的对象之间不能相互依赖。
3. Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。

实例

场景：与数据库相关的connection，command，reader三个相关数据库产品，它们三个相互依赖构成一个具体的数据库。

1. 分别定义connection，command，reader的接口

public interface IDBConnection {
    void connectDB();
}
public interface IDBCommand {
    void exeDBCommand();
}
public interface IDBReader {
    void readDBData();
}

2. 分别实现具体的产品

public class MySqlDbConnection implements IDBConnection {
    @Override
    public void connectDB() {
        System.out.println("my sql db connection");
    }
}
public class MySqlDBCommand implements IDBCommand {
    @Override
    public void exeDBCommand() {
        System.out.println("MySql db command");
    }
}
public class MySqlDBReader implements IDBReader {
    @Override
    public void readDBData() {
        System.out.println("Mysql db reader");
    }
}

public class OraclelDbConnection implements IDBConnection {
    @Override
    public void connectDB() {
        System.out.println("Oracle db connection");
    }
}
public class OracleDBCommand implements IDBCommand {
    @Override
    public void exeDBCommand() {
        System.out.println("Oracle db command");
    }
}
public class OracleDBReader implements IDBReader {
    @Override
    public void readDBData() {
        System.out.println("Oracle db reader");
    }
}

3. 使用抽象工厂模式，把三个产品管理在一个接口中

public interface IDBFactory {
    IDBConnection createDbConnection();

    IDBCommand createDbCommand();

    IDBReader createDbReader();
}

4. 分别实现具体的数据库

public class MySqlDbFactory implements IDBFactory {
    @Override
    public IDBConnection createDbConnection() {
        System.out.println("MySql create db connection");
        return new MySqlDbConnection();
    }

    @Override
    public IDBCommand createDbCommand() {
        System.out.println("MySql create db command");
        return new MySqlDBCommand();
    }

    @Override
    public IDBReader createDbReader() {
        System.out.println("MySql create db reader");
        return new MySqlDBReader();
    }
}

public class OracleDbFactory implements IDBFactory {
    @Override
    public IDBConnection createDbConnection() {
        System.out.println("Oracle create db connection");
        return new OraclelDbConnection();
    }

    @Override
    public IDBCommand createDbCommand() {
        System.out.println("Oracle create db command");
        return new OracleDBCommand();
    }

    @Override
    public IDBReader createDbReader() {
        System.out.println("Oracle create db reader");
        return new OracleDBReader();
    }
}

5. 创建客户端框架，框架是稳定的，不会因为需求的改变而改变，满足开闭原则，复用原则，把变化都封装在了客户端定制化和可扩展的具体商品中

public class DBEmployee {

    private IDBFactory dbFactory;

    public DBEmployee(IDBFactory dbFactory) {
        this.dbFactory = dbFactory;
    }


    public void dbWork() {
        // DBConnection
        IDBConnection dbConnection = dbFactory.createDbConnection();
        dbConnection.connectDB();

        // DBCommand
        IDBCommand dbCommand = dbFactory.createDbCommand();
        dbCommand.exeDBCommand();

        // DBReader
        IDBReader dbReader = dbFactory.createDbReader();
        dbReader.readDBData();
    }

    public static void main(String[] args) {
        DBEmployee dbEmployee = new DBEmployee(new OracleDbFactory());
        dbEmployee.dbWork();
    }
}